コード例 #1
0
        protected internal virtual InterchangeUnitNode ParseInterchangeElement(InterchangeElementNode nodeForAnnotation)
        {
            // PARSE: <interchangeElement> ::= <classDefinition> | <classInitialization> | <globalDefinition> |
            //      <globalValueInitialization> | <poolDefinition> | <poolVariableDefinition> | <poolValueInitialization> |
            //      <methodDefinition> | <classMethodDefinition> | <programInitialization> | comment <elementSeparator>

            // PARSE: The above definitions expand to:
            // ’Class’ ’named:’ <classNameString> .... <elementSeparator>
            // <className> ’initializer’ <elementSeparator>
            // ’Global’ ’variable:’ <globalNameString> <elementSeparator>
            // ’Global’ ’constant:’ <globalNameString> <elementSeparator>
            // <globalName> ’initializer’ <elementSeparator>
            // ’Pool’ ’named:’ <poolNameString> <elementSeparator>
            // <poolName> ’variable:’ <poolVariableNameString> <elementSeparator>
            // <poolName> ’constant:’ <poolVariableNameString> <elementSeparator>
            // <poolName> ’initializerFor:’ <poolVariableNameString> <elementSeparator>
            // <className> ’method’ <elementSeparator>
            // <className> ’classMethod’ <elementSeparator>
            // ’Global’ ’initializer’ <elementSeparator>
            // comment <elementSeparator> ... NB: This will NEVER be returned by GetNextTokenxx().

            Token token = this.GetNextTokenxx();
            if (token is EofToken)
                return null; // Most probably just a comment ...

            // The abode syntax shows us that we are dealing with the following pattern:
            //      identifier indetifier_or_keyword undefined_token*
            // Comments are ignored and discarded by GetNextTokenxx().
            IdentifierToken id = token as IdentifierToken;
            if (id == null)
            {
                this.ReportParserError("Expected identifier.", token);
                return null;
            }

            token = this.GetNextTokenxx();
            IdentifierOrKeywordToken cmd = token as IdentifierOrKeywordToken;
            if (cmd == null)
            {
                this.ReportParserError("Expected identifier or keyword.", token);
                return null;
            }

            // <classDefinition> ::= ’Class’ ’named:’ <classNameString> .... <elementSeparator>
            if ((id.Value == "Class") && (cmd.Value == "named:"))
                return this.ParseClassDefinition(); // Discard <id> and <cmd>
            // <globalDefinition> ::= ’Global’ ’variable:’ <globalNameString> <elementSeparator>
            if ((id.Value == "Global") && (cmd.Value == "variable:"))
                return this.ParseGlobalVariableDefinition(); // Discard <id> and <cmd>
            // <globalDefinition> ::= ’Global’ ’constant:’ <globalNameString> <elementSeparator>
            if ((id.Value == "Global") && (cmd.Value == "constant:"))
                return this.ParseGlobalConstantDefinition(); // Discard <id> and <cmd>
            // <poolDefinition> ::= ’Pool’ ’named:’ <poolNameString> <elementSeparator>
            if ((id.Value == "Pool") && (cmd.Value == "named:"))
                return this.ParsePoolDefinition(); // Discard <id> and <cmd>
            // <programInitialization> ::= ’Global’ ’initializer’ <elementSeparator>
            if ((id.Value == "Global") && (cmd.Value == "initializer"))
                return this.ParseProgramInitialization(); // Discard <id> and <cmd>

            // <methodDefinition> ::= <className> ’method’ <elementSeparator>
            if (cmd.Value == "method")
                return this.ParseInstanceMethodDefinition(id); // Discard <cmd>
            // <classMethodDefinition> ::= <className> ’classMethod’ <elementSeparator>
            if (cmd.Value == "classMethod")
                return this.ParseClassMethodDefinition(id); // Discard <cmd>
            // <classInitialization> ::= <className> ’initializer’ <elementSeparator>
            // <globalValueInitialization> ::= <globalName> ’initializer’ <elementSeparator>
            if (cmd.Value == "initializer")
                return this.ParseGlobalInitialization(id); // Discard <cmd>
            // <poolVariableDefinition> ::= <poolName> ’variable:’ <poolVariableNameString> <elementSeparator>
            if (cmd.Value == "variable:")
                return this.ParsePoolVariableDefinition(id); // Discard <cmd>
            // <poolVariableDefinition> ::= <poolName> ’constant:’ <poolVariableNameString> <elementSeparator>
            if (cmd.Value == "constant:")
                return this.ParsePoolConstantDefinition(id); // Discard <cmd>
            // <poolValueInitialization> ::= <poolName> ’initializerFor:’ <poolVariableNameString> <elementSeparator>
            if (cmd.Value == "initializerFor:")
                return this.ParsePoolValueInitialization(id);

            // SPECIAL CASE .... Not really interchange element, but handled like one for simplicity.
            // <annotation> ::= ’Annotation’ ’key:’ quotedString ’value:’ quotedString <elementSeparator>
            if ((id.Value == "Annotation") && (cmd.Value == "key:"))
            {
                if (nodeForAnnotation == null)
                    this.ReportParserError("Annotation must follow an interchange element", cmd);
                return this.ParseAnnotation(nodeForAnnotation);
            }

            this.ReportParserError("Unrecognized interchange element.", token);
            return null;
        }
コード例 #2
0
 protected virtual AnnotationNode CreateAnnotationNode(InterchangeElementNode nodeForAnnotation)
 {
     return new AnnotationNode(nodeForAnnotation);
 }
コード例 #3
0
        protected virtual AnnotationNode ParseAnnotation(InterchangeElementNode nodeForAnnotation)
        {
            // PARSE: <annotation> ::= ’Annotation’ ’key:’ quotedString ’value:’ quotedString <elementSeparator>
            AnnotationNode result = this.CreateAnnotationNode(nodeForAnnotation);
            Token token = this.GetNextTokenxx();
            StringToken str = token as StringToken;
            if (str == null)
                this.ReportParserError(result, "Missing annotation key.", token);
            result.Key = str;

            token = this.GetNextTokenxx();
            KeywordToken cmd = token as KeywordToken;
            if ((cmd == null) || (cmd.Value != "value:"))
                this.ReportParserError("Missing annotation #value: keyword.", token);

            token = this.GetNextTokenxx();
            str = token as StringToken;
            if (str == null)
                this.ReportParserError(result, "Missing annotation value.", token);
            result.Value = str;

            token = this.GetNextTokenxx();
            if (!(token is EofToken))
            {
                this.ReportParserError(result, "Unexpected code found after annotation value.", token);
                result.Key = null; // This is to avoid somethind like: Annotation key: 'x' value: 'y' crash: 'yes'.
                result.Value = null; // This is to avoid somethind like: Annotation key: 'x' value: 'y' crash: 'yes'.
                return result;
            }

            return result;
        }
コード例 #4
0
ファイル: AnnotationNode.cs プロジェクト: erlis/IronSmalltalk
 public AnnotationNode(InterchangeElementNode annotatedNode)
 {
     this.AnnotatedNode = annotatedNode; // Null is OK!
 }