--- /dev/null
+SHELL := bash
+CC := /usr/lib/ccache/gcc
+NAME := gesamt_arm
+CFLAGS := -ansi -pedantic -D_GNU_SOURCE -g
+OBJS := scanner.o parser.o symtable.o code.o chelper.o tree.o
+
+all: $(NAME)
+
+$(NAME): $(OBJS)
+ @echo " LINK $@"
+ @$(CC) -o $@ $(OBJS) -lfl
+
+scanner.c: oxout.l
+ @echo " FLEX $<"
+ @flex -o$@ $<
+
+#dirty deps ;)
+%.o: %.c parser.h symtable.h chelper.h tree.h
+ @echo " CC $<"
+ @cp $< tmp.c
+ @$(CC) -c $(CFLAGS) $< #-Wall
+ @rm tmp.c
+
+parser.c: oxout.y chelper.h tree.h
+ @echo " YACC $<"
+ @yacc -t -v -d $< -o $@
+
+parser.h: parser.c
+
+oxout.y oxout.l: parser.y scanner.lex
+ @echo " OX $^"
+ @ox $^
+
+%.c: %.bfe chelper.h tree.h
+ @echo " IBURG $<"
+ @bfe < $< | iburg > $@
+
+.PHONY: clean
+clean:
+ rm -f $(NAME) $(OBJS) scanner.c parser.{h,c,output} oxout.{y,l,h} code.c
+
+1test:
+ ~/test/scripts/modlvatest_$(NAME).sh 2>&1
+
+lvatest:
+ /usr/ftp/pub/ublu/test/$(NAME)/test 2>&1
+
+bench:
+ ~/test/scripts/bench.sh $(NAME)
--- /dev/null
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include "chelper.h"
+#include "tree.h"
+
+#if 0
+#define DDCHELP
+#endif
+
+/* TODO */
+#define REGLEN 5
+static char *regsppc[] = {"r10", "r11", "r12", "r13", "r14"};
+
+/* ja, dirty.. */
+static char *akt_func_name = (char*) NULL;
+static char need_stack = 0;
+
+void func_header(char *s, int vars, int parms, int call)
+{
+ printf("\t.globl %1$s\n\t.type %1$s, %%function\n%1$s:\n", s);
+ printf("\t@ vars: %i, parms: %i, call(bool): %i\n", vars, parms, call);
+ akt_func_name = s;
+
+ need_stack = (vars || parms) && call;
+ if(need_stack) {
+ /* save the link register */
+ printf("\tmflr 0; stw 0,-8(1)\n");
+ /* create the stack */
+ printf("\tstwu 1, -80(1)\n");
+ }
+}
+
+char *get_func_name(void)
+{
+ return akt_func_name;
+}
+
+void func_footer(void)
+{
+ if(need_stack) {
+ /* remove stack frame */
+ printf("\taddi 1,1,80\n");
+ /* restore link register */
+ printf("\tlwz 0,-8(1); mtlr 0\n");
+ }
+ printf("\tbx lr\n\n\n");
+}
+
+void move(char *src, char *dst)
+{
+ if(src == (char*) NULL) return;
+ if(strcmp(src,dst) != 0) {
+ printf("\tmov %s, %s\n", dst, src);
+ }
+}
+
+void moveimm(long imm, char *dst)
+{
+ static int constlbl = 1;
+ if((imm > 65536-1) || (imm < -65536)) {
+ printf("\t.align 2\n\t.CONSTLBL%i\n\t.word %i\n", constlbl++);
+ printf("\tldr %s, .CONSTLBL%i\n", dst, constlbl);
+ } else {
+ /* just low word */
+ printf("\t%s %s, #%d\n", imm >= 0 ? "mov" : "mvn", dst, imm >= 0 ? imm : (-1 * imm) - 1);
+ }
+}
+
+char *next_reg(char *s, int params)
+{
+ int i = 0;
+ if (s != (char*) NULL) {
+ while(strcmp(s, regsppc[i]) != 0) {
+ i = (i+1) % REGLEN;
+ }
+ i = (i+1) % REGLEN;
+ }
+#ifdef DDCHELP
+ fprintf(stderr, "next_reg(): %s (bei %i parameter)\n", regsppc[i], params);
+#endif
+ return regsppc[i];
+}
+
+char *reg_64to8l(char *s)
+{
+ fprintf(stderr, "reg_64to8l(): sollte nicht passieren\n");
+ exit(4);
+ return "";
+}
+
+char *param_reg(int num)
+{ /* TODO */
+ char *regs[] = {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9"};
+ return regs[num];
+}
+
--- /dev/null
+#ifndef __CHELPER_H
+#define __CHELPER_H
+
+void func_header(char *s, int vars, int parms, int call);
+char *get_func_name(void);
+void func_footer(void);
+char *next_reg(char *s, int params);
+char *param_reg(int num);
+char *reg_64to8l(char *s);
+void move(char *src, char *dest);
+#endif
--- /dev/null
+%{
+#define BFEHAX
+
+/* macros zum registerzugriff bei kinder */
+#define KID_REG(A) bnode->kids[A]->reg
+#define KIDKID_REG(A,B) bnode->kids[A]->kids[B]->reg
+#define KIDKIDKID_REG(A,B,C) bnode->kids[A]->kids[B]->kids[C]->reg
+
+/* macros zum wertezugriff bei kindern */
+#define KID_VAL(A) bnode->kids[A]->val
+#define KIDKID_VAL(A,B) bnode->kids[A]->kids[B]->val
+#define KIDKIDKID_VAL(A,B,C) bnode->kids[A]->kids[B]->kids[C]->val
+
+#define KID_PARM(A) bnode->kids[A]->param_index
+#define KIDKID_PARM(A,B) bnode->kids[A]->kids[B]->param_index
+#define KIDKIDKID_PARM(A,B,C) bnode->kids[A]->kids[B]->kids[C]->param_index
+
+/* macros zum zugriff des aktuellen knotens */
+#define BN_REG bnode->reg
+#define BN_VAL bnode->val
+
+/* wenn sich ein parameter auf der "leseseite" (also links bei at&t syntax)
+ * befindet, dann soll dieses register verwendet werden */
+#define KIDREG2PARM(A) if(bnode->kids[A]->param_index > -1) { bnode->kids[A]->reg = param_reg(bnode->kids[A]->param_index); }
+#define KIDKIDREG2PARM(A,B) if(bnode->kids[A]->kids[B]->param_index > -1) { bnode->kids[A]->kids[B]->reg = param_reg(bnode->kids[A]->kids[B]->param_index); }
+#define KIDKIDKIDREG2PARM(A,B,C) if(bnode->kids[A]->kids[B]->kids[C]->param_index > -1) { bnode->kids[A]->kids[B]->kids[C]->reg = param_reg(bnode->kids[A]->kids[B]->kids[C]->param_index); }
+
+/* wenn sich ein parameter auf der "schreibeseite" befindet (also rechts bei
+ * at&t syntax), dann muss es vorher in ein temporaeres register gemovt werden */
+#define KIDREG2ID(A) if(bnode->kids[A]->op == O_ID && bnode->kids[A]->param_index > -1) move(param_reg(bnode->kids[A]->param_index), bnode->kids[A]->reg);
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "tree.h"
+#include "chelper.h"
+
+void gen_e_eno(struct treenode *bnode, char *instr)
+{
+ printf("\t@ gen_e_eno(%s)\n", instr);
+ KIDREG2PARM(0);
+ KIDREG2PARM(1);
+ printf("\t%s %s, %s, %s\n", instr, BN_REG, KID_REG(0), KID_REG(1));
+}
+
+void gen_id_eno(struct treenode *bnode)
+{
+ printf("\t@gen_id_eno\n");
+ KIDKIDREG2PARM(1,0);
+ KIDKIDREG2PARM(1,1);
+ KIDREG2PARM(0);
+
+ printf("\tsub %s,%s,%s\n", BN_REG, KID_REG(0), KIDKID_REG(1,1));
+ printf("\tsub %s,%s,%s\n", BN_REG, BN_REG, KIDKID_REG(1,0));
+}
+
+void gen_e_imm(struct treenode *bnode, char *instr)
+{
+ printf("\t@gen_e_imm(%s)\n", instr);
+ KIDREG2PARM(0);
+ KIDREG2ID(1);
+ /* man kann sich ein move der konstante bei der multiplikation ersparen */
+ if(strcmp(instr, "mullw") == 0) {
+ if(KID_VAL(1) == 1 && strcmp(KID_REG(0), BN_REG) == 0) {
+ printf("\t@multiplikation mit 1 wegoptimiert\n");
+ } else {
+ if(KID_VAL(1) > (65536)-1 || KID_VAL(1) < -65536) {
+ moveimm(KID_VAL(1), next_reg(BN_REG,0));
+ printf("\tmul %s, %s, %s\n", BN_REG, KID_REG(0), next_reg(BN_REG,0));
+ } else {
+ printf("\tmul %s, %s, #%d\n", BN_REG, KID_REG(0), KID_VAL(1));
+ }
+ }
+ } else {
+ if(strcmp(instr, "sub") == 0 && KID_VAL(1) == 0) {
+ printf("\t@subtraktion mit 0 wegoptimiert\n");
+ move(KID_REG(0), BN_REG);
+ } else {
+ if(KID_VAL(1) > (65536)-1 || KID_VAL(1) < -65536) {
+ moveimm(KID_VAL(1), next_reg(BN_REG,0));
+ printf("\t%s %s, %s, %s\n", instr, BN_REG, KID_REG(0), next_reg(BN_REG,0));
+ } else {
+ printf("\t%s %s, %s, #%d\n", instr, BN_REG, KID_REG(0), KID_VAL(1));
+ }
+ }
+ }
+}
+
+void gen_imm_eno(struct treenode *bnode, char *instr)
+{
+ printf("\t@gen_imm_eno(%s)\n", instr);
+ KIDREG2ID(0);
+ KIDREG2PARM(1);
+ /* man kann sich ein move der konstante bei der multiplikation ersparen */
+ if(strcmp(instr, "mul") == 0) {
+ if(KID_VAL(0) == 1 && strcmp(KID_REG(1), BN_REG) == 0) {
+ printf("\t@multiplikation mit 1 wegoptimiert\n");
+ } else {
+ if(KID_VAL(0) > (65536)-1 || KID_VAL(0) < -65536) {
+ moveimm(KID_VAL(0), next_reg(BN_REG,0));
+ printf("\tmul %s, %s, %s\n", BN_REG, KID_REG(1), next_reg(BN_REG,0));
+ } else {
+ printf("\tmul %s, %s, #%d\n", BN_REG, KID_REG(1), KID_VAL(0));
+ }
+ }
+ } else { /* addq */
+ /* TODO: imm check einbauen */
+ printf("\tadd %s, %s, #%d\n", BN_REG, KID_REG(1), KID_VAL(0));
+ }
+}
+
+void gen_eqless(struct treenode *bnode, char *op, short e0, short e1, short deep)
+{
+ printf("\t@gen_eqless_%i%i @ %i (op: %s)\n", e0, e1, deep, op);
+ if(e0) { KIDREG2PARM(0); } else { moveimm(KID_VAL(0), BN_REG); }
+ if(e1) { KIDREG2PARM(1); }
+ if(strcmp(op,"e")==0 && bnode->kids[1]->op == O_NULL) {
+ /* not */
+ printf("\tcmp %s, #0\n", KID_REG(0));
+ printf("\tmoveq %s, #1\n", BN_REG);
+ printf("\tmovne %s, #0\n", BN_REG);
+ } else {
+ if(!e1) {
+ moveimm(KID_VAL(1), KID_REG(1));
+ }
+ if(strcmp(op, "e")==0) {
+ /* eq */
+ printf("\tcmp %s,%s\n", KID_REG(0), KID_REG(1));
+ printf("\tmoveq %s, #1\n", BN_REG);
+ printf("\tmovne %s, #0\n", BN_REG);
+ } else if(strcmp(op, "l")==0 || strcmp(op, "g")==0) {
+ /* less */
+ printf("\tcmp %s, %s\n", KID_REG(1), KID_REG(0));
+ printf("\tmovle %s, #0\n", BN_REG);
+ printf("\tmovgt %s, #1\n", BN_REG);
+ }
+ }
+}
+
+void gen_subspecial(struct treenode *bnode, short e)
+{
+ /* tritt z.b. bei snafu_05.0 auf */
+ printf("\t@gen_subspecial(%i)\n", e);
+ KIDREG2ID(0);
+ KIDKIDREG2PARM(1,0);
+
+ /* TODO: Loong@ codea_snafu_03.0 */
+
+ if(e) {
+ if(KIDKID_VAL(1,0) != 0) {
+ printf("\tsubi %s,%s,%d\n", BN_REG, BN_REG, KIDKID_VAL(1,0));
+ }
+ } else {
+ printf("\tsub %s,%s,%s\n", BN_REG, BN_REG, KIDKID_REG(1,0));
+ }
+ if(e) KIDKIDREG2PARM(1,1);
+ printf("\tadd %s,%s,%s\n", BN_REG, BN_REG, KIDKID_REG(1,1));
+}
+
+void assign_var(struct treenode *bnode)
+{
+ printf("\t@assign_var\n");
+ KIDREG2PARM(1);
+ if (strcmp(bnode->kids[0]->kids[0]->name, bnode->kids[1]->name) != 0) {
+ KIDKIDREG2PARM(0,0);
+ printf("\tmr %s,%s\n", KID_REG(1), KIDKID_REG(0,0));
+ } /*else: x := x - 1 geht in einem befehl */
+ printf("\tsubi %s,%s,%d\n", KID_REG(1), KID_REG(1), KIDKID_VAL(0,1));
+}
+
+/* ... dirty */
+static short sc[8] = {0};
+void make_call(struct treenode *bnode)
+{
+ int j;
+ printf("\t@params pushen\n");
+ for(j = 0; j < bnode->soffset; j++) {
+ if(sc[j] == 1) {
+ printf("\tlwz 20,%d(1)\n", j*4);
+ printf("\tstw %s,%d(1)\n", param_reg(j), j*4);
+ printf("\tmr %s,20\n", param_reg(j));
+ } else if (sc[j] == 0) {
+ printf("\tstw %s,%d(1)\n", param_reg(j), j*4);
+ }
+ }
+ printf("\t@vars pushen\n");
+ for(j = bnode->soffset; j < bnode->soffset + bnode->vars; j++) {
+ printf("\tstw %s,%d(1)\n", param_reg(j), j*4);
+ }
+
+ /* TODO: schoener machen... */
+ if(strcmp(BN_REG, "14")!=0) {
+ printf("\t@tmp register pushen\n");
+ printf("\tstw 14,52(1)\n");
+ if(strcmp(BN_REG, "15")!=0) {
+ printf("\tstw 15,56(1)\n");
+ if(strcmp(BN_REG, "16")!=0) {
+ printf("\tstw 16,60(1)\n");
+ }
+ }
+ }
+
+ printf("\tbl %s\n", bnode->name);
+ move("r0", BN_REG);
+
+ if(strcmp(BN_REG, "14")!=0) {
+ printf("\t@tmp register poppen\n");
+ if(strcmp(BN_REG, "15")!=0) {
+ if(strcmp(BN_REG, "16")!=0) {
+ printf("\tlwz 16,60(1)\n");
+ }
+ printf("\tlwz 15,56(1)\n");
+ }
+ printf("\tlwz 14,52(1)\n");
+ }
+
+ printf("\t@vars poppen\n");
+ for(j = bnode->soffset + bnode->vars - 1; j > bnode->soffset - 1; j--) {
+ printf("\tlwz %s,%d(1)\n", param_reg(j), j*4);
+ }
+
+ printf("\t@params poppen\n");
+ for(j = bnode->soffset - 1; j >= 0; j--) {
+ if(sc[j] == 0)
+ printf("\tlwz %s,%d(1)\n", param_reg(j), j*4);
+ }
+ for(j = 0; j < bnode->soffset; j++) {
+ if(sc[j] > 0)
+ printf("\tlwz %s,%d(1)\n", param_reg(j), j*4);
+ }
+
+ /* clear stack control array */
+ for(j = 0; j < sizeof sc / sizeof sc[0]; j++)
+ sc[j] = 0;
+}
+
+void prep_arg(struct treenode *bnode, int moveit)
+{
+ printf("\t@args-nr-> %i (%%%s) [moveit= %i]\n", bnode->soffset, param_reg(bnode->soffset), moveit);
+ sc[bnode->soffset] = 1;
+ if(moveit) { /* expr */
+ if((BN_REG == (char *) NULL) || (bnode->kids[1] != TREENULL && bnode->kids[1]->op == O_ID && bnode->kids[1]->kids[0] == TREENULL && bnode->kids[1]->kids[1] == TREENULL)) {
+ if(bnode->kids[1]->name != (char *) NULL && strcmp(bnode->kids[1]->name,"this")!=0) {
+ KIDREG2PARM(1);
+ printf("\tstw %s,%d(1)\n", KID_REG(1),bnode->soffset*4);
+ } else {
+ printf("\tstw %s,%d(1)\n", param_reg(bnode->soffset), bnode->soffset*4);
+ sc[bnode->soffset] = 2;
+ }
+ } else {
+ printf("\tstw %s,%d(1)\n", BN_REG, bnode->soffset*4);
+ }
+ } else { /* just O_ID */
+ KIDREG2PARM(0);
+ printf("\tstw %s,%d(1)\n", KID_REG(0), bnode->soffset*4);
+ }
+}
+
+void field_lolbfefail(struct treenode *bnode)
+{
+ printf("\t@ field(expr)\n");
+ KIDREG2PARM(0);
+ printf("\tldr %s, [%s, #%d]\n", BN_REG, KID_REG(0), bnode->soffset * 4);
+}
+
+void field_lolbfefail_imm(struct treenode *bnode)
+{
+ printf("\t@ field(imm)\n");
+ moveimm(KID_VAL(0), BN_REG);
+ printf("\tlwz %s, [%s, #%d]\n", BN_REG, BN_REG, bnode->soffset * 4);
+}
+
+%}
+
+%start begin
+%term O_RET=1 O_NULL=2 O_SUB=3 O_MUL=4 O_OR=5 O_LESS=6 O_EQ=7 O_ID=8 O_ADD=9 O_NUM=10 O_FIELD=11 O_MTWO=12 O_MFOUR=13 O_MEIGHT=14 O_MONE=15 O_ASSIGN=16 O_IF=17 O_BOOL=18 O_CALL=19 O_ARG=20 O_NOTHING=21 O_EXPR=22
+
+%%
+
+begin: ret # 0 #
+begin: assign # 0 #
+begin: ifstat # 0 #
+begin: args # 0 #
+
+
+assign: O_ASSIGN(expr, O_ID) # 1 # KIDREG2PARM(1); printf("\tmr %s,%s\n", KID_REG(1), BN_REG);
+assign: O_ASSIGN(imm, O_ID) # 1 # KIDREG2PARM(1); moveimm(KID_VAL(0), KID_REG(1));
+assign: O_ASSIGN(O_ID, O_ID) # 1 # KIDREG2PARM(1); KIDREG2PARM(0); printf("\tmr %s,%s\n", KID_REG(1), KID_REG(0));
+
+assign: O_ASSIGN(O_SUB(O_ID,O_NUM), O_ID) # 1 # assign_var(bnode);
+
+assign: O_ASSIGN(expr, O_FIELD(expr)) # 1 # KIDKIDREG2PARM(1,0); printf("\tstw %s,%d(%s)\n", BN_REG, bnode->kids[1]->soffset * 4, KIDKID_REG(1,0));
+assign: O_ASSIGN(O_ID, O_FIELD(expr)) # 1 # KIDREG2PARM(0); KIDKIDREG2PARM(1,0); printf("\tstw %s,%d(%s)\n", KID_REG(0), bnode->kids[1]->soffset * 4, KIDKID_REG(1,0));
+
+
+ifstat: O_IF(O_ID) # 1 # /* fuer faelle wie "if bla then" noetig */ KIDREG2PARM(0); printf("\tcmpwi %s,0\n", KID_REG(0));
+ifstat: O_IF(O_BOOL(imm)) # 1 # printf("\tcmpwi %s,0\n", BN_REG);
+ifstat: O_IF(expr) # 2 # /* iburg beschummeln :/ */ printf("\tcmpwi %s,0\n", BN_REG);
+ifstat: O_IF(O_BOOL(expr)) # 1 # /* dann braucht man kein test */
+
+
+ret: O_RET(retexpr) # 2 # printf("\t@ o_ret(expr)\n"); move(BN_REG, "r0");
+ret: O_EXPR(expr) # 0 #
+
+retexpr: O_ID # 1 # printf("\t@*retexpr*/\n"); if(bnode->param_index > -1) move(param_reg(bnode->param_index), BN_REG);
+retexpr: expr
+
+
+expr: O_ID # 0 #
+expr: imm # 1 # moveimm(BN_VAL, BN_REG);
+expr: O_BOOL(expr) # 0 #
+
+expr: O_CALL(expr) # 0 # make_call(bnode);
+expr: O_ARG(expr,expr) # 1 # prep_arg(bnode, 1);
+expr: O_ARG(O_ID,expr) # 1 # prep_arg(bnode, 0);
+expr: O_NOTHING # 0 #
+
+expr: O_SUB(expr,expr) # 2 # gen_e_eno(bnode, "sub");
+expr: O_SUB(expr,imm) # 1 # gen_e_imm(bnode, "sub");
+
+expr: O_SUB(expr,O_SUB(O_ID,expr)) # 2 # gen_subspecial(bnode, 0);
+expr: O_SUB(expr,O_SUB(imm,expr)) # 2 # gen_subspecial(bnode, 1);
+
+expr: O_SUB(expr, O_ADD(O_ID,expr)) # 1 # gen_id_eno(bnode);
+
+
+expr: O_ADD(expr,expr) # 1 # gen_e_eno(bnode, "add");
+expr: O_ADD(expr,imm) # 1 # gen_e_imm(bnode, "add");
+expr: O_ADD(imm,expr) # 1 # gen_imm_eno(bnode, "add");
+
+
+expr: O_MUL(expr,expr) # 1 # gen_e_eno(bnode, "mul");
+expr: O_MUL(expr,imm) # 1 # gen_e_imm(bnode, "mul");
+expr: O_MUL(imm,expr) # 1 # gen_imm_eno(bnode, "mul");
+
+
+expr: O_OR(expr,expr) # 1 # gen_e_eno(bnode, "orr");
+expr: O_OR(expr,imm) # 2 # gen_e_imm(bnode, "orr");
+
+
+expr: O_LESS(expr,expr) # 3 # gen_eqless(bnode, "l", 1, 1, 0);
+expr: O_LESS(expr,imm) # 3 # gen_eqless(bnode, "l", 1, 0, 0);
+expr: O_LESS(imm,expr) # 3 # gen_eqless(bnode, "g", 0, 1, 0);
+
+
+expr: O_EQ(expr,expr) # 3 # gen_eqless(bnode, "e", 1, 1, 0);
+expr: O_EQ(expr,imm) # 3 # gen_eqless(bnode, "e", 1, 0, 0);
+expr: O_EQ(imm,expr) # 3 # gen_eqless(bnode, "e", 0, 1, 0);
+expr: O_EQ(expr,O_NULL) # 3 # gen_eqless(bnode, "e", 1, 0, 0);
+
+expr: O_EQ(O_EQ(expr,O_NULL),O_NULL) # 3 # gen_eqless(bnode, "ne", 1, 0, 1);
+expr: O_EQ(O_EQ(O_EQ(expr,O_NULL),O_NULL),O_NULL) # 3 # gen_eqless(bnode, "e", 1, 0, 2);
+
+
+expr: O_FIELD(expr) # 1 # field_lolbfefail(bnode);
+expr: O_FIELD(imm) # 1 # field_lolbfefail_imm(bnode);
+
+
+imm: O_ADD(imm,imm) # 0 # BN_VAL = KID_VAL(0) + KID_VAL(1);
+imm: O_SUB(imm,imm) # 0 # BN_VAL = KID_VAL(0) - KID_VAL(1);
+imm: O_MUL(imm,imm) # 0 # BN_VAL = KID_VAL(0) * KID_VAL(1);
+imm: O_LESS(imm,imm) # 0 # BN_VAL = KID_VAL(0) < KID_VAL(1) ? 1 : 0;
+imm: O_EQ(imm,imm) # 0 # BN_VAL = KID_VAL(0) == KID_VAL(1) ? 1 : 0;
+imm: O_OR(imm,imm) # 0 # BN_VAL = KID_VAL(0) | KID_VAL(1);
+imm: O_NUM # 0 #
+imm: O_MONE # 0 #
+imm: O_MTWO # 0 #
+imm: O_MFOUR # 0 #
+imm: O_MEIGHT # 0 #
+imm: O_NULL # 0 #
+
+%%
+
+/* vim: filetype=c
+ */
--- /dev/null
+%{
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include "symtable.h"
+ #include "chelper.h"
+ #include "tree.h"
+
+ #define MAX(A,B) (A > B ? A : B)
+%}
+
+%start Input
+%token STRUCT END METHOD VAR IF THEN ELSE WHILE DO RETURN NOT OR THIS IDENT NUM ASSIGN
+
+@macro xxputsin(xx,)
+ @i xx = @Statement.sin@;
+@end
+
+@macro statinout()
+ @i @Statement.sout@ = @Statement.sin@;
+ /* das
+ *> xxputsin(@Statement.sout@,)
+ * geht nicht, weil verschachtelte macros deaktiviert sind */
+@end
+
+@macro lblcountinout()
+ @i @Statement.lblcnt_out@ = @Statement.lblcnt_in@;
+@end
+
+@macro varsinout()
+ @i @Statement.vars_out@ = @Statement.vars_in@;
+@end
+
+/* beschreibung der attribute
+ * s: symboltabelle
+ * f: symboltabelle fuer quirks mit structur und parameter
+ * gparamges: anzahl der parameter in einer methode
+ * parms: parametercounter
+ * node: baum fuer iburg
+ * sin: symboltabelle fuer statement ("eingabe")
+ * sout: symboltabelle die aus einem statement wieder rauskommt ("ausgabe")
+ */
+@autoinh s gparamges vars_in
+@autosyn node imm call
+
+@attributes { char *name; } IDENT
+@attributes { long val; } NUM
+@attributes { struct symbol *f; int paramges; int parms; } Parms
+@attributes { struct symbol *f; } Program Structdef;
+@attributes { struct symbol *f; int offsetcount; } FeldID
+@attributes { struct symbol *s; } Methoddef
+@attributes { struct symbol *s; int gparamges; int vars_in; int cnt; int paramcount; struct treenode *node; } Exprs
+@attributes { struct symbol *s; int gparamges; int lblcnt_in; int lblcnt_out; int vars_in; int vars_out; int call; } Statseq
+@attributes { struct symbol *s; int gparamges; int lblcnt_in; int lblcnt_out; int reallblcnt; int vars_in; int vars_out; int call; } Elsestat
+@attributes { struct symbol *s; int gparamges; int vars_in; struct treenode *node; short imm; int call; } Expr Minusterm Multerm Orterm Feld Term
+@attributes { struct symbol *s; int gparamges; int vars_in; struct treenode *node; } Lexpr
+@attributes { struct symbol *sin; int gparamges; struct symbol *sout; struct treenode *node; int vars_in; int vars_out; int lblcnt_in; int lblcnt_out; int call; } Statement
+
+@traversal @postorder c
+@traversal @preorder reg
+@traversal @preorder gen
+
+%%
+Input:
+ Program
+ @{
+ @i @Program.f@ = tab_new();
+ @gen printf("\t.section\t\".text\"\n");
+ @}
+ ;
+
+Program:
+ Methoddef ';' Program
+ @{
+ @i @Methoddef.s@ = @Program.0.f@;
+ @i @Program.1.f@ = @Program.0.f@;
+ @}
+
+ | Structdef ';' Program
+ @{
+ @i @Program.1.f@ = tab_merge(@Program.0.f@, @Structdef.f@, 1);
+ @}
+ |
+ ;
+
+Methoddef:
+ METHOD IDENT '(' Parms ')' Statseq END
+ @{
+ @i @Parms.parms@ = 1;
+ @i @Statseq.s@ = tab_merge(@Methoddef.s@, @Parms.f@, 0);
+ @i @Statseq.vars_in@ = 0;
+ @i @Statseq.gparamges@ = @Parms.paramges@;
+ @i @Statseq.lblcnt_in@ = 0;
+ @gen func_header(@IDENT.name@, @Statseq.vars_out@, @Parms.paramges@, @Statseq.call@);
+ @}
+ ;
+
+Structdef:
+ STRUCT FeldID END
+ @{
+ @i @Structdef.f@ = @FeldID.f@;
+ @i @FeldID.offsetcount@ = 0;
+ @}
+ ;
+
+Parms:
+ /* lokale Vars werden in Statement in die tabelle eingefuegt */
+ IDENT Parms
+ @{
+ @i @Parms.1.parms@ = @Parms.0.parms@ + 1;
+ @i @Parms.0.paramges@ = @Parms.1.paramges@;
+ @i @Parms.0.f@ = tab_add_symbol(@Parms.1.f@, @IDENT.name@, S_PARM, 1, @Parms.parms@, -1);
+ @}
+
+ |
+ @{
+ @i @Parms.f@ = tab_new();
+ @i @Parms.paramges@ = @Parms.parms@;
+ @}
+ ;
+
+FeldID:
+ IDENT FeldID
+ @{
+ @i @FeldID.1.offsetcount@ = @FeldID.0.offsetcount@ + 1;
+ @i @FeldID.0.f@ = tab_add_symbol(@FeldID.1.f@, @IDENT.name@, S_FIELD, 1, -1, @FeldID.0.offsetcount@);
+ @}
+
+ |
+ @{
+ @i @FeldID.f@ = tab_new();
+ @}
+ ;
+
+Statseq:
+ Statement ';' Statseq
+ @{
+ @i @Statement.sin@ = @Statseq.0.s@;
+ @i @Statement.lblcnt_in@ = @Statseq.0.lblcnt_in@;
+
+ @i @Statseq.1.s@ = @Statement.sout@;
+ @i @Statseq.1.lblcnt_in@ = @Statement.lblcnt_out@;
+ @i @Statseq.1.gparamges@ = @Statseq.0.gparamges@;
+
+ @i @Statement.vars_in@ = @Statseq.0.vars_in@;
+ @i @Statseq.1.vars_in@ = @Statement.vars_out@;
+
+ @i @Statseq.0.lblcnt_out@ = @Statseq.1.lblcnt_out@;
+ @i @Statseq.0.vars_out@ = @Statseq.1.vars_out@;
+
+ @i @Statseq.0.call@ = @Statement.call@ || @Statseq.1.call@;
+ @}
+
+ |
+ @{
+ @i @Statseq.0.lblcnt_out@ = @Statseq.0.lblcnt_in@;
+ @i @Statseq.0.vars_out@ = @Statseq.0.vars_in@;
+ @i @Statseq.0.call@ = 0;
+ @}
+ ;
+
+Statement:
+ Lexpr ASSIGN Expr
+ @{
+ statinout()
+ lblcountinout()
+ varsinout()
+ xxputsin(@Lexpr.s@,)
+ xxputsin(@Expr.s@,)
+ @i @Statement.node@ = new_node(O_ASSIGN, @Expr.node@, @Lexpr.node@);
+ @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@);
+ @reg @Lexpr.node@->reg = next_reg(@Expr.node@->reg, @Expr.gparamges@);
+
+ @gen write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1);
+ @}
+
+ | VAR IDENT ASSIGN Expr
+ @{
+ /* tab_clone ist hier noetig, vgl. folgendes statement
+ * > var x := x - 1; */
+ @i @Statement.sout@ = tab_add_symbol(tab_clone(@Statement.sin@), @IDENT.name@, S_VAR, 1, @Statement.gparamges@ + @Statement.vars_in@, -1);
+ lblcountinout()
+
+ @i @Statement.vars_out@ = @Statement.vars_in@ + 1;
+
+ xxputsin(@Expr.s@,)
+
+ @i @Statement.node@ = new_node(O_ASSIGN, @Expr.node@, new_param(O_ID, @IDENT.name@, TREENULL, TREENULL, @Statement.gparamges@ + @Statement.vars_in@));
+ @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@);
+
+ @gen write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1);
+ @}
+
+ | Expr
+ @{
+ statinout()
+ varsinout()
+ lblcountinout()
+ xxputsin(@Expr.s@,)
+ @i @Statement.node@ = new_node(O_EXPR, @Expr.node@, TREENULL);
+ @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@);
+
+ @gen write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1);
+ @}
+
+ | IF Expr THEN Statseq END
+ @{
+ statinout()
+ @i @Statseq.lblcnt_in@ = @Statement.lblcnt_in@ + 1;
+ @i @Statement.lblcnt_out@ = @Statseq.lblcnt_out@;
+
+ @i @Statseq.vars_in@ = @Statement.vars_in@;
+ @i @Statement.vars_out@ = @Statseq.vars_out@;
+
+ @i @Statement.call@ = @Expr.call@ || @Statseq.call@;
+
+ xxputsin(@Expr.s@,)
+ xxputsin(@Statseq.s@,)
+
+ @i @Statement.node@ = new_node(O_IF, @Expr.node@, TREENULL);
+
+ @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@);
+ @gen {
+ printf(".%s_ifstart_%d:\n", get_func_name(), @Statement.lblcnt_in@);
+ write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1);
+ printf("\tbeq 0,.%s_ifend_%d\n", get_func_name(), @Statement.lblcnt_in@);
+ }
+ @gen @revorder(1) printf(".%s_ifend_%d:\n", get_func_name(), @Statement.lblcnt_in@);
+ @}
+
+ | IF Expr THEN Statseq Elsestat END
+ @{
+ statinout()
+ @i @Statseq.0.lblcnt_in@ = @Statement.lblcnt_in@ + 1;
+ @i @Elsestat.lblcnt_in@ = @Statseq.lblcnt_out@;
+ @i @Statement.lblcnt_out@ = @Elsestat.lblcnt_out@;
+
+ /* im Elsestat muss noch ein label numeriert werden */
+ @i @Elsestat.reallblcnt@ = @Statement.lblcnt_in@;
+
+ @i @Statseq.vars_in@ = @Statement.vars_in@;
+ @i @Elsestat.vars_in@ = @Statement.vars_in@;
+ @i @Statement.vars_out@ = MAX(@Statseq.vars_out@, @Elsestat.vars_out@);
+
+ @i @Statement.call@ = @Expr.call@ || @Statseq.call@ || @Elsestat.call@;
+
+ xxputsin(@Expr.s@,)
+ xxputsin(@Statseq.0.s@,)
+ xxputsin(@Elsestat.s@,)
+
+ @i @Statement.node@ = new_node(O_IF, @Expr.node@, TREENULL);
+
+ @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@);
+ @gen {
+ printf(".%s_ifstart_%d:\n", get_func_name(), @Statement.lblcnt_in@);
+ write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1);
+ printf("\tbeq 0,.%s_ifelse_%d\n", get_func_name(), @Statement.lblcnt_in@);
+ }
+ @gen @revorder(1) printf(".%s_ifend_%d:\n", get_func_name(), @Statement.lblcnt_in@);
+ @}
+
+ | WHILE Expr DO Statseq END
+ @{
+ statinout()
+ @i @Statseq.lblcnt_in@ = @Statement.lblcnt_in@ + 1;
+ @i @Statement.lblcnt_out@ = @Statseq.lblcnt_out@;
+
+ @i @Statseq.vars_in@ = @Statement.vars_in@;
+ @i @Statement.vars_out@ = @Statseq.vars_out@;
+
+ @i @Statement.call@ = @Expr.call@ || @Statseq.call@;
+
+ xxputsin(@Expr.s@,)
+ xxputsin(@Statseq.s@,)
+
+ @i @Statement.node@ = new_node(O_IF, @Expr.node@, TREENULL);
+
+ @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@);
+ @gen {
+ printf(".%s_whilestart_%d:\n", get_func_name(), @Statement.lblcnt_in@);
+ write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1);
+ printf("\tbeq 0,.%s_whileend_%d\n", get_func_name(), @Statement.lblcnt_in@);
+ }
+ @gen @revorder(1) printf("\tb .%s_whilestart_%d\n.%s_whileend_%d:\n", get_func_name(), @Statement.lblcnt_in@, get_func_name(), @Statement.lblcnt_in@);
+ @}
+
+ | RETURN Expr
+ @{
+ statinout()
+ lblcountinout()
+ varsinout()
+ xxputsin(@Expr.s@,)
+
+ @i @Statement.node@ = new_node(O_RET, @Expr.node@, TREENULL);
+ @reg @Statement.node@->reg = @Expr.node@->reg = next_reg((char *)NULL, @Expr.gparamges@);
+
+ @gen write_tree(@Statement.node@, 0); burm_label(@Statement.node@); burm_reduce(@Statement.node@, 1); func_footer();
+ @}
+ ;
+
+Elsestat:
+ ELSE Statseq
+ @{
+ @i @Statseq.lblcnt_in@ = @Elsestat.lblcnt_in@;
+ @i @Elsestat.lblcnt_out@ = @Statseq.lblcnt_out@;
+
+ @i @Statseq.vars_in@ = @Elsestat.vars_in@;
+ @i @Elsestat.vars_out@ = @Statseq.vars_out@;
+
+ @gen printf("\tb .%s_ifend_%d\n.%s_ifelse_%d:\n", get_func_name(), @Elsestat.reallblcnt@, get_func_name(), @Elsestat.reallblcnt@);
+ @}
+
+Lexpr:
+ IDENT
+ @{
+ @c check(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM);
+
+ /* TODO: selbe Code wie bei Term/IDENT -- schoener machen! */
+ @i {
+ @Lexpr.node@ = TREENULL;
+ if(tab_lookup(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL) {
+ /* es handelt sich um ein feldzugriff auf this */
+ @Lexpr.node@ = new_field(@IDENT.name@, new_param(O_ID, strdup("this"), TREENULL, TREENULL, 0), TREENULL, tab_lookup(@Lexpr.s@, @IDENT.name@, S_FIELD) == SYMNULL ? -1 : tab_lookup(@Lexpr.s@, @IDENT.name@, S_FIELD)->soffset);
+ } else { /* param oder var */
+ int tmp = tab_lookup(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL ? -1 : tab_lookup(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM)->param_index;
+ @Lexpr.node@ = new_param(O_ID, @IDENT.name@, TREENULL, TREENULL, tmp);
+ }
+ }
+
+ @reg if(tab_lookup(@Lexpr.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL) {
+ /* TODO: kein schoener hack? */
+ @Lexpr.node@->kids[0]->reg = @Lexpr.node@->reg;
+ }
+ @}
+
+ | Feld
+ ;
+
+Feld: Term '.' IDENT
+ @{
+ @c check(@Feld.s@, @IDENT.name@, S_FIELD);
+ @i @Feld.node@ = new_field(@IDENT.name@, @Term.node@, TREENULL, tab_lookup(@Feld.s@, @IDENT.name@, S_FIELD) == SYMNULL ? -1 : tab_lookup(@Feld.s@, @IDENT.name@, S_FIELD)->soffset);
+
+ @reg @Term.node@->reg = next_reg(@Feld.node@->reg, @Term.gparamges@);
+ @}
+ ;
+
+Expr:
+ Term
+ @{
+ @reg @Term.node@->reg = @Expr.node@->reg;
+ @}
+
+ | NOT Term
+ @{
+ @i @Expr.node@ = new_node(O_BOOL, new_node(O_EQ, @Term.node@, new_node(O_NULL, TREENULL, TREENULL)), TREENULL);
+
+ @reg @Term.node@->reg = @Expr.node@->kids[0]->reg = @Expr.node@->reg;
+ @}
+
+ | Term Minusterm
+ @{
+ @i @Expr.node@ = new_node(O_SUB, @Term.node@, @Minusterm.node@);
+ @i @Expr.imm@ = @Term.imm@ && @Minusterm.imm@;
+ @i @Expr.call@ = @Term.call@ || @Minusterm.call@;
+
+ @reg {
+ if(!(@Expr.node@->kids[0] == TREENULL && @Expr.node@->kids[1] == TREENULL)) {
+ @Term.node@->reg = @Expr.node@->reg;
+ if(@Minusterm.imm@) {
+ @Minusterm.node@->reg = @Expr.node@->reg;
+ } else {
+ @Minusterm.node@->reg = next_reg(@Term.node@->reg, @Expr.gparamges@);
+ }
+ }
+ }
+ @}
+
+ | Term Multerm
+ @{
+ @i @Expr.node@ = new_node(O_MUL, @Term.node@, @Multerm.node@);
+ @i @Expr.imm@ = @Term.imm@ && @Multerm.imm@;
+ @i @Expr.call@ = @Term.call@ || @Multerm.call@;
+
+ @reg {
+ @Term.node@->reg = next_reg(@Expr.node@->reg, @Expr.gparamges@);
+ if(@Term.imm@) {
+ @Multerm.node@->reg = @Expr.node@->reg;
+ } else {
+ @Multerm.node@->reg = next_reg(@Term.node@->reg, @Expr.gparamges@);
+ }
+ }
+ @}
+
+ | Term Orterm
+ @{
+ @i @Expr.node@ = new_node(O_OR, @Term.node@, @Orterm.node@);
+ @i @Expr.imm@ = @Term.imm@ && @Orterm.imm@;
+ @i @Expr.call@ = @Term.call@ || @Orterm.call@;
+
+ @reg {
+ @Term.node@->reg = @Expr.node@->reg;
+ @Orterm.node@->reg = next_reg(@Term.node@->reg, @Expr.gparamges@);
+ }
+ @}
+
+ | Term '<' Term
+ @{
+ @i @Expr.node@ = new_node(O_BOOL, new_node(O_LESS, @Term.0.node@, @Term.1.node@), TREENULL);
+ @i @Expr.imm@ = @Term.0.imm@ && @Term.1.imm@;
+ @i @Expr.call@ = @Term.0.call@ || @Term.1.call@;
+
+ @reg {
+ @Term.0.node@->reg = @Expr.node@->kids[0]->reg = @Expr.node@->reg;
+ @Term.1.node@->reg = next_reg(@Term.0.node@->reg, @Expr.gparamges@);
+ }
+ @}
+
+ | Term '=' Term
+ @{
+ @i @Expr.node@ = new_node(O_BOOL, new_node(O_EQ, @Term.0.node@, @Term.1.node@), TREENULL);
+ @i @Expr.imm@ = @Term.0.imm@ && @Term.1.imm@;
+ @i @Expr.call@ = @Term.0.call@ || @Term.1.call@;
+
+ @reg {
+ @Term.0.node@->reg = @Expr.node@->kids[0]->reg = @Expr.node@->reg;
+ @Term.1.node@->reg = next_reg(@Term.0.node@->reg, @Expr.gparamges@);
+ }
+ @}
+ ;
+
+Minusterm:
+ '-' Term Minusterm
+ @{
+ @i @Minusterm.node@ = new_node(O_ADD, @Minusterm.1.node@, @Term.node@);
+ @i @Minusterm.0.imm@ = @Term.imm@ && @Minusterm.1.imm@;
+ @i @Minusterm.0.call@ = @Term.call@ || @Minusterm.1.call@;
+
+ @reg {
+ @Minusterm.1.node@->reg = @Minusterm.node@->reg;
+ if(@Minusterm.1.imm@) {
+ @Term.node@->reg = @Minusterm.node@->reg;
+ } else {
+ @Term.node@->reg = next_reg(@Minusterm.1.node@->reg, @Minusterm.gparamges@);
+ }
+ }
+ @}
+
+ | '-' Term
+ @{
+ @reg @Term.node@->reg = @Minusterm.node@->reg;
+ @}
+ ;
+
+Multerm:
+ '*' Term Multerm
+ @{
+ @i @Multerm.node@ = new_node(O_MUL, @Multerm.1.node@, @Term.node@);
+ @i @Multerm.0.imm@ = @Term.imm@ && @Multerm.1.imm@;
+ @i @Multerm.0.call@ = @Term.call@ || @Multerm.1.call@;
+
+ @reg {
+ @Multerm.1.node@->reg = @Multerm.node@->reg;
+ if(@Multerm.1.imm@) {
+ @Term.node@->reg = @Multerm.node@->reg;
+ } else {
+ @Term.node@->reg = next_reg(@Multerm.1.node@->reg, @Multerm.gparamges@);
+ }
+ }
+ @}
+
+ | '*' Term
+ @{
+ @reg @Term.node@->reg = @Multerm.node@->reg;
+ @}
+ ;
+
+Orterm:
+ OR Term Orterm
+ @{
+ @i @Orterm.node@ = new_node(O_OR, @Orterm.1.node@, @Term.node@);
+ @i @Orterm.0.imm@ = @Term.imm@ && @Orterm.1.imm@;
+ @i @Orterm.0.call@ = @Term.call@ || @Orterm.1.call@;
+
+ @reg {
+ @Orterm.1.node@->reg = @Orterm.node@->reg;
+ if(@Orterm.1.imm@) {
+ @Term.node@->reg = @Orterm.node@->reg;
+ } else {
+ @Term.node@->reg = next_reg(@Orterm.1.node@->reg, @Orterm.gparamges@);
+ }
+ }
+ @}
+ | OR Term
+ @{
+ @reg @Term.node@->reg = @Orterm.node@->reg;
+ @}
+
+ ;
+
+Term:
+ '(' Expr ')'
+ @{
+ @i @Term.node@ = @Expr.node@;
+ @}
+
+ | NUM
+ @{
+ @i @Term.node@ = new_number(@NUM.val@);
+ @i @Term.imm@ = 1;
+ @i @Term.call@ = 0;
+ @}
+
+ | '-' NUM
+ @{
+ @i @Term.node@ = new_number(-1 * (@NUM.val@));
+ @i @Term.imm@ = 1;
+ @i @Term.call@ = 0;
+ @}
+
+ | THIS
+ @{
+ @i @Term.node@ = new_param(O_ID, strdup("this"), TREENULL, TREENULL, 0);
+ @i @Term.imm@ = 0;
+ @i @Term.call@ = 0;
+ @}
+
+ | IDENT
+ @{
+ @c check(@Term.s@, @IDENT.name@, S_VAR|S_PARM);
+
+ @i @Term.imm@ = 0;
+ @i @Term.call@ = 0;
+ @i {
+ @Term.node@ = TREENULL;
+ if(tab_lookup(@Term.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL) {
+ /* es handelt sich um ein feldzugriff auf this */
+ @Term.node@ = new_field(@IDENT.name@, new_param(O_ID, strdup("this"), TREENULL, TREENULL, 0), TREENULL, tab_lookup(@Term.s@, @IDENT.name@, S_FIELD) == SYMNULL ? -1 : tab_lookup(@Term.s@, @IDENT.name@, S_FIELD)->soffset);
+ } else { /* param oder var */
+ int tmp = tab_lookup(@Term.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL ? -1 : tab_lookup(@Term.s@, @IDENT.name@, S_VAR|S_PARM)->param_index;
+ @Term.node@ = new_param(O_ID, @IDENT.name@, TREENULL, TREENULL, tmp);
+ }
+ }
+
+ @reg if(tab_lookup(@Term.s@, @IDENT.name@, S_VAR|S_PARM) == SYMNULL) {
+ /* TODO: kein schoener hack? */
+ @Term.node@->kids[0]->reg = @Term.node@->reg;
+ }
+ @}
+
+ | Feld
+ @{
+ @i @Term.node@ = @Feld.node@;
+ @i @Term.imm@ = 0;
+ @}
+
+ | IDENT '(' Exprs ')'
+ @{
+ @i {
+ @Term.node@ = new_call(@IDENT.name@, new_arg(@Exprs.node@, new_nothing(), 0) /*this*/,
+ TREENULL, @Term.gparamges@, @Term.vars_in@);
+ @Term.node@->soffset = MAX(@Exprs.paramcount@, @Term.gparamges@);
+ }
+ @i @Exprs.cnt@ = 1;
+ @i @Term.imm@ = 0;
+ @i @Term.call@ = 1;
+ @reg @Exprs.node@->reg = @Term.node@->reg;
+ @}
+
+ | Term '.' IDENT '(' Exprs ')'
+ @{
+ @i {
+ @Term.node@ = new_call(@IDENT.name@, new_arg(@Exprs.node@, @Term.1.node@, 0) /*this*/,
+ TREENULL, @Term.gparamges@, @Term.vars_in@);
+ @Term.node@->soffset = MAX(@Exprs.paramcount@, @Term.gparamges@);
+ }
+ @i @Exprs.cnt@ = 1;
+ @i @Term.imm@ = 0;
+ @i @Term.call@ = 1;
+ @reg @Exprs.node@->reg = @Term.1.node@->reg = @Term.node@->kids[0]->reg = @Term.node@->reg;
+ @}
+
+ ;
+
+Exprs:
+ Expr ',' Exprs
+ @{
+ @i @Exprs.0.node@ = new_arg(@Expr.0.node@, @Exprs.1.node@, @Exprs.0.cnt@);
+ @i @Exprs.0.paramcount@ = @Exprs.1.paramcount@;
+ @i @Exprs.1.cnt@ = @Exprs.0.cnt@ + 1;
+ @reg @Expr.node@->reg = @Exprs.0.node@->reg; @Exprs.1.node@->reg = next_reg(@Exprs.0.node@->reg, @Exprs.gparamges@);
+ @}
+ | Expr
+ @{
+ @i @Exprs.0.node@ = new_arg(@Expr.0.node@, new_nothing(), @Exprs.cnt@);
+ @i @Exprs.paramcount@ = @Exprs.cnt@ + 1;
+ @reg @Expr.node@->reg = @Exprs.0.node@->reg;
+ @}
+ |
+ @{
+ @i @Exprs.0.node@ = new_nothing();
+ @i @Exprs.paramcount@ = @Exprs.cnt@;
+ @}
+ ;
+%%
+
+extern int yylex();
+extern int yylineno;
+
+int yyerror(char *error_text)
+{
+ fprintf(stderr,"Zeile %i: %s\n", yylineno, error_text);
+ exit(2);
+}
+
+int main(int argc, char **argv)
+{
+ #if 0
+ yydebug=1;
+ #endif
+ yyparse();
+ return 0;
+}
+
--- /dev/null
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include "parser.h"
+
+KEYWORD struct|end|method|var|if|then|else|while|do|return|not|or|this
+IDENTIFIER [a-zA-Z_][0-9a-zA-Z_]*
+NUMBER_HEX 0x[0-9A-Fa-f]+
+NUMBER_DEC [0-9]+
+WHITESPACE [\t\n\r ]
+COMMENT_START \/\*
+COMMENT_END \*\/
+
+%x COMMENT
+%option yylineno
+%%
+
+{COMMENT_START} BEGIN(COMMENT);
+
+<COMMENT>{COMMENT_END} BEGIN(INITIAL);
+
+<COMMENT><<EOF>> {
+ fprintf(stderr, "Kommentar nicht geschlossen\n");
+ exit(1);
+}
+
+<COMMENT>(.|\n) /* alles im kommentar wird ignoriert */
+
+struct return(STRUCT);
+end return(END);
+method return(METHOD);
+var return(VAR);
+if return(IF);
+then return(THEN);
+else return(ELSE);
+while return(WHILE);
+do return(DO);
+return return(RETURN);
+not return(NOT);
+or return(OR);
+this return(THIS);
+
+{IDENTIFIER} return(IDENT); @{ @IDENT.name@ = strdup(yytext); @}
+
+{NUMBER_DEC} return(NUM); @{ @NUM.val@ = strtol(yytext, (char **)NULL, 10); @}
+{NUMBER_HEX} return(NUM); @{ @NUM.val@ = strtol(yytext, (char **)NULL, 16); @}
+
+\:= return(ASSIGN);
+\; return(';');
+\( return('(');
+\) return(')');
+\. return('.');
+\- return('-');
+\* return('*');
+\< return('<');
+\= return('=');
+\, return(',');
+
+{WHITESPACE} /* ignore */
+
+. {
+ fprintf(stderr, "Lexical error on line %i\n", yylineno);
+ exit(1);
+}
+
+%%
+
--- /dev/null
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "symtable.h"
+
+#if 0
+#define DD
+#endif
+
+struct symbol *tab_new(void)
+{
+ return SYMNULL;
+}
+
+struct symbol *tab_clone(struct symbol *tab)
+{
+ struct symbol *elm = tab;
+ struct symbol *ntab = tab_new();
+#ifdef DD
+ fprintf(stderr, "tab_clone: tab(%08X)\n", tab);
+#endif
+
+ while(elm != SYMNULL) {
+ ntab = tab_add_symbol(ntab, elm->ident, elm->type, 0, elm->param_index, elm->soffset);
+ elm = elm->next;
+ }
+ return ntab;
+}
+
+struct symbol *tab_add_symbol(struct symbol *tab, char *ident, short type, short check, int param_index, int soffset)
+{
+ struct symbol *elm = tab;
+ struct symbol *new_elm;
+#ifdef DD
+ fprintf(stderr, "tab_add_symbol: tab(%08X), ident(%s), type(%i), check(%i), param_index(%i), soffset(%i)\n", tab, ident, type, check, param_index, soffset);
+#endif
+
+#if 0
+ /* kann statt return -3, -4 verursachen... (z.b. codea_ag_snafu_01.3) */
+ if(param_index >= 6) {
+ fprintf(stderr, "eine methode hat zu viele parameter (max. 6 inkl. this erlaubt)\n");
+ exit(4);
+ }
+#endif
+
+ if(tab_lookup(tab, ident, type) != SYMNULL || (type == S_VAR && tab_lookup(tab, ident, S_PARM) != SYMNULL)) {
+ if(check) {
+ fprintf(stderr, "Identifier doppelt vorhanden: \"%s\"\n", ident);
+ exit(3);
+ } else {
+ tab = tab_remove_symbol(tab, ident, type);
+ }
+ }
+
+ new_elm = (struct symbol *) malloc(sizeof(struct symbol));
+ new_elm->next = SYMNULL;
+ new_elm->ident = strdup(ident);
+ new_elm->type = type;
+ new_elm->param_index = param_index;
+ new_elm->soffset = soffset;
+
+ if(tab == SYMNULL) return new_elm;
+
+ while(elm->next != SYMNULL) {
+ elm = elm->next;
+ }
+ elm->next = new_elm;
+
+ return tab;
+}
+
+struct symbol *tab_lookup(struct symbol *tab, char *ident, short type)
+{
+ struct symbol *elm = tab;
+
+ if(tab == SYMNULL) return SYMNULL;
+
+ do {
+ if((elm->type & type) && (strcmp(elm->ident, ident) == 0)) {
+ return elm;
+ }
+ elm = elm->next;
+ } while(elm != SYMNULL);
+
+ return SYMNULL;
+}
+
+struct symbol *tab_merge(struct symbol *tab, struct symbol *to_add, short check)
+{
+ struct symbol *elm = to_add;
+ struct symbol *ntab = tab_clone(tab);
+#ifdef DD
+ fprintf(stderr, "tab_merge: tab(%08X), to_add(%08X), check(%i), ntab(%08X)\n", tab, to_add, check, ntab);
+#endif
+
+ while(elm != SYMNULL) {
+ ntab = tab_add_symbol(ntab, elm->ident, elm->type, check, elm->param_index, elm->soffset);
+ elm = elm->next;
+ }
+
+ return ntab;
+}
+
+struct symbol *tab_remove_symbol(struct symbol *tab, char *ident, short type)
+{
+ struct symbol *elm = tab;
+ struct symbol *previous_elm = SYMNULL;
+
+ while(elm != SYMNULL) {
+ if((elm->type == type) && (strcmp(elm->ident, ident) == 0)) {
+ if(previous_elm == SYMNULL) {
+ tab = elm->next;
+ } else {
+ previous_elm->next = elm->next;
+ }
+ (void)free(elm->ident);
+ (void)free(elm);
+ break;
+ }
+ previous_elm = elm;
+ elm = elm->next;
+ }
+
+ return tab;
+}
+
+void check(struct symbol *tab, char *ident, short type)
+{
+ struct symbol *elm;
+#ifdef DD
+ fprintf(stderr, "check: tab(%08X), ident(%s), type(%i), elm(%08X)\n", tab, ident, type, elm);
+#endif
+
+ if(type & (S_VAR | S_PARM)) {
+ elm = tab_lookup(tab, ident, type);
+ if(elm != SYMNULL) {
+ return;
+ }
+ }
+
+ /* keine passende variable gefunden?
+ * => vllt gibt es ja ein passenden feldnamen */
+ elm = tab_lookup(tab, ident, S_FIELD);
+ if(elm == SYMNULL) {
+ fprintf(stderr, "Unbekannter Identifier: \"%s\"\n", ident);
+ exit(3);
+ }
+}
+
--- /dev/null
+#ifndef SYMTABLE_H
+#define SYMTABLE_H
+
+#define S_FIELD (1<<0)
+#define S_VAR (1<<1)
+#define S_PARM (1<<2)
+
+#define SYMNULL (struct symbol *)NULL
+
+struct symbol {
+ char *ident;
+ struct symbol *next;
+ short type;
+ int param_index;
+ int soffset;
+};
+
+struct symbol *tab_clone(struct symbol *tab);
+struct symbol *tab_new(void);
+struct symbol *tab_add_symbol(struct symbol *tab, char *ident, short type, short check, int param_index, int soffset);
+struct symbol *tab_lookup(struct symbol *tab, char *ident, short type);
+struct symbol *tab_remove_symbol(struct symbol *tab, char *ident, short type);
+struct symbol *tab_merge(struct symbol *tab, struct symbol *to_add, short check);
+void check(struct symbol *tab, char *ident, short type);
+
+#endif
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "tree.h"
+
+#if 0
+#define DDTREE
+#endif
+
+static struct treenode *_new_plain(int op)
+{
+ struct treenode *new = (TREECAST) malloc(TREESIZE);
+ new->op = op;
+ new->kids[0] = new->kids[1] = TREENULL;
+ new->parent = TREENULL;
+ new->label = NULL;
+ new->name = new->reg = (char *)NULL;
+ new->val = new->paramges = new->vars = 0;
+ new->param_index = -1;
+ return new;
+}
+
+struct treenode *new_nothing(void)
+{
+ return new_node(O_NOTHING, TREENULL, TREENULL);
+}
+
+struct treenode *new_node(int op, struct treenode *l, struct treenode *r)
+{
+ struct treenode *new = TREENULL;
+
+#ifdef DDTREE
+ fprintf(stderr, "new_node: %i (%s)\n", op, o_names[op]);
+#endif
+ if(op == O_SUB && l != TREENULL && r != TREENULL && l->op == O_NUM && r->op == O_NUM) {
+ new = new_number(l->val - r->val);
+ free(l); free(r);
+ } else {
+ new = _new_plain(op);
+ new->kids[0] = l;
+ new->kids[1] = r;
+ }
+ new->name = (char *)NULL;
+ return new;
+}
+
+struct treenode *new_param(int op, char *name, struct treenode *l, struct treenode *r, int param_index)
+{
+ struct treenode *new = new_node(op, l, r);
+
+#ifdef DDTREE
+ fprintf(stderr, "new_param: %i (index)\n", param_index);
+#endif
+ new->param_index = param_index;
+ new->name = name;
+ return new;
+}
+
+struct treenode *new_field(char *name, struct treenode *l, struct treenode *r, int soffset)
+{
+ struct treenode *new = new_node(O_FIELD, l, r);
+
+#ifdef DDTREE
+ fprintf(stderr, "new_field: %i (soffset)\n", soffset);
+#endif
+ new->soffset = soffset;
+ new->name = name;
+ return new;
+}
+
+struct treenode *new_arg(struct treenode *l, struct treenode *r, int soffset)
+{
+ struct treenode *new = new_node(O_ARG, l, r);
+
+#ifdef DDTREE
+ fprintf(stderr, "new_arg: %i (soffset)\n", soffset);
+#endif
+ new->soffset = soffset;
+ new->name = (char *) malloc(10);
+ sprintf(new->name, "%i", soffset);
+ return new;
+}
+
+struct treenode *new_call(char *name, struct treenode *l, struct treenode *r, int paramges, int vars)
+{
+ struct treenode *new = new_node(O_CALL, l, r);
+
+#ifdef DDTREE
+ fprintf(stderr, "new_call\n");
+#endif
+ new->name = name;
+ new->paramges = paramges;
+ new->vars = vars;
+ return new;
+}
+
+struct treenode *new_number(long val)
+{
+ struct treenode *new;
+ /* TODO: maximal groesse? */
+#define BUFMAX 40
+ char *t = (char*) malloc(BUFMAX);
+
+ if (val == 0) {
+ new = _new_plain(O_NULL);
+ } else if(val == -1) {
+ new = _new_plain(O_MONE);
+ } else if(val == -2) {
+ new = _new_plain(O_MTWO);
+ } else if(val == -4) {
+ new = _new_plain(O_MFOUR);
+ } else if(val == -8) {
+ new = _new_plain(O_MEIGHT);
+ } else {
+ new = _new_plain(O_NUM);
+ }
+
+#ifdef DDTREE
+ fprintf(stderr, "new_number: %i\n", val);
+#endif
+ new->val = val;
+ memset(t, 0, BUFMAX);
+ sprintf(t, "%li", val);
+ new->name = t;
+
+ return new;
+}
+
+static void write_indent(int i)
+{
+ int a;
+ for(a = 0; a < i; a++) {
+ fprintf(stderr, "| ");
+ }
+}
+
+void write_tree(struct treenode *node, int indent)
+{
+ if(node == TREENULL) return;
+ write_indent(indent);
+ fprintf(stderr, "%s @ %%%s. \"%s\"\n", o_names[node->op], node->reg, node->name == (char*) NULL ? "" : node->name);
+ if(node->kids[0] != TREENULL) {
+ write_tree(node->kids[0], indent+1);
+ }
+ if(node->kids[1] != TREENULL) {
+ write_tree(node->kids[1], indent+1);
+ }
+}
+
--- /dev/null
+#ifndef __TREE_H
+#define __TREE_H
+
+#define TREENULL (struct treenode *)NULL
+#define TREESIZE (sizeof(struct treenode))
+#define TREECAST struct treenode *
+
+#ifndef BFEHAX
+typedef struct burm_state *STATEPTR_TYPE;
+#endif
+
+enum {
+ O_RET=1, O_NULL, O_SUB, O_MUL,
+ O_OR=5, O_LESS, O_EQ, O_ID, O_ADD,
+ O_NUM=10, O_FIELD, O_MTWO, O_MFOUR, O_MEIGHT,
+ O_MONE=15, O_ASSIGN, O_IF, O_BOOL, O_CALL,
+ O_ARG=20, O_NOTHING, O_EXPR
+};
+
+static char *o_names[] = {
+ "", "O_RET", "O_NULL", "O_SUB", "O_MUL",
+ "O_OR", "O_LESS", "O_EQ", "O_ID", "O_ADD",
+ "O_NUM", "O_FIELD", "O_MTWO", "O_MFOUR", "O_MEIGHT",
+ "O_MONE", "O_ASSIGN", "O_IF", "O_BOOL", "O_CALL",
+ "O_ARG", "O_NOTHING", "O_EXPR"
+};
+
+struct treenode {
+ int op;
+ struct treenode *kids[2];
+ STATEPTR_TYPE label;
+ char *name;
+ long val;
+ char *reg;
+ struct treenode *parent;
+ int param_index;
+ int soffset;
+ int paramges;
+ int vars;
+};
+
+typedef struct treenode *treenodep;
+
+#define NODEPTR_TYPE treenodep
+#define OP_LABEL(p) ((p)->op)
+#define LEFT_CHILD(p) ((p)->kids[0])
+#define RIGHT_CHILD(p) ((p)->kids[1])
+#define STATE_LABEL(p) ((p)->label)
+#define PANIC printf
+
+struct treenode *new_node(int op, struct treenode *l, struct treenode *r);
+struct treenode *new_number(long val);
+struct treenode *new_param(int op, char *name, struct treenode *l, struct treenode *r, int param_index);
+struct treenode *new_field(char *name, struct treenode *l, struct treenode *r, int soffset);
+struct treenode *new_call(char *name, struct treenode *l, struct treenode *r, int paramges, int vars);
+struct treenode *new_arg(struct treenode *l, struct treenode *r, int soffset);
+struct treenode *new_nothing(void);
+void write_tree(struct treenode *node, int ident);
+
+#endif
projects / uebersetzerbau-ss10.git / commitdiff