def reduceLoop(startNode): treeModified = False conditionNode = None # Can only reduce constant condition expression if startNode.type != "constant": return treeModified # Can only reduce a condition expression # of a loop context node = startNode while(node): # find the loop's condition node if node.parent and node.parent.type == "loop" and node.parent.getFirstChild(ignoreComments=True)==node: conditionNode = node break node = node.parent if not conditionNode: return treeModified # handle "if" statements if conditionNode.parent.get("loopType") == "IF": loopNode = conditionNode.parent # startNode must be only condition if startNode==conditionNode or isDirectDescendant(startNode, conditionNode): value = startNode.get("value") if startNode.get("constantType") == 'string': value = '"' + value + '"' # re-parse into an internal value value = json.loads(value) condValue = bool(value) #print "optimizing: if" treeutil.inlineIfStatement(loopNode, condValue) treeModified = True return treeModified
def processEnvironmentClass(node, variantMap): def myVariantNodes(node): variantNodes = treeutil.findVariablePrefix(node, "this.useCheck") for variantNode in variantNodes: print variantNode.toXml() if not variantNode.hasParentContext("call/operand"): continue else: yield variantNode treeModified = False #TODO: use myVariantNodes() # Simple sanity checks params = callNode.getChild("params") if len(params.children) != 1: log("Warning", "Expecting exactly one argument for qx.core.Environment.get. Ignoring this occurrence.", params) return treeModified firstParam = params.getChildByPosition(0) if not isStringLiteral(firstParam): log("Warning", "First argument must be a string literal! Ignoring this occurrence.", firstParam) return treeModified variantKey = firstParam.get("value"); variantValue, found = __keyLookup(variantKey, variantMap) #if not variantKey in variantMap.keys(): if not found: return treeModified #else: # variantValue = variantMap[variantKey] # Processing # are we in a if/loop condition expression, i.e. a "loop/expression/..." context? conditionNode = None loopType = None node = callNode while (node): if node.type == "expression" and node.parent and node.parent.type == "loop": conditionNode = node break node = node.parent if not conditionNode: return treeModified # handle "if" statements if conditionNode.parent.get("loopType") == "IF": loopNode = conditionNode.parent # get() call is only condition if callNode.parent == conditionNode: #TODO: variantValue is not interesting, only if variantKey is in variantMap (!?) treeutil.inlineIfStatement(loopNode, bool(variantValue)) # take the truth val of the key value treeModified = True return treeModified
def visit_loop(self, node): loop_type = node.get("loopType") if loop_type == "IF": cond_node = node.children[0] if hasattr(cond_node, "evaluated") and cond_node.evaluated != (): #self._rewrite_if(node, bool(cond_node.evaluated)) treeutil.inlineIfStatement(node, bool(cond_node.evaluated)) for child in node.children: self.visit(child)
def visit_loop(self, node): loop_type = node.get("loopType") if loop_type == "IF": cond_node = node.children[0] if hasattr(cond_node, "evaluated") and cond_node.evaluated!=(): #self._rewrite_if(node, bool(cond_node.evaluated)) treeutil.inlineIfStatement(node, bool(cond_node.evaluated)) for child in node.children: self.visit(child)
def processEnvironmentClass(tree, usedVariantKeys): def useCheckNodes(node): variantNodes = treeutil.findVariablePrefix(node, "this.useCheck") for variantNode in variantNodes: #print variantNode.toXml() if not variantNode.hasParentContext("call/operand"): continue else: yield selectCallNode(variantNode) # ----------------------------------------------------------------- global verbose global fileId verbose = False fileId = "qx.core.Environment" for callNode in useCheckNodes(tree): # Simple sanity checks params = callNode.getChild("params") if len(params.children) != 1: log("Warning", "Expecting exactly one argument for qx.core.Environment.get. Ignoring this occurrence.", params) continue firstParam = params.getChildByPosition(0) if not isStringLiteral(firstParam): log("Warning", "First argument must be a string literal! Ignoring this occurrence.", firstParam) continue variantKey = firstParam.get("value"); if variantKey in usedVariantKeys: continue # need these checks at run time # Processing # are we in a if/loop condition expression, i.e. a "loop/expression/..." context? conditionNode = None loopType = None node = callNode while (node): if node.type == "expression" and node.parent and node.parent.type == "loop": conditionNode = node break node = node.parent if not conditionNode: continue # handle "if" statements if conditionNode.parent.get("loopType") == "IF": loopNode = conditionNode.parent # useCheck() call is only condition if callNode.parent == conditionNode: treeutil.inlineIfStatement(loopNode, False) # use 'else' branch (if any) return tree
def visit_loop(self, node): loop_type = node.get("loopType") nnode = node if loop_type == "IF": cond_node = node.children[0] if hasattr(cond_node, "evaluated"): value = bool(cond_node.evaluated) nnode, is_empty = treeutil.inlineIfStatement(node, value, inPlace=False) return nnode
def reduceLoop(startNode): treeModified = False conditionNode = None loopType = None # Can only reduce constant condition expression if startNode.type != "constant": return treeModified # Can only reduce a condition expression, # i.e. a "loop/expression/..." context node = startNode while node: if node.type == "expression" and node.parent and node.parent.type == "loop": conditionNode = node break node = node.parent if not conditionNode: return treeModified # handle "if" statements if conditionNode.parent.get("loopType") == "IF": loopNode = conditionNode.parent # startNode must be only condition if isDirectDescendant(startNode, conditionNode): value = startNode.get("value") if startNode.get("constantType") == "string": value = '"' + value + '"' # re-parse into an internal value value = json.loads(value) condValue = bool(value) # print "optimizing: if" treeutil.inlineIfStatement(loopNode, condValue) treeModified = True return treeModified
def processVariantGet(callNode, variantMap): treeModified = False fresult = [None] # input-output parameter for functions # Simple sanity checks params = callNode.getChild("params") if len(params.children) != 1: log("Warning", "Expecting exactly one argument for qx.core.Environment.get. Ignoring this occurrence.", params) return treeModified firstParam = params.getChildByPosition(0) if not isStringLiteral(firstParam): log("Warning", "First argument must be a string literal! Ignoring this occurrence.", firstParam) return treeModified variantKey = firstParam.get("value"); confValue, found = __keyLookup(variantKey, variantMap) if not found: return treeModified # Processing # are we in a if/loop condition expression, i.e. a "loop/expression/..." context? conditionNode = None loopType = None node = callNode while (node): if node.type == "expression" and node.parent and node.parent.type == "loop": conditionNode = node break node = node.parent if not conditionNode: return treeModified # handle "if" statements if conditionNode.parent.get("loopType") == "IF": loopNode = conditionNode.parent # get() call is only condition #if callNode.parent == conditionNode: if isDirectDescendant(callNode, conditionNode): # @deprecated if confValue in ["off", "false"]: varValue = False else: varValue = bool(confValue) treeutil.inlineIfStatement(loopNode, varValue) treeModified = True # a single comparison is the condition #elif (callNode.parent.parent.type == "operation" # and callNode.parent.parent.parent == conditionNode): elif isComparisonOperand(callNode, conditionNode, fresult): cmpNode = fresult[0] # check operator cmpOp = cmpNode.get("operator") if cmpOp in ["EQ", "SHEQ"]: cmpFcn = operator.eq elif cmpOp in ["NE", "SHNE"]: cmpFcn = operator.ne else: # unsupported compare cmpFcn = None if cmpFcn: # get other compare operand cmpOperands = cmpNode.getChildren(True) if cmpOperands[0] == callNode.parent: # switch between "first" and "second" otherValue = cmpOperands[1].getFirstChild(ignoreComments=True) else: otherValue = cmpOperands[0].getFirstChild(ignoreComments=True) if otherValue.type == "constant": constType = otherValue.get("constantType") if constType == "number": op1 = confValue op2 = int(otherValue.get("value")) elif constType == "string": op1 = confValue op2 = otherValue.get("value") elif constType == "boolean": # @deprecated if isinstance(confValue, types.StringTypes) and confValue in ["on","off"]: op1 = {"on":True,"off":False}[confValue] else: op1 = confValue op2 = {"true":True, "false":False}[otherValue.get("value")] elif constType == "null": op1 = confValue op2 = None # compare result if constType in ("number", "string", "boolean", "null"): treeutil.inlineIfStatement(loopNode, cmpFcn(op1,op2)) treeModified = True return treeModified
def processEnvironmentClass(node, variantMap): def myVariantNodes(node): variantNodes = treeutil.findVariablePrefix(node, "this.useCheck") for variantNode in variantNodes: print variantNode.toXml() if not variantNode.hasParentContext("call/operand"): continue else: yield variantNode treeModified = False #TODO: use myVariantNodes() # Simple sanity checks params = callNode.getChild("params") if len(params.children) != 1: log( "Warning", "Expecting exactly one argument for qx.core.Environment.get. Ignoring this occurrence.", params) return treeModified firstParam = params.getChildByPosition(0) if not isStringLiteral(firstParam): log( "Warning", "First argument must be a string literal! Ignoring this occurrence.", firstParam) return treeModified variantKey = firstParam.get("value") variantValue, found = __keyLookup(variantKey, variantMap) #if not variantKey in variantMap.keys(): if not found: return treeModified #else: # variantValue = variantMap[variantKey] # Processing # are we in a if/loop condition expression, i.e. a "loop/expression/..." context? conditionNode = None loopType = None node = callNode while (node): if node.type == "expression" and node.parent and node.parent.type == "loop": conditionNode = node break node = node.parent if not conditionNode: return treeModified # handle "if" statements if conditionNode.parent.get("loopType") == "IF": loopNode = conditionNode.parent # get() call is only condition if callNode.parent == conditionNode: #TODO: variantValue is not interesting, only if variantKey is in variantMap (!?) treeutil.inlineIfStatement( loopNode, bool(variantValue)) # take the truth val of the key value treeModified = True return treeModified
def processVariantGet(callNode, variantMap): treeModified = False fresult = [None] # input-output parameter for functions # Simple sanity checks params = callNode.getChild("params") if len(params.children) != 1: log( "Warning", "Expecting exactly one argument for qx.core.Environment.get. Ignoring this occurrence.", params) return treeModified firstParam = params.getChildByPosition(0) if not isStringLiteral(firstParam): log( "Warning", "First argument must be a string literal! Ignoring this occurrence.", firstParam) return treeModified variantKey = firstParam.get("value") confValue, found = __keyLookup(variantKey, variantMap) if not found: return treeModified # Processing # are we in a if/loop condition expression, i.e. a "loop/expression/..." context? conditionNode = None loopType = None node = callNode while (node): if node.type == "expression" and node.parent and node.parent.type == "loop": conditionNode = node break node = node.parent if not conditionNode: return treeModified # handle "if" statements if conditionNode.parent.get("loopType") == "IF": loopNode = conditionNode.parent # get() call is only condition #if callNode.parent == conditionNode: if isDirectDescendant(callNode, conditionNode): # @deprecated if confValue in ["off", "false"]: varValue = False else: varValue = bool(confValue) treeutil.inlineIfStatement(loopNode, varValue) treeModified = True # a single comparison is the condition #elif (callNode.parent.parent.type == "operation" # and callNode.parent.parent.parent == conditionNode): elif isComparisonOperand(callNode, conditionNode, fresult): cmpNode = fresult[0] # check operator cmpOp = cmpNode.get("operator") if cmpOp in ["EQ", "SHEQ"]: cmpFcn = operator.eq elif cmpOp in ["NE", "SHNE"]: cmpFcn = operator.ne else: # unsupported compare cmpFcn = None if cmpFcn: # get other compare operand cmpOperands = cmpNode.getChildren(True) if cmpOperands[ 0] == callNode.parent: # switch between "first" and "second" otherValue = cmpOperands[1].getFirstChild( ignoreComments=True) else: otherValue = cmpOperands[0].getFirstChild( ignoreComments=True) if otherValue.type == "constant": constType = otherValue.get("constantType") if constType == "number": op1 = confValue op2 = int(otherValue.get("value")) elif constType == "string": op1 = confValue op2 = otherValue.get("value") elif constType == "boolean": # @deprecated if isinstance(confValue, types.StringTypes) and confValue in [ "on", "off" ]: op1 = {"on": True, "off": False}[confValue] else: op1 = confValue op2 = { "true": True, "false": False }[otherValue.get("value")] elif constType == "null": op1 = confValue op2 = None # compare result if constType in ("number", "string", "boolean", "null"): treeutil.inlineIfStatement(loopNode, cmpFcn(op1, op2)) treeModified = True return treeModified