Пример #1
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            TargetType.CheckSemantics(astHelper);
            Expression.CheckSemantics(astHelper);
        }
        /// <summary>
        ///   Add the current function to the scope
        /// </summary>
        /// <param name = "astHelper"></param>
        public void AddToScope(AstHelper astHelper)
        {
            Name.CheckSemantics(astHelper);
            ReturnTypeName.CheckSemantics(astHelper);

            astHelper.Errors.Check(new SomeParametersWithTheSameNameError(Parameters, Start));

            foreach (FunctionParameterExpression functionParameterExpression in Parameters)
                functionParameterExpression.CheckSemantics(astHelper);

            Type[] argTypes = Parameters.Select(param => param.Type).ToArray();
            Type delegateType = ReturnTypeName.HasType
                                    ? MAst.GetFuncType(new List<Type>(argTypes) {Type}.ToArray())
                                    : MAst.GetActionType(argTypes);

            Pointer = MAst.Parameter(delegateType);

            bool error = false;

            error |= astHelper.Errors.Check(new MemberWithSameSignatureAlreadyDefinedError(
                                                Name.Name, argTypes, astHelper, Name.Start));
            error |= astHelper.Errors.Check(new VariableAlreadyDefinedError(Name.Name, astHelper, Start));

            if (!error)
                astHelper.Functions.Add(Name.Name, new FunctionReference(Pointer, Type, argTypes));
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            TypeName.CheckSemantics(astHelper);
            Name.CheckSemantics(astHelper);

            _parameter = MAst.Parameter(Type);
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            VariableName.CheckSemantics(astHelper);
            VariableTypeName.CheckSemantics(astHelper);

            AstHelper childScope = VariableTypeName.HasType
                                       ? astHelper.CreateChild(expecting: true,
                                                               expectedType: VariableTypeName.ReferencedType)
                                       : astHelper.CreateChild(expecting: true);

            Value.CheckSemantics(childScope);

            bool cantInferType = astHelper.Errors.Check(new CanNotInferTypeError(Type, Value.Type, Start));
            astHelper.Errors.Check(new NotAssignableError(Type, Value.Type, Start));
            bool memberDeclared = astHelper.Errors.Check(
                new MemberWithSameNameAlreadyDefinedError(VariableName.Name, astHelper, Start));

            if (!memberDeclared)
            {
                if (!cantInferType)
                {
                    Pointer = MAst.Parameter(Type, VariableName.Name);
                }
                else
                {
                    // if the type can't be inferred then register the variable with null type
                    Pointer = MAst.Parameter(typeof (Null), VariableName.Name);
                }

                astHelper.Variables.Add(VariableName.Name, Pointer);
            }
        }
        public static MAst Compile(AstHelper runtime, ICharStream stream)
        {
            var lexer = new TigerLexer(stream);
            var tokens = new CommonTokenStream(lexer);
            var parser = new TigerParser(tokens);
            ProgramExpression programExpression = parser.parse();

            if (parser.NumberOfSyntaxErrors > 0)
            {
                IEnumerable<string> errors = from e in parser.Errors
                                             select e.ToString();

                throw new SyntaxException(errors);
            }

            AstHelper helper = runtime.CreateChild(function: true, variables: true, types: true);
            programExpression.CheckSemantics(helper);

            if (helper.Errors.HasErrors)
            {
                throw new SemanticException(helper.Errors);
            }

            return programExpression.Transform();
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            FunctionName.CheckSemantics(astHelper);

            // initialize the scopes for each one of the arguments
            var scopes = new AstHelper[Args.Count()];
            for (int i = 0; i < scopes.Length; scopes[i++] = astHelper.CreateChild(expecting: true))
            {
            }

            foreach (var item in Args.Zip(scopes, (arg, scope) => new {arg, scope}))
                item.arg.CheckSemantics(item.scope);

            Type[] argTypes = (from arg in Args select arg.Type).ToArray();

            if (astHelper.Errors.Check(new FunctionNotDefinedError(FunctionName.Name, argTypes, astHelper.Functions,
                                                                   Start))) return;

            _pointer = astHelper.Functions[FunctionName.Name, argTypes];

            // SPEC: The following are legal: function f(p:rec) = f(nil)
            // for that reason the expected type for each one of the arguments is the
            // type of the function argument (in the definition)
            foreach (var item in _pointer.ArgTypes.Zip(scopes, (type, scope) => new {type, scope}))
                item.scope.Expecting.Type = item.type;
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            foreach (Expression arg in Args)
                arg.CheckSemantics(astHelper);
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            Test.CheckSemantics(astHelper);
            Then.CheckSemantics(astHelper);

            astHelper.Errors.Check(new IfThenBodyReturnsValueError(Then.Type, Then.Start));
        }
Пример #9
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            // the identifier shouldn't be a keyword
            astHelper.Errors.Check(new IdentifierExpectedError(Name, Start));
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            if (_checkSemanticsCalled) return;
            _checkSemanticsCalled = true;

            base.CheckSemantics(astHelper);
            Expression.CheckSemantics(astHelper);
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            Target.CheckSemantics(astHelper);

            foreach (Expression index in Indexes)
                index.CheckSemantics(astHelper);
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            AstHelper helper = astHelper.CreateChild(expecting: true, expectedType: typeof (bool));
            _innerExpression.CheckSemantics(helper);

            // only void expressions can't be converted to bool
            astHelper.Errors.Check(new NotBoolConvertibleError(_innerExpression.Type, Start));
        }
Пример #13
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            Value.CheckSemantics(astHelper);

            // todo checkSemantics for the return expression class, similar to the continue/break with the assignments

            _returnLabel = astHelper.ReturnScope.ReturnLabel;
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            // if the type is not defined or is already a direct reference to it
            if (!HasType || ReferencedType != typeof (void)) return;

            if (!astHelper.Errors.Check(new MissingTypeError(TypeName, astHelper.Types, Start)))
                ReferencedType = astHelper.Types[TypeName];
        }
        public void AddToScope(AstHelper astHelper)
        {
            string typeName = astHelper.Types.Contains(Name.Name) ? Name.Name + TypeUniqueId++ : Name.Name;
            astHelper.Errors.Check(new TypeWithSameNameAlreadyDefinedError(Name.Name, astHelper.Types, Start));

            _builder = astHelper.ModuleBuilder.DefineType(typeName, TypeAttributes.NotPublic);

            // the type is added to the scope with it's name
            astHelper.Types.Add(Name.Name, _builder);
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);
            FieldName.CheckSemantics(astHelper);

            var error = new FieldNotFoundError(Target.Type, FieldName.Name, Start);
            _type = !astHelper.Errors.Check(error)
                        ? error.PropertyType
                        : typeof (Null);
        }
Пример #17
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            foreach (var item in Args.Zip(Constructor.GetParameters().Select(parameter => parameter.ParameterType), (arg, type) => new {arg, type}))
            {
                AstHelper helper = astHelper.CreateChild(expecting: true, expectedType: item.type);
                item.arg.CheckSemantics(helper);
            }
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);
            MethodName.CheckSemantics(astHelper);
            foreach (Expression expression in Args) expression.CheckSemantics(astHelper);

            Type[] argTypes = (from arg in Args select arg.Type).ToArray();

            if (!astHelper.Errors.Check(new MethodNotFoundError(Target.Type, MethodName.Name, argTypes, Start)))
                _methodInfo = Target.Type.GetMethod(MethodName.Name, argTypes);
        }
Пример #19
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            //Debug.Assert(!astHelper.Expecting.IsExpectingType,"A break is not allowed when we are expecting a type");
            astHelper.Errors.Check(new ExpectingTypeError(Start, astHelper.Expecting));
            if (! astHelper.Errors.Check(new BreakOutOfLoopScopeError(Start, astHelper.LoopScope)))
            {
                _target = astHelper.LoopScope.BreakLabel;
            }
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            Left.CheckSemantics(astHelper);
            Right.CheckSemantics(astHelper);

            // SPEC: Nil must be used in a context were its actual record type can be determined
            // SPEC: Thus the following are ilegal: var a := nil, if nil = nil then ...
            astHelper.Errors.Check(new CanNotInferTypeError(Left.Type, Right.Type, Start));
        }
Пример #21
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            Left.CheckSemantics(astHelper);

            AstHelper helper = astHelper.CreateChild(expecting: true, expectedType: Left.Type);

            Right.CheckSemantics(helper);

            astHelper.Errors.Check(new NotAssignableError(Left.Type, Right.Type, Start));
        }
Пример #22
0
        /// <summary>
        /// Comverts the expression into the corresponding 
        /// <see cref="System.Linq.Expressions.Expression"/>
        /// </summary>
        /// <param name="runtime"></param>
        /// <returns></returns>
        /// <exception cref="SemanticException">if there is some semantic error in the tree</exception>
        public MAst Compile(AstHelper runtime)
        {
            AstHelper helper = runtime.CreateChild(function: true, variables: true, types: true);
            CheckSemantics(helper);

            if (helper.Errors.HasErrors)
            {
                throw new SemanticException(helper.Errors);
            }

            return Transform();
        }
        public void calls_function_in_runtime()
        {
            string program = "Calc()";

            TigerParser parser = Mother.CreateParser(program);
            var runtime = new AstHelper(null);
            Expression<Func<int>> calc = () => 1;
            runtime.Functions.Add("Calc", new FunctionReference(calc, typeof (int)));
            Expression result = parser.parse().Compile(runtime);

            Mother.Test(result, 1);
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            foreach (RecordFieldNode fieldNode in Fields)
            {
                fieldNode.CheckSemantics(astHelper);

                if (fieldNode.TypeName.HasType)
                    _builder.DefineField(fieldNode.FieldName.Name, fieldNode.TypeName.ReferencedType,
                                         FieldAttributes.Public);
            }

            astHelper.Types.CreateType(Name.Name);
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            ArrayTypeName.CheckSemantics(astHelper);
            // type must be an array: type XX = array of ...
            astHelper.Errors.Check(new NotAnArrayTypeError(Type, Start));

            OriginalType = Type.GetElementType();

            Lenght.CheckSemantics(astHelper);

            astHelper.Errors.Check(new TypeMismatchedError(Lenght.Type, typeof (int), Start));
        }
 protected internal override void CheckSemantics(AstHelper astHelper)
 {
     if (!astHelper.Errors.Check(new IdentifierNotDefinedError(VariableName, astHelper.Variables, Start)))
     {
         _pointer = astHelper.Variables[VariableName];
         _type = _pointer.Type;
     }
     else
     {
         // if the variable isn't defined, apply the null type that can be assigned
         // to all the record types
         _type = astHelper.Expecting.IsExpectingType ? astHelper.Expecting.Type : typeof (Null);
     }
 }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            VariableName.CheckSemantics(astHelper);
            VariableTypeName.CheckSemantics(astHelper);

            bool memberDeclared = astHelper.Errors.Check(new MemberWithSameNameAlreadyDefinedError(VariableName.Name, astHelper, Start));

            if (!memberDeclared)
            {
                Pointer = System.Linq.Expressions.Expression.Parameter(Type, VariableName.Name);

                astHelper.Variables.Add(VariableName.Name, Pointer);
            }
        }
Пример #28
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            _breakLabel = MAst.Label();
            _continueLabel = MAst.Label();

            Test.CheckSemantics(astHelper);

            AstHelper child = astHelper.CreateChild(loop: true, breakLabel: _breakLabel, continueLabel: _continueLabel);
            Body.CheckSemantics(child);

            astHelper.Errors.Check(new WhileBodyReturnsValueError(Body.Type, Start));
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            // SPEC: The comparison operators do not associate, e.g., a=b=c is erroneous, but a=(b=c) is legal.
            if (!Operator.IsComparison()) throw new InvalidOperationException();

            AstHelper helper = astHelper.CreateChild(expecting: true);

            Left.CheckSemantics(helper);
            Right.CheckSemantics(helper);

            // SPEC: Nil must be used in a context were its actual record type can be determined
            // SPEC: Thus the following are ilegal: var a := nil, if nil = nil then ...
            astHelper.Errors.Check(new CanNotInferTypeError(Left.Type, Right.Type, Start));

            astHelper.Errors.Check(new OperatorNotDefinedError(Left.Type, Right.Type, Operator, Start));
        }
Пример #30
0
        public static AstHelper Default(ModuleBuilder moduleBuilder)
        {
            var result = new AstHelper(moduleBuilder);

            result.Types.Add("int", typeof (int));
            result.Types.Add("string", typeof (string));
            result.Types.Add("bool", typeof (bool));

            Expression<Func<int, string>> str = a => a.ToString(CultureInfo.InvariantCulture);
            result.Functions.Add("str", new FunctionReference(str, typeof (string), typeof (int)));

            // function ord(s : string) : int
            // Return the ASCII value of the first character of s, or €1 if s is empty.
            Expression<Func<string, int>> ord = a => string.IsNullOrEmpty(a) ? -1 : (int) a[0];
            result.Functions.Add("ord", new FunctionReference(ord, typeof (int), typeof (string)));

            // function chr(i : int) : string
            // Return a single-character string for ASCII value i. Terminate program if i is out of range.
            // todo when chr is called terminate the program if i is out of range
            Expression<Func<int, string>> chr = a => ((char) a).ToString();
            result.Functions.Add("chr", new FunctionReference(chr, typeof (string), typeof (int)));

            // function size(s : string) : int
            // Return the number of characters in s.
            Expression<Func<string, int>> size = a => a.Length;
            result.Functions.Add("size", new FunctionReference(size, typeof (int), typeof (string)));

            // function substring(s:string,f:int,n:int):string
            // Return the substring of s starting at the character f (first character is numbered zero) and going for n characters.
            Expression<Func<string, int, int, string>> substring = (s, f, n) => s.Substring(f, n);
            result.Functions.Add("substring",
                                 new FunctionReference(substring, typeof (int), typeof (string), typeof (int),
                                                       typeof (int)));

            // function concat (s1:string, s2:string):string
            // Return a new string consisting of s1 followed by s2.
            Expression<Func<string, string, string>> concat = (s1, s2) => s1 + s2;
            result.Functions.Add("concat", new FunctionReference(concat, typeof (string), typeof (string), typeof (string)));

            // function not(i : int) : int
            // Return 1 if i is zero, 0 otherwise.
            Expression<Func<int, int>> not = i => i == 0 ? 1 : 0;
            result.Functions.Add("not", new FunctionReference(not, typeof (int), typeof (int)));

            return result;
        }
Пример #31
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            // SPEC: The comparison operators do not associate, e.g., a=b=c is erroneous, but a=(b=c) is legal.
            if (!Operator.IsComparison())
            {
                throw new InvalidOperationException();
            }

            AstHelper helper = astHelper.CreateChild(expecting: true);

            Left.CheckSemantics(helper);
            Right.CheckSemantics(helper);

            // SPEC: Nil must be used in a context were its actual record type can be determined
            // SPEC: Thus the following are ilegal: var a := nil, if nil = nil then ...
            astHelper.Errors.Check(new CanNotInferTypeError(Left.Type, Right.Type, Start));

            astHelper.Errors.Check(new OperatorNotDefinedError(Left.Type, Right.Type, Operator, Start));
        }
Пример #32
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            AstHelper helper = astHelper.CreateChild(function: true, variables: true, types: true);

            // add all type builders to the scope in case of recursive type calls
            foreach (IAddToScope typeDeclarationNode in TypeDeclarations.OfType <IAddToScope>())
            {
                typeDeclarationNode.AddToScope(helper);
            }

            var error = new CircularTypeReferencesError(TypeDeclarations, Start);

            astHelper.Errors.Check(error);
            // define other types
            foreach (TypeDeclarationNode typeDeclarationNode in error.OrderedTypes)
            {
                typeDeclarationNode.CheckSemantics(helper);
            }

            // add all functions to the scope in case of recursive calls
            foreach (FunctionDefinitionExpression functionDefinitionExpression in FunctionDefinitions)
            {
                functionDefinitionExpression.AddToScope(helper);
            }

            foreach (VariableDeclarationBase variableDeclarationExpression in VariableDeclarations)
            {
                variableDeclarationExpression.CheckSemantics(helper);
            }

            foreach (FunctionDefinitionExpression functionDefinitionExpression in FunctionDefinitions)
            {
                functionDefinitionExpression.CheckSemantics(helper);
            }

            Body.CheckSemantics(helper);

            IEnumerable <ParameterExpression> variables = from variable in VariableDeclarations select variable.Pointer;
            IEnumerable <ParameterExpression> functions = from function in FunctionDefinitions select function.Pointer;

            // calculate the closure that will be used when we're generating the expression
            _closure = variables.Union(functions);
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            TypeName.CheckSemantics(astHelper);

            string result = "#result";

            _inner = new LetInExpression
            {
                VariableDeclarations = new List <VariableDeclarationBase>
                {
                    new VariableDeclarationExpression
                    {
                        VariableName = new MemberIdentifierNode {
                            Name = result
                        },
                        Value = new NewExpression(TypeName.ReferencedType)
                    }
                },
                Body = new ListSemiExpression(from field in Fields
                                              select new AssignExpression
                {
                    Left = new FieldAccessExpression
                    {
                        FieldName = field.FieldName,
                        Target    = new VariableAccessExpression
                        {
                            VariableName = result
                        }
                    },
                    Right = field.Value,
                    Start = field.Start
                })
                {
                    new VariableAccessExpression
                    {
                        VariableName = result
                    }
                }
            };

            _inner.CheckSemantics(astHelper);
        }
Пример #34
0
        /// <summary>
        ///   returns the expression that this program represents.
        /// </summary>
        /// <returns></returns>
        public MAst Compile()
        {
            var assemblyName = new AssemblyName(Guid.NewGuid().ToString())
            {
                Version = new Version(1, 0)
            };
            AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName,
                                                                                            AssemblyBuilderAccess.Run);
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("Program");

            var ast = new AstHelper(moduleBuilder);

            ast.Types.Add("int", typeof(int));
            ast.Types.Add("string", typeof(string));
            ast.Types.Add("bool", typeof(bool));

            Program.CheckSemantics(ast);

            return(Transform());
        }
Пример #35
0
        public AstHelper CreateChild(bool function  = false, bool variables          = false, bool types = false,
                                     bool expecting = false, Type expectedType       = null,
                                     bool loop      = false, LabelTarget breakLabel  = null, LabelTarget continueLabel = null,
                                     bool returning = false, LabelTarget returnLabel = null)
        {
            var result = new AstHelper
            {
                ModuleBuilder = ModuleBuilder,
                Errors        = Errors,
                Expecting     = expecting
                                    ? expectedType != null ? new Expecting(expectedType) : new Expecting()
                                    : Expecting,
                Functions = function ? (FunctionScope)Functions.GetChild() : Functions,
                Variables = variables
                                    ? (VariableScope)Variables.GetChild()
                                    : Variables,
                Types       = types ? (TypeScope)Types.GetChild() : Types,
                LoopScope   = loop ? new LoopScope(breakLabel, continueLabel) : LoopScope,
                ReturnScope = returning ? new ReturnScope(returnLabel) : ReturnScope
            };

            return(result);
        }
Пример #36
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            astHelper.Errors.Check(new TypeWithSameNameAlreadyDefinedError(Name, astHelper.Types, Start));
        }
Пример #37
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            var from = From.ProtectSemantics();
            var to   = To.ProtectSemantics();

            from.CheckSemantics(astHelper);
            to.CheckSemantics(astHelper);

            bool error = false;

            error |= astHelper.Errors.Check(new NotAssignableError(typeof(int), from.Type, VariableName.Start));
            error |= astHelper.Errors.Check(new NotAssignableError(typeof(int), to.Type, VariableName.Start));

            if (error)
            {
                return;
            }

            _implementation = new LetInExpression
            {
                VariableDeclarations = new List <VariableDeclarationBase>
                {
                    new VariableDeclarationExpression
                    {
                        VariableName =
                            new MemberIdentifierNode
                        {
                            Name = VariableName.Name
                        },
                        Value = from
                    }
                },
                Body = new ListSemiExpression
                {
                    new WhileExpression
                    {
                        Test = new LogicalBinaryOperationExpression
                        {
                            Left = new VariableAccessExpression
                            {
                                VariableName =
                                    VariableName.Name
                            },
                            Right    = to,
                            Operator = TigerOperator.LessThanOrEqual
                        },
                        Body = new ListSemiExpression
                        {
                            Body,
                            new UnaryOperationExpression
                            {
                                Expression =
                                    new VariableAccessExpression
                                {
                                    VariableName =
                                        VariableName.Name
                                },
                                Operator =
                                    TigerOperator.PreIncrementAssign
                            },
                            new EmptyExpression()
                        }
                    }
                }
            };

            _implementation.CheckSemantics(astHelper);
        }
Пример #38
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);
            var collectionWrapper = Collection.ProtectSemantics();

            collectionWrapper.CheckSemantics(astHelper);

            if (!astHelper.Errors.Check(new NotEnumerableError(collectionWrapper.Type, Collection.Start)))
            {
                Type collectionType = TypeUtils.GetCollectionType(collectionWrapper.Type);

                string enumerator = "#enumerator" + _uniqueId++;
                _implementation = new LetInExpression
                {
                    VariableDeclarations = new List <VariableDeclarationBase>
                    {
                        new VariableDeclarationExpression
                        {
                            VariableName = new MemberIdentifierNode
                            {
                                Name = enumerator
                            },
                            Value = new MethodCallExpression
                            {
                                MethodName = new IdentifierNode
                                {
                                    Name = "GetEnumerator"
                                },
                                Target = collectionWrapper
                            }
                        },
                        new VariableDeclarationBase
                        {
                            VariableName = new MemberIdentifierNode
                            {
                                Name = Identifier.Name
                            },
                            VariableTypeName = new TypeReferenceNode(collectionType)
                        }
                    },
                    Body = new ListSemiExpression
                    {
                        new WhileExpression
                        {
                            Test = new MethodCallExpression
                            {
                                Target = new VariableAccessExpression
                                {
                                    VariableName = enumerator
                                },
                                MethodName = new IdentifierNode
                                {
                                    Name = "MoveNext"
                                }
                            },
                            Body = new ListSemiExpression
                            {
                                new AssignExpression
                                {
                                    Left = new VariableAccessExpression
                                    {
                                        VariableName = Identifier.Name
                                    },
                                    Right = new TypeCastExpression
                                    {
                                        Expression = new FieldAccessExpression
                                        {
                                            Target = new VariableAccessExpression
                                            {
                                                VariableName = enumerator
                                            },
                                            FieldName = new IdentifierNode
                                            {
                                                Name = "Current"
                                            }
                                        },
                                        TargetType = collectionType
                                    }
                                },
                                Body
                            }
                        }
                    }
                };
                _implementation.CheckSemantics(astHelper);
            }
        }
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            Expression.CheckSemantics(astHelper);
        }
Пример #40
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            base.CheckSemantics(astHelper);

            _expecting = astHelper.Expecting;
        }
Пример #41
0
        public static MAst Compile(AstHelper runtime, string program)
        {
            var stream = new ANTLRStringStream(program);

            return(Compile(runtime, stream));
        }
Пример #42
0
        public static MAst CompileFile(AstHelper runtime, string fileName)
        {
            var stream = new ANTLRFileStream(fileName);

            return(Compile(runtime, stream));
        }
Пример #43
0
 protected internal override void CheckSemantics(AstHelper astHelper)
 {
     Program.CheckSemantics(astHelper);
 }
Пример #44
0
        public MAst Compile(AstHelper runtime)
        {
            Program.CheckSemantics(runtime);

            return(Transform());
        }
Пример #45
0
        protected internal override void CheckSemantics(AstHelper astHelper)
        {
            string lenght     = "#length" + uniqueId++;
            string result     = "#result" + uniqueId++;
            string forVarName = "#i" + uniqueId++;

            var valueEnclosed = InitialValue.ProtectSemantics();

            _implementation = new LetInExpression
            {
                VariableDeclarations = new List <VariableDeclarationBase>
                {
                    new VariableDeclarationExpression
                    {
                        VariableName =
                            new MemberIdentifierNode
                        {
                            Name = lenght
                        },
                        Value = Lenght
                    },
                    new VariableDeclarationExpression
                    {
                        VariableName =
                            new MemberIdentifierNode
                        {
                            Name = result
                        },
                        Value = new ArrayInitializationExpression
                        {
                            ArrayTypeName =
                                ArrayTypeName,
                            Lenght =
                                new VariableAccessExpression
                            {
                                VariableName =
                                    lenght
                            }
                        }
                    }
                },
                Body = new ListSemiExpression
                {
                    new ForLoopExpression
                    {
                        VariableName = new IdentifierNode {
                            Name = forVarName
                        },
                        From = new IntLiteralExpression(0),
                        To   = new BinaryOperationExpression
                        {
                            Operator = TigerOperator.Subtract,
                            Left     = new VariableAccessExpression
                            {
                                VariableName = lenght
                            },
                            Right = new IntLiteralExpression(1)
                        },
                        Body = new AssignExpression
                        {
                            Left = new ArrayIndexExpression
                            {
                                Indexes = new[]
                                {
                                    new VariableAccessExpression
                                    {
                                        VariableName
                                            =
                                                forVarName
                                    }
                                },
                                Target =
                                    new VariableAccessExpression
                                {
                                    VariableName =
                                        result
                                }
                            },
                            Right = valueEnclosed
                        }
                    },
                    new VariableAccessExpression {
                        VariableName = result
                    }
                }
            };

            _implementation.CheckSemantics(astHelper);
        }
Пример #46
0
 /// <summary>
 ///   this method is executed before the generation, should
 ///   resolve all variable references and populate the scopes.
 ///   If some error is found the error should be added to the
 ///   collection.
 /// </summary>
 /// <param name = "astHelper"></param>
 protected internal virtual void CheckSemantics(AstHelper astHelper)
 {
     // todo refactor the ModuleBuilder and the ErrorSet as parameters of CheckSemantic
 }