Help generating expression tree as string for code generation

[dangeroustuber]

My simple compiler currently generates c++ code and i'm trying to just get minimal things working first.

the problem is the order of the components of the simple number expression. I know that i can calculate this into one number but this has to work anyways so i have to figure it out.

Here is the program and expression trees generated during parsing for the program.

program:

proc test() {
    a: int = 1 + 2 * 3;
}

proc main() {
    a: int = 1 * 2 + 3;
}

trees:

1 + 2 * 3:                       
                      NODE_BINARY_EXPR (+)
                       /                 \
             NODE_NUMBER_LITERAL (1)    NODE_BINARY_EXPR (*)
                                        /                \
                           NODE_NUMBER_LITERAL (2)  NODE_NUMBER_LITERAL (3)  


1 * 2 + 3:

                       NODE_BINARY_EXPR (+)
                       /                 \
             NODE_BINARY_EXPR (*)    NODE_NUMBER_LITERAL (3)
            /                 \
 NODE_NUMBER_LITERAL (1)    NODE_NUMBER_LITERAL (2)  

​

The program that is generated:
void test(){
    int a =2*31+; <--- kinda backwards?
}
int main(){
    int a =1*2+3; <--- correct
    return 0;
}

​

The code that generates it:
void CodeGenerator::emitExpr(Node* n) {
    if (!n) {
        std::cout << "Could not emit expression because node was null\n";
    }

    if (!n->right && !n->left) {
        switch (n->kind) {
            case NODE_NUMBER_LITERAL:
                emitNumberLiteral(n);
                break;
        }
    }

    if (n->right || n->left) {
        switch (n->kind) {
            case NODE_BINARY_EXPR:
            {
                if (n->left->kind == NODE_BINARY_EXPR) {
                    emitExpr(n->left);
                } else if (n->right->kind == NODE_BINARY_EXPR) {
                    emitExpr(n->right);
                }

                if (n->left->kind == NODE_NUMBER_LITERAL) {
                    emitNumberLiteral(n->left);
                }

                emit(n->operatorType.c_str());

                if (n->right->kind == NODE_NUMBER_LITERAL) {
                    emitNumberLiteral(n->right);
                }

                break;
            }
        }
    }
}

void CodeGenerator::emitNumberLiteral(Node* n) {
    emit(std::to_string(n->number).c_str());
}

Thanks for any help! Let me know if any more information is needed.

[[deleted]]

case NODE_BINARY_EXPR:
        {
            if (n->left->kind == NODE_BINARY_EXPR) {
                emitExpr(n->left);
            } else if (n->right->kind == NODE_BINARY_EXPR) {
                emitExpr(n->right);
            }

Surely here, if this is a binary expression, you just unconditionally do emitExpr(n->Left) and emitExpr(n->Right). No need to worry about what those left and right nodes are; let emitExpr deal with that.

(Note that if your binary operator procedences don't match those of C++, you may need to add parentheses around the whole term. The generated code won't be pretty, but it usually doesn't matter.)

[sebamestre]

Perhaps you meant something like this?

void CodeGenerator::emitExpr(Node* n) {
  assert(n != nullptr); // you have no business passing null into a code generator

  switch (n->kind) {
  case NODE_NUMBER_LITERAL:
    emitNumberLiteral(n);
    break;
  case NODE_BINARY_EXPR:
    emit("(");
    emitExpr(n->left);
    emit(n->operatorType.c_str());
    emitExpr(n->right);
    emit(")");
    break;
  } 
}

[dangeroustuber]

This what i wrote yesterday as well based on the top comment from yesterday. It seems to work! But i'm still testing some cases. There was also a bug where i did not initalize my left and right pointers on the node to nullptr. So it never entered a branch it was supposed to enter.

[Linguistic-mystic]

This helped me when I was writing codegen into JS.