void CAipi_ExpParser::expression_unary_plus()
{
AfxMessageBox(_T("CASE UNARY"));
emit_expression(UNARY_PLUS);
getToken();
expression_factor();
emit_expression(UNARY_OP);
}
void CAipi_ExpParser::expression_unary_minus()
{
AfxMessageBox(_T("UNARY MINUS"));
emit_expression(UNARY_MINUS);
getToken();
expression_factor();
emit_expression(UNARY_OP);
}
void emitstmt(void* stmt){
Syntax *st = (Syntax*) stmt;
if(st->type == IF_STATEMENT){
int label = labelconditionid++;
char c[10];
emit_condition(st->if_statement->condition,label);
emitblock(st->if_statement->then);
sprintf(c,".LC%d",label);
emit_label(c);
}else if(st->type == WHILE_SYNTAX){
int labelcondition,labelblock;
labelcondition = labelconditionid++;
labelblock = labelconditionid++;
char c[10];
emit_instr_format("jmp",".LC%d",labelcondition);//to check condition
sprintf(c,".LC%d",labelblock);
emit_label(c);
emitblock(st->while_statement->body);
sprintf(c,".LC%d",labelcondition);
emit_label(c);
emit_condition(st->while_statement->condition,labelblock);
}else if(st->type == PRINT_STATEMENT){
emit_instr_format("leaq","%s(%%rip), %%rcx",st->printstmt->tag);
emit_ins("call","printf");
}else if(st->type == PRINTDEC_STATEMENT){
emit_expression(st->printexp->exp);
emit_ins("movq","%%rax, %%rdx");
emit_ins("leaq",".DEC(%%rip), %%rcx");//.DEC print dec format
emit_ins("call","printf");
}else if(st->type == PRINTHEX_STATEMENT){
emit_expression(st->printexp->exp);
emit_ins("movq","%%rax, %%rdx");
emit_ins("leaq",".HEX(%%rip), %%rcx");//.HEX print hex format
emit_ins("call","printf");
}else if(st->type == ASSIGNMENT){
int tempoffset = findOffsetVar(st->assignment->var_name);//not found is -1
if(tempoffset == -1){
OffsetVarmap* temp = (OffsetVarmap*)malloc(sizeof(OffsetVarmap));
temp->varname = st->assignment->var_name;
temp->offset = offset;
tempoffset = offset;
//printf("offset %d \n",offset);
offset = offset+8;
list_push(tablevar,temp);
}
emit_expression(st->assignment->expression);
emit_instr_format("movq","%%rax, -%d(%%rbp)",tempoffset);//result to variable.
}else if(st->type == VARIABLE){
OffsetVarmap *temp = (OffsetVarmap*)malloc(sizeof(OffsetVarmap));
temp->varname = st->variable->var_name;
temp->offset = offset;
offset = offset+8;
list_push(tablevar,temp);
}else{
fprintf(fp,"statement error");
}
}
void CAipi_ExpParser::operator_unary()
{
switch(m_lookahead)
{
case PLUS_SIGN:
emit_expression(PLUS_SIGN);
break;
case MINUS_SIGN:
emit_expression(MINUS_SIGN);
break;
}
}
void CAipi_ExpParser::expression_aritmetic()
{
expression_term();
while(true)
{
if( m_lookahead == PLUS_SIGN || m_lookahead == MINUS_SIGN )
{
int tk = m_lookahead;
//AfxMessageBox(_T("Arit get Token"));
getToken();
//AfxMessageBox(_T("Arit get Term"));
expression_term();
//AfxMessageBox(_T("Arit emit_expression"));
//CString str;
//str.Format(_T("Look Ahead...%d " ), m_lookahead);
//AfxMessageBox(str);
emit_expression(tk);
}
else
{
return;
}
}
}
void Prepreprocess::magic_quote(const std::string &line)
{
int end=line.length();
bool use_suffix=true;
state=START;
for (int pos=0; pos<end; ++pos) {
if (line[pos]=='$') {
if (pos == end-1) {
use_suffix=false;
break;
} else {
if (id0(line[pos+1])) {
++pos;
int begin=pos;
while (pos < end && id1(line[pos])) ++pos;
emit_expression(line.substr(begin,(pos-begin)));
--pos;
continue;
}
if (line[pos+1] == '(') {
++pos;
int begin=pos;
int parens=0;
while (pos < end) {
if (line[pos]=='(') ++parens;
if (line[pos]==')') {--parens; if (parens==0) { ++pos; break; } }
++pos;
}
emit_expression(line.substr(begin,(pos-begin)));
--pos;
continue;
}
if (line[pos+1]=='$') {
++pos;
}
}
}
emit_char(line[pos]);
}
emit_end(use_suffix);
}
void CAipi_ExpParser::expression_unary_decrement()
{
AfxMessageBox(_T("DECREMENT OPERATOR"));
getToken();
//It just apply to identifiers
if( m_lookahead = IDENTIFIER )
{
expression_factor();
emit_expression(DEC_OP);
}
}
void CAipi_ExpParser::type_name()
{
//CString str;
//str.Format(_T("SPECIFIER_QUALIFIER_LIST...%d " ), m_lookahead);
//AfxMessageBox(str);
switch(m_lookahead)
{
case AIPI_CHAR:
emit_expression(AIPI_CHAR);
break;
case AIPI_SHORT:
emit_expression(AIPI_SHORT);
break;
case AIPI_INT:
emit_expression(AIPI_INT);
break;
case AIPI_LONG:
emit_expression(AIPI_LONG);
break;
case AIPI_FLOAT:
emit_expression(AIPI_FLOAT);
break;
case AIPI_DOUBLE:
emit_expression(AIPI_DOUBLE);
break;
}
}
void CAipi_ExpParser::expression_atom_identifier()
{
emit_expression(IDENTIFIER);
getToken();
if( m_lookahead == INC_OP )
{
expression_unary_increment();
}
if( m_lookahead == DEC_OP )
{
expression_unary_decrement();
}
}
void Prepreprocess::emit_end(bool use_suffix) {
if (use_suffix) emit_expression(suffix);
if (state == SEPARATED) {
(*out) << "\"";
state=LITERAL;
}
if (state == LITERAL) {
(*out) << "\"";
state=READY;
}
if (state == READY) {
(*out) << ";" << std::endl;
state = START;
}
}
void CAipi_ExpParser::operator_assigment()
{
switch(m_lookahead)
{
case EQUAL:
emit_expression(EQUAL);
break;
case MUL_ASSIGN:
emit_expression(MUL_ASSIGN);
break;
case DIV_ASSIGN:
emit_expression(DIV_ASSIGN);
break;
case ADD_ASSIGN:
emit_expression(ADD_ASSIGN);
break;
case SUB_ASSIGN:
emit_expression(SUB_ASSIGN);
break;
}
}
void CAipi_ExpParser::expression_logical_and()
{
expression_equality();
while(true)
{
if( m_lookahead == AND_OP )
{
getToken();
expression_equality();
emit_expression(AND_OP);
}
else
{
return;
}
}
}
void CAipi_ExpParser::expression_relational()
{
expression_aritmetic();
while(true)
{
if( m_lookahead == LT || m_lookahead == LE || m_lookahead == GT || m_lookahead == GE )
{
int tk = m_lookahead;
getToken();
expression_aritmetic();
emit_expression(tk);
}
else
{
return;
}
}
}
void CAipi_ExpParser::expression_term()
{
expression_factor();
while(true)
{
if( m_lookahead == ASTERIC || m_lookahead == SLASH || m_lookahead == PERCENT )
{
int tk = m_lookahead;
getToken();
expression_factor();
emit_expression(tk);
}
else
{
return;
}
}
}
void CAipi_ExpParser::expression_equality()
{
expression_relational();
while(true)
{
if( m_lookahead == ET || m_lookahead == NE )
{
int tk = m_lookahead;
getToken();
expression_relational();
emit_expression(tk);
}
else
{
return;
}
}
}
void emit_expression(Syntax *exp){
if (exp->type == UNARY_OPERATOR) {
UnaryExpression *unary_syntax = exp->unary_expression;
emit_expression(unary_syntax->expression);
if (unary_syntax->unary_type == BITWISE_NEGATION) {
emit_ins("notq", "%%rax");
} else {
emit_ins("testq", "$0xFFFFFFFF, %%rax");
emit_ins("setz", "%%al");
}
} else if (exp->type == IMMEDIATE) {
//may be fix 64 bit
emit_instr_format("movq", "$%d, %%rax", exp->immediate->value);
} else if (exp->type == VARIABLE) {
int tempoffset = findOffsetVar(exp->variable->var_name);
emit_instr_format("movq", "-%d(%%rbp), %%rax",tempoffset);
} else if (exp->type == BINARY_OPERATOR) {
BinaryExpression *binary_syntax = exp->binary_expression;
char l[20];
char r[20];//digit no exceed 20 digit.
if(binary_syntax->left->type == VARIABLE){
int os = findOffsetVar(binary_syntax->left->variable->var_name);
if(os == -1)
printf("%s not initialize",binary_syntax->left->variable->var_name);
sprintf(l,"-%d(%%rbp)",os);
}else if(binary_syntax->left->type == IMMEDIATE){
sprintf(l,"$%d",binary_syntax->left->immediate->value);
}else{
emit_expression(binary_syntax->left);
}
if(binary_syntax->right->type == VARIABLE){
int os = findOffsetVar(binary_syntax->right->variable->var_name);
if(os == -1)
printf("%s not initialize",binary_syntax->right->variable->var_name);
sprintf(r,"-%d(%%rbp)",os);
}else if(binary_syntax->right->type == IMMEDIATE){
sprintf(r,"$%d",binary_syntax->right->immediate->value);
}else{
emit_expression(binary_syntax->right);
}
/*
int stack_offset = ctx->stack_offset;
ctx->stack_offset -= WORD_SIZE;
emit_instr(out, "sub", "$4, %esp");
write_syntax(out, binary_syntax->left, ctx);
emit_instr_format(out, "mov", "%%eax, %d(%%ebp)", stack_offset);
write_syntax(out, binary_syntax->right, ctx);
*/
emit_instr_format("movq", "%%rax ,%%r8");//bug
emit_instr_format("movq","%s ,%%rax",l);
if (binary_syntax->binary_type == MULTIPLICATION) {
emit_instr_format("imulq", "%s ,%%rax",r);
} else if (binary_syntax->binary_type == ADDITION) {
emit_instr_format("addq", "%s ,%%rax",r);
} else if (binary_syntax->binary_type == SUBTRACTION) {
emit_instr_format("movq", "%s, %%r10", r);
emit_ins("subq", "%%r10, %%rax");
//emit_instr_format("movq", "%s, %%rax", r);
} else if (binary_syntax->binary_type == DIVIDE) {
emit_ins("cltd",NULL);
emit_instr_format("idivl","%s",r);
} else if (binary_syntax->binary_type == MODULO){
emit_ins("cltd",NULL);
emit_instr_format("idivl","%s",r);
emit_ins("movq","%rdx, %rax");
} else{
printf("expression error");
}
}
}
void CAipi_ExpParser::expression_atom_literal()
{
emit_expression(LITERAL);
getToken();
}
void emit_expression(expr *e) {
// A NULL pointer is the same as the empty list.
if (e == NULL) {
printf("()");
return;
}
switch (e->type) {
// String expressions are printed out in quotes
case STRING_EXPR:
printf("\"%s\"", e->string_value);
break;
// Int expressions are directly printed
case INT_EXPR:
printf("%d", e->int_value);
break;
// Boolean expressions either print TRUE or FALSE
case BOOL_EXPR:
if (e->boolean_value)
printf("TRUE");
else
printf("FALSE");
break;
// Symbols are directly printed
case SYMBOL_EXPR:
printf("%s", e->string_value);
break;
// Lists are printed, wrapped in parentheses
case CELL_EXPR:
printf("(");
for (struct expr *curr = e; curr != NULL; curr = curr->tail) {
emit_expression(curr->head);
if (curr->tail != NULL)
printf(" ");
}
printf(")");
break;
// Builtin-in function
case BUILTIN_EXPR:
printf("<built-in function>");
break;
// User-defined function object
case FUNC_EXPR:
printf("<%s args: ", e->ismacro ? "macro" : "function");
emit_expression(e->arguments);
printf(" body: ");
emit_expression(e->body);
printf(">");
break;
// Unkown expression type
default:
printf("UNKOWN_EXPR");
break;
}
}
void CAipi_ExpParser::expression_atom_constant()
{
emit_expression(DIGIT);
getToken();
}
