public Exp Parse(List <Exp> exps)
{
tape = new ExpTape(exps, this.expContext.FileContext);
newExpList = new List <Exp>();
while (tape.HasCurrent)
{
Exp subExp = AnalyCurrent();
ParseExp(subExp);
}
if (newExpList.Count == 1)
{
Exp exp = newExpList[0];
if (exp is ExpBracket)
{
ExpBracket eb = exp as ExpBracket;
return(eb.UnBracket());
}
else if (!(exp is ExpProcNamePart))
{
return(exp);
}
}
ExpCall_Parsed ec = new ExpCall_Parsed(this.expContext, newExpList, SrcExp);
return(ec);
}
private ExpNew AnalyNewExp(ExpTypeUnsure expType, ExpBracket expBracket)
{
ExpNew expNew = new ExpNew(this.expContext, expType, expBracket);
// expNew.SetContextExp(this.expContext);
Exp expArg = expNew.Analy();
ParseAsArg(expArg);
return(expNew);
}
private Exp ParseToExpNew(ExpTypeBase expType, Exp exp2)
{
ExpBracket bracketBracket = WarpExp(exp2);
if (bracketBracket.IsExpBracketTagNew())
{
bracketBracket = bracketBracket.AnalyToTagNew();
}
ExpNew newexp = new ExpNew(this.ExpContext, expType, bracketBracket);
//newexp.SetContextExp(this.expContext);
Exp exp3 = newexp.Analy();
return(exp3);
}
private Exp ParseChain()
{
ExpChain expChain = new ExpChain(expContext);
while (tape.HasCurrent)
{
if (tape.Current.IsKind(TokenKindSymbol.LBS))
{
ExpBracket subExp = parseBracket();
expChain.Add(subExp);
}
else if (tape.Current.IsKind(TokenKindSymbol.RBS))
{
break;
//tape.error("多余的右括号");
//tape.MoveNext();
}
else if (tape.Current is LexTokenLiteral)
{
ExpLiteral subExp = parseLiteral();
expChain.Add(subExp);
}
else if (tape.Current.IsKind(
TokenKindKeyword.Ident,
TokenKindKeyword.Ident,
TokenKindKeyword.DE,
TokenKindKeyword.DI,
TokenKindKeyword.Each,
TokenKindKeyword.NewDefault
)
)
{
LexToken tok = tape.Current;
expChain.Add(tok);
tape.MoveNext();
}
else
{
break;
}
}
if (expChain.SubCount == 0)
{
return(null);
}
return(expChain);
}
ExpBracket parseBracket()
{
//report("parseBracket");
ExpBracket bracket = new ExpBracket();
bracket.LeftBracketToken = tape.Current;
tape.MoveNext();
if (!tape.isBracketEnd(tape.Current.Kind))
{
while (true)
{
Exp expr = parseBinaryLogicExp();
if (expr != null)
{
bracket.InneExps.Add(expr);
}
if (tape.isBracketEnd(tape.CurrentKind))
{
break;
}
if (tape.CurrentKind != TokenKind.Comma)
{
tape.error("多余的表达式元素");
tape.MoveNext();
while (!(tape.isBracketEnd(tape.CurrentKind)) && tape.CurrentKind != TokenKind.Comma)
{
tape.MoveNext();
}
}
if (tape.CurrentKind == TokenKind.Comma)
{
tape.MoveNext();
}
}
}
if (tape.CurrentKind == TokenKind.RBS)
{
bracket.RightBracketToken = tape.Current;
tape.MoveNext();
}
else
{
tape.error("括号不匹配");
}
return(bracket);
}
private Exp ParseAddInnerExp(ExpBracket bracketExp)
{
//if(tape.Current.Text=="新的")
//{
// Console.WriteLine("新的");
//}
Exp expr = ParseAssign();
if (expr != null)
{
bracketExp.AddInnerExp(expr);
}
else
{
tape.error("缺少表达式");
}
return(expr);
}
private Exp ParseItemExp()
{
if (Tape.Current is ExpBracket)
{
ExpBracket expb = (ExpBracket)Tape.Current;
MoveNext();
//expb.SetContextExp(this.expContext);
return(expb.Analy());
}
else if (Tape.Current is ExpLiteral)
{
ExpLiteral expb = (ExpLiteral)Tape.Current;
MoveNext();
//expb.SetContextExp(this.expContext);
return(expb.Analy());
}
throw new CCException();
}
private ExpBracket parseBracket( )
{
//report("parseBracket");
ExpBracket bracketExp = new ExpBracket(this.expContext);
bracketExp.LeftBracketToken = tape.Current;
tape.MoveNext();
Exp innerExp = null;
innerExp = ParseAddInnerExp(bracketExp);
if (tape.HasCurrent && !isBracketEnd(tape.Current))
{
while (tape.HasCurrent && !isBracketEnd(tape.Current))
{
//if(tape.Current.Line==17)
//{
// Console.WriteLine("17 line");
//}
//if (isBracketEnd(tape.Current) )
//{
// break;
//}
//else
if (tape.Current.IsKind(TokenKindSymbol.Comma))
{
tape.MoveNext();
innerExp = ParseAddInnerExp(bracketExp);
}
//if (tape.Current.IsKind(TokenKindSymbol.Comma))
//{
// tape.error("多余的表达式元素");
// tape.MoveNext();
// while (!isBracketEnd(tape.Current) && !tape.Current.IsKind( TokenKindSymbol.Comma))
// {
// tape.MoveNext();
// }
//}
//else if (tape.Current.IsKind(TokenKindSymbol.Comma))
//{
// tape.MoveNext();
//}
}
}
if (tape.HasCurrent)
{
if (tape.Current.IsKind(TokenKindSymbol.RBS))
{
bracketExp.RightBracketToken = tape.Current;
tape.MoveNext();
}
else
{
tape.error("右括号不匹配");
}
}
else
{
tape.error("缺少右括号");
}
//bracketExp.SetContextExp(this.expContext);
return(bracketExp);
}
private bool ParseItem()
{
if (!Tape.HasCurrent)
{
return(false);
}
var data = Tape.Current;
if (featurer.IsDe(data))
{
var obj = ParseDe();
chains.Push(obj);
return(true);
}
else if (featurer.IsNewfault(data))// (cf.IsNewfault)
{
var obj = ParseNewfault();
chains.Push(obj);
return(true);
//MoveNext();
//return false;
}
else if (featurer.IsDi(data))//(cf.IsDi)
{
var obj = ParseDi();
chains.Push(obj);
return(true);
}
else if (featurer.IsExp(data))//if (cf.IsExp)
{
var obj = ParseItemExp();
chains.Push(obj);
return(true);
}
else if (featurer.IsLocalVar(data) ||//cf.IsLocalVar
featurer.IsLiteral(data) ||//cf.IsLiteral
featurer.IsThisProperty(data) ||
featurer.IsSuperProperty(data) ||//cf.IsSuperProperty
featurer.IsUsedEnumItem(data) ||//cf.IsUsedEnumItem
featurer.IsUsedProperty(data) ||// cf.IsUsedProperty
featurer.IsParameter(data) ||//cf.IsParameter
featurer.IsUsedField(data) ||
featurer.IsThisField(data)
)
{
Exp exp1 = ParseExpect_Var();
ExpBracket bracketBracket = WarpExp(exp1);
chains.Push(bracketBracket);
return(true);
}
else if (featurer.IsThisClassName(data) || featurer.IsImportTypeName(data))
{
Exp exp = ParseTypes();
chains.Push(exp);
if (exp is ExpTypeBase)
{
if (Tape.HasCurrent)
{
var data2 = Tape.Current;
if (!(featurer.IsDi(data2) || featurer.IsDe(data2)))
{
var b2 = ParseItem();
if (b2)
{
var nextObj = PeekChains();
if ((nextObj is ExpBracket) ||
(nextObj is ExpLiteral) ||
(nextObj is ExpVarBase)
)
{
var argExp = (Exp)PopChains();
var typeExp = (ExpTypeBase)PopChains();
Exp newexp = ParseToExpNew(typeExp, argExp);
//obj = newexp;
chains.Push(newexp);
return(true);
}
}
}
}
return(true);
}
}
else if (featurer.IsIdent(data))
{
LexTokenText lexToken = (LexTokenText)data;
if (lexToken.Text == "是" || lexToken.Text == "否")
{
LexTokenLiteral literalToken = new LexTokenLiteral(lexToken.Line, lexToken.Col,
lexToken.Text == "是" ? TokenKindLiteral.True : TokenKindLiteral.False, lexToken.Text);
ExpLiteral literalExp = new ExpLiteral(this.ExpContext, literalToken);
Exp exp2 = literalExp.Analy();
chains.Push(exp2);
MoveNext();
}
else if (featurer.IsProcNamePart(lexToken.Text))
{
Exp exp = ParseProcNamePart();
chains.Push(exp);
}
else
{
//ExpErrorToken errorExp = new ExpErrorToken(this.ExpContext, lexToken);
//Exp exp1 = errorExp.Analy();
ExpLocalVar varExp = new ExpLocalVar(this.ExpContext, lexToken);
varExp.IsAssignTo = this.IsAssignTo;
Exp exp1 = varExp.Analy();
ExpBracket bracketBracket = WarpExp(exp1);
chains.Push(bracketBracket);
MoveNext();
}
return(true);
}
else
{
throw new CCException();
}
return(true);
}
