#include "translate.h"
#include "../Parser/ParseNode.h"


#include "Statement.h"
#include "Expression.h"
#include "Constant.h"
#include "Type.h"

int translate_driver(ParseNode *pn){
    // in effect, this function is a visitor of sorts

    if (pn == 0)
	exit(1);

    /* Type switching considered harmful */

    switch(pn->what_kind()){
    case ParseNode::Statement:
	translate((StatementNode *)pn);
	break;
    case ParseNode::Expression:
	translate((ExpressionNode *)pn);
	break;
    default:
	translate(pn);
	break;
    }

    return 0;
}

Expression *translate(ExpressionNode *en){
    Expression *expr;

    switch(en->what_kind()){
    case ParseNode::CompositeExpression:
	break;
    case ParseNode::Constant:
	expr = translate((ConstantNode *)en);
	break;
    case ParseNode::VarRef:
	cout << "It's a varref" << endl;
	break;
    case ParseNode::Operator:
	cout << "It's an operator" << endl;
	break;
    default:
	break;
    }

    return expr;
}

Statement *translate(StatementNode *sn){
    Statement *stmt = 0;

    switch(sn->get_type()){
    case StatementNode::Exp:
	translate(sn->get_control());
	break;
    case StatementNode::If:
	cout << "if" << endl;
	translate(sn->get_control());
	break;
    case StatementNode::Switch:
	cout << "switch" << endl;
	break;
    case StatementNode::Case:
	cout << "case" << endl;
	break;
    case StatementNode::Default:
	cout << "default" << endl;
	break;
    case StatementNode::Choose:
	cout << "choose" << endl;
	break;
    case StatementNode::Fallthru:
	cout << "fallthru" << endl;
	break;
    case StatementNode::While:
	cout << "while" << endl;
	break;
    case StatementNode::Do:
	cout << "do" << endl;
	break;
    case StatementNode::For:
	cout << "for" << endl;
	break;
    case StatementNode::Goto:
	cout << "goto" << endl;
	break;
    case StatementNode::Continue:
	cout << "continue" << endl;
	break;
    case StatementNode::Break:
	cout << "break" << endl;
	break;
    case StatementNode::Return:
	cout << "return" << endl;
	break;
    case StatementNode::Throw:
	cout << "throw" << endl;
	break;
    case StatementNode::Try:
	cout << "try" << endl;
	break;
    case StatementNode::Catch:
	cout << "catch" << endl;
	break;
    case StatementNode::Asm:
	cout << "asm" << endl;
	break;
    default:
	break;
    }

    return stmt;
}

ConstantExpr *translate(ConstantNode *cn){
    ConstantExpr *cnst;
    BasicType::Kind knd;

    struct Type::Qualifiers tq = {0,0,0};
    struct BasicType::Modifiers tm = {0,0,0,0};

    switch(cn->get_type()){
    case ConstantNode::Integer:
	knd = BasicType::Int;
	break;
    case ConstantNode::Float:
	knd = BasicType::Float;
	break;
    case ConstantNode::Character:
	knd = BasicType::Char;
	break;
    case ConstantNode::String:
	break;
    default:
	break;
    }

    Constant *c = new Constant(new BasicType(tq,tm,knd), cn->get_name());
    cnst = new ConstantExpr(*c);

    return cnst;
}

Expression *translate(CompositeExprNode *ce){
    return 0;
}

int translate(ParseNode *pn){
    cout << "In translate - parsenode" << endl;

    return 0;
}