public override void AcceptCall(CallStatement stmt)
{
var fspec = stmt.Callee as FunctionSpec;
if (fspec != null &&
fspec.IntrinsicRep != null &&
fspec.IntrinsicRep.Action == IntrinsicFunction.EAction.ProceedWithState)
{
int state = (int)fspec.IntrinsicRep.Parameter;
int index = state + 1;
_sfun.States[index].Accept(this);
return;
}
base.AcceptCall(stmt);
}
private static IToken BuildCodeElementFromType(CodeElementType type, Token lastTokenBeforeError, string informationText)
{
CodeElement codeElement = null;
switch (type)
{
case CodeElementType.ProgramIdentification:
codeElement = new ProgramIdentification();
break;
case CodeElementType.ProgramEnd:
codeElement = new ProgramEnd();
break;
case CodeElementType.ClassIdentification:
codeElement = new ClassIdentification();
break;
case CodeElementType.ClassEnd:
codeElement = new ClassEnd();
break;
case CodeElementType.FactoryIdentification:
codeElement = new FactoryIdentification();
break;
case CodeElementType.FactoryEnd:
codeElement = new FactoryEnd();
break;
case CodeElementType.ObjectIdentification:
codeElement = new ObjectIdentification();
break;
case CodeElementType.ObjectEnd:
codeElement = new ObjectEnd();
break;
case CodeElementType.MethodIdentification:
codeElement = new MethodIdentification();
break;
case CodeElementType.MethodEnd:
codeElement = new MethodEnd();
break;
case CodeElementType.EnvironmentDivisionHeader:
codeElement = new EnvironmentDivisionHeader();
break;
case CodeElementType.DataDivisionHeader:
codeElement = new DataDivisionHeader();
break;
case CodeElementType.ProcedureDivisionHeader:
codeElement = new ProcedureDivisionHeader();
break;
case CodeElementType.DeclarativesHeader:
codeElement = new DeclarativesHeader();
break;
case CodeElementType.DeclarativesEnd:
codeElement = new DeclarativesEnd();
break;
case CodeElementType.SectionHeader:
codeElement = new SectionHeader();
break;
case CodeElementType.ConfigurationSectionHeader:
codeElement = new ConfigurationSectionHeader();
break;
case CodeElementType.InputOutputSectionHeader:
codeElement = new InputOutputSectionHeader();
break;
case CodeElementType.FileSectionHeader:
codeElement = new FileSectionHeader();
break;
case CodeElementType.GlobalStorageSectionHeader:
codeElement = new GlobalStorageSectionHeader();
break;
case CodeElementType.WorkingStorageSectionHeader:
codeElement = new WorkingStorageSectionHeader();
break;
case CodeElementType.LocalStorageSectionHeader:
codeElement = new LocalStorageSectionHeader();
break;
case CodeElementType.LinkageSectionHeader:
codeElement = new LinkageSectionHeader();
break;
case CodeElementType.ParagraphHeader:
codeElement = new ParagraphHeader();
break;
case CodeElementType.FileControlParagraphHeader:
codeElement = new FileControlParagraphHeader();
break;
case CodeElementType.IOControlParagraphHeader:
codeElement = new IOControlParagraphHeader();
break;
case CodeElementType.SentenceEnd:
codeElement = new SentenceEnd();
break;
case CodeElementType.FileDescriptionEntry:
codeElement = new FileDescriptionEntry();
break;
case CodeElementType.DataDescriptionEntry:
codeElement = new DataDescriptionEntry();
break;
case CodeElementType.DataRedefinesEntry:
codeElement = new DataRedefinesEntry();
break;
case CodeElementType.DataRenamesEntry:
codeElement = new DataRenamesEntry();
break;
case CodeElementType.DataConditionEntry:
codeElement = new DataConditionEntry();
break;
case CodeElementType.FileControlEntry:
codeElement = new FileControlEntry();
break;
case CodeElementType.IOControlEntry:
codeElement = new RerunIOControlEntry();
break;
case CodeElementType.SourceComputerParagraph:
codeElement = new SourceComputerParagraph();
break;
case CodeElementType.ObjectComputerParagraph:
codeElement = new ObjectComputerParagraph();
break;
case CodeElementType.SpecialNamesParagraph:
codeElement = new SpecialNamesParagraph();
break;
case CodeElementType.RepositoryParagraph:
codeElement = new RepositoryParagraph();
break;
case CodeElementType.AcceptStatement:
codeElement = new AcceptFromInputDeviceStatement();
break;
case CodeElementType.AddStatement:
codeElement = new AddSimpleStatement();
break;
case CodeElementType.AlterStatement:
codeElement = new AlterStatement();
break;
case CodeElementType.CallStatement:
codeElement = new CallStatement();
break;
case CodeElementType.CancelStatement:
codeElement = new CancelStatement();
break;
case CodeElementType.CloseStatement:
codeElement = new CloseStatement();
break;
case CodeElementType.ComputeStatement:
codeElement = new ComputeStatement();
break;
case CodeElementType.ContinueStatement:
codeElement = new ContinueStatement();
break;
case CodeElementType.DeleteStatement:
codeElement = new DeleteStatement();
break;
case CodeElementType.DisplayStatement:
codeElement = new DisplayStatement();
break;
case CodeElementType.DivideStatement:
codeElement = new DivideSimpleStatement();
break;
case CodeElementType.EntryStatement:
codeElement = new EntryStatement();
break;
case CodeElementType.EvaluateStatement:
codeElement = new EvaluateStatement();
break;
case CodeElementType.ExecStatement:
codeElement = new ExecStatement();
break;
case CodeElementType.ExitMethodStatement:
codeElement = new ExitMethodStatement();
break;
case CodeElementType.ExitProgramStatement:
codeElement = new ExitProgramStatement();
break;
case CodeElementType.ExitStatement:
codeElement = new ExitStatement();
break;
case CodeElementType.GobackStatement:
codeElement = new GobackStatement();
break;
case CodeElementType.GotoStatement:
codeElement = new GotoSimpleStatement();
break;
case CodeElementType.IfStatement:
codeElement = new IfStatement();
break;
case CodeElementType.InitializeStatement:
codeElement = new InitializeStatement();
break;
case CodeElementType.InspectStatement:
codeElement = new InspectTallyingStatement();
break;
case CodeElementType.InvokeStatement:
codeElement = new InvokeStatement();
break;
case CodeElementType.MergeStatement:
codeElement = new MergeStatement();
break;
case CodeElementType.MoveStatement:
codeElement = new MoveSimpleStatement(null, null, null);
break;
case CodeElementType.MultiplyStatement:
codeElement = new MultiplySimpleStatement();
break;
case CodeElementType.NextSentenceStatement:
codeElement = new NextSentenceStatement();
break;
case CodeElementType.OpenStatement:
codeElement = new OpenStatement();
break;
case CodeElementType.PerformProcedureStatement:
codeElement = new PerformProcedureStatement();
break;
case CodeElementType.PerformStatement:
codeElement = new PerformStatement();
break;
case CodeElementType.ReadStatement:
codeElement = new ReadStatement();
break;
case CodeElementType.ReleaseStatement:
codeElement = new ReleaseStatement();
break;
case CodeElementType.ReturnStatement:
codeElement = new ReturnStatement();
break;
case CodeElementType.RewriteStatement:
codeElement = new RewriteStatement();
break;
case CodeElementType.SearchStatement:
codeElement = new SearchSerialStatement();
break;
case CodeElementType.SetStatement:
codeElement = new SetStatementForAssignment();
break;
case CodeElementType.SortStatement:
codeElement = new SortStatement();
break;
case CodeElementType.StartStatement:
codeElement = new StartStatement();
break;
case CodeElementType.StopStatement:
codeElement = new StopStatement();
break;
case CodeElementType.StringStatement:
codeElement = new StringStatement();
break;
case CodeElementType.SubtractStatement:
codeElement = new SubtractSimpleStatement();
break;
case CodeElementType.UnstringStatement:
codeElement = new UnstringStatement();
break;
case CodeElementType.UseStatement:
codeElement = new UseAfterIOExceptionStatement();
break;
case CodeElementType.WriteStatement:
codeElement = new WriteStatement();
break;
case CodeElementType.XmlGenerateStatement:
codeElement = new XmlGenerateStatement();
break;
case CodeElementType.XmlParseStatement:
codeElement = new XmlParseStatement();
break;
case CodeElementType.AtEndCondition:
codeElement = new AtEndCondition();
break;
case CodeElementType.NotAtEndCondition:
codeElement = new NotAtEndCondition();
break;
case CodeElementType.AtEndOfPageCondition:
codeElement = new AtEndOfPageCondition();
break;
case CodeElementType.NotAtEndOfPageCondition:
codeElement = new NotAtEndOfPageCondition();
break;
case CodeElementType.OnExceptionCondition:
codeElement = new OnExceptionCondition();
break;
case CodeElementType.NotOnExceptionCondition:
codeElement = new NotOnExceptionCondition();
break;
case CodeElementType.OnOverflowCondition:
codeElement = new OnOverflowCondition();
break;
case CodeElementType.NotOnOverflowCondition:
codeElement = new NotOnOverflowCondition();
break;
case CodeElementType.InvalidKeyCondition:
codeElement = new InvalidKeyCondition();
break;
case CodeElementType.NotInvalidKeyCondition:
codeElement = new NotInvalidKeyCondition();
break;
case CodeElementType.OnSizeErrorCondition:
codeElement = new OnSizeErrorCondition();
break;
case CodeElementType.NotOnSizeErrorCondition:
codeElement = new NotOnSizeErrorCondition();
break;
case CodeElementType.ElseCondition:
codeElement = new ElseCondition();
break;
case CodeElementType.WhenCondition:
codeElement = new WhenCondition();
break;
case CodeElementType.WhenOtherCondition:
codeElement = new WhenOtherCondition();
break;
case CodeElementType.WhenSearchCondition:
codeElement = new WhenSearchCondition();
break;
case CodeElementType.AddStatementEnd:
codeElement = new AddStatementEnd();
break;
case CodeElementType.CallStatementEnd:
codeElement = new CallStatementEnd();
break;
case CodeElementType.ComputeStatementEnd:
codeElement = new ComputeStatementEnd();
break;
case CodeElementType.DeleteStatementEnd:
codeElement = new DeleteStatementEnd();
break;
case CodeElementType.DivideStatementEnd:
codeElement = new DivideStatementEnd();
break;
case CodeElementType.EvaluateStatementEnd:
codeElement = new EvaluateStatementEnd();
break;
case CodeElementType.IfStatementEnd:
codeElement = new IfStatementEnd();
break;
case CodeElementType.InvokeStatementEnd:
codeElement = new InvokeStatementEnd();
break;
case CodeElementType.MultiplyStatementEnd:
codeElement = new MultiplyStatementEnd();
break;
case CodeElementType.PerformStatementEnd:
codeElement = new PerformStatementEnd();
break;
case CodeElementType.ReadStatementEnd:
codeElement = new ReadStatementEnd();
break;
case CodeElementType.ReturnStatementEnd:
codeElement = new ReturnStatementEnd();
break;
case CodeElementType.RewriteStatementEnd:
codeElement = new RewriteStatementEnd();
break;
case CodeElementType.SearchStatementEnd:
codeElement = new SearchStatementEnd();
break;
case CodeElementType.StartStatementEnd:
codeElement = new StartStatementEnd();
break;
case CodeElementType.StringStatementEnd:
codeElement = new StringStatementEnd();
break;
case CodeElementType.SubtractStatementEnd:
codeElement = new SubtractStatementEnd();
break;
case CodeElementType.UnstringStatementEnd:
codeElement = new UnstringStatementEnd();
break;
case CodeElementType.WriteStatementEnd:
codeElement = new WriteStatementEnd();
break;
case CodeElementType.XmlStatementEnd:
codeElement = new XmlStatementEnd();
break;
case CodeElementType.LibraryCopy:
codeElement = new LibraryCopyCodeElement();
break;
case CodeElementType.FunctionDeclarationHeader:
codeElement = new FunctionDeclarationHeader(null, AccessModifier.Private, FunctionType.Undefined);
break;
case CodeElementType.FunctionDeclarationEnd:
codeElement = new FunctionDeclarationEnd();
break;
default:
throw new NotImplementedException();
}
if (lastTokenBeforeError != null)
{
var missingToken = new MissingToken(TokenType.InvalidToken, informationText, lastTokenBeforeError.TokensLine, lastTokenBeforeError.StopIndex);
codeElement.ConsumedTokens.Add(missingToken);
}
return(codeElement);
}
public void AcceptCall(CallStatement stmt)
{
}
public override void AcceptCall(CallStatement stmt)
{
var cilRef = stmt.QueryAttribute<ILIndexRef>();
PushCILRef(cilRef);
IStorableLiteral retv;
bool success = TryInline(stmt.Callee, stmt.Arguments, out retv);
PopCILRef(cilRef);
if (!success)
{
base.AcceptCall(stmt);
}
}
public virtual TRes Visit(CallStatement node, TArg arg) => Visit((Statement)node, arg);
public void AcceptCall(CallStatement stmt)
{
_result.Add(stmt);
}
public void AcceptCall(CallStatement stmt)
{
Result = stmt;
}
public void AcceptCall(CallStatement stmt)
{
IsEmpty = false;
}
Statement ParseStatement(Scope scope)
{
int startP = reader.p;
int startLine = reader.Peek().Line;
Statement stat = null;
// print(tok.Peek().Print())
if (reader.ConsumeKeyword("if"))
{
//setup
IfStmt _if = new IfStmt();
//clauses
do
{
int sP = reader.p;
Expression nodeCond = ParseExpr(scope);
if (!reader.ConsumeKeyword("then"))
{
error("'then' expected");
}
List <Statement> nodeBody = ParseStatementList(scope);
List <Token> range = new List <Token>();
range.Add(reader.tokens[sP - 1]);
range.AddRange(reader.Range(sP, reader.p));
_if.Clauses.Add(new ElseIfStmt(scope)
{
Condition = nodeCond,
Body = nodeBody,
ScannedTokens = range
});
}while (reader.ConsumeKeyword("elseif"));
// else clause
if (reader.ConsumeKeyword("else"))
{
int sP = reader.p;
List <Statement> nodeBody = ParseStatementList(scope);
List <Token> range = new List <Token>();
range.Add(reader.tokens[sP - 1]);
range.AddRange(reader.Range(sP, reader.p));
_if.Clauses.Add(new ElseStmt(scope)
{
Body = nodeBody,
ScannedTokens = range
});
}
// end
if (!reader.ConsumeKeyword("end"))
{
error("'end' expected");
}
stat = _if;
}
else if (reader.ConsumeKeyword("while"))
{
WhileStatement w = new WhileStatement(scope);
// condition
Expression nodeCond = ParseExpr(scope);
// do
if (!reader.ConsumeKeyword("do"))
{
error("'do' expected");
}
// body
List <Statement> body = ParseStatementList(scope);
//end
if (!reader.ConsumeKeyword("end"))
{
error("'end' expected");
}
// return
w.Condition = nodeCond;
w.Body = body;
stat = w;
}
else if (reader.ConsumeKeyword("do"))
{
// do block
List <Statement> b = ParseStatementList(scope);
if (!reader.ConsumeKeyword("end"))
{
error("'end' expected");
}
stat = new DoStatement(scope)
{
Body = b
};
}
else if (reader.ConsumeKeyword("for"))
{
//for block
if (!reader.Is(TokenType.Ident))
{
error("<ident> expected");
}
Token baseVarName = reader.Get();
if (reader.ConsumeSymbol('='))
{
//numeric for
NumericForStatement forL = new NumericForStatement(scope);
Variable forVar = new Variable()
{
Name = baseVarName.Data
};
forL.Scope.AddLocal(forVar);
Expression startEx = ParseExpr(scope);
if (!reader.ConsumeSymbol(','))
{
error("',' expected");
}
Expression endEx = ParseExpr(scope);
Expression stepEx = null;
if (reader.ConsumeSymbol(','))
{
stepEx = ParseExpr(scope);
}
if (!reader.ConsumeKeyword("do"))
{
error("'do' expected");
}
List <Statement> body = ParseStatementList(forL.Scope);
if (!reader.ConsumeKeyword("end"))
{
error("'end' expected");
}
forL.Variable = forVar;
forL.Start = startEx;
forL.End = endEx;
forL.Step = stepEx;
forL.Body = body;
stat = forL;
}
else
{
// generic for
GenericForStatement forL = new GenericForStatement(scope);
List <Variable> varList = new List <Variable> {
forL.Scope.CreateLocal(baseVarName.Data)
};
while (reader.ConsumeSymbol(','))
{
if (!reader.Is(TokenType.Ident))
{
error("for variable expected");
}
varList.Add(forL.Scope.CreateLocal(reader.Get().Data));
}
if (!reader.ConsumeKeyword("in"))
{
error("'in' expected");
}
List <Expression> generators = new List <Expression>();
Expression first = ParseExpr(scope);
generators.Add(first);
while (reader.ConsumeSymbol(','))
{
Expression gen = ParseExpr(scope);
generators.Add(gen);
}
if (!reader.ConsumeKeyword("do"))
{
error("'do' expected");
}
List <Statement> body = ParseStatementList(forL.Scope);
if (!reader.ConsumeKeyword("end"))
{
error("'end' expected");
}
forL.VariableList = varList;
forL.Generators = generators;
forL.Body = body;
stat = forL;
}
}
else if (reader.ConsumeKeyword("repeat"))
{
List <Statement> body = ParseStatementList(scope);
if (!reader.ConsumeKeyword("until"))
{
error("'until' expected");
}
Expression cond = ParseExpr(scope);
RepeatStatement r = new RepeatStatement(scope);
r.Condition = cond;
r.Body = body;
stat = r;
}
else if (reader.ConsumeKeyword("function"))
{
if (!reader.Is(TokenType.Ident))
{
error("function name expected");
}
Expression name = ParseSuffixedExpr(scope, true);
// true: only dots and colons
FunctionStatement func = ParseFunctionArgsAndBody(scope);
func.IsLocal = false;
func.Name = name;
stat = func;
}
else if (reader.ConsumeKeyword("local"))
{
if (reader.Is(TokenType.Ident))
{
List <string> varList = new List <string> {
reader.Get().Data
};
while (reader.ConsumeSymbol(','))
{
if (!reader.Is(TokenType.Ident))
{
error("local variable name expected");
}
varList.Add(reader.Get().Data);
}
List <Expression> initList = new List <Expression>();
if (reader.ConsumeSymbol('='))
{
do
{
Expression ex = ParseExpr(scope);
initList.Add(ex);
} while (reader.ConsumeSymbol(','));
}
//now patch var list
//we can't do this before getting the init list, because the init list does not
//have the locals themselves in scope.
List <Expression> newVarList = new List <Expression>();
for (int i = 0; i < varList.Count; i++)
{
Variable x = scope.CreateLocal(varList[i]);
newVarList.Add(new VariableExpression {
Var = x
});
}
AssignmentStatement l = new AssignmentStatement();
l.Lhs = newVarList;
l.Rhs = initList;
l.IsLocal = true;
stat = l;
}
else if (reader.ConsumeKeyword("function"))
{
if (!reader.Is(TokenType.Ident))
{
error("Function name expected");
}
string name = reader.Get().Data;
Variable localVar = scope.CreateLocal(name);
FunctionStatement func = ParseFunctionArgsAndBody(scope);
func.Name = new VariableExpression {
Var = localVar
};
func.IsLocal = true;
stat = func;
}
else
{
error("local variable or function definition expected");
}
}
#if !VANILLA_LUA
else if (reader.ConsumeSymbol("::"))
{
if (!reader.Is(TokenType.Ident))
{
error("label name expected");
}
string label = reader.Get().Data;
if (!reader.ConsumeSymbol("::"))
{
error("'::' expected");
}
LabelStatement l = new LabelStatement();
l.Label = label;
stat = l;
}
#endif
else if (reader.ConsumeKeyword("return"))
{
List <Expression> exprList = new List <Expression>();
if (!reader.IsKeyword("end") && !reader.IsEof())
{
Expression firstEx = ParseExpr(scope);
exprList.Add(firstEx);
while (reader.ConsumeSymbol(','))
{
Expression ex = ParseExpr(scope);
exprList.Add(ex);
}
}
ReturnStatement r = new ReturnStatement();
r.Arguments = exprList;
stat = r;
}
else if (reader.ConsumeKeyword("break"))
{
stat = new BreakStatement();
}
else if (reader.ConsumeKeyword("continue"))
{
stat = new ContinueStatement();
}
#if !VANILLA_LUA
else if (reader.ConsumeKeyword("goto"))
{
if (!reader.Is(TokenType.Ident))
{
error("label expected");
}
string label = reader.Get().Data;
GotoStatement g = new GotoStatement();
g.Label = label;
stat = g;
}
else if (reader.ConsumeKeyword("using"))
{
// using <a, b = 1, x()> do <statements> end
UsingStatement us = new UsingStatement(scope);
us.Scope = new Scope(scope);
List <Expression> lhs = new List <Expression> {
ParseExpr(us.Scope)
};
while (reader.ConsumeSymbol(','))
{
lhs.Add(ParseSuffixedExpr(us.Scope, true));
}
// equals
if (!reader.ConsumeSymbol('='))
{
error("'=' expected");
}
//rhs
List <Expression> rhs = new List <Expression>();
rhs.Add(ParseExpr(us.Scope));
while (reader.ConsumeSymbol(','))
{
rhs.Add(ParseExpr(scope));
}
AssignmentStatement a = new AssignmentStatement();
a.Lhs = lhs;
a.Rhs = rhs;
a.IsLocal = true;
if (!reader.ConsumeKeyword("do"))
{
error("'do' expected");
}
List <Statement> block = ParseStatementList(us.Scope);
if (!reader.ConsumeKeyword("end"))
{
error("'end' expected");
}
us.Vars = a;
us.Body = block;
stat = us;
}
#endif
else
{
// statementParseExpr
Expression suffixed = ParseSuffixedExpr(scope);
// assignment or call?
if (reader.IsSymbol(',') || reader.IsSymbol('='))
{
// check that it was not parenthesized, making it not an lvalue
if (suffixed.ParenCount > 0)
{
error("Can not assign to parenthesized expression, it is not an lvalue");
}
// more processing needed
List <Expression> lhs = new List <Expression> {
suffixed
};
while (reader.ConsumeSymbol(','))
{
lhs.Add(ParseSuffixedExpr(scope));
}
// equals
if (!reader.ConsumeSymbol('='))
{
error("'=' expected");
}
//rhs
List <Expression> rhs = new List <Expression>();
rhs.Add(ParseExpr(scope));
while (reader.ConsumeSymbol(','))
{
rhs.Add(ParseExpr(scope));
}
AssignmentStatement a = new AssignmentStatement();
a.Lhs = lhs;
a.Rhs = rhs;
stat = a;
}
#if !VANILLA_LUA
else if (isAugmentedAssignment(reader.Peek()))
{
AugmentedAssignmentStatement aas = new AugmentedAssignmentStatement();
Expression left = suffixed;
Expression right = null;
string augmentedOp = reader.Get().Data;
right = ParseExpr(scope);
BinOpExpr nRight = new BinOpExpr();
nRight.Lhs = left;
nRight.Op = augmentedOp.Substring(0, augmentedOp.Length - 1); // strip the '='
nRight.Rhs = right;
aas.Lhs = new List <Expression> {
left
};
aas.Rhs = new List <Expression> {
nRight
};
stat = aas;
}
#endif
else if (suffixed is CallExpr ||
suffixed is TableCallExpr ||
suffixed is StringCallExpr)
{
//it's a call statement
CallStatement c = new CallStatement();
c.Expression = suffixed;
stat = c;
}
else
{
error("assignment statement expected");
}
}
stat.ScannedTokens = reader.Range(startP, reader.p);
if (reader.Peek().Data == ";" && reader.Peek().Type == TokenType.Symbol)
{
stat.HasSemicolon = true;
stat.SemicolonToken = reader.Get();
}
if (stat.Scope == null)
{
stat.Scope = scope;
}
stat.LineNumber = startLine;
return(stat);
}
/// <summary>
/// Transforms a "call" statement. The default implementation clones the call.
/// </summary>
/// <param name="stmt">"call" statement</param>
public virtual void AcceptCall(CallStatement stmt)
{
Call(stmt.Callee,
stmt.Arguments.Select(a => a.Transform(this)).ToArray());
CopyAttributesToLastStatement(stmt);
LabelLastStmt(stmt);
}
public Node AssignmentCallStatement()
{
var identif = Expect(TokenCategory.IDENTIFIER);
var assignment = new AssignmentStatement();
var call = new CallStatement();
Console.WriteLine("IDENTIFFFF" + identif);
Console.WriteLine("CT: " + CurrentToken);
//var alter = new Expression();
//call-statement
if (CurrentToken == TokenCategory.INITPARENTHESIS)
{
Expect(TokenCategory.INITPARENTHESIS);
if (firstOfSimpleExpression.Contains(CurrentToken))
{
call.Add(Expression());
while (CurrentToken == TokenCategory.COMMA)
{
Expect(TokenCategory.COMMA);
call.Add(Expression());
}
}
//call.Add(
Expect(TokenCategory.CLOSINGPARENTHESIS);
Expect(TokenCategory.ENDLINE);
var result = new List()
{
call
};
call.AnchorToken = identif;
return(call);
//call.AnchorToken = identif;
//return call;
}
else if (CurrentToken == TokenCategory.INITBRACKET || CurrentToken == TokenCategory.CONSTANTDECLARATION)
{
if (CurrentToken == TokenCategory.INITBRACKET)
{
Expect(TokenCategory.INITBRACKET);
var expression = Expression();
Expect(TokenCategory.CLOSINGBRACKET);
assignment.Add(expression);
}
Expect(TokenCategory.CONSTANTDECLARATION);
var expression2 = Expression();
Expect(TokenCategory.ENDLINE);
assignment.Add(expression2);
assignment.AnchorToken = identif;
return(assignment);
}
/************** ATENCION ************/
/************** ATENCION ************/
/************** ATENCION ************/
else
{
throw new SyntaxError(firstOfStatement,
tokenStream.Current);
}
return(call);
}
private void ParseStatements(string file, string source)
{
var lines = source.Split('\n').Where(l => l != "\r").ToList();
var variable_regex = GetStatementRegex(VariableDeclarationPattern);
var function_regex = GetStatementRegex(FunctionDeclarationPattern);
var call_regex = GetStatementRegex(FunctionCallPattern);
Function current_function = null;
Block current_block = null;
Stack <Block> block_stack = new Stack <Block>();
bool entered = false;
for (int i = 0; i < lines.Count; i++)
{
var line = lines[i].Trim();
if (line.Length == 0)
{
continue;
}
if (variable_regex.IsMatch(line))
{
var m = variable_regex.Match(line);
var variable = new Variable()
{
Type = DefinedTypes[m.Groups["Type"].Value],
Name = m.Groups["Name"].Value
};
if (current_block != null && entered == true)
{
var defined = GlobalVariables.Values.ToList();
defined.AddRange(current_function.Parameters);
defined.AddRange(current_block.LocalVariables);
defined.AddRange(block_stack.SelectMany(b => b.LocalVariables));
if (defined.Select(v => v.Name).Contains(variable.Name))
{
throw new ParserException(file, i, "variable already defined: " + line);
}
Log.Debug("decl: " + line);
current_block.LocalVariables.Add(variable);
}
else if (!GlobalVariables.ContainsKey(variable.Name))
{
throw new ParserException(file, i, "variable declaration unexpected: " + line);
}
}
else if (function_regex.IsMatch(line))
{
var m = function_regex.Match(line);
var name = m.Groups["Name"].Value;
current_function = DefinedFunctions[name];
current_block = current_function.Block;
entered = false;
if (line.Contains("{"))
{
entered = true;
}
}
else if (call_regex.IsMatch(line))
{
if (entered == false)
{
throw new ParserException(file, i, "unexpected statement: " + line);
}
var m = call_regex.Match(line);
var result_name = m.Groups["Result"].Value;
var function_name = m.Groups["Name"].Value;
var parameter_names = m.Groups["Params"].Value.Replace("(", "").Replace(")", "").Split(',')
.Select(p => p.Trim()).Where(p => p.Length > 0).ToList();
var variables = GlobalVariables.Values.ToList();
variables.AddRange(current_function.Parameters);
variables.AddRange(current_block.LocalVariables);
variables.AddRange(block_stack.SelectMany(b => b.LocalVariables));
var result = variables.Single(v => v.Name == result_name);
var function = DefinedFunctions[function_name];
var parameters = new List <Variable>();
foreach (var pn in parameter_names)
{
var parameter = variables.FirstOrDefault(v => v.Name == pn);
if (parameter == null)
{
throw new ParserException(file, i, $"parameter {pn} not found: {line}");
}
parameters.Add(parameter);
}
var statement = new CallStatement()
{
Result = result,
Function = function,
Parameters = parameters
};
current_block.Elements.Add(statement);
}
else if (line == "{")
{
if (entered)
{
throw new ParserException(file, i, "did not expect {");
}
entered = true;
}
else if (line == "}")
{
if (!entered)
{
throw new ParserException(file, i, "did not expect }");
}
if (block_stack.Count > 0)
{
current_block = block_stack.Pop();
}
else if (current_function != null)
{
current_function = null;
}
else
{
throw new ParserException(file, i, "did not expect }");
}
}
else
{
throw new ParserException(file, i, "parser error: " + line);
}
}
}
public void AcceptCall(CallStatement stmt)
{
Result = stmt;
}
private BoundStatement Bind(CallStatement callStatement)
{
return(new BoundCallStatement(Bind(callStatement.Call)));
}
public void AcceptCall(CallStatement stmt)
{
Call(stmt.Callee, stmt.Arguments);
LabelLastStmt(stmt);
}
private void UpdateCalls()
{
var procedureName = Identifier.GetName(_subStmtQualifiedContext.Context.subroutineName().identifier());
var procedure =
_state.AllDeclarations.SingleOrDefault(d =>
!d.IsBuiltIn &&
d.IdentifierName == procedureName &&
d.Context is VBAParser.SubStmtContext &&
d.QualifiedName.QualifiedModuleName.Equals(_subStmtQualifiedContext.ModuleName));
if (procedure == null)
{
return;
}
foreach (var reference in procedure.References.OrderByDescending(o => o.Selection.StartLine).ThenByDescending(d => d.Selection.StartColumn))
{
var startLine = reference.Selection.StartLine;
if (procedure.ComponentName == reference.QualifiedModuleName.ComponentName && procedure.Selection.EndLine < reference.Selection.StartLine)
{
startLine += _lineOffset;
}
var referenceParent = ParserRuleContextHelper.GetParent <VBAParser.CallStmtContext>(reference.Context);
if (referenceParent == null)
{
continue;
}
var module = reference.QualifiedModuleName.Component.CodeModule;
{
var argList = CallStatement.GetArgumentList(referenceParent);
var paramNames = new List <string>();
var argsCall = string.Empty;
var argsCallOffset = 0;
if (argList != null)
{
argsCallOffset = argList.GetSelection().EndColumn - reference.Context.GetSelection().EndColumn;
argsCall = argList.GetText();
if (argList.positionalOrNamedArgumentList().positionalArgumentOrMissing() != null)
{
paramNames.AddRange(argList.positionalOrNamedArgumentList().positionalArgumentOrMissing().Select(p =>
{
if (p is VBAParser.SpecifiedPositionalArgumentContext)
{
return(((VBAParser.SpecifiedPositionalArgumentContext)p).positionalArgument().GetText());
}
return(string.Empty);
}).ToList());
}
if (argList.positionalOrNamedArgumentList().namedArgumentList() != null)
{
paramNames.AddRange(argList.positionalOrNamedArgumentList().namedArgumentList().namedArgument().Select(p => p.GetText()).ToList());
}
if (argList.positionalOrNamedArgumentList().requiredPositionalArgument() != null)
{
paramNames.Add(argList.positionalOrNamedArgumentList().requiredPositionalArgument().GetText());
}
}
var referenceText = reference.Context.GetText();
var newCall = paramNames.ToList().ElementAt(_argListQualifiedContext.Context.arg().ToList().IndexOf(_argQualifiedContext.Context)) +
" = " + _subStmtQualifiedContext.Context.subroutineName().GetText() +
"(" + argsCall + ")";
var oldLines = module.GetLines(startLine, reference.Selection.LineCount);
var newText = oldLines.Remove(reference.Selection.StartColumn - 1, referenceText.Length + argsCallOffset)
.Insert(reference.Selection.StartColumn - 1, newCall);
module.DeleteLines(startLine, reference.Selection.LineCount);
module.InsertLines(startLine, newText);
}
}
}
public void AcceptCall(CallStatement stmt)
{
Call(stmt.Callee, stmt.Arguments);
LabelLastStmt(stmt);
}
internal string DoStatement(Statement s)
{
if (s is AssignmentStatement && !(s is AugmentedAssignmentStatement))
{
AssignmentStatement a = s as AssignmentStatement;
StringBuilder sb = new StringBuilder();
if (a.IsLocal)
{
sb.Append("local ");
}
for (int i = 0; i < a.Lhs.Count; i++)
{
sb.Append(DoExpr(a.Lhs[i]));
if (i != a.Lhs.Count - 1)
{
sb.Append(",");
}
}
if (a.Rhs.Count > 0)
{
sb.Append("=");
for (int i = 0; i < a.Rhs.Count; i++)
{
sb.Append(DoExpr(a.Rhs[i]));
if (i != a.Rhs.Count - 1)
{
sb.Append(",");
}
}
}
return(sb.ToString());
}
else if (s is AugmentedAssignmentStatement)
{
AugmentedAssignmentStatement a = s as AugmentedAssignmentStatement;
StringBuilder sb = new StringBuilder();
//sb.Append(DoExpr(a.Lhs[0]));
if (a.IsLocal)
{
sb.Append("local ");
}
Expression assignment = ((BinOpExpr)a.Rhs[0]).Rhs;
sb.Append(DoExpr((((BinOpExpr)a.Rhs[0]).Lhs)));
sb.Append("" + ((BinOpExpr)a.Rhs[0]).Op + "=");
sb.Append(DoExpr(assignment));
return(sb.ToString());
}
else if (s is BreakStatement)
{
// HAHAHA this is incredibly simple...
return("break");
}
else if (s is ContinueStatement)
{
return("continue");
}
else if (s is CallStatement)
{
// Also incredibly simple...
CallStatement c = s as CallStatement;
return(DoExpr(c.Expression));
}
else if (s is DoStatement)
{
DoStatement d = s as DoStatement;
StringBuilder sb = new StringBuilder();
sb.Append("do ");
sb.Append(DoChunk(d.Body));
sb.Append("end");
return(sb.ToString());
}
else if (s is GenericForStatement)
{
GenericForStatement g = s as GenericForStatement;
StringBuilder sb = new StringBuilder();
sb.Append("for ");
for (int i = 0; i < g.VariableList.Count; i++)
{
sb.Append(g.VariableList[i].Name);
if (i != g.VariableList.Count - 1)
{
sb.Append(",");
}
}
sb.Append(" in ");
for (int i = 0; i < g.Generators.Count; i++)
{
sb.Append(DoExpr(g.Generators[i]));
if (i != g.Generators.Count - 1)
{
sb.Append(",");
}
}
sb.Append(" do ");
sb.Append(DoChunk(g.Body));
sb.Append("end");
return(sb.ToString());
}
else if (s is NumericForStatement)
{
NumericForStatement n = s as NumericForStatement;
StringBuilder sb = new StringBuilder();
sb.Append("for ");
sb.Append(n.Variable.Name);
sb.Append("=");
sb.Append(DoExpr(n.Start));
sb.Append(",");
sb.Append(DoExpr(n.End));
if (n.Step != null)
{
sb.Append(",");
sb.Append(DoExpr(n.Step));
}
sb.Append(" do ");
sb.Append(DoChunk(n.Body));
sb.Append("end");
return(sb.ToString());
}
else if (s is FunctionStatement)
{
FunctionStatement f = s as FunctionStatement;
StringBuilder sb = new StringBuilder();
sb.Append("function " + DoExpr(f.Name) + "(");
for (int i = 0; i < f.Arguments.Count; i++)
{
sb.Append(f.Arguments[i].Name);
if (i != f.Arguments.Count - 1 || f.IsVararg)
{
sb.Append(",");
}
}
if (f.IsVararg)
{
sb.Append("...");
}
sb.Append(")");
sb.Append(DoChunk(f.Body));
sb.Append("end");
return(sb.ToString());
}
else if (s is GotoStatement)
{
GotoStatement g = s as GotoStatement;
return("goto " + g.Label);
}
else if (s is IfStmt)
{
IfStmt i = s as IfStmt;
StringBuilder sb = new StringBuilder();
for (int x = 0; x < i.Clauses.Count; x++)
{
string ss = DoStatement(i.Clauses[x]);
if (x == 0)
{
sb.Append("if ");
sb.Append(ss);
}
else if (i.Clauses[x] is ElseStmt)
{
sb.Append(" else ");
sb.Append(ss);
}
else
{
sb.Append("elseif " + ss);
}
}
sb.Append("end");
return(sb.ToString());
}
else if (s is LabelStatement)
{
LabelStatement l = s as LabelStatement;
return("::" + l.Label + "::");
}
else if (s is RepeatStatement)
{
RepeatStatement r = s as RepeatStatement;
StringBuilder sb = new StringBuilder();
sb.Append("repeat ");
sb.Append(DoChunk(r.Body));
sb.Append(" until " + DoExpr(r.Condition));
return(sb.ToString());
}
else if (s is ReturnStatement)
{
ReturnStatement r = s as ReturnStatement;
StringBuilder sb = new StringBuilder();
sb.Append("return ");
for (int i = 0; i < r.Arguments.Count; i++)
{
sb.Append(DoExpr(r.Arguments[i]));
if (i != r.Arguments.Count - 1)
{
sb.Append(",");
}
}
return(sb.ToString());
}
else if (s is UsingStatement)
{
UsingStatement u = s as UsingStatement;
StringBuilder sb = new StringBuilder();
sb.Append("using ");
sb.Append(DoStatement(u.Vars));
sb.Append(" do ");
sb.Append(DoChunk(u.Body));
sb.Append("end");
return(sb.ToString());
}
else if (s is WhileStatement)
{
WhileStatement w = s as WhileStatement;
StringBuilder sb = new StringBuilder();
sb.Append("while ");
sb.Append(DoExpr(w.Condition));
sb.Append(" do ");
sb.Append(DoChunk(w.Body));
sb.Append("end");
return(sb.ToString());
}
else if (s is ElseIfStmt)
{
ElseIfStmt e = s as ElseIfStmt;
string s2 = DoExpr(e.Condition) + " then ";
s2 += DoChunk(e.Body);
return(s2);
}
else if (s is ElseStmt)
{
return(DoChunk(((ElseStmt)s).Body));
}
throw new NotImplementedException(s.GetType().Name + " is not implemented");
}
public void AcceptCall(CallStatement stmt)
{
SimpleResult(stmt);
}
public void AcceptCall(CallStatement stmt)
{
SingleResult(GetAtomicSuccessor(stmt));
}
public void Visit(CallStatement st)
{
sa.TabPrint("");
st.Call.Accept(this);
sa.Print(";");
}
public override void AcceptCall(CallStatement stmt)
{
Success = false;
}
public void AcceptCall(CallStatement stmt)
{
}
public void AcceptCall(CallStatement stmt)
{
IsEmpty = false;
}
void DoStatement(Statement s)
{
line = s.LineNumber;
if (s is AssignmentStatement && !(s is AugmentedAssignmentStatement))
{
AssignmentStatement a = s as AssignmentStatement;
if (a.IsLocal == false)
{
for (int i = a.Rhs.Count; i > 0; i--)
{
DoExpr(a.Rhs[i - 1], false, a.Lhs.Count);
}
for (int i = a.Lhs.Count; i > 0; i--)
{
DoExpr(a.Lhs[i - 1], true);
}
return;
}
else
{
for (int i = a.Rhs.Count; i > 0; i--)
{
DoExpr(a.Rhs[i - 1], false, a.Lhs.Count);
}
for (int i = a.Lhs.Count; i > 0; i--)
{
DoExpr(a.Lhs[i - 1], true);
}
return;
}
}
else if (s is AugmentedAssignmentStatement)
{
AugmentedAssignmentStatement aas = s as AugmentedAssignmentStatement;
StringBuilder sb = new StringBuilder();
//sb.Append(DoExpr(a.Lhs[0]));
if (aas.IsLocal)
{
throw new LuaSourceException(s.LineNumber, 0, "Local assignment cannot have augmented operators");
}
DoExpr(aas.Rhs[0], true, 1);
DoExpr(aas.Lhs[0], true, 1);
return;
}
else if (s is BreakStatement)
{
bool hadLoop = false;
while (block != null)
{
if (block.IsLoop)
{
hadLoop = true;
break;
}
block = block.PreviousBlock;
}
if (!hadLoop)
{
throw new LuaSourceException(s.LineNumber, 0, "No loop to break");
}
Instruction i = new Instruction("JMP");
i.A = 0;
i.sBx = -1; // Infinite loop ;)
emit(i);
patchSbx.Push(i);
return;
}
else if (s is ContinueStatement)
{
}
else if (s is CallStatement)
{
CallStatement cs = s as CallStatement;
DoExpr(cs.Expression);
return;
}
else if (s is DoStatement)
{
}
else if (s is GenericForStatement)
{
}
else if (s is NumericForStatement)
{
}
else if (s is FunctionStatement)
{
}
else if (s is GotoStatement)
{
;
}
else if (s is IfStmt)
{
}
else if (s is LabelStatement)
{
;
}
else if (s is RepeatStatement)
{
}
else if (s is ReturnStatement)
{
}
else if (s is UsingStatement)
{
}
else if (s is WhileStatement)
{
WhileStatement ws = s as WhileStatement;
int start = block.Chunk.Instructions.Count;
DoExpr(ws.Condition);
Instruction t = new Instruction("TEST");
t.A = block.regnum;
t.C = 0;
emit(t);
DoChunk(ws.Body, true);
Instruction i = new Instruction("JMP");
i.A = 0;
i.sBx = -(block.Chunk.Instructions.Count - start) - 1;
emit(i);
while (patchSbx.Count > 0)
{
patchSbx.Pop().sBx = Math.Abs(block.Chunk.Instructions.Count + i.sBx - 1);
}
//return;
}
throw new NotImplementedException(s.GetType().Name + " is not implemented");
}
private void EmitCallStatement(ILGenerator il, CallStatement call, SymbolTable symbolTable)
{
Symbol symbol = symbolTable.Find(call.Name, SymbolType.Function);
if (symbol != null)
{
Function function = symbol.SyntaxObject as Function;
//
// Проверка аргументов
//
if (call.Arguments == null && function.Parameters == null)
{
goto Hack;
}
else if (call.Arguments.Count != function.Parameters.Count)
{
Error("Argument mismatch [" + call.Name + "]");
}
else if (call.Arguments.Count != function.Parameters.Count)
{
Error("Argument mismatch [" + call.Name + "]");
}
else
{
for (int x = 0; x < call.Arguments.Count; x++)
{
if (call.Arguments[x].PassMethod != function.Parameters[x].PassMethod)
{
Error("Argument error [" + call.Name + "], argument [" + x + "] is wrong.");
}
}
}
if (call.Arguments != null)
{
foreach (Argument argument in call.Arguments)
{
if (argument.PassMethod == PassMethod.ByReference)
{
// Если параметр передан по ссылке
if (argument.Value is Name)
{
Symbol variable = symbolTable.Find(((Name)argument.Value).Value, SymbolType.Variable);
if (variable.CodeObject is LocalBuilder)
{
if (((Variable)variable.SyntaxObject).Type.VariableType == VariableType.PrimitiveArray)
Error("ref cannot be applied to arrays");
il.Emit(OpCodes.Ldloca, variable.CodeObject as LocalBuilder);
}
else if (variable.CodeObject is FieldBuilder)
{
if (((Variable)variable.SyntaxObject).Type.VariableType == VariableType.PrimitiveArray)
Error("ref cannot be applied to arrays");
il.Emit(OpCodes.Ldsflda, variable.CodeObject as FieldBuilder);
}
else if (variable.CodeObject is ParameterBuilder)
{
if (((Parameter)variable.SyntaxObject).Type.VariableType == VariableType.PrimitiveArray)
Error("ref cannot be applied to arrays");
il.Emit(OpCodes.Ldarga, ((ParameterBuilder)variable.CodeObject).Position - 1);
}
}
else if (argument.Value is UnaryExpression && ((UnaryExpression)argument.Value).UnaryOperatorType == UnaryOperatorType.Indexer)
{
Symbol variable = symbolTable.Find(((Name)argument.Value).Value, SymbolType.Variable);
if (variable.CodeObject is LocalBuilder)
{
il.Emit(OpCodes.Ldloc, variable.CodeObject as LocalBuilder);
}
else if (variable.CodeObject is FieldBuilder)
{
il.Emit(OpCodes.Ldsfld, variable.CodeObject as FieldBuilder);
}
else if (variable.CodeObject is ParameterBuilder)
{
il.Emit(OpCodes.Ldarga, ((ParameterBuilder)variable.CodeObject).Position - 1);
}
EmitExpression(il, ((UnaryExpression)argument.Value).Indexer, symbolTable);
il.Emit(OpCodes.Ldelema);
}
else
{
Error("ref may only be applied to variables");
}
}
else
{
EmitExpression(il, argument.Value, symbolTable);
}
}
}
Hack:
il.Emit(OpCodes.Call, ((MethodBuilder)symbol.CodeObject));
}
else
{
if (call.Name == "Read")
{
il.Emit(OpCodes.Ldstr, "Input > ");
MethodInfo write = System.Type.GetType("System.Console").GetMethod("Write", new System.Type[] { typeof(string) });
il.EmitCall(OpCodes.Call, write, null);
MethodInfo read = System.Type.GetType("System.Console").GetMethod("ReadLine");
MethodInfo parse = System.Type.GetType("System.Int32").GetMethod("Parse", new System.Type[] { typeof(string) });
il.EmitCall(OpCodes.Call, read, null);
il.EmitCall(OpCodes.Call, parse, null);
}
else if (call.Name == "Write")
{
EmitExpression(il, call.Arguments[0].Value, symbolTable);
MethodInfo write = null;
if (call.Arguments[0].Value is Literal)
{
Literal temp = call.Arguments[0].Value as Literal;
System.Type type = null;
switch (temp.LiteralType)
{
case LiteralType.Boolean:
type = typeof(bool);
break;
case LiteralType.Character:
type = typeof(char);
break;
case LiteralType.Integer:
type = typeof(int);
break;
case LiteralType.Real:
type = typeof(double);
break;
case LiteralType.String:
type = typeof(string);
break;
}
write = System.Type.GetType("System.Console").GetMethod("WriteLine", new System.Type[] { type });
}
else
{
write = System.Type.GetType("System.Console").GetMethod("WriteLine", new System.Type[] { typeof(int) });
}
il.EmitCall(OpCodes.Call, write, null);
}
else
{
Error("Unknown function name. [" + call.Name + "]");
}
}
}
public override void VisitCallStatement(CallStatement callStatement)
{
VisitCall(callStatement.Call, true);
}
public void AcceptCall(CallStatement stmt)
{
Check(stmt);
}
public virtual object Visit(CallStatement that, object value)
{
throw new System.NotImplementedException();
}
