Schema definition
Inheritance: TypeDefinition
コード例 #1
0
ファイル: Lexer.cs プロジェクト: paralect/Schematra
        /// <summary>
        /// Parsing of schema-def-tagged-option nonterm
        /// </summary>
        private void ParseSchemaDefTaggedOption(ParseTreeNode node, RecordDefinition schemadef)
        {
            _currentNode = node;

            foreach (var child in node.ChildNodes)
            {
                switch (child.Term.Name)
                {
                    case SchematraGrammer.term_schema_def_tag:

                        var guidText = child.Token.ValueString;
                        schemadef.Tag = Guid.Parse(guidText);
                        break;
                }
            }
        }
コード例 #2
0
ファイル: Lexer.cs プロジェクト: paralect/Schematra
        /// <summary>
        /// Parsing of schema-def-options nonterm
        /// </summary>
        private void ParseSchemaDefOptions(ParseTreeNode node, RecordDefinition schemadef)
        {
            _currentNode = node;

            if (node.ChildNodes.Count <= 0)
                return;

            foreach (var child in node.ChildNodes)
            {
                switch (child.Term.Name)
                {
                    case SchematraGrammer.term_schema_def_option:
                        ParseSchemaDefOption(child, schemadef);
                        break;
                }
            }
        }
コード例 #3
0
ファイル: Lexer.cs プロジェクト: paralect/Schematra
        /// <summary>
        /// Parsing of schema-def-option nonterm
        /// </summary>
        private void ParseSchemaDefOption(ParseTreeNode node, RecordDefinition schemadef)
        {
            _currentNode = node;

            foreach (var child in node.ChildNodes)
            {
                switch (child.Term.Name)
                {
                    case SchematraGrammer.term_schema_def_tagged_option:
                        ParseSchemaDefTaggedOption(child, schemadef);
                        break;
                    case SchematraGrammer.term_schema_def_extends_option:
                        ParseSchemaDefExtendsOption(child, schemadef);
                        break;
                }
            }
        }
コード例 #4
0
ファイル: Lexer.cs プロジェクト: paralect/Schematra
        /// <summary>
        /// Parsing of schema-def-extends-option nonterm
        /// </summary>
        private void ParseSchemaDefExtendsOption(ParseTreeNode node, RecordDefinition schemadef)
        {
            _currentNode = node;

            foreach (var child in node.ChildNodes)
            {
                switch (child.Term.Name)
                {
                    case SchematraGrammer.term_schema_def_extends:
                        schemadef.Extends = child.Token.ValueString;
                        break;
                }
            }
        }
コード例 #5
0
ファイル: Lexer.cs プロジェクト: paralect/Schematra
        /// <summary>
        /// Parsing of schema-def-body nonterm
        /// </summary>
        private void ParseSchemaDefBody(ParseTreeNode node, RecordDefinition schemadef)
        {
            _currentNode = node;

            foreach (var child in node.ChildNodes)
            {
                switch (child.Term.Name)
                {
                    case SchematraGrammer.term_field:
                        var fieldDefinition = new FieldDefinition();
                        ParseField(child, fieldDefinition);
                        schemadef.FieldDefinitions.Add(fieldDefinition);
                        break;
                }
            }
        }
コード例 #6
0
ファイル: Lexer.cs プロジェクト: paralect/Schematra
        /// <summary>
        /// Parsing of schema-def nonterm
        /// </summary>
        private void ParseSchemaDef(ParseTreeNode node, UnitDefinition unitDefinition, String space)
        {
            _currentNode = node;

            var schemadef = new RecordDefinition();

            foreach (var child in node.ChildNodes)
            {
                switch (child.Term.Name)
                {
                    case SchematraGrammer.term_schema_def_name:
                        schemadef.Name = child.Token.Text;
                        schemadef.Namespace = space;
                        break;

                    case SchematraGrammer.term_schema_def_options:
                        ParseSchemaDefOptions(child, schemadef);
                        break;

                    case SchematraGrammer.term_schema_def_body:
                        ParseSchemaDefBody(child, schemadef);
                        break;
                }
            }

            unitDefinition.TypeDefinitions.Add(schemadef);
        }