def expand(self, start, end, context):
        
        start\
        .connect(tnode(PREFIX))\
        .connect(tnode(ID, 'id'))\
        .connect(tnode(SEMICOLON))\
        .connect(end)
        
    def transform(self, astNode):
        
        idNode = astNode.getChildById('id')
        
        return AstNode(self.getName(), idNode.getText())
        
ArgType = defineRule('argType')

@expand(ArgType)
def argtype_expand(start, end, context):
    
    start.connect(TypeName('type')).connect(end)
    
    start\
    .connect(tnode(REF, 'reference'))\
    .connect(tnode(PAR_OPEN))\
    .connect(ArgType('arg'))\
    .connect(tnode(PAR_CLOSE))\
    .connect(end)
    
    start\
    .connect(tnode(LIST, 'list'))\
#! coding=UTF-8

from tbparser.grammar import defineRule, expand, transform, connector, tokenNode as tnode, Rule, sequence, Switch
from tbparser.parser import AstNode
from gobjcreator2.input.grammar.tokens import *
from gobjcreator2.input.grammar.misc_rules import ComposedId, EnumRule, LiteralOrCode
from gobjcreator2.input.grammar.type_name import TypeName
import gobjcreator2.input.grammar.util as util

Property = defineRule("property")


@expand(Property)
def prop_expand(start, end, context):

    start_ = connector()
    end_ = connector()

    start.connect(tnode(PROPERTY)).connect(ComposedId("name")).connect(tnode(BRACE_OPEN)).connect(start_)

    descr = sequence(tnode(DESCRIPTION), tnode(COLON), tnode(LITERAL, "description"), tnode(SEMICOLON))

    auto = sequence(tnode(AUTO_CREATE, "auto"), tnode(SEMICOLON))

    switch = Switch(
        {
            TYPE: _PropType("type"),
            ACCESS: _Access("access"),
            DESCRIPTION: descr,
            GTYPE: _PropGType("gtype"),
            PROP_MAX: _PropMax("max"),
#! coding=UTF-8

from tbparser.grammar import defineRule, expand, transform, \
tokenNode as tnode, connector, zeroToOne
from tbparser.parser import AstNode
from gobjcreator2.input.grammar.tokens import *
from gobjcreator2.input.grammar.type_name import TypeName
from gobjcreator2.input.grammar.misc_rules import Type, Visibility, Scope

Attribute = defineRule('attribute')

@expand(Attribute)
def _expand(start, end, contex):
    
    start_ = connector()
    
    start\
    .connect(tnode(ATTRIBUTE))\
    .connect(tnode(ID, 'name'))\
    .connect(tnode(BRACE_OPEN))\
    .connect(Type('type'))\
    .connect(start_)
    
    start_.connect(Visibility('visi')).connect(start_)
    start_.connect(Scope('scope')).connect(start_)
    
    start_.connect(tnode(BRACE_CLOSE)).connect(end)

@transform(Attribute)
def _transform(astNode):