#include "ast.h"

#include "code_gen.h"

#include "error.h"

#include "mem_pool.h"

#include "parser.h"

#include "token.h"

#include "evaluator.h"

static MemPoolImp<BinaryOp> binaryOpPool;

static MemPoolImp<ConditionalOp> conditionalOpPool;

static MemPoolImp<FuncCall> funcCallPool;

static MemPoolImp<Declaration> initializationPool;

static MemPoolImp<Object> objectPool;

static MemPoolImp<Identifier> identifierPool;

static MemPoolImp<Enumerator> enumeratorPool;

static MemPoolImp<Constant> constantPool;

static MemPoolImp<TempVar> tempVarPool;

static MemPoolImp<UnaryOp> unaryOpPool;

static MemPoolImp<EmptyStmt> emptyStmtPool;

static MemPoolImp<IfStmt> ifStmtPool;

static MemPoolImp<JumpStmt> jumpStmtPool;

static MemPoolImp<ReturnStmt> returnStmtPool;

static MemPoolImp<LabelStmt> labelStmtPool;

static MemPoolImp<CompoundStmt> compoundStmtPool;

static MemPoolImp<FuncDef> funcDefPool;

void Declaration::Accept(Visitor* v)

{

v->VisitDeclaration(this);

}

void EmptyStmt::Accept(Visitor* v) {

//assert(false);

//v->VisitEmptyStmt(this);

}

void LabelStmt::Accept(Visitor* v) {

v->VisitLabelStmt(this);

}

void IfStmt::Accept(Visitor* v) {

v->VisitIfStmt(this);

}

void JumpStmt::Accept(Visitor* v) {

v->VisitJumpStmt(this);

}

void ReturnStmt::Accept(Visitor* v) {

v->VisitReturnStmt(this);

}

void CompoundStmt::Accept(Visitor* v) {

v->VisitCompoundStmt(this);

}

void BinaryOp::Accept(Visitor* v) {

v->VisitBinaryOp(this);

}

void UnaryOp::Accept(Visitor* v) {

v->VisitUnaryOp(this);

}

void ConditionalOp::Accept(Visitor* v) {

v->VisitConditionalOp(this);

}

void FuncCall::Accept(Visitor* v) {

v->VisitFuncCall(this);

}

void Object::Accept(Visitor* v) {

v->VisitObject(this);

}

void Constant::Accept(Visitor* v) {

v->VisitConstant(this);

}

void Enumerator::Accept(Visitor* v)

{

v->VisitEnumerator(this);

}

void TempVar::Accept(Visitor* v) {

v->VisitTempVar(this);

}

void FuncDef::Accept(Visitor* v) {

v->VisitFuncDef(this);

}

void TranslationUnit::Accept(Visitor* v) {

v->VisitTranslationUnit(this);

}

Expr* Expr::MayCast(Expr* expr)

{

auto arrType = expr->Type()->ToArrayType();

if (arrType) {

auto pointer = Type::NewPointerType(arrType->Derived());

pointer->SetQual(Q_CONST);

return UnaryOp::New(expr->Tok(), Token::CAST, expr, pointer);

}

auto funcType = expr->Type()->ToFuncType();

if (funcType) {

auto pointer = Type::NewPointerType(funcType);

return UnaryOp::New(expr->Tok(), Token::CAST, expr, pointer);

}

return expr;

}

BinaryOp* BinaryOp::New(const Token* tok, Expr* lhs, Expr* rhs)

{

return New(tok, tok->Tag(), lhs, rhs);

}

BinaryOp* BinaryOp::New(const Token* tok, int op, Expr* lhs, Expr* rhs)

{

switch (op) {

case ',':

case '.':

case '=':

case '*':

case '/':

case '%':

case '+':

case '-':

case '&':

case '^':

case '|':

case '<':

case '>':

case Token::LEFT_OP:

case Token::RIGHT_OP:

case Token::LE_OP:

case Token::GE_OP:

case Token::EQ_OP:

case Token::NE_OP:

case Token::AND_OP:

case Token::OR_OP:

break;

default:

assert(0);

}

auto ret = new (binaryOpPool.Alloc()) BinaryOp(op, lhs, rhs);

ret->_pool = &binaryOpPool;

ret->TypeChecking();

return ret;

}

ArithmType* BinaryOp::Promote(void)

{

// Both lhs and rhs are ensured to be have arithmetic type

auto lhsType = _lhs->Type()->ToArithmType();

auto rhsType = _rhs->Type()->ToArithmType();

auto type = MaxType(lhsType, rhsType);

if (lhsType != type) {// Pointer comparation is enough!

_lhs = UnaryOp::New(_tok, Token::CAST, _lhs, type);

}

if (rhsType != type) {

_rhs = UnaryOp::New(_tok, Token::CAST, _rhs, type);

}

return type;

}

void BinaryOp::TypeChecking(void)

}

void BinaryOp::SubScriptingOpTypeChecking(void)

}

void BinaryOp::MemberRefOpTypeChecking(void)

{

_type = _rhs->Type();

}

void BinaryOp::MultiOpTypeChecking(void)

}

void BinaryOp::AdditiveOpTypeChecking(void)

}

void BinaryOp::ShiftOpTypeChecking(void)

}

void BinaryOp::RelationalOpTypeChecking(void)

}

void BinaryOp::EqualityOpTypeChecking(void)

}

void BinaryOp::BitwiseOpTypeChecking(void)

}

void BinaryOp::LogicalOpTypeChecking(void)

}

void BinaryOp::AssignOpTypeChecking(void)

}

UnaryOp* UnaryOp::New(const Token* tok,

int op, Expr* operand, ::Type* type)

{

auto ret = new (unaryOpPool.Alloc()) UnaryOp(op, operand, type);

ret->_pool = &unaryOpPool;

ret->TypeChecking();

return ret;

}

bool UnaryOp::IsLVal(void) {

}

void UnaryOp::TypeChecking(void)

}

void UnaryOp::IncDecOpTypeChecking(void)

}

void UnaryOp::AddrOpTypeChecking(void)

}

void UnaryOp::DerefOpTypeChecking(void)

}

void UnaryOp::UnaryArithmOpTypeChecking(void)

}

void UnaryOp::CastOpTypeChecking(void)

}

ConditionalOp* ConditionalOp::New(const Token* tok,

Expr* cond, Expr* exprTrue, Expr* exprFalse)

{

auto ret = new (conditionalOpPool.Alloc())

ConditionalOp(cond, exprTrue, exprFalse);

ret->_pool = &conditionalOpPool;

ret->TypeChecking();

return ret;

}

ArithmType* ConditionalOp::Promote(void)

{

auto lhsType = _exprTrue->Type()->ToArithmType();

auto rhsType = _exprFalse->Type()->ToArithmType();

auto type = MaxType(lhsType, rhsType);

if (lhsType != type) {// Pointer comparation is enough!

_exprTrue = UnaryOp::New(_tok, Token::CAST, _exprTrue, type);

}

if (rhsType != type) {

_exprFalse = UnaryOp::New(_tok, Token::CAST, _exprFalse, type);

}

return type;

}

void ConditionalOp::TypeChecking(void)

}

FuncCall* FuncCall::New(Expr* designator, const std::list<Expr*>& args)

{

auto ret = new (funcCallPool.Alloc()) FuncCall(designator, args);

ret->_pool = &funcCallPool;

ret->TypeChecking();

return ret;

}

void FuncCall::TypeChecking(void)

}

Identifier* Identifier::New(const Token* tok,

::Type* type, ::Scope* scope, enum Linkage linkage)

{

auto ret = new (identifierPool.Alloc())

Identifier(tok, type, scope, linkage);

ret->_pool = &identifierPool;

return ret;

}

Enumerator* Enumerator::New(const Token* tok, ::Scope* scope, int val)

{

auto ret = new (enumeratorPool.Alloc()) Enumerator(tok, scope, val);

ret->_pool = &enumeratorPool;

return ret;

}

Declaration* Declaration::New(Object* obj)

{

auto ret = new (initializationPool.Alloc()) Declaration(obj);

ret->_pool = &initializationPool;

return ret;

}

void Declaration::AddInit(int offset, Type* type, Expr* expr)

}

StaticInitializer Declaration::GetStaticInit(const Initializer& init)

}

Object* Object::New(const Token* tok,

::Type* type, ::Scope* scope, int storage, enum Linkage linkage)

{

auto ret = new (objectPool.Alloc())

Object(tok, type, scope, storage, linkage);

ret->_pool = &objectPool;

return ret;

}

Constant* Constant::New(const Token* tok, int tag, long val)

{

auto type = Type::NewArithmType(tag);

auto ret = new (constantPool.Alloc()) Constant(tok, type, val);

ret->_pool = &constantPool;

return ret;

}

Constant* Constant::New(const Token* tok, int tag, double val)

{

auto type = Type::NewArithmType(tag);

auto ret = new (constantPool.Alloc()) Constant(tok, type, val);

ret->_pool = &constantPool;

return ret;

}

Constant* Constant::New(const Token* tok, const std::string* val)

{

static auto derived = Type::NewArithmType(T_CHAR);

derived->SetQual(Q_CONST);

static auto type = Type::NewPointerType(derived);

auto ret = new (constantPool.Alloc()) Constant(tok, type, val);

ret->_pool = &constantPool;

static long tag = 0;

ret->_tag = tag++;

return ret;

}

TempVar* TempVar::New(::Type* type)

{

auto ret = new (tempVarPool.Alloc()) TempVar(type);

ret->_pool = &tempVarPool;

return ret;

}

EmptyStmt* EmptyStmt::New(void)

{

auto ret = new (emptyStmtPool.Alloc()) EmptyStmt();

ret->_pool = &emptyStmtPool;

return ret;

}

IfStmt* IfStmt::New(Expr* cond, Stmt* then, Stmt* els)

{

auto ret = new (ifStmtPool.Alloc()) IfStmt(cond, then, els);

ret->_pool = &ifStmtPool;

return ret;

}

CompoundStmt* CompoundStmt::New(std::list<Stmt*>& stmts, ::Scope* scope)

{

auto ret = new (compoundStmtPool.Alloc()) CompoundStmt(stmts, scope);

ret->_pool = &compoundStmtPool;

return ret;

}

JumpStmt* JumpStmt::New(LabelStmt* label)

{

auto ret = new (jumpStmtPool.Alloc()) JumpStmt(label);

ret->_pool = &jumpStmtPool;

return ret;

}

ReturnStmt* ReturnStmt::New(Expr* expr)

{

auto ret = new (returnStmtPool.Alloc()) ReturnStmt(expr);

ret->_pool = &returnStmtPool;

return ret;

}

LabelStmt* LabelStmt::New(void)

{

auto ret = new (labelStmtPool.Alloc()) LabelStmt();

ret->_pool = &labelStmtPool;

return ret;

}

FuncDef* FuncDef::New(const Token* tok, FuncType* type,

const std::list<Object*>& params, CompoundStmt* stmt)

{

auto ret = new (funcDefPool.Alloc()) FuncDef(tok, type, params, stmt);

ret->_pool = &funcDefPool;

return ret;

}