bug fixes& code cleanups on parser

initial code-gen

engine/__init__.py

@@ -0,0 +1,13 @@
+from engine.ast import Context, ast_node
+import engine.ddl
+
+def initialize():
+    return Context()    
+
+def generate(ast, cxt):
+    for k in ast.keys():
+        if k in ast_node.types.keys():
+            root = ast_node.types[k](None, ast, cxt)
+
+
+__all__ = ["generate"]

engine/ast.py

@@ -0,0 +1,65 @@
+from typing import List
+
+
+class TableInfo:
+    def __init__(self, table_name, cols, cxt:'Context'):
+        # statics
+        self.table_name = table_name
+        self.columns = dict() # column_name, type
+        for c in cols:
+            self.columns[c['name']] = ((list(c['type'].keys()))[0], c)
+            k9name = self.table_name + c['name']
+            if k9name in cxt.k9cols_byname: # duplicate names?
+                root = cxt.k9cols_byname[k9name] 
+                k9name = k9name + root[1]
+                root[1] += 1
+            cxt.k9cols[c] = k9name
+            cxt.k9cols_byname[k9name] = (c, 1)
+        # runtime
+        self.n_cols = 0 # number of cols
+        self.order = [] # assumptions
+
+        cxt.tables_byname[self.table_name] = self # construct reverse map
+
+    def get_k9colname(self, cxt:'Context', col_name):
+        return cxt.k9cols[self.columns[col_name][1]] # well, this is gnarly.. will change later
+
+class Context:
+    def __init__(self): 
+        self.tables:List[TableInfo] = []
+        self.tables_byname = dict()
+        self.k9cols = dict()
+        self.k9cols_byname = dict()
+
+        self.k9code = ''
+
+    def add_table(self, table_name, cols):
+        tbl = TableInfo(table_name, cols, self)
+        self.tables.append(tbl)
+        return tbl
+
+    def emit(self, codelet):
+        self.k9code += codelet + '\n'
+
+    def __str__(self):
+        return self.k9code
+
+class ast_node:
+    types = dict()
+    def __init__(self, parent:"ast_node", node, context:Context = None):
+        self.context = parent.context if context is None else context
+        self.produce(node)
+        self.enumerate(node)
+        self.consume(node)
+    
+    def emit(self, code):
+        self.context.emit(code)
+
+    name = 'null'
+
+    def produce(self, _):
+        pass
+    def enumerate(self, _):
+        pass
+    def consume(self, _):
+        pass

engine/ddl.py

@@ -0,0 +1,22 @@
+from engine.ast import TableInfo, ast_node
+class create_table(ast_node):
+    name = 'create_table'
+    def produce(self, node):
+        ct = node[self.name]
+        tbl = self.context.add_table(ct['name'], ct['columns'])
+        # create tables in k9
+        for c in ct['columns']:
+            self.emit(f"{tbl.get_k9colname((list(c['name'].keys())))[0]}:()")
+
+class insert_into(ast_node):
+    name = 'insert'
+    def produce(self, node):
+        ct = node[self.name]
+        table:TableInfo = self.context.tables_byname[ct]
+        
+
+import sys, inspect
+
+for name, cls in inspect.getmembers(sys.modules[__name__]):
+    if inspect.isclass(cls) and issubclass(cls, ast_node):
+        ast_node.types[name] = cls