def p_bracket_list(p): '''bracket_list : LBRACKET expression RBRACKET | bracket_list LBRACKET expression RBRACKET''' if len(p) == 4: p[0] = AST.bracketListNode(p[2], nlines) else: p[0] = AST.bracketListNode(p[1].children + [p[3]], nlines)
def p_exprArray(p): '''expression : IDENTIFIER bracket_list | IDENTIFIER LBRACKET RBRACKET''' if len(p) == 3: p[0] = AST.array_exprNode([AST.TokenNode(p[1], nlines)] + [p[2]], nlines) else: p[0] = AST.array_exprNode([AST.TokenNode(p[1], nlines)])
def generate_bsvcpp(filelist, project_dir, bsvdefines, interfaces): for inputfile in filelist: syntax_parse(open(inputfile).read(),inputfile, bsvdefines) ## code generation pass ilist = [] for i in interfaces: ifc = globalv.globalvars.get(i) if not ifc: print 'Connectal: Unable to locate the interface:', i for keys in globalv.globalvars: print ' ', keys sys.exit(1) ifc = ifc.instantiate(dict(zip(ifc.params, ifc.params))) ilist.append(ifc) for ditem in ifc.decls: for pitem in ditem.params: thisType = pitem.type p = globalv.globalvars.get(thisType.name) if p and thisType.params and p.params: myName = '%sL_%s_P' % (thisType.name, '_'.join([t.name for t in thisType.params if t])) pitem.oldtype = pitem.type pitem.type = AST.Type(myName, []) if not globalv.globalvars.get(myName): globalv.add_new(AST.TypeDef(p.tdtype.instantiate(dict(zip(p.params, thisType.params))), myName, [])) jsondata = AST.serialize_json(ilist, globalimports, bsvdefines) if project_dir: cppgen.generate_cpp(project_dir, noisyFlag, jsondata) bsvgen.generate_bsv(project_dir, noisyFlag, False, jsondata)
def p_argument_declaration(p): '''argument_declaration : IDENTIFIER | NUMBER | IDENTIFIER LBRACKET RBRACKET''' if len(p) == 2: p[0] = AST.TokenNode(p[1], nlines) elif len(p) == 2 and isinstance (p[1], AST.NumberNode): p[0] = AST.NumberNode(p[1], nlines) else: p[0] = AST.array_declNode(AST.TokenNode(p[1], nlines), nlines)
def generate_bsvcpp(filelist, project_dir, dutname, bsvdefines, interfaces, nf): global noisyFlag noisyFlag=nf for inputfile in filelist: syntax_parse(open(inputfile).read(),inputfile, bsvdefines) ## code generation pass ilist = [] for i in interfaces: ifc = globalv.globalvars[i] ifc = ifc.instantiate(dict(zip(ifc.params, ifc.params))) ifc.ind = AST.Interface(i, [], [], None, ifc.package) ifc.ind.req = ifc ilist.append(ifc) jsondata = AST.serialize_json(ilist, globalimports, dutname) cppgen.generate_cpp(project_dir, noisyFlag, jsondata) bsvgen.generate_bsv(project_dir, noisyFlag, jsondata)
def p_rect(p): '''expression : expression '[' expression ']' ''' p[0] = AST.TabNode([p[1], p[3]])
def p_for_instruction(self, p): """for_instruction : FOR variable_expression '=' expression ':' expression instruction """ p[0] = AST.ForInstruction(p[2], p[4], p[6], p[7], p.lineno(1))
self.children[2].children) OUT = self.children[1].execute() if OUT: VARS[self.children[0]][ORDERED][i] = OUT else: for c in VARS[self.children[0]].keys(): if isinstance(VARS[self.children[0]][c], list): continue self.children[1].children[0] = ParamsNode([TokenNode(self.children[0], c)] + self.children[2].children) OUT = self.children[1].execute() if OUT: VARS[self.children[0]][c] = OUT @addToClass(AST.SomehowNode) def execute(self): if self.children[0].execute(): return self.children[1].execute() else: return self.children[2].execute() if __name__ == '__main__': from PARSER import PARSE import sys with open(sys.argv[1]) as PROG: AST = PARSE(PROG.read()) AST.execute()
def p_matrix_initialization_zeros(self, p): """expression : ZEROS '(' expression ')'""" p[0] = AST.ZerosInitialization(p[3], p.lineno(1))
def p_matrix_initialization_eye(self, p): """expression : EYE '(' expression ')'""" p[0] = AST.EyeInitialization(p[3], p.lineno(1))
def p_range_op(p): """rangeoperator : expr ':' expr """ p[0] = AST.BinExpr(p[2], p[1], p[3])
def p_neg_unary_expression(self, p): """expression : '-' expression %prec NEGATION """ p[0] = AST.NegUnaryExpression(p[2], p.lineno(1))
def p_expr2(p): """expr : INTNUMBER """ p[0] = AST.IntNum(p[1])
def p_for_loop(p): """forloop : FOR ID '=' rangeoperator block""" p[0] = AST.ForLoop(p[2], p[4], p[5])
def p_waitOneFrame(p): '''statement : WAITONEFRAME ''' p[0] = AST.WaitNode(AST.TokenNode(p[1]))
def p_member(p): '''member : expression '.' climember''' #try: p[0] = AST.MemberNode([p[1], p[3]])
def p_cliprog(p): '''expression : '{' program '}' ''' p[0] = AST.ProgramNode(p[2])
def p_string(p): '''expression : STRING''' p[0] = AST.PathNode(AST.TokenNode(p[1]))
def p_programme_statement(p): ''' programme : statement ''' p[0] = AST.ProgramNode(p[1])
def p_assign(p): ''' assignation : IDENTIFIER '=' expression ''' p[0] = AST.AssignNode([AST.TokenNode(p[1]), p[3]])
def p_minus(p): ''' expression : ADD_OP expression %prec UMINUS''' p[0] = AST.OpNode(p[1], [p[2]])
def p_expr3(p): """expr : FLOATNUMBER""" p[0] = AST.FloatNum(p[1])
def p_uminus(p): 'expression : ADD_OP expression %prec UMINUS' #p[0] = operations[p[1]](0,p[2]) p[0] = AST.OpNode(p[1], [p[2]])
def p_while_loop(p): """whileloop : WHILE '(' expr ')' block""" p[0] = AST.WhileLoop(p[3], p[5])
def p_scene_type(p): '''scene : SCENE '(' expression ',' '[' id_list ']' ')' ''' p[0] = AST.SceneNode([p[3], p[6]])
def p_print_statement(p): """printstatement : PRINT printables""" p[0] = AST.PrintStatement(p[2])
def p_cli_type(p): '''cli : CLI '(' expression ',' rect ')' '{' program '}' ''' p[0] = AST.CliNode([p[3], p[5], p[8]])
def p_trans_unary_expression(self, p): """expression : expression "'" """ p[0] = AST.TransUnaryExpression(p[1], p.lineno(2))
def p_rect_type(p): '''rect : RECT '(' expression ',' expression ',' expression ',' expression ')' ''' p[0] = AST.RectNode([p[3], p[5], p[7], p[9]])
def p_matrix_initialization_ones(self, p): """expression : ONES '(' expression ')'""" p[0] = AST.OnesInitialization(p[3], p.lineno(1))
def p_expression_op(p): '''expression : expression ADD_OP expression | expression MULT_OP expression''' p[0] = AST.OpNode(p[2], [p[1], p[3]])
def p_while_instruction(self, p): """while_instruction : WHILE '(' condition ')' instruction""" p[0] = AST.WhileInstruction(p[3], p[5], p.lineno(3))
def p_array_declaration(p): '''array_declaration : NEW IDENTIFIER bracket_list''' p[0] = AST.array_declNode([AST.TokenNode(p[2], nlines)] + [p[3]], nlines)
def p_compound_instruction(self, p): """compound_instruction : '{' instructions '}' """ p[0] = AST.CompoundInstruction(p[2], p.lineno(1))
def p_variable(p): '''expression : ID''' p[0] = AST.TokenNode(p[1])
def p_number(p): '''expression : NUMBER''' p[0] = AST.TokenNode(p[1])
def p_pritable2(p): """printable : STRING""" p[0] = AST.String(p[1])