Anyone here familiar with GENTLE?

122
Author
January 13, 2002 09:26 AM
Cus I got this pretty mystic problem: I downloaded the entire Gentle Compiler System and tried to make the compiler that where included in the package. However, when I tried to run through the lexical file gen.lit using REFLEX (also included), everything just stops with the reason "missing ''='' in argument". This is kinda weird, since everything looks fine in the sources and so on... Can someone around help me? -toki
toki!
eldee
122
January 13, 2002 09:32 AM
post some code.. we''re not psychic

-eldee
;another space monkey;
-eldee;another space monkey;[ Forced Evolution Studios ]
Tokikenshi
122
Author
January 13, 2002 09:38 AM
  gen.lit:")" { yysetpos(); return yytk_RPAREN; }"(" { yysetpos(); return yytk_LPAREN; }"/" { yysetpos(); return yytk_SLASH; }"*" { yysetpos(); return yytk_ASTERISK; }"-" { yysetpos(); return yytk_MINUS; }"+" { yysetpos(); return yytk_PLUS; }">=" { yysetpos(); return yytk_GREATER_EQUAL; }">" { yysetpos(); return yytk_GREATER; }"<=" { yysetpos(); return yytk_LESS_EQUAL; }"<" { yysetpos(); return yytk_LESS; }"#" { yysetpos(); return yytk_SHARP; }"odd" { yysetpos(); return yykw_odd; }"put" { yysetpos(); return yykw_put; }"do" { yysetpos(); return yykw_do; }"while" { yysetpos(); return yykw_while; }"then" { yysetpos(); return yykw_then; }"if" { yysetpos(); return yykw_if; }"end" { yysetpos(); return yykw_end; }"begin" { yysetpos(); return yykw_begin; }"call" { yysetpos(); return yykw_call; }":=" { yysetpos(); return yytk_COLON_EQUAL; }"procedure" { yysetpos(); return yykw_procedure; }"var" { yysetpos(); return yykw_var; }"=" { yysetpos(); return yytk_EQUAL; }"," { yysetpos(); return yytk_COMMA; }";" { yysetpos(); return yytk_SEMICOLON; }"const" { yysetpos(); return yykw_const; }"." { yysetpos(); return yytk_DOT; }virtual.g:/*****************************************************************************//*                                                                           *//*  A compiler for PL/0                                                      *//*                                                                           *//*  Source language and target machine of this compiler are described in     *//*                                                                           *//*  Niklaus Wirth                                                            *//*  Compilerbau                                                              *//*  B.G. Teubner, Stuttgart 1986                                             *//*                                                                           *//*****************************************************************************/-- Abstract syntax''type'' Block   block(ConstDecls, VarDecls, ProcDecls, Statement)''type'' ConstDecls   list(ConstDecl, ConstDecls), nil''type'' ConstDecl   const(IDENT, INT, POS)''type'' VarDecls   list(VarDecl, VarDecls), nil''type'' VarDecl   var(IDENT, POS)''type'' ProcDecls   list(ProcDecl, ProcDecls), nil''type'' ProcDecl   proc(IDENT, Block, POS)''type'' Statement   assign(IDENT, Expression, POS)   call(IDENT, POS)   seq(Statement, Statement)   if(Condition, Statement)   while(Condition, Statement)   null   put(Expression)''type'' Condition   odd(Expression)   rel(Op, Expression, Expression)''type'' Expression   neg(Expression)   binary(Op, Expression, Expression)   id(IDENT, POS)   int(INT)''type'' Op   plus, minus, times, div, eq, ne, lt, le, gt, ge''type'' IDENT-- Concrete syntax''root''   program(-> B)   trafo(B)''nonterm'' program(-> Block)''rule'' program(-> B):   block(-> B) "."''nonterm'' block(-> Block)''rule'' block(-> block(C, V, P, S)):   constpart(-> C) varpart(-> V) procpart(-> P) statement(-> S)''nonterm'' constpart(-> ConstDecls)''rule'' constpart(-> C): "const" constdeflist(-> C) ";"''rule'' constpart(-> nil):''nonterm'' constdeflist(-> ConstDecls)''rule'' constdeflist(-> list(D, L)): constdef(-> D) "," constdeflist(-> L)''rule'' constdeflist(-> list(D, nil)): constdef(-> D)''nonterm''constdef(-> ConstDecl)''rule'' constdef(-> const(I, N, Pos)): Ident(-> I) @(-> Pos) "=" Number(-> N)''nonterm'' varpart(-> VarDecls)''rule'' varpart(-> V): "var" vardecllist(-> V) ";"''rule'' varpart(-> nil):''nonterm'' vardecllist(-> VarDecls)''rule'' vardecllist(-> list(D, L)): vardecl(-> D) "," vardecllist(-> L)''rule'' vardecllist(-> list(D, nil)): vardecl(-> D)''nonterm'' vardecl(-> VarDecl)''rule'' vardecl(-> var(I, Pos)): Ident(-> I) @(-> Pos)''nonterm'' procpart(-> ProcDecls)''rule'' procpart(-> list(D, L)): procdef(-> D) procpart(-> L)''rule'' procpart(-> nil):''nonterm'' procdef(-> ProcDecl)''rule'' procdef(-> proc(I, B, Pos)):   "procedure" Ident(-> I) @(-> Pos) ";" block(-> B) ";"''nonterm'' statement(-> Statement)''rule'' statement(-> assign(I, E, P)): Ident(-> I) @(-> P) ":=" expression(-> E)''rule'' statement(-> call(I, P)): "call" Ident(-> I) @(-> P)''rule'' statement(-> S): "begin" statementlist(-> S) "end"''rule'' statement(-> if(C, S)): "if" condition(-> C) "then" statement(-> S)''rule'' statement(-> while(C, S)): "while" condition(-> C) "do" statement(-> S)''rule'' statement(-> put(E)): "put" expression(-> E)''rule'' statement(-> null):''nonterm'' statementlist(-> Statement)''rule'' statementlist(-> seq(S, L)): statement(-> S) ";" statementlist(-> L)''rule'' statementlist(-> S): statement(-> S)''nonterm'' condition(-> Condition)''rule'' condition(-> odd(E)): "odd" expression(-> E)''rule'' condition(-> rel(Op, E1, E2)):   expression(-> E1) relop(-> Op) expression(-> E2)''nonterm'' relop(-> Op)''rule'' relop(-> eq): "="''rule'' relop(-> ne): "#"''rule'' relop(-> lt): "<"''rule'' relop(-> le): "<="''rule'' relop(-> gt): ">"''rule'' relop(-> ge): ">="''nonterm'' expression(-> Expression)''rule'' expression(-> E): "+" term(-> E)''rule'' expression(-> neg(E)): "-" term(-> E)''rule'' expression(-> E): expr2(-> E)''nonterm'' expr2(-> Expression)''rule'' expr2(-> binary(Op, E1, E2)): expr2(-> E1) addop(-> Op) term(-> E2)''rule'' expr2(-> E): term(-> E)''nonterm'' addop(-> Op)''rule'' addop(-> plus): "+"''rule'' addop(-> minus): "-"''nonterm'' term(-> Expression)''rule'' term(-> binary(Op, E1, E2)): term(-> E1) mulop(-> Op) factor(-> E2)''rule'' term(-> E): factor(-> E)''nonterm'' mulop(-> Op)''rule'' mulop(-> times): "*"''rule'' mulop(-> div): "/"''nonterm'' factor(-> Expression)''rule'' factor(-> id(I, P)): Ident(-> I) @(-> P)''rule'' factor(-> int(N)): Number(-> N)''rule'' factor(-> E): "(" expression(-> E) ")"''token'' Ident(-> IDENT)''token'' Number(-> INT)-- Trafo''action'' trafo(Block)''rule'' trafo(B)   InitEnv   trBlock(B)   execute''var'' Offset: INT''action'' trBlock(Block)''rule'' trBlock(block(ConstDecls, VarDecls, ProcDecls, Statement)):   EnterScope   trConstDecls(ConstDecls)   Offset <- 3   trVarDecls(VarDecls)   Offset -> N   PC(-> X)   JMP(0)   trProcDecls(ProcDecls)   PATCH(X)   INT_(N)   trStatement(Statement)   OPR(0)   LeaveScope''action'' trConstDecls(ConstDecls)''rule'' trConstDecls(list(ConstDecl, ConstDecls)):   trConstDecl(ConstDecl)   trConstDecls(ConstDecls)''rule'' trConstDecls(nil):''action'' trConstDecl(ConstDecl)''rule'' trConstDecl(const(Id, N, Pos)):   Define(Id, const(N), Pos)''action'' trVarDecls(VarDecls)''rule'' trVarDecls(list(VarDecl, VarDecls)):   trVarDecl(VarDecl)   trVarDecls(VarDecls)''rule'' trVarDecls(nil):''action'' trVarDecl(VarDecl)''rule'' trVarDecl(var(Id, Pos)):   CurrentLevel -> L   Offset -> N   Offset <- N+1   Define(Id, var(L, N), Pos)''action'' trProcDecls(ProcDecls)''rule'' trProcDecls(list(ProcDecl, ProcDecls)):   trProcDecl(ProcDecl)   trProcDecls(ProcDecls)''rule'' trProcDecls(nil):''action'' trProcDecl(ProcDecl)''rule'' trProcDecl(proc(Id, Block, Pos)):   CurrentLevel -> Lev   PC(-> X)   Define(Id, proc(Lev, X), Pos)   trBlock(Block)''action'' trStatement(Statement)''rule'' trStatement(assign(Id, Expression, Pos)):   trExpression(Expression)   (| Apply(Id -> var(L, A))      CurrentLevel -> CurLev      STO(CurLev-L,A)   || ErrorI("[1] ''", Id, "'' not defined as variable", Pos)   |)''rule'' trStatement(call(Id, Pos)):   (| Apply(Id -> proc(L, A))      CurrentLevel -> CurLev      CAL(CurLev-L,A)   || ErrorI("[2] ''", Id, "'' not defined as procedure", Pos)   |)''rule'' trStatement(seq(Statement1, Statement2)):   trStatement(Statement1)   trStatement(Statement2)''rule'' trStatement(if(Condition, Statement)):   trCondition(Condition)   PC(-> X)   JPC(0)   trStatement(Statement)   PATCH(X)''rule'' trStatement(while(Condition, Statement)):   PC(-> X1)   trCondition(Condition)   PC(-> X2)   JPC(0)   trStatement(Statement)   JMP(X1)   PATCH(X2)''rule'' trStatement(null):''rule'' trStatement(put(Expression)):   trExpression(Expression)   OPR(14)''action'' trCondition(Condition)''rule'' trCondition(odd(Expression)):   trExpression(Expression)   OPR(6)''rule'' trCondition(rel(Op, Expression1, Expression2)):   trExpression(Expression1)   trExpression(Expression2)   OpCode(Op -> N)   OPR(N)''action'' trExpression(Expression)''rule'' trExpression(neg(Expression)):   trExpression(Expression)   OPR(1)''rule'' trExpression(binary(Op, Expression1, Expression2)):   trExpression(Expression1)   trExpression(Expression2)   OpCode(Op -> N)   OPR(N)''rule'' trExpression(id(Id, Pos)):   (| Apply(Id -> const(N))      LIT(N)   || Apply(Id -> var(L, A))      CurrentLevel -> CurLev      LOD(CurLev-L,A)   || ErrorI("[3] ''", Id, "'' not defined as constant or variable", Pos)   |)''rule'' trExpression(int(N)):   LIT(N) ''action'' OpCode(Op -> INT)''rule'' OpCode(plus -> 2)''rule'' OpCode(minus -> 3)''rule'' OpCode(times -> 4)''rule'' OpCode(div -> 5)''rule'' OpCode(eq -> 8)''rule'' OpCode(ne -> 9)''rule'' OpCode(lt -> 10)''rule'' OpCode(ge -> 11)''rule'' OpCode(gt -> 12)''rule'' OpCode(le -> 13)-- Error messages''action'' ErrorI (STRING, IDENT, STRING, POS)-- Instructions''action'' LIT(INT)''action'' OPR(INT)''action'' LOD(L: INT, A: INT)''action'' STO(L: INT, A: INT)''action'' CAL(L: INT, A: INT)''action'' INT_(INT)''action'' JMP(INT)''action'' JPC(INT)''action'' PC(-> INT)''action'' PATCH(INT)''action'' execute-- Scopes''type'' Object   const(INT)   var(Level: INT, Addr: INT)   proc(Level: INT, Addr: INT)''action'' DefMeaning (IDENT, ASSOC)''condition'' HasMeaning (IDENT -> ASSOC)''type'' ENV   env (NEST, ENV), emptyenv ''type'' NEST   nest (IDENT, NEST), emptynest''type'' ASSOC   assoc(Obj: Object, Level: INT, Hidden: ASSOC), noassoc''var'' CurrentEnv: ENV''var'' CurrentNest: NEST''var'' CurrentLevel: INT''action'' InitEnv''rule'' InitEnv :   CurrentEnv <- emptyenv   CurrentNest <- emptynest   CurrentLevel <- 0''action'' EnterScope''rule'' EnterScope :   CurrentEnv -> OldEnv   CurrentNest -> OldNest   CurrentEnv <- env(OldNest, OldEnv)   CurrentNest <- emptynest   CurrentLevel -> N   CurrentLevel <- N+1''action'' LeaveScope''rule'' LeaveScope :   CurrentEnv -> env (OldNest, OldEnv)   CurrentNest -> Nest   ForgetNest (Nest)   CurrentEnv <- OldEnv   CurrentNest <- OldNest   CurrentLevel -> N   CurrentLevel <- N-1''action'' Define (IDENT, Object, POS)''rule'' Define (Ident, Object, Pos) :   CurrentLevel -> ThisLev   (| HasMeaning(Ident -> Hidden)      where(Hidden -> assoc(_,L,_))      [| eq(L, ThisLev)	 ErrorI("[4] multiple declaration of ''", Ident, "''", Pos)      |]   || let(noassoc -> Hidden)   |)   DefMeaning (Ident, assoc(Object, ThisLev, Hidden))   CurrentNest -> Nest   CurrentNest <- nest(Ident, Nest)''condition'' Apply (IDENT -> Object)''rule'' Apply (Ident -> Object) :   HasMeaning (Ident -> assoc(Object,Lev,Hidden))''action'' ForgetNest (NEST)''rule'' ForgetNest (nest(Id, Nest)) :   HasMeaning (Id -> assoc(Obj, Lev, Hidden))   DefMeaning (Id, Hidden)   ForgetNest (Nest)''rule'' ForgetNest (emptynest) :
toki!
Ronin_54
122
January 13, 2002 09:44 AM
Eldee: LOL! Well, you asked for it... Happy reading