/// <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 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 \',\'");
}
}
public static ADVariable global_variable_list()
{
// Pokud je dalsi token ','
if (MainFSM.PeekNextToken().Type == TokenType.comType)
{
MainFSM.GetNextToken(); // Sezeru ','
var id = MainFSM.GetNextToken(); // Dalsim znakem musi byt identifikator
if (id.Type != TokenType.idType)
{
SyntaxError("Byl ocekavan identifikator promenne.");
}
var variable = new ADVariable()
{
Name = id.Attribute
};
global_decl_type(variable);
global_assign(variable);
// Pokud jde o pole, nastavim mu takovy typ
if (variable.ArrayDimensions.Count > 0)
{
variable.Type = ADVariable.VarType.array;
}
else
{
variable.Type = ADVariable.VarType.variable;
}
return(variable);
}
return(null);
}
/// <summary>
/// Metoda, ktera priradi (pokud je zadana) hodnotu promenne.
/// </summary>
/// <param name="variable"></param>
public static void global_assign(ADVariable variable)
{
// Pokud je dalsi token znak /'='/
if (MainFSM.PeekNextToken().Type == TokenType.asgnType)
{
var token = MainFSM.GetNextToken(); // Sezeru '='
global_assign_value(variable);
}
}
public static void next_global_array_item(ADVariable variable)
{
var nextToken = MainFSM.PeekNextToken();
if (nextToken.Type == TokenType.comType)
{
MainFSM.GetNextToken(); // Sezeru carku
global_array_item(variable);
}
if (MainFSM.PeekNextToken().Type == TokenType.rightCBType)
{
return;
}
}
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 void decl_type(ADVariable variable)
{
if (MainFSM.PeekNextToken().Type == TokenType.leftABType)
{
MainFSM.GetNextToken();
variable.Type = ADVariable.VarType.array;
variable.STRecord.Type = STType.array;
var arrayDimension = new ADArrayDimension()
{
ValuesCount = value()
};
variable.ArrayDimensions.Add(arrayDimension);
if (MainFSM.GetNextToken().Type != TokenType.rightABType)
{
SyntaxError("Byl ocekavan znak \']\'");
}
decl_type(variable);
}
}
public static void PrintVariable(ADVariable variable, string tab)
{
if (variable.Type == ADVariable.VarType.variable)
{
Console.WriteLine($"{tab}Variable: {variable.Name}");
}
else if (variable.Type == ADVariable.VarType.array)
{
Console.WriteLine($"{tab}Array: {variable.Name}:");
Console.WriteLine($"{tab}\t Dimensions:");
foreach (var dimension in variable.ArrayDimensions)
{
if (dimension.ValuesCount != null)
{
Console.WriteLine($"{tab}\t\tCount:");
PrintExpression(dimension.ValuesCount, tab + "\t\t\t");
}
if (dimension.Values.Count > 0)
{
Console.WriteLine($"{tab}\t\tValues:");
}
foreach (var value in dimension.Values)
{
PrintExpression(value, tab + "\t\t\t");
}
}
}
else if (variable.Type == ADVariable.VarType.pointer)
{
Console.WriteLine($"{tab} Pointer {variable.Name}:");
}
if (variable.Value != null)
{
Console.WriteLine($"{tab}\t Value");
PrintExpression(variable.Value, tab + "\t\t");
}
}
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 \'{\'");
}
}
private static IADExpression GetExpression(STRecord stRecord)
{
IADExpression result = null;
if (stRecord.Type == STType.constant)
{
result = new ADConstant {
Value = stRecord.Value
};
}
else if (stRecord.Type == STType.variable || stRecord.Type == STType.array)
{
result = new ADVariable {
Name = stRecord.Name, Type = ADVariable.VarType.variable, STRecord = stRecord
};
}
else if (stRecord.Type == STType.function)
{
MainFSM.Index--;
result = ParserFunctions.fce_call();
}
return(result);
}
public static IEnumerable <ADVariable> glob_decl()
{
if (MainFSM.GetNextToken().Type != TokenType.longType)
{
SyntaxError("Byla ocekavana deklarace globalni promenne nebo funkce.");
}
var id = MainFSM.GetNextToken();
if (id.Type != TokenType.idType)
{
SyntaxError("Byl ocekavan identifikator promenne.");
}
var variable = new ADVariable()
{
Name = id.Attribute
};
variable.STRecord = new STRecord
{
Access = STAccess.global,
Name = variable.Name,
Type = STType.variable,
Address = variable.Name
};
STablesStack.Peek().Records.Add(variable.STRecord);
global_decl_type(variable);
if (variable.ArrayDimensions.Count > 0)
{
variable.Type = ADVariable.VarType.array;
}
else
{
variable.Type = ADVariable.VarType.variable;
}
global_assign(variable);
yield return(variable);
List <ADVariable> variableList = new List <ADVariable>();
variableList.Add(variable);
while (true)
{
variable = global_variable_list();
if (variable != null)
{
variableList.Add(variable);
yield return(variable);
}
else
{
foreach (var item in variableList)
{
if (item.Value == null)
{
item.Value = variableList.Last().Value;
}
}
break;
}
}
if (MainFSM.GetNextToken().Type != TokenType.semiType)
{
SyntaxError("Byl ocekavan znak \';\'");
}
yield break;
}
private static Term GetNextTerm(TokenType endType, int numOfLeftB, int numOfRightB, ref Stack <Term> SS, bool decl = false)
{
var token = MainFSM.GetNextToken();
TermType type = TermType.error;
Term newTerm = new Term();
#region Term type by token
switch (token.Type)
{
case TokenType.exrType:
type = TermType.not;
break;
case TokenType.decNumberType:
case TokenType.hexNumberType:
case TokenType.octNumberType:
case TokenType.charType:
case TokenType.idType:
case TokenType.longType:
case TokenType.sizeofType:
case TokenType.stringType:
type = TermType.id;
break;
case TokenType.asgnType:
type = TermType.asgn;
break;
case TokenType.procType:
type = TermType.mod;
break;
case TokenType.ampType:
type = TermType.binAnd;
break;
case TokenType.andType:
type = TermType.logAnd;
break;
case TokenType.starType:
type = TermType.mul;
break;
case TokenType.plusType:
type = TermType.plus;
break;
case TokenType.incrType:
type = TermType.inc;
break;
case TokenType.minusType:
type = TermType.minus;
break;
case TokenType.decrType:
type = TermType.dec;
break;
case TokenType.divType:
type = TermType.div;
break;
case TokenType.tElseType:
type = TermType.cElse;
break;
case TokenType.leftRBType:
type = TermType.leftBr;
break;
case TokenType.rightRBType:
type = TermType.rightBr;
break;
case TokenType.lessType:
type = TermType.less;
break;
case TokenType.leftType:
type = TermType.left;
break;
case TokenType.lessEqType:
type = TermType.lessEq;
break;
case TokenType.eqEqType:
type = TermType.eq;
break;
case TokenType.grtType:
type = TermType.grt;
break;
case TokenType.grtEqType:
type = TermType.grtEq;
break;
case TokenType.rightType:
type = TermType.right;
break;
case TokenType.tIfType:
type = TermType.cCond;
break;
case TokenType.xorType:
type = TermType.xor;
break;
case TokenType.bOrType:
type = TermType.binOr;
break;
case TokenType.lOrType:
type = TermType.logOr;
break;
case TokenType.plusEqType:
type = TermType.plusEq;
break;
case TokenType.minusEqType:
type = TermType.minusEq;
break;
case TokenType.multEqType:
type = TermType.mulEq;
break;
case TokenType.divEqType:
type = TermType.divEq;
break;
case TokenType.procEq:
type = TermType.modEq;
break;
case TokenType.rightEqType:
type = TermType.rightEq;
break;
case TokenType.leftEqType:
type = TermType.leftEq;
break;
case TokenType.ampEqType:
type = TermType.andEq;
break;
case TokenType.xorEqType:
type = TermType.xorEq;
break;
case TokenType.bOrEqType:
type = TermType.orEq;
break;
case TokenType.bNotType:
type = TermType.compl;
break;
case TokenType.exrEqType:
type = TermType.negEq;
break;
case TokenType.leftABType:
type = TermType.leftABtype;
break;
}
#endregion
if ((endType == TokenType.rightCBType ||
endType == TokenType.rightRBType) &&
token.Type == TokenType.comType &&
(numOfLeftB == numOfRightB))
{
type = TermType.end;
}
if (endType == TokenType.semiType && decl && token.Type == TokenType.comType)
{
type = TermType.end;
}
if (token.Type == endType && (numOfLeftB == numOfRightB))
{
type = TermType.end;
}
if (token.Type == TokenType.leftCBType)
{
MainFSM.Index--;
var array = new ADVariable()
{
Type = ADVariable.VarType.array
};
array.ArrayDimensions.Add(new ADArrayDimension());
StatementHelpers.ArrayValuesDeclaration(array, 0);
type = TermType.id;
array.STRecord = new STRecord {
Access = STAccess.local, Name = array.Name, Type = STType.array
};
newTerm.Expression = array;
newTerm.STRecord = array.STRecord;
var declaration = new ADVariableDeclarations();
declaration.Variables.Add(array);
(AnonymousDeclarations as List <IADNode>).Add(declaration);
}
if (type != TermType.error)
{
if (token.Type == TokenType.decNumberType ||
token.Type == TokenType.hexNumberType ||
token.Type == TokenType.octNumberType ||
token.Type == TokenType.charType)
{
string newId = Guid.NewGuid().ToString("N");
newTerm.STRecord.Name = newId;
newTerm.STRecord.Value = token.Attribute;
newTerm.STRecord.Type = STType.constant;
}
else if (token.Type == TokenType.stringType)
{
string newId = Guid.NewGuid().ToString("N");
newTerm.STRecord.Name = newId;
newTerm.STRecord.Value = token.Attribute;
newTerm.STRecord.Type = STType.str;
newTerm.STRecord.Access = STAccess.local;
var array = new ADVariable
{
STRecord = newTerm.STRecord,
Name = newId,
Type = ADVariable.VarType.array
};
if (MainFSM.PeekNextToken().Type == TokenType.leftABType)
{
var arrayValue = new ADArrayValue()
{
STRecord = newTerm.STRecord
};
arrayValue.ComputeIndexes();
newTerm.Expression = arrayValue;
}
var declaration = new ADVariableDeclarations();
declaration.Variables.Add(array);
(AnonymousDeclarations as List <IADNode>).Add(declaration);
}
else if (token.Type == TokenType.idType)
{
var stRecord = ParserFunctions.STSearch(token.Attribute);
if (stRecord == null)
{
if (MainFSM.PeekNextToken().Type == TokenType.leftRBType)
{
stRecord = ParserFunctions.STablesStack.Peek().Records.Where(m => m.Name == token.Attribute).FirstOrDefault();
if (stRecord == null)
{
stRecord = new STRecord()
{
Name = token.Attribute, Type = STType.function
};
}
}
if (stRecord == null)
{
ParserFunctions.SemanticError($"Promenna \'{token.Attribute}\' nebyla deklarovana.");
}
}
if (stRecord.Type == STType.function)
{
if (SS.Peek().Type == TermType.reference)
{
stRecord.Address = stRecord.Name;
var variable = new ADVariable()
{
Name = stRecord.Name, STRecord = stRecord, Type = ADVariable.VarType.function
};
newTerm.Expression = variable;
}
else
{
var fceCall = ParserFunctions.fce_call(token.Attribute);
fceCall.STRecord = stRecord;
newTerm.Expression = fceCall;
}
}
newTerm.STRecord = stRecord;
}
else if (token.Type == TokenType.sizeofType)
{
if (MainFSM.GetNextToken().Type != TokenType.leftRBType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \'(\'");
}
if (MainFSM.GetNextToken().Type != TokenType.longType)
{
ParserFunctions.SyntaxError("Bylo ocekavano klicove slovo \'long\'");
}
if (MainFSM.GetNextToken().Type != TokenType.rightRBType)
{
ParserFunctions.SyntaxError("Byl ocekavan znak \')\'");
}
newTerm.Expression = new ADSizeOfValue();
type = TermType.id;
}
newTerm.Type = type;
return(newTerm);
}
else
{
ParserFunctions.SyntaxError("Chyba ve vyrazu.");
return(null);
}
}
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);
}
