AssignNode MakeDictAssign(DictGetNode n, ExprNode n1, Lexer.TokenType op, Lexer.Position pos)
{
if (op == Lexer.TokenType.TOK_ASSIGN)
{
return(new AsgDictNode(n.Left, n.Right, n1, pos));
}
switch (op)
{
case Lexer.TokenType.TOK_PLUS:
case Lexer.TokenType.TOK_MINUS:
case Lexer.TokenType.TOK_MUL:
case Lexer.TokenType.TOK_DIV:
case Lexer.TokenType.TOK_MOD:
case Lexer.TokenType.TOK_SHL:
case Lexer.TokenType.TOK_SHR:
//case Lexer.TokenType.TOK_NOTAR:
case Lexer.TokenType.TOK_AND:
case Lexer.TokenType.TOK_OR:
case Lexer.TokenType.TOK_XOR:
case Lexer.TokenType.TOK_PLUSPLUS:
case Lexer.TokenType.TOK_MINUSMINUS:
case Lexer.TokenType.FTOK_PLUSPLUS_PREF:
case Lexer.TokenType.FTOK_MINUSMINUS_PREF:
return(new AsgArifmDictNode(n.Left, n.Right, n1, op, pos));
}
throw new ParserException("Can't assign to " + n.OpType, pos);
}
public GrammarDefinition(Lexer.TokenType tType, Symbol evalTo, params Symbol[] accepts)
{
Accepts = new List <Symbol>();
if (Accepts.Count > 0)
{
Accepts.AddRange(accepts);
}
TokenType = tType;
EvaluatesTo = evalTo;
}
public bool MoveIfPeekEquals(Lexer.TokenType tokenType)
{
if (Peek().Name.Equals(tokenType))
{
Move();
return(true);
}
else
{
return(false);
}
}
AssignNode MakeAssign(ExprNode n, ExprNode n1, Lexer.TokenType op, Lexer.Position pos)
{
if (n.OpType == ExprType.Ident)
{
return(MakeIdentAssign(n as IdentNode, n1, op, pos));
}
else if (n.OpType == ExprType.DictGet)
{
return(MakeDictAssign(n as DictGetNode, n1, op, pos));
}
throw new ParserException("Can't assign to " + n.OpType, pos);
}
public bool Parse()
{
token = lexer.GetNextToken();
if (delayinc)
{
depth++;
delayinc = false;
}
if (token == Lexer.TokenType.EOF)
{
depth = 0;
return(false);
}
/*
* Console.WriteLine("Token: " + token.ToString() + " - " +
* lexer.TokenString);
*/
switch (token)
{
case Lexer.TokenType.CLOSE_PAREN:
if (depth == 0)
{
throw new Exception("Parse Error: unexpected )");
}
depth--;
type = LispType.END_LIST;
break;
case Lexer.TokenType.OPEN_PAREN:
type = LispType.START_LIST;
delayinc = true;
break;
case Lexer.TokenType.SYMBOL:
type = LispType.SYMBOL;
break;
case Lexer.TokenType.STRING:
type = LispType.STRING;
break;
case Lexer.TokenType.TRUE:
type = LispType.BOOLEAN;
break;
case Lexer.TokenType.INTEGER:
type = LispType.INTEGER;
break;
}
return(true);
}
public bool Parse()
{
token = lexer.GetNextToken();
if(delayinc) {
depth++;
delayinc = false;
}
if(token == Lexer.TokenType.EOF) {
depth = 0;
return false;
}
/*
Console.WriteLine("Token: " + token.ToString() + " - " +
lexer.TokenString);
*/
switch(token) {
case Lexer.TokenType.CLOSE_PAREN:
if(depth == 0)
throw new Exception("Parse Error: unexpected )");
depth--;
type = LispType.END_LIST;
break;
case Lexer.TokenType.OPEN_PAREN:
type = LispType.START_LIST;
delayinc = true;
break;
case Lexer.TokenType.SYMBOL:
type = LispType.SYMBOL;
break;
case Lexer.TokenType.STRING:
type = LispType.STRING;
break;
case Lexer.TokenType.TRUE:
type = LispType.BOOLEAN;
break;
case Lexer.TokenType.INTEGER:
type = LispType.INTEGER;
break;
}
return true;
}
ArifmOperation GetOperation(Lexer.TokenType op)
{
switch (op)
{
case Lexer.TokenType.TOK_PLUS: return(new Addition());
case Lexer.TokenType.TOK_MINUS: return(new Subtraction());
case Lexer.TokenType.TOK_MUL: return(new Multiplication());
case Lexer.TokenType.TOK_DIV: return(new Division());
case Lexer.TokenType.TOK_MOD: return(new Modulo());
case Lexer.TokenType.TOK_SHL: return(new Shl());
case Lexer.TokenType.TOK_SHR: return(new Shr());
case Lexer.TokenType.TOK_AND: return(new And());
case Lexer.TokenType.TOK_OR: return(new Or());
case Lexer.TokenType.TOK_XOR: return(new Xor());
case Lexer.TokenType.TOK_LOGAND: return(new LogAnd());
case Lexer.TokenType.TOK_LOGOR: return(new LogOr());
case Lexer.TokenType.TOK_LESS: return(new Below());
case Lexer.TokenType.TOK_LESSEQ: return(new BelowEq());
case Lexer.TokenType.TOK_GREATER: return(new Above());
case Lexer.TokenType.TOK_GREATEQ: return(new AboveEq());
case Lexer.TokenType.TOK_EQUAL: return(new Equal());
case Lexer.TokenType.TOK_NOTEQ: return(new NEqual());
}
return(null);
}
ArifmOperation GetUnaryOperation(Lexer.TokenType op)
{
switch (op)
{
case Lexer.TokenType.TOK_PLUS: return(new Positive());
case Lexer.TokenType.TOK_MINUS: return(new Negative());
case Lexer.TokenType.TOK_NOTAR: return(new Not());
case Lexer.TokenType.TOK_NOT: return(new LogNot());
case Lexer.TokenType.TOK_PLUSPLUS: return(new Inc());
case Lexer.TokenType.TOK_MINUSMINUS: return(new Dec());
case Lexer.TokenType.FTOK_PLUSPLUS_PREF: return(new Inc());
case Lexer.TokenType.FTOK_MINUSMINUS_PREF: return(new Dec());
}
return(null);
}
public UnaryExprNode(ExprNode l, Lexer.TokenType op, Lexer.Position pos) : base(ExprType.Unary, pos)
{
Left = l;
ArifmOp = op;
}
public AsgArifmVarNode(IdentNode l, ExprNode r, Lexer.TokenType op, Lexer.Position pos) : base(l, r, op, ExprType.AsgArifm, pos)
{
}
public AsgArifmDictNode(ExprNode l, ExprNode m, ExprNode r, Lexer.TokenType op, Lexer.Position pos) : base(l, r, op, ExprType.AsgArifmDict, pos)
{
Key = m;
}
protected AsgArifmNode(ExprNode l, ExprNode r, Lexer.TokenType op, ExprType t, Lexer.Position pos) : base(l, r, t, pos)
{
ArifmOp = op;
}
public ArifmExprNode(ExprNode l, ExprNode r, Lexer.TokenType op, Lexer.Position pos) : base(l, r, ExprType.Arifm, pos)
{
ArifmOp = op;
}
public Token(Lexer.TokenType name, string value)
{
Name = name;
Value = value;
}
