Modify a Function in C

[abhinav3]

Hey Guys,

Is it possible to inheritance in C??
I want to do the following thing.

I have a compiler.c file in which I have the following function:

void execute_program(struct statementNode * program)
{
    struct statementNode * pc = program;
    int op1, op2, result;

    while (pc != NULL)
    {
        switch (pc->stmt_type)
        {
            case NOOPSTMT:
                pc = pc->next;
                break;

            case PRINTSTMT:
                if (pc->print_stmt == NULL)
                {
                    print_debug("Error: pc points to a print statement but pc->print_stmt is null.\n");
                    exit(1);
                }
                if (pc->print_stmt->id == NULL)
                {
                    print_debug("Error: print_stmt->id is null.\n");
                    exit(1);
                }
                printf("%d\n", pc->print_stmt->id->value);
                pc = pc->next;
                break;

            case ASSIGNSTMT:
                if (pc->assign_stmt == NULL)
                {
                    print_debug("Error: pc points to an assignment statement but pc->assign_stmt is null.\n");
                    exit(1);
                }
                if (pc->assign_stmt->op1 == NULL)
                {
                    print_debug("Error: assign_stmt->op1 is null.\n");
                    exit(1);
                }
                if (pc->assign_stmt->op == PLUS || pc->assign_stmt->op == MINUS
                    || pc->assign_stmt->op == MULT || pc->assign_stmt->op == DIV)
                {
                    if (pc->assign_stmt->op2 == NULL)
                    {
                        print_debug("Error: right-hand-side of assignment is an expression but assign_stmt->op2 is null.\n");
                        exit(1);
                    }
                }
                if (pc->assign_stmt->lhs == NULL)
                {
                    print_debug("Error: assign_stmt->lhs is null.\n");
                    exit(1);
                }
                switch (pc->assign_stmt->op)
                {
                    case PLUS:
                        op1 = pc->assign_stmt->op1->value;
                        op2 = pc->assign_stmt->op2->value;
                        result = op1 + op2;
                        break;
                    case MINUS:
                        op1 = pc->assign_stmt->op1->value;
                        op2 = pc->assign_stmt->op2->value;
                        result = op1 - op2;
                        break;
                    case MULT:
                        op1 = pc->assign_stmt->op1->value;
                        op2 = pc->assign_stmt->op2->value;
                        result = op1 * op2;
                        break;
                    case DIV:
                        op1 = pc->assign_stmt->op1->value;
                        op2 = pc->assign_stmt->op2->value;
                        result = op1 / op2;
                        break;
                    case 0:
                        op1 = pc->assign_stmt->op1->value;
                        result = op1;
                        break;
                    default:
                        print_debug("Error: invalid value for assign_stmt->op (%d).\n", pc->assign_stmt->op);
                        exit(1);
                        break;
                }
                pc->assign_stmt->lhs->value = result;
                pc = pc->next;
                break;

            case IFSTMT:
                if (pc->if_stmt == NULL)
                {
                    print_debug("Error: pc points to an if statement but pc->if_stmt is null.\n");
                    exit(1);
                }
                if (pc->if_stmt->true_branch == NULL)
                {
                    print_debug("Error: if_stmt->true_branch is null.\n");
                    exit(1);
                }
                if (pc->if_stmt->false_branch == NULL)
                {
                    print_debug("Error: if_stmt->false_branch is null.\n");
                    exit(1);
                }
                if (pc->if_stmt->op1 == NULL)
                {
                    print_debug("Error: if_stmt->op1 is null.\n");
                    exit(1);
                }
                if (pc->if_stmt->op2 == NULL)
                {
                    print_debug("Error: if_stmt->op2 is null.\n");
                    exit(1);
                }
                op1 = pc->if_stmt->op1->value;
                op2 = pc->if_stmt->op2->value;
                switch (pc->if_stmt->relop)
                {
                    case GREATER:
                        if (op1 > op2)
                            pc = pc->if_stmt->true_branch;
                        else
                            pc = pc->if_stmt->false_branch;
                        break;
                    case LESS:
                        if (op1 < op2)
                            pc = pc->if_stmt->true_branch;
                        else
                            pc = pc->if_stmt->false_branch;
                        break;
                    case NOTEQUAL:
                        if (op1 != op2)
                            pc = pc->if_stmt->true_branch;
                        else
                            pc = pc->if_stmt->false_branch;
                        break;
                    default:
                        print_debug("Error: invalid value for if_stmt->relop (%d).\n", pc->if_stmt->relop);
                        exit(1);
                        break;
                }
                break;

            case GOTOSTMT:
                if (pc->goto_stmt == NULL)
                {
                    print_debug("Error: pc points to a goto statement but pc->goto_stmt is null.\n");
                    exit(1);
                }
                if (pc->goto_stmt->target == NULL)
                {
                    print_debug("Error: goto_stmt->target is null.\n");
                    exit(1);
                }
                pc = pc->goto_stmt->target;
                break;

            default:
                print_debug("Error: invalid value for stmt_type (%d).\n", pc->stmt_type);
                exit(1);
                break;
        }
    }
}

I have to make another .c file in which I have to use this function.
In the above given function I just need to add a new case for while and repeat statements. I can't change the above function in compiler.c file.
Please suggest me alternative for the above problem.

Thanks in advance

[laserlight]

I have to make another .c file in which I have to use this function.
In the above given function I just need to add a new case for while and repeat statements. I can't change the above function in compiler.c file.
Please suggest me alternative for the above problem.

From what I understand, if you could change the implementation of execute_program, you would simply add another case for switch (pc->stmt_type).

I may be mistaken, but I don't think you can accomplish what you want to do without changing the implementation of execute_program. If this were C++, the polymorphic behaviour would still require changing the implementation of execute_program, after which no further changes would be required to cater to new statement (sub)types.

If you were allowed to change the implementation of execute_program, then you could indeed implement inheritance/polymorphism in C to accomplish what you want, similiar to how it might be done in C++, e.g., the statementNode object might have a function pointer member that pointed to the right function for the subtype to do the specific action that you want to take.

[Hodor]

You're not allowed to (or cannot) change execute_program() at all? The problems, that I see, are that it's a void function and there are calls to exit() throughout it (although if the default case didn't call exit() I could see a way to do it)

Edit: actually, you could (sort of) do it. Just have a new function that parses your new values and if they fail then fallback onto execute_program(). It wouldn't be "morphism" in the way it's normally implement by, say, a C++ compiler but it'd work.

Actually, no. The silly while is in the function. Hmm.

[grumpy]

If you have the source code for your compiler, why are you not permitted to modify it for your purposes?

[Salem]

> In the above given function I just need to add a new case for while and repeat statements. I can't change the above function in compiler.c file.
So what's the problem?

You can synthesise any loop with an if statement and a goto statement, both of which are provided for you.