code.c

雏形java的解释器源码。配合flex和bison可以工作

/*
 * JOOS is Copyright (C) 1997 Laurie Hendren & Michael I. Schwartzbach
 *
 * Reproduction of all or part of this software is permitted for
 * educational or research use on condition that this copyright notice is
 * included in any copy. This software comes with no warranty of any
 * kind. In no event will the authors be liable for any damages resulting from
 * use of this software.
 *
 * email: [e-mail], [e-mail]
 */

#include <stdio.h>
#include <string.h>
#include "memory.h"
#include "code.h"
#include "symbol.h"

CODE *currentcode;
CODE *currenttail;
LABEL *currentlabels;

void appendCODE(CODE *c)
{ if (currentcode==NULL) {
     currentcode = c;
     currenttail = c;
  } else {
     currenttail->next = c;
     currenttail = c;
  }
}

void code_nop()
{ appendCODE(makeCODEnop(NULL));
}

void code_i2c()
{ appendCODE(makeCODEi2c(NULL));
}

void code_new(char *arg)
{ appendCODE(makeCODEnew(arg,NULL));
}

void code_instanceof(char *arg)
{ appendCODE(makeCODEinstanceof(arg,NULL));
}

void code_checkcast(char *arg)
{ appendCODE(makeCODEcheckcast(arg,NULL));
}

void code_imul()
{ appendCODE(makeCODEimul(NULL));
}
 
void code_ineg()
{ appendCODE(makeCODEineg(NULL));
}
 
void code_irem()
{ appendCODE(makeCODEirem(NULL));
}

void code_isub()
{ appendCODE(makeCODEisub(NULL));
}
 
void code_idiv()
{ appendCODE(makeCODEidiv(NULL));
}

void code_iadd()
{ appendCODE(makeCODEiadd(NULL));
}

CODE *code_label(char *name, int label)
{ currentlabels[label].name = name;
  currentlabels[label].sources = 1;
  appendCODE(makeCODElabel(label,NULL));
  currentlabels[label].position = currenttail;
  return currenttail;
}

void code_goto(int label)
{ appendCODE(makeCODEgoto(label,NULL));
}

void code_ifeq(int label)
{ appendCODE(makeCODEifeq(label,NULL));
}

void code_ifne(int label)
{ appendCODE(makeCODEifne(label,NULL));
}

void code_if_acmpeq(int label)
{ appendCODE(makeCODEif_acmpeq(label,NULL));
}

void code_if_acmpne(int label)
{ appendCODE(makeCODEif_acmpne(label,NULL));
}

void code_ifnull(int label)
{ appendCODE(makeCODEifnull(label,NULL));
}

void code_ifnonnull(int label)
{ appendCODE(makeCODEifnonnull(label,NULL));
}

void code_if_icmpeq(int label)
{ appendCODE(makeCODEif_icmpeq(label,NULL));
}

void code_if_icmpgt(int label)
{ appendCODE(makeCODEif_icmpgt(label,NULL));
}

void code_if_icmplt(int label)
{ appendCODE(makeCODEif_icmplt(label,NULL));
}

void code_if_icmple(int label)
{ appendCODE(makeCODEif_icmple(label,NULL));
}

void code_if_icmpge(int label)
{ appendCODE(makeCODEif_icmpge(label,NULL));
}

void code_if_icmpne(int label)
{ appendCODE(makeCODEif_icmpne(label,NULL));
}

void code_ireturn()
{ appendCODE(makeCODEireturn(NULL));
}

void code_areturn()
{ appendCODE(makeCODEareturn(NULL));
}

void code_return()
{ appendCODE(makeCODEreturn(NULL));
}
 
void code_aload(int arg)
{ appendCODE(makeCODEaload(arg,NULL));
}

void code_astore(int arg)
{ appendCODE(makeCODEastore(arg,NULL));
}

void code_iload(int arg)
{ appendCODE(makeCODEiload(arg,NULL));
}

void code_istore(int arg)
{ appendCODE(makeCODEistore(arg,NULL));
}

void code_dup()
{ appendCODE(makeCODEdup(NULL));
}

void code_pop()
{ appendCODE(makeCODEpop(NULL));
}

void code_swap()
{ appendCODE(makeCODEswap(NULL));
}

void code_ldc_int(int arg)
{ appendCODE(makeCODEldc_int(arg,NULL));
}

void code_ldc_string(char *arg)
{ appendCODE(makeCODEldc_string(arg,NULL));
}

void code_aconst_null()
{ appendCODE(makeCODEaconst_null(NULL));
}

void code_getfield(char *arg)
{ appendCODE(makeCODEgetfield(arg,NULL));
}

void code_putfield(char *arg)
{ appendCODE(makeCODEputfield(arg,NULL));
}

void code_invokevirtual(char *arg)
{ appendCODE(makeCODEinvokevirtual(arg,NULL));
}

void code_invokenonvirtual(char *arg)
{ appendCODE(makeCODEinvokenonvirtual(arg,NULL));
}

char *strcat2(char *s1, char *s2)
{ char *s;
  s = (char *)Malloc(strlen(s1)+strlen(s2)+1);
  sprintf(s,"%s%s",s1,s2);
  return s;
}

char *strcat3(char *s1, char *s2, char *s3)
{ char *s;
  s = (char *)Malloc(strlen(s1)+strlen(s2)+strlen(s3)+1);
  sprintf(s,"%s%s%s",s1,s2,s3);
  return s;
}

char *strcat4(char *s1, char *s2, char *s3, char *s4)
{ char *s;
  s = (char *)Malloc(strlen(s1)+strlen(s2)+strlen(s3)+strlen(s4)+1);
  sprintf(s,"%s%s%s%s",s1,s2,s3,s4);
  return s;
}

char *strcat5(char *s1, char *s2, char *s3, char *s4, char *s5)
{ char *s;
  s = (char *)Malloc(strlen(s1)+strlen(s2)+strlen(s3)+strlen(s4)+strlen(s5)+1);
  sprintf(s,"%s%s%s%s%s",s1,s2,s3,s4,s5);
  return s;
}

char *codePackage(char *package)
{ char *p;
  int i;
  p = (char *)Malloc(strlen(package)+2);
  for (i=0; i<strlen(package); i++) {
      if (package[i]=='.') p[i] = '/'; else p[i] = package[i];
  }
  p[i] = '/';
  p[i+1] = '\0';
  return p;
}

char *codeClassname(CLASS *c)
{ if (c->package==NULL) {
     return c->name;
  } else {
     return strcat2(codePackage(c->package),c->name);
  }
}

char *codeType(TYPE *t)
{ switch (t->kind) {
    case intK:
         return "I";
         break;
    case boolK:
         return "Z";
         break;
    case charK:
         return "C";
         break;
    case voidK:
         return "V";
         break;
    case refK:
         return strcat3("L",codeClassname(t->class),";");
         break;
    case polynullK:
         break;
  }
  return NULL;
}

char *codeFormals(FORMAL *f)
{ if (f==NULL) return "";
  return strcat2(codeFormals(f->next),codeType(f->type));
}

char *codeSignature(FORMAL *f, TYPE *t)
{ return strcat4("(",codeFormals(f),")",codeType(t));
}

char *codeConstructorSignature(FORMAL *f)
{ return strcat3("(",codeFormals(f),")V");
}

char *codeConstructor(CLASS *c, FORMAL *f)
{ return strcat3(codeClassname(c),"/<init>",codeConstructorSignature(f));
}

char *codeMethod(CLASS *c, METHOD *m)
{ return strcat4(codeClassname(c),
                 "/",
                 m->name,
                 codeSignature(m->formals,m->returntype));
}

void codePROGRAM(PROGRAM *p)
{ if (p!=NULL) {
     codePROGRAM(p->next);
     codeCLASSFILE(p->classfile);
  }
}

void codeCLASSFILE(CLASSFILE *c)
{ if (c!=NULL) {
     codeCLASSFILE(c->next);
     codeCLASS(c->class);
  }
}

CLASS *currentclass;

void codeCLASS(CLASS *c)
{ currentclass = c;
  codeCONSTRUCTOR(c->constructors);
  codeMETHOD(c->methods);
  c->signature = codeClassname(c);
}

void codeCONSTRUCTOR(CONSTRUCTOR *c)
{ if (c!=NULL) {
     codeCONSTRUCTOR(c->next);
     currentcode = NULL;
     c->labels = Malloc(c->labelcount*sizeof(LABEL));
     currentlabels = c->labels;
     codeSTATEMENT(c->statements);
     code_return();
     c->opcodes = currentcode;
     c->signature = codeConstructorSignature(c->formals);
  }
}

void codeMETHOD(METHOD *m)
{ if (m!=NULL) {
     codeMETHOD(m->next);
     currentcode = NULL;
     m->labels = Malloc(m->labelcount*sizeof(LABEL));
     currentlabels = m->labels;
     codeSTATEMENT(m->statements);
     if (m->returntype->kind==voidK) {
        code_return();
     } else {
        code_nop();
     }
     m->opcodes = currentcode;
     m->signature = codeSignature(m->formals,m->returntype);
  }
}

void codeSTATEMENT(STATEMENT *s)
{ if (s!=NULL) {
     switch (s->kind) {
       case skipK:
            break;
       case localK:
            break;
       case expK:
            codeEXP(s->val.expS);
            if (s->val.expS->type->kind!=voidK) {
               code_pop();
            }
            break;
       case returnK:
            if (s->val.returnS==NULL) {
               code_return();
            } else {
               codeEXP(s->val.returnS);
               if (s->val.returnS->type->kind==refK ||
                   s->val.returnS->type->kind==polynullK) {
                  code_areturn();
               } else {