public override void CheckSemantics(Scope scope, List<SemanticError> errors)
{
CheckIdentifier(scope, errors);
if (scope.GetType(Identifier.Text).Type != TypesEnumeration.Array)
errors.Add(SemanticError.WrongType(Identifier.Text, "Array", this));
Identifier.ILName = string.Format("{0}Scope{1}", Identifier.Text, scope.CurrentScope);
DefinedType.ILName = scope.GetILTypeName(DefinedType.Text);
}
public override void CheckSemantics(Scope scope, List<SemanticError> errors)
{
//Verify if the array exist
var varInfo = scope.GetVarInstance(this.ArrayIdentifier.Text);
if (varInfo == null)
{
errors.Add(SemanticError.UndefinedVariableUsed(this.ArrayIdentifier.Text, this));
return;
}
this.NextNested.CheckSemantics(varInfo.VariableType, scope, errors);
ExpressionType = this.NextNested.ExpressionType;
ArrayIdentifier.ILName = scope.GetILVarNames(ArrayIdentifier.Text);
var arrayInfo = (ArrayInfo) scope.GetType(varInfo.VariableType);
NextNested.Index.ILName = scope.GetILTypeName(arrayInfo.ItemsType);
ILName = scope.GetILVarNames(ArrayIdentifier.Text);
ExpressionType.ILName = scope.GetILTypeName(ExpressionType.Name);
}
public void CheckSemantics(string identifier, Scope scope, List<SemanticError> errors)
{
NestedNode curreNode = this;
do
{
//check the field access
var typeInfo = scope.GetType(identifier);
if (curreNode is FieldNestedNode)
{
//check if the type is record
if (typeInfo.Type != TypesEnumeration.Record)
{
errors.Add(SemanticError.WrongType("Record", typeInfo.Type.ToString(), this));
return;
}
var recordInfo = (RecordInfo)typeInfo;
var fieldNested = (FieldNestedNode) curreNode;
var currentField = recordInfo.Parameters.FirstOrDefault(x => x.Identifier == fieldNested.FieldIdentifier.Text);
if (currentField == null)
errors.Add(SemanticError.InvalidFieldAccess(identifier,
fieldNested.FieldIdentifier.Text, this));
else
{
fieldNested.FieldIdentifier.ILName = scope.GetILTypeName(identifier) + "." + fieldNested.FieldIdentifier.Text;
identifier = currentField.Type;
}
}
else
{
//check if the type is an array
if (typeInfo.Type != TypesEnumeration.Array)
{
errors.Add(SemanticError.WrongType("Array", typeInfo.Type.ToString(), this));
return;
}
var arrayInfo = (ArrayInfo) typeInfo;
var arrayIndex = (IndexNestedNode) curreNode;
arrayIndex.CheckSemantics(scope, errors);
if (((IndexNestedNode)curreNode).Index.ExpressionType.Type != TypesEnumeration.Integer)
errors.Add(SemanticError.WrongType(((IndexNestedNode)curreNode).Index.ExpressionType.Name,"int",this));
else
{
identifier = arrayInfo.ItemsType;
//arrayIndex.Index.ILName = scope.GetILTypeName(identifier);
}
curreNode.ILName = scope.GetILTypeName(identifier);
//curreNode.ILName = scope.GetILTypeName(identifier) + "." + fieldNested.FieldIdentifier.Text;
}
curreNode = curreNode.NextNested;
} while (curreNode != null);
ExpressionType = scope.GetType(identifier);
}
public override void CheckSemantics(Scope scope, List<SemanticError> errors)
{
var newScope = new Scope(scope);
DeclarationBlock.CheckSemantics(newScope, errors);
if (InstructionsBlock != null)
InstructionsBlock.CheckSemantics(newScope, errors);
//check the visibility of the returned type.
ExpressionType = InstructionsBlock == null ? TypeInfo.GenerateVoidInfo() : this.InstructionsBlock.ExpressionType;
if (ExpressionType != null && ExpressionType.Type != TypesEnumeration.Void && !scope.ContainsType(ExpressionType.Name))
errors.Add(SemanticError.TypeNotVisible(ExpressionType.Name, this));
ExpressionType.ILName = scope.GetILTypeName(ExpressionType.Name);
}
public override void CheckSemantics(Scope scope, List<SemanticError> errors)
{
var varInfo = scope.GetVarInstance(Record.Text);
//Verify if the variable exist
if (varInfo == null)
{
errors.Add(SemanticError.UndefinedVariableUsed(this.Record.Text, this));
return;
}
NextNested.CheckSemantics(varInfo.VariableType, scope, errors);
ExpressionType = NextNested.ExpressionType;
Record.ILName = scope.GetILVarNames(Record.Text);
ILName = scope.GetILVarNames(Record.Text);
ExpressionType.ILName = scope.GetILTypeName(ExpressionType.Name);
}
public override void CheckSemantics(Scope scope, List<SemanticError> errors)
{
RecordIdentifier.ILName = scope.GetILTypeName(RecordIdentifier.Text);
var typeInfo = scope.GetType(this.RecordIdentifier.Text);
//check if the record type is defined
if (typeInfo == null || typeInfo.Type != TypesEnumeration.Record || scope.GetType(typeInfo.Name).Name != scope.GetType(this.RecordIdentifier.Text).Name)
{
errors.Add(SemanticError.TypeNotDefined(this.RecordIdentifier.Text, this));
return;
}
var recordInfo = (RecordInfo) typeInfo;
//the count of parameters used to define and to initialice a record must match.
if (recordInfo.FieldsCount != this.FieldInitialicer.Count)
{
errors.Add(SemanticError.WrongParameterNumber("Record", this.RecordIdentifier.Text, recordInfo.FieldsCount, this.FieldInitialicer.Count, this));
return;
}
for (int i = 0; i < recordInfo.FieldsCount; i++)
{
var assignNode = this.FieldInitialicer[i];
assignNode.CheckSemantics(scope, errors);
//check the field name and order
if (assignNode.Field.Text != recordInfo.Parameters[i].Identifier)
errors.Add(SemanticError.WrongFieldInit(this.RecordIdentifier.Text, recordInfo.Parameters[i].Identifier, this));
//check the field type
if (assignNode.Value.ExpressionType.Type == TypesEnumeration.Nil)
{
if (!scope.GetType(recordInfo.Parameters[i].Type).Nilable)
errors.Add(SemanticError.InvalidNilAssignation(recordInfo.Parameters[i].Identifier, this));
}
else if (scope.GetType(assignNode.Value.ExpressionType.Name).Name != scope.GetType(recordInfo.Parameters[i].Type).Name)
errors.Add(SemanticError.WrongType(assignNode.Value.ExpressionType.Name, recordInfo.Parameters[i].Type, this));
FieldInitialicer[i].ILName = RecordIdentifier.ILName + string.Format(".{0}", assignNode.Field.Text);
}
ExpressionType = recordInfo;
ExpressionType.ILName = scope.GetILTypeName(ExpressionType.Name);
}
public override void CheckSemantics(Scope scope, List<SemanticError> errors)
{
CheckFunctionId(scope,errors);
//check the return type is defined already
if (!scope.ContainsType(ReturnType.Text))
{
errors.Add(SemanticError.TypeNotDefined(ReturnType.Text, this));
return;
}
var newScope = CreateFunctionScope(scope, errors);
Body.CheckSemantics(newScope, errors);
if (Body.ExpressionType.Type == TypesEnumeration.Nil)
{
if (!scope.GetType(ReturnType.Text).Nilable)
errors.Add(SemanticError.InvalidNilAssignation(ReturnType.Text,this));
}
else if (Body.ExpressionType.Name != scope.GetType(ReturnType.Text).Name)
errors.Add(SemanticError.WrongType(ReturnType.Text, Body.ExpressionType.Name, this));
ReturnType.ILName = ReturnType != null ? scope.GetILTypeName(ReturnType.Text) : "voidScope0";
Identifier.ILName = string.Format("{0}Scope{1}", Identifier, scope.CurrentScope);
}
public override void CheckSemantics(Scope scope, List<SemanticError> errors)
{
CheckIdentifier(scope, errors);
Identifier.ILName = string.Format("{0}Scope{1}", Identifier.Text, scope.CurrentScope);
Alias.ILName = scope.GetILTypeName(Alias.Text);
}
public override void CheckSemantics(Scope scope, List<SemanticError> errors)
{
Value.CheckSemantics(scope, errors);
if (scope.ContainsVarInstance(Identifier.Text, true) || scope.ContainsRoutine(Identifier.Text, true))
errors.Add(SemanticError.DefinedVariable(Identifier.Text, this));
if (Scope.standard_functions.Contains(Identifier.Text))
errors.Add(SemanticError.HidingAnStandardFunc("Function", Identifier.Text, this));
if (VariableType != null)
{
if (!scope.ContainsType(this.VariableType.Text))
{
errors.Add(SemanticError.TypeNotDefined(this.VariableType.Text, this));
return;
}
//check if the value of the variable has the same type that the defined
else if (Value.ExpressionType.Type == TypesEnumeration.Nil)
{
if (!scope.GetType(VariableType.Text).Nilable)
errors.Add(SemanticError.InvalidNilAssignation(VariableType.Text, this));
}
else if (scope.GetType(this.Value.ExpressionType.Name).Name != scope.GetType(this.VariableType.Text).Name)
errors.Add(SemanticError.WrongType(this.VariableType.Text, this.Value.ExpressionType.Name, this));
}
else
{
switch (Value.ExpressionType.Type)
{
case TypesEnumeration.Nil:
errors.Add(SemanticError.InvalidNilAssignation(Identifier.Text, this));
return;
case TypesEnumeration.Void:
errors.Add(SemanticError.NonValuedAssignation(this));
return;
}
}
Identifier.ExpressionType = VariableType != null ? scope.GetType(VariableType.Text) : Value.ExpressionType;
Identifier.ILName = string.Format("{0}Scope{1}", Identifier.Text, scope.CurrentScope);
Value.ExpressionType.ILName = scope.GetILTypeName(Value.ExpressionType.Name);
}
public override void CheckSemantics(Scope scope, List<SemanticError> errors)
{
this.Length.CheckSemantics(scope, errors);
this.DefaultValue.CheckSemantics(scope, errors);
//check if the array identifier is defined
var typeInfo = scope.GetType(this.ArrayIdentifier.Text);
if (typeInfo == null)
{
errors.Add(SemanticError.TypeNotDefined(this.ArrayIdentifier.Text, this));
return;
}
/*if (scope.GetType(typeInfo.Name).Name != scope.GetType(ArrayIdentifier.Text).Name)
{
errors.Add(SemanticError.WrongType(ExpressionType.Name, typeInfo.Name, this));
return;
}*/
if (typeInfo.Type != TypesEnumeration.Array)
{
errors.Add(SemanticError.WrongType("Array", typeInfo.Name, this));
return;
}
var arrayInfo = (ArrayInfo) typeInfo;
//check if lenght is int
if (this.Length.ExpressionType.Type != TypesEnumeration.Integer)
errors.Add(SemanticError.InvalidNumber("The length", this));
//default value must be the same type of the defined
if (DefaultValue.ExpressionType.Type == TypesEnumeration.Nil)
{
if (!scope.GetType(arrayInfo.ItemsType).Nilable)
errors.Add(SemanticError.InvalidNilAssignation(arrayInfo.ItemsType, this));
}
else if (arrayInfo.ItemsType != scope.GetType(DefaultValue.ExpressionType.Name).Name)
errors.Add(SemanticError.WrongType(arrayInfo.ItemsType, this.DefaultValue.ExpressionType.Name, this));
this.ExpressionType = scope.GetType(ArrayIdentifier.Text);
ArrayIdentifier.ILName = string.Format("{0}Scope{1}", ArrayIdentifier, scope.CurrentScope);
DefaultValue.ILName = scope.GetILTypeName(arrayInfo.ItemsType);
}