示例#1
0
        // Given a list of terms, create the variable objects to represent the parameters of the declaration
        private void CreateParameterDescriptors()
        {
            int parameterIndex = -3;
            if (HiddenArguments != null)
            {
                for (int i = HiddenArguments.Count - 1; i >= 0; --i)
                {
                    if (Type != DeclarationType.System)
                    {
                        var hiddenArgument = new Variable();
                        hiddenArgument.StorageMethod = VariableStorageMethod.Local;
                        hiddenArgument.Name = HiddenArguments[i].Item1;
                        hiddenArgument.DeclaredTypeName = HiddenArguments[i].Item2;
                        hiddenArgument.DeclaredType = DeclarationScope.FindType(hiddenArgument.DeclaredTypeName);
                        if (hiddenArgument.DeclaredType == null) throw new CompileError("Could not find type for hidden argument '"
                            + hiddenArgument.DeclaredTypeName + "'.");
                        hiddenArgument.Offset = parameterIndex;
                        DeclarationScope.Variables.Add(hiddenArgument);
                    }

                    --parameterIndex;
                }
            }

            for (int i = Terms.Count - 1; i >= 0; --i)
            {
                if (Terms[i].Type == DeclarationTermType.Term)
                {
                    var declaredType = String.IsNullOrEmpty(Terms[i].DeclaredTypeName) ?
                        EtcScriptLib.Type.Generic : DeclarationScope.FindType(Terms[i].DeclaredTypeName);
                    if (declaredType == null) throw new CompileError("Could not find type '" + Terms[i].DeclaredTypeName + "'.");
                    Terms[i].DeclaredType = declaredType;

                    if (Type != DeclarationType.System)
                    {
                        var variable = new Variable
                        {
                            Name = Terms[i].Name,
                            Offset = parameterIndex,
                            DeclaredType = declaredType
                        };
                        DeclarationScope.Variables.Add(variable);
                    }

                    --parameterIndex;
                }
            }
        }
示例#2
0
            public override Ast.Node Transform(ParseScope Scope)
            {
                List = List.Transform(Scope);
                ResultType = List.ResultType;

                //Try to find an access macro for this type.
                var getterArguments = DummyArguments(Keyword("GET"), Keyword("AT"), Term(Scope.FindType("NUMBER")),
                    Keyword("FROM"), Term(List.ResultType));
                var indexerMacro = Scope.FindAllPossibleMacroMatches(getterArguments).Where(d =>
                    ExactDummyMatch(d.Terms, getterArguments)).FirstOrDefault();
                if (indexerMacro == null)
                    throw new CompileError("No macro of the form GET AT NUMBER FROM " +
                        List.ResultType.Name + " found.", Source);

                var lengthArguments = DummyArguments(Keyword("LENGTH"), Keyword("OF"), Term(List.ResultType));
                var lengthMacro = Scope.FindAllPossibleMacroMatches(lengthArguments).Where(d =>
                    ExactDummyMatch(d.Terms, lengthArguments)).FirstOrDefault();
                if (lengthMacro == null)
                    throw new CompileError("No macro of the form LENGTH OF " + List.ResultType.Name + " found.", Source);

                var nestedScope = Scope.Push(ScopeType.Block);

                ResultVariable = nestedScope.NewLocal("__result@" + VariableName, Scope.FindType("LIST"));
                ListVariable = nestedScope.NewLocal("__list@" + VariableName, Scope.FindType("LIST"));
                TotalVariable = nestedScope.NewLocal("__total@" + VariableName, Scope.FindType("NUMBER"));
                CounterVariable = nestedScope.NewLocal("__counter@" + VariableName, Scope.FindType("NUMBER"));
                ValueVariable = nestedScope.NewLocal(VariableName, indexerMacro.ReturnType);

                Indexer = Ast.StaticInvokation.CreateCorrectInvokationNode(Source, nestedScope, indexerMacro,
                    new List<Ast.Node>(new Ast.Node[] {
                        new Ast.Identifier(new Token { Type = TokenType.Identifier, Value = "__counter@"+VariableName }),
                        new Ast.Identifier(new Token { Type = TokenType.Identifier, Value = "__list@"+VariableName })
                    })).Transform(nestedScope);

                LengthFunc = Ast.StaticInvokation.CreateCorrectInvokationNode(Source, nestedScope, lengthMacro,
                    new List<Ast.Node>(new Ast.Node[] {
                        new Ast.Identifier(new Token { Type = TokenType.Identifier, Value = "__list@"+VariableName })
                    })).Transform(nestedScope);

                Condition = Condition.Transform(nestedScope);
                if (Condition.ResultType.Name != "BOOLEAN")
                    throw new CompileError("Condition to where clause must return boolean", Source);
                return this;
            }
示例#3
0
 public Variable NewLocal(String Name, Type Type)
 {
     var r = new Variable { Name = Name.ToUpper(), Offset = VariableIndex, DeclaredType = Type };
     VariableIndex += 1;
     Variables.Add(r);
     return r;
 }
示例#4
0
文件: Parse.cs 项目: Blecki/EtcScript
        internal static Variable ParseMemberDeclaration(TokenStream Stream, ParseContext Context)
        {
            if (Stream.Next().Type != TokenType.Identifier) throw new CompileError("[032] Expected identifier", Stream.Next());
            Stream.Advance();

            var r = new Variable();
            r.StorageMethod = VariableStorageMethod.Member;

            if (Stream.Next().Type != TokenType.Identifier) throw new CompileError("[033] Expected identifier", Stream.Next());
            r.Name = Stream.Next().Value.ToUpper();

            Stream.Advance();

            if (Stream.Next().Type == TokenType.Colon)
            {
                Stream.Advance();
                if (Stream.Next().Type != TokenType.Identifier) throw new CompileError("[034] Expected identifier", Stream.Next());
                r.DeclaredTypeName = Stream.Next().Value.ToUpper();
                Stream.Advance();
            }

            if (!Stream.AtEnd() && Stream.Next().Type == TokenType.QuestionMark)
            {
                Stream.Advance();
                if (Stream.Next().Type != TokenType.String) throw new CompileError("Expected documentation", Stream);
                r.Documentation = Stream.Next().Value;
                Stream.Advance();
            }

            if (Stream.Next().Type != TokenType.Semicolon) throw new CompileError("[035] Expected ;", Stream.Next());
            Stream.Advance();
            return r;
        }
示例#5
0
文件: Parse.cs 项目: Blecki/EtcScript
        internal static Variable ParseGlobalDeclaration(TokenStream Stream, ParseContext Context)
        {
            if (Stream.Next().Type != TokenType.Identifier) throw new CompileError("[032] Expected identifier", Stream.Next());
            Stream.Advance();

            var r = new Variable();
            r.StorageMethod = VariableStorageMethod.Member;

            if (Stream.Next().Type != TokenType.Identifier) throw new CompileError("[033] Expected identifier", Stream.Next());
            var start = Stream.Next();
            r.Name = Stream.Next().Value.ToUpper();

            Stream.Advance();

            if (Stream.Next().Type == TokenType.Colon)
            {
                Stream.Advance();
                if (Stream.Next().Type != TokenType.Identifier) throw new CompileError("[034] Expected identifier", Stream.Next());
                r.DeclaredTypeName = Stream.Next().Value.ToUpper();
                Stream.Advance();
            }

            if (Stream.Next().Type == TokenType.Operator && Stream.Next().Value == "=")
            {
                Stream.Advance();
                var initialValue = ParseExpression(Stream, Context, TokenType.Semicolon);
                var initializer = new Ast.Let(start, new Ast.Identifier(start), initialValue);
                Context.Initialization.Add(initializer);
            }

            if (!Stream.AtEnd() && Stream.Next().Type == TokenType.QuestionMark)
            {
                Stream.Advance();
                if (Stream.Next().Type != TokenType.String) throw new CompileError("Expected documentation", Stream);
                r.Documentation = Stream.Next().Value;
                Stream.Advance();
            }

            if (Stream.Next().Type != TokenType.Semicolon) throw new CompileError("[035] Expected ;", Stream.Next());
            Stream.Advance();
            return r;
        }
示例#6
0
 public override Ast.Node Transform(ParseScope Scope)
 {
     ResultType = Type.Void;
     Max = Max.Transform(Scope);
     var nestedScope = Scope.Push(ScopeType.Block);
     TotalVariable = nestedScope.NewLocal("__total@" + VariableName, Scope.FindType("NUMBER"));
     Min = Min.Transform(nestedScope);
     CounterVariable = nestedScope.NewLocal("__counter@" + VariableName, Scope.FindType("NUMBER"));
     ValueVariable = nestedScope.NewLocal(VariableName, Scope.FindType("NUMBER"));
     Body = Body.Transform(nestedScope);
     return this;
 }