def parse(tokens):
        from ast.vartypes import Type
        from ast.expression import Expression

        if tokens.peek() != "array":
            return None

        position = tokens.peek().position
        tokens.expect("array")
        tokens.expect("(")

        arrayType = Type.parse(tokens)
        if arrayType is None:
            raise error.SyntaxError(position, 'Expected type after "(", got %r' % tokens.peek())

        tokens.expect(",")

        size = []

        while True:
            s = Expression.parse(tokens)
            if s is None:
                raise error.SyntaxError(position, "Expected expression for array size, got %r" % tokens.peek())

            size.append(s)

            if tokens.peek() == ",":
                tokens.expect(",")
            else:
                break
        tokens.expect(")")

        return NewArrayExpression(position, arrayType, size)
    def parseCast(tokens):
        from ast.vartypes import Type

        tokens.expect('as')

        type = Type.parse(tokens)
        if type is None:
            raise error.SyntaxError, "Expected type name after 'as', got %r" % tokens.peek()

        return type
Beispiel #3
0
    def parse(tokens):
        flags = memberflags.MemberFlags()
        position = tokens.peek().position

        oldPosition = tokens.getPosition()

        while True:
            tok = tokens.getNext()
            if tok == 'abstract':
                flags.abstract = True
            elif tok == 'sealed':
                flags.sealed = True
            else:
                tokens.unget()
                break

        if tokens.peek() != 'class':
            tokens.setPosition(oldPosition)
            return None
        tokens.expect('class')

        name = tokens.getNext()
        if name.type != 'identifier':
            tokens.unget()
            raise error.SyntaxError(position, 'Expected class name, got %r' % name)

        bases = []

        if tokens.peek() == '(':
            tokens.expect('(')
            # parse base classes
            while tokens.peek() != ')':
                base = Type.parse(tokens)
                if base is None:
                    raise error.SyntaxError(tokens.peek().position, 'Expected type, got %r' % tokens.peek())

                bases.append(base)

                if tokens.peek() == ',':
                    tokens.expect(',')
                else:
                    tokens.expect(')')
                    break

        assert tokens.peek() != '(', 'Internal error at %r: Inheritance is NYI' % tokens.peek()

        tokens.expect(':')
        tokens.expect(token.END_OF_STATEMENT)

        body = ClassBody.parse(tokens)
        if body is None:
            raise error.SyntaxError, 'Expected class body, got %r' % tokens.peek()

        return ClassDecl(position, name.value, bases, body, flags)
Beispiel #4
0
    def parse(tokens):
        from ast.vartypes import Type

        tok = tokens.getNext()

        if tok.type != 'identifier':
            tokens.unget()
            return None

        position = tok.position
        name = tok.value
        type = None

        if tokens.peek() == 'as':
            tokens.expect('as')
            type = Type.parse(tokens)

            if type is None:
                raise error.SyntaxError(position, 'Expected type after "as", got %r' % tokens.peek())
        else:
            raise error.InternalError(position, 'Untyped parameters are not yet implemented')

        return Parameter(position, name, type)