parserHTMLizr.py

import ply.yacc as yacc

from lex import tokens
import AST

vars = {}

# Statement are statements
def p_programme_statement(p):
 ''' programme : statement '''
 p[0] = AST.ProgramNode(p[1])

# Recursive programme can be a statement followed by a programme
def p_programme_recursive(p):
 ''' programme : statement programme '''
 p[0] = AST.ProgramNode([p[1]]+p[2].children)


# Statements can be assignations, structures, components, identifier, expression or imbrication
def p_statement(p):
 ''' statement : assignation
 | structure
 | component
 | identifier
 | expression
 | imbrication '''
 p[0] = p[1]

# Newlines
def p_statement_newline(p):
 ''' statement : NEWLINE '''
 p[0] = AST.NewLineNode()

# Simple IF ... THEN condition creates AST.CondNode
# expression between IF and THEN, NEWLINE and programme before the ENDIF reserved word
def p_condition(p):
 ''' statement : IF expression THEN NEWLINE programme ENDIF'''
 p[0] = AST.CondNode([p[2], p[5]])

# IF ... THEN ... ELSE ... ENDIF condition creates CondNode
def p_condition_else(p):
 ''' statement : IF expression THEN NEWLINE programme ELSE NEWLINE programme ENDIF'''
 p[0] = AST.CondNode([p[2], p[5], p[8]])

# Imbrications to have tags in other tags
# Imbricated programme is between { }
def p_imbrication(p):
 ''' imbrication : identifier '{' programme '}' '''
 p[1].addChild(p[3])
 p[0] = p[1]

# A print of you want to display variables content. Creates a PrintNode
def p_statement_print(p):
 ''' statement : PRINT expression '''
 p[0] = AST.PrintNode(p[2])

# While structure with the reserved words WHILE .. DO .. ENDWHILE
def p_structure(p):
 ''' structure : WHILE expression DO NEWLINE programme ENDWHILE '''
 p[0] = AST.WhileNode([p[2],p[5]])

# Components for Bootstrap, will get the content of that comp in components/xxx.html
# The reserved word is COM:nameofcomponent
def p_component(p):
 ''' component : COM ':' TAG '''
 p[0] = AST.ComponentNode(AST.TokenNode(p[3]))

# Identifier for tags properties such as ID, classes and content value
# When three elements are specified
def p_identifier_three_element(p):
 ''' identifier : TAG elem_parts elem_parts elem_parts'''
 p[0] = AST.TagNode([AST.TagNameNode(AST.TokenNode(p[1])), p[2], p[3], p[4]])

# When two elements are specified
def p_identifier_two_element(p):
 ''' identifier : TAG elem_parts elem_parts'''
 p[0] = AST.TagNode([AST.TagNameNode(AST.TokenNode(p[1])), p[2], p[3]])

# When only one element is specified
def p_identifier_one_element(p):
 ''' identifier : TAG elem_parts '''
 p[0] = AST.TagNode([AST.TagNameNode(AST.TokenNode(p[1])), p[2]])

# Single tag identifier
def p_identifier(p):
 ''' identifier : TAG '''
 p[0] = AST.TagNode(AST.TagNameNode(AST.TokenNode(p[1])))

# Argument for the value in the class, id, value for a tag.
def p_arguments(p):
 ''' argument : STRING
 | VARIABLE
 | NUMBER '''
 p[0] = p[1].replace("\"", "")

# Elements parts for a tag. Can be a class, ID or content
# Used in the previous p_identifier for tags
def p_elements_identifier(p):
 '''elem_parts : class
 | id
 | content '''
 p[0] = p[1]

# Tag class definition. Part of the elem_parts identifier
def p_class(p):
 '''class : '.' argument '''
 p[0] = AST.ClassNode(AST.TokenNode(p[2]))

# Tag ID definition. Part of the elem_parts identifier
def p_id(p):
 '''id : '#' argument '''
 p[0] = AST.IdNode(AST.TokenNode(p[2]))

# Tag content definition. Part of the elem_parts identifier
def p_content(p):
 '''content : '@' argument '''
 p[0] = AST.ContentNode(AST.TokenNode(p[2]))

# Mathematical expression for multiplication in the xxx * 2 way
def p_identifier_mulop_expression(p):
 '''expression : identifier MUL_OP expression
 | component MUL_OP expression'''
 p[0] = AST.OpTagNode(p[2], [p[1], p[3]])

# Mathematical expression for multiplication in the 2 * xxx way
def p_expression_mulop_identifier(p):
 '''expression : expression MUL_OP identifier
 | expression MUL_OP component'''
 p[0] = AST.OpTagNode(p[2], [p[3], p[1]])

# Mathematical expression for imbrication multiplication
def p_expression_imbrication(p):
 '''imbrication : expression MUL_OP imbrication '''
 p[0] = AST.OpTagNode(p[2], [p[3], p[1]])

def p_imbrication_expression(p):
 '''imbrication : imbrication MUL_OP expression '''
 p[0] = AST.OpTagNode(p[2], [p[1], p[3]])

# Mathematical expressions
def p_expression_op(p):
 '''expression : expression ADD_OP expression
 | expression MUL_OP expression
 | expression CMP_OP expression
 | expression EQ_OP expression
 | expression NEQ_OP expression'''
 p[0] = AST.OpNode(p[2], [p[1], p[3]])

# Number or variable
def p_expression_num_or_var(p):
 '''expression : NUMBER
 | VARIABLE '''
 p[0] = AST.TokenNode(p[1])

# String expression
def p_expression_string(p):
 '''expression : STRING '''
 p[0] = AST.TokenNode(p[1].replace("\"", ""))

# Brackets expression
def p_expression_paren(p):
 '''expression : '(' expression ')' '''
 p[0] = p[2]

# Minus
def p_minus(p):
 ''' expression : ADD_OP expression %prec UMINUS'''
 p[0] = AST.OpNode(p[1], [p[2]])

# Assignation
def p_assign(p):
 ''' assignation : VARIABLE '=' expression '''
 p[0] = AST.AssignNode([AST.TokenNode(p[1]),p[3]])

# For errors management
def p_error(p):
 if p:
 print ("Syntax error in line %d" % p.lineno)
 yacc.errok()
 else:
 print ("Syntax error: unexpected end of file!")

# Precedence
precedence = (
 ('left', 'ADD_OP'),
 ('left', 'MUL_OP'),
 ('right', 'UMINUS'),
)

def parse(program):
 return yacc.parse(program)

yacc.yacc(outputdir='generated')

if __name__ == "__main__":
 import sys

 prog = open(sys.argv[1]).read()
 result = yacc.parse(prog)
 if result:
 print (result)

 import os
 graph = result.makegraphicaltree()
 name = os.path.splitext(sys.argv[1])[0]+'-ast.pdf'
 graph.write_pdf(name)
 #print ("wrote ast to", name)
 else:
 print ("Parsing returned no result!")