Subversion Repositories c16

// Node.hh

#ifndef __NODE_HH_DEFINED__

#define __NODE_HH_DEFINED__

#include 

#include "List.hh"

//-----------------------------------------------------------------------------

class TypeSpecifier;

class DeclItem;

class Initializer;

class TypeName;

class Expression;

const char * GetDeclaredName(Declarator * decl);

ParameterDeclarationList * GetParameters(Declarator * decl);

bool         IsFunPtr(Declarator * decl);

bool         IsPointer(Declarator * decl);

Expression * ArrayLength(Declarator * decl);

void         SetArrayLength(Declarator * decl, int len);

bool         IsFunction(Declarator * decl);

bool         IsArray(Declarator * decl);

enum SUW { SB, UB, WO };

//-----------------------------------------------------------------------------

class Constant : public Node

{

public:

   Constant(const char * name)

   : Node(name)

   {};

   virtual void EmitValue_RR(FILE * out) = 0;

   virtual void EmitValue_LL(FILE * out) = 0;

};

//-----------------------------------------------------------------------------

class NumericConstant : public Constant

{

public:

   NumericConstant(const char * txt);

   NumericConstant(int val, int siz = 0)

   : Constant("NumericConstant"),

     value(val),

     size(siz)

     {};

   virtual void EmitValue_RR(FILE * out);

   virtual void EmitValue_LL(FILE * out);

   int GetValue() const   { return value; };

   int GetSize()  const   { return size;  };

   void Negate()       { value = -value; };

   void Complement()   { value = ~value; };

   void LogNot()       { if (value)   value = 0;   else value = -1; };

private:

   int value;

   int size;

};

//-----------------------------------------------------------------------------

class StringConstant : public Constant

{

public:

   StringConstant();

   ~StringConstant();

   virtual void EmitValue_RR(FILE * out);

   virtual void EmitValue_LL(FILE * out);

   void operator += (char txt);

   StringConstant * operator & (StringConstant * other);

   void operator += (const char * txt)

      { while (*txt)   *this += *txt++; };

   int GetStringNumber() const   { return string_number; };

   int GetLength()       const   { return value_len;     };

   char * Kill()

      { char * ret = buffer;   buffer = 0;   delete this;   return ret; };

   void  EmitAndRemove(FILE * out, int length);

   static void  EmitAll(FILE * out);

private:

   char       * buffer;

   int          buffer_len;

   int          value_len;

   int          string_number;

   static int str_count;

   enum { MAX_STRINGS = 5000 };

   static StringConstant * all_strings[MAX_STRINGS];

};

//-----------------------------------------------------------------------------

// how an expression is created...

// //

enum BinExprType

{

   // binary

   ET_LIST,             // expr  ,  expr

   ET_ARGLIST,          // expr  ,  expr in function argument

   ET_ASSIGN,           // expr  =  expr

   ET_MULT_ASSIGN,      // expr *=  expr

   ET_DIV_ASSIGN,       // expr /=  expr

   ET_MOD_ASSIGN,       // expr %=  expr

   ET_ADD_ASSIGN,       // expr +=  expr

   ET_SUB_ASSIGN,       // expr -=  expr

   ET_LEFT_ASSIGN,      // expr <<= expr

   ET_RIGHT_ASSIGN,     // expr >>= expr

   ET_AND_ASSIGN,       // expr &=  expr

   ET_XOR_ASSIGN,       // expr ^=  expr

   ET_OR_ASSIGN,        // expr |=  expr

   ET_BIT_OR,           // expr |   expr

   ET_BIT_AND,          // expr &   expr

   ET_BIT_XOR,          // expr ^   expr

   ET_LOG_OR,           // expr ||  expr

   ET_LOG_AND,          // expr &&  expr

   ET_EQUAL,            // expr ==  expr

   ET_NOT_EQUAL,        // expr !=  expr

   ET_LESS_EQUAL,       // expr <=  expr

   ET_LESS,             // expr <   expr

   ET_GREATER_EQUAL,    // expr >=  expr

   ET_GREATER,          // expr >   expr

   ET_LEFT,             // expr <<  expr

   ET_RIGHT,            // expr >>  expr

   ET_ADD,              // expr +   expr

   ET_SUB,              // expr -   expr

   ET_MULT,             // expr *   expr

   ET_DIV,              // expr /   expr

   ET_MOD,              // expr %   expr

   ET_ELEMENT,          // expr [   expr ]

   ET_FUNCALL           // expr (   ... )

};

enum UnaExprType

{

   ET_CAST,             // (type)   expr

   ET_ADDRESS,          //      &   expr

   ET_CONTENT,          //      *   expr

   ET_CONJUGATE,        //      +   expr

   ET_NEGATE,           //      -   expr

   ET_COMPLEMENT,       //      ~   expr

   ET_LOG_NOT,          //      !   expr

   ET_POSTINC,          //      ++  expr

   ET_POSTDEC,          //      --  expr

   ET_PREINC,           //      ++  expr

   ET_PREDEC            //      --  expr

};

class Expression : public Node

{

public:

   Expression(const char * nodename)

   : Node(nodename),

     type_name(0)

   {};

   virtual void Emit(FILE * out) = 0;

   virtual void Emit_to_ll(FILE * out)   { assert(0); };

           void EmitCall(FILE * out, Expression * right);

   virtual void EmitInitialization(FILE * out, int size);

   virtual void EmitAddress(FILE * out);

   virtual void AddAddress(FILE * out);

   virtual int  EmitPush(FILE * out, ParameterDeclarationList * params);

   virtual void EmitAssign(FILE * out)   { assert(0); };

   virtual int  GetParaLength() const    { return 1; };

   virtual bool IsConstant() const          { return false; };

   virtual bool IsNumericConstant() const   { return false; };

   virtual bool IsStringConstant() const    { return false; };

   virtual bool IsVariable() const          { return false; };

   virtual const char * GetVarname() const  { return 0;     };

   virtual int  GetConstantNumericValue() const;

   virtual StringConstant * GetStringConstant() const;

   virtual      TypeName * FunReturnType();

   virtual      TypeName * SetType() = 0;

   virtual SUW  GetSUW();

   void SetType(TypeName * t);

   bool       IsPointer();

   bool       IsArray();

   int        PointeeSize();

   int        GetSize();

   TypeName * GetType();

   bool       IsUnsigned();

   int        FunReturnSize();

   static const char * GetPrettyName(const char * pretty);

   virtual Expression * OptNegate()        { assert(0); };

   virtual Expression * OptComplement()    { assert(0); };

   virtual Expression * OptLogNot()        { assert(0); };

private:

   TypeName *  type_name;

};

//-----------------------------------------------------------------------------

class IdentifierExpression : public Expression

{

public:

   static Expression * New(const char * s);

   virtual void  Emit(FILE * out);

   virtual void  EmitAssign(FILE * out);

   virtual void  Emit_to_ll(FILE * out);

   virtual       TypeName * SetType();

   virtual bool             IsVariable() const   { return true;    };

   virtual const char *     GetVarname() const   { return varname; };

   virtual void             EmitAddress(FILE * out);

   virtual void             EmitInitialization(FILE * out, int size);

   virtual void             AddAddress(FILE * out);

   virtual TypeName *       FunReturnType();

private:

   IdentifierExpression(const char * s)

   : Expression("Expression (variable name)"),

     varname(s)

   {};

   const char * varname;

};

//-----------------------------------------------------------------------------

class MemberExpression : public Expression

{

public:

   MemberExpression(bool is_pointer, Expression * r, const char * s);

   virtual void  Emit(FILE * out);

   virtual void EmitAddress(FILE * out);

   void EmitAddress(FILE * out, bool content);

   virtual       TypeName * SetType();

private:

   Expression * left;

   const char * membername;

};

//-----------------------------------------------------------------------------

class StringExpression : public Expression

{

public:

   StringExpression(StringConstant * s);

   virtual void  Emit(FILE * out);

   virtual void EmitAddress(FILE * out);

   virtual void  Emit_to_ll(FILE * out);

   virtual       TypeName * SetType();

   virtual void  EmitInitialization(FILE * out, int size);

   virtual bool  IsConstant()       const   { return true; };

   virtual bool  IsStringConstant() const   { return true; };

   virtual StringConstant * GetStringConstant() const

      { return string_constant; }

private:

   StringConstant * string_constant;

};

//-----------------------------------------------------------------------------

class NumericExpression : public Expression

{

public:

   NumericExpression(NumericConstant * n);

   NumericExpression(TypeName * t);

   NumericExpression(Expression * r);

   NumericExpression(int value);

   virtual void Emit(FILE * out);

   virtual void Emit_to_ll(FILE * out);

   virtual bool IsConstant()        const   { return true; };

   virtual bool IsNumericConstant() const   { return true; };

   virtual int  GetConstantNumericValue() const;

   virtual       TypeName * SetType();

   virtual void EmitInitialization(FILE * out, int size);

   static const char * GetPretty(int value);

   virtual Expression * OptNegate();

   virtual Expression * OptComplement();

   virtual Expression * OptLogNot();

private:

   NumericConstant * int_value;

};

//-----------------------------------------------------------------------------

class CondExpression : public Expression

{

public:

   CondExpression(Expression * l, Expression * m, Expression * r)

   : Expression("Expression (l ? m : r)"),

     left(l),

     middle(m),

     right(r)

   {};

   virtual void Emit(FILE * out);

   virtual       TypeName * SetType();

private:

   Expression      * left;

   Expression      * middle;

   Expression      * right;

};

//-----------------------------------------------------------------------------

class BinaryExpression : public Expression

{

public:

   static Expression * New(BinExprType et, Expression * l, Expression * r);

   virtual void Emit(FILE * out);

   virtual       TypeName * SetType();

   virtual void EmitAddress(FILE * out);

   TypeName * MaxType(Expression * l, Expression * r);

   static const char * GetPretty(BinExprType expr_type);

   static BinExprType  MapAssign(BinExprType et);

protected:

   BinaryExpression(BinExprType et, Expression * l, Expression * r);

   BinExprType       expr_type;

   Expression      * left;

   Expression      * right;

};

//-----------------------------------------------------------------------------

class ArgListExpression : public BinaryExpression

{

public:

   ArgListExpression(Expression * l, Expression * r)

   : BinaryExpression(ET_ARGLIST, l, r)

   {};

   virtual void Emit(FILE * out)  {};   // done vy EmitPush()

   virtual int  EmitPush(FILE * out, ParameterDeclarationList * params);

   virtual int  GetParaLength() const;

   virtual       TypeName * SetType();

};

//-----------------------------------------------------------------------------

class AdditionExpression : public BinaryExpression

{

public:

   static Expression * New(Expression * l, Expression * r);

   virtual void Emit(FILE * out);

   virtual       TypeName * SetType();

private:

   AdditionExpression(Expression * l, Expression * r)

   : BinaryExpression(ET_ADD, l, r)

   {};

};

//-----------------------------------------------------------------------------

class SubtractionExpression : public BinaryExpression

{

public:

   static Expression * New(Expression * l, Expression * r);

   virtual void Emit(FILE * out);

   virtual       TypeName * SetType();

private:

   SubtractionExpression(Expression * l, Expression * r)

   : BinaryExpression(ET_SUB, l, r)

   {};

};

//-----------------------------------------------------------------------------

class UnaryExpression : public Expression

{

public:

   UnaryExpression(TypeName * t, Expression * r);

   virtual void Emit(FILE * out);

   virtual void EmitAddress(FILE * out);

   virtual void EmitInitialization(FILE * out, int size);

   virtual       TypeName * SetType();

   static const char * GetPretty(UnaExprType expr_type);

   static Expression * New(UnaExprType et, Expression * r);

private:

   UnaryExpression(UnaExprType et, Expression * r)

   : Expression(GetPrettyName(GetPretty(et))),

     expr_type(et),

     right(r)

   {};

   UnaExprType   expr_type;

   Expression  * right;

};

//-----------------------------------------------------------------------------

class AsmExpression : public Expression

{

public:

   AsmExpression(StringConstant * string);

   virtual void Emit(FILE * out);

   virtual       TypeName * SetType();

private:

     char * asm_string;

};

//-----------------------------------------------------------------------------

enum Specifier

{

   // storage class

   SC_TYPEDEF   = 0x00000001,

   SC_EXTERN    = 0x00000002,

   SC_STATIC    = 0x00000004,

   SC_AUTO      = 0x00000008,

   SC_REGISTER  = 0x00000010,

   SC_MASK      = SC_TYPEDEF | SC_EXTERN | SC_STATIC  | SC_AUTO  | SC_REGISTER,

   // type qualifiers

   TQ_CONST     = 0x00000100,

   TQ_VOLATILE  = 0x00000200,

   TQ_MASK      = TQ_CONST | TQ_VOLATILE,

   // type specifiers

   TS_SIGNED    = 0x00001000,

   TS_UNSIGNED  = 0x00002000,

   TS_SIGN_MASK = TS_SIGNED | TS_UNSIGNED,

   TS_VOID      = 0x00010000,

   TS_CHAR      = 0x00020000,

   TS_SHORT     = 0x00040000,

   TS_INT       = 0x00080000,

   TS_LONG      = 0x00100000,

   TS_FLOAT     = 0x00200000,

   TS_DOUBLE    = 0x00400000,

   TS_STRUCT    = 0x00800000,

   TS_UNION     = 0x01000000,

   TS_ENUM      = 0x02000000,

   TS_TYPE_NAME = 0x04000000,

   TS_MASK      = TS_VOID  | TS_CHAR   | TS_SHORT  | TS_INT | TS_LONG |

                  TS_FLOAT | TS_DOUBLE | TS_STRUCT |

                  TS_UNION | TS_ENUM   | TS_TYPE_NAME,

   TS_NUMERIC   = TS_CHAR  | TS_SHORT  | TS_INT    | TS_LONG |

                  TS_FLOAT | TS_DOUBLE | TS_ENUM,

};

//-----------------------------------------------------------------------------

class Ptr : public Node

{

public:

   Ptr(TypeSpecifier * ds)

   : Node("Ptr"),

     decl_specs(ds)

     {};

   virtual void Emit(FILE * out);

   int Print(FILE * out) const;

private:

   TypeSpecifier * decl_specs;

};

//-----------------------------------------------------------------------------

class Identifier : public Node

{

public:

   Identifier(const char * n)

   : Node("Identifier"),

     name(n)

     {};

private:

   const char * name;

};

//-----------------------------------------------------------------------------

class Initializer : public Node

{

public:

   Initializer(Expression * expr)

   : Node("Initializer (skalar)"),

     skalar_value(expr),

     array_value(0)

     {};

   Initializer(InitializerList * list)

   : Node("Initializer (vector)"),

     skalar_value(0),

     array_value(list)

     {};

   virtual void Emit(FILE * out);

   virtual void EmitValue(FILE * out, TypeName * tn);

   int  InitAutovar(FILE * out, TypeName * type);

   int  ElementCount() const;

private:

   Expression      * skalar_value;

   InitializerList * array_value;

};

//-----------------------------------------------------------------------------

class ParameterDeclaration : public Node

{

public:

   ParameterDeclaration(TypeSpecifier * ds, Declarator * dec);

   virtual void Emit(FILE * out);

   int AllocateParameters(int position);

   const char * GetDeclaredName(int skip);

   TypeName * GetTypeName() const   { return type; };

   bool       IsEllipsis() const    { return isEllipsis; };

   ParameterDeclaration * SetEllipsis() { isEllipsis = true; return this; };

private:

   TypeName * type;

   bool       isEllipsis;

};

//-----------------------------------------------------------------------------

enum DECL_WHAT

{

   DECL_NAME    = 1,

   DECL_FUNPTR  = 2,

   DECL_ARRAY   = 3,

   DECL_FUN     = 4,

   DECL_POINTER = 5

};

class DeclItem : public Node

{

public:

   DeclItem(DECL_WHAT w)

   : Node("DeclItem"),

     what(w),

     name(0),

     funptr(0),

     array_size(0),

     fun_params(0),

     fun_identifiers(0),

     pointer(0)

     {};

   DeclItem(const char * n)

   : Node("DeclItem"),

     what(DECL_NAME),

     name(n),

     funptr(0),

     array_size(0),

     fun_params(0),

     fun_identifiers(0),

     pointer(0)

     {};

   DeclItem(Declarator * fp)

   : Node("DeclItem"),

     what(DECL_FUNPTR),

     name(0),

     funptr(fp),

     array_size(0),

     fun_params(0),

     fun_identifiers(0),

     pointer(0)

     {};

   DeclItem(Expression * ep)

   : Node("DeclItem"),

     what(DECL_ARRAY),

     name(0),

     funptr(0),

     array_size(ep),

     fun_params(0),

     fun_identifiers(0),

     pointer(0)

     {};

   DeclItem(ParameterDeclarationList * pl)

   : Node("DeclItem"),

     what(DECL_FUN),

     name(0),

     funptr(0),

     array_size(0),

     fun_params(pl),

     fun_identifiers(0),

     pointer(0)

     {};

   DeclItem(IdentifierList * il)

   : Node("DeclItem"),

     what(DECL_FUN),

     name(0),

     funptr(0),

     array_size(0),

     fun_params(0),

     fun_identifiers(il),

     pointer(0)

     {};

   DeclItem(Pointer * p)

   : Node("DeclItem"),

     what(DECL_POINTER),

     name(0),

     funptr(0),

     array_size(0),

     fun_params(0),

     fun_identifiers(0),

     pointer(p)

     {};

   virtual void Emit(FILE * out);

   int Print(FILE * out) const;

   const char * GetName()      const   { return name;       };

   DECL_WHAT    GetWhat()      const   { return what;       };

   Declarator * GetFunptr()    const   { return funptr;     };

   Pointer    * GetPointer()   const   { return pointer;    };

   Expression * GetArraySize() const   { return array_size; };

   void         SetArraySize(int n);

   ParameterDeclarationList * GetParameters() const   { return fun_params; };

private:

   const DECL_WHAT            what;

   const char               * name;

   Declarator               * funptr;

   Expression               * array_size;

   ParameterDeclarationList * fun_params;

   IdentifierList           * fun_identifiers;

   Pointer                  * pointer;

};

//-----------------------------------------------------------------------------

class Enumerator : public Node

{

public:

   Enumerator(const char * n, Expression * v)

   : Node("Enumerator"),

     name(n),

     value(v)

   {};

   virtual void Emit(FILE * out);

   static int current;

private:

   const char * name;

   Expression * value;

};

//-----------------------------------------------------------------------------

class StructDeclarator : public Node

{

public:

   StructDeclarator(Declarator * dcl, Expression * exp)

   : Node("StructDeclarator"),

     declarator(dcl),

     expression(exp),

     position(-1)

     {};

   virtual void Emit(FILE * out);

   int EmitMember(FILE * out, const char * struct_name,

        TypeSpecifier * tspec, int pos, bool is_union);

   TypeName * GetMemberType(TypeSpecifier * tspec, const char * member);

   int GetMemberPosition(const char * member) const;

   Declarator * GetDeclarator() const   { return declarator; };

   TypeName * FirstUnionMember(TypeSpecifier * tspec, int union_size) const;

   const char * GetMemberName() const;

private:

   Declarator * declarator;

   Expression * expression;   // : bitfield

   int          position;

};

//-----------------------------------------------------------------------------

class StructDeclaration : public Node

{

public:

   StructDeclaration(TypeSpecifier * ds, StructDeclaratorList * sdl)

   : Node("StructDeclaration"),

     decl_specifiers(ds),

     struct_decl_list(sdl),

     size(-1)

     { };

   int Emit(FILE * out, const char * struct_name, int pos, bool is_union);

   TypeName * GetMemberType(const char * struct_name, const char * member);

   TypeName * GetMemberType(int pos);

   int GetMemberPosition(const char * struct_name,

                         const char * member, bool is_union) const;

   int GetSize() const   { assert(size != -1);   return size; };

   TypeSpecifier        * GetSpecifier()   const { return decl_specifiers; };

   StructDeclaratorList * GetDeclarators() const { return struct_decl_list; };

   TypeName * FirstUnionMember(int size) const;

   int GetDeclaratorCount() const

      { return StructDeclaratorList::Length(struct_decl_list); };

private:

   TypeSpecifier        * decl_specifiers;

   StructDeclaratorList * struct_decl_list;

   int size;

};

TypeName * GetMemberType(StructDeclarationList * sdl, int pos);

//-----------------------------------------------------------------------------

class TypeSpecifier : public Node

{

public:

   // all types

   TypeSpecifier(Specifier sp)

   : Node("TypeSpecifier (all)"),

     spec(sp),

     name(0),

     struct_decl_list(0),

     enum_list(0)

     {};

   // structs, unions, typedef(name)

   TypeSpecifier(Specifier sp, const char * n, StructDeclarationList * sdl);

   // enums

   TypeSpecifier(const char * n, EnumeratorList * el)

   : Node("TypeSpecifier (enum)"),

     spec(TS_ENUM),

     name(n),

     struct_decl_list(0),

     enum_list(el)

     {};

   virtual void Emit(FILE * out);

   int Print(FILE * out) const;

   TypeSpecifier * operator +(TypeSpecifier & other);

   TypeSpecifier * self()   { return this; };

   Specifier    GetType()    const   { return spec; };

   const char * GetName()    const   { return name; };

   StructDeclarationList * GetStructDecl() const

                                     { return struct_decl_list; };

   bool         IsUnsigned() const   { return spec & TS_UNSIGNED; };

   int          GetFunReturnSize(Declarator * decl) const;

   int          GetSize(Declarator * decl) const;

   int          GetBaseSize()              const;

   TypeName *   GetMemberType(const char * member);

   bool         IsNumericType() const;  // char, short, or int

   bool         IsUnion() const

      { if (spec & TS_UNION)    return true; return false; };

   bool             IsStruct() const

      { if (spec & TS_STRUCT)   return true; return false; };

private:

   Specifier               spec;                // all types

   const char            * name;                // enums, structs and unions

   StructDeclarationList * struct_decl_list;    // structs and unions

   EnumeratorList        * enum_list;           // enums

   static int anonymous_number;

};

//-----------------------------------------------------------------------------

class InitDeclarator : public Node

{

public:

   InitDeclarator(Declarator * decl, Initializer * init)

   : Node("InitDeclarator"),

     declarator(decl),

     initializer(init)

     {};

   virtual void Emit(FILE * out);

   Declarator * GetDeclarator() const   { return declarator; };

   const char * GetDeclaredName(int skip);

   void Allocate(FILE * out, TypeSpecifier * spec);

   int  EmitAutovars(FILE * out, TypeSpecifier * spec);

private:

   Declarator  * declarator;

   Initializer * initializer;

};

//-----------------------------------------------------------------------------

class Declaration : public Node

{

public:

   Declaration(TypeSpecifier * ds, InitDeclaratorList * il);

   virtual void Emit(FILE * out);

   void Allocate(FILE * out);

   int  EmitAutovars(FILE * out);

private:

   TypeSpecifier      * base_type;

   InitDeclaratorList * init_list;

};

//-----------------------------------------------------------------------------

class TypeName : public Node

{

public:

   TypeName(TypeSpecifier * ds, Declarator * ad);

   TypeName(Specifier sp);

   virtual void Emit(FILE * out);

   int Print(FILE * out) const;

   Declarator     * GetDeclarator()    const   { return abs_declarator; };

   TypeSpecifier  * GetTypeSpecifier() const   { return decl_spec;  };

   const char     * GetDeclaredName();

   TypeName       * GetFunReturnType();

   TypeName *       AddressOf() const;

   TypeName *       ContentOf() const;

   TypeName *       GetElementType() const;

   bool             IsNumericType() const;  // char, short, or int

   bool             IsPointer() const;

   Expression *     ArrayLength() const;

   void             SetArrayLength(int len);

   bool             IsStruct()    const;

   bool             IsUnion()     const;

   bool             IsArray()     const;

   int              GetPointeeSize() const;

   TypeName *       GetMemberType(const char * member);

   TypeName *       FirstUnionMember(int size) const;

   int GetFunReturnSize()

       { return decl_spec->GetFunReturnSize(abs_declarator); };

   int GetSize() const

       { return decl_spec->GetSize(abs_declarator); };

   SUW GetSUW();

   bool IsUnsigned() const;

   bool IsFunPtr() const

       { return ::IsFunPtr(abs_declarator); };

   ParameterDeclarationList * GetParameters() const

       { return ::GetParameters(abs_declarator); };

private:

   TypeSpecifier * decl_spec;

   Declarator    * abs_declarator;

};

//-----------------------------------------------------------------------------

class Statement : public Node

{

public:

   Statement(const char * ntype)

   : Node(ntype)

   {};

   virtual void Emit(FILE * out) = 0;

   virtual bool NotEmpty() const   { return true; };

   virtual bool EmitCaseJump(FILE * out, bool def, int loop, int size)

      { return false; };

};

//-----------------------------------------------------------------------------

class LabelStatement : public Statement

{

public:

   LabelStatement(const char * n, Statement * stat)

   : Statement("Label Statement"),

     label_name(n),

     statement(stat)

     {};

   virtual void Emit(FILE * out);

private:

   const char * label_name;

   Statement  * statement;

};

//-----------------------------------------------------------------------------

class CaseStatement : public Statement

{

public:

   CaseStatement(Expression * exp, Statement * stat)

   : Statement("case Statement"),

     case_value(exp),

     statement(stat)

     {};

   virtual void Emit(FILE * out);

   virtual bool EmitCaseJump(FILE * out, bool def, int loop, int size);

private:

   Expression * case_value;             // case, or 0 for default

   Statement  * statement;

};

//-----------------------------------------------------------------------------

class CompoundStatement : public Statement

{

public:

   CompoundStatement(DeclarationList * dl, StatementList * sl)

   : Statement("CompoundStatement"),

     decl_list(dl),

     stat_list(sl)

     {};

   virtual void Emit(FILE * out);

   virtual bool NotEmpty() const   { return decl_list || stat_list; };

   void EmitCaseJumps(FILE * out, int size);

   int  EmitAutovars(FILE * out);

private:

   DeclarationList * decl_list;

   StatementList   * stat_list;

};

//-----------------------------------------------------------------------------

class ExpressionStatement : public Statement

{

public:

   ExpressionStatement(Expression * expr)

   : Statement("ExpressionStatement"),

     expression(expr)

   {};

   virtual void Emit(FILE * out);

   virtual bool NotEmpty() const   { return expression; };

   Expression * GetExpression() const   { return expression; };

private:

   Expression * expression;

};

//-----------------------------------------------------------------------------

class SwitchStatement : public Statement

{

public:

   SwitchStatement(Expression * cond, CompoundStatement * cas)

   : Statement("SwitchStatement"),

     condition(cond),

     case_stat(cas)

   {};

   virtual void Emit(FILE * out);

private:

   Expression         * condition;

   CompoundStatement  * case_stat;

};

//-----------------------------------------------------------------------------

class IfElseStatement : public Statement

{

public:

   IfElseStatement(Expression * cond, Statement * ifs, Statement * els)

   : Statement("IfElseStatement"),

     condition(cond),

     if_stat(ifs),

     else_stat(els)

   {};

   virtual void Emit(FILE * out);