codegen.c

#include <stdio.h>
#include "codegen.h"
#include "getSource.h"

#ifndef TBL
#define TBL
#include "table.h"
#endif

#define MAXCODE 200
#define MAXMEM 2000
#define MAXREG 20
#define MAXLEVEL 5

typedef struct inst {
  OpCode opCode;
  union {
      RelativeAddr addr;
      int value;
      Operator optr;
  } u;
} Inst;

static Inst code[MAXCODE];
static int codeIndex = -1;
static void printCode(int i);

int nextCode()
{
  return codeIndex + 1;
}

int genCodeWithValue(OpCode op, int value)
{
	codeIndex++;
	code[codeIndex].opCode = op;
	code[codeIndex].u.value = value;
	return(codeIndex);
}

int genCodeWithAddr(OpCode op, int tableIndex)
{
	codeIndex++;
	code[codeIndex].opCode = op;
	code[codeIndex].u.addr = relAddr(tableIndex);
	return(codeIndex);
}

int genCodeOperator(Operator operator)
{
	codeIndex++;
	code[codeIndex].opCode = opr;
	code[codeIndex].u.optr = operator;
	return(codeIndex);
}

int genCodeReturn()
{
	if (code[codeIndex].opCode == ret) return(codeIndex);
	codeIndex++;
	code[codeIndex].opCode = ret;
	code[codeIndex].u.addr.level = currentBlockLevel();
	code[codeIndex].u.addr.addr = functionParamCount();
	return(codeIndex);
}

void backPatch(int index)
{
  code[index].u.value = codeIndex + 1;
}

void listCode()
{
	int i;
	printf("\ncode\n");
	for(i=0; i<=codeIndex; i++){
		printf("%3d: ", i);
		printCode(i);
	}
}

void printCode(int i)
{
	int flag;
	switch (code[i].opCode) {
		case lit: printf("lit"); flag=1; break;
		case opr: printf("opr"); flag=3; break;
		case lod: printf("lod"); flag=2; break;
		case sto: printf("sto"); flag=2; break;
		case cal: printf("cal"); flag=2; break;
		case ret: printf("ret"); flag=2; break;
		case ict: printf("ict"); flag=1; break;
		case jmp: printf("jmp"); flag=1; break;
		case jpc: printf("jpc"); flag=1; break;
	}
	switch (flag) {
		case 1:
			printf(",%d\n", code[i].u.value);
			return;
	    case 2:
	    	printf(",%d", code[i].u.addr.level);
	    	printf(",%d\n", code[i].u.addr.addr);
	    	return;
	    case 3:
	    	switch (code[i].u.optr) {
	    		case neg:  printf(",neg\n");  return;
	    		case add:  printf(",add\n");  return;
	    		case sub:  printf(",sub\n");  return;
	    		case mul:  printf(",mul\n");  return;
	    		case div:  printf(",div\n");  return;
	    		case odd:  printf(",odd\n");  return;
	    		case eq:   printf(",eq\n");   return;
	    		case ls:   printf(",ls\n");   return;
	    		case gr:   printf(",gr\n");   return;
	    		case neq:  printf(",neq\n");  return;
	    		case lseq: printf(",lseq\n"); return;
	    		case greq: printf(",greq\n"); return;
	    		case wrt:  printf(",wrt\n");  return;
	    		case wrl:  printf(",wrl\n");  return;
	    	}
	}
}

void execute() {
  int stack[MAXMEM];
  int display[MAXLEVEL];
  int pc, top, lev, temp;
  Inst i;
  top = 0;
  pc = 0;
  stack[0] = 0;
  stack[1] = 0;
  display[0] = 0;

  do {
    i = code[pc++];
    switch (i.opCode) {
      case lit:
        stack[top++] = i.u.value;
        break;
      case lod:
        stack[top++] = stack[display[i.u.addr.level] + i.u.addr.addr];
        break;
      case sto:
        stack[display[i.u.addr.level] + i.u.addr.addr] = stack[--top];
        break;
      case cal:
        lev = i.u.addr.level + 1;
        stack[top] = display[lev];
        stack[top+1] = pc;
        display[lev] = top;
        pc = i.u.addr.addr;
        break;
      case ret:
        temp = stack[--top];
        top = display[i.u.addr.level];
        display[i.u.addr.level] = stack[top];
        pc = stack[top+1];
        top -= i.u.addr.addr;
        stack[top++] = temp;
        break;
      case ict:
        top += i.u.value;
        break;
      case jmp:
        pc = i.u.value;
        break;
      case jpc:
        if (stack[--top] == 0) pc = i.u.value;
        break;
      case opr:
      	switch(i.u.optr) {
      		case neg: stack[top-1] = -stack[top-1]; continue;
      		case add: --top;  stack[top-1] += stack[top]; continue;
      		case sub: --top; stack[top-1] -= stack[top]; continue;
      		case mul: --top;  stack[top-1] *= stack[top];  continue;
      		case div: --top;  stack[top-1] /= stack[top]; continue;
      		case odd: stack[top-1] = stack[top-1] & 1; continue;
      		case eq: --top;  stack[top-1] = (stack[top-1] == stack[top]); continue;
      		case ls: --top;  stack[top-1] = (stack[top-1] < stack[top]); continue;
      		case gr: --top;  stack[top-1] = (stack[top-1] > stack[top]); continue;
      		case neq: --top;  stack[top-1] = (stack[top-1] != stack[top]); continue;
      		case lseq: --top;  stack[top-1] = (stack[top-1] <= stack[top]); continue;
      		case greq: --top;  stack[top-1] = (stack[top-1] >= stack[top]); continue;
      		case wrt: printf("%d ", stack[--top]); continue;
      		case wrl: printf("\n"); continue;
      	}
    }
  } while (pc != 0);
}