public static ADFunctionCall fce_call(string fceName = "")
{
STRecord fceRecord = null;
var result = new ADFunctionCall();
fceRecord = STSearch(fceName);
if (MainFSM.GetNextToken().Type != TokenType.leftRBType)
{
SyntaxError("Byl ocekavan znak \'(\' pri volani funkce.");
}
var argumentsList = new List <IADExpression>();
while (MainFSM.PeekNextToken().Type != TokenType.rightRBType)
{
argumentsList.Add(PrecedenceSyntaxAnalysis.Precedence(TokenType.rightRBType));
if (MainFSM.PeekNextToken().Type == TokenType.comType)
{
MainFSM.GetNextToken();
}
}
result.Arguments = argumentsList;
result.STRecord = fceRecord;
if (MainFSM.GetNextToken().Type != TokenType.rightRBType)
{
SyntaxError("Byl ocekavan znak \')\' pri volani funkce.");
}
return(result);
}
public static IADNode WhileLoop()
{
MainFSM.GetNextToken();
if (MainFSM.GetNextToken().Type != TokenType.leftRBType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \'(\'");
}
var result = new ADWhileLoop();
result.Condition = PrecedenceSyntaxAnalysis.Precedence(TokenType.rightRBType);
if (MainFSM.GetNextToken().Type != TokenType.rightRBType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \')\'");
}
if (MainFSM.GetNextToken().Type != TokenType.leftCBType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \'{\'");
}
ParserFunctions.STablesStack.Push(new STable());
result.Body = ParserFunctions.statement_list();
if (MainFSM.GetNextToken().Type != TokenType.rightCBType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \'}\'");
}
ParserFunctions.STablesStack.Pop();
return(result);
}
public static void global_decl_type(ADVariable variable)
{
if (MainFSM.PeekNextToken().Type == TokenType.leftABType) // Pokud je dalsi token leva hranata zavorka
{
MainFSM.GetNextToken(); // Sezeru levou hranatou zavorku
// Zavolam precedencni syntakticky analyzator na vyhodnoceni cisla
var expression = PrecedenceSyntaxAnalysis.Precedence(TokenType.rightABType);
variable.ArrayDimensions.Add(new ADArrayDimension()
{
ValuesCount = expression
});
// Dalsi token musi byt prava hranata zavorka, jinak jde o syntaktickou chybu
if (MainFSM.GetNextToken().Type != TokenType.rightABType)
{
SyntaxError("Byl ocekavan znak /']/'");
}
global_decl_type(variable); // Znovu rekurzivne zavolam tuto metodu
}
var nextToken = MainFSM.PeekNextToken();
if (nextToken.Type == TokenType.comType || nextToken.Type == TokenType.semiType || nextToken.Type == TokenType.asgnType)
{
return;
}
else
{
SyntaxError("Byl ocekavan znak \';\' nebo \',\'");
}
}
/// <summary>
/// Metoda, ktera priradi promenne (poli) hodnotu/y
/// </summary>
/// <param name="variable"></param>
public static void global_assign_value(ADVariable variable)
{
// Pokud hodnota zacina na slozenou zavorku '{'
if (MainFSM.PeekNextToken().Type == TokenType.leftCBType)
{
// Pokud slo o pole, je to chyba
// TODO
if (variable.Type == ADVariable.VarType.array)
{
SyntaxError("Nelze priradit polozky do j*z deklarovaneho pole s pevnym poctem znaku.");
}
MainFSM.GetNextToken(); // Sezeru '{'
global_array_item(variable);
if (MainFSM.GetNextToken().Type != TokenType.rightCBType)
{
SyntaxError("Byl ocekavan znak \'}\'");
}
}
// Pokud to neni prirazeni hodnot do pole, prirazuji hodnotu do promenne
else
{
var expression = PrecedenceSyntaxAnalysis.Precedence(TokenType.semiType, true);
variable.Value = expression;
}
}
public static ADVariableAssignment IDAssign(bool dereference)
{
var token = MainFSM.GetNextToken();
if (token.Type != TokenType.idType)
{
ParserFunctions.SyntaxError("Byla ocekavana promenna.");
}
var record = ParserFunctions.STSearch(token.Attribute);
if (record == null)
{
ParserFunctions.SemanticError($"Promenna {token.Attribute} nebyla deklarovana");
}
var asgnOperator = MainFSM.GetNextToken();
if (!IsAssignOperator(asgnOperator.Type))
{
ParserFunctions.SyntaxError("Byl ocekavan prirazovaci operator");
}
var assign = new ADVariableAssignment()
{
Dereference = dereference, STRecord = record, AssignOperator = asgnOperator.Type
};
bool nextDereference = false;
if (MainFSM.PeekNextToken().Type == TokenType.starType)
{
nextDereference = true;
MainFSM.GetNextToken();
}
if (MainFSM.PeekNextToken().Type == TokenType.idType)
{
if (IsAssignOperator(MainFSM.PeekNextToken(2).Type))
{
assign.Expression = IDAssign(nextDereference);
}
else
{
assign.Expression = PrecedenceSyntaxAnalysis.Precedence(TokenType.semiType);
}
}
else
{
assign.Expression = PrecedenceSyntaxAnalysis.Precedence(TokenType.semiType);
}
return(assign);
}
public void ComputeIndexes()
{
MainFSM.GetNextToken();
var newIndex = PrecedenceSyntaxAnalysis.Precedence(TokenType.rightABType);
MainFSM.GetNextToken();
Indexes.Add(newIndex);
if (MainFSM.PeekNextToken().Type == TokenType.leftABType)
{
ComputeIndexes();
}
}
public static void global_array_item(ADVariable variable)
{
// Pokud neni promenna klasifikovana jako pole, vytvorim z nej pole
if (variable.ArrayDimensions.Count == 0)
{
variable.ArrayDimensions.Add(new ADArrayDimension());
variable.Type = ADVariable.VarType.array;
}
var expression = PrecedenceSyntaxAnalysis.Precedence(TokenType.rightCBType);
variable.ArrayDimensions[0].Values.Add(expression);
next_global_array_item(variable);
}
public static IADNode Return()
{
if (MainFSM.GetNextToken().Type != TokenType.returnType)
{
ParserFunctions.SyntaxError("Bylo ocekavano klicove slovo \'return\'");
}
var result = PrecedenceSyntaxAnalysis.Precedence(TokenType.semiType);
if (MainFSM.GetNextToken().Type != TokenType.semiType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \';\'");
}
return(new ADReturn {
Expression = result
});
}
static void Main(string[] args)
{
PrecedenceSyntaxAnalysis.LoadPrecTable();
string input = string.Empty;
string sourceCode = string.Empty;
while ((input = Console.ReadLine()) != null)
{
sourceCode += input + Environment.NewLine;
}
MainFSM.SourceCode = sourceCode;
MainFSM.Index = 0;
MainFSM.RowCounter = 0;
var adTree = new ADTree();
ParserFunctions.prog(adTree);
AssemblyCompiler.Compile(adTree);
}
public static void ArrayValuesDeclaration(ADVariable array, int dimensionIndex)
{
if (array.ArrayDimensions.Count > 0 && array.ArrayDimensions.Count < (dimensionIndex + 1))
{
ParserFunctions.SemanticError("Dane pole nema tolik dimenzi.");
}
array.Type = ADVariable.VarType.array;
if (MainFSM.GetNextToken().Type == TokenType.leftCBType)
{
while (MainFSM.PeekNextToken().Type != TokenType.rightCBType)
{
array.ArrayDimensions[dimensionIndex].Values.Add
(
PrecedenceSyntaxAnalysis.Precedence(TokenType.rightCBType)
);
if (MainFSM.PeekNextToken().Type == TokenType.comType)
{
MainFSM.GetNextToken();
}
}
if (MainFSM.GetNextToken().Type != TokenType.rightCBType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \'}\'");
}
if (MainFSM.PeekNextToken().Type == TokenType.comType)
{
ArrayValuesDeclaration(array, dimensionIndex++);
}
}
else
{
ParserFunctions.SyntaxError("Byl ocekavan znak \'{\'");
}
}
public static IADExpression value()
{
var token = MainFSM.PeekNextToken();
if (token.Type == TokenType.idType)
{
if (MainFSM.PeekNextToken(2).Type == TokenType.leftRBType)
{
return(fce_call());
}
else
{
var symbol = STSearch(MainFSM.PeekNextToken().Attribute);
if (symbol == null)
{
SemanticError($"Promenna {token.Attribute} nebyla deklarovana.");
}
return(new ADVariable()
{
Name = symbol.Name, STRecord = symbol
});
}
}
else
{
if (token.Type == TokenType.decNumberType ||
token.Type == TokenType.hexNumberType ||
token.Type == TokenType.octNumberType)
{
return(PrecedenceSyntaxAnalysis.Precedence(TokenType.rightABType));
}
}
return(null);
}
public static IADNode statement()
{
var nextToken = MainFSM.PeekNextToken();
IADNode result = null;
switch (nextToken.Type)
{
case TokenType.longType:
var list = new ADVariableDeclarations();
StatementHelpers.VariableDeclaration(ref list);
list.Variables.Reverse();
result = list;
break;
case TokenType.starType:
result = new ADStatementExpression {
Expression = PrecedenceSyntaxAnalysis.Precedence(TokenType.semiType)
};
if (MainFSM.GetNextToken().Type != TokenType.semiType)
{
SyntaxError("Byl ocekavan znak \';\'");
}
break;
case TokenType.idType:
case TokenType.incrType:
case TokenType.decrType:
if (MainFSM.PeekNextToken(2).Type == TokenType.leftRBType)
{
var fceToken = MainFSM.GetNextToken();
result = fce_call(fceToken.Attribute);
if (MainFSM.GetNextToken().Type != TokenType.semiType)
{
SyntaxError("Byl ocekavan znak \';\'");
}
}
else
{
result = new ADStatementExpression {
Expression = PrecedenceSyntaxAnalysis.Precedence(TokenType.semiType)
};
if (MainFSM.GetNextToken().Type != TokenType.semiType)
{
SyntaxError("Byl ocekavan znak \';\'");
}
}
break;
case TokenType.ifType:
result = StatementHelpers.Condition();
break;
case TokenType.forType:
result = StatementHelpers.ForLoop();
break;
case TokenType.whileType:
result = StatementHelpers.WhileLoop();
break;
case TokenType.doType:
result = StatementHelpers.DoWhileLoop();
break;
case TokenType.returnType:
result = StatementHelpers.Return();
break;
case TokenType.breakType:
result = StatementHelpers.Break();
break;
case TokenType.continueType:
result = StatementHelpers.Continue();
break;
case TokenType.leftCBType:
result = StatementHelpers.InnerStatements();
break;
default:
SyntaxError("Byl ocekavan jeden z nasledujici klicovych slov nebo znaku: long, *, identifikator, if, for, while, do, return, break, continue");
break;
}
return(result);
}
public static void VariableDeclaration(ref ADVariableDeclarations list, bool recursive = false)
{
if (!recursive)
{
if (MainFSM.GetNextToken().Type != TokenType.longType)
{
ParserFunctions.SyntaxError("Bylo ocekavano klicove slovo \'long\'");
}
}
var token = MainFSM.GetNextToken();
if (token.Type != TokenType.idType)
{
ParserFunctions.SyntaxError("Byl ocekavan identifikator");
}
if (ParserFunctions.STSearch(token.Attribute, true) != null)
{
ParserFunctions.SemanticError($"Promenna {token.Attribute} byla j*z deklarovana");
}
var newRecord = new STRecord()
{
Name = token.Attribute,
Access = STAccess.local
};
ParserFunctions.STablesStack.Peek().Records.Add(newRecord);
var variableDeclaration = new ADVariable()
{
Name = token.Attribute,
STRecord = newRecord,
Type = ADVariable.VarType.variable
};
ParserFunctions.decl_type(variableDeclaration);
if (MainFSM.PeekNextToken().Type == TokenType.comType)
{
MainFSM.GetNextToken();
VariableDeclaration(ref list, true);
}
if (MainFSM.PeekNextToken().Type == TokenType.semiType)
{
list.Variables.Add(variableDeclaration);
if (!recursive)
{
MainFSM.GetNextToken();
}
return;
}
if (MainFSM.GetNextToken().Type != TokenType.asgnType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \';\' nebo \'=\'");
}
if (MainFSM.PeekNextToken().Type == TokenType.leftCBType)
{
variableDeclaration.STRecord.Type = STType.array;
if (variableDeclaration.ArrayDimensions.Count == 0)
{
variableDeclaration.ArrayDimensions.Add(new ADArrayDimension());
}
ArrayValuesDeclaration(variableDeclaration, 0);
}
else
{
variableDeclaration.STRecord.Type = STType.variable;
variableDeclaration.Value = PrecedenceSyntaxAnalysis.Precedence(TokenType.semiType, true);
}
if (MainFSM.PeekNextToken().Type == TokenType.comType)
{
MainFSM.GetNextToken();
VariableDeclaration(ref list, true);
}
if (!recursive)
{
if (MainFSM.GetNextToken().Type != TokenType.semiType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \';\'");
}
}
list.Variables.Add(variableDeclaration);
}
