internal static CompilerException AppendCodeInfo(CompilerException exc, CodePositionInfo codePosInfo)
{
exc.LineNumber = codePosInfo.LineNumber;
exc.ColumnNumber = codePosInfo.LineNumber;
exc.Code = codePosInfo.Code;
exc.ModuleName = codePosInfo.ModuleName;
return(exc);
}
private void UnwindOperators()
{
while (_operators.Count > 0)
{
var oper = PopOperator();
if (oper == Token.OpenPar)
{
throw CompilerException.ExpressionSyntax();
}
AddCommandForToken(oper);
}
}
internal static CompilerException AppendCodeInfo(CompilerException exc, CodePositionInfo codePosInfo)
{
AppendCodeInfo(exc, codePosInfo.LineNumber, codePosInfo.Code);
return(exc);
}
internal static CompilerException AppendCodeInfo(CompilerException exc, int line, string codeString)
{
exc.LineNumber = line;
exc.Code = codeString;
return(exc);
}
private void AppendCodeInfo(int line, CompilerException exc)
{
var cp = new CodePositionInfo();
cp.LineNumber = line;
cp.Code = _parser.GetCodeLine(line);
CompilerException.AppendCodeInfo(exc, cp);
}
private void BuildSingleMethod()
{
if (_lastExtractedLexem.Token == Token.Procedure)
{
PushStructureToken(Token.EndProcedure);
_isFunctionProcessed = false;
NextToken();
}
else if (_lastExtractedLexem.Token == Token.Function)
{
PushStructureToken(Token.EndFunction);
_isFunctionProcessed = true;
NextToken();
}
else
{
throw CompilerException.UnexpectedOperation();
}
#region Method signature
// сигнатура
if (!IsUserSymbol(ref _lastExtractedLexem))
{
throw CompilerException.IdentifierExpected();
}
int definitionLine = _parser.CurrentLine;
MethodInfo method = new MethodInfo();
method.Name = _lastExtractedLexem.Content;
method.IsFunction = _isFunctionProcessed;
NextToken();
if (_lastExtractedLexem.Token != Token.OpenPar)
{
throw CompilerException.TokenExpected(Token.OpenPar);
}
#endregion
NextToken();
#region Parameters list
var paramsList = new List<ParameterDefinition>();
var methodCtx = new SymbolScope();
while (_lastExtractedLexem.Token != Token.ClosePar)
{
var param = new ParameterDefinition();
string name;
if (_lastExtractedLexem.Token == Token.ByValParam)
{
param.IsByValue = true;
NextToken();
if (IsUserSymbol(ref _lastExtractedLexem))
{
name = _lastExtractedLexem.Content;
}
else
{
throw CompilerException.IdentifierExpected();
}
}
else if (IsUserSymbol(ref _lastExtractedLexem))
{
param.IsByValue = false;
name = _lastExtractedLexem.Content;
}
else
{
throw CompilerException.UnexpectedOperation();
}
NextToken();
if (_lastExtractedLexem.Token == Token.Equal)
{
param.HasDefaultValue = true;
NextToken();
if (IsLiteral(ref _lastExtractedLexem))
{
var cd = CreateConstDefinition(ref _lastExtractedLexem);
var num = GetConstNumber(ref cd);
param.DefaultValueIndex = num;
NextToken();
}
else
{
throw CompilerException.UnexpectedOperation();
}
}
if (_lastExtractedLexem.Token == Token.Comma || _lastExtractedLexem.Token == Token.ClosePar)
{
paramsList.Add(param);
methodCtx.DefineVariable(name);
if(_lastExtractedLexem.Token != Token.ClosePar)
NextToken();
}
else
{
throw CompilerException.UnexpectedOperation();
}
}
method.Params = paramsList.ToArray();
#endregion
NextToken();
bool isExportedMethod = false;
if (_lastExtractedLexem.Token == Token.Export)
{
isExportedMethod = true;
NextToken();
}
#region Body
// тело
var entryPoint = _module.Code.Count;
try
{
_ctx.PushScope(methodCtx);
DispatchMethodBody();
}
finally
{
_ctx.PopScope();
}
var pop = PopStructureToken();
var descriptor = new MethodDescriptor();
descriptor.EntryPoint = entryPoint;
descriptor.Signature = method;
descriptor.VariableFrameSize = methodCtx.VariableCount;
SymbolBinding binding;
try
{
binding = _ctx.DefineMethod(method);
}
catch (CompilerException)
{
var exc = new CompilerException("Метод с таким именем уже определен: " + method.Name);
exc.LineNumber = definitionLine;
exc.Code = _parser.GetCodeLine(exc.LineNumber);
throw exc;
}
_module.MethodRefs.Add(binding);
_module.Methods.Add(descriptor);
if (isExportedMethod)
{
_module.ExportedMethods.Add(new ExportedSymbol()
{
SymbolicName = method.Name,
Index = binding.CodeIndex
});
}
#endregion
NextToken();
}
internal static CompilerException AppendCodeInfo(CompilerException exc, CodePositionInfo codePosInfo)
{
AppendCodeInfo(exc, codePosInfo.LineNumber, codePosInfo.Code);
return exc;
}
internal static CompilerException AppendCodeInfo(CompilerException exc, int line, string codeString)
{
exc.LineNumber = line;
exc.Code = codeString;
return exc;
}
public void Build(Token stopToken)
{
const int STATE_UNDEF = 0;
const int STATE_OPERAND_EXPECTED = 1;
const int STATE_FUNC_WAIT = 2;
const int STATE_OPERATOR_EXPECTED = 3;
_operators = new Stack <Token>();
int currentState = STATE_UNDEF;
string waitingIdentifier = null;
int parCount = 0;
while (true)
{
bool success = false;
if (_compiler._lastExtractedLexem.Token == stopToken)
{
if (currentState == STATE_FUNC_WAIT)
{
_compiler.BuildPushVariable(waitingIdentifier);
}
else if (currentState != STATE_OPERATOR_EXPECTED)
{
throw CompilerException.ExpressionSyntax();
}
break;
}
switch (currentState)
{
case STATE_UNDEF:
case STATE_OPERAND_EXPECTED:
if (_compiler.IsLiteral(ref _compiler._lastExtractedLexem))
{
_compiler.BuildPushConstant();
currentState = STATE_OPERATOR_EXPECTED;
success = true;
}
else if (_compiler._lastExtractedLexem.Type == LexemType.Identifier)
{
if (_compiler._lastExtractedLexem.Token == Token.NotAToken)
{
waitingIdentifier = _compiler._lastExtractedLexem.Content;
currentState = STATE_FUNC_WAIT;
success = true;
}
else if (LanguageDef.IsBuiltInFunction(_compiler._lastExtractedLexem.Token))
{
_compiler.BuildBuiltinFunction();
currentState = STATE_OPERATOR_EXPECTED;
success = true;
}
else if (_compiler._lastExtractedLexem.Token == Token.NewObject)
{
_compiler.BuildNewObjectCreation();
currentState = STATE_OPERATOR_EXPECTED;
success = true;
}
else
{
throw CompilerException.TokenExpected(stopToken);
}
}
else if (_compiler._lastExtractedLexem.Token == Token.Minus)
{
PushOperator(Token.UnaryMinus);
currentState = STATE_OPERAND_EXPECTED;
success = true;
}
else if (_compiler._lastExtractedLexem.Token == Token.OpenPar)
{
PushOperator(Token.OpenPar);
parCount++;
currentState = STATE_UNDEF;
success = true;
}
else if (_compiler._lastExtractedLexem.Token == Token.Not)
{
PushOperator(Token.Not);
currentState = STATE_OPERAND_EXPECTED;
success = true;
}
break;
case STATE_FUNC_WAIT:
if (_compiler._lastExtractedLexem.Token == Token.OpenPar)
{
_compiler.BuildFunctionCall(waitingIdentifier);
if (_compiler._lastExtractedLexem.Token == Token.ClosePar)
{
currentState = STATE_OPERATOR_EXPECTED;
success = true;
}
else if (_compiler._lastExtractedLexem.Type == LexemType.Operator)
{
currentState = STATE_OPERATOR_EXPECTED;
continue;
}
}
else if (_compiler._lastExtractedLexem.Token == Token.OpenBracket)
{
_compiler.BuildIndexedAccess(waitingIdentifier);
currentState = STATE_OPERATOR_EXPECTED;
success = true;
}
else if (_compiler._lastExtractedLexem.Token == Token.Dot)
{
_compiler.BuildPushVariable(waitingIdentifier);
int identifier;
_compiler.BuildResolveChain(out identifier);
_compiler.ProcessResolvedItem(identifier, stopToken);
if (_compiler._lastExtractedLexem.Type == LexemType.Operator || _compiler._lastExtractedLexem.Token == stopToken)
{
currentState = STATE_OPERATOR_EXPECTED;
continue;
}
}
else if (_compiler._lastExtractedLexem.Type == LexemType.Operator && IsBinaryOperator(_compiler._lastExtractedLexem.Token))
{
_compiler.BuildPushVariable(waitingIdentifier);
currentState = STATE_OPERATOR_EXPECTED;
continue;
}
else if (_compiler._lastExtractedLexem.Token == Token.ClosePar)
{
_compiler.BuildPushVariable(waitingIdentifier);
currentState = STATE_OPERATOR_EXPECTED;
continue;
}
break;
case STATE_OPERATOR_EXPECTED:
if (_compiler._lastExtractedLexem.Type == LexemType.Operator && IsBinaryOperator(_compiler._lastExtractedLexem.Token))
{
ProcessExpressionOperator();
currentState = STATE_OPERAND_EXPECTED;
success = true;
}
else if (_compiler._lastExtractedLexem.Token == Token.ClosePar)
{
Token current;
parCount--;
if (parCount < 0)
{
UnwindOperators();
var cp = new CodePositionInfo();
cp.LineNumber = _compiler._parser.CurrentLine;
cp.Code = _compiler._parser.GetCodeLine(cp.LineNumber);
throw new ExtraClosedParenthesis(cp);
}
if (_operators.Count > 0)
{
while ((current = PopOperator()) != Token.OpenPar)
{
AddCommandForToken(current);
if (_operators.Count == 0)
{
throw CompilerException.TokenExpected(Token.OpenPar);
}
}
currentState = STATE_OPERATOR_EXPECTED;
success = true;
}
else
{
throw CompilerException.TokenExpected(Token.OpenPar);
}
}
else if (_compiler._lastExtractedLexem.Token == Token.OpenBracket)
{
_compiler.NextToken();
_compiler.BuildExpression(Token.CloseBracket);
_compiler.AddCommand(OperationCode.PushIndexed, 0);
currentState = STATE_OPERATOR_EXPECTED;
success = true;
}
else if (_compiler._lastExtractedLexem.Token == Token.Dot)
{
int identifier;
_compiler.BuildResolveChain(out identifier);
_compiler.ProcessResolvedItem(identifier, stopToken);
if (_compiler._lastExtractedLexem.Type == LexemType.Operator || _compiler._lastExtractedLexem.Token == stopToken)
{
currentState = STATE_OPERATOR_EXPECTED;
continue;
}
}
else if (_compiler._lastExtractedLexem.Token != stopToken)
{
throw CompilerException.TokenExpected(stopToken);
}
break;
}
if (success)
{
if (_compiler._lastExtractedLexem.Token != stopToken)
{
_compiler.NextToken();
}
}
else
{
throw CompilerException.ExpressionSyntax();
}
}
UnwindOperators();
}