C# Scope.GetILTypeName方法代码示例

        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);
        }