Ejemplo n.º 1
0
        def optimizeTree(tree):

            try:
                if ["comments"] == optimize:
                    # do a mere comment stripping
                    commentoptimizer.patch(tree)

                # "variants" prunes parts of the tree, so all subsequent optimizations benefit
                if "variants" in optimize:
                    variantoptimizer.search(tree, variantSet, self.id)

                # 'statics' has to come before 'privates', as it needs the original key names in tree
                # if features should be removed recursively, this has to be controlled on the calling
                # level.
                if "statics" in optimize:
                    if not featureMap:
                        console.warn("Empty feature map passed to static methods optimization; skipping")
                    elif self.type == "static" and self.id in featureMap:
                        featureoptimizer.patch(tree, self, featureMap)

                if "basecalls" in optimize:
                    basecalloptimizer.patch(tree)

                if "privates" in optimize:
                    privatesMap = load_privates()
                    privateoptimizer.patch(tree, id, privatesMap)
                    write_privates(privatesMap)

                if "strings" in optimize:
                    tree = self._stringOptimizer(tree)

                if "variables" in optimize:
                    variableoptimizer.search(tree)
            except Exception, e:
                raise RuntimeError("Problem optimizing %s; probably a syntax problem?!" % self.id)
Ejemplo n.º 2
0
    def optimize(self, tree, optimize=[], featureMap={}):

        def load_privates():
            cacheId  = privateoptimizer.privatesCacheId
            privates, _ = cache.read(cacheId, keepLock=True)
            if privates == None:
                privates = {}
            return privates

        def write_privates(globalprivs):
            cacheId  = privateoptimizer.privatesCacheId
            cache.write(cacheId, globalprivs)  # removes lock by default

        # -----------------------------------------------------------------------------

        if not optimize:
            return tree
        
        cache = self.context['cache']
        console = self.context['console']

        if ["comments"] == optimize:
            # do a mere comment stripping
            commentoptimizer.patch(tree)
            return tree

        # 'statics' has to come before 'privates', as it needs the original key names in tree
        if "statics" in optimize:
            if not featureMap:
                console.warn("Empty feature map passed to static methods optimization; skipping")
            elif self.type == 'static' and self.id in featureMap:
                featureoptimizer.patch(tree, self.id, featureMap[self.id])

        if "basecalls" in optimize:
            basecalloptimizer.patch(tree)

        if "privates" in optimize:
            privatesMap = load_privates()
            privateoptimizer.patch(tree, id, privatesMap)
            write_privates(privatesMap)

        if "strings" in optimize:
            tree = self._stringOptimizer(tree)

        if "variables" in optimize:
            variableoptimizer.search(tree)

        return tree
Ejemplo n.º 3
0
        def optimizeTree(tree):

            if "comments" in optimize:
                commentoptimizer.patch(tree)

            # "variants" prunes parts of the tree, so all subsequent optimizations benefit
            if "variants" in optimize:
                variantoptimizer.search(tree, variantSet, self.id)

            # 'statics' has to come before 'privates', as it needs the original key names in tree
            # if features should be removed recursively, this has to be controlled on the calling
            # level.
            if "statics" in optimize:
                if not featureMap:
                    console.warn("Empty feature map passed to static methods optimization; skipping")
                elif self.type == 'static' and self.id in featureMap:
                    optimzed_features = featureoptimizer.patch(tree, self, featureMap)
                    if optimzed_features:
                        optimized_statics_overall = load_features()
                        copy = optimized_statics_overall.copy()
                        copy.update(optimzed_features)
                        write_features(copy)

            if "basecalls" in optimize:
                basecalloptimizer.patch(tree)

            if "privates" in optimize:
                privatesMap = load_privates()
                privateoptimizer.patch(tree, id, privatesMap)
                write_privates(privatesMap)

            if "globals" in optimize:
                tree = globalsoptimizer.process(tree) # need to re-assign as this optimizer might change the root node

            if "strings" in optimize:
                tree = stringoptimizer.process(tree, self.id)

            if "variables" in optimize:
                variableoptimizer.search(tree)

            return tree
Ejemplo n.º 4
0
 def _baseCallOptimizeHelper(self, tree, id, variants):
     basecalloptimizer.patch(tree)
Ejemplo n.º 5
0
def run_compile(fileName, fileContent, options, args):
    fileId = fileName
    tokens = tokenizer.Tokenizer().parseStream(fileContent, fileName)
    if not options.quiet:
        print(">>> Creating tree...")
    tree = treegenerator.createFileTree(tokens)
    tree = scopes.create_scopes(tree)

    # optimizing tree
    if len(options.variants) > 0:
        if not options.quiet:
            print(">>> Selecting variants...")
        varmap = {}
        for entry in options.variants:
            pos = entry.index(":")
            varmap[entry[0:pos]] = entry[pos+1:]

        variantoptimizer.search(tree, varmap, fileId)

    if options.all or options.basecalls:
        if not options.quiet:
            print(">>> Optimizing basecalls...")
        basecalloptimizer.patch(tree)

    #if options.all or options.inline:
    #    if not options.quiet:
    #        print(">>> Optimizing inline...")
    #    inlineoptimizer.patch(tree)

    if options.all or options.strings:
        if not options.quiet:
            print(">>> Optimizing strings...")
        _optimizeStrings(tree, fileId)

    if options.all or options.variables:
        if not options.quiet:
            print(">>> Optimizing variables...")
        variableoptimizer.search(tree)

    if options.all or options.globals:
        if not options.quiet:
            print(">>> Optimizing globals...")
        tree = globalsoptimizer.process(tree)

    if options.all or options.privates:
        if not options.quiet:
            print(">>> Optimizing privates...")
        privates = {}
        if options.cache:
            cache = Cache(options.cache,
                interruptRegistry=interruptRegistry
            )
            privates, _ = cache.read(options.privateskey)
            if privates == None:
                privates = {}
        privateoptimizer.patch(tree, fileId, privates)
        if options.cache:
            cache.write(options.privateskey, privates)

    if not options.quiet:
        print(">>> Compiling...")
    result = [u'']
    result = Packer().serializeNode(tree, None, result, True)
    result = u''.join(result)
    print(result.encode('utf-8'))

    return
Ejemplo n.º 6
0
def main():
    parser = optparse.OptionParser(option_class=ExtendAction)

    usage_str = '''%prog [options] file.js,...'''
    parser.set_usage(usage_str)
    
    # General flags
    parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="verbose output mode (extra verbose)")
    parser.add_option("-q", "--quiet", action="store_true", dest="quiet", default=False, help="quiet output")

    # Optimization flags
    parser.add_option("-n", "--variables", action="store_true", dest="variables", default=False, help="optimize variables")
    parser.add_option("-s", "--strings", action="store_true", dest="strings", default=False, help="optimize strings")
    parser.add_option("-p", "--privates", action="store_true", dest="privates", default=False, help="optimize privates")
    parser.add_option("-b", "--basecalls", action="store_true", dest="basecalls", default=False, help="optimize basecalls")            
    parser.add_option("-i", "--inline", action="store_true", dest="inline", default=False, help="optimize inline")
    parser.add_option("-r", "--variants", action="store_true", dest="variantsopt", default=False, help="optimize variants")
    parser.add_option("-m", "--comments", action="store_true", dest="comments", default=False, help="optimize comments")
    parser.add_option("--all", action="store_true", dest="all", default=False, help="optimize all")            

    # Variant support
    parser.add_option("--variant", action="extend", dest="variants", metavar="KEY:VALUE", type="string", default=[], help="Selected variants")
    
    # Action modifier
    parser.add_option("--pretty", action="store_true", dest="pretty", default=False, help="print out pretty printed")            
    parser.add_option("--tree", action="store_true", dest="tree", default=False, help="print out tree")
    parser.add_option("--lint", action="store_true", dest="lint", default=False, help="ecmalint the file")

    # Cache support
    parser.add_option("-c", "--cache", dest="cache", metavar="CACHEPATH", type="string", default="", help="path to cache directory")
    parser.add_option("--privateskey", dest="privateskey", metavar="CACHEKEY", type="string", default="", help="cache key for privates")
    
    
    #
    # Process arguments
    #
    (options, args) = parser.parse_args(sys.argv[1:])
    
    if len(args) == 0:
        print ">>> Missing filename!"
        return

    if not options.quiet:
        print ">>> Parsing file..."
    fileName = args[0]
    fileContent = filetool.read(fileName, "utf-8")
    fileId = "xxx"
    tokens = tokenizer.parseStream(fileContent, fileName)
    
    if not options.quiet:
        print ">>> Creating tree..."
    tree = treegenerator.createFileTree(tokens)
    
    
    #
    # Optimizing tree
    #
    
    if len(options.variants) > 0:
        if not options.quiet:
            print ">>> Selecting variants..."
        varmap = {}
        for entry in options.variants:
            pos = entry.index(":")
            varmap[entry[0:pos]] = entry[pos+1:]
            
        variantoptimizer.search(tree, varmap, fileId)
    
    if options.all or options.basecalls:
        if not options.quiet:
            print ">>> Optimizing basecalls..."
        basecalloptimizer.patch(tree)   

    if options.all or options.inline:
        if not options.quiet:
            print ">>> Optimizing inline..."
        inlineoptimizer.patch(tree)   

    if options.all or options.strings:
        if not options.quiet:
            print ">>> Optimizing strings..."
        _optimizeStrings(tree, fileId)

    if options.all or options.variables:
        if not options.quiet:
            print ">>> Optimizing variables..."
        variableoptimizer.search(tree)

    if options.all or options.privates:
        if not options.quiet:
            print ">>> Optimizing privates..."
        privates = {}
        if options.cache:
            cache = Cache(options.cache, 
                interruptRegistry=interruptRegistry
            )
            privates, _ = cache.read(options.privateskey)
            if privates == None:
                privates = {}
        privateoptimizer.patch(tree, fileId, privates)
        if options.cache:
            cache.write(options.privateskey, privates)
         
         
    #
    # Output the result
    #
            
    if options.lint:
        if not options.quiet:
            print ">>> Executing ecmalint..."
        print "Needs implementation"
    
    elif options.tree:
        if not options.quiet:
            print ">>> Printing out tree..."
        print tree.toXml().encode('utf-8')
        
    else:
        if not options.quiet:
            print ">>> Compiling..."
        compiled = _compileTree(tree, options.pretty)
        print compiled.encode('utf-8')
Ejemplo n.º 7
0
def main():
    parser = optparse.OptionParser(option_class=ExtendAction)

    usage_str = '''%prog [options] file.js,...'''
    parser.set_usage(usage_str)
    
    # General flags
    parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="verbose output mode (extra verbose)")

    # Optimization flags
    parser.add_option("-n", "--variables", action="store_true", dest="variables", default=False, help="optimize variables")
    parser.add_option("-s", "--strings", action="store_true", dest="strings", default=False, help="optimize strings")
    parser.add_option("-p", "--privates", action="store_true", dest="privates", default=False, help="optimize privates")
    parser.add_option("-b", "--basecalls", action="store_true", dest="basecalls", default=False, help="optimize basecalls")            
    parser.add_option("-i", "--inline", action="store_true", dest="inline", default=False, help="optimize inline")
    parser.add_option("--all", action="store_true", dest="all", default=False, help="optimize all")            

    # Variant support
    parser.add_option("--variant", action="extend", dest="variants", metavar="KEY:VALUE", type="string", default=[], help="Selected variants")
    
    # Action modifier
    parser.add_option("--pretty", action="store_true", dest="pretty", default=False, help="print out pretty printed")            
    parser.add_option("--tree", action="store_true", dest="tree", default=False, help="print out tree")
    parser.add_option("--apiXml", action="store_true", dest="apiXml", default=False, help="print out api data as XML")
    parser.add_option("--apiJson", action="store_true", dest="apiJson", default=False, help="print out api data as JSON")
    parser.add_option("--lint", action="store_true", dest="lint", default=False, help="ecmalint the file")
    
    
    #
    # Process arguments
    #
    (options, args) = parser.parse_args(sys.argv[1:])
    
    if len(args) == 0:
        print ">>> Missing filename!"
        return

    print ">>> Parsing file..."
    fileName = args[0]
    fileContent = filetool.read(fileName, "utf-8")
    fileId = "xxx"
    tokens = tokenizer.parseStream(fileContent, fileName)
    
    print ">>> Creating tree..."
    tree = treegenerator.createSyntaxTree(tokens)
    
    
    #
    # Optimizing tree
    #
    
    if len(options.variants) > 0:
        print ">>> Selecting variants..."
        variantoptimizer.search(tree, options.variants, fileId)
    
    if options.all or options.basecalls:
        print ">>> Optimizing basecalls..."
        basecalloptimizer.patch(tree)   

    if options.all or options.inline:
        print ">>> Optimizing inline..."
        inlineoptimizer.patch(tree)   

    if options.all or options.strings:
        print ">>> Optimizing strings..."
        _optimizeStrings(tree, fileId)

    if options.all or options.variables:
        print ">>> Optimizing variables..."
        variableoptimizer.search(tree)

    if options.all or options.privates:
        print ">>> Optimizing privates..."
        privateoptimizer.patch(tree, fileId)
         
         
    #
    # Output the result
    #
    
    if options.apiXml or options.apiJson:
        (data, hasError) = api.createDoc(tree)  
        if hasError:
            print "Error in API docs!"
        elif options.apiXml:
            print ">>> API data as XML..."
            print data.toXml()
        else:
            print ">>> API data as JSON..."
            print data.toJson()
            
    elif options.lint:
        print ">>> Executing ecmalint..."
        print "Needs implementation"
    
    elif options.tree:
        print ">>> Printing out tree..."
        print tree.toXml()
        
    else:
        print ">>> Compiling..."
        compiled = _compileTree(tree, options.pretty)
        print compiled