コード例 #1
0
ファイル: Type.py プロジェクト: el-coder-sb/pyVHDLParser
	def stateVariableAssignment(cls, parserState: ParserState):
		token = parserState.Token
		errorMessage = "Expected ':=' or whitespace after type mark."
		if isinstance(token, CharacterToken):
			if (token == "\n"):
				parserState.NewBlock =    TypeBlock(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				parserState.NewToken =    LinebreakToken(token)
				_ =                       LinebreakBlock(parserState.NewBlock, parserState.NewToken)
				parserState.TokenMarker = None
				parserState.NextState =   cls.stateWhitespace5
				parserState.PushState =   LinebreakBlock.stateLinebreak
				return
			elif (token == "-"):
				parserState.NewBlock = TypeBlock(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				parserState.TokenMarker = None
				parserState.NextState = cls.stateWhitespace5
				parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
				parserState.TokenMarker = token
				return
			elif (token == "/"):
				parserState.NewBlock = TypeBlock(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				parserState.TokenMarker = None
				parserState.NextState = cls.stateWhitespace5
				parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
				parserState.TokenMarker = token
				return
		elif isinstance(token, SpaceToken):
			parserState.NextState = cls.stateWhitespace5
			return

		raise TokenParserException(errorMessage, token)
コード例 #2
0
ファイル: ForLoop.py プロジェクト: Paebbels/pyVHDLParser
	def stateWhitespace3(cls, parserState: ParserState):
		token = parserState.Token
		if isinstance(token, LinebreakToken):
			if (not (isinstance(parserState.LastBlock, CommentBlock) and isinstance(parserState.LastBlock.StartToken, MultiLineCommentToken))):
				parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				_ =                       LinebreakBlock(parserState.NewBlock, token)
			else:
				parserState.NewBlock =    LinebreakBlock(parserState.LastBlock, token)
			parserState.TokenMarker =   None
			return
		elif isinstance(token, CommentToken):
			parserState.NewBlock =      cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
			_ =                         CommentBlock(parserState.NewBlock, token)
			parserState.TokenMarker =   None
			return
		elif (isinstance(token, IndentationToken) and isinstance(token.PreviousToken, (LinebreakToken, SingleLineCommentToken))):
			return
		elif (isinstance(token, SpaceToken) and (isinstance(parserState.LastBlock, CommentBlock) and isinstance(parserState.LastBlock.StartToken, MultiLineCommentToken))):
			parserState.NewToken =      BoundaryToken(token)
			parserState.NewBlock =      WhitespaceBlock(parserState.LastBlock, parserState.NewToken)
			parserState.TokenMarker =   None
			return
		else:
			parserState.NewBlock =      cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken)
			parserState.NextState =     LoopBlock.stateLoopKeyword
			parserState.PushState =     ExpressionBlockEndedByLoop.stateExpression
			parserState.PushState =     ExpressionBlockEndedByLoopORToORDownto.stateExpression
			parserState.TokenMarker =   parserState.Token
			parserState.NextState(parserState)
			return
コード例 #3
0
	def stateGenerateKeyword(cls, parserState: ParserState):
		token = parserState.Token
		errorMessage = "Expected whitespace after keyword GENERATE."
		if isinstance(token, CharacterToken):
			if (token == "\n"):
				parserState.NewBlock =    CaseBlock(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				parserState.NewToken =    LinebreakToken(token)
				_ =                       LinebreakBlock(parserState.NewBlock, parserState.NewToken)
				parserState.TokenMarker = None
				parserState.NextState =   cls.stateWhitespace1
				parserState.PushState =   LinebreakBlock.stateLinebreak
				return
			elif (token == "-"):
				parserState.NewBlock =    CaseBlock(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				parserState.TokenMarker = None
				parserState.NextState =   cls.stateWhitespace1
				parserState.PushState =   SingleLineCommentBlock.statePossibleCommentStart
				parserState.TokenMarker = token
				return
			elif (token == "/"):
				parserState.NewBlock =    CaseBlock(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				parserState.TokenMarker = None
				parserState.NextState =   cls.stateWhitespace1
				parserState.PushState =   MultiLineCommentBlock.statePossibleCommentStart
				parserState.TokenMarker = token
				return
		elif isinstance(token, SpaceToken):
			parserState.NewToken =      BoundaryToken(token)
			parserState.NextState =     cls.stateWhitespace1
			return

		raise BlockParserException(errorMessage, token)
コード例 #4
0
ファイル: Type.py プロジェクト: Paebbels/pyVHDLParser
    def stateExpressionEnd(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected ';'."
        if isinstance(token, CharacterToken):
            if (token == ";"):
                parserState.NewToken = EndToken(token)
                parserState.NewBlock = TypeBlock(parserState.LastBlock,
                                                 parserState.TokenMarker,
                                                 endToken=parserState.NewToken)
                parserState.Pop()
                return
            elif (token == "-"):
                parserState.NewBlock = TypeBlock(parserState.LastBlock,
                                                 parserState.TokenMarker,
                                                 endToken=token.PreviousToken,
                                                 multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.NewBlock = TypeBlock(parserState.LastBlock,
                                                 parserState.TokenMarker,
                                                 endToken=token.PreviousToken,
                                                 multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return

        raise TokenParserException(errorMessage, token)
コード例 #5
0
ファイル: GenericMapList.py プロジェクト: cmarqu/pyVHDLParser
    def stateWhitespace1(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected  '(' after keyword GENERIC."
        if isinstance(token, CharacterToken):
            if (token == "("):
                parserState.NewToken = BoundaryToken(token)
                parserState.NewBlock = OpenBlock(parserState.LastBlock,
                                                 parserState.TokenMarker,
                                                 endToken=parserState.NewToken)
                parserState.NextState = CloseBlock.stateClosingParenthesis
                parserState.PushState = OpenBlock.stateOpeningParenthesis
                parserState.Counter = 1
                return
            elif (token == "\n"):
                parserState.NewToken = LinebreakToken(token)
                if (not isinstance(parserState.LastBlock,
                                   MultiLineCommentBlock)):
                    parserState.NewBlock = OpenBlock(
                        parserState.LastBlock,
                        parserState.TokenMarker,
                        endToken=parserState.NewToken.PreviousToken,
                        multiPart=True)
                    _ = LinebreakBlock(parserState.NewBlock,
                                       parserState.NewToken)
                else:
                    parserState.NewBlock = LinebreakBlock(
                        parserState.LastBlock, parserState.NewToken)
                parserState.TokenMarker = None
                parserState.NextState = cls.stateWhitespace1
                parserState.PushState = LinebreakBlock.stateLinebreak
                return
            elif (token == "-"):
                parserState.NewBlock = OpenBlock(parserState.LastBlock,
                                                 parserState.TokenMarker,
                                                 endToken=token.PreviousToken,
                                                 multiPart=True)
                parserState.TokenMarker = None
                parserState.NextState = cls.stateWhitespace1
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.NewBlock = OpenBlock(parserState.LastBlock,
                                                 parserState.TokenMarker,
                                                 endToken=token.PreviousToken,
                                                 multiPart=True)
                parserState.TokenMarker = None
                parserState.NextState = cls.stateWhitespace1
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif (isinstance(token, SpaceToken)
              and isinstance(parserState.LastBlock, MultiLineCommentBlock)):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = WhitespaceBlock(parserState.LastBlock,
                                                   parserState.NewToken)
            parserState.TokenMarker = None
            return

        raise TokenParserException(errorMessage, token)
コード例 #6
0
ファイル: Type.py プロジェクト: el-coder-sb/pyVHDLParser
	def stateTypeName(cls, parserState: ParserState):
		token = parserState.Token
		errorMessage = "Expected ';' after library name."
		if isinstance(token, CharacterToken):
			if (token == ":"):
				parserState.NewToken =    BoundaryToken(token)
				parserState.NextState =   cls.stateColon1
				return
			elif (token == "\n"):
				parserState.NewBlock =    TypeBlock(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				parserState.NewToken =    LinebreakToken(token)
				_ =                       LinebreakBlock(parserState.NewBlock, parserState.NewToken)
				parserState.TokenMarker = None
				parserState.NextState =   cls.stateWhitespace2
				parserState.PushState =   LinebreakBlock.stateLinebreak
				return
			elif (token == "-"):
				parserState.NewBlock =    TypeBlock(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				parserState.TokenMarker = None
				parserState.NextState =   cls.stateWhitespace2
				parserState.PushState =   SingleLineCommentBlock.statePossibleCommentStart
				parserState.TokenMarker = token
				return
			elif (token == "/"):
				parserState.NewBlock =    TypeBlock(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				parserState.TokenMarker = None
				parserState.NextState =   cls.stateWhitespace2
				parserState.PushState =   MultiLineCommentBlock.statePossibleCommentStart
				parserState.TokenMarker = token
				return
		elif isinstance(token, SpaceToken):
			parserState.NextState =     cls.stateWhitespace2
			return

		raise TokenParserException(errorMessage, token)
コード例 #7
0
ファイル: PortList.py プロジェクト: cmarqu/pyVHDLParser
    def stateItemDelimiter(cls, parserState: ParserState):
        token = parserState.Token
        if isinstance(token, StringToken):
            if (token <= "signal"):
                parserState.NewToken = SignalKeyword(token)
                parserState.PushState = PortListInterfaceSignalBlock.stateSignalKeyword
                parserState.TokenMarker = parserState.NewToken
                return
            else:
                parserState.NewToken = IdentifierToken(token)
                parserState.PushState = PortListInterfaceSignalBlock.stateObjectName
                parserState.TokenMarker = parserState.NewToken
                return
        elif isinstance(token, ExtendedIdentifier):
            parserState.NextState = PortListInterfaceSignalBlock.stateObjectName
            return
        elif isinstance(token, SpaceToken):
            parserState.NextState = OpenBlock.stateOpeningParenthesis
            return
        elif isinstance(token, LinebreakToken):
            parserState.NewBlock = LinebreakBlock(parserState.LastBlock, token)
            parserState.TokenMarker = token
            parserState.NextState = OpenBlock.stateOpeningParenthesis
            return
        elif isinstance(token, CommentToken):
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=token.PreviousToken,
                                       multiPart=True)
            _ = CommentBlock(parserState.NewBlock, token)
            parserState.TokenMarker = None
            # parserState.NextState =     cls.stateWhitespace1
            return

        raise TokenParserException("Expected port name (identifier).", token)
コード例 #8
0
ファイル: If.py プロジェクト: Paebbels/pyVHDLParser
	def stateIfKeyword(cls, parserState: ParserState):
		token = parserState.Token
		if (isinstance(token, CharacterToken) and (token == "(")):
			parserState.NewToken =    BoundaryToken(token)
			parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=parserState.NewToken.PreviousToken)
			parserState.TokenMarker = parserState.NewToken
			parserState.NextState =   ThenBlock.stateThenKeyword
			parserState.PushState =   ExpressionBlockEndedByThen.stateExpression
			return
		elif isinstance(token, SpaceToken):
			parserState.NewToken =    BoundaryToken(token)
			parserState.NextState =   cls.stateWhitespace1
			return
		elif isinstance(token, (LinebreakToken, CommentToken)):
			block =                   LinebreakBlock if isinstance(token, LinebreakToken) else CommentBlock
			parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
			_ =                       block(parserState.NewBlock, token)
			parserState.TokenMarker = None
			parserState.NextState =   cls.stateWhitespace1
			return
		else:
			parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken)
			parserState.NextState =   ThenBlock.stateThenKeyword
			parserState.PushState =   ExpressionBlockEndedByThen.stateExpression
			parserState.TokenMarker = parserState.Token
			parserState.NextState(parserState)
			return
コード例 #9
0
    def stateWhitespace2(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected attribute name (identifier)."
        if isinstance(token, CharacterToken):
            if (token == ":"):
                parserState.NewToken = BoundaryToken(token)
                parserState.NextState = cls.stateColon1
                return
            if (token == "\n"):
                parserState.NewToken = LinebreakToken(token)
                if (not isinstance(parserState.LastBlock,
                                   MultiLineCommentBlock)):
                    parserState.NewBlock = AttributeDeclarationBlock(
                        parserState.LastBlock,
                        parserState.TokenMarker,
                        endToken=parserState.NewToken.PreviousToken,
                        multiPart=True)
                    _ = LinebreakBlock(parserState.NewBlock,
                                       parserState.NewToken)
                else:
                    parserState.NewBlock = LinebreakBlock(
                        parserState.LastBlock, parserState.NewToken)
                parserState.TokenMarker = None
                parserState.PushState = LinebreakBlock.stateLinebreak
                return
            elif (token == "-"):
                parserState.NewBlock = AttributeDeclarationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.NewBlock = AttributeDeclarationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif isinstance(token, WordToken):
            parserState.NewToken = IdentifierToken(token)
            parserState.NextState = cls.stateColon1()
            return
        elif (isinstance(token, SpaceToken)
              and isinstance(parserState.LastBlock, MultiLineCommentBlock)):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = WhitespaceBlock(parserState.LastBlock,
                                                   parserState.NewToken)
            parserState.TokenMarker = None
            return

        raise TokenParserException(errorMessage, token)
コード例 #10
0
ファイル: IfGenerate.py プロジェクト: cmarqu/pyVHDLParser
    def stateWhitespace2(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected keyword IS after generate name."
        if isinstance(token, CharacterToken):
            if (token == "\n"):
                parserState.NewToken = LinebreakToken(token)
                if (not isinstance(parserState.LastBlock,
                                   MultiLineCommentBlock)):
                    parserState.NewBlock = ElseGenerateBlock(
                        parserState.LastBlock,
                        parserState.TokenMarker,
                        endToken=parserState.NewToken.PreviousToken,
                        multiPart=True)
                    _ = LinebreakBlock(parserState.NewBlock,
                                       parserState.NewToken)
                else:
                    parserState.NewBlock = LinebreakBlock(
                        parserState.LastBlock, parserState.NewToken)
                parserState.TokenMarker = None
                parserState.PushState = LinebreakBlock.stateLinebreak
                return
            elif (token == "-"):
                parserState.NewBlock = ElseGenerateBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.NewBlock = ElseGenerateBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif (isinstance(token, StringToken) and (token <= "is")):
            parserState.NewToken = IsKeyword(token)
            parserState.NewBlock = ElseGenerateBlock(
                parserState.LastBlock,
                parserState.TokenMarker,
                endToken=parserState.NewToken)
            parserState.NextState = cls.stateDeclarativeRegion
            return
        elif (isinstance(token, SpaceToken)
              and isinstance(parserState.LastBlock, MultiLineCommentBlock)):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = WhitespaceBlock(parserState.LastBlock,
                                                   parserState.NewToken)
            parserState.TokenMarker = None
            return

        raise TokenParserException(errorMessage, token)
コード例 #11
0
    def stateWhitespace2(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected ';'."
        if isinstance(token, CharacterToken):
            if (token == ";"):
                parserState.NewToken = EndToken(token)
                parserState.NewBlock = EntityInstantiationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=parserState.NewToken)
                parserState.Pop()
                return
            elif (token == "\n"):
                parserState.NewToken = LinebreakToken(token)
                if (not isinstance(parserState.LastBlock,
                                   MultiLineCommentBlock)):
                    parserState.NewBlock = EntityInstantiationBlock(
                        parserState.LastBlock,
                        parserState.TokenMarker,
                        endToken=parserState.NewToken.PreviousToken,
                        multiPart=True)
                    _ = LinebreakBlock(parserState.NewBlock,
                                       parserState.NewToken)
                else:
                    parserState.NewBlock = LinebreakBlock(
                        parserState.LastBlock, parserState.NewToken)
                parserState.TokenMarker = None
                parserState.PushState = LinebreakBlock.stateLinebreak
                return
            elif (token == "-"):
                parserState.NewBlock = EntityInstantiationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.NewBlock = EntityInstantiationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif (isinstance(token, SpaceToken)
              and isinstance(parserState.LastBlock, MultiLineCommentBlock)):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = WhitespaceBlock(parserState.LastBlock,
                                                   parserState.NewToken)
            parserState.TokenMarker = None
            return

        raise TokenParserException(errorMessage, token)
コード例 #12
0
    def stateWhitespace4(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected ':=' after type mark."
        if isinstance(token, CharacterToken):
            if (token == ":"):
                parserState.NewToken = BoundaryToken(token)
                parserState.NextState = cls.statePossibleVariableAssignment
                return
            elif (token == "\n"):
                parserState.NewToken = LinebreakToken(token)
                if (not isinstance(parserState.LastBlock,
                                   MultiLineCommentBlock)):
                    parserState.NewBlock = AttributeSpecificationBlock(
                        parserState.LastBlock,
                        parserState.TokenMarker,
                        endToken=parserState.NewToken.PreviousToken,
                        multiPart=True)
                    _ = LinebreakBlock(parserState.NewBlock,
                                       parserState.NewToken)
                else:
                    parserState.NewBlock = LinebreakBlock(
                        parserState.LastBlock, parserState.NewToken)
                parserState.TokenMarker = None
                parserState.PushState = LinebreakBlock.stateLinebreak
                return
            elif (token == "-"):
                parserState.NewBlock = AttributeSpecificationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.NewBlock = AttributeSpecificationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif (isinstance(token, SpaceToken)
              and isinstance(parserState.LastBlock, MultiLineCommentBlock)):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = WhitespaceBlock(parserState.LastBlock,
                                                   parserState.NewToken)
            parserState.TokenMarker = None
            return

        raise TokenParserException(errorMessage, token)
コード例 #13
0
    def stateItemDelimiter(cls, parserState: ParserState):
        token = parserState.Token
        if isinstance(token, WordToken):
            if (token <= "constant"):
                parserState.NewToken = ConstantKeyword(token)
                parserState.PushState = GenericListInterfaceConstantBlock.stateConstantKeyword
                parserState.TokenMarker = parserState.NewToken
                return
            elif (token <= "type"):
                parserState.NewToken = TypeKeyword(token)
                parserState.PushState = GenericListInterfaceTypeBlock.stateTypeKeyword
                parserState.TokenMarker = parserState.NewToken
                return
            elif (token <= "procedure"):
                raise NotImplementedError(
                    "Generic procedures are not supported.")
            elif (token <= "function"):
                raise NotImplementedError(
                    "Generic functions are not supported.")
            elif (token <= "impure"):
                raise NotImplementedError(
                    "Generic impure functions are not supported.")
            elif (token <= "pure"):
                raise NotImplementedError(
                    "Generic pure functions are not supported.")
            else:
                parserState.NewToken = IdentifierToken(token)
                parserState.PushState = GenericListInterfaceConstantBlock.stateObjectName
                parserState.TokenMarker = parserState.NewToken
                return
        elif isinstance(token, ExtendedIdentifier):
            parserState.NextState = GenericListInterfaceConstantBlock.stateObjectName
            return
        elif isinstance(token, SpaceToken):
            parserState.NextState = OpenBlock.stateOpeningParenthesis
            return
        elif isinstance(token, LinebreakToken):
            parserState.NewBlock = LinebreakBlock(parserState.LastBlock, token)
            parserState.TokenMarker = token
            parserState.NextState = OpenBlock.stateOpeningParenthesis
            return
        elif isinstance(token, CommentToken):
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=token.PreviousToken,
                                       multiPart=True)
            _ = CommentBlock(parserState.NewBlock, token)
            parserState.TokenMarker = None
            # parserState.NextState =   cls.stateWhitespace1
            return

        raise BlockParserException("Expected generic name (identifier).",
                                   token)
コード例 #14
0
    def stateOpeningParenthesis(cls, parserState: ParserState):
        token = parserState.Token
        if isinstance(token, StringToken):
            if (token <= "constant"):
                parserState.NewToken = ConstantKeyword(token)
                parserState.NextState = DelimiterBlock.stateItemDelimiter
                parserState.PushState = ParameterListInterfaceConstantBlock.stateConstantKeyword
                parserState.TokenMarker = parserState.NewToken
                return
            elif (token <= "variable"):
                parserState.NewToken = VariableKeyword(token)
                parserState.NextState = DelimiterBlock.stateItemDelimiter
                parserState.PushState = ParameterListInterfaceVariableBlock.stateVariableKeyword
                parserState.TokenMarker = parserState.NewToken
                return
            elif (token <= "signal"):
                parserState.NewToken = SignalKeyword(token)
                parserState.NextState = DelimiterBlock.stateItemDelimiter
                parserState.PushState = ParameterListInterfaceSignalBlock.stateSignalKeyword
                parserState.TokenMarker = parserState.NewToken
                return
            else:
                parserState.NewToken = IdentifierToken(token)
                parserState.PushState = ParameterListInterfaceConstantBlock.stateObjectName
                parserState.TokenMarker = parserState.NewToken
                return
        elif isinstance(token, ExtendedIdentifier):
            parserState.NextState = ParameterListInterfaceConstantBlock.stateObjectName
            return
        elif isinstance(token, SpaceToken):
            blockType = IndentationBlock if isinstance(
                token, IndentationToken) else WhitespaceBlock
            parserState.NewBlock = blockType(parserState.LastBlock, token)
            return
        elif isinstance(token, LinebreakToken):
            parserState.NewBlock = LinebreakBlock(parserState.LastBlock, token)
            parserState.TokenMarker = token
            return
        elif isinstance(token, CommentToken):
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=token.PreviousToken,
                                       multiPart=True)
            _ = CommentBlock(parserState.NewBlock, token)
            parserState.TokenMarker = None
            return

        raise TokenParserException(
            "Expected interface element name (identifier).", token)
コード例 #15
0
ファイル: IfGenerate.py プロジェクト: cmarqu/pyVHDLParser
    def stateDeclarativeRegion(cls, parserState: ParserState):
        errorMessage = "Expected one of these keywords: generic, port, begin, end."
        token = parserState.Token
        if isinstance(parserState.Token, CharacterToken):
            if (token == "\n"):
                parserState.NewToken = LinebreakToken(token)
                parserState.NewBlock = LinebreakBlock(parserState.LastBlock,
                                                      parserState.NewToken)
                parserState.TokenMarker = parserState.NewToken
                return
            elif (token == "-"):
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif isinstance(token, SpaceToken):
            parserState.NewToken = IndentationToken(token)
            parserState.NewBlock = IndentationBlock(parserState.LastBlock,
                                                    parserState.NewToken)
            return
        elif isinstance(token, StringToken):
            keyword = token.Value.lower()
            if (keyword == "generic"):
                newToken = GenericKeyword(token)
                parserState.PushState = GenericList.OpenBlock.stateGenericKeyword
            elif (keyword == "port"):
                newToken = PortKeyword(token)
                parserState.PushState = PortList.OpenBlock.statePortKeyword
            elif (keyword == "end"):
                newToken = EndKeyword(token)
                parserState.NextState = EndGenerateBlock.stateEndKeyword
            elif (keyword == "begin"):
                parserState.NewToken = BeginKeyword(token)
                parserState.NewBlock = ElseGenerateBeginBlock(
                    parserState.LastBlock, parserState.NewToken)
                parserState.NextState = ElseGenerateBeginBlock.stateBeginKeyword
                return
            else:
                raise TokenParserException(errorMessage, token)

            parserState.NewToken = newToken
            parserState.TokenMarker = newToken
            return

        raise TokenParserException(errorMessage, token)
コード例 #16
0
    def stateColon1(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected type mark or whitespace after ':'."
        if isinstance(token, CharacterToken):
            if (token == "\n"):
                parserState.NewBlock = AttributeDeclarationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.NewToken = LinebreakToken(token)
                _ = LinebreakBlock(parserState.NewBlock, parserState.NewToken)
                parserState.TokenMarker = None
                parserState.NextState = cls.stateWhitespace3
                parserState.PushState = LinebreakBlock.stateLinebreak
                return
            elif (token == "-"):
                parserState.NewBlock = AttributeDeclarationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.NextState = cls.stateWhitespace3
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.NewBlock = AttributeDeclarationBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=token.PreviousToken,
                    multiPart=True)
                parserState.TokenMarker = None
                parserState.NextState = cls.stateWhitespace3
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif isinstance(token, SpaceToken):
            parserState.NewToken = BoundaryToken(token)
            parserState.NextState = cls.stateWhitespace3
            return
        elif isinstance(token, WordToken):
            parserState.NewToken = IdentifierToken(token)
            parserState.NextState = cls.stateTypeMarkName
            return

        raise TokenParserException(errorMessage, token)
コード例 #17
0
ファイル: Context.py プロジェクト: Paebbels/pyVHDLParser
	def stateDeclarativeRegion(cls, parserState: ParserState):
		token = parserState.Token
		if isinstance(token, SpaceToken):
			blockType =                 IndentationBlock if isinstance(token, IndentationToken) else WhitespaceBlock
			parserState.NewBlock =      blockType(parserState.LastBlock, token)
			return
		elif isinstance(token, (LinebreakToken, CommentToken)):
			block =                     LinebreakBlock if isinstance(token, LinebreakToken) else CommentBlock
			parserState.NewBlock =      block(parserState.LastBlock, token)
			parserState.TokenMarker =   None
			return
		elif isinstance(token, WordToken):
			tokenValue = token.Value.lower()
			for keyword in cls.KEYWORDS:
				if (tokenValue == keyword.__KEYWORD__):
					newToken =                keyword(token)
					parserState.PushState =   cls.KEYWORDS[keyword]
					parserState.NewToken =    newToken
					parserState.TokenMarker = newToken
					return

			if (tokenValue == "end"):
				parserState.NewToken =    EndKeyword(token)
				parserState.TokenMarker = parserState.NewToken
				parserState.NextState =   EndBlock.stateEndKeyword
				return

		raise BlockParserException(
			"Expected one of these keywords: END, {keywords}. Found: '{tokenValue}'.".format(
				keywords=", ".join(
					[kw.__KEYWORD__.upper() for kw in cls.KEYWORDS]
				),
				tokenValue=token.Value
			), token)
コード例 #18
0
	def stateWhitespace3(cls, parserState: ParserState):
		token = parserState.Token
		if (isinstance(token, CharacterToken) and  (token == ";")):
			parserState.NewToken =    EndToken(token)
			parserState.NewBlock =    EndBlock(parserState.LastBlock, parserState.TokenMarker, endToken=parserState.NewToken.PreviousToken)
			parserState.Pop()
			return
		elif isinstance(token, LinebreakToken):
			if (not (isinstance(parserState.LastBlock, CommentBlock) and isinstance(parserState.LastBlock.StartToken, MultiLineCommentToken))):
				parserState.NewBlock =  cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				_ =                     LinebreakBlock(parserState.NewBlock, token)
			else:
				parserState.NewBlock =  LinebreakBlock(parserState.LastBlock, token)
			parserState.TokenMarker = None
			return
		elif isinstance(token, CommentToken):
			parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
			_ =                       CommentBlock(parserState.NewBlock, token)
			parserState.TokenMarker = None
			return
		elif (isinstance(token, IndentationToken) and isinstance(token.PreviousToken, (LinebreakToken, SingleLineCommentToken))):
			return
		elif (isinstance(token, SpaceToken) and (
			isinstance(parserState.LastBlock, CommentBlock) and isinstance(parserState.LastBlock.StartToken, MultiLineCommentToken))):
			parserState.NewToken =    BoundaryToken(token)
			parserState.NewBlock =    WhitespaceBlock(parserState.LastBlock, parserState.NewToken)
			parserState.TokenMarker = None
			return
		else:
			parserState.NewBlock = cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken)
			parserState.NextState =   EndBlock.stateError
			parserState.PushState =   ExitConditionBlock.stateExpression
			parserState.TokenMarker = parserState.Token
			parserState.NextState(parserState)
			return
コード例 #19
0
	def stateWhenKeyword(cls, parserState: ParserState):
		token = parserState.Token
		if isinstance(token, CharacterToken):
			if  (token == ";"):
				parserState.NewToken =    EndToken(token)
				parserState.NewBlock =    EndBlock(parserState.LastBlock, parserState.TokenMarker, endToken=parserState.NewToken.PreviousToken)
				parserState.Pop()
				return
			elif  (token == "("):
				parserState.NewToken =    BoundaryToken(token)
				parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=parserState.NewToken.PreviousToken)
				parserState.TokenMarker = parserState.NewToken
				parserState.NextState =   EndBlock.stateError
				parserState.PushState =   ExitConditionBlock.stateExpression
				return
		elif isinstance(token, SpaceToken):
			parserState.NewToken =    BoundaryToken(token)
			parserState.NextState =   cls.stateWhitespace3
			return
		elif isinstance(token, (LinebreakToken, CommentToken)):
			block =                   LinebreakBlock if isinstance(token, LinebreakToken) else CommentBlock
			parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
			_ =                       block(parserState.NewBlock, token)
			parserState.TokenMarker = None
			parserState.NextState =   cls.stateWhitespace3
			return

		raise TokenParserException("Expected ';' or whitespace after keyword RETURN.", token)
コード例 #20
0
ファイル: ForLoop.py プロジェクト: cmarqu/pyVHDLParser
    def stateInKeyword(cls, parserState: ParserState):
        token = parserState.Token
        if (isinstance(token, CharacterToken) and (token == "(")):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = cls(
                parserState.LastBlock,
                parserState.TokenMarker,
                endToken=parserState.NewToken.PreviousToken)
            parserState.TokenMarker = parserState.NewToken
            parserState.NextState = LoopBlock.stateSequentialRegion
            parserState.PushState = ExpressionBlockEndedByLoopORToORDownto.stateExpression
            return
        elif isinstance(token, SpaceToken):
            parserState.NewToken = BoundaryToken(token)
            parserState.NextState = cls.stateWhitespace3
            return
        elif isinstance(token, (LinebreakToken, CommentToken)):
            block = LinebreakBlock if isinstance(
                token, LinebreakToken) else CommentBlock
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=token.PreviousToken,
                                       multiPart=True)
            _ = block(parserState.NewBlock, token)
            parserState.TokenMarker = None
            parserState.NextState = cls.stateWhitespace3
            return

        raise TokenParserException(
            "Expected '(' or whitespace after keyword IN.", token)
コード例 #21
0
    def stateParameterKeyword(cls, parserState: ParserState):
        token = parserState.Token
        if (isinstance(token, CharacterToken) and (token == "(")):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=parserState.NewToken)
            parserState.NextState = CloseBlock.stateClosingParenthesis
            parserState.PushState = cls.stateOpeningParenthesis
            parserState.Counter = 1
            return
        elif isinstance(token, SpaceToken):
            parserState.NextState = cls.stateWhitespace1
            return
        elif isinstance(token, (LinebreakToken, CommentToken)):
            block = LinebreakBlock if isinstance(
                token, LinebreakToken) else CommentBlock
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=token.PreviousToken,
                                       multiPart=True)
            _ = block(parserState.NewBlock, token)
            parserState.TokenMarker = None
            parserState.NextState = cls.stateWhitespace1
            return

        raise TokenParserException(
            "Expected '(' or whitespace after keyword PARAMETER.", token)
コード例 #22
0
ファイル: Procedure.py プロジェクト: el-coder-sb/pyVHDLParser
    def stateProcedureName(cls, parserState: ParserState):
        token = parserState.Token
        if (isinstance(token, CharacterToken) and (token == "(")):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = cls(
                parserState.LastBlock,
                parserState.TokenMarker,
                endToken=parserState.NewToken.PreviousToken)
            _ = ParameterList.OpenBlock(parserState.NewBlock,
                                        parserState.NewToken)
            parserState.TokenMarker = None
            parserState.NextState = VoidBlock.stateAfterParameterList
            parserState.PushState = ParameterList.OpenBlock.stateOpeningParenthesis
            parserState.Counter = 1
            return
        elif isinstance(token, SpaceToken):
            parserState.NewToken = BoundaryToken(token)
            parserState.NextState = cls.stateWhitespace2
            return
        elif isinstance(token, (LinebreakToken, CommentToken)):
            block = LinebreakBlock if isinstance(
                token, LinebreakToken) else CommentBlock
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=token.PreviousToken,
                                       multiPart=True)
            _ = block(parserState.NewBlock, token)
            parserState.TokenMarker = None
            parserState.NextState = cls.stateWhitespace2
            return

        raise BlockParserException(
            "Expected '(' or whitespace after procedure name.", token)
コード例 #23
0
ファイル: PortList.py プロジェクト: cmarqu/pyVHDLParser
    def stateOpeningParenthesis(cls, parserState: ParserState):
        token = parserState.Token
        if (isinstance(token, CharacterToken) and (token == ")")):
            # if (parserState.TokenMarker != token):
            # 	parserState.NewBlock = IndentationBlock(parserState.LastBlock, parserState.TokenMarker, token.PreviousToken)
            parserState.Pop()
            parserState.TokenMarker = token
            return
        elif isinstance(token, StringToken):
            if (token <= "signal"):
                parserState.NewToken = SignalKeyword(token)
                parserState.NextState = DelimiterBlock.stateItemDelimiter
                parserState.PushState = PortListInterfaceSignalBlock.stateSignalKeyword
                parserState.TokenMarker = parserState.NewToken
                return
            else:
                parserState.NewToken = IdentifierToken(token)
                parserState.NextState = DelimiterBlock.stateItemDelimiter
                parserState.PushState = PortListInterfaceSignalBlock.stateObjectName
                parserState.TokenMarker = parserState.NewToken
                return
        elif isinstance(token, ExtendedIdentifier):
            parserState.NextState = PortListInterfaceSignalBlock.stateObjectName
            return
        elif isinstance(token, SpaceToken):
            blockType = IndentationBlock if isinstance(
                token, IndentationToken) else WhitespaceBlock
            parserState.NewBlock = blockType(parserState.LastBlock, token)
            return
        elif isinstance(token, LinebreakToken):
            parserState.NewBlock = LinebreakBlock(parserState.LastBlock, token)
            parserState.TokenMarker = token
            # parserState.NextState =   cls.stateWhitespace1
            return
        elif isinstance(token, CommentToken):
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=token.PreviousToken,
                                       multiPart=True)
            _ = CommentBlock(parserState.NewBlock, token)
            parserState.TokenMarker = None
            # parserState.NextState =   cls.stateWhitespace1
            return

        raise TokenParserException(
            "Expected interface signal name (identifier) or keyword: SIGNAL.",
            token)
コード例 #24
0
ファイル: Comment.py プロジェクト: Paebbels/pyVHDLParser
 def stateConsumeComment(cls, parserState: ParserState):
     token = parserState.Token
     if (isinstance(token, CharacterToken) and (token == "*")):
         parserState.PushState = cls.statePossibleCommentEnd
         parserState.TokenMarker = token
         return
     else:
         pass  # consume everything until "*/"
コード例 #25
0
ファイル: IfGenerate.py プロジェクト: cmarqu/pyVHDLParser
    def stateBeginKeyword(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected label or one of these keywords: assert, process."
        if isinstance(token, CharacterToken):
            if (token == "\n"):
                parserState.NewToken = LinebreakToken(token)
                parserState.NewBlock = LinebreakBlock(parserState.LastBlock,
                                                      parserState.NewToken)
                parserState.TokenMarker = parserState.NewToken
                return
            elif (token == "-"):
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif isinstance(token, SpaceToken):
            return
        # 	parserState.NewToken = IndentationToken(token)
        # 	parserState.NewBlock = IndentationBlock(parserState.LastBlock, parserState.NewToken)
        # 	return
        elif isinstance(token, StringToken):
            keyword = token.Value.lower()
            if (keyword == "process"):
                newToken = ProcessKeyword(token)
                parserState.PushState = Process.OpenBlock.stateProcessKeyword
            elif (keyword == "assert"):
                newToken = AssertKeyword(token)
                parserState.PushState = AssertBlock.stateAssertKeyword
            elif (keyword == "end"):
                newToken = EndKeyword(token)
                parserState.NextState = EndGenerateBlock.stateEndKeyword
            else:
                raise TokenParserException(errorMessage, token)

            parserState.NewToken = newToken
            parserState.TokenMarker = newToken
            return

        raise TokenParserException(errorMessage, token)
コード例 #26
0
ファイル: GenericMapList.py プロジェクト: cmarqu/pyVHDLParser
    def stateClosingParenthesis(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected ';' or whitespace."
        if isinstance(token, CharacterToken):
            if (token == ";"):
                parserState.NewToken = EndToken(token)
                parserState.NewBlock = CloseBlock(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=parserState.NewToken)
                parserState.Pop()
                return
            elif (token == "\n"):
                parserState.NewToken = LinebreakToken(token)
                parserState.PushState = LinebreakBlock.stateLinebreak
                parserState.TokenMarker = parserState.NewToken
                return
            elif (token == "-"):
                parserState.NewBlock = CloseBlock(parserState.LastBlock,
                                                  parserState.TokenMarker,
                                                  endToken=token.PreviousToken,
                                                  multiPart=True)
                parserState.TokenMarker = None
                parserState.NextState = cls.stateWhitespace1
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.NewBlock = CloseBlock(parserState.LastBlock,
                                                  parserState.TokenMarker,
                                                  endToken=token.PreviousToken,
                                                  multiPart=True)
                parserState.TokenMarker = None
                parserState.NextState = cls.stateWhitespace1
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif isinstance(token, SpaceToken):
            parserState.NextState = cls.stateWhitespace1
            return

        raise TokenParserException(errorMessage, token)
コード例 #27
0
ファイル: GenericMapList.py プロジェクト: cmarqu/pyVHDLParser
    def stateOpeningParenthesis(cls, parserState: ParserState):
        token = parserState.Token
        errorMessage = "Expected generic name (identifier)."
        if isinstance(token, CharacterToken):
            if (token == ")"):
                # if (parserState.TokenMarker != token):
                # 	parserState.NewBlock = IndentationBlock(parserState.LastBlock, parserState.TokenMarker, token.PreviousToken)
                parserState.Pop()
                parserState.TokenMarker = token
                return
            elif (token == "\n"):
                parserState.NewToken = LinebreakToken(token)
                parserState.NewBlock = LinebreakBlock(parserState.LastBlock,
                                                      parserState.NewToken)
                parserState.TokenMarker = None
                parserState.PushState = LinebreakBlock.stateLinebreak
                return
            elif (token == "-"):
                parserState.TokenMarker = None
                parserState.PushState = SingleLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
            elif (token == "/"):
                parserState.TokenMarker = None
                parserState.PushState = MultiLineCommentBlock.statePossibleCommentStart
                parserState.TokenMarker = token
                return
        elif isinstance(token, SpaceToken):
            parserState.NewToken = IndentationToken(token)
            parserState.NewBlock = IndentationBlock(parserState.LastBlock,
                                                    parserState.NewToken)
            return
        elif isinstance(token, StringToken):
            parserState.NewToken = IdentifierToken(token)
            parserState.TokenMarker = parserState.NewToken
            parserState.NextState = ItemBlock.stateItemRemainder

            # if (parserState.TokenMarker != token):
            # 	parserState.NewBlock = IndentationBlock(parserState.LastBlock, parserState.TokenMarker, token)
            return

        raise TokenParserException(errorMessage, token)
コード例 #28
0
ファイル: Procedure.py プロジェクト: cmarqu/pyVHDLParser
	def stateWhitespace2(cls, parserState: ParserState):
		token = parserState.Token
		if (isinstance(token, CharacterToken) and (token == "(")):
			parserState.NewToken =      BoundaryToken(token)
			parserState.NewBlock =      cls(parserState.LastBlock, parserState.TokenMarker, endToken=parserState.NewToken.PreviousToken)
			_ =                         ParameterList.OpenBlock(parserState.NewBlock, parserState.NewToken)
			parserState.TokenMarker =   None
			parserState.NextState =     VoidBlock.stateAfterParameterList
			parserState.PushState =     ParameterList.OpenBlock.stateOpeningParenthesis
			parserState.Counter =       1
			return
		elif isinstance(token, StringToken):
			keyword = token.Value.lower()
			if (keyword == "is"):
				parserState.NewToken =    IsKeyword(token)
				parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=parserState.NewToken.PreviousToken)
				_ =                       VoidBlock(parserState.NewBlock, parserState.NewToken)
				parserState.TokenMarker = parserState.NewToken
				parserState.NextState =   VoidBlock.stateDeclarativeRegion
				return
			elif (keyword == "generic"):
				parserState.NewToken =    GenericKeyword(token)
				parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=parserState.NewToken.PreviousToken)
				parserState.NextState =   GenericList.OpenBlock.stateGenericKeyword
				parserState.TokenMarker = parserState.NewToken
				return
			elif (keyword == "parameter"):
				parserState.NewToken =    ParameterKeyword(token)
				parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=parserState.NewToken.PreviousToken)
				parserState.NextState =   ParameterList.OpenBlock.stateParameterKeyword
				parserState.TokenMarker = parserState.NewToken
				return
		elif isinstance(token, LinebreakToken):
			if (not (isinstance(parserState.LastBlock, CommentBlock) and isinstance(parserState.LastBlock.StartToken, MultiLineCommentToken))):
				parserState.NewBlock =    cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
				_ =                       LinebreakBlock(parserState.NewBlock, token)
			else:
				parserState.NewBlock =    LinebreakBlock(parserState.LastBlock, token)
			parserState.TokenMarker =   None
			return
		elif isinstance(token, CommentToken):
			parserState.NewBlock =      cls(parserState.LastBlock, parserState.TokenMarker, endToken=token.PreviousToken, multiPart=True)
			_ =                         CommentBlock(parserState.NewBlock, token)
			parserState.TokenMarker =   None
			return
		elif (isinstance(token, SpaceToken) and (isinstance(parserState.LastBlock, CommentBlock) and isinstance(parserState.LastBlock.StartToken, MultiLineCommentToken))):
			parserState.NewToken =      BoundaryToken(token)
			parserState.NewBlock =      WhitespaceBlock(parserState.LastBlock, parserState.NewToken)
			parserState.TokenMarker =   None
			return

		raise TokenParserException("Expected '(' or keywords GENERIC, PARAMETER or RETURN after procedure name.", token)
コード例 #29
0
    def stateSubtypeIndication(cls, parserState: ParserState):
        token = parserState.Token
        if (isinstance(token, FusedCharacterToken) and (token == ":=")):
            parserState.NewToken = VariableAssignmentKeyword(token)
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=parserState.NewToken)
            parserState.NextState = cls.DELIMITER_BLOCK.stateItemDelimiter
            parserState.PushState = cls.EXPRESSION.stateBeforeExpression
            parserState.TokenMarker = None
            parserState.Counter = 0
            return
        elif isinstance(token, CharacterToken):
            if (token == ';'):
                parserState.NewToken = DelimiterToken(token)
                parserState.NewBlock = cls(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=parserState.NewToken.PreviousToken)
                _ = cls.DELIMITER_BLOCK(parserState.NewBlock,
                                        parserState.NewToken)
                parserState.Pop()
                return
            elif (token == ')'):
                parserState.NewToken = BoundaryToken(token)
                parserState.NewBlock = cls(
                    parserState.LastBlock,
                    parserState.TokenMarker,
                    endToken=parserState.NewToken.PreviousToken)
                parserState.Pop(2)
                parserState.TokenMarker = parserState.NewToken
                return
        elif isinstance(token, SpaceToken):
            parserState.NewToken = BoundaryToken(token)
            parserState.NextState = cls.stateWhitespace5
            return
        elif isinstance(token, (LinebreakToken, CommentToken)):
            block = LinebreakBlock if isinstance(
                token, LinebreakToken) else CommentBlock
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=token.PreviousToken,
                                       multiPart=True)
            _ = block(parserState.NewBlock, token)
            parserState.TokenMarker = None
            parserState.NextState = cls.stateWhitespace5
            return

        raise TokenParserException(
            "Expected ';', ':=' or whitespace after subtype indication.",
            token)
コード例 #30
0
    def stateWhitespace1(cls, parserState: ParserState):
        token = parserState.Token
        if (isinstance(token, CharacterToken) and (token == "(")):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=parserState.NewToken)
            parserState.PushState = cls.stateOpeningParenthesis
            parserState.Counter = 1
            return
        elif isinstance(token, LinebreakToken):
            if (not (isinstance(parserState.LastBlock, CommentBlock)
                     and isinstance(parserState.LastBlock.StartToken,
                                    MultiLineCommentToken))):
                parserState.NewBlock = cls(parserState.LastBlock,
                                           parserState.TokenMarker,
                                           endToken=token.PreviousToken,
                                           multiPart=True)
                _ = LinebreakBlock(parserState.NewBlock, token)
            else:
                parserState.NewBlock = LinebreakBlock(parserState.LastBlock,
                                                      token)
            parserState.TokenMarker = None
            return
        elif isinstance(token, CommentToken):
            parserState.NewBlock = cls(parserState.LastBlock,
                                       parserState.TokenMarker,
                                       endToken=token.PreviousToken,
                                       multiPart=True)
            _ = CommentBlock(parserState.NewBlock, token)
            parserState.TokenMarker = None
            return
        elif (isinstance(token, IndentationToken)
              and isinstance(token.PreviousToken,
                             (LinebreakToken, SingleLineCommentToken))):
            return
        elif (isinstance(token, SpaceToken) and
              (isinstance(parserState.LastBlock, CommentBlock) and isinstance(
                  parserState.LastBlock.StartToken, MultiLineCommentToken))):
            parserState.NewToken = BoundaryToken(token)
            parserState.NewBlock = WhitespaceBlock(parserState.LastBlock,
                                                   parserState.NewToken)
            parserState.TokenMarker = None
            return

        raise TokenParserException("Expected '(' after keyword PARAMETER.",
                                   token)