private Syntax.Expression ParseInitializer()
{
Syntax.Expression res = null;
if (scan.Peek().type == Token.Type.LBRACE)
{
scan.Read();
res = new Syntax.Initializer();
Syntax.InitializerList init_list = null;
while (true)
{
if ((init_list = ParseInitializerList()) != null)
{
((Syntax.Initializer)res).AddInitializer(init_list);
}
if (scan.Peek().type != Token.Type.COMMA)
{
break;
}
scan.Read();
}
CheckToken(scan.Peek(), Token.Type.RBRACE, true);
}
else
{
res = ParseAssignmentExpression();
}
return(res);
}
private Syntax.Expression ParsePostfixExpr(Syntax.Expression expr_node = null)
{
Syntax.Expression node = expr_node == null?this.ParsePrimaryExpr() : expr_node, res = null;
while (true)
{
switch (scan.Peek().type)
{
case Token.Type.OP_INC:
case Token.Type.OP_DEC:
res = new Syntax.UnaryOperator(scan.Read(), false);
((Syntax.UnaryOperator)res).SetOperand(node);
break;
case Token.Type.OP_DOT:
case Token.Type.OP_REF:
res = new Syntax.Refference(scan.Read());
((Syntax.Refference)res).SetExpression(node);
CheckToken(scan.Peek(), Token.Type.IDENTIFICATOR);
((Syntax.Refference)res).SetRefference(new Syntax.Identifier(scan.Read()));
break;
case Token.Type.LPAREN:
res = new Syntax.Call(scan.Read());
((Syntax.Call)res).SetOperand(node);
try
{
if (scan.Peek().type == Token.Type.RPAREN)
{
((Syntax.Call)res).SetArgumentList(new List <Syntax.Expression>());
scan.Read();
break;
}
((Syntax.Call)res).SetArgumentList(this.ParseArgExpressionList());
}
catch (Symbols.Exception e)
{
this.logger.Add(e);
}
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
break;
case Token.Type.LBRACKET:
res = new Syntax.Refference(scan.Read());
((Syntax.Refference)res).SetExpression(node);
((Syntax.Refference)res).SetRefference(this.ParseExpression());
CheckToken(scan.Peek(), Token.Type.RBRACKET, true);
break;
default:
return(res == null? node: res);
}
if (res != null)
{
node = res;
}
}
}
private Syntax.Expression ParseAssignmentExpression()
{
Syntax.Expression node = ParseUnaryExpr();
if (node == null)
{
return(null);
}
return(ParseBinaryOper(0, node, true));
}
private Syntax.Expression ParseExpression()
{
Syntax.Expression node = ParseUnaryExpr();
if (node != null)
{
node = ParseBinaryOper(0, node);
}
return(node);
}
private Syntax.Expression ParseBinaryOper(int level, Syntax.Expression lnode, bool stop_if_comma = false)
{
Syntax.Expression root = null;
while (true)
{
Syntax.Object.CheckObject(lnode);
if (scan.Peek().type == Token.Type.QUESTION)
{
scan.Read();
Syntax.Expression expr = ParseExpression();
CheckToken(scan.Peek(), Token.Type.COLON, true);
root = new Syntax.Ternary(lnode);
((Syntax.Ternary)root).SetBranchTrue(expr);
((Syntax.Ternary)root).SetBranchFalse(ParseExpression());
lnode = root;
}
int op_level = GetOperatorPriority(scan.Peek());
if (op_level < level || (stop_if_comma && scan.Peek().type == Token.Type.COMMA))
{
return(lnode);
}
if (this.parse_const_expr && op_level == 2)
{
throw new Syntax.Exception("недопустимый оператор в константном выражении", scan.GetPos(), scan.GetLine());
}
Token oper = scan.Read();
Syntax.Expression rnode = ParseUnaryExpr();
int level_next_oper = GetOperatorPriority(scan.Peek());
try
{
if (op_level < level_next_oper)
{
rnode = ParseBinaryOper(op_level + 1, rnode, stop_if_comma);
}
root = new Syntax.BinaryOperator(oper);
((Syntax.BinaryOperator)root).SetLeftOperand(lnode);
((Syntax.BinaryOperator)root).SetRightOperand(rnode);
}
catch (Syntax.Exception e)
{
ToHandlerException(e);
}
lnode = root;
}
}
private Syntax.Expression ParseConstExpr()
{
this.parse_const_expr = true;
Syntax.Expression node = ParseUnaryExpr();
if (node != null)
{
node = ParseBinaryOper(0, node, true);
}
this.parse_const_expr = false;
return(node);
}
public void SetSize(Syntax.Expression size)
{
Syntax.Object.CheckObject(size);
try
{
this.size = size.ComputeConstIntValue();
}
catch (Syntax.CanNotCalculated e)
{
throw e;
}
this.ComputeSizeType();
}
private Syntax.Expression ParsePrimaryExpr()
{
Syntax.Expression res = null;
switch (scan.Peek().type)
{
case Token.Type.CONST_CHAR:
res = new Syntax.Const(scan.Read(), tstack.GetType("char"));
break;
case Token.Type.CONST_DOUBLE:
res = new Syntax.Const(scan.Read(), tstack.GetType("double"));
break;
case Token.Type.CONST_INT:
res = new Syntax.Const(scan.Read(), tstack.GetType("int"));
break;
case Token.Type.CONST_STRING:
this.count_string++;
Symbols.ARRAY strt = new Symbols.ARRAY(tstack.GetType("char"));
Token str = scan.Read();
strt.SetSize(new Syntax.Const(str.GetStrVal().Length.ToString(), tstack.GetType("int")));
res = new Syntax.Const(str, strt);
break;
case Token.Type.IDENTIFICATOR:
Token t = scan.Read();
Symbols.Var v = new Symbols.SuperVar();
try
{
v = tstack.GetVariable(t);
}
catch (Symbols.Exception e)
{
this.logger.Add(e);
}
res = new Syntax.Identifier(t, v);
break;
case Token.Type.LPAREN:
scan.Read();
res = ParseExpression();
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
break;
}
return(res);
}
private Syntax.InitializerList.Designation ParseDesignation()
{
Syntax.InitializerList.Designation designation = null, subdisignation = null;
while (true)
{
if (scan.Peek().type == Token.Type.COMMA)
{
CheckToken(scan.Peek(), Token.Type.IDENTIFICATOR);
subdisignation = new Syntax.InitializerList.Designation();
subdisignation.SetDesignator(new Syntax.Identifier(scan.Read()));
}
else if (scan.Peek().type == Token.Type.LBRACKET)
{
scan.Read();
Syntax.Expression const_expr = ParseConstExpr();
Syntax.Object.CheckObject(const_expr);
subdisignation = new Syntax.InitializerList.Designation();
subdisignation.SetDesignator(const_expr);
CheckToken(scan.Peek(), Token.Type.RBRACKET, true);
}
if (subdisignation == null)
{
break;
}
if (designation == null)
{
designation = subdisignation;
}
else
{
designation.SetDesignator(subdisignation);
}
subdisignation = null;
}
return(designation);
}
private Syntax.InitializerList ParseInitializerList()
{
Syntax.InitializerList res = null;
while (true)
{
Syntax.InitializerList.Designation designation = ParseDesignation();
Syntax.Expression const_val = null;
if (designation != null)
{
CheckToken(scan.Peek(), Token.Type.OP_ASSIGN, true);
const_val = ParseInitializer();
Syntax.Object.CheckObject(const_val);
}
else
{
const_val = ParseConstExpr();
}
if (const_val != null)
{
if (res == null)
{
res = new Syntax.InitializerList();
}
res.AddInitializer(const_val, designation);
}
if (scan.Peek().type != Token.Type.COMMA || const_val == null)
{
break;
}
scan.Read();
}
return(res);
}
private Syntax.Statement ParseStmt()
{
Syntax.Statement node = null;
const string NOT_CYCLE = "оператор можно использовать только внутри цикла";
switch (scan.Peek().type)
{
case Token.Type.KW_WHILE:
this.parse_cycle = true;
try
{
scan.Read();
CheckToken(scan.Peek(), Token.Type.LPAREN, true);
Syntax.Expression cond = ParseExpression();
node = new Syntax.WHILE(cond);
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
((Syntax.WHILE)node).SetCycleStatement(ParseStmt());
}
catch (Exception e)
{
this.parse_cycle = false;
throw e;
}
break;
case Token.Type.KW_DO:
this.parse_cycle = true;
try
{
scan.Read();
node = new Syntax.DO(ParseStmt());
CheckToken(scan.Peek(), Token.Type.KW_WHILE, true);
CheckToken(scan.Peek(), Token.Type.LPAREN, true);
((Syntax.DO)node).SetCondition(ParseExpression());
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
CheckToken(scan.Peek(), Token.Type.SEMICOLON, true);
}
catch (Exception e)
{
this.parse_cycle = false;
throw e;
}
break;
case Token.Type.KW_FOR:
this.parse_cycle = true;
try
{
scan.Read();
CheckToken(scan.Peek(), Token.Type.LPAREN, true);
node = new Syntax.FOR();
((Syntax.FOR)node).SetCounter(
((Syntax.StatementExpression)ParseStmExpression()).GetExpression()
);
((Syntax.FOR)node).SetCondition(
((Syntax.StatementExpression)ParseStmExpression()).GetExpression()
);
if (scan.Peek().type != Token.Type.RPAREN)
{
((Syntax.FOR)node).SetIncriment(ParseExpression());
}
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
((Syntax.FOR)node).SetCycleStatement(ParseStmt());
}
catch (Exception e)
{
this.parse_cycle = false;
throw e;
}
break;
case Token.Type.KW_IF:
scan.Read();
CheckToken(scan.Peek(), Token.Type.LPAREN, true);
node = new Syntax.IF(ParseExpression());
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
((Syntax.IF)node).SetBranchTrue(ParseStmt());
if (scan.Peek().type == Token.Type.KW_ELSE)
{
scan.Read();
((Syntax.IF)node).SetBranchFalse(ParseStmt());
}
break;
case Token.Type.LBRACE:
node = ParseCompound();
break;
case Token.Type.KW_RETURN:
scan.Read();
if (scan.Peek().type != Token.Type.SEMICOLON)
{
node = new Syntax.RETURN(this.ret_func_type);
((Syntax.RETURN)node).SetValue(ParseExpression());
}
else
{
node = new Syntax.RETURN(this.ret_func_type);
((Syntax.RETURN)node).SetValue(new Syntax.EmptyExpression());
}
CheckToken(scan.Peek(), Token.Type.SEMICOLON, true);
break;
case Token.Type.KW_BREAK:
if (!this.parse_cycle)
{
this.logger.Add(new Syntax.Exception(NOT_CYCLE, scan.GetPos(), scan.GetLine()));
}
try
{
scan.Read();
node = new Syntax.BREAK();
CheckToken(scan.Peek(), Token.Type.SEMICOLON, true);
}
catch (Exception e)
{
if (this.parse_cycle)
{
throw e;
}
}
break;
case Token.Type.KW_CONTINUE:
if (!this.parse_cycle)
{
this.logger.Add(new Syntax.Exception(NOT_CYCLE, scan.GetPos(), scan.GetLine()));
}
try
{
scan.Read();
node = new Syntax.CONTINUE();
CheckToken(scan.Peek(), Token.Type.SEMICOLON, true);
}
catch (Exception e)
{
if (this.parse_cycle)
{
throw e;
}
}
break;
default:
node = ParseStmExpression();
break;
}
return(node);
}
private Syntax.Expression ParseUnaryExpr()
{
Syntax.UnaryOperator node = null;
switch (scan.Peek().type)
{
case Token.Type.OP_INC:
case Token.Type.OP_DEC:
case Token.Type.OP_BIT_AND:
case Token.Type.OP_STAR:
case Token.Type.OP_PLUS:
case Token.Type.OP_SUB:
case Token.Type.OP_TILDE:
case Token.Type.OP_NOT:
node = new Syntax.UnaryOperator(scan.Read());
node.SetOperand(this.ParseUnaryExpr());
return(node);
case Token.Type.LPAREN:
Syntax.Expression res = null;
Token t = scan.Read();
if (IsType(scan.Peek()))
{
res = new Syntax.Cast(t);
Symbols.ParamVar var = ParseParameterDeclaration(); //this is hack
((Syntax.Cast)res).SetTypeCast(var.GetType());
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
((Syntax.Cast)res).SetOperand(ParseUnaryExpr());
return(res);
}
res = ParseExpression();
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
return(ParsePostfixExpr(res));
case Token.Type.KW_SIZEOF:
node = new Syntax.UnaryOperator(scan.Read());
if (scan.Peek().type != Token.Type.LPAREN)
{
node.SetOperand(ParseUnaryExpr());
return(node);
}
scan.Read();
if (IsType(scan.Peek()))
{
((Syntax.UnaryOperator)node).SetOperand(new Syntax.Identifier(scan.Read()));
}
else
{
node.SetOperand(ParseExpression());
}
CheckToken(scan.Peek(), Token.Type.RPAREN, true);
return(node);
default:
return(ParsePostfixExpr());
}
}
public Exception(Syntax.Expression expr, string message)
: base("Семантическая ошибка", message, expr.GetIndex(), expr.GetLine())
{
}
public void SetInitializer(Syntax.Expression init)
{
this.value = init;
}
public VariableDeclaration(SourceSpan span, string name, string type, Expression value) : base(span, name)
{
Type = type;
Value = value;
}
public void SetInitializer(Syntax.Expression init)
{
this.value = init;
}
