public void IntExp(IntExp e)
{
switch (e.Value)
{
case 0:
il.Emit(OpCodes.Ldc_I4_0);
break;
case 1:
il.Emit(OpCodes.Ldc_I4_1);
break;
case 2:
il.Emit(OpCodes.Ldc_I4_2);
break;
case 3:
il.Emit(OpCodes.Ldc_I4_3);
break;
case 4:
il.Emit(OpCodes.Ldc_I4_4);
break;
case 5:
il.Emit(OpCodes.Ldc_I4_5);
break;
case 6:
il.Emit(OpCodes.Ldc_I4_6);
break;
case 7:
il.Emit(OpCodes.Ldc_I4_7);
break;
case 8:
il.Emit(OpCodes.Ldc_I4_8);
break;
default:
if (e.Value > -128 && e.Value < 127)
{
il.Emit(OpCodes.Ldc_I4_S, (byte)e.Value);
}
else if (e.Value > Int32.MinValue && e.Value < Int32.MaxValue)
{
il.Emit(OpCodes.Ldc_I4, (int)e.Value);
}
else
{
il.Emit(OpCodes.Ldc_I8, e.Value);
}
break;
}
}
Exp MatchExp()
{
AlphaToken at;
Object o1;
switch (((Token)tokens.Peek()).Type)
{
case TokenType.NIL:
tokens.Dequeue();
return(new StringExp(String.Empty)); //NIL is represented as an empty string
case TokenType.NUMBER:
return(new IntExp(((NumberToken)tokens.Dequeue()).Value));
case TokenType.STRING:
return(new StringExp(((StringToken)tokens.Dequeue()).Value));
case TokenType.ALPHA:
at = (AlphaToken)tokens.Dequeue();
if (DoVars != null && DoVars.Count != 0)
{
o1 = DoVars[at.Name];
if (o1 != null)
{
return(new DoVarExp(at.Name, (int)o1));
}
}
if (CurrentVarScope != null && CurrentVarScope.Count != 0)
{
o1 = CurrentVarScope[at.Name];
if (o1 != null)
{
return(new VarExp(at.Name, (int)o1));
}
}
o1 = GlobalVars[at.Name];
if (o1 != null)
{
return(new GlobalVarExp(at.Name));
}
Console.WriteLine("Error 6: Undefined Symbol " + at.Name);
return(null);
case TokenType.LPAREN:
MatchToken(TokenType.LPAREN);
Exp e1, e2, e3;
Exp [] ea;
//ListExp el1, el2, el3;
Token o;
switch (((Token)tokens.Peek()).Type)
{
case TokenType.PLUS:
case TokenType.MINUS:
case TokenType.MUL:
case TokenType.DIVIDE:
o = (Token)tokens.Dequeue();
e1 = MatchExp();
e2 = MatchExp();
MatchToken(TokenType.RPAREN);
return(new BinopExp(e1, o, e2));
case TokenType.LT:
case TokenType.GT:
case TokenType.EQ:
case TokenType.LE:
case TokenType.GE:
o = (Token)tokens.Dequeue();
e1 = MatchExp();
e2 = MatchExp();
MatchToken(TokenType.RPAREN);
return(new CompareExp(e1, o, e2));
case TokenType.CDR:
tokens.Dequeue();
e1 = MatchExp();
MatchToken(TokenType.RPAREN);
ea = new Exp[1];
ea[0] = e1;
return(new CallExp("LispRuntime", "Cdr", ea, typeof(CList)));
case TokenType.CAR:
tokens.Dequeue();
e1 = MatchExp();
MatchToken(TokenType.RPAREN);
return(new CarExp(e1));
case TokenType.CONS:
tokens.Dequeue();
e1 = MatchExp();
e2 = MatchExp();
MatchToken(TokenType.RPAREN);
ea = new Exp[2];
ea[0] = e1;
ea[1] = e2;
return(new CallExp("LispRuntime", "Cons", ea, typeof(CList)));
case TokenType.SUBST:
tokens.Dequeue();
e1 = MatchExp();
e2 = MatchExp();
e3 = MatchExp();
MatchToken(TokenType.RPAREN);
ea = new Exp[3];
ea[0] = e1;
ea[1] = e2;
ea[2] = e3;
return(new CallExp("LispRuntime", "Subst", ea, typeof(CList)));
case TokenType.NULL:
tokens.Dequeue();
e1 = MatchExp();
MatchToken(TokenType.RPAREN);
ea = new Exp[1];
ea[0] = e1;
return(new CallExp("LispRuntime", "IsNull", ea, typeof(bool)));
case TokenType.ATOM:
tokens.Dequeue();
e1 = MatchExp();
MatchToken(TokenType.RPAREN);
ea = new Exp[1];
ea[0] = e1;
return(new CallExp("LispRuntime", "IsAtom", ea, typeof(bool)));
case TokenType.IF:
tokens.Dequeue();
e1 = MatchExp();
e2 = MatchExp();
e3 = MatchExp();
MatchToken(TokenType.RPAREN);
return(new IfExp(e1, e2, e3));
case TokenType.DO:
tokens.Dequeue();
MatchToken(TokenType.LPAREN);
ExpList el1, el2;
if (CurrentVarScope == null)
{
Console.WriteLine("Error 13: Do must be present in a Function");
success = false;
return(null);
}
el1 = MatchDoExpList();
MatchToken(TokenType.RPAREN);
//MatchToken(TokenType.LPAREN);
el2 = MatchDoCondList();
MatchToken(TokenType.RPAREN);
return(new DoExp(el1, el2));
case TokenType.SETQ:
tokens.Dequeue();
AlphaToken t1 = (AlphaToken)MatchToken(TokenType.ALPHA);
if (((Token)tokens.Peek()).Type == TokenType.NUMBER)
{
e1 = new IntExp(((NumberToken)tokens.Dequeue()).Value);
}
else
{
e1 = MatchExp();
}
GlobalVars.Add(t1.Name, typeof(int));
MatchToken(TokenType.RPAREN);
return(new GlobalVarDef(t1.Name, e1));
case TokenType.DEFUN:
ArrayList param = new ArrayList();
int count = 0;
if (CurrentVarScope != null)
{
Console.WriteLine("Error 12: Nested Functions Not Allowed");
success = false;
return(null);
}
CurrentVarScope = new Hashtable();
DoVars = new Hashtable();
DoVarsCount = 0;
tokens.Dequeue();
AlphaToken t = (AlphaToken)MatchToken(TokenType.ALPHA);
MatchToken(TokenType.LPAREN);
while (((Token)tokens.Peek()).Type == TokenType.ALPHA)
{
param.Add(((AlphaToken)tokens.Dequeue()).Name);
CurrentVarScope.Add(param[count], count++);
}
MatchToken(TokenType.RPAREN);
//CurrentVarScope = param;
Functions.Add(t.Name, count);
e1 = MatchExp();
CurrentVarScope = null;
MatchToken(TokenType.RPAREN);
return(new FunctionDef(t.Name, param, e1));
case TokenType.ALPHA:
at = (AlphaToken)tokens.Dequeue();
int iparams;
if (Functions == null || Functions.Count == 0)
{
Console.WriteLine("Error 6: Undefined Symbol " + at.Name);
return(null);
}
else
{
o1 = Functions[at.Name];
if (o1 == null)
{
Console.WriteLine("Error 6: Undefined Symbol " + at.Name);
return(null);
}
else
{
iparams = (int)o1;
}
}
Exp [] eparams = new Exp[iparams];
for (int i = 0; i < iparams; i++)
{
eparams[i] = MatchExp();
}
MatchToken(TokenType.RPAREN);
return(new CallExp(null, at.Name, eparams));
default:
o = null;
Console.WriteLine("Error 1");
success = false;
return(null);
}
default:
Console.WriteLine("Error 7: Unexpected Token");
tokens.Dequeue();
success = false;
return(null);
}
}
public void IntExp(IntExp e)
{
e.ExpType = typeof(int);
}
