// Node.hh
|
// Node.hh
|
#ifndef __NODE_HH_DEFINED__
|
#ifndef __NODE_HH_DEFINED__
|
#define __NODE_HH_DEFINED__
|
#define __NODE_HH_DEFINED__
|
|
|
#include
|
#include
|
#include "List.hh"
|
#include "List.hh"
|
|
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
|
|
class TypeSpecifier;
|
class TypeSpecifier;
|
class DeclItem;
|
class DeclItem;
|
class Initializer;
|
class Initializer;
|
class TypeName;
|
class TypeName;
|
class Expression;
|
class Expression;
|
|
|
const char * GetDeclaredName(Declarator * decl);
|
const char * GetDeclaredName(Declarator * decl);
|
ParameterDeclarationList * GetParameters(Declarator * decl);
|
ParameterDeclarationList * GetParameters(Declarator * decl);
|
bool IsFunPtr(Declarator * decl);
|
bool IsFunPtr(Declarator * decl);
|
bool IsPointer(Declarator * decl);
|
bool IsPointer(Declarator * decl);
|
Expression * ArrayLength(Declarator * decl);
|
Expression * ArrayLength(Declarator * decl);
|
void SetArrayLength(Declarator * decl, int len);
|
void SetArrayLength(Declarator * decl, int len);
|
bool IsFunction(Declarator * decl);
|
bool IsFunction(Declarator * decl);
|
bool IsArray(Declarator * decl);
|
bool IsArray(Declarator * decl);
|
|
|
enum SUW { SB, UB, WO };
|
enum SUW { SB, UB, WO };
|
|
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class Constant : public Node
|
class Constant : public Node
|
{
|
{
|
public:
|
public:
|
Constant(const char * name)
|
Constant(const char * name)
|
: Node(name)
|
: Node(name)
|
{};
|
{};
|
|
|
virtual void EmitValue_RR(FILE * out) = 0;
|
virtual void EmitValue_RR(FILE * out) = 0;
|
virtual void EmitValue_LL(FILE * out) = 0;
|
virtual void EmitValue_LL(FILE * out) = 0;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class NumericConstant : public Constant
|
class NumericConstant : public Constant
|
{
|
{
|
public:
|
public:
|
NumericConstant(const char * txt);
|
NumericConstant(const char * txt);
|
NumericConstant(int val, int siz = 0)
|
NumericConstant(int val, int siz = 0)
|
: Constant("NumericConstant"),
|
: Constant("NumericConstant"),
|
value(val),
|
value(val),
|
size(siz)
|
size(siz)
|
{};
|
{};
|
|
|
virtual void EmitValue_RR(FILE * out);
|
virtual void EmitValue_RR(FILE * out);
|
virtual void EmitValue_LL(FILE * out);
|
virtual void EmitValue_LL(FILE * out);
|
int GetValue() const { return value; };
|
int GetValue() const { return value; };
|
int GetSize() const { return size; };
|
int GetSize() const { return size; };
|
|
|
void Negate() { value = -value; };
|
void Negate() { value = -value; };
|
void Complement() { value = ~value; };
|
void Complement() { value = ~value; };
|
void LogNot() { if (value) value = 0; else value = -1; };
|
void LogNot() { if (value) value = 0; else value = -1; };
|
|
|
private:
|
private:
|
int value;
|
int value;
|
int size;
|
int size;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class StringConstant : public Constant
|
class StringConstant : public Constant
|
{
|
{
|
public:
|
public:
|
StringConstant();
|
StringConstant();
|
~StringConstant();
|
~StringConstant();
|
|
|
virtual void EmitValue_RR(FILE * out);
|
virtual void EmitValue_RR(FILE * out);
|
virtual void EmitValue_LL(FILE * out);
|
virtual void EmitValue_LL(FILE * out);
|
void operator += (char txt);
|
void operator += (char txt);
|
StringConstant * operator & (StringConstant * other);
|
StringConstant * operator & (StringConstant * other);
|
void operator += (const char * txt)
|
void operator += (const char * txt)
|
{ while (*txt) *this += *txt++; };
|
{ while (*txt) *this += *txt++; };
|
|
|
int GetStringNumber() const { return string_number; };
|
int GetStringNumber() const { return string_number; };
|
int GetLength() const { return value_len; };
|
int GetLength() const { return value_len; };
|
char * Kill()
|
char * Kill()
|
{ char * ret = buffer; buffer = 0; delete this; return ret; };
|
{ char * ret = buffer; buffer = 0; delete this; return ret; };
|
|
|
void EmitAndRemove(FILE * out, int length);
|
void EmitAndRemove(FILE * out, int length);
|
|
|
static void EmitAll(FILE * out);
|
static void EmitAll(FILE * out);
|
|
|
private:
|
private:
|
char * buffer;
|
char * buffer;
|
int buffer_len;
|
int buffer_len;
|
int value_len;
|
int value_len;
|
int string_number;
|
int string_number;
|
|
|
static int str_count;
|
static int str_count;
|
enum { MAX_STRINGS = 5000 };
|
enum { MAX_STRINGS = 5000 };
|
static StringConstant * all_strings[MAX_STRINGS];
|
static StringConstant * all_strings[MAX_STRINGS];
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
// how an expression is created...
|
// how an expression is created...
|
// //
|
// //
|
enum BinExprType
|
enum BinExprType
|
{
|
{
|
// binary
|
// binary
|
ET_LIST, // expr , expr
|
ET_LIST, // expr , expr
|
ET_ARGLIST, // expr , expr in function argument
|
ET_ARGLIST, // expr , expr in function argument
|
ET_ASSIGN, // expr = expr
|
ET_ASSIGN, // expr = expr
|
ET_MULT_ASSIGN, // expr *= expr
|
ET_MULT_ASSIGN, // expr *= expr
|
ET_DIV_ASSIGN, // expr /= expr
|
ET_DIV_ASSIGN, // expr /= expr
|
ET_MOD_ASSIGN, // expr %= expr
|
ET_MOD_ASSIGN, // expr %= expr
|
ET_ADD_ASSIGN, // expr += expr
|
ET_ADD_ASSIGN, // expr += expr
|
ET_SUB_ASSIGN, // expr -= expr
|
ET_SUB_ASSIGN, // expr -= expr
|
ET_LEFT_ASSIGN, // expr <<= expr
|
ET_LEFT_ASSIGN, // expr <<= expr
|
ET_RIGHT_ASSIGN, // expr >>= expr
|
ET_RIGHT_ASSIGN, // expr >>= expr
|
ET_AND_ASSIGN, // expr &= expr
|
ET_AND_ASSIGN, // expr &= expr
|
ET_XOR_ASSIGN, // expr ^= expr
|
ET_XOR_ASSIGN, // expr ^= expr
|
ET_OR_ASSIGN, // expr |= expr
|
ET_OR_ASSIGN, // expr |= expr
|
ET_BIT_OR, // expr | expr
|
ET_BIT_OR, // expr | expr
|
ET_BIT_AND, // expr & expr
|
ET_BIT_AND, // expr & expr
|
ET_BIT_XOR, // expr ^ expr
|
ET_BIT_XOR, // expr ^ expr
|
ET_LOG_OR, // expr || expr
|
ET_LOG_OR, // expr || expr
|
ET_LOG_AND, // expr && expr
|
ET_LOG_AND, // expr && expr
|
ET_EQUAL, // expr == expr
|
ET_EQUAL, // expr == expr
|
ET_NOT_EQUAL, // expr != expr
|
ET_NOT_EQUAL, // expr != expr
|
ET_LESS_EQUAL, // expr <= expr
|
ET_LESS_EQUAL, // expr <= expr
|
ET_LESS, // expr < expr
|
ET_LESS, // expr < expr
|
ET_GREATER_EQUAL, // expr >= expr
|
ET_GREATER_EQUAL, // expr >= expr
|
ET_GREATER, // expr > expr
|
ET_GREATER, // expr > expr
|
ET_LEFT, // expr << expr
|
ET_LEFT, // expr << expr
|
ET_RIGHT, // expr >> expr
|
ET_RIGHT, // expr >> expr
|
ET_ADD, // expr + expr
|
ET_ADD, // expr + expr
|
ET_SUB, // expr - expr
|
ET_SUB, // expr - expr
|
ET_MULT, // expr * expr
|
ET_MULT, // expr * expr
|
ET_DIV, // expr / expr
|
ET_DIV, // expr / expr
|
ET_MOD, // expr % expr
|
ET_MOD, // expr % expr
|
ET_ELEMENT, // expr [ expr ]
|
ET_ELEMENT, // expr [ expr ]
|
ET_FUNCALL // expr ( ... )
|
ET_FUNCALL // expr ( ... )
|
};
|
};
|
|
|
enum UnaExprType
|
enum UnaExprType
|
{
|
{
|
ET_CAST, // (type) expr
|
ET_CAST, // (type) expr
|
ET_ADDRESS, // & expr
|
ET_ADDRESS, // & expr
|
ET_CONTENT, // * expr
|
ET_CONTENT, // * expr
|
ET_CONJUGATE, // + expr
|
ET_CONJUGATE, // + expr
|
ET_NEGATE, // - expr
|
ET_NEGATE, // - expr
|
ET_COMPLEMENT, // ~ expr
|
ET_COMPLEMENT, // ~ expr
|
ET_LOG_NOT, // ! expr
|
ET_LOG_NOT, // ! expr
|
ET_POSTINC, // ++ expr
|
ET_POSTINC, // ++ expr
|
ET_POSTDEC, // -- expr
|
ET_POSTDEC, // -- expr
|
ET_PREINC, // ++ expr
|
ET_PREINC, // ++ expr
|
ET_PREDEC // -- expr
|
ET_PREDEC // -- expr
|
};
|
};
|
|
|
class Expression : public Node
|
class Expression : public Node
|
{
|
{
|
public:
|
public:
|
Expression(const char * nodename)
|
Expression(const char * nodename)
|
: Node(nodename),
|
: Node(nodename),
|
type_name(0)
|
type_name(0)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out) = 0;
|
virtual void Emit(FILE * out) = 0;
|
virtual void Emit_to_ll(FILE * out) { assert(0); };
|
virtual void Emit_to_ll(FILE * out) { assert(0); };
|
void EmitCall(FILE * out, Expression * right);
|
void EmitCall(FILE * out, Expression * right);
|
virtual void EmitInitialization(FILE * out, int size);
|
virtual void EmitInitialization(FILE * out, int size);
|
virtual void EmitAddress(FILE * out);
|
virtual void EmitAddress(FILE * out);
|
virtual void AddAddress(FILE * out);
|
virtual void AddAddress(FILE * out);
|
virtual int EmitPush(FILE * out, ParameterDeclarationList * params);
|
virtual int EmitPush(FILE * out, ParameterDeclarationList * params);
|
virtual void EmitAssign(FILE * out) { assert(0); };
|
virtual void EmitAssign(FILE * out) { assert(0); };
|
virtual int GetParaLength() const { return 1; };
|
virtual int GetParaLength() const { return 1; };
|
|
|
virtual bool IsConstant() const { return false; };
|
virtual bool IsConstant() const { return false; };
|
virtual bool IsNumericConstant() const { return false; };
|
virtual bool IsNumericConstant() const { return false; };
|
virtual bool IsStringConstant() const { return false; };
|
virtual bool IsStringConstant() const { return false; };
|
virtual bool IsVariable() const { return false; };
|
virtual bool IsVariable() const { return false; };
|
virtual const char * GetVarname() const { return 0; };
|
virtual const char * GetVarname() const { return 0; };
|
virtual int GetConstantNumericValue() const;
|
virtual int GetConstantNumericValue() const;
|
virtual StringConstant * GetStringConstant() const;
|
virtual StringConstant * GetStringConstant() const;
|
virtual TypeName * FunReturnType();
|
virtual TypeName * FunReturnType();
|
virtual TypeName * SetType() = 0;
|
virtual TypeName * SetType() = 0;
|
virtual SUW GetSUW();
|
virtual SUW GetSUW();
|
void SetType(TypeName * t);
|
void SetType(TypeName * t);
|
|
|
bool IsPointer();
|
bool IsPointer();
|
bool IsArray();
|
bool IsArray();
|
int PointeeSize();
|
int PointeeSize();
|
int GetSize();
|
int GetSize();
|
TypeName * GetType();
|
TypeName * GetType();
|
bool IsUnsigned();
|
bool IsUnsigned();
|
int FunReturnSize();
|
int FunReturnSize();
|
|
|
static const char * GetPrettyName(const char * pretty);
|
static const char * GetPrettyName(const char * pretty);
|
|
|
virtual Expression * OptNegate() { assert(0); };
|
virtual Expression * OptNegate() { assert(0); };
|
virtual Expression * OptComplement() { assert(0); };
|
virtual Expression * OptComplement() { assert(0); };
|
virtual Expression * OptLogNot() { assert(0); };
|
virtual Expression * OptLogNot() { assert(0); };
|
|
|
private:
|
private:
|
TypeName * type_name;
|
TypeName * type_name;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class IdentifierExpression : public Expression
|
class IdentifierExpression : public Expression
|
{
|
{
|
public:
|
public:
|
static Expression * New(const char * s);
|
static Expression * New(const char * s);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual void EmitAssign(FILE * out);
|
virtual void EmitAssign(FILE * out);
|
virtual void Emit_to_ll(FILE * out);
|
virtual void Emit_to_ll(FILE * out);
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
|
|
virtual bool IsVariable() const { return true; };
|
virtual bool IsVariable() const { return true; };
|
virtual const char * GetVarname() const { return varname; };
|
virtual const char * GetVarname() const { return varname; };
|
virtual void EmitAddress(FILE * out);
|
virtual void EmitAddress(FILE * out);
|
virtual void EmitInitialization(FILE * out, int size);
|
virtual void EmitInitialization(FILE * out, int size);
|
virtual void AddAddress(FILE * out);
|
virtual void AddAddress(FILE * out);
|
virtual TypeName * FunReturnType();
|
virtual TypeName * FunReturnType();
|
|
|
private:
|
private:
|
IdentifierExpression(const char * s)
|
IdentifierExpression(const char * s)
|
: Expression("Expression (variable name)"),
|
: Expression("Expression (variable name)"),
|
varname(s)
|
varname(s)
|
{};
|
{};
|
|
|
const char * varname;
|
const char * varname;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class MemberExpression : public Expression
|
class MemberExpression : public Expression
|
{
|
{
|
public:
|
public:
|
MemberExpression(bool is_pointer, Expression * r, const char * s);
|
MemberExpression(bool is_pointer, Expression * r, const char * s);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual void EmitAddress(FILE * out);
|
virtual void EmitAddress(FILE * out);
|
void EmitAddress(FILE * out, bool content);
|
void EmitAddress(FILE * out, bool content);
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
|
|
private:
|
private:
|
Expression * left;
|
Expression * left;
|
const char * membername;
|
const char * membername;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class StringExpression : public Expression
|
class StringExpression : public Expression
|
{
|
{
|
public:
|
public:
|
StringExpression(StringConstant * s);
|
StringExpression(StringConstant * s);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual void EmitAddress(FILE * out);
|
virtual void EmitAddress(FILE * out);
|
virtual void Emit_to_ll(FILE * out);
|
virtual void Emit_to_ll(FILE * out);
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
virtual void EmitInitialization(FILE * out, int size);
|
virtual void EmitInitialization(FILE * out, int size);
|
|
|
virtual bool IsConstant() const { return true; };
|
virtual bool IsConstant() const { return true; };
|
virtual bool IsStringConstant() const { return true; };
|
virtual bool IsStringConstant() const { return true; };
|
virtual StringConstant * GetStringConstant() const
|
virtual StringConstant * GetStringConstant() const
|
{ return string_constant; }
|
{ return string_constant; }
|
|
|
private:
|
private:
|
StringConstant * string_constant;
|
StringConstant * string_constant;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class NumericExpression : public Expression
|
class NumericExpression : public Expression
|
{
|
{
|
public:
|
public:
|
NumericExpression(NumericConstant * n);
|
NumericExpression(NumericConstant * n);
|
NumericExpression(TypeName * t);
|
NumericExpression(TypeName * t);
|
NumericExpression(Expression * r);
|
NumericExpression(Expression * r);
|
NumericExpression(int value);
|
NumericExpression(int value);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual void Emit_to_ll(FILE * out);
|
virtual void Emit_to_ll(FILE * out);
|
virtual bool IsConstant() const { return true; };
|
virtual bool IsConstant() const { return true; };
|
virtual bool IsNumericConstant() const { return true; };
|
virtual bool IsNumericConstant() const { return true; };
|
virtual int GetConstantNumericValue() const;
|
virtual int GetConstantNumericValue() const;
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
virtual void EmitInitialization(FILE * out, int size);
|
virtual void EmitInitialization(FILE * out, int size);
|
static const char * GetPretty(int value);
|
static const char * GetPretty(int value);
|
|
|
virtual Expression * OptNegate();
|
virtual Expression * OptNegate();
|
virtual Expression * OptComplement();
|
virtual Expression * OptComplement();
|
virtual Expression * OptLogNot();
|
virtual Expression * OptLogNot();
|
|
|
private:
|
private:
|
NumericConstant * int_value;
|
NumericConstant * int_value;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class CondExpression : public Expression
|
class CondExpression : public Expression
|
{
|
{
|
public:
|
public:
|
CondExpression(Expression * l, Expression * m, Expression * r)
|
CondExpression(Expression * l, Expression * m, Expression * r)
|
: Expression("Expression (l ? m : r)"),
|
: Expression("Expression (l ? m : r)"),
|
left(l),
|
left(l),
|
middle(m),
|
middle(m),
|
right(r)
|
right(r)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
|
|
private:
|
private:
|
Expression * left;
|
Expression * left;
|
Expression * middle;
|
Expression * middle;
|
Expression * right;
|
Expression * right;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class BinaryExpression : public Expression
|
class BinaryExpression : public Expression
|
{
|
{
|
public:
|
public:
|
static Expression * New(BinExprType et, Expression * l, Expression * r);
|
static Expression * New(BinExprType et, Expression * l, Expression * r);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
virtual void EmitAddress(FILE * out);
|
virtual void EmitAddress(FILE * out);
|
|
|
TypeName * MaxType(Expression * l, Expression * r);
|
TypeName * MaxType(Expression * l, Expression * r);
|
|
|
static const char * GetPretty(BinExprType expr_type);
|
static const char * GetPretty(BinExprType expr_type);
|
static BinExprType MapAssign(BinExprType et);
|
static BinExprType MapAssign(BinExprType et);
|
|
|
protected:
|
protected:
|
BinaryExpression(BinExprType et, Expression * l, Expression * r);
|
BinaryExpression(BinExprType et, Expression * l, Expression * r);
|
BinExprType expr_type;
|
BinExprType expr_type;
|
Expression * left;
|
Expression * left;
|
Expression * right;
|
Expression * right;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class ArgListExpression : public BinaryExpression
|
class ArgListExpression : public BinaryExpression
|
{
|
{
|
public:
|
public:
|
ArgListExpression(Expression * l, Expression * r)
|
ArgListExpression(Expression * l, Expression * r)
|
: BinaryExpression(ET_ARGLIST, l, r)
|
: BinaryExpression(ET_ARGLIST, l, r)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out) {}; // done vy EmitPush()
|
virtual void Emit(FILE * out) {}; // done vy EmitPush()
|
virtual int EmitPush(FILE * out, ParameterDeclarationList * params);
|
virtual int EmitPush(FILE * out, ParameterDeclarationList * params);
|
virtual int GetParaLength() const;
|
virtual int GetParaLength() const;
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class AdditionExpression : public BinaryExpression
|
class AdditionExpression : public BinaryExpression
|
{
|
{
|
public:
|
public:
|
static Expression * New(Expression * l, Expression * r);
|
static Expression * New(Expression * l, Expression * r);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
|
|
private:
|
private:
|
AdditionExpression(Expression * l, Expression * r)
|
AdditionExpression(Expression * l, Expression * r)
|
: BinaryExpression(ET_ADD, l, r)
|
: BinaryExpression(ET_ADD, l, r)
|
{};
|
{};
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class SubtractionExpression : public BinaryExpression
|
class SubtractionExpression : public BinaryExpression
|
{
|
{
|
public:
|
public:
|
static Expression * New(Expression * l, Expression * r);
|
static Expression * New(Expression * l, Expression * r);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
|
|
private:
|
private:
|
SubtractionExpression(Expression * l, Expression * r)
|
SubtractionExpression(Expression * l, Expression * r)
|
: BinaryExpression(ET_SUB, l, r)
|
: BinaryExpression(ET_SUB, l, r)
|
{};
|
{};
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class UnaryExpression : public Expression
|
class UnaryExpression : public Expression
|
{
|
{
|
public:
|
public:
|
UnaryExpression(TypeName * t, Expression * r);
|
UnaryExpression(TypeName * t, Expression * r);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual void EmitAddress(FILE * out);
|
virtual void EmitAddress(FILE * out);
|
virtual void EmitInitialization(FILE * out, int size);
|
virtual void EmitInitialization(FILE * out, int size);
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
|
|
static const char * GetPretty(UnaExprType expr_type);
|
static const char * GetPretty(UnaExprType expr_type);
|
static Expression * New(UnaExprType et, Expression * r);
|
static Expression * New(UnaExprType et, Expression * r);
|
|
|
private:
|
private:
|
UnaryExpression(UnaExprType et, Expression * r)
|
UnaryExpression(UnaExprType et, Expression * r)
|
: Expression(GetPrettyName(GetPretty(et))),
|
: Expression(GetPrettyName(GetPretty(et))),
|
expr_type(et),
|
expr_type(et),
|
right(r)
|
right(r)
|
{};
|
{};
|
|
|
UnaExprType expr_type;
|
UnaExprType expr_type;
|
Expression * right;
|
Expression * right;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class AsmExpression : public Expression
|
class AsmExpression : public Expression
|
{
|
{
|
public:
|
public:
|
AsmExpression(StringConstant * string);
|
AsmExpression(StringConstant * string);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual TypeName * SetType();
|
virtual TypeName * SetType();
|
|
|
private:
|
private:
|
char * asm_string;
|
char * asm_string;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
enum Specifier
|
enum Specifier
|
{
|
{
|
// storage class
|
// storage class
|
SC_TYPEDEF = 0x00000001,
|
SC_TYPEDEF = 0x00000001,
|
SC_EXTERN = 0x00000002,
|
SC_EXTERN = 0x00000002,
|
SC_STATIC = 0x00000004,
|
SC_STATIC = 0x00000004,
|
SC_AUTO = 0x00000008,
|
SC_AUTO = 0x00000008,
|
SC_REGISTER = 0x00000010,
|
SC_REGISTER = 0x00000010,
|
SC_MASK = SC_TYPEDEF | SC_EXTERN | SC_STATIC | SC_AUTO | SC_REGISTER,
|
SC_MASK = SC_TYPEDEF | SC_EXTERN | SC_STATIC | SC_AUTO | SC_REGISTER,
|
|
|
// type qualifiers
|
// type qualifiers
|
TQ_CONST = 0x00000100,
|
TQ_CONST = 0x00000100,
|
TQ_VOLATILE = 0x00000200,
|
TQ_VOLATILE = 0x00000200,
|
TQ_MASK = TQ_CONST | TQ_VOLATILE,
|
TQ_MASK = TQ_CONST | TQ_VOLATILE,
|
|
|
// type specifiers
|
// type specifiers
|
TS_SIGNED = 0x00001000,
|
TS_SIGNED = 0x00001000,
|
TS_UNSIGNED = 0x00002000,
|
TS_UNSIGNED = 0x00002000,
|
TS_SIGN_MASK = TS_SIGNED | TS_UNSIGNED,
|
TS_SIGN_MASK = TS_SIGNED | TS_UNSIGNED,
|
|
|
TS_VOID = 0x00010000,
|
TS_VOID = 0x00010000,
|
TS_CHAR = 0x00020000,
|
TS_CHAR = 0x00020000,
|
TS_SHORT = 0x00040000,
|
TS_SHORT = 0x00040000,
|
TS_INT = 0x00080000,
|
TS_INT = 0x00080000,
|
TS_LONG = 0x00100000,
|
TS_LONG = 0x00100000,
|
TS_FLOAT = 0x00200000,
|
TS_FLOAT = 0x00200000,
|
TS_DOUBLE = 0x00400000,
|
TS_DOUBLE = 0x00400000,
|
TS_STRUCT = 0x00800000,
|
TS_STRUCT = 0x00800000,
|
TS_UNION = 0x01000000,
|
TS_UNION = 0x01000000,
|
TS_ENUM = 0x02000000,
|
TS_ENUM = 0x02000000,
|
TS_TYPE_NAME = 0x04000000,
|
TS_TYPE_NAME = 0x04000000,
|
TS_MASK = TS_VOID | TS_CHAR | TS_SHORT | TS_INT | TS_LONG |
|
TS_MASK = TS_VOID | TS_CHAR | TS_SHORT | TS_INT | TS_LONG |
|
TS_FLOAT | TS_DOUBLE | TS_STRUCT |
|
TS_FLOAT | TS_DOUBLE | TS_STRUCT |
|
TS_UNION | TS_ENUM | TS_TYPE_NAME,
|
TS_UNION | TS_ENUM | TS_TYPE_NAME,
|
TS_NUMERIC = TS_CHAR | TS_SHORT | TS_INT | TS_LONG |
|
TS_NUMERIC = TS_CHAR | TS_SHORT | TS_INT | TS_LONG |
|
TS_FLOAT | TS_DOUBLE | TS_ENUM,
|
TS_FLOAT | TS_DOUBLE | TS_ENUM,
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class Ptr : public Node
|
class Ptr : public Node
|
{
|
{
|
public:
|
public:
|
Ptr(TypeSpecifier * ds)
|
Ptr(TypeSpecifier * ds)
|
: Node("Ptr"),
|
: Node("Ptr"),
|
decl_specs(ds)
|
decl_specs(ds)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
int Print(FILE * out) const;
|
int Print(FILE * out) const;
|
|
|
private:
|
private:
|
TypeSpecifier * decl_specs;
|
TypeSpecifier * decl_specs;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class Identifier : public Node
|
class Identifier : public Node
|
{
|
{
|
public:
|
public:
|
Identifier(const char * n)
|
Identifier(const char * n)
|
: Node("Identifier"),
|
: Node("Identifier"),
|
name(n)
|
name(n)
|
{};
|
{};
|
|
|
private:
|
private:
|
const char * name;
|
const char * name;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class Initializer : public Node
|
class Initializer : public Node
|
{
|
{
|
public:
|
public:
|
Initializer(Expression * expr)
|
Initializer(Expression * expr)
|
: Node("Initializer (skalar)"),
|
: Node("Initializer (skalar)"),
|
skalar_value(expr),
|
skalar_value(expr),
|
array_value(0)
|
array_value(0)
|
{};
|
{};
|
|
|
Initializer(InitializerList * list)
|
Initializer(InitializerList * list)
|
: Node("Initializer (vector)"),
|
: Node("Initializer (vector)"),
|
skalar_value(0),
|
skalar_value(0),
|
array_value(list)
|
array_value(list)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual void EmitValue(FILE * out, TypeName * tn);
|
virtual void EmitValue(FILE * out, TypeName * tn);
|
|
|
int InitAutovar(FILE * out, TypeName * type);
|
int InitAutovar(FILE * out, TypeName * type);
|
int ElementCount() const;
|
int ElementCount() const;
|
|
|
private:
|
private:
|
Expression * skalar_value;
|
Expression * skalar_value;
|
InitializerList * array_value;
|
InitializerList * array_value;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class ParameterDeclaration : public Node
|
class ParameterDeclaration : public Node
|
{
|
{
|
public:
|
public:
|
ParameterDeclaration(TypeSpecifier * ds, Declarator * dec);
|
ParameterDeclaration(TypeSpecifier * ds, Declarator * dec);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
int AllocateParameters(int position);
|
int AllocateParameters(int position);
|
const char * GetDeclaredName(int skip);
|
const char * GetDeclaredName(int skip);
|
TypeName * GetTypeName() const { return type; };
|
TypeName * GetTypeName() const { return type; };
|
bool IsEllipsis() const { return isEllipsis; };
|
bool IsEllipsis() const { return isEllipsis; };
|
ParameterDeclaration * SetEllipsis() { isEllipsis = true; return this; };
|
ParameterDeclaration * SetEllipsis() { isEllipsis = true; return this; };
|
|
|
private:
|
private:
|
TypeName * type;
|
TypeName * type;
|
bool isEllipsis;
|
bool isEllipsis;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
enum DECL_WHAT
|
enum DECL_WHAT
|
{
|
{
|
DECL_NAME = 1,
|
DECL_NAME = 1,
|
DECL_FUNPTR = 2,
|
DECL_FUNPTR = 2,
|
DECL_ARRAY = 3,
|
DECL_ARRAY = 3,
|
DECL_FUN = 4,
|
DECL_FUN = 4,
|
DECL_POINTER = 5
|
DECL_POINTER = 5
|
};
|
};
|
|
|
class DeclItem : public Node
|
class DeclItem : public Node
|
{
|
{
|
public:
|
public:
|
DeclItem(DECL_WHAT w)
|
DeclItem(DECL_WHAT w)
|
: Node("DeclItem"),
|
: Node("DeclItem"),
|
what(w),
|
what(w),
|
name(0),
|
name(0),
|
funptr(0),
|
funptr(0),
|
array_size(0),
|
array_size(0),
|
fun_params(0),
|
fun_params(0),
|
fun_identifiers(0),
|
fun_identifiers(0),
|
pointer(0)
|
pointer(0)
|
{};
|
{};
|
|
|
DeclItem(const char * n)
|
DeclItem(const char * n)
|
: Node("DeclItem"),
|
: Node("DeclItem"),
|
what(DECL_NAME),
|
what(DECL_NAME),
|
name(n),
|
name(n),
|
funptr(0),
|
funptr(0),
|
array_size(0),
|
array_size(0),
|
fun_params(0),
|
fun_params(0),
|
fun_identifiers(0),
|
fun_identifiers(0),
|
pointer(0)
|
pointer(0)
|
{};
|
{};
|
|
|
DeclItem(Declarator * fp)
|
DeclItem(Declarator * fp)
|
: Node("DeclItem"),
|
: Node("DeclItem"),
|
what(DECL_FUNPTR),
|
what(DECL_FUNPTR),
|
name(0),
|
name(0),
|
funptr(fp),
|
funptr(fp),
|
array_size(0),
|
array_size(0),
|
fun_params(0),
|
fun_params(0),
|
fun_identifiers(0),
|
fun_identifiers(0),
|
pointer(0)
|
pointer(0)
|
{};
|
{};
|
|
|
DeclItem(Expression * ep)
|
DeclItem(Expression * ep)
|
: Node("DeclItem"),
|
: Node("DeclItem"),
|
what(DECL_ARRAY),
|
what(DECL_ARRAY),
|
name(0),
|
name(0),
|
funptr(0),
|
funptr(0),
|
array_size(ep),
|
array_size(ep),
|
fun_params(0),
|
fun_params(0),
|
fun_identifiers(0),
|
fun_identifiers(0),
|
pointer(0)
|
pointer(0)
|
{};
|
{};
|
|
|
DeclItem(ParameterDeclarationList * pl)
|
DeclItem(ParameterDeclarationList * pl)
|
: Node("DeclItem"),
|
: Node("DeclItem"),
|
what(DECL_FUN),
|
what(DECL_FUN),
|
name(0),
|
name(0),
|
funptr(0),
|
funptr(0),
|
array_size(0),
|
array_size(0),
|
fun_params(pl),
|
fun_params(pl),
|
fun_identifiers(0),
|
fun_identifiers(0),
|
pointer(0)
|
pointer(0)
|
{};
|
{};
|
|
|
DeclItem(IdentifierList * il)
|
DeclItem(IdentifierList * il)
|
: Node("DeclItem"),
|
: Node("DeclItem"),
|
what(DECL_FUN),
|
what(DECL_FUN),
|
name(0),
|
name(0),
|
funptr(0),
|
funptr(0),
|
array_size(0),
|
array_size(0),
|
fun_params(0),
|
fun_params(0),
|
fun_identifiers(il),
|
fun_identifiers(il),
|
pointer(0)
|
pointer(0)
|
{};
|
{};
|
|
|
DeclItem(Pointer * p)
|
DeclItem(Pointer * p)
|
: Node("DeclItem"),
|
: Node("DeclItem"),
|
what(DECL_POINTER),
|
what(DECL_POINTER),
|
name(0),
|
name(0),
|
funptr(0),
|
funptr(0),
|
array_size(0),
|
array_size(0),
|
fun_params(0),
|
fun_params(0),
|
fun_identifiers(0),
|
fun_identifiers(0),
|
pointer(p)
|
pointer(p)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
int Print(FILE * out) const;
|
int Print(FILE * out) const;
|
|
|
const char * GetName() const { return name; };
|
const char * GetName() const { return name; };
|
DECL_WHAT GetWhat() const { return what; };
|
DECL_WHAT GetWhat() const { return what; };
|
Declarator * GetFunptr() const { return funptr; };
|
Declarator * GetFunptr() const { return funptr; };
|
Pointer * GetPointer() const { return pointer; };
|
Pointer * GetPointer() const { return pointer; };
|
Expression * GetArraySize() const { return array_size; };
|
Expression * GetArraySize() const { return array_size; };
|
void SetArraySize(int n);
|
void SetArraySize(int n);
|
ParameterDeclarationList * GetParameters() const { return fun_params; };
|
ParameterDeclarationList * GetParameters() const { return fun_params; };
|
|
|
private:
|
private:
|
const DECL_WHAT what;
|
const DECL_WHAT what;
|
const char * name;
|
const char * name;
|
Declarator * funptr;
|
Declarator * funptr;
|
Expression * array_size;
|
Expression * array_size;
|
ParameterDeclarationList * fun_params;
|
ParameterDeclarationList * fun_params;
|
IdentifierList * fun_identifiers;
|
IdentifierList * fun_identifiers;
|
Pointer * pointer;
|
Pointer * pointer;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class Enumerator : public Node
|
class Enumerator : public Node
|
{
|
{
|
public:
|
public:
|
Enumerator(const char * n, Expression * v)
|
Enumerator(const char * n, Expression * v)
|
: Node("Enumerator"),
|
: Node("Enumerator"),
|
name(n),
|
name(n),
|
value(v)
|
value(v)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
static int current;
|
static int current;
|
|
|
private:
|
private:
|
const char * name;
|
const char * name;
|
Expression * value;
|
Expression * value;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class StructDeclarator : public Node
|
class StructDeclarator : public Node
|
{
|
{
|
public:
|
public:
|
StructDeclarator(Declarator * dcl, Expression * exp)
|
StructDeclarator(Declarator * dcl, Expression * exp)
|
: Node("StructDeclarator"),
|
: Node("StructDeclarator"),
|
declarator(dcl),
|
declarator(dcl),
|
expression(exp),
|
expression(exp),
|
position(-1)
|
position(-1)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
int EmitMember(FILE * out, const char * struct_name,
|
int EmitMember(FILE * out, const char * struct_name,
|
TypeSpecifier * tspec, int pos, bool is_union);
|
TypeSpecifier * tspec, int pos, bool is_union);
|
TypeName * GetMemberType(TypeSpecifier * tspec, const char * member);
|
TypeName * GetMemberType(TypeSpecifier * tspec, const char * member);
|
int GetMemberPosition(const char * member) const;
|
int GetMemberPosition(const char * member) const;
|
Declarator * GetDeclarator() const { return declarator; };
|
Declarator * GetDeclarator() const { return declarator; };
|
TypeName * FirstUnionMember(TypeSpecifier * tspec, int union_size) const;
|
TypeName * FirstUnionMember(TypeSpecifier * tspec, int union_size) const;
|
const char * GetMemberName() const;
|
const char * GetMemberName() const;
|
|
|
private:
|
private:
|
Declarator * declarator;
|
Declarator * declarator;
|
Expression * expression; // : bitfield
|
Expression * expression; // : bitfield
|
int position;
|
int position;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class StructDeclaration : public Node
|
class StructDeclaration : public Node
|
{
|
{
|
public:
|
public:
|
StructDeclaration(TypeSpecifier * ds, StructDeclaratorList * sdl)
|
StructDeclaration(TypeSpecifier * ds, StructDeclaratorList * sdl)
|
: Node("StructDeclaration"),
|
: Node("StructDeclaration"),
|
decl_specifiers(ds),
|
decl_specifiers(ds),
|
struct_decl_list(sdl),
|
struct_decl_list(sdl),
|
size(-1)
|
size(-1)
|
{ };
|
{ };
|
|
|
int Emit(FILE * out, const char * struct_name, int pos, bool is_union);
|
int Emit(FILE * out, const char * struct_name, int pos, bool is_union);
|
TypeName * GetMemberType(const char * struct_name, const char * member);
|
TypeName * GetMemberType(const char * struct_name, const char * member);
|
TypeName * GetMemberType(int pos);
|
TypeName * GetMemberType(int pos);
|
int GetMemberPosition(const char * struct_name,
|
int GetMemberPosition(const char * struct_name,
|
const char * member, bool is_union) const;
|
const char * member, bool is_union) const;
|
int GetSize() const { assert(size != -1); return size; };
|
int GetSize() const { assert(size != -1); return size; };
|
|
|
TypeSpecifier * GetSpecifier() const { return decl_specifiers; };
|
TypeSpecifier * GetSpecifier() const { return decl_specifiers; };
|
StructDeclaratorList * GetDeclarators() const { return struct_decl_list; };
|
StructDeclaratorList * GetDeclarators() const { return struct_decl_list; };
|
TypeName * FirstUnionMember(int size) const;
|
TypeName * FirstUnionMember(int size) const;
|
int GetDeclaratorCount() const
|
int GetDeclaratorCount() const
|
{ return StructDeclaratorList::Length(struct_decl_list); };
|
{ return StructDeclaratorList::Length(struct_decl_list); };
|
|
|
private:
|
private:
|
TypeSpecifier * decl_specifiers;
|
TypeSpecifier * decl_specifiers;
|
StructDeclaratorList * struct_decl_list;
|
StructDeclaratorList * struct_decl_list;
|
int size;
|
int size;
|
};
|
};
|
TypeName * GetMemberType(StructDeclarationList * sdl, int pos);
|
TypeName * GetMemberType(StructDeclarationList * sdl, int pos);
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class TypeSpecifier : public Node
|
class TypeSpecifier : public Node
|
{
|
{
|
public:
|
public:
|
// all types
|
// all types
|
TypeSpecifier(Specifier sp)
|
TypeSpecifier(Specifier sp)
|
: Node("TypeSpecifier (all)"),
|
: Node("TypeSpecifier (all)"),
|
spec(sp),
|
spec(sp),
|
name(0),
|
name(0),
|
struct_decl_list(0),
|
struct_decl_list(0),
|
enum_list(0)
|
enum_list(0)
|
{};
|
{};
|
|
|
// structs, unions, typedef(name)
|
// structs, unions, typedef(name)
|
TypeSpecifier(Specifier sp, const char * n, StructDeclarationList * sdl);
|
TypeSpecifier(Specifier sp, const char * n, StructDeclarationList * sdl);
|
|
|
// enums
|
// enums
|
TypeSpecifier(const char * n, EnumeratorList * el)
|
TypeSpecifier(const char * n, EnumeratorList * el)
|
: Node("TypeSpecifier (enum)"),
|
: Node("TypeSpecifier (enum)"),
|
spec(TS_ENUM),
|
spec(TS_ENUM),
|
name(n),
|
name(n),
|
struct_decl_list(0),
|
struct_decl_list(0),
|
enum_list(el)
|
enum_list(el)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
int Print(FILE * out) const;
|
int Print(FILE * out) const;
|
|
|
TypeSpecifier * operator +(TypeSpecifier & other);
|
TypeSpecifier * operator +(TypeSpecifier & other);
|
TypeSpecifier * self() { return this; };
|
TypeSpecifier * self() { return this; };
|
|
|
Specifier GetType() const { return spec; };
|
Specifier GetType() const { return spec; };
|
const char * GetName() const { return name; };
|
const char * GetName() const { return name; };
|
StructDeclarationList * GetStructDecl() const
|
StructDeclarationList * GetStructDecl() const
|
{ return struct_decl_list; };
|
{ return struct_decl_list; };
|
bool IsUnsigned() const { return spec & TS_UNSIGNED; };
|
bool IsUnsigned() const { return spec & TS_UNSIGNED; };
|
|
|
int GetFunReturnSize(Declarator * decl) const;
|
int GetFunReturnSize(Declarator * decl) const;
|
int GetSize(Declarator * decl) const;
|
int GetSize(Declarator * decl) const;
|
int GetBaseSize() const;
|
int GetBaseSize() const;
|
TypeName * GetMemberType(const char * member);
|
TypeName * GetMemberType(const char * member);
|
bool IsNumericType() const; // char, short, or int
|
bool IsNumericType() const; // char, short, or int
|
bool IsUnion() const
|
bool IsUnion() const
|
{ if (spec & TS_UNION) return true; return false; };
|
{ if (spec & TS_UNION) return true; return false; };
|
bool IsStruct() const
|
bool IsStruct() const
|
{ if (spec & TS_STRUCT) return true; return false; };
|
{ if (spec & TS_STRUCT) return true; return false; };
|
|
|
private:
|
private:
|
Specifier spec; // all types
|
Specifier spec; // all types
|
const char * name; // enums, structs and unions
|
const char * name; // enums, structs and unions
|
StructDeclarationList * struct_decl_list; // structs and unions
|
StructDeclarationList * struct_decl_list; // structs and unions
|
EnumeratorList * enum_list; // enums
|
EnumeratorList * enum_list; // enums
|
|
|
static int anonymous_number;
|
static int anonymous_number;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class InitDeclarator : public Node
|
class InitDeclarator : public Node
|
{
|
{
|
public:
|
public:
|
InitDeclarator(Declarator * decl, Initializer * init)
|
InitDeclarator(Declarator * decl, Initializer * init)
|
: Node("InitDeclarator"),
|
: Node("InitDeclarator"),
|
declarator(decl),
|
declarator(decl),
|
initializer(init)
|
initializer(init)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
Declarator * GetDeclarator() const { return declarator; };
|
Declarator * GetDeclarator() const { return declarator; };
|
|
|
const char * GetDeclaredName(int skip);
|
const char * GetDeclaredName(int skip);
|
void Allocate(FILE * out, TypeSpecifier * spec);
|
void Allocate(FILE * out, TypeSpecifier * spec);
|
int EmitAutovars(FILE * out, TypeSpecifier * spec);
|
int EmitAutovars(FILE * out, TypeSpecifier * spec);
|
|
|
private:
|
private:
|
Declarator * declarator;
|
Declarator * declarator;
|
Initializer * initializer;
|
Initializer * initializer;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class Declaration : public Node
|
class Declaration : public Node
|
{
|
{
|
public:
|
public:
|
Declaration(TypeSpecifier * ds, InitDeclaratorList * il);
|
Declaration(TypeSpecifier * ds, InitDeclaratorList * il);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
void Allocate(FILE * out);
|
void Allocate(FILE * out);
|
int EmitAutovars(FILE * out);
|
int EmitAutovars(FILE * out);
|
|
|
private:
|
private:
|
TypeSpecifier * base_type;
|
TypeSpecifier * base_type;
|
InitDeclaratorList * init_list;
|
InitDeclaratorList * init_list;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class TypeName : public Node
|
class TypeName : public Node
|
{
|
{
|
public:
|
public:
|
TypeName(TypeSpecifier * ds, Declarator * ad);
|
TypeName(TypeSpecifier * ds, Declarator * ad);
|
TypeName(Specifier sp);
|
TypeName(Specifier sp);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
int Print(FILE * out) const;
|
int Print(FILE * out) const;
|
|
|
Declarator * GetDeclarator() const { return abs_declarator; };
|
Declarator * GetDeclarator() const { return abs_declarator; };
|
TypeSpecifier * GetTypeSpecifier() const { return decl_spec; };
|
TypeSpecifier * GetTypeSpecifier() const { return decl_spec; };
|
const char * GetDeclaredName();
|
const char * GetDeclaredName();
|
TypeName * GetFunReturnType();
|
TypeName * GetFunReturnType();
|
|
|
TypeName * AddressOf() const;
|
TypeName * AddressOf() const;
|
TypeName * ContentOf() const;
|
TypeName * ContentOf() const;
|
TypeName * GetElementType() const;
|
TypeName * GetElementType() const;
|
bool IsNumericType() const; // char, short, or int
|
bool IsNumericType() const; // char, short, or int
|
bool IsPointer() const;
|
bool IsPointer() const;
|
Expression * ArrayLength() const;
|
Expression * ArrayLength() const;
|
void SetArrayLength(int len);
|
void SetArrayLength(int len);
|
bool IsStruct() const;
|
bool IsStruct() const;
|
bool IsUnion() const;
|
bool IsUnion() const;
|
bool IsArray() const;
|
bool IsArray() const;
|
int GetPointeeSize() const;
|
int GetPointeeSize() const;
|
TypeName * GetMemberType(const char * member);
|
TypeName * GetMemberType(const char * member);
|
TypeName * FirstUnionMember(int size) const;
|
TypeName * FirstUnionMember(int size) const;
|
|
|
int GetFunReturnSize()
|
int GetFunReturnSize()
|
{ return decl_spec->GetFunReturnSize(abs_declarator); };
|
{ return decl_spec->GetFunReturnSize(abs_declarator); };
|
int GetSize() const
|
int GetSize() const
|
{ return decl_spec->GetSize(abs_declarator); };
|
{ return decl_spec->GetSize(abs_declarator); };
|
SUW GetSUW();
|
SUW GetSUW();
|
bool IsUnsigned() const;
|
bool IsUnsigned() const;
|
bool IsFunPtr() const
|
bool IsFunPtr() const
|
{ return ::IsFunPtr(abs_declarator); };
|
{ return ::IsFunPtr(abs_declarator); };
|
ParameterDeclarationList * GetParameters() const
|
ParameterDeclarationList * GetParameters() const
|
{ return ::GetParameters(abs_declarator); };
|
{ return ::GetParameters(abs_declarator); };
|
|
|
private:
|
private:
|
TypeSpecifier * decl_spec;
|
TypeSpecifier * decl_spec;
|
Declarator * abs_declarator;
|
Declarator * abs_declarator;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class Statement : public Node
|
class Statement : public Node
|
{
|
{
|
public:
|
public:
|
Statement(const char * ntype)
|
Statement(const char * ntype)
|
: Node(ntype)
|
: Node(ntype)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out) = 0;
|
virtual void Emit(FILE * out) = 0;
|
virtual bool NotEmpty() const { return true; };
|
virtual bool NotEmpty() const { return true; };
|
virtual bool EmitCaseJump(FILE * out, bool def, int loop, int size)
|
virtual bool EmitCaseJump(FILE * out, bool def, int loop, int size)
|
{ return false; };
|
{ return false; };
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class LabelStatement : public Statement
|
class LabelStatement : public Statement
|
{
|
{
|
public:
|
public:
|
LabelStatement(const char * n, Statement * stat)
|
LabelStatement(const char * n, Statement * stat)
|
: Statement("Label Statement"),
|
: Statement("Label Statement"),
|
label_name(n),
|
label_name(n),
|
statement(stat)
|
statement(stat)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
private:
|
private:
|
const char * label_name;
|
const char * label_name;
|
Statement * statement;
|
Statement * statement;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class CaseStatement : public Statement
|
class CaseStatement : public Statement
|
{
|
{
|
public:
|
public:
|
CaseStatement(Expression * exp, Statement * stat)
|
CaseStatement(Expression * exp, Statement * stat)
|
: Statement("case Statement"),
|
: Statement("case Statement"),
|
case_value(exp),
|
case_value(exp),
|
statement(stat)
|
statement(stat)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual bool EmitCaseJump(FILE * out, bool def, int loop, int size);
|
virtual bool EmitCaseJump(FILE * out, bool def, int loop, int size);
|
|
|
private:
|
private:
|
Expression * case_value; // case, or 0 for default
|
Expression * case_value; // case, or 0 for default
|
Statement * statement;
|
Statement * statement;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class CompoundStatement : public Statement
|
class CompoundStatement : public Statement
|
{
|
{
|
public:
|
public:
|
CompoundStatement(DeclarationList * dl, StatementList * sl)
|
CompoundStatement(DeclarationList * dl, StatementList * sl)
|
: Statement("CompoundStatement"),
|
: Statement("CompoundStatement"),
|
decl_list(dl),
|
decl_list(dl),
|
stat_list(sl)
|
stat_list(sl)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual bool NotEmpty() const { return decl_list || stat_list; };
|
virtual bool NotEmpty() const { return decl_list || stat_list; };
|
void EmitCaseJumps(FILE * out, int size);
|
void EmitCaseJumps(FILE * out, int size);
|
|
|
int EmitAutovars(FILE * out);
|
int EmitAutovars(FILE * out);
|
|
|
private:
|
private:
|
DeclarationList * decl_list;
|
DeclarationList * decl_list;
|
StatementList * stat_list;
|
StatementList * stat_list;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class ExpressionStatement : public Statement
|
class ExpressionStatement : public Statement
|
{
|
{
|
public:
|
public:
|
ExpressionStatement(Expression * expr)
|
ExpressionStatement(Expression * expr)
|
: Statement("ExpressionStatement"),
|
: Statement("ExpressionStatement"),
|
expression(expr)
|
expression(expr)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
virtual bool NotEmpty() const { return expression; };
|
virtual bool NotEmpty() const { return expression; };
|
|
|
Expression * GetExpression() const { return expression; };
|
Expression * GetExpression() const { return expression; };
|
|
|
private:
|
private:
|
Expression * expression;
|
Expression * expression;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class SwitchStatement : public Statement
|
class SwitchStatement : public Statement
|
{
|
{
|
public:
|
public:
|
SwitchStatement(Expression * cond, CompoundStatement * cas)
|
SwitchStatement(Expression * cond, CompoundStatement * cas)
|
: Statement("SwitchStatement"),
|
: Statement("SwitchStatement"),
|
condition(cond),
|
condition(cond),
|
case_stat(cas)
|
case_stat(cas)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
private:
|
private:
|
Expression * condition;
|
Expression * condition;
|
CompoundStatement * case_stat;
|
CompoundStatement * case_stat;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class IfElseStatement : public Statement
|
class IfElseStatement : public Statement
|
{
|
{
|
public:
|
public:
|
IfElseStatement(Expression * cond, Statement * ifs, Statement * els)
|
IfElseStatement(Expression * cond, Statement * ifs, Statement * els)
|
: Statement("IfElseStatement"),
|
: Statement("IfElseStatement"),
|
condition(cond),
|
condition(cond),
|
if_stat(ifs),
|
if_stat(ifs),
|
else_stat(els)
|
else_stat(els)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
private:
|
private:
|
Expression * condition;
|
Expression * condition;
|
Statement * if_stat;
|
Statement * if_stat;
|
Statement * else_stat;
|
Statement * else_stat;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class DoWhileStatement : public Statement
|
class DoWhileStatement : public Statement
|
{
|
{
|
public:
|
public:
|
DoWhileStatement(Statement * bdy, Expression * cond)
|
DoWhileStatement(Statement * bdy, Expression * cond)
|
: Statement("do while Statement"),
|
: Statement("do while Statement"),
|
condition(cond),
|
condition(cond),
|
body(bdy)
|
body(bdy)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
private:
|
private:
|
Expression * condition;
|
Expression * condition;
|
Statement * body;
|
Statement * body;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class WhileStatement : public Statement
|
class WhileStatement : public Statement
|
{
|
{
|
public:
|
public:
|
WhileStatement(Expression * cond, Statement * bdy)
|
WhileStatement(Expression * cond, Statement * bdy)
|
: Statement("while Statement"),
|
: Statement("while Statement"),
|
condition(cond),
|
condition(cond),
|
body(bdy)
|
body(bdy)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
private:
|
private:
|
Expression * condition;
|
Expression * condition;
|
Statement * body;
|
Statement * body;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class ForStatement : public Statement
|
class ForStatement : public Statement
|
{
|
{
|
public:
|
public:
|
|
|
ForStatement(ExpressionStatement * f1, ExpressionStatement * f2,
|
ForStatement(ExpressionStatement * f1, ExpressionStatement * f2,
|
Expression * f3, Statement * bdy)
|
Expression * f3, Statement * bdy)
|
: Statement("for Statement"),
|
: Statement("for Statement"),
|
for_1(f1),
|
for_1(f1),
|
for_2(f2),
|
for_2(f2),
|
for_3(f3),
|
for_3(f3),
|
body(bdy)
|
body(bdy)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
private:
|
private:
|
ExpressionStatement * for_1;
|
ExpressionStatement * for_1;
|
ExpressionStatement * for_2;
|
ExpressionStatement * for_2;
|
Expression * for_3;
|
Expression * for_3;
|
Statement * body;
|
Statement * body;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class GotoStatement : public Statement
|
class GotoStatement : public Statement
|
{
|
{
|
public:
|
public:
|
GotoStatement(const char * lab)
|
GotoStatement(const char * lab)
|
: Statement("goto Statement"),
|
: Statement("goto Statement"),
|
label_name(lab)
|
label_name(lab)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
private:
|
private:
|
const char * label_name;
|
const char * label_name;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class ReturnStatement : public Statement
|
class ReturnStatement : public Statement
|
{
|
{
|
public:
|
public:
|
ReturnStatement(Expression * expr)
|
ReturnStatement(Expression * expr)
|
: Statement("return Statement"),
|
: Statement("return Statement"),
|
retval(expr)
|
retval(expr)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
private:
|
private:
|
Expression * retval;
|
Expression * retval;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class ContStatement : public Statement
|
class ContStatement : public Statement
|
{
|
{
|
public:
|
public:
|
ContStatement(bool do_brk)
|
ContStatement(bool do_brk)
|
: Statement("break/continue Statement"),
|
: Statement("break/continue Statement"),
|
do_break(do_brk)
|
do_break(do_brk)
|
{};
|
{};
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
private:
|
private:
|
bool do_break; // true for break, false for continue
|
bool do_break; // true for break, false for continue
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
class FunctionDefinition : public Node
|
class FunctionDefinition : public Node
|
{
|
{
|
public:
|
public:
|
FunctionDefinition(TypeSpecifier * ds, Declarator * decl,
|
FunctionDefinition(TypeSpecifier * ds, Declarator * decl,
|
DeclarationList * dl);
|
DeclarationList * dl);
|
|
|
virtual void Emit(FILE * out);
|
virtual void Emit(FILE * out);
|
|
|
FunctionDefinition * SetBody(CompoundStatement * bdy)
|
FunctionDefinition * SetBody(CompoundStatement * bdy)
|
{ body = bdy; return this; };
|
{ body = bdy; return this; };
|
|
|
private:
|
private:
|
TypeName * ret_type;
|
TypeName * ret_type;
|
Declarator * fun_declarator;
|
Declarator * fun_declarator;
|
DeclarationList * decl_list;
|
DeclarationList * decl_list;
|
CompoundStatement * body;
|
CompoundStatement * body;
|
};
|
};
|
//-----------------------------------------------------------------------------
|
//-----------------------------------------------------------------------------
|
|
|
#endif
|
#endif
|
|
|