예제 #1
0
        public ROUTINE(int ps, bool o, string name) : base(name)
        {
            PureSafe   = ps;
            isOverride = o;

            this.name         = new IDENTIFIER(name);
            genericParameters = new List <FORMAL_GENERIC>();
            parameters        = new List <ENTITY>();
            preconditions     = new List <EXPRESSION>();
            postconditions    = new List <EXPRESSION>();
            requireElse       = false;
            ensureThen        = false;
            routineBody       = new BODY();
        }
예제 #2
0
파일: Try.cs 프로젝트: Tubbz-alt/SLang-6
        /// <summary>
        ///
        /// </summary>
        /// <syntax>
        /// Try : try
        ///          StatementList
        ///       catch ( [ Identifier : ] UnitType )
        ///          [ StatementList ]
        ///     { catch ( [ Identifier : ] UnitType )
        ///          [ StatementList ]
        ///     }
        ///     [ else [ StatementsList ] ]
        ///       end
        /// </syntax>
        /// <returns></returns>
        public static void parse(iSCOPE context)
        {
            Token token = get();
            Token begin = token;

            if (token.code != TokenCode.Try)   // Compiler error
            {
            }
            forget();

            TRY result = new TRY();

            Context.enter(result);

            BODY.parse(TokenCode.Catch, TokenCode.ERROR, TokenCode.ERROR, result);

            while (true)
            {
                token = get();
                if (token.code != TokenCode.Catch)
                {
                    break;
                }
                CATCH.parse(result);
            }
            token = get();
            if (token.code == TokenCode.Else)
            {
                forget();
                BODY.parse(TokenCode.End, TokenCode.ERROR, TokenCode.ERROR, context);
            }
            token = get();
            if (token.code != TokenCode.End)   // Syntax error
            {
            }
            forget();

            result.setSpan(begin, token);
            context.add(result);
            Context.exit();
        }
예제 #3
0
파일: Loop.cs 프로젝트: Tubbz-alt/SLang-6
 public LOOP() : base()
 {
     invariants = new List <EXPRESSION>();
     body       = new BODY();
     variants   = new List <EXPRESSION>();
 }
예제 #4
0
파일: Loop.cs 프로젝트: Tubbz-alt/SLang-6
        /// <summary>
        ///
        /// </summary>
        /// <syntax>
        /// Loop    : while BooleanExpression
        ///           loop
        ///           [ invariant PredicateList ]
        ///           [ StatementList ]
        ///           [ variant PredicateList ]
        ///           end [ loop ]
        ///
        ///         | loop
        ///           [ invariant PredicateList ]
        ///           [ StatementList ]
        ///           [ variant PredicateList ]
        ///           [ while BooleanExpression ]
        ///           end [ loop ]
        /// </syntax>
        /// <returns></returns>
        public static void parse(Token id, iSCOPE context)
        {
            Debug.Indent();
            Debug.WriteLine("Entering LOOP.parse");

            // If id != null, then 'id' is a loop label.
            // ':' after label is already parsed.
            LOOP loop = new LOOP();

            Context.enter(loop);

            Token token = get();
            Token begin = token;

            if (token.code == TokenCode.While)
            {
                forget();
                loop.prefix = true;
                EXPRESSION whileExpr = EXPRESSION.parse(null, context);
                token = get();
                if (token.code == TokenCode.Loop)
                {
                    forget();
                    loop.addw(whileExpr);
                    whileExpr.parent = loop;
                }
                else // Syntax error
                {
                    error(token, "no-loop");
                }

                token = get();
                if (token.code == TokenCode.Invariant)
                {
                    forget();
                    parseInvariant(loop);
                }

                BODY body = new BODY();
                body.parent = loop;
                loop.body   = body;

                Context.enter(body);
                token = get();
                BODY.parse(TokenCode.End, TokenCode.Variant, TokenCode.ERROR, body);
                body.setSpan(token, get());
                Context.exit();

                token = get();
                if (token.code == TokenCode.Variant)
                {
                    forget();
                    parseVariant(loop);
                }
            }
            else if (token.code == TokenCode.Loop)
            {
                loop.prefix = false;
                forget();
                token = get();
                if (token.code == TokenCode.Invariant)
                {
                    forget();
                    parseInvariant(loop);
                }

                BODY body = new BODY();
                body.parent = loop;
                loop.body   = body;

                Context.enter(body);
                token = get();
                BODY.parse(TokenCode.End, TokenCode.Variant, TokenCode.While, body);
                body.setSpan(token, get());
                Context.exit();

                token = get();
                if (token.code == TokenCode.Variant)
                {
                    forget();
                    parseVariant(loop);
                }
                token = get();
                if (token.code == TokenCode.While)
                {
                    forget();
                    EXPRESSION whileExpr = EXPRESSION.parse(null, context);
                    loop.addw(whileExpr);
                    whileExpr.parent = loop;
                }
            }
            else // Compiler error
            {
                error(token, "system-bug");
            }

            token = get();
            if (token.code != TokenCode.End)   // Syntax error
            {
                error(token, "no-end", "loop");
            }
            else
            {
                forget();
                token = get();
                if (token.code == TokenCode.Loop)
                {
                    forget();
                }
            }

            if (loop != null)
            {
                loop.setSpan(begin, token);
            }

            context.add(loop);
            Context.exit();

            Debug.WriteLine("Exiting LOOP.parse");
            Debug.Unindent();
        }
예제 #5
0
        public static void parse(Token routineName, bool hidden, bool final, bool isOverride, int pure_safe, iSCOPE context)
        {
            ROUTINE routine = null;

            if (routineName.code == TokenCode.Init)
            {
                Debug.Indent();
                Debug.WriteLine("Entering INITIALIZER.parse");

                routine = new INITIALIZER();
                goto Init;
            }

            Debug.Indent();
            Debug.WriteLine("Entering ROUTINE.parse (" + routineName.image + ")");

            string image = routineName.image;
            Token  token = get(); // What's after the routine name?

            switch (routineName.image)
            {
            case "and":
                if (token.code == TokenCode.Then)
                {
                    forget();
                    image += " then";
                    Span span = new Span(routineName.span, token.span);
                    routineName = new Token(span, TokenCode.Identifier, image, new Category(CategoryCode.identifier));
                }
                break;

            case "or":
                token = get();
                if (token.code == TokenCode.Else)
                {
                    forget();
                    image += " else";
                    Span span = new Span(routineName.span, token.span);
                    routineName = new Token(span, TokenCode.Identifier, image, new Category(CategoryCode.identifier));
                }
                break;
            }
            routine = new ROUTINE(pure_safe, isOverride, routineName);
Init:
            routine.setSpecs(hidden, final);
            Context.enter(routine);

            if (routineName.code == TokenCode.Init)
            {
                goto Init2;
            }

            token = get();
            if (token.code == TokenCode.Alias)
            {
                forget();
                token         = expect(TokenCode.Identifier);
                routine.alias = new IDENTIFIER(token.image);
            }

            if (token.code == TokenCode.LBracket)
            {
                // Generic routine
                forget();
                while (true)
                {
                    var generic = FORMAL_GENERIC.parse(context);
                    routine.add(generic);

                    token = get();
                    switch (token.code)
                    {
                    case TokenCode.Comma:
                    case TokenCode.Semicolon: forget(); continue;

                    case TokenCode.RBracket:  forget(); goto Finish;

                    default: { /* Syntax error */ break; }
                    }
                }
Finish:
                ;
            }

Init2:
            token = get();
            if (token.code == TokenCode.LParen)
            {
                forget(); token = get();
                if (token.code == TokenCode.RParen)
                {
                    // Empty parameter list
                    forget();
                    goto Weiter;
                }
                while (true)
                {
                    VARIABLE.parse(false, false, false, false, null, null, routine);

                    token = get();
                    if (token.code == TokenCode.Comma)
                    {
                        forget(); continue;
                    }
                    if (token.code == TokenCode.Semicolon)
                    {
                        forget(); continue;
                    }
                    break;
                }
                expect(TokenCode.RParen);
            }

Weiter:
            token = get();
            if (token.code == TokenCode.Colon)
            {
                forget();

                bool ref_val, conc;  // TEMP SOLUTION
                Span span2;
                routine.type = VARIABLE.parseTypeSpecifier(routine, out ref_val, out conc, out span2);
                if (routine.type != null)
                {
                    routine.type.parent = routine;
                    routine.type.setSpan(span2);
                }
            }

            token = get();
            if (token.code == TokenCode.Require)
            {
                forget(); token = get();
                if (token.code == TokenCode.Else)
                {
                    forget(); routine.requireElse = true;
                }
                while (true)
                {
                    EXPRESSION precondition = EXPRESSION.parse(null, routine);
                    routine.addPre(precondition);
                    precondition.parent = routine;

                    token = get();
                    if (token.code == TokenCode.Is || token.code == TokenCode.Arrow)
                    {
                        break;
                    }
                }
            }

            if (token.code == TokenCode.Arrow)
            {
                forget();

                BODY body = new BODY();
                routine.routineBody = body;
                body.parent         = routine;

                Context.enter(body);
                EXPRESSION expression = EXPRESSION.parse(null, body);
                RETURN     ret        = new RETURN(expression);
                expression.parent = ret;
                ret.setSpan(expression.span);

                ret.parent = body;
                body.add(ret);
                body.setSpan(ret.span);

                Context.exit();
            }
            else if (token.code == TokenCode.Is)
            {
                forget(); token = get();
                if (token.code == TokenCode.Abstract)
                {
                    forget();
                    routine.isAbstract = true;
                }
                else if (token.code == TokenCode.Foreign)
                {
                    forget();
                    routine.isForeign = true;
                }
                else
                {
                    BODY body = new BODY();
                    body.parent         = routine;
                    routine.routineBody = body;

                    Context.enter(body);
                    BODY.parse(TokenCode.End, TokenCode.Ensure, TokenCode.ERROR, body);
                    Context.exit();
                }
                token = get();
                if (token.code == TokenCode.Ensure)
                {
                    forget();
                    token = get();
                    if (token.code == TokenCode.Then)
                    {
                        forget(); routine.ensureThen = true;
                    }
                    ENTITY.weAreWithinEnsure = true;
                    while (true)
                    {
                        EXPRESSION postcondition = EXPRESSION.parse(null, routine);
                        routine.addPre(postcondition);
                        postcondition.parent = routine;

                        token = get();
                        if (token.code == TokenCode.End)
                        {
                            forget(); break;
                        }
                    }
                    ENTITY.weAreWithinEnsure = false;
                }
                else if (!routine.isAbstract && !routine.isForeign)
                {
                    expect(TokenCode.End);
                }
            }
            token = get();
            if (token.code == TokenCode.Semicolon)
            {
                forget();
            }

            Context.exit();
            context.add(routine);

            routine.parent = context.self;
            routine.setSpan(routineName, token);

            if (routineName.code == TokenCode.Init)
            {
                Debug.WriteLine("Exiting INITIALIZER.parse");
            }
            else
            {
                Debug.WriteLine("Exiting ROUTINE.parse");
            }
            Debug.Unindent();
        }
예제 #6
0
파일: Try.cs 프로젝트: Tubbz-alt/SLang-6
        public static void parse(iSCOPE context) // REWRITE!!
        {
            Token token = get();
            Token begin = token;

            if (token.code != TokenCode.Catch)   // Compiler error
            {
            }
            forget();

            CATCH handler = new CATCH();

            Context.enter(handler);

            token = get();
            if (token.code != TokenCode.LParen)   // Syntax error
            {
            }
            else
            {
                forget();
            }

            token = get();
            if (token.code != TokenCode.Identifier)   // Syntax error
            {
            }
            else
            {
                Token id = token;
                forget();
                token = get();
                if (token.code == TokenCode.Colon)
                {
                    forget();
                    // handler.identifier = id.image;

                    token = get();
                    if (token.code != TokenCode.Identifier)   // Syntax error
                    {
                    }
                    forget();
                    token = id;
                }
                UNIT_REF unit_ref = UNIT_REF.parse(null, false, context); // CHECK!!
                handler.unit_ref = unit_ref;
                unit_ref.parent  = handler;
            }

            token = get();
            if (token.code != TokenCode.RParen)   // Syntax error
            {
            }
            forget();

            BODY.parse(TokenCode.Catch, TokenCode.Else, TokenCode.End, handler);

            token = get(); // just to get the span...
            handler.setSpan(begin, token);

            Context.exit();
            context.add(handler);
        }
예제 #7
0
파일: Try.cs 프로젝트: Tubbz-alt/SLang-6
 public CATCH() : base()
 {
     body = new BODY();
 }
예제 #8
0
        public static void parse(TokenCode stop1, TokenCode stop2, TokenCode stop3, iSCOPE context)
        {
            Debug.Indent();
            Debug.WriteLine("Entering BODY.parse");

            Token token;
            Token start = get();

            while (true)
            {
                bool res = STATEMENT.parse(context, stop1, stop2, stop3);

                if (!res)
                {
                    // Neither a statement nor a simple declaration.
                    // Perhaps, a nested/local function?
                    token = get();
                    switch (token.code)
                    {
                    case TokenCode.Routine:
                    case TokenCode.Safe:
                    case TokenCode.Pure:
                        forget();
                        int pure_safe = 0;
                        switch (token.code)
                        {
                        case TokenCode.Pure: pure_safe = 1; break;

                        case TokenCode.Safe: pure_safe = 2; break;
                        }
                        ROUTINE.parse(null, false, false, false, pure_safe, context);
                        break;

                    case TokenCode.Unit:
                    case TokenCode.Ref:
                    case TokenCode.Val:
                        // A _local_ unit???
                        UNIT.parse(context);
                        break;

                    default:
                        // What's this?
                        break;
                    }
                }

                token = get();
                if (token.code == TokenCode.Semicolon /*|| wasEOL*/)
                {
                    forget();
                }
                if (token.code == stop1)
                {
                    break;                        // don't 'forget()'
                }
                if (stop2 != TokenCode.ERROR && token.code == stop2)
                {
                    break;                                                    // don't 'forget()'
                }
                if (stop3 != TokenCode.ERROR && token.code == stop3)
                {
                    break;                                                    // don't 'forget()'
                }
            }

            BODY body = context as BODY;

            if (body == null) /* A system error */ } {