jaseci 1.4.2.5__py3-none-any.whl → 2.0.0__py3-none-any.whl

jaseci/jac/ir/ast_builder.py

@@ -1,249 +0,0 @@
-import os
-from antlr4 import ParseTreeListener
-from antlr4.error.ErrorListener import ErrorListener
-from jaseci.utils.utils import logger, parse_str_token
-from jaseci.jac.jac_parse.jacParser import jacParser, ParseTreeWalker
-from jaseci.jac.jac_parse.jacLexer import jacLexer
-from antlr4 import InputStream, CommonTokenStream
-from jaseci.jac.ir.ast import Ast
-
-
-class JacAstBuilder:
-    """
-    Jac Code to AST Tree
-    """
-
-    _ast_head_map = {}
-
-    def __init__(
-        self,
-        mod_name,
-        mod_dir="./",
-        jac_text=None,
-        start_rule="start",
-    ):
-        self.root = Ast(mod_name)
-        self._parse_errors = []
-        self._start_rule = start_rule
-        self._mod_dir = mod_dir
-        self.dependencies = []
-        if jac_text:
-            self.jac_code_to_ast(jac_text)
-
-    def jac_code_to_ast(self, jac_str):
-        """Parse language and build ast from string"""
-        JacAstBuilder._ast_head_map[self._mod_dir + self.root.loc[2]] = self
-        input_stream = InputStream(jac_str)
-        lexer = jacLexer(input_stream)
-        stream = CommonTokenStream(lexer)
-        errors = JacTreeError(self)
-        parser = jacParser(stream)
-        parser.removeErrorListeners()
-        parser.addErrorListener(errors)
-        tree = getattr(parser, self._start_rule)()
-        builder = JacTreeBuilder(builder=self, code=jac_str)
-        walker = ParseTreeWalker()
-        walker.walk(builder, tree)
-
-        if self._parse_errors:
-            logger.error(str(f"Parse errors encountered - {self}"))
-
-
-class JacTreeBuilder(ParseTreeListener):
-    """Converter class from Antlr trees to Jaseci Tree"""
-
-    def __init__(self, builder, code):
-        self.builder = builder
-        self.code = code
-        self.node_stack = []
-
-    def run_import_module(self, jac_ast):
-        """
-        import_module:
-            KW_IMPORT LBRACE (import_items | '*') RBRACE
-            KW_WITH STRING SEMI;
-
-        TODO: Check for duplicate imports and ignore if imported
-        """
-        kid = jac_ast.kid
-        fn = os.path.join(self.builder._mod_dir, parse_str_token(kid[-2].token_text()))
-        full_path = os.path.realpath(fn)
-        mod_name = os.path.basename(fn)
-        mdir = os.path.dirname(full_path) + "/"
-        from_mod = self.builder.root.loc[2]
-        logger.debug(f"Importing items from {mod_name} to {from_mod}...")
-        pre_build = None
-        if (mdir + mod_name) in JacAstBuilder._ast_head_map.keys():
-            pre_build = JacAstBuilder._ast_head_map[mdir + mod_name]
-        elif os.path.isfile(fn):
-            with open(fn, "r") as file:
-                jac_text = file.read()
-            pre_build = JacAstBuilder(
-                jac_text=jac_text,
-                mod_name=mod_name,
-                mod_dir=mdir,
-            )
-        else:
-            err = (
-                f"Module not found for import! {mod_name} from" + f" {from_mod} - {fn}"
-            )
-            self.builder._parse_errors.append(err)
-        if pre_build:
-            self.builder._parse_errors += pre_build._parse_errors
-            self.builder.dependencies += pre_build.dependencies
-            import_elements = list(
-                filter(lambda x: x.name == "element", pre_build.root.kid)
-            )
-            if kid[2].name == "STAR_MUL":
-                ret = import_elements
-            else:
-                ret = self.run_import_items(kid[2], import_elements)
-            for i in ret:
-                self.builder.dependencies.append(i)
-            return ret
-        else:
-            return []
-
-    def run_import_items(self, jac_ast, import_elements):
-        """
-        import_items:
-            WALKER_DBL_COLON (STAR_MUL | import_names) (
-                COMMA import_items
-            )?
-            | NODE_DBL_COLON (STAR_MUL | import_names) (
-                COMMA import_items
-            )?
-            | EDGE_DBL_COLON (STAR_MUL | import_names) (
-                COMMA import_items
-            )?
-            | GRAPH_DBL_COLON (STAR_MUL | import_names) (
-                COMMA import_items
-            )?
-            | KW_GLOBAL DBL_COLON (STAR_MUL | import_names) (
-                COMMA import_items
-            )?
-            | TYPE_DBL_COLON (STAR_MUL | import_names) (
-                COMMA import_items
-            )?;
-        """
-        kid = jac_ast.kid
-        type_name = (
-            "KW_" + kid[0].name.split("_")[0]
-            if not kid[0].name.startswith("KW_")
-            else kid[0].name
-        )
-        kid = kid[2:] if kid[1].name == "DBL_COLON" else kid[1:]
-        ret_elements = list(
-            filter(
-                lambda x: x in self.builder.dependencies
-                or x.kid[0].kid[0].name == type_name,
-                import_elements,
-            )
-        )
-        if kid[0].name == "import_names":
-            import_names = self.run_import_names(kid[0])
-            ret_elements = list(
-                filter(
-                    lambda x: x in self.builder.dependencies
-                    or x.kid[0].kid[1].token_text() in import_names,
-                    ret_elements,
-                )
-            )
-            if len(ret_elements) < len(import_names):
-                err = (
-                    f"{kid[0].loc[2]}: Line {kid[0].loc[0]}: "
-                    + "Module name not found!"
-                )
-                self.builder._parse_errors.append(err)
-
-        if kid[-1].name == "import_items":
-            return ret_elements + self.run_import_items(kid[-1], import_elements)
-
-        return ret_elements
-
-    def run_import_names(self, jac_ast):
-        """
-        import_names: NAME | LBRACE name_list RBRACE;
-        """
-        kid = jac_ast.kid
-        if kid[0].name == "NAME":
-            return [kid[0].token_text()]
-        else:
-            return self.run_name_list(kid[1])
-
-    def run_name_list(self, jac_ast):
-        """
-        name_list: NAME (COMMA NAME)*;
-        """
-        kid = jac_ast.kid
-        ret = []
-        for i in kid:
-            if i.name == "NAME":
-                ret.append(i.token_text())
-        return ret
-
-    def enterEveryRule(self, ctx):  # noqa
-        """Visits every node in antlr parse tree"""
-        if len(self.node_stack) == 0:
-            new_node = self.builder.root
-        else:
-            new_node = Ast(mod_name=self.builder.root.loc[2])
-        new_node.name = jacParser.ruleNames[ctx.getRuleIndex()]
-        new_node.loc[0] = ctx.start.line
-        if new_node.name == "architype":
-            new_node.src = self.get_code(ctx)
-        new_node.loc[1] = ctx.start.column
-
-        if len(self.node_stack) and new_node.name != "import_module":
-            self.node_stack[-1].kid.append(new_node)
-        self.node_stack.append(new_node)
-
-    def exitEveryRule(self, ctx):  # noqa
-        """Overloaded function that visits every node on exit"""
-        top = self.node_stack.pop()
-        if top.name == "import_module":
-            for i in self.run_import_module(top):
-                if i not in self.node_stack[-1].kid:
-                    self.node_stack[-1].kid.append(i)
-
-    def visitTerminal(self, node):  # noqa
-        """Visits terminals as walker walks, adds ast node"""
-        new_node = Ast(mod_name=self.builder.root.loc[2])
-        new_node.name = jacParser.symbolicNames[node.getSymbol().type]
-        new_node.loc[0] = node.getSymbol().line
-        new_node.loc[1] = node.getSymbol().column
-
-        token = {
-            "symbol": jacParser.symbolicNames[node.getSymbol().type],
-            "text": node.getSymbol().text,
-        }
-        new_node.loc[3]["token"] = token
-
-        self.node_stack[-1].kid.append(new_node)
-
-    def get_code(self, ctx):
-        out = ""
-        lines = self.code.split("\n")
-
-        for idx, i in enumerate(lines[ctx.start.line - 1 : ctx.stop.line]):
-            out += i
-            if idx != ctx.stop.line - 1:
-                out += "\n"
-
-        return out
-
-
-class JacTreeError(ErrorListener):
-    """Accumulate errors as parse tree is walked"""
-
-    def __init__(self, builder):
-        self.builder = builder
-
-    def syntaxError(  # noqa
-        self, recognizer, offendingSymbol, line, column, msg, e  # noqa
-    ):
-        """Add error to error list"""
-        root = self.builder.root
-        self.builder._parse_errors.append(
-            f"{str(root.loc[2])}: line {str(line)}:" f"{str(column)} - {root} - {msg}"
-        )

jaseci/jac/ir/jac_code.py

@@ -1,152 +0,0 @@
-"""
-Mix in for jac code object in Jaseci
-"""
-import json
-from jaseci.utils.utils import logger
-from jaseci.jac.ir.ast_builder import JacAstBuilder
-from jaseci.jac.ir.passes.schedule import multi_pass_optimizer
-from jaseci.jac.ir.ast import Ast
-import hashlib
-from pathlib import Path
-from os.path import dirname
-
-from jaseci.jac.ir.passes.printer_pass import PrinterPass
-
-# Used to check ir matches grammar of current Jaseci instance
-grammar_hash = hashlib.md5(
-    Path(dirname(__file__) + "/../jac.g4").read_text().encode()
-).hexdigest()
-
-
-class JacJsonEnc(json.JSONEncoder):
-    """Custom Json encoder for Jac ASTs"""
-
-    def default(self, obj):
-        if isinstance(obj, Ast):
-            retd = {}
-            for i in obj.__dict__.keys():
-                if not i.startswith("_"):
-                    retd[i] = obj.__dict__[i]
-            return retd
-        return super().default(obj)
-
-
-class JacJsonDec(json.JSONDecoder):
-    """Custom hook for decoding Jac ASTs"""
-
-    def __init__(self, *args, **kwargs):
-        json.JSONDecoder.__init__(self, object_hook=self.object_hook, *args, **kwargs)
-
-    def object_hook(self, obj):
-        if isinstance(obj, dict) and "loc" in obj and "kid" in obj:
-            ret = Ast(mod_name=obj["loc"][2])
-            for i in obj.keys():
-                setattr(ret, i, obj[i])
-            return ret
-        return obj
-
-
-def jac_ast_to_ir(jac_ast: Ast):
-    """Convert AST to IR string"""
-    return json.dumps(cls=JacJsonEnc, obj={"gram_hash": grammar_hash, "ir": jac_ast})
-
-
-def jac_ir_to_ast(ir: str):
-    """Convert IR string to AST"""
-    ir_load = json.loads(cls=JacJsonDec, s=ir)
-    if (
-        not isinstance(ir_load, dict)
-        or "gram_hash" not in ir_load
-        or ir_load["gram_hash"] != grammar_hash
-        or (not isinstance(ir_load["ir"], Ast) and not ir_load["ir"] is None)
-    ):
-        logger.error(
-            "Jac IR invalid or incompatible with current Jaseci "
-            f"(valid gram_hash: {grammar_hash}!"
-        )
-    return ir_load["ir"]
-
-
-class JacCode:
-    """Obj mixin to code pickling"""
-
-    def __init__(self, code_ir=None):
-        self.is_active = False
-        self.code_ir = None
-        self.code_sig = None
-        self._jac_ast = None
-        self.errors = []
-        self.apply_ir(code_ir)
-
-    def reset(self):
-        JacCode.__init__(self)
-
-    def refresh(self):
-        self._jac_ast = jac_ir_to_ast(self.code_ir) if self.code_ir else None
-        if self._jac_ast:
-            self.is_active = True
-        else:
-            self.is_active = False
-
-    def apply_ir(self, ir):
-        """Apply's IR to object"""
-        self.code_ir = (
-            ir.strip()
-            if (isinstance(ir, str))
-            else json.dumps(ir)
-            if (isinstance(ir, dict))
-            else jac_ast_to_ir(ir)
-        )
-        self.code_sig = hashlib.md5(self.code_ir.encode()).hexdigest()
-        JacCode.refresh(self)  # should disregard overloaded versions
-
-    def compile_jac(self, code, dir, start_rule="start", opt_level=4):
-        """Generate AST tree from Jac code text"""
-        tree = JacAstBuilder(
-            jac_text=code, start_rule=start_rule, mod_name=self.name, mod_dir=dir
-        )
-        # Must clear this state across compiles (so fresh imports dont use stale data)
-        JacAstBuilder._ast_head_map = {}
-
-        self.errors = tree._parse_errors
-        if tree._parse_errors:
-            logger.error(str(f"{self.name}: Invalid syntax in Jac code!"))
-            for i in tree._parse_errors:
-                logger.error(i)
-            return None
-
-        multi_pass_optimizer(
-            tree.root, opt_level=opt_level
-        )  # run analysis and optimizers
-
-        return tree.root
-
-    def get_jac_ast(self):
-        if not self._jac_ast:
-            self.refresh()
-        return self._jac_ast
-
-    def print_ir(self, to_screen=True):
-        irout = PrinterPass(ir=self.get_jac_ast(), to_screen=to_screen)
-        irout.run()
-        return irout.output
-
-    def register(self, code, dir, opt_level=4):
-        """
-        Parses Jac code and saves IR
-        """
-        start_rule = "start" if self.j_type == "sentinel" else self.j_type
-        tree = self.compile_jac(code, dir, start_rule=start_rule, opt_level=opt_level)
-
-        if not tree:
-            self.is_active = False
-        else:
-            self.apply_ir(tree)
-
-        if not self.is_active:
-            logger.error(str(f"{self.name}: Code not registered"))
-        return self.is_active
-
-    def ir_dict(self):
-        """Return IR as dictionary"""
-        return json.loads(self.code_ir)

jaseci/jac/ir/passes/__init__.py

@@ -1,6 +0,0 @@
-from jaseci.jac.ir.passes.ir_pass import IrPass  # noqa
-from jaseci.jac.ir.passes.pt_prune_pass import ParseTreePrunePass  # noqa
-from jaseci.jac.ir.passes.printer_pass import PrinterPass  # noqa
-from jaseci.jac.ir.passes.stats_pass import StatsPass  # noqa
-from jaseci.jac.ir.passes.codegen_pass import CodeGenPass  # noqa
-from jaseci.jac.ir.passes.ast_prune_pass import AstPrunePass  # noqa

jaseci/jac/ir/passes/ast_prune_pass.py

@@ -1,9 +0,0 @@
-from jaseci.jac.ir.passes.ir_pass import IrPass
-from base64 import b64encode
-
-
-class AstPrunePass(IrPass):
-    def enter_node(self, node):
-        if hasattr(node, "bytecode") and node.bytecode:
-            node.bytecode = b64encode(node.bytecode).decode()
-            node.kid = [] if node.name != "inc_assign" else [node.kid[0]]

jaseci/jac/ir/passes/codegen_pass.py

@@ -1,244 +0,0 @@
-from jaseci.jac.ir.passes import IrPass
-from jaseci.jac.jsci_vm.op_codes import JsCmp, JsOp, JsType
-from struct import pack
-
-from jaseci.utils.utils import parse_str_token
-
-
-def byte_length(val):
-    if type(val) == str:
-        return len(bytes(val, "unicode_escape"))
-    else:
-        return (val.bit_length() + 7) // 8
-
-
-def to_bytes(val):
-    if type(val) == str:
-        return bytes(val, "unicode_escape")
-    elif type(val) == float:
-        return pack("d", val)
-    elif type(val) == int:
-        return val.to_bytes(byte_length(val), "little")
-
-
-def has_bytecode(node):
-    if not hasattr(node, "bytecode"):
-        return False
-    return True
-
-
-def is_bytecode_complete(node):
-    for i in node.kid:
-        if not i.is_terminal() and not has_bytecode(i) and i.name != "cmp_op":
-            return False
-    return True
-
-
-class CodeGenPass(IrPass):
-    def __init__(self, debug_info=True, **kwargs):
-        super().__init__(**kwargs)
-        self.debug_info = debug_info
-        self.cur_loc = None
-        self.create_var_mode = 0
-
-    def emit(self, node, *items):
-        if not has_bytecode(node):
-            node.bytecode = bytearray()
-        node_loc = [node.loc[0], node.loc[2]]
-        if self.debug_info and self.cur_loc != node_loc:
-            debug_inst = [
-                JsOp.DEBUG_INFO,
-                byte_length(node_loc[0]),
-                to_bytes(node_loc[0]),
-            ]
-            if not self.cur_loc or self.cur_loc[1] != node_loc[1]:
-                debug_inst += [byte_length(node_loc[1]), to_bytes(node_loc[1])]
-            else:
-                debug_inst += [0]
-            self.cur_loc = node_loc
-            items = debug_inst + list(items)
-        for i in items:
-            if type(i) in [bytes, bytearray]:
-                node.bytecode += bytearray(i)
-            elif type(i) is str:
-                node.bytecode += bytearray(i, "utf-8")
-            else:
-                node.bytecode.append(i)
-
-    def enter_node(self, node):
-        # print("entering", node)
-        if hasattr(self, f"enter_{node.name}"):
-            getattr(self, f"enter_{node.name}")(node)
-
-    def exit_node(self, node):
-        # print("exiting", node)
-        if hasattr(self, f"exit_{node.name}"):
-            getattr(self, f"exit_{node.name}")(node)
-        if hasattr(node, "_create_flag"):
-            self.create_var_mode -= 1
-
-    def enter_expression(self, node):
-        kid = node.kid
-        if len(kid) > 1 and kid[-1].name == "assignment":
-            kid[-1]._create_flag = True
-            self.create_var_mode += 1
-
-    def exit_expression(self, node):  # TODO: Incomplete
-        kid = node.kid
-        if is_bytecode_complete(node):
-            for i in reversed(node.kid):
-                if has_bytecode(i):
-                    self.emit(node, i.bytecode)
-            if len(kid) > 1 and kid[1].name == "assignment":
-                self.emit(node, JsOp.ASSIGN)
-            elif len(kid) > 1 and kid[1].name == "copy_assign":
-                self.emit(node, JsOp.COPY_FIELDS)
-            elif len(kid) > 1 and kid[1].name == "inc_assign":
-                self.emit(node, JsOp.INCREMENT, JsCmp[kid[1].kid[0].name])
-
-    def exit_assignment(self, node):
-        if is_bytecode_complete(node):
-            if has_bytecode(node.kid[-1]):
-                self.emit(node, node.kid[-1].bytecode)
-
-    def exit_copy_assign(self, node):
-        if is_bytecode_complete(node):
-            if has_bytecode(node.kid[-1]):
-                self.emit(node, node.kid[-1].bytecode)
-
-    def exit_inc_assign(self, node):
-        if is_bytecode_complete(node):
-            if has_bytecode(node.kid[-1]):
-                self.emit(node, node.kid[-1].bytecode)
-
-    def exit_logical(self, node):
-        if is_bytecode_complete(node):
-            for i in reversed(node.kid):
-                if has_bytecode(i):
-                    self.emit(node, i.bytecode)
-            for i in node.kid:
-                if i.name == "KW_AND":
-                    self.emit(node, JsOp.AND)
-                elif i.name == "KW_OR":
-                    self.emit(node, JsOp.OR)
-
-    def exit_compare(self, node):
-        if is_bytecode_complete(node):
-            for i in reversed(node.kid):
-                if has_bytecode(i):
-                    self.emit(node, i.bytecode)
-            for i in node.kid:
-                if i.name == "NOT":
-                    self.emit(node, JsOp.COMPARE, JsCmp.NOT)
-                elif i.name == "cmp_op" and i.kid[0].name == "EE":
-                    self.emit(node, JsOp.COMPARE, JsCmp.EE)
-                elif i.name == "cmp_op" and i.kid[0].name == "LT":
-                    self.emit(node, JsOp.COMPARE, JsCmp.LT)
-                elif i.name == "cmp_op" and i.kid[0].name == "GT":
-                    self.emit(node, JsOp.COMPARE, JsCmp.GT)
-                elif i.name == "cmp_op" and i.kid[0].name == "LTE":
-                    self.emit(node, JsOp.COMPARE, JsCmp.LTE)
-                elif i.name == "cmp_op" and i.kid[0].name == "GTE":
-                    self.emit(node, JsOp.COMPARE, JsCmp.GTE)
-                elif i.name == "cmp_op" and i.kid[0].name == "NE":
-                    self.emit(node, JsOp.COMPARE, JsCmp.NE)
-                elif i.name == "cmp_op" and i.kid[0].name == "KW_IN":
-                    self.emit(node, JsOp.COMPARE, JsCmp.IN)
-                elif i.name == "cmp_op" and i.kid[0].name == "nin":
-                    self.emit(node, JsOp.COMPARE, JsCmp.NIN)
-
-    def exit_arithmetic(self, node):
-        if is_bytecode_complete(node):
-            for i in reversed(node.kid):
-                if has_bytecode(i):
-                    self.emit(node, i.bytecode)
-            for i in node.kid:
-                if i.name == "PLUS":
-                    self.emit(node, JsOp.ADD)
-                elif i.name == "MINUS":
-                    self.emit(node, JsOp.SUBTRACT)
-
-    def exit_term(self, node):
-        if is_bytecode_complete(node):
-            for i in reversed(node.kid):
-                if has_bytecode(i):
-                    self.emit(node, i.bytecode)
-            for i in node.kid:
-                if i.name == "STAR_MUL":
-                    self.emit(node, JsOp.MULTIPLY)
-                elif i.name == "DIV":
-                    self.emit(node, JsOp.DIVIDE)
-                elif i.name == "MOD":
-                    self.emit(node, JsOp.MODULO)
-
-    def exit_factor(self, node):
-        if is_bytecode_complete(node):
-            self.emit(node, node.kid[-1].bytecode)
-            if node.kid[0].name == "MINUS":
-                self.emit(node, JsOp.NEGATE)
-
-    def exit_power(self, node):
-        if is_bytecode_complete(node):
-            for i in reversed(node.kid):
-                if has_bytecode(i):
-                    self.emit(node, i.bytecode)
-            for i in node.kid:
-                if i.name == "POW":
-                    self.emit(node, JsOp.POWER)
-
-    def exit_atom(self, node):  # TODO: Incomplete
-        kid = node.kid
-        if kid[0].name == "INT":
-            val = int(kid[0].token_text())
-            self.emit(
-                node, JsOp.LOAD_CONST, JsType.INT, byte_length(val), to_bytes(val)
-            )
-        elif kid[0].name == "FLOAT":
-            val = float(kid[0].token_text())
-            self.emit(node, JsOp.LOAD_CONST, JsType.FLOAT, to_bytes(val))
-        elif kid[0].name == "multistring":
-            val = ""
-            for i in kid[0].kid:
-                val += parse_str_token(i.token_text())
-            str_len = byte_length(val)
-            self.emit(
-                node,
-                JsOp.LOAD_CONST,
-                JsType.STRING,
-                byte_length(str_len),
-                to_bytes(str_len),
-            )
-            if str_len > 0:
-                self.emit(node, to_bytes(val))
-        elif kid[0].name == "BOOL":
-            val = int(kid[0].token_text() == "true")
-            self.emit(node, JsOp.LOAD_CONST, JsType.BOOL, val)
-        elif kid[0].name == "NULL":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.NULL)
-        elif kid[0].name == "NAME":
-            name = kid[0].token_text()
-            if self.create_var_mode:
-                self.emit(node, JsOp.CREATE_VAR, byte_length(name), to_bytes(name))
-            else:
-                self.emit(node, JsOp.LOAD_VAR, byte_length(name), to_bytes(name))
-
-    def exit_any_type(self, node):
-        kid = node.kid
-        if kid[0].name == "TYP_STRING":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.STRING)
-        elif kid[0].name == "TYP_INT":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.INT)
-        elif kid[0].name == "TYP_FLOAT":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.FLOAT)
-        elif kid[0].name == "TYP_LIST":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.LIST)
-        elif kid[0].name == "TYP_DICT":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.DICT)
-        elif kid[0].name == "TYP_BOOL":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.BOOL)
-        elif kid[0].name == "KW_NODE":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.NODE)
-        elif kid[0].name == "KW_EDGE":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.EDGE)
-        elif kid[0].name == "KW_TYPE":
-            self.emit(node, JsOp.LOAD_CONST, JsType.TYPE, JsType.TYPE)

jaseci/jac/ir/passes/ir_pass.py

@@ -1,29 +0,0 @@
-class IrPass:
-    def __init__(self, ir=None):
-        self.ir = ir
-
-    def before_pass(self):
-        pass
-
-    def after_pass(self):
-        pass
-
-    def enter_node(self, node):
-        pass
-
-    def exit_node(self, node):
-        pass
-
-    def run(self):
-        self.before_pass()
-        self.traverse()
-        self.after_pass()
-        return self
-
-    def traverse(self, node=None):
-        if node is None:
-            node = self.ir
-        self.enter_node(node)
-        for i in node.kid:
-            self.traverse(i)
-        self.exit_node(node)