public StructAssign ParseAssign(ref int i)
{
if (toks.Tokes[i].Token != Token.Id)
{
Error(i, "Expecting identifier");
}
Log("Parsing Assign", i);
var assign = new StructAssign();
while (true)
{
var var_name = toks.Tokes[i].Text;
if (var_name == ".")
{
i++;
continue;
}
if (var_name == "=")
{
i--;
break;
}
else
{
i++;
var nv = new Var();
nv.Name = var_name;
assign.Vars.Add(nv);
}
}
if (assign.Vars[0].Name == "ti")
{
int bb = 1;
}
AssertTok(i + 1, Token.Equal, "Expecting =");
i = i + 2;
bool call = false;
// assign.Vars.Add(av);
if (!call)
{
StructExpr exp = ParseExp(ref i);
assign.Expr.Add(exp);
}
Log("End of assign:", i);
return(assign);
}
public void TestExpr(StructExpr expr)
{
if (expr.Expr.Count > 0)
{
foreach (var se in expr.Expr)
{
TestExpr(se);
}
}
else
{
switch (expr.Type)
{
case ExprType.VarValue:
case ExprType.ClassValue:
isObj = true;
break;
}
}
}
public StructExpr ParseExp(ref int i)
{
Log("Parsing expressionj", i);
var exp = new StructExpr();
bool prev_op = false;
bool first_toke = true;
bool prev_op_min = false;
for (i = i; i < toks.Len; i++)
{
switch (Get(i).Token)
{
case Token.New:
Console.WriteLine("New");
var newe = new StructExpr();
newe.NewClass = true;
newe.Type = ExprType.NewClass;
newe.NewClassType = Get(i + 1).Text;
Log("New Class:" + newe.NewClassType);
i = NextToken(i, Token.LeftPara);
exp.Expr.Add(newe);
//i--;
if (Get(i + 1).Text != ")")
{
newe.NewPars = ParseCallPars(ref i);
}
else
{
i++;
}
return(exp);
break;
break;
case Token.RightPara:
case Token.EndLine:
case Token.Comma:
Log("Expr:" + exp.DebugString(), i);
return(exp);
break;
case Token.Id:
Log("VarInExpr:" + Get(i).Text, i);
var ie = new StructExpr();
ie.Type = ExprType.ClassVar;
while (true)
{
var ve = new StructExpr();
ve.Type = ExprType.VarValue;
ve.VarName = Get(i).Text;
ie.Expr.Add(ve);
if (Get(i + 1).Text == ".")
{
i += 2;
continue;
}
else
{
if (Get(i + 1).Text == "(")
{
if (Get(i + 2).Text == ")")
{
i = i + 2;
}
else
{
i++;
ve.CallPars = ParseCallPars(ref i);
}
}
break;
}
}
exp.Expr.Add(ie);
if (!prev_op && !first_toke)
{
Error(i, "Expecting operator.");
}
prev_op = false;
first_toke = false;
break;
case Token.LeftPara:
i++;
var sub_e = ParseExp(ref i);
first_toke = false;
sub_e.Type = ExprType.SubExpr;
exp.Expr.Add(sub_e);
break;
case Token.Greater:
if (prev_op || first_toke)
{
Error(i, "Expecting value.");
}
var more_op = new StructExpr();
more_op.Op = OpType.MoreThan;
more_op.Type = ExprType.Operator;
exp.Expr.Add(more_op);
prev_op = true;
break;
case Token.Lesser:
if (prev_op || first_toke)
{
Error(i, "Expecting value.");
}
var less_op = new StructExpr();
less_op.Op = OpType.LessThan;
less_op.Type = ExprType.Operator;
exp.Expr.Add(less_op);
prev_op = true;
break;
case Token.Equal:
if (prev_op || first_toke)
{
Error(i, "Expecting value.");
}
var equal_op = new StructExpr();
equal_op.Op = OpType.EqualTo;
equal_op.Type = ExprType.Operator;
exp.Expr.Add(equal_op);
prev_op = true;
break;
case Token.Plus:
if (prev_op || first_toke)
{
Error(i, "Expecting value.");
}
var ep = new StructExpr();
ep.Op = OpType.Plus;
ep.Type = ExprType.Operator;
exp.Expr.Add(ep);
prev_op = true;
break;
case Token.Minus:
if (prev_op_min)
{
Error(i, "too many negations operators.");
}
if (prev_op)
{
if (first_toke)
{
Error(i, "Illegal minus op.");
}
var nv = new StructExpr();
nv.Type = ExprType.Operator;
nv.Op = OpType.Minus;
exp.Expr.Add(nv);
prev_op = true;
prev_op_min = true;
continue;
//Error(i, "Expecting value.");
}
var em = new StructExpr();
em.Type = ExprType.Operator;
em.Op = OpType.Minus;
exp.Expr.Add(em);
prev_op = true;
break;
case Token.Div:
if (prev_op || first_toke)
{
Error(i, "Expecting value.");
}
Log("Times?", i);
var ed = new StructExpr();
ed.Type = ExprType.Operator;
ed.Op = OpType.Divide;
exp.Expr.Add(ed);
prev_op = true;
break;
case Token.Multi:
if (prev_op || first_toke)
{
Error(i, "Expecting value.");
}
var eo = new StructExpr();
eo.Type = ExprType.Operator;
eo.Op = OpType.Times;
exp.Expr.Add(eo);
prev_op = true;
break;
case Token.String:
if (!prev_op && !first_toke)
{
Error(i, "Expecting operator.");
}
prev_op = false;
var es = new StructExpr();
es.StringV = Get(i).Text;
es.Type = ExprType.StringValue;
exp.Expr.Add(es);
first_toke = false;
break;
case Token.Float:
if (!prev_op && !first_toke)
{
Error(i, "Expecting operator.");
}
prev_op = false;
var evf = new StructExpr();
evf.floatV = float.Parse(Get(i).Text);
evf.Type = ExprType.FloatValue;
exp.Expr.Add(evf);
first_toke = false;
break;
case Token.Int:
case Token.Short:
case Token.Long:
case Token.Double:
if (!prev_op && !first_toke)
{
Error(i, "Expecting operator.");
}
prev_op = false;
var ev = new StructExpr();
ev.intV = int.Parse(Get(i).Text);
ev.Type = ExprType.IntValue;
exp.Expr.Add(ev);
first_toke = false;
break;
default:
Error(i, "Illegal token within expression:" + Get(i).ToString());
break;
}
}
Log("Expr:" + exp.DebugString(), i);
return(exp);
}
public void WriteExpr(StructExpr expr)
{
if (expr.Expr.Count > 0)
{
int ei = 0;
foreach (var se in expr.Expr)
{
WriteExpr(se);
ei++;
if (ei < expr.Expr.Count)
{
isObj = false;
TestExpr(expr.Expr[ei]);
//if(expr.Expr[ei].Type
}
if (ei < expr.Expr.Count)
{
if (!osfuncs.Contains(pobj) && pobj != "N" && isObj == true)
{
C(".");
}
pobj = "";
// C(",");
}
}
}
else
{
switch (expr.Type)
{
case ExprType.StringValue:
C(" \"" + expr.StringV + "\"");
pobj = "N";
break;
case ExprType.IntValue:
C(" " + expr.intV + " ");
pobj = "N";
break;
case ExprType.FloatValue:
C(" " + expr.floatV + "f");
pobj = "N";
break;
case ExprType.SubExpr:
int oh = 1;
break;
case ExprType.ClassVar:
int oh2 = 2;
break;
case ExprType.VarValue:
C(" " + expr.VarName);
if (expr.CallPars != null)
{
C("(");
WriteCallPars(expr.CallPars);
C(")");
}
else
{
if (osfuncs.Contains(expr.VarName))
{
C("(");
C(")");
}
}
pobj = expr.VarName;
break;
case ExprType.NewClass:
C(" new ");
if (expr.NewPars != null)
{
C(expr.NewClassType);
C("(");
WriteCallPars(expr.NewPars);
C(")");
break;
}
if (expr.CallPars != null)
{
C(expr.NewClassType);
C("(");
WriteCallPars(expr.CallPars);
C(")");
}
else
{
C(expr.NewClassType);
C("()");
}
break;
case ExprType.Operator:
switch (expr.Op)
{
case OpType.Null:
C(" null ");
break;
case OpType.LessThan:
C(" < ");
break;
case OpType.MoreThan:
C(" > ");
break;
case OpType.Plus:
C(" + ");
break;
case OpType.Minus:
C(" - ");
break;
case OpType.Divide:
C(" / ");
break;
case OpType.Times:
C(" * ");
break;
case OpType.EqualTo:
C(" == ");
break;
}
pobj = "N";
break;
}
}
}
