#! /usr/bin/python

from canvas2d import *
import sys
import lex
import yacc

tokens = ('NUMBER', 'LBRACE', 'RBRACE', 'LBRAC', 'RBRAC',
          'TRANSLAT','ROT','SFACTOR','FDIST','NDIST','ORIENT',
          'COORDINDEX','TOP','LEFT','RIGHT','BOTTOM','SEPARATOR',
          'COORD3','PCAMERA','TRANSFORM','POS','IFS','COMMA',
          'POINT')
#Tokens
t_LBRACE    = r'\{'
t_RBRACE    = r'\}'
t_LBRAC     = r'\['
t_RBRAC     = r'\]'
t_TRANSLAT  = r'translation'
t_ROT       = r'rotation'
t_SFACTOR   = r'scaleFactor'
t_FDIST     = r'farDistance'
t_NDIST     = r'nearDistance'
t_LEFT      = r'left'
t_RIGHT     = r'right'
t_TOP       = r'top'
t_BOTTOM    = r'bottom'
t_SEPARATOR = r'Separator'
t_COORDINDEX= r'coordIndex'
t_COORD3    = r'Coordinate3'
t_PCAMERA   = r'PerspectiveCamera'
t_TRANSFORM = r'Transform'
t_POS       = r'position'
t_IFS       = r'IndexedFaceSet'
t_ORIENT    = r'orientation'
t_COMMA     = r','
t_POINT     = r'point'

#All numbers will be interpreted as floating point numbers
def t_NUMBER(t):
    r'[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?'
    try:
        t.value = float(t.value)
    except ValueError:
        print "Unable to convert to float",t.value
        sys.exit()
    return t

t_ignore  = " \t" #ignore whitespace

#line counter 
def t_newline(t):
    r'[\n\r]'
    t.lineno += 1

#error handler
def t_error(t):
    print "Illegal character '%s' on line %d" % (t.value[0], t.lineno)
    sys.exit()

lex.lex()  #build the lexer



#Parsing
def p_blocks(p):
    'blocks     : block block'
    p[0] = p[1]
    p[0].extend(p[2])

def p_block(p):
    '''block : camerablock
            | sepblock'''
    p[0] = p[1]

def p_camerablock(p):
    'camerablock : PCAMERA open cameralines close'
    p[0] = ("camera",p[3])

def p_cameralines(p):
    'cameralines : cameraline cameraline'
    p[0] = p[1]
    p[1].extend(p[2])
    
def p_cameraline(p):
    '''cameraline : POS triple
    | ORIENT quad
    | NDIST NUMBER
    | FDIST NUMBER
    | LEFT NUMBER
    | RIGHT NUMBER
    | TOP NUMBER
    | BOTTOM NUMBER'''
    print "----------------Camera line!------"
    

def p_sepblock(p):
    'sepblock    : SEPARATOR open sepitems close'
    
def p_sepitems(p):
    'sepitems    : sepitem sepitem'
    p[0] = p[1]
    p[0].extend(p[2])
    
def p_sepitem(p):
    '''sepitem     : TRANSFORM open translines close
              | COORD3 open POINT sqopen triples sqclose close
              | IFS open ifslines close'''
    
def p_translines(p):
    'translines  : transline transline'
    p[0] = p[1]
    p[0].extend(p[2])
    
def p_transline(p):
    '''transline   : TRANSLAT triple
              | SFACTOR triple
              | ROT quad'''
    
def p_ifslines(p):
    'ifslines    : ifsline ifsline'
    p[0] = p[1]
    p[0].extend(p[2])
    
def p_ifsline(p):
    'ifsline     : COORDINDEX sqopen singles sqclose'

def p_quad (p):
    'quad : NUMBER NUMBER NUMBER NUMBER'
    p[0] = (p[1],p[2],p[3],p[4])
    sys.stderr.write("Parsed a quad: (%f,%f,%f,%f)\n" % (p[1],p[2],p[3],p[4]))

def p_triple(p):
    'triple : NUMBER NUMBER NUMBER'
    p[0] = (p[1],p[2],p[3])
    sys.stderr.write("Parsed a triple: (%f,%f,%f)\n" % (p[1],p[2],p[3]))

    
def p_triples(p):
    'triples    : triple COMMA triple'
    p[0] = p[1]
    p[0].extend(p[3])
    
def p_open(p):
    'open   : LBRACE'
    
def p_close(p):
    'close   : RBRACE'
    
def p_sqopen(p):
    'sqopen     : LBRAC'

def p_sqclose(p):
    'sqclose    : RBRAC'

def p_singles(p):
    'singles : single single'
    p[0] = p[1]
    p[1].extend(p[2])

def p_single(p):
    'single : NUMBER'
    p[0] = p[1]

def p_error(t):
    print "Syntax error at '%s'" % t.value

#build parser
yacc.yacc()


def main():
    #while 1:
    #    tok = lex.token()
    #    if not tok: break      # No more input
    #    print tok
    while 1:
        result = yacc.parse(sys.stdin.read())
    #print result


if __name__ == '__main__': main()