def make_attr_node(self, attr): node_list = [] new_attr_name = attr.localName attr_ast = util.parse(attr.nodeValue, 'rhs_expression') node_list.append(ast.TextNode(u' %(new_attr_name)s="' % vars())) # fixme: need to guarantee good output - escape sequences etc node_list.append(ast.PlaceholderSubstitutionNode(attr_ast)) node_list.append(ast.TextNode('"')) return node_list
def handle_condition(self, dom_node, attr_name): expr_ast = util.parse(dom_node.getAttribute(attr_name), 'rhs_expression') node_list = [] if_node = ast.IfNode(expr_ast) node_list.append(if_node) if_node.append(self.make_tag_node(dom_node)) for n in dom_node.childNodes: if_node.extend(self.build_ast(n)) if_node.extend(self.make_tag_node(dom_node, close=True)) return node_list
def handle_condition(self, dom_node, attr_name): expr_ast = util.parse( dom_node.getAttribute(attr_name), 'rhs_expression') node_list = [] if_node = ast.IfNode(expr_ast) node_list.append(if_node) if_node.append(self.make_tag_node(dom_node)) for n in dom_node.childNodes: if_node.extend(self.build_ast(n)) if_node.extend(self.make_tag_node(dom_node, close=True)) return node_list
def handle_define(self, dom_node, attr_name): node_list = [] node_name = dom_node.nodeName # print "handle_define", node_name # fixme: this is a nasty temp hack, it will generate the correct code # for 1 define, but multiple expressions won't work expr_ast = util.parse(dom_node.getAttribute(attr_name), 'argument_list') dom_node.removeAttribute(attr_name) node_list.extend(expr_ast) node_list.extend(self.build_ast(dom_node)) return node_list
def handleMacro(self, pnode, macro_function, parse_rule): if isinstance(pnode, ast.MacroNode): kargs_map = pnode.parameter_list.get_arg_map() elif isinstance(pnode, ast.CallFunctionNode): kargs_map = pnode.arg_list.get_arg_map() else: self.compiler.error(SemanticAnalyzerError( "unexpected node type '%s' for macro" % type(pnode)), pos=pnode.pos) macro_output = macro_function(pnode, kargs_map, self.compiler) # fixme: bad place to import, difficult to put at the top due to # cyclic dependency try: if parse_rule: fragment_ast = util.parse(macro_output, parse_rule) elif isinstance(pnode, ast.MacroNode): fragment_ast = util.parse(macro_output, 'fragment_goal') elif isinstance(pnode, ast.CallFunctionNode): fragment_ast = util.parse(macro_output, 'rhs_expression') except Exception, e: self.compiler.error(MacroParseError(e), pos=pnode.pos)
def handle_omit_tag(self, dom_node, attr_name): debug("handle_omit_tag", dom_node) node_list = [] node_name = dom_node.nodeName raw_expression = dom_node.getAttribute(attr_name) if raw_expression: expr_ast = util.parse(raw_expression, 'argument_list') else: expr_ast = None dom_node.removeAttribute(attr_name) setattr(dom_node, 'omit_tag', True) setattr(dom_node, 'omit_tag_ast', expr_ast) return node_list
def macro_i18n(macro_node, arg_map, compiler): # fixme: parse the parameter list into something usable # macro_node.parameter_list # generate a fake translation for now to verify this is working # most apps will have to stub this part out somehow i think macro_content_ast = util.parse(macro_node.value, 'i18n_goal') i18n_msg = make_i18n_message(macro_node.value, macro_content_ast) i18n_msg_utf8 = i18n_msg.encode(sys.getdefaultencoding()) #print "macro_content_ast" #print "orginal:", macro_node.value #print "i18n:", i18n_msg_utf8 #visitor.print_tree(macro_content_ast) return i18n_msg
def handleMacro(self, pnode, macro_function, parse_rule): if isinstance(pnode, ast.MacroNode): kargs_map = pnode.parameter_list.get_arg_map() elif isinstance(pnode, ast.CallFunctionNode): kargs_map = pnode.arg_list.get_arg_map() else: self.compiler.error( SemanticAnalyzerError("unexpected node type '%s' for macro" % type(pnode)), pos=pnode.pos) macro_output = macro_function(pnode, kargs_map, self.compiler) # fixme: bad place to import, difficult to put at the top due to # cyclic dependency try: if parse_rule: fragment_ast = util.parse(macro_output, parse_rule) elif isinstance(pnode, ast.MacroNode): fragment_ast = util.parse(macro_output, 'fragment_goal') elif isinstance(pnode, ast.CallFunctionNode): fragment_ast = util.parse(macro_output, 'rhs_expression') except Exception, e: self.compiler.error(MacroParseError(e), pos=pnode.pos)
def handle_content(self, dom_node, attr_name): debug("handle_content", dom_node) #traceback.print_stack() expr_ast = util.parse( dom_node.getAttribute(attr_name), 'rhs_expression') dom_node.removeAttribute(attr_name) setattr(dom_node, 'has_child_stuff', True) node_list = [] debug("handle_content start", dom_node) node_list.extend(self.make_tag_node(dom_node)) node_list.append(ast.PlaceholderSubstitutionNode(expr_ast)) debug("handle_content end", dom_node) node_list.extend(self.make_tag_node(dom_node, close=True)) debug("handle_content return", dom_node) return node_list
def analyzeMacroNode(self, pnode): # fixme: better error handler macro_handler_name = 'macro_%s' % pnode.name try: macro_function, macro_parse_rule = self.compiler.macro_registry[ macro_handler_name] except KeyError: self.compiler.error(SemanticAnalyzerError("no handler registered for '%s'" % macro_handler_name), pos=pnode.pos) try: temp_fragment = util.parse(pnode.value, macro_parse_rule or 'fragment_goal') except Exception, e: self.compiler.error(MacroParseError(e), pos=pnode.pos)
def analyzeMacroNode(self, pnode): # fixme: better error handler macro_handler_name = 'macro_%s' % pnode.name try: macro_function, macro_parse_rule = self.compiler.macro_registry[ macro_handler_name] except KeyError: self.compiler.error(SemanticAnalyzerError( "no handler registered for '%s'" % macro_handler_name), pos=pnode.pos) try: temp_fragment = util.parse(pnode.value, macro_parse_rule or 'fragment_goal') except Exception, e: self.compiler.error(MacroParseError(e), pos=pnode.pos)
def handle_content(self, dom_node, attr_name): debug("handle_content", dom_node) #traceback.print_stack() expr_ast = util.parse(dom_node.getAttribute(attr_name), 'rhs_expression') dom_node.removeAttribute(attr_name) setattr(dom_node, 'has_child_stuff', True) node_list = [] debug("handle_content start", dom_node) node_list.extend(self.make_tag_node(dom_node)) node_list.append(ast.PlaceholderSubstitutionNode(expr_ast)) debug("handle_content end", dom_node) node_list.extend(self.make_tag_node(dom_node, close=True)) debug("handle_content return", dom_node) return node_list
def handle_repeat(self, dom_node, attr_name): debug("handle_repeat", dom_node) expr_pieces = dom_node.getAttribute(attr_name).split() dom_node.removeAttribute(attr_name) target = expr_pieces[0] expr_ast = util.parse(' '.join(expr_pieces[1:]), 'rhs_expression') node_list = [] # hack - assumes python syntax fn = ast.ForNode( ast.TargetListNode([ ast.IdentifierNode("self.repeat['%s']" % target), ast.IdentifierNode(target) ]), ast.ExpressionListNode([ ast.CallFunctionNode(ast.IdentifierNode('enumerate'), ast.ArgListNode([expr_ast])) ])) if self.has_child_stuff(dom_node): debug("has_child_stuff:", dom_node) fn.extend(self.build_ast(dom_node)) #fn.append(self.make_tag_node(dom_node)) #for n in dom_node.childNodes: # fn.extend(self.build_ast(n)) else: # print "no children" fn.extend(self.build_ast(dom_node)) if (dom_node.previousSibling and dom_node.previousSibling.nodeType == xml.dom.minidom.Node.TEXT_NODE and not dom_node.previousSibling.nodeValue.strip()): # inject the previous whitespace sibling to keep the output looking # ok fixme: a conditional is probably required here - you only want # to execute this if it's not the last execution of the loop fn.prepend(self.build_ast(dom_node.previousSibling)) # now remove the previous sibling #print "node", dom_node #print "parent", dom_node.parentNode #print ' '.join("previous", dom_node.previousSibling, # id(dom_node.previousSibling)) #print "next", dom_node.nextSibling, id(dom_node.nextSibling) #dom_node.parentNode.removeChild(dom_node.previousSibling) node_list.append(ast.EatPrevious()) node_list.append(fn) #fn.extend(self.make_tag_node(dom_node, close=True)) return node_list
def handle_repeat(self, dom_node, attr_name): debug("handle_repeat", dom_node) expr_pieces = dom_node.getAttribute(attr_name).split() dom_node.removeAttribute(attr_name) target = expr_pieces[0] expr_ast = util.parse(' '.join(expr_pieces[1:]), 'rhs_expression') node_list = [] # hack - assumes python syntax fn = ast.ForNode( ast.TargetListNode([ast.IdentifierNode( "self.repeat['%s']" % target), ast.IdentifierNode(target)]), ast.ExpressionListNode([ast.CallFunctionNode( ast.IdentifierNode('enumerate'), ast.ArgListNode([expr_ast]))])) if self.has_child_stuff(dom_node): debug("has_child_stuff:", dom_node) fn.extend(self.build_ast(dom_node)) #fn.append(self.make_tag_node(dom_node)) #for n in dom_node.childNodes: # fn.extend(self.build_ast(n)) else: # print "no children" fn.extend(self.build_ast(dom_node)) if (dom_node.previousSibling and dom_node.previousSibling.nodeType == xml.dom.minidom.Node.TEXT_NODE and not dom_node.previousSibling.nodeValue.strip()): # inject the previous whitespace sibling to keep the output looking # ok fixme: a conditional is probably required here - you only want # to execute this if it's not the last execution of the loop fn.prepend(self.build_ast(dom_node.previousSibling)) # now remove the previous sibling #print "node", dom_node #print "parent", dom_node.parentNode #print ' '.join("previous", dom_node.previousSibling, # id(dom_node.previousSibling)) #print "next", dom_node.nextSibling, id(dom_node.nextSibling) #dom_node.parentNode.removeChild(dom_node.previousSibling) node_list.append(ast.EatPrevious()) node_list.append(fn) #fn.extend(self.make_tag_node(dom_node, close=True)) return node_list
def handle_replace(self, dom_node, attr_name): expr_ast = util.parse( dom_node.getAttribute(attr_name), 'rhs_expression') dom_node.removeAttribute(attr_name) return [ast.PlaceholderSubstitutionNode(expr_ast)]
def handle_replace(self, dom_node, attr_name): expr_ast = util.parse(dom_node.getAttribute(attr_name), 'rhs_expression') dom_node.removeAttribute(attr_name) return [ast.PlaceholderSubstitutionNode(expr_ast)]