#ifndef RESOURCEDEFINITIONS_H#define RESOURCEDEFINITIONS_H #include <iosfwd>#include <memory>#include <map> #include "Expression.h"#include "ResType.h" #include "location.hh" class TypeSpec{    ResType type;    int id;public:    static const int noID = 65536;     TypeSpec() : id(noID) {}    TypeSpec(ResType type) : type(type), id(noID) {}    TypeSpec(ResType type, int id) : type(type), id(id) {}     ResType getType() const { return type; }    int getID() const { return id; }     bool hasID() const { return id != noID; }     bool operator<(TypeSpec y) const    {        if(type < y.type)            return true;        else if(y.type < type)            return false;        else            return id < y.id;    }}; std::ostream& operator<<(std::ostream& out, TypeSpec ts);  class ResourceCompiler; class Field{public:    yy::location location;     virtual ~Field() = default;     virtual bool needsValue() { return true; }     virtual void compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass) = 0;     virtual ExprPtr lookupNamedValue(std::string) { return nullptr; }};typedef std::shared_ptr<Field> FieldPtr; class SimpleField : public Field{public:    enum class Type    {        boolean, byte, integer, longint, rect, point, char_,        pstring, wstring, string, bitstring    };     enum class Attrs    {        none = 0, hex = 1, key = 2, unsigned_ = 4, literal = 8, binary = 16    };     Type type;    Attrs attrs = Attrs::none;    ExprPtr arrayCount;     ExprPtr    value;    std::map<std::string, ExprPtr> namedValues;    ExprPtr lastNamedValue;     void addNamedValue(std::string n);    void addNamedValue(std::string n, ExprPtr val);    ExprPtr lookupNamedValue(std::string);     virtual bool needsValue();    virtual void compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass); private:    void compileString(ExprPtr expr, ResourceCompiler *compiler, bool prePass);    void compileInt(ExprPtr expr, ResourceCompiler *compiler, bool prePass);    void compileCompound(ExprPtr expr, ResourceCompiler *compiler, bool prePass);};typedef std::shared_ptr<SimpleField> SimpleFieldPtr; class FillAlignField : public Field{public:    enum class Type    {        bit, nibble, byte, word, long_    };     FillAlignField(Type type, bool isAlign, ExprPtr count = ExprPtr());    virtual bool needsValue();    virtual void compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass);private:    Type type;    ExprPtr count;    bool isAlign;}; inline SimpleField::Attrs operator|(SimpleField::Attrs a, SimpleField::Attrs b){    return SimpleField::Attrs( int(a) | int(b) );}  class LabelField : public Field{    std::string name;public:    LabelField(std::string name);     virtual bool needsValue();    virtual void compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass);};typedef std::shared_ptr<LabelField> LabelFieldPtr;  class FieldList : public Field{protected:    std::vector<FieldPtr> fields;public:    virtual ~FieldList();    void addField(FieldPtr field, yy::location loc);    void addLabel(std::string name, yy::location loc);     virtual void compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass);};typedef std::shared_ptr<FieldList> FieldListPtr;  class ArrayField : public FieldList{    std::string name;    ExprPtr arrayCount;public:    ArrayField(std::string name /* or empty */, ExprPtr count /* may be null*/);     virtual void compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass);};typedef std::shared_ptr<ArrayField> ArrayFieldPtr; class SwitchField : public Field{    std::map<std::string, FieldListPtr> cases;public:    void addCase(const std::string name, FieldListPtr alternative);     virtual void compile(ExprPtr expr, ResourceCompiler *compiler, bool prePass);};typedef std::shared_ptr<SwitchField> SwitchFieldPtr; class TypeDefinition : public FieldList{};typedef std::shared_ptr<TypeDefinition> TypeDefinitionPtr; #endif // RESOURCEDEFINITIONS_H