コード例 #1
0
ファイル: Parser.cs プロジェクト: m4k3r-org/yazd
        public static bool IsReservedWord(string str)
        {
            if (str == null)
            {
                return(false);
            }

            if (InstructionSet.IsConditionFlag(str) ||
                InstructionSet.IsValidInstructionName(str) ||
                InstructionSet.IsValidRegister(str))
            {
                return(true);
            }

            switch (str.ToUpperInvariant())
            {
            case "ORG":
            case "SEEK":
            case "END":
            case "INCLUDE":
            case "INCBIN":
            case "EQU":
            case "DB":
            case "DEFB":
            case "DEFM":
            case "DW":
            case "DEFW":
            case "DS":
            case "DEFS":
            case "IF":
            case "ENDIF":
            case "ELSE":
            case "ELSEIF":
            case "PROC":
            case "ENDP":
            case "MACRO":
            case "ENDM":
            case "DEFBITS":
            case "BITMAP":
            case "ENDB":
            case "ERROR":
            case "WARNING":
            case "RADIX":
            case "STRUCT":
            case "ENDS":
            case "BYTE":
            case "WORD":
                return(true);
            }

            return(false);
        }
コード例 #2
0
ファイル: Parser.cs プロジェクト: m4k3r-org/yazd
        ExprNode ParseLeaf()
        {
            var pos = _tokenizer.TokenPosition;

            // Number literal?
            if (_tokenizer.Token == Token.Number)
            {
                var node = new ExprNodeNumberLiteral(pos, _tokenizer.TokenNumber);
                _tokenizer.Next();
                return(node);
            }

            // String literal?
            if (_tokenizer.Token == Token.String)
            {
                var str = _tokenizer.TokenString;
                _tokenizer.Next();
                return(new ExprNodeStringLiteral(pos, str));
            }

            // Defined operator?
            if (_tokenizer.TrySkipIdentifier("defined"))
            {
                _tokenizer.SkipToken(Token.OpenRound);
                _tokenizer.CheckToken(Token.Identifier);
                var node = new ExprNodeIsDefined(pos, _tokenizer.TokenString);
                _tokenizer.Next();
                _tokenizer.SkipToken(Token.CloseRound);
                return(node);
            }

            // Sizeof operator?
            if (_tokenizer.TrySkipIdentifier("sizeof"))
            {
                _tokenizer.SkipToken(Token.OpenRound);
                var node = new ExprNodeSizeOf(pos, ParseExpression());
                _tokenizer.SkipToken(Token.CloseRound);
                return(node);
            }

            // Identifier
            if (_tokenizer.Token == Token.Identifier)
            {
                // Special identifier
                if (InstructionSet.IsConditionFlag(_tokenizer.TokenString) ||
                    InstructionSet.IsValidRegister(_tokenizer.TokenString))
                {
                    var node = new ExprNodeRegisterOrFlag(pos, _tokenizer.TokenString);
                    _tokenizer.Next();
                    return(node);
                }
                else
                {
                    var node = new ExprNodeIdentifier(pos, _tokenizer.TokenString);
                    _tokenizer.Next();

                    if (_tokenizer.Token == Token.Period)
                    {
                        ExprNode retNode = node;
                        while (_tokenizer.TrySkipToken(Token.Period))
                        {
                            _tokenizer.CheckToken(Token.Identifier);
                            retNode = new ExprNodeMember(_tokenizer.TokenPosition, _tokenizer.TokenString, retNode);
                            _tokenizer.Next();
                        }
                        return(retNode);
                    }

                    if (_tokenizer.Token == Token.OpenRound)
                    {
                        node.Arguments = ParseArgumentList();
                    }

                    return(node);
                }
            }

            // Parens?
            if (_tokenizer.TrySkipToken(Token.OpenRound))
            {
                var node = ParseExpressionList();
                _tokenizer.SkipToken(Token.CloseRound);
                return(node);
            }

            // Array?
            if (_tokenizer.Token == Token.OpenSquare)
            {
                return(ParseOrderedStructData());
            }

            // Map?
            if (_tokenizer.Token == Token.OpenBrace)
            {
                return(ParseNamedStructData());
            }

            throw new CodeException($"syntax error in expression: {Tokenizer.DescribeToken(_tokenizer.Token, _tokenizer.TokenRaw)}", _tokenizer.TokenPosition);
        }