Value.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
 
#pragma once
 
#include <deque>
#include <exception>
#include <ostream>
#include <string>
#include <boost/intrusive_ptr.hpp>
#include "installer/common/scummsys.h"
#include "RefCounted.h"
#include "Stack.h"
#include "DecompilerException.h"
 
class Value;
 
const int PRECEDENCE_NO = 0;
 
const int PRECEDENCE_UNARY = 1;
 
const int PRECEDENCE_MULT = 2;
 
const int PRECEDENCE_ADD = 3;
 
const int PRECEDENCE_SHIFT = 4;
 
const int PRECEDENCE_RELATION = 5;
 
const int PRECEDENCE_EQUALITY = 6;
 
const int PRECEDENCE_BIT_AND = 7;
 
const int PRECEDENCE_BIT_XOR = 8;
 
const int PRECEDENCE_BIT_OR = 9;
 
const int PRECEDENCE_LOGIC_AND = 10;
 
const int PRECEDENCE_LOGIC_OR = 11;
 
typedef boost::intrusive_ptr<Value> ValuePtr;
 
typedef std::deque<ValuePtr> ValueList;
 
typedef Stack<ValuePtr> ValueStack;
 
class Value : public RefCounted{
 
    public:
 
        virtual ~Value();
 
        virtual bool IsInteger();
 
        virtual bool IsAddress();
 
        virtual bool IsSignedValue();
 
        virtual int32 GetSigned();
 
        virtual uint32 GetUnsigned();
 
        virtual std::ostream& Print(std::ostream &output) const = 0;
 
        virtual std::string GetString() const;
 
        virtual ValuePtr Dup(std::ostream &output);
 
        virtual ValuePtr Negate();
 
        virtual int GetPrecedence() const;
 
        friend std::ostream &operator<<(std::ostream &output, Value *value) {
            return value->Print(output);
        }
 
};
 
class IntValue : public Value {
 
    public:
 
        IntValue(const IntValue& value) = delete;
 
        IntValue& operator = (const IntValue& value) = delete;
 
        IntValue(int32 val, bool is_signed);
 
        IntValue(uint32 val, bool is_signed);
 
        bool IsInteger() override;
 
        bool IsSignedValue() override;
 
        int32 GetSigned() override;
 
        uint32 GetUnsigned() override;
 
        ValuePtr Dup(std::ostream &output) override;
 
        virtual std::ostream& Print(std::ostream &output) const override;
 
    protected:
 
        const int32 val_;
 
        const bool signed_;
};
 
class AddressValue: public IntValue{
 
    public:
 
        AddressValue(const AddressValue& value) = delete;
 
        AddressValue& operator = (const AddressValue& value) = delete;
 
        explicit AddressValue(uint32 addr);
 
        bool IsAddress() override;
 
        int32 GetSigned() override;
 
        ValuePtr Dup(std::ostream &output) override;
 
        virtual std::ostream& Print(std::ostream &output) const override;
};
 
class RelAddressValue : public IntValue{
 
    public:
 
        RelAddressValue(const RelAddressValue& value) = delete;
 
        RelAddressValue& operator = (const RelAddressValue& value) = delete;
 
        RelAddressValue(uint32 base_addr, int32 offset);
 
        bool IsAddress() override;
 
        uint32 GetUnsigned() override;
 
        ValuePtr Dup(std::ostream &output) override;
 
        virtual std::ostream& Print(std::ostream &output) const override;
 
    protected:
 
        const uint32 base_addr_;
};
 
class DupValue : public Value {
 
    public:
 
        DupValue(const DupValue& value) = delete;
 
        DupValue& operator = (const DupValue& value) = delete;
 
        explicit DupValue(int idx);
 
        ValuePtr Dup(std::ostream &output) override;
 
        virtual std::ostream& Print(std::ostream &output) const override;
 
    protected:
 
        const int index_;
};
 
class StringValue : public Value {
 
    public:
 
        StringValue(const StringValue& value) = delete;
 
        StringValue& operator = (const StringValue& value) = delete;
 
        explicit StringValue(std::string str);
 
        virtual std::ostream& Print(std::ostream &output) const override;
 
    protected:
 
        const std::string str_;
};
 
class UnquotedStringValue : public StringValue{
 
    public:
 
        explicit UnquotedStringValue(std::string str);
 
        virtual std::ostream& Print(std::ostream &output) const override;
};
 
class VarValue : public Value {
 
    public:
        explicit VarValue(std::string name);
        virtual std::ostream& Print(std::ostream &output) const override;
 
    protected:
 
        std::string name_;
};
 
class ArrayValue : public VarValue {
 
    public:
 
        ArrayValue(const ArrayValue& value) = delete;
 
        ArrayValue& operator = (const ArrayValue& value) = delete;
 
        ArrayValue(const std::string& name, const ValueList& indexes);
 
        virtual std::ostream& Print(std::ostream &output) const override;
 
    protected:
 
        const ValueList indexes_;
};
 
class BinaryOpValue : public Value {
 
 
    public:
 
        BinaryOpValue(const BinaryOpValue& value) = delete;
 
        BinaryOpValue& operator = (const BinaryOpValue& value) = delete;
 
        BinaryOpValue(ValuePtr left, ValuePtr right, std::string oper);
 
        virtual std::ostream& Print(std::ostream &output) const override;
 
        virtual ValuePtr Negate() override;
 
        virtual int GetPrecedence() const override;
 
    protected:
 
        const ValuePtr left_val_;
 
        const ValuePtr right_val_;
 
        const std::string oper_;
};
 
class UnaryOpValue : public Value{
 
    public:
 
        UnaryOpValue(const UnaryOpValue& value) = delete;
 
        UnaryOpValue& operator = (const UnaryOpValue& value) = delete;
 
        UnaryOpValue(ValuePtr operand, std::string oper, bool postfix);
 
        virtual std::ostream& Print(std::ostream &output) const override;
 
        virtual int GetPrecedence() const override;
 
    protected:
 
        const ValuePtr operand_;
 
        const std::string oper_;
 
        const bool postfix_;
};
 
class NegatedValue : public UnaryOpValue{
 
    public:
 
        NegatedValue(const NegatedValue& value) = delete;
 
        NegatedValue& operator = (const NegatedValue& value) = delete;
 
        explicit NegatedValue(ValuePtr val);
 
        virtual ValuePtr Negate() override;
};
 
class CallValue : public Value {
 
    public:
 
        CallValue(const CallValue& value) = delete;
 
        CallValue& operator = (const CallValue& value) = delete;
 
        CallValue(std::string function, ValueList args);
 
        virtual std::ostream& Print(std::ostream &output) const override;
 
    protected:
 
        const std::string function_;
 
        const ValueList args_;
 
};