摘自COCO/R手册，代码具有启发性
Sources of the Sample Compiler
B.1 Taste.ATG
COMPILER Taste
const int // types
undef = 0, integer = 1, boolean = 2;
const int // object kinds
var = 0, proc = 1;
public SymbolTable tab;
public CodeGenerator gen;
CHARACTERS
letter = 'A'..'Z' + 'a'..'z'.
digit = '0'..'9'.
TOKENS
ident = letter {letter | digit}.
number = digit {digit}.
COMMENTS FROM "/*" TO "*/" NESTED
COMMENTS FROM "//" TO '\n'
IGNORE '\r' + '\n' + '\t'
PRODUCTIONS
AddOp
= (. op = Op.ADD; .)
( '+'
| '-' (. op = Op.SUB; .)
).
/*------------------------------------------------------------------------*/
Expr
= SimExpr
[ RelOp
SimExpr
gen.Emit(op); type = boolean; .)
].
/*------------------------------------------------------------------------*/
Factor
= (. type = undef; .)
( Ident
if (obj.kind == var) {
if (obj.level == 0) gen.Emit(Op.LOADG, obj.adr);
else gen.Emit(Op.LOAD, obj.adr);
} else SemErr("variable expected"); .)
| number (. n = Convert.ToInt32(t.val);
gen.Emit(Op.CONST, n); type = integer; .)
| '-'
Factor
SemErr("integer type expected"); type = integer;
}
gen.Emit(Op.NEG); .)
| "true" (. gen.Emit(Op.CONST, 1); type = boolean; .)
| "false" (. gen.Emit(Op.CONST, 0); type = boolean; .)
).
/*------------------------------------------------------------------------*/
Ident
= ident (. name = t.val; .).
/*------------------------------------------------------------------------*/
35
MulOp
= (. op = Op.MUL; .)
( '*'
| '/' (. op = Op.DIV; .)
).
/*------------------------------------------------------------------------*/
ProcDecl (. string name; Obj obj; int adr; .)
= "void"
Ident
if (name == "Main") gen.progStart = gen.pc;
tab.OpenScope(); .)
'(' ')'
'{' (. gen.Emit(Op.ENTER, 0); adr = gen.pc - 2; .)
{ VarDecl | Stat }
'}' (. gen.Emit(Op.LEAVE); gen.Emit(Op.RET);
gen.Patch(adr, tab.topScope.nextAdr);
tab.CloseScope(); .).
/*------------------------------------------------------------------------*/
RelOp
= (. op = Op.EQU; .)
( "=="
| '<' (. op = Op.LSS; .)
| '>' (. op = Op.GTR; .)
).
/*------------------------------------------------------------------------*/
SimExpr
= Term
{ AddOp
Term
SemErr("integer type expected");
gen.Emit(op); .)
}.
/*------------------------------------------------------------------------*/
Stat (. int type; string name; Obj obj;
int adr, adr2, loopstart; .)
= Ident
( '=' (. if (obj.kind != var) SemErr("cannot assign to procedure"); .)
Expr
if (obj.level == 0) gen.Emit(Op.STOG, obj.adr);
else gen.Emit(Op.STO, obj.adr); .)
| '(' ')' ';' (. if (obj.kind != proc) SemErr("object is not a procedure");
gen.Emit(Op.CALL, obj.adr); .)
)
| "if"
'(' Expr
gen.Emit(Op.FJMP, 0); adr = gen.pc - 2; .)
Stat
[ "else" (. gen.Emit(Op.JMP, 0); adr2 = gen.pc - 2;
gen.Patch(adr, gen.pc);
adr = adr2; .)
Stat
] (. gen.Patch(adr, gen.pc); .)
| "while" (. loopstart = gen.pc; .)
'(' Expr
gen.Emit(Op.FJMP, 0); adr = gen.pc - 2; .)
Stat (. gen.Emit(Op.JMP, loopstart); gen.Patch(adr, gen.pc); .)
| "read"
Ident
if (obj.type != integer) SemErr("integer type expected");
gen.Emit(Op.READ);
if (obj.level == 0) gen.Emit(Op.STOG, obj.adr);
else gen.Emit(Op.STO, obj.adr); .)
36
| "write"
Expr
gen.Emit(Op.WRITE); .)
| '{' { Stat | VarDecl } '}' .
/*------------------------------------------------------------------------*/
Taste (. string name; .)
= "program" (. gen.Init(); tab.Init(); .)
Ident
'{'
{ VarDecl | ProcDecl }
'}' (. tab.CloseScope();
if (gen.progStart == -1) SemErr("main function never defined");
.).
/*------------------------------------------------------------------------*/
Term
= Factor
{ MulOp
Factor
SemErr("integer type expected");
gen.Emit(op); .)
}.
/*------------------------------------------------------------------------*/
Type
= (. type = undef; .)
( "int" (. type = integer; .)
| "bool" (. type = boolean; .)
).
/*------------------------------------------------------------------------*/
VarDecl (. string name; int type; .)
= Type
Ident
{ ',' Ident
} ';'.
END Taste.
37
B.2 SymTab.cs (symbol table)
using System;
namespace Taste {
public class Obj { // object decribing a declared name
public string name; // name of the object
public int type; // type of the object (undef for procs)
public Obj next; // to next object in same scope
public int kind; // var, proc, scope
public int adr; // address in memory or start of proc
public int level; // nesting level; 0=global, 1=local
public Obj locals; // scopes: to locally declared objects
public int nextAdr; // scopes: next free address in this scope
}
public class SymbolTable {
const int // types
undef = 0, integer = 1, boolean = 2;
const int // object kinds
var = 0, proc = 1, scope = 2;
public int curLevel; // nesting level of current scope
public Obj undefObj; // object node for erroneous symbols
public Obj topScope; // topmost procedure scope
Parser parser;
// open a new scope and make it the current scope (topScope)
public void OpenScope () {
Obj scop = new Obj();
scop.name = ""; scop.kind = scope;
scop.locals = null; scop.nextAdr = 0;
scop.next = topScope; topScope = scop;
curLevel++;
}
// close the current scope
public void CloseScope () {
topScope = topScope.next; curLevel--;
}
// create a new object node in the current scope
public Obj NewObj (string name, int kind, int type) {
Obj p, last, obj = new Obj();
obj.name = name; obj.kind = kind; obj.type = type;
obj.level = curLevel;
p = topScope.locals; last = null;
while (p != null) {
if (p.name == name) parser.SemErr("name declared twice");
last = p; p = p.next;
}
if (last == null) topScope.locals = obj; else last.next = obj;
if (kind == var) obj.adr = topScope.nextAdr++;
return obj;
}
38
// search the name in all open scopes and return its object node
public Obj Find (string name) {
Obj obj, scope;
scope = topScope;
while (scope != null) { // for all scopes
obj = scope.locals;
while (obj != null) { // for all objects in this scope
if (obj.name == name) return obj;
obj = obj.next;
}
scope = scope.next;
}
parser.SemErr(name + " is undeclared");
return undefObj;
}
public SymbolTable (Parser parser) {
this.parser = parser;
topScope = null;
curLevel = -1;
undefObj = new Obj();
undefObj.name = "undef"; undefObj.type = undef; undefObj.kind = var;
undefObj.adr = 0; undefObj.level = 0; undefObj.next = null;
}
} // end SymbolTable
} // end namespace
39
B.3 CodeGen.cs (code generator)
using System;
using System.IO;
namespace Taste {
public enum Op { // opcodes
ADD, SUB, MUL, DIV, EQU, LSS, GTR, NEG,
LOAD, LOADG, STO, STOG, CONST,
CALL, RET, ENTER, LEAVE, JMP, FJMP, READ, WRITE
}
public class CodeGenerator {
string[] opcode =
{"ADD ", "SUB ", "MUL ", "DIV ", "EQU ", "LSS ", "GTR ", "NEG ",
"LOAD ", "LOADG", "STO ", "STOG ", "CONST", "CALL ", "RET ", "ENTER",
"LEAVE", "JMP ", "FJMP ", "READ ", "WRITE"};
public int progStart; // address of first instruction of main program
public int pc; // program counter
byte[] code = new byte[3000];
// data for Interpret
int[] globals = new int[100];
int[] stack = new int[100];
int top; // top of stack
int bp; // base pointer
//----- code generation methods -----
public void Put(int x) { code[pc++] = (byte)x; }
public void Emit (Op op) { Put((int)op); }
public void Emit (Op op, int val) { Emit(op); Put(val>>8); Put(val); }
public void Patch (int adr, int val) {
code[adr] = (byte)(val>>8); code[adr+1] = (byte)val;
}
public void Decode() {
int maxPc = pc; pc = 1;
while (pc < maxPc) {
Op code = (Op)Next();
Console.Write("{0,3}: {1} ", pc-1, opcode[(int)code]);
switch(code) {
case Op.LOAD: case Op.LOADG: case Op.CONST: case Op.STO: case Op.STOG:
case Op.CALL: case Op.ENTER: case Op.JMP: case Op.FJMP:
Console.WriteLine(Next2()); break;
case Op.ADD: case Op.SUB: case Op.MUL: case Op.DIV: case Op.NEG:
case Op.EQU: case Op.LSS: case Op.GTR: case Op.RET: case Op.LEAVE:
case Op.READ: case Op.WRITE:
Console.WriteLine(); break;
}
}
}
//----- interpreter methods -----
int Next () {
return code[pc++];
}
int Next2 () {
int x, y;
x = (sbyte)code[pc++]; y = code[pc++];
return (x << 8) + y;
}
40
int Int (bool b) {
if (b) return 1; else return 0;
}
void Push (int val) {
stack[top++] = val;
}
int Pop() {
return stack[--top];
}
int ReadInt(FileStream s) {
int ch, sign, n = 0;
do {ch = s.ReadByte();} while (!(ch >= '0' && ch <= '9' || ch == '-'));
if (ch == '-') {sign = -1; ch = s.ReadByte();} else sign = 1;
while (ch >= '0' && ch <= '9') {
n = 10 * n + (ch - '0');
ch = s.ReadByte();
}
return n * sign;
}
public void Interpret (string data) {
int val;
try {
FileStream s = new FileStream(data, FileMode.Open);
Console.WriteLine();
pc = progStart; stack[0] = 0; top = 1; bp = 0;
for (;;) {
switch ((Op)Next()) {
case Op.CONST: Push(Next2()); break;
case Op.LOAD: Push(stack[bp+Next2()]); break;
case Op.LOADG: Push(globals[Next2()]); break;
case Op.STO: stack[bp+Next2()] = Pop(); break;
case Op.STOG: globals[Next2()] = Pop(); break;
case Op.ADD: Push(Pop()+Pop()); break;
case Op.SUB: Push(-Pop()+Pop()); break;
case Op.DIV: val = Pop(); Push(Pop()/val); break;
case Op.MUL: Push(Pop()*Pop()); break;
case Op.NEG: Push(-Pop()); break;
case Op.EQU: Push(Int(Pop()==Pop())); break;
case Op.LSS: Push(Int(Pop()>Pop())); break;
case Op.GTR: Push(Int(Pop()
case Op.FJMP: val = Next2(); if (Pop()==0) pc = val; break;
case Op.READ: val = ReadInt(s); Push(val); break;
case Op.WRITE: Console.WriteLine(Pop()); break;
case Op.CALL: Push(pc+2); pc = Next2(); break;
case Op.RET: pc = Pop(); if (pc == 0) return; break;
case Op.ENTER: Push(bp); bp = top; top = top + Next2(); break;
case Op.LEAVE: top = bp; bp = Pop(); break;
default: throw new Exception("illegal opcode");
}
}
} catch (IOException) {
Console.WriteLine("--- Error accessing file {0}", data);
System.Environment.Exit(0);
}
}
public CodeGenerator () { pc = 1; progStart = -1; }
} // end CodeGen
} // end namespace
41
B.4 Taste.cs (main program)
using System;
namespace Taste {
class Taste {
public static void Main (string[] arg) {
if (arg.Length > 0) {
Scanner scanner = new Scanner(arg[0]);
Parser parser = new Parser(scanner);
parser.tab = new SymbolTable(parser);
parser.gen = new CodeGenerator();
parser.Parse();
if (parser.errors.count == 0) {
parser.gen.Decode();
parser.gen.Interpret("Taste.IN");
}
} else {
Console.WriteLine("-- No source file specified");
}
}
}
} // end namespace