Подскажите пожалуйста что происходит в сороке p[0] = Node('define', [p[2]])

# coding=utf8
 
from lexer import tokens
import ply.yacc as yacc
 
class Node:
    def parts_str(self):
        st = []
        for part in self.parts:
            st.append( str( part ) )
        return "\n".join(st)
 
    def __repr__(self):
        return self.type + ":\n\t" + self.parts_str().replace("\n", "\n\t")
 
    def add_parts(self, parts):
        self.parts += parts
        return self
 
    def __init__(self, type, parts):
        self.type = type
        self.parts = parts
 
def p_text(p):
    '''text :
           | START commands'''
    if len(p) == 1:
        p[0] = None
    else:
        p[0] = p[2]
 
def p_commands(p):
    '''commands :
               | commands lines'''
    if len(p) > 1:
        if p[1] is None:
            p[1] = Node('text', [])
        p[0] = p[1].add_parts([p[2]])
    else:
        p[0] = Node('text', [])
 
def p_lines(p):
    '''lines : assign
             | passign
             | dassign
             | mulassign
             | minassign
             | def
             | op_if
             | while
             | input
             | print'''
    p[0] = p[1]
 
def p_passign(p):
    '''passign : IDENT PASSIGN expr COLON'''
    p[0] = Node('assign', [p[1], Node('+', [p[1], p[3]])])
 
def p_dassign(p):
    '''dassign : IDENT DASSIGN expr COLON'''
    p[0] = Node('assign', [p[1], Node('/', [p[1], p[3]])])
 
def p_mulassign(p):
    '''mulassign : IDENT MULASSIGN expr COLON'''
    p[0] = Node('assign', [p[1], Node('*', [p[1], p[3]])])
 
def p_minassign(p):
    '''minassign : IDENT MINASSIGN expr COLON'''
    p[0] = Node('assign', [p[1], Node('-', [p[1], p[3]])])
 
def p_input(p):
    '''input : INPUT OPEN IDENT CLOSE COLON'''
    p[0] = Node('input', [p[3]])
 
def p_print(p):
    '''print : PRINT OPEN args CLOSE COLON'''
    p[0] = Node('print', [p[3]])
 
def p_args(p):
    '''args :
            | expr
            | args COMA expr'''
    if len(p) == 1:
        p[0] = Node('args', [])
    elif len(p) == 2:
        p[0] = Node('args', [p[1]])
    else:
        p[0] = p[1].add_parts([p[3]])
    
def p_def(p):
    '''def : DEF IDENT COLON
           | DEF assign'''
    if len(p) > 3:
        p[0] = Node('define', [p[2]])
    else:
        p[0] = Node('define', [p[2]])
 
def p_assign(p):
    '''assign : IDENT ASSIGN expr COLON'''
    p[0] = Node('assign', [p[1], p[3]])
 
def p_expr(p):
    '''expr : term
            | expr PLUSMINUS expr
            | expr DIVMUL expr'''
    if len(p) == 2:
        p[0] = p[1]
    else:
        p[0] = Node(p[2], [p[1], p[3]])
 
def p_compare(p):
    '''compare : arg COMPARE arg'''
    p[0] = Node(p[2], [p[1],p[3]])
 
def p_logic(p):
    '''logic : OPEN compare CLOSE LOGIC OPEN compare CLOSE
             | compare
             | expr'''
    if len(p) == 2:
        p[0] = p[1]
    else:
        p[0] = Node(p[4], [p[2],p[6]])
 
def p_op_if(p):
    '''op_if : IF OPEN logic CLOSE then else END COLON
             | IF OPEN logic CLOSE then END COLON'''
    if len(p) == 8:
        p[0] = Node('if', [p[3], p[5]]) 
    else:       
        p[0] = Node('if', [p[3], p[5], p[6]])
 
def p_while(p):
    '''while : WHILE OPEN logic CLOSE do END COLON'''
    p[0] = Node('while', [p[3], p[5]])
 
def p_do(p):
    '''do : DO
          | do lines'''
    if len(p) == 2:
        p[0] = Node('do', [])
    else:
        p[0] = p[1].add_parts([p[2]])
 
def p_then(p):
    '''then : THEN
            | then lines'''
    if len(p) == 2:
        p[0] = Node('then', [])
    else:
        p[0] = p[1].add_parts([p[2]])
 
def p_else(p):
    '''else : ELSE
            | else lines'''
    if len(p) == 2:
        p[0] = Node('else', [])
    else:
        p[0] = p[1].add_parts([p[2]])
 
def p_term(p):
    '''term : arg
            | OPEN expr CLOSE'''
    if len(p) == 2:
        p[0] = p[1]
    else:
        p[0] = p[2]
 
def p_arg(p):
    '''arg : NUM
       | IDENT'''
    p[0] = Node('arg', [p[1]])
 
def p_error(p):
    print ('Unexpected token:', p)
 
parser = yacc.yacc()
 
def build_tree(code):
    return (parser.parse(code))