antlr_funcs.py

#! /usr/bin/env python
import sys

from antlr4 import *
from CLexer import CLexer
from CParser import CParser
from CListener import CListener
from code_expand import preprocess_string
import linked_list
import inspect
import codecs
import copy
import json
import re

debug=(False,True) # [0] print debug messages ; [1] generate debug log from debug messages
gbl_debug_msg=["",0,open("debug.log","w") if debug[1] else None,debug[1] ]

#This program assumes that C.g4 has been used to create
#The parser files CLexer.py Clistener.py and Cparser.py
#see /Documents/work/sefcom/gitpatch/antlr.md for more info
def main():
    """
    parser,tree = get_tree_from_file('test.c')
    print(tree.toStringTree(recog=parser))
    printer = KeyPrinter()
    walker = ParseTreeWalker()
    walker.walk(printer, tree)
    """
    if False:
        test_functs()
        args = get_func_args_from_inp("test_files/test.c", "simple_func",'file')
        print(args)
    #p,t =get_tree_from_file("test_files/service.i")
    p,t =get_tree_from_file("test.service.c.prev")
    exit()
    #p,t =get_tree_from_file("new_code_expand.c")
    print_ctx_bfs(t,"help")
    printer=ScopeListener()
    walker = ParseTreeWalker()
    walker.walk(printer,t)

    #for i,k in printer.scopes.items():
    #    print(f"{type(i)} => {get_string2(i)}")
    #    print(f"\t {k['func_ctx']}")
    #    print(f"\t {type(k['parent'])} => {get_string2(k['parent'])}")

    x=get_function_info(functions=get_functions(t),fscope=printer.scopes,dont_eval=[])

    """
    for key,members in inspect.getmembers(ctx):
        print(f"key = {key}\nmember={members}")
    """
def siblings(current):
    parent=current.parentCtx
    family=list(parent.getChildren())
    older=None
    younger=None
    if len(family)>0:
        for i in range(0,len(family)):
            if current==family[i]:
                break
        if i!=0:
            younger=family[0:i]
        if i!=len(family)-1:
            older=family[i+1:]
    return younger,older

def get_type_var_info(ctx):
    chld=list(ctx.getChildren())
    nodes=[]
    if len(chld)<=1:
        return None,None,None
    elif len(chld)==3:
        typ=get_string2(chld[0])
        node=chld[1]
        dec=list(find_multictx(node,[CParser.DeclaratorContext],None,None))
        nodes=[(typ,d) for d in dec]
    elif len(chld)==2:
        checkme=chld[0];
        c=list(checkme.getChildren())
        typ,node=(None,None)
        if len(c)==2:
           typ=get_string2(c[0])
           node=c[1]
        elif len(c)==3:
           typ=" ".join([get_string2(x) for x in c[0:2]])
           node=c[2]
        nodes=[(typ,node)]
    else:
        return None,None,None
    sym_dict=dict()
    up_nodes=list()
    for t,d in nodes:
        if d is None or len(list(d.getChildren()))<1 :
            continue
        c=list(d.getChild(0).getChildren())
        if len(c)>1:
            decl_info=""
            decl_nodes=list(c[1:])
            for i in range(1,len(c)):
                decl_info+=" "+get_string2(c[i])
            d_=get_string2(c[0])
            typ=t+" *"
            sym_dict[d_]=typ
            up_nodes.extend([(typ,c[0],decl_info)])
        up_nodes.extend([(t,d,None)])
        
    return nodes, sym_dict, up_nodes

class ScopeListener(CListener):
    cur_scopes=[ [], ]
    cur_declarations=[ [], ]
    cur_symbol_lut=dict()
    cur_assignments=[ [], ]
    cur_comparators=[ [], ]
    resolved=list()
    scopes=dict()
    # keys: k, list of nodes that are valid_parent_scopes
    #       k['ancestors'] : list of parent nodes
    #       k['ignore_nodes'] : list of nodes that should not be used to evaluate for variables declaration
    #       k['pscopes'] : list of preceding scope noes
    #       k['parent'] : immediate parent node
    #       k['children'] : children nodes
    #       k['func_ctx'] : function context
    valid_parent_scopes=[\
        CParser.CompoundStatementContext,\
        CParser.IterationStatementContext,\
        CParser.SelectionStatementContext,\
        CParser.FunctionDefinitionContext\
        ]
    current_fn_ctx=None
    current_scope=None

    valid_comparators=[\
        CParser.RelationalExpressionContext,\
        CParser.EqualityExpressionContext\
    ]
    
    func_names=[]

    def set_functions(self,funcs):
        if funcs and type(funcs)==list and len(funcs)>0:
            self.func_names=copy.copy(funcs)
        
    def get_basic_type_or_expression(self,node):
        n_=node
        typ=None
        expression=None
        un_op=None
        found=False
        i="-"
        dprint(f"[get_basic_type_or_expression]")
        dprint(f"{type(n_)} : {get_string2(n_)}")
        while (type(n_)!=CParser.PrimaryExpressionContext) and not found:
            c=list(n_.getChildren())
            dprint(f"{i}{type(n_)} {[type(x) for x in c]} {[get_string2(x) for x in c ]}")
            i+="-"
            if type(n_)==CParser.DigitSequence:
                typ="int"
                found=True
            elif type(n_) in [\
                           CParser.Identifier,\
                           CParser.Constant,\
                           CParser.PrimaryExpressionContext\
                           ]:
                expression=get_string2(n_)
                found=True
            elif type(n_)==CParser.CastExpressionContext:
                if len(c)>1 and not typ:
                    typ=get_string2(c[-3])
                    expression=get_string2(c[-1])
                    found=True
                n_=c[-1]
            elif type(n_)==CParser.PostfixExpressionContext:
                if type(c[0])==CParser.PrimaryExpressionContext:
                    n_=c[0]
                else:
                    if type(c[1])==CParser.TypeNameContext:
                        n_=c[1]
                    elif type(c[2])==CParser.TypeNameContext:
                        n_=c[2]
                    else:
                        print("Error: Bad PostFix Expression")
                        print(f"=>{get_string2(n_)}")
                        print("Exiting.")
                        import sys; sys.exit(-1)
            elif type(n_)==CParser.UnaryExpressionContext:
                if type(c[0])==CParser.UnaryOperatorContext and len(c)==2:
                    un_op=get_string2(c[0])
                    if un_op == '!':
                        typ="bool"
                        found=True
                if type(c[-1]) in [ CParser.PostfixExpressionContext,\
                                    CParser.CastExpressionContext,\
                                    CParser.Identifier ]:
                    n_=c[-1]
                elif type(c[-2])==CParser.TypeNameContext:
                    n_=c[-2]
                else:
                    print("Error: Bad Unary Expression")
                    print(f"=>{get_string2(n_)}")
                    print("Exiting.")
                    import sys; sys.exit(-1)
            elif type(n_) in [CParser.AndExpressionContext,\
                              CParser.ExclusiveOrExpressionContext,\
                              CParser.InclusiveOrExpressionContext,\
                              CParser.ShiftExpressionContext,\
                              CParser.AdditiveExpressionContext,\
                              CParser.MultiplicativeExpressionContext\
                             ]:
                n_=c[0]
            elif type(n_) in [CParser.LogicalAndExpressionContext,\
                             CParser.RelationalExpressionContext,\
                             CParser.EqualityExpressionContext,\
                             CParser.LogicalOrExpressionContext\
                             ]:
                if len(c)>1:
                    typ="bool"
                    found=True
                else:
                    n_=c[0]
                pass
            else:
                print("Error: Bad Type Expression")
                print(f"type {type(n_)} =>{get_string2(n_)}")
                print("Exiting.")
                import sys; sys.exit(-1)
        # end of while ^^
        if not found:
            expression=get_string2(n_);
        return (typ,expression,un_op)

    def is_comparator(self,node):
        if type(node) not in self.valid_comparators:
            return False,None
        else:
            children=list(node.getChildren())
            if len(children)>1:
                dprint(f"[is_comparator] {type(node)} => {get_string2(node)}")   
                vals=list()
                for i in range(0,len(children),2):
                    dprint(f"[{i}] {type(children[i])} => {get_string2(children[i])}")   
                    vals.append(children[i]) 
                return True,vals
            else:
                return False,None

            
    def find_pruned_nodes(self):
        for i in list(self.scopes.keys()):
            self.prune(i)

    def prune(self,start):
        pruned_nodes=[]
        for i in self.scopes[start]['ancestors']:
            if i:
                x=self.right_siblings(i)
                if x:
                    pruned_nodes.extend(x)
        self.scopes[start]['ignore_nodes']=pruned_nodes

    def siblings(self,current):
        return siblings(current)

    def left_siblings(self,current):
        return self.siblings(current)[0]

    def right_siblings(self,current):
        return self.siblings(current)[1]

    def scopeleft_siblings(self,current):
        if type(current)==CParser.FunctionDefinitionContext:
            return None
        else:
            parent=current.parentCtx
            family=list(parent.getChildren())
            younger=None
            if len(family)>0:
                for i in range(0,len(family)):
                    if current==family[i]:
                        break
                younger=family[0:i]
                return younger
            else:
                return self.left_siblings(parent)

    def scoperight_siblings(self,current):
        if type(current)==CParser.FunctionDefinitionContext:
            return None
        else:
            parent=current.parentCtx
            family=list(parent.getChildren())
            older=None
            if len(family)>0:
                for i in range(0,len(family)):
                    if current==family[i]:
                        break
                older=family[i+1:]
                return older
            else:
                return self.scoperight_siblings(parent)

    def get_last_child(self,node):
        n=node
        if type(n)==tree.Tree.ErrorNodeImpl:
            print(f"ERROR: We have a parsetree error with {get_string2(n)} [type={type(n)}]")
            print(f"Parent node: {get_string2(n.parentCtx)} [type={type(n.parentCtx)}]")
            return n
        while type(n) not in [ tree.Tree.TerminalNodeImpl, tree.Tree.ErrorNodeImpl ]:
            n=list(n.getChildren())[-1]
            if type(n)==tree.Tree.ErrorNodeImpl:
                print(f"ERROR: We have a parsetree error with {get_string2(n)} [type={type(n)}]")
                print(f"Parent node: {get_string2(n.parentCtx)} [type={type(n.parentCtx)}]")
        return n
    

    def get_scope_limits(self,node):
        children=list(node.getChildren())
        valid_scope=[node]
        invalid_scope=[]
        corner=False
        if type(node)==CParser.FunctionDefinitionContext:
            pass
        if type(node)==CParser.CompoundStatementContext:
            pass
        if type(node)==CParser.SelectionStatementContext:
            valid_scope=children[:5] # StatementContext
            if len(children)>5:
                invalid_scope=children[5:]
            else:
                corner=True
        if type(node)==CParser.IterationStatementContext:
            valid_scope=children[:5] # StatementContext
            if len(children)>5:
                invalid_scope=children[5:]
            else:
                corner=True
        return ((valid_scope,invalid_scope),(node,self.get_last_child(valid_scope[-1])),corner)

    def is_else(self,node):
        return type(node)==tree.Tree.TerminalNodeImpl and node.getText()=="else"

    def getParentScopes(self,start):
        # add the current node to the previous hierarchy's descendant list
        if self.current_scope:
            self.cur_symbol_lut[start]=copy.copy(self.cur_symbol_lut[self.current_scope])
        else:
            self.cur_symbol_lut[start]=dict()
            #for i,c in enumerate(list(start.getChildren())):
            #    print(f" {i} : {type(c)}")
            #    if i==1:
            #        print(f" {i}[0] : {get_string2(c.getChild(0).getChild(0))}")
            #        print(f" {i}[1] : {get_string2(c.getChild(0).getChild(1))}")
            #        print(f" {i}[2] : {get_string2(c.getChild(0).getChild(2))}")
            #        print(f" {i}[2] : type : {type(c.getChild(0).getChild(2))}")

                    
        self.current_scope=start
        self.cur_scopes[-1].append(start)
        # create a new list to accumulate descendants
        self.cur_scopes.append([])
        self.cur_declarations.append([])
        self.cur_assignments.append([])
        self.cur_comparators.append([])
        pscopes=[]
        p=[start]
        siblings=self.siblings(start)
        self.scopes[start]=dict()
        self.scopes[start]['children']=list(start.getChildren())
        self.scopes[start]['parent']=start.parentCtx
        self.scopes[start]['func_ctx']=self.current_fn_ctx
        self.scopes[start]['scope_limits']=self.get_scope_limits(start)
        self.scopes[start]['siblings']=siblings
        done=(type(start)==CParser.FunctionDefinitionContext)
        CASE=0
        while not done:
            dprint(f"{CASE} : {type(p[-1])} [start? {p[-1]==start}]")
            CASE+=1
            if p[-1] == start:
                p.append(p[-1].parentCtx)
                continue
            if type(p[-1]) in self.valid_parent_scopes:
                capture=True
                x=min(5,len(p))
                dprint(f"Valid scope parent: {type(p[-1])}")
                dprint(f" ===> Last {x} parents! ")
                for i in range(0,x):
                    dprint(f" [{i}] : {type(p[i-x])} ")
                    # [ {get_string2(p[x-i-1])} ]")
                if type(p[-1])==CParser.SelectionStatementContext:
                    lsiblings=self.left_siblings(p[-2])
                    for i in range(0,len(lsiblings)):
                        dprint(f" sibling [{i}] : {type(lsiblings[i])} [ {get_string2(lsiblings[i])} ]")
                        pass
                    if self.is_else(lsiblings[-1]):
                        dprint(f"In an else condition, don't capture {type(p[-1])}")
                        capture=False
                if capture:
                    pscopes.append(p[-1])
                    if p[-1] in self.resolved:
                        dprint(f"RESOLVED : {type(start)} => {type(p[-1])} ")
                        last=p.pop()
                        if type(last) == CParser.FunctionDefinitionContext:
                            done=True
                            break
                        else:
                            x=self.scopes.get(last,None)
                            if x:
                                dprint(f" converged parent => {type(last)}")
                                pscopes.extend(x['pscopes'])
                                p.extend(x['ancestors'])
                                done=True
                                break
            p.append(p[-1].parentCtx)

        self.scopes[start]['pscopes']=pscopes
        self.scopes[start]['ancestors']=p
        self.resolved.append(start)

    def exitExternalDeclaration(self,ctx:CParser.ExternalDeclarationContext):
        pass

    def enterExternalDeclaration(self,ctx:CParser.ExternalDeclarationContext):
        pass

    def exitCompoundStatement(self,ctx:CParser.CompoundStatementContext):
        x=self.cur_scopes.pop()
        self.current_scope=self.cur_scopes[-1][-1]
        dprint(f"Descendants of {type(ctx)} : {get_string2(ctx)}")
        for i in range(0,len(x)):
            dprint(f" {i} : {type(x[i])}   [ {get_string2(x[i])} ]")
        self.scopes[ctx]['descendants']=copy.copy(x)
        x=self.cur_symbol_lut[ctx]
        self.scopes[ctx]['sym_lut']=copy.copy(x)
        x=self.cur_declarations.pop()
        self.scopes[ctx]['decls']=copy.copy(x)
        x=self.cur_assignments.pop()
        self.scopes[ctx]['assigns']=copy.copy(x)
        s=[(n[0],n[1],n[2],get_string2(n[3])) for n in x]
        dprint(f"Assigns = {s}")
        x=self.cur_comparators.pop()
        self.scopes[ctx]['compares']=copy.copy(x)
        s=[(n[0],n[1],n[2],type(n[3]),get_string2(n[3])) for n in x]
        dprint(f"Compares = {s}")
        pass

    def enterCompoundStatement(self,ctx:CParser.CompoundStatementContext):
        x=self.scopes.get(ctx,None)
        if x:
            print("[DuplicateNodeError] {get_string2(ctx)}")
        else:
            self.getParentScopes(ctx)
        pass

    def exitSelectionStatement(self, ctx:CParser.SelectionStatementContext):
        x=self.cur_scopes.pop()
        self.current_scope=self.cur_scopes[-1][-1]
        dprint(f"Descendants of {type(ctx)} : {get_string2(ctx)}")
        for i in range(0,len(x)):
            dprint(f" {i} : {type(x[i])}   [ {get_string2(x[i])} ]")
        self.scopes[ctx]['descendants']=copy.copy(x)
        x=self.cur_symbol_lut[ctx]
        self.scopes[ctx]['sym_lut']=copy.copy(x)
        x=self.cur_declarations.pop()
        self.scopes[ctx]['decls']=copy.copy(x)
        x=self.cur_assignments.pop()
        self.scopes[ctx]['assigns']=copy.copy(x)
        x=self.cur_comparators.pop()
        self.scopes[ctx]['compares']=copy.copy(x)
        pass

    def enterSelectionStatement(self, ctx:CParser.SelectionStatementContext):
        x=self.scopes.get(ctx,None)
        if x:
            print("[DuplicateNodeError] {get_string2(ctx)}")
        else:
            self.getParentScopes(ctx)
        pass

    def exitIterationStatement(self, ctx:CParser.IterationStatementContext):
        x=self.cur_scopes.pop()
        self.current_scope=self.cur_scopes[-1][-1]
        dprint(f"Descendants of {type(ctx)} : {get_string2(ctx)}")
        for i in range(0,len(x)):
            dprint(f" {i} : {type(x[i])}   [ {get_string2(x[i])} ]")
        self.scopes[ctx]['descendants']=copy.copy(x)
        x=self.cur_symbol_lut[ctx]
        self.scopes[ctx]['sym_lut']=copy.copy(x)
        x=self.cur_declarations.pop()
        self.scopes[ctx]['decls']=copy.copy(x)
        x=self.cur_assignments.pop()
        self.scopes[ctx]['assigns']=copy.copy(x)
        x=self.cur_comparators.pop()
        self.scopes[ctx]['compares']=copy.copy(x)
        pass

    def enterIterationStatement(self, ctx:CParser.IterationStatementContext):
        x=self.scopes.get(ctx,None)
        if x:
            print("[DuplicateNodeError] {get_string2(ctx)}")
        else:
            self.getParentScopes(ctx)
        pass

    def enterFunctionDefinition(self,ctx:CParser.FunctionDefinitionContext):
        self.current_fn_ctx=ctx
        x=self.scopes.get(ctx,None)
        c=list(ctx.getChildren())
        dprint(f"[enterFunctionDefinition]")
        dprint(f"{[(type(c[x]),get_string2(c[x])) for x in range(0,len(c)-1)]}")
        if x:
            print("[DuplicateNodeError] {get_string2(ctx)}")
        else:
            self.getParentScopes(ctx)
        pass

    def exitFunctionDefinition(self,ctx:CParser.FunctionDefinitionContext):
        self.find_pruned_nodes()
        self.current_fn_ctx=None
        x=self.cur_scopes.pop()
        self.current_scope=None
        dprint(f"Descendants of {type(ctx)} : {get_string2(ctx)}")
        for i in range(0,len(x)):
            dprint(f" {i} : {type(x[i])}   [ {get_string2(x[i])} ]")
        self.scopes[ctx]['descendants']=copy.copy(x)
        x=self.cur_symbol_lut[ctx]
        self.scopes[ctx]['sym_lut']=copy.copy(x)
        x=self.cur_declarations.pop()
        self.scopes[ctx]['decls']=copy.copy(x)
        x=self.cur_assignments.pop()
        self.scopes[ctx]['assigns']=copy.copy(x)
        x=self.cur_comparators.pop()
        self.scopes[ctx]['compares']=copy.copy(x)
        pass

    def exitRelationalExpression(self, ctx:CParser.RelationalExpressionContext):
        pass
    def enterRelationalExpression(self, ctx:CParser.RelationalExpressionContext):
        comp,values=self.is_comparator(ctx)
        if comp:
            typ=None
            expr=None
            un_op=None
            dprint(f"[enterRelationalExpression] : {type(ctx)} => {get_string2(ctx)}")
            dprint(f"=> {[get_string2(x) for x in values]}")
            for x in values:
                #str_x=get_string2(x)
                typ,expr,un_op=self.get_basic_type_or_expression(x)
                if typ != None:
                    dprint(f"FOUND IT! [1.1]  {typ} : {expr}")
                    break
                typ=self.cur_symbol_lut[self.current_scope].get(expr,None)
                if typ != None:
                    dprint(f"FOUND IT! [1.2]  {typ} : {expr}")
                    break
            # note from pdr: i don't think this is particularly robust, but oh well. good luck to me
            if not typ:
                typ="UNDEF"
                if un_op:
                    if un_op in ['+','-','~']:
                        typ='int'
                    elif un_op in ['!']:
                        typ='bool'
            if un_op=="*" and "*" in typ:
                typ=typ.replace(" *","",1)
            elif un_op=="&":
                typ=typ+" *"
            dprint(f"Resolved type: [1.3]  {typ} : {expr}")
            for x in values:
                # the point here is to somewhat take advantage of existing tuple structure for reuse
                self.cur_comparators[-1].extend([(typ,"","",x)])
        pass

    def exitEqualityExpression(self, ctx:CParser.EqualityExpressionContext):
        pass
    def enterEqualityExpression(self, ctx:CParser.EqualityExpressionContext):
        comp,values=self.is_comparator(ctx)
        if comp:
            typ=None
            expr=None
            un_op=None
            dprint(f"[enterEqualityExpression] : {type(ctx)} => {get_string2(ctx)}")
            dprint(f"=> {[get_string2(x) for x in values]}")
            for x in values:
                #str_x=get_string2(x)
                typ,expr,un_op=self.get_basic_type_or_expression(x)
                if typ != None:
                    dprint(f"FOUND IT! [2.1]  {typ} : {expr}")
                    break
                typ=self.cur_symbol_lut[self.current_scope].get(expr,None)
                if typ != None:
                    dprint(f"FOUND IT! [2.2]  {typ} : {expr}")
                    break
            if not typ:
                typ="UNDEF"
                if un_op:
                    if un_op in ['+','-','~']:
                        typ='int'
                    elif un_op in ['!']:
                        typ='bool'
            if un_op=="*" and "*" in typ:
                typ=typ.replace(" *","",1)
            elif un_op=="&":
                typ=typ+" *"
            dprint(f"Resolved type: [2.3]  {typ} : {expr}")
            for x in values:
                self.cur_comparators[-1].extend([(typ,"","",x)])
        pass

    def exitAssignmentExpression(self, ctx:CParser.AssignmentExpressionContext):
        pass
    def enterAssignmentExpression(self, ctx:CParser.AssignmentExpressionContext):
        if self.current_scope is None or self.cur_symbol_lut[self.current_scope] is None:
            dprint(f"[WARNING] : self.current_scope = '{self.current_scope}'")
            dprint(f"[WARNING] : self.cur_symbol_lut[self.current_scope] = '{self.cur_symbol_lut.get(self.current_scope,None)}'")
            dprint(f"[WARNING] ctx : {get_string2(ctx)}")
            pass
            
        chld=list(ctx.getChildren())
        if len(chld)==3 and "=" in get_string2(chld[1]):
            #nodes=get_string2(ctx)
            ovar=get_string2(chld[0])
            var_ext=ovar.split('[',1) if '[' in ovar else [ovar,""]
            var=var_ext[0]
            ext=var_ext[1]
            if ext!="":
                ext="["+ext
            nodes=chld[2]
            dprint(f"var: {var} ({ovar}) = {get_string2(nodes)}")
            typ=self.cur_symbol_lut[self.current_scope].get(var,"UNDEF") 
            dprint(f"var: {typ} {var} ({ovar}) = {get_string2(nodes)}")
            if ovar!=var:
                typ=typ.rsplit(' *',1)[0]
            self.cur_assignments[-1].extend([(typ,var,ext,nodes)])
        else:
            pass
        pass

    #def exitInitializer(self, ctx:CParser.InitializerContext):
    #    pass
    #def enterInitializer(self, ctx:CParser.InitializerContext):
    #    if type(ctx.getChild(0))==CParser.AssignmentExpressionContext:
    #        nodes=get_string2(ctx)
    #        print(f"Initializer: {nodes}")
    #        self.cur_assignments[-1].extend([nodes])
    #    pass

    #rules_with_declarations=[CParser.ForDeclarationContext,CParser.DeclarationContext]


    def exitDeclaration(self, ctx:CParser.DeclarationContext):
        pass
    def enterDeclaration(self, ctx:CParser.DeclarationContext):
        if self.current_scope==None:
            pass
        else:
            chld=list(ctx.getChildren())
            nodes=[]
            dprint(f"[enterDeclaration] {[(type(c),get_string2(c)) for c in chld]}")
            if len(chld)<=1:
                return
            elif len(chld)==3:
                typ=get_string2(chld[0])
                node=chld[1]
                dec=list(find_multictx(node,[CParser.DeclaratorContext],None,None))
                nodes=[(typ,d) for d in dec]
            elif len(chld)==2:
                checkme=chld[0];
                c=list(checkme.getChildren())
                typ,node=(None,None)
                if len(c)==2:
                   typ=get_string2(c[0])
                   node=c[1]
                elif len(c)==3:
                   typ=" ".join([get_string2(x) for x in c[0:2]])
                   node=c[2]
                nodes=[(typ,node)]
            else:
                return

            sym_dict=dict()
            up_nodes=list()
            i=-1
            for t,d in nodes:
                i+=1
                if d is None or len(list(d.getChildren()))<1 :
                    continue
                if t in self.func_names:
                    continue
                c=list(d.getChild(0).getChildren())
                if len(c)>1:
                    decl_info=""
                    decl_nodes=list(c[1:])
                    for i in range(1,len(c)):
                        decl_info+=" "+get_string2(c[i])
                    d_=get_string2(c[0])
                    typ=t+" *"
                    sym_dict[d_]=typ
                    dprint(f"[A-t-{i}] sym_dict [{get_string2(d_)}] = {typ} ")
                    up_nodes.extend([(typ,c[0],decl_info)])
                    if type(c[0])!=tree.Tree.TerminalNodeImpl:
                        c0=list(c[0].getChildren())
                        if len(c0)>1:
                            dl_info=""
                            dl_nodes=list(c0[1:])
                            for i in range(1,len(c)):
                                dl_info+=" "+get_string2(c[i])
                            dl_info+=decl_info
                            typ+="*"
                            d_=get_string2(c0[0])
                            sym_dict[d_]=typ
                            dprint(f"[B-t-{i}] sym_dict [{get_string2(d_)}] = {typ} ")
                            up_nodes.extend([(typ,c0[0],dl_info)])
                        
                up_nodes.extend([(t,d,None)])
                
                dprint(f"[C-t-{i}] sym_dict [{get_string2(d)}] = {t} ")
                sym_dict[get_string2(d)]=t
                
            self.cur_declarations[-1].extend(up_nodes)
            try:
                self.cur_symbol_lut[self.current_scope].update(sym_dict)
            except Exception as e:
                print(e)
                print(f"=> {type(self.current_scope)}")
                print(f"ctx => {get_string2(ctx)}")
                raise(e)
        pass

    def exitForDeclaration(self, ctx:CParser.ForDeclarationContext):
        pass
    def enterForDeclaration(self, ctx:CParser.ForDeclarationContext):
        chld=list(ctx.getChildren())
        if len(chld)>=2:
            typ=get_string2(chld[0])
            try:
               node=chld[1]
            except:
               print(f"[enterForDeclaration] len(chld)={len(chld)}")
               raise
            dec=list(find_multictx(node,[CParser.DeclaratorContext],None,None))
            dprint(f"[enterForDeclaration]")
            nodes=[(typ,d) for d in dec]
            up_nodes=list()
            sym_dict=dict()
            if len(nodes)==0:
                return
            i=-1
            for t,d in nodes:
                i+=1
                if d is None or len(list(d.getChildren()))<1 :
                    continue
                if t in self.func_names:
                    continue
                c=list(d.getChild(0).getChildren())
                if len(c)>1:
                    decl_info=""
                    decl_nodes=list(c[1:])
                    for i in range(1,len(c)):
                        decl_info+=" "+get_string2(c[i])
                    d_=get_string2(c[0])
                    typ=t+" *"
                    sym_dict[d_]=typ
                    dprint(f"[A-t-{i}] sym_dict [{get_string2(d_)}] = {typ}  [# children={len(c)}]")
                    up_nodes.extend([(typ,c[0],decl_info)])
                    if type(c[0])!=tree.Tree.TerminalNodeImpl:
                        c0=list(c[0].getChildren())
                        if len(c0)>1:
                            dl_info=""
                            dl_nodes=list(c0[1:])
                            for i in range(1,len(c)):
                                dl_info+=" "+get_string2(c[i])
                            dl_info+=decl_info
                            typ+="*"
                            d_=get_string2(c0[0])
                            sym_dict[d_]=typ
                            dprint(f"[B-t-{i}] sym_dict [{get_string2(d_)}] = {typ} ")
                            up_nodes.extend([(typ,c0[0],dl_info)])
                up_nodes.extend([(t,d,None)])
                
                dprint(f"[C-t-{i}] sym_dict [{get_string2(d)}] = {t} ")
                sym_dict[get_string2(d)]=t
                
            self.cur_declarations[-1].extend(up_nodes)
            self.cur_symbol_lut[self.current_scope].update(sym_dict)
        pass

    def exitParameterDeclaration(self, ctx:CParser.ParameterDeclarationContext):
        pass
    def enterParameterDeclaration(self, ctx:CParser.ParameterDeclarationContext):
        if not self.current_scope:
            dprint("[CORNER CASE] Parameter Declaration, current_scope is None?")
            dprint(f"current: {get_string2(ctx)}")
        else:
            chld=list(ctx.getChildren())
            typ=get_string2(chld[0])
            if len(chld)>1 and typ!=CParser.DeclarationSpecifiers2Context:
                node=chld[1]
                dprint(f"ParameterDeclaration : type = {typ}, var = {get_string2(node)} [type={type(node)}]")
                dec=[node]
                if type(node)!=CParser.DeclaratorContext:
                    dec=list(find_multictx(node,[CParser.DeclaratorContext],None,None))
                dprint(f" dec = {[get_string2(d) for d in dec]}")
                nodes=[(typ,d) for d in dec]
                up_nodes=list()
                sym_dict=dict()
                for t,d in nodes:
                    if d is None or len(list(d.getChildren()))<1 :
                        continue
                    if t in self.func_names:
                        continue
                    dprint(f"[enterParameterDeclaration] {t} : {get_string2(d)}")
                    c=list(d.getChild(0).getChildren())
                    if len(c)>1:
                        decl_info=""
                        decl_nodes=list(c[1:])
                        for i in range(1,len(c)):
                            decl_info+=" "+get_string2(c[i])
                        d_=get_string2(c[0])
                        typ=t+" *"
                        sym_dict[d_]=typ
                        dprint(f"sym_dict [{get_string2(d_)}] = {typ} ")
                        up_nodes.extend([(typ,c[0],decl_info)])
                    up_nodes.extend([(t,d,None)])
                
                self.cur_declarations[-1].extend(up_nodes)
                for a,b in nodes:
                    if b is None or len(list(b.getChildren()))<1 :
                        continue
                    if a in self.func_names:
                        continue
                    dprint(f"sym_dict [{get_string2(b)}] = {a} ")
                    sym_dict[get_string2(b)]=a
                self.cur_symbol_lut[self.current_scope].update(sym_dict)
            else:
                dprint(f"[CORNER CASE] ParameterDeclaration : children = {[(type(v),get_string2(v)) for v in chld]} => setting default type to 'int'")
                sym_dict=dict()
                sym_dict[get_string2(chld[0])]="int";
                self.cur_symbol_lut[self.current_scope].update(sym_dict)
                pass
        pass


class KeyPrinter(CListener):
    def enterSelectionStatement(self, ctx):
        print(f"Enter Selection Statement\n{ctx.getText()}")
        pass
    def enterFunctionDefinition(self,ctx):
        print("Found function: '"+str(ctx.declarator().directDeclarator().directDeclarator().Identifier())+"'")
        print(f"Function content {self.function_content}")
        print ("Looking for '"+self.function+"'")
        if str(ctx.declarator().directDeclarator().directDeclarator().Identifier())==self.function:
            print("Found it!  "+self.function)
            self.enable_dumping=True

def dprint(instr,flush=False):
    if debug[0]:
        print(instr,flush=flush)
    else:
        global gbl_debug_msg
        if gbl_debug_msg[3]:
            if gbl_debug_msg[1]%50 == 0:
                flush=True
            gbl_debug_msg[0]+=instr+"\n"
            gbl_debug_msg[1]+=1
            if flush:
                write_log()
                gbl_debug_msg[0]=""

def write_log():
    if gbl_debug_msg[3]:
        gbl_debug_msg[2].write(gbl_debug_msg[0])

def get_tree(inp):
    lexer = CLexer(inp)
    stream = CommonTokenStream(lexer)
    stream.fill()
    parser = CParser(stream)
    #compilationUnit is the "base case" for the grammer described
    #in C.g4
    tree = parser.compilationUnit()
    return parser,tree

def get_tree_from_file(file_name):
    inp = FileStream(file_name)
    return get_tree(inp)

def get_tree_from_string(inp):
    inp = InputStream(inp)
    return get_tree(inp)

def print_ctx_bfs(tree,outf):
    q = linked_list.ll()
    #get first set of children
    q.push_list(list(tree.getChildren()))
    #go through all children breadth first
    txt = ""
    while q.length > 0 :
        e = q.dequeue()
        txt += f"Text={e.getText()}\nType={type(e)}\n"
        txt += f"Child Count = {e.getChildCount()}\n"
        if e.getChildCount()>0:
            for i,c in enumerate(list(e.getChildren())):
                txt+=f"{i} : {type(c)} [{c.getText()}]\n"
        txt += "-------\n"
        if e.getChildCount() != 0:
            q.push_list(list(e.getChildren()))
    with open(outf, 'w') as outfile:
        outfile.write(txt)
    """
    outfile = open(outf, 'w')
    outfile.write(txt)
    """

#get all types of ctx
#use to find functions or conditional statements
def find_ctx(tree,ctx,screen=None):
    q = []
    #get first set of children
    pushq(q, list(tree.getChildren()))
    #go through all children breadth first
    r = []
    while q != []:
        e = popq(q)
        if screen and type(e) in screen:
            continue
        t = type(e)
        if str(t) == ctx:
            r.append(e)
        if e.getChildCount() != 0:
            pushq(q,list(e.getChildren()))
    return r

#get all types of ctx
#use to find functions or conditional statements
def find_ctx_list(tree,ctx,screen=None):
    q = []
    #get first set of children
    pushq(q, list(tree.getChildren()))
    #go through all children breadth first
    r = []
    while q != []:
        e = popq(q)
        if screen and type(e) in screen:
            continue
        t = type(e)
        if str(t) in ctx:
            r.append(e)
        if e.getChildCount() != 0:
            pushq(q,list(e.getChildren()))
    return r

#Input: a functionDefinitionContext
#Output: the argument names
def get_func_name(fctx):
    gtx = fctx.getText()
    node=None
    if type(fctx)==CParser.FunctionDefinitionContext:
        node=fctx.declarator()
    else:
        node=fctx.funcDeclarator()

    if node.getChild(0).getChild(0).getText().strip() == '(':
        ret = fctx.getChild(0).getText()
    else:
        ret = node.getChild(0).getChild(0).getText()
        if ret == '*':
            ret = node.getChild(1).getChild(0).getText()
    return ret

def find_multictx_with_scope(tree,multctx,screen=None,ignore_nodes=None,okay_subscope=None):
    if not tree:
        return None
    q = []
    #get first set of children
    pushq(q, list(tree.getChildren()))
    #go through all children breadth first
    txt = ""
    r = []
    start_scope=type(tree)
    check_scope=any([((screen!=None) and (start_scope in screen)), (okay_subscope!=None)])
    screen_me=screen
    if check_scope:
        if not screen_me:
            screen_me=[]
        screen_me+=okay_subscope
    dprint(f"scope info: start = {start_scope}, check_scope = {check_scope}")

    while q != []:
        e = popq(q)
        if (check_scope and okay_subscope and type(e) in okay_subscope):
            check_scope=False
            screen_me+=okay_subscope
        if (screen_me and type(e) in screen_me) or (ignore_nodes and e in ignore_nodes):
            continue
        txt += f"Text={e.getText()}\nType={type(e)}\n"
        txt += "-------\n"
        t = type(e)
        if t in multctx:
            r.append(e)
        if e.getChildCount() != 0:
            #DFS
            q=list(e.getChildren())+q
            #pushq(q,list(e.getChildren()))
    return r

def find_multictx(tree,multctx,screen=None,ignore_nodes=None,dfs=True,screen_first=True):
    """
        tree = start search here
        multctx = push nodes that matcb any of these type
        screen = dont search below nodes that match these types
        ignore = don't search below nodes that match these nodes
    """
    q = []
    #get first set of children
    pushq(q, list(tree.getChildren()))
    #go through all children breadth first
    txt = ""
    r = []
    while q != []:
        e = popq(q)
        t = type(e)
        if screen_first:
            if (screen and t in screen) or (ignore_nodes and e in ignore_nodes):
                continue
            if t in multctx:
                r.append(e)
        else:
            if t in multctx:
                r.append(e)
            if (screen and t in screen) or (ignore_nodes and e in ignore_nodes):
                continue

        if e.getChildCount() != 0:
            #DFS
            if dfs:
                q=list(e.getChildren())+q
            else:
                pushq(q,list(e.getChildren()))
        txt += f"Text={e.getText()}\nType={t}\n"
        txt += "-------\n"
    return r

# unused
def find_scope_descendant(ancestor,descend_lineage):
    indx=descend_lineage.index(ancestor)
    return descend_lineage[indx-1]

def is_not_inscope(node,older):
    found=False
    node_=node
    while not found:
        if type(node_)==CParser.ExternalDeclarationContext:
            return False
        if node_ in older:
            return True
        node_=node_.parentCtx

def is_descendant(node,ancestor):
    found=False
    node_=node
    while not found:
        if type(node_)==CParser.ExternalDeclarationContext:
            return False
        if node_==ancestor:
            return True
        node_=node_.parentCtx

def get_function_info(functions,fscope,dont_eval:list=None,okay_eval:list=None):
    scope_vars=dict()
    variable_lut=dict()
    for ctx in functions:
        fname=ctx
        fargs=get_func_args_nodes(ctx)
        scope_dict=dict()
        scope_vars[fname]=dict()
        compound_scope=list()
        for k,x in fscope.items():
            if x['func_ctx']==ctx:
                scope_dict[k]=x
                if type(k)==CParser.IterationStatementContext or type(k)==CParser.SelectionStatementContext:
                    c=list(k.getChildren())
                    if type(c[4].getChild(0))!=CParser.CompoundStatementContext:
                        dprint(f"iteration/selection scope corner case {len(compound_scope)} : {get_string2(k)}")
                        compound_scope.append((k,True))
                if type(k)==CParser.CompoundStatementContext:
                    dprint(f"compound scope {len(compound_scope)} : {get_string2(k)}")
                    compound_scope.append((k,False))
        dprint(f"len(compound_scope) : {len(compound_scope)}")
        for p,add_p_to_scope_stack in list(compound_scope):
            dprint(f"=======START=======")
            pscope=dict()
            decl_scopes=[]
            assign_scopes=[]
            compare_scopes=[]
            var_lut=dict()
            import copy
            scope_stack=copy.copy(scope_dict[p]['pscopes'])
            if add_p_to_scope_stack:
                scope_stack=[p]+scope_stack
            else:
                decl_scopes.extend(scope_dict[p]['decls'])
                assign_scopes.extend([n for n in scope_dict[p]['assigns'] if not(any([x in n[3].getText() for x in dont_eval]))])
                compare_scopes.extend([n for n in scope_dict[p]['compares'] if not(any([x in n[3].getText() for x in dont_eval]))])
                var_lut.update(scope_dict[p]['sym_lut'])
            parent_scope=scope_dict[p]['parent']
            siblings=scope_dict[p]['siblings'] #[0] are younger, [1] older
            ignore_sibs=copy.copy(scope_dict[p]['ignore_nodes'])

            cur=None
            scope_end=p
            if add_p_to_scope_stack:
                while scope_end.parentCtx!=scope_stack[1]:
                    scope_end=scope_end.parentCtx
            dprint(f"SCOPE STACK : {add_p_to_scope_stack} ")
            dprint(f"START SCOPE : [ {type(p)} => {get_string2(p)} ] ")
            dprint(f"END SCOPE   : [ {type(scope_end)} => {get_string2(scope_end)} ] ")
            dprint(f"p_decls = {[(get_string2(n[0]),get_string2(n[1]),get_string2(n[2])) for n in scope_dict[p]['decls']]}")

            for i in range(0,len(scope_stack)):
                dprint(f" scope [{i}] : {type(scope_stack[i])}")
            while(len(scope_stack)>0):
                cur=scope_stack.pop()
                cur_info=scope_dict.get(cur,None)
                if not cur_info:
                    print(f" ERROR : {type(cur)} does not exist in scope_dict!")
                    continue

                nxt=scope_stack[-1] if len(scope_stack)>0 else None
                nxt_ignore=ignore_sibs
                nxt_info=None
                if nxt:
                    nxt_info=scope_dict.get(nxt,None)
                    nxt_ignore=nxt_info['ignore_nodes']
                curscope_limits=cur_info['scope_limits'][0]
                desc_scopes=cur_info['descendants']
                var_lut.update(cur_info['sym_lut'])
                local_decls=[n for n in cur_info['decls'] if not is_not_inscope(n[1],nxt_ignore)]
                local_assigns=[n for n in cur_info['assigns'] if not is_not_inscope(n[3],nxt_ignore) and not(any([x in n[3].getText() for x in dont_eval]))]
                local_compares=[n for n in cur_info['compares'] if not is_not_inscope(n[3],nxt_ignore) and not(any([x in n[3].getText() for x in dont_eval]))]
                decl_scopes.extend(local_decls)
                assign_scopes.extend(local_assigns)
                compare_scopes.extend(local_compares)
                dprint(f"decls = {[(get_string2(n[0]),get_string2(n[1]),get_string2(n[2])) for n in decl_scopes]}")
                dprint(f"assigns = {[(get_string2(n[0]),get_string2(n[1]),get_string2(n[2]),get_string2(n[3])) for n in assign_scopes]}")
                dprint(f"compares = {[get_string2(n[1]) for n in compare_scopes]}")
            # end of while
            dprint(f"===> context {get_string2(p)}")
            s=[get_string2(n) for n in ignore_sibs]
            dprint(f"ignore sibs: {s}")
            for j,c in enumerate(decl_scopes):
                dprint(f"{j} : |  decl_scope  | type: {c[0]}, var: {get_string2(c[1])}")
            for j,c in enumerate(assign_scopes):
                dprint(f"{j} : | assign_scope | type: {c[0]}, value: {get_string2(c[3])}")
            for j,c in enumerate(compare_scopes):
                dprint(f"{j} : |compare_scopes| type: {c[0]}, value: {get_string2(c[3])}")
            dprint(f"=======END=======")

            scope_vars[fname][p]=\
                                  {'variables':copy.copy(decl_scopes),\
                                  'values':copy.copy(assign_scopes),\
                                  'compvalues':copy.copy(compare_scopes),\
                                  'symbol2type_lut':copy.copy(var_lut),\
                                  'parent':copy.copy(parent_scope),\
                                  'scope_end':copy.copy(scope_end)
                                  }
    return scope_vars


def is_operator(val):
    if re.match(r"([()*-/%+\[\]]|->)",val):
        return True
    return False

def is_literal(val):
    # if is a digit
    if re.match(r"\d+",val):
        return True
    elif re.match(r"('\w*'|\"\w*\")",val):
        return True
    return False




number_equivalent_classes=[ 
                        set(['long long','unsigned long long','signed long long',\
                        'long long int','unsigned long long int','signed long long int']), \
                        set(['long int','unsigned long int','signed long int',\
                        'long','unsigned long','signed long' ]), \
                        set(['uint32_t','cgc_size_t',\
                        'size_t','void *','char *','int *']),\
                        set(['int','unsigned','signed','signed int','unsigned int',\
                        'uint','uint_t' ]),\
                        set(['short','uint16_t','signed short','unsigned short',\
                        'short int','signed short int','unsigned short int']),
                        set(['char','uint8_t','signed char','unsigned char'])
                        ]    
floatp_equivalent_classes=[
        set(['long double','double double']),
        set(['double']),
        set(['float'])
        ]
number_set=set()
fpnumber_set=set()
for i in range(0,len(number_equivalent_classes)):
    number_set=number_set|number_equivalent_classes[i] 
for i in range(0,len(floatp_equivalent_classes)):
    fpnumber_set=fpnumber_set|floatp_equivalent_classes[i] 

def can_cast(ltyp,rtyp,ignore_int_hier=True):
    # determines if rtyp variable can be cast as ltyp
    equivalent_classes=None
    hier=True
    if ltyp in number_set and rtyp in number_set:
        equivalent_classes=number_equivalent_classes 
        hier=not ignore_int_hier
    elif ltyp in fpnumber_set and rtyp in fpnumber_set:
        equivalent_classes=floatp_equivalent_classes 
    if not equivalent_classes:
        # they're not in the same number classes
        return False
    index=[None,None]
    for i,eq in enumerate(equivalent_classes):
        if ltyp.rstrip() in eq:
            index[0]=i
        if rtyp.rstrip() in eq:
            index[1]=i
    if index[0] is not None and index[1] is not None:
        return index[0]<=index[1] if hier else True
    return False

def has_multiptr_refs(rhs_value):
    x=re.sub(" ","",rhs_value)
    has_multiptr=re.search(r"((\w+|\(\w+\))(\.|->|\[[^\]]+\])){2,}",x,flags=re.ASCII)
    has_multidim_array=re.search(r"(\[[^\]]*]){2,}",x,flags=re.ASCII)
    dprint(f"has_multiptr_refs '{x}' - {has_multiptr is not None} OR  {has_multidim_array is not None}")
    return (has_multiptr is not None) or (has_multidim_array is not None)

def is_function(name):
    is_func=re.match(r"\s*(\w+)\s*\(((\s*(\S+),)*\s*\S+\s*)?\s*\)",name,flags=re.ASCII) is not None
    is_func_ptr= (re.match(r"\s*(\(\s*\*\s*\S+\s*\))\s*(\(.*\))",name,flags=re.ASCII) is not None) or \
                (re.match(r"\s*(\w+\s*)*\s*(\(\s*\*\s*\S+\s*\))\s*(\(.*\))",name,flags=re.ASCII) is not None)
    dprint(f"Checking '{name}' - is_func={is_func}, is_func_ptr={is_func_ptr}")
    return is_func or is_func_ptr

def is_okay_func_call(rhs_value,eval_me):
    is_func=re.search(r"(\w+)\s*\(((\s*(\w+)\s*,)*\s*\w+\s*)?\)",rhs_value,flags=re.ASCII)
    is_func_ptr=re.match(r"\s*(\(\s*\*\s*\S+\s*\))\s*(\(.*\))",rhs_value,flags=re.ASCII)
    is_func_call=re.match(r"\s*(\w+((\s*\.\s*\w+|\s*\[.*\]|\s*->\s*\w+)*))\s*(\(.*\))",rhs_value,flags=re.ASCII)
    is_func_=[True if is_func else False,\
             True if is_func_ptr else False,\
             True if is_func_call else False]
    is_valid_=[ True if is_func and is_func.group(1) in eval_me else False,\
                True if is_func_call and is_func_call.group(1) in eval_me else False\
              ]
    dprint(f"is_func_ [{rhs_value[0]}] => '{is_func_}'")
    return any(is_func_),any(is_valid_)
        
    
# the point of this is to be able to disable fix_repair* functions from being executed
def generate_preface(var):
    var=var.rstrip();
    prog="#ifndef FIX_INGREDIENT_CONTENT\n"
    prog+="#define FIX_INGREDIENT_CONTENT\n"
    prog+="#define FIX_INGREDIENT_CONTENT_VAR\n"
    prog+=f"static int {var}=0;\n"
    prog+="static void __attribute((constructor)) "+f"{var}"+"_init(){\n"
    prog+="    char* tmp=getenv(\"ENABLE_FIXES\");\n"
    prog+="    if (tmp) { "+f"{var}=1;"+" }\n" 
    prog+="}\n"
    prog+="#else\n"
    prog+="#ifndef FIX_INGREDIENT_CONTENT_VAR\n"
    prog+="#define FIX_INGREDIENT_CONTENT_VAR\n"
    prog+=f"static int {var}=0;\n"
    prog+="#endif\n"
    prog+="#endif\n"
    return prog

def uniquify(varlist):
    svals=list()
    uniq_varlist=list()
    for x in varlist:
        xs=get_string2(x)
        if xs not in svals:
           svals.append(xs)
           uniq_varlist.append(x)
    return uniq_varlist

    

def get_fix_loc_subfns(scope,dvars,eval_me,id_="",root=None,ptr_t=None,defines=None):
    uniques=[]
    fn_body=[]
    rewrites=[]
    fname=f"fix_ingred_{id_}"
    bl_funcs=[]
    preface_included=False
    ## function scope
    #def get_type_var_info(ctx) => return nodes, sym_dict, up_nodes
    all_fn_def=""
    num_i=len(scope.items())
    for i,f_info in enumerate(scope.items()):
        fn,fs=f_info
        type_lut=dict()
        #def_vars = get_all_vars(fn, False)
        # add here pemma
        fn_name=get_func_name(fn)
        print(f"Processing [{fn_name}] :",flush=True)
        try:
            ddef_vars=dvars[fn_name]
            def_vars=uniquify(ddef_vars)
        except Exception as e:
            print(f"Can't find {fn_name} in dvars {dvars.keys()}")
            raise(e)
        for dd,d in enumerate(def_vars):
            dprint(f"def_vars[{dd}]: [{fn_name}] : {type(d)} : {get_string2(d)}")
        #strip_array_decs(def_vars)
        ## for each namespace scope in function scope
        s2_fn_def=""
        s2_fn_decls=""
        s2_body=""
        s2_calls=""
        num_j=len(fs.items())
        for j, s_info in enumerate(fs.items()):
            sn,s=s_info
            uniq_init=[]
            parent=s['parent'] if s['parent'] else sn
            var_s=s['variables']
            sym_lut=s['symbol2type_lut']
            val_s=s['values']
            cval_s=s['compvalues']
            #val_s=s['vals_w_nodes']
            scope_uniq=[]
            end=s['scope_end']
            dprint(f"sym_lut=>'{sym_lut}'\nval_s=>'{val_s}'\ncval_s=>'{cval_s}'")

            #s2_decls=""
            s2_fn=f"{fname}_{i}"
            ## for each value in the namespace scope
            num_d=len(def_vars)
            
            valid_def_vars=list()
            for dd,def_var in enumerate(def_vars):
                n,lut,un=get_type_var_info(def_var)
                ltyp=n[0][0]
                lname=get_string2(n[0][1])
                if lname is None:
                    continue
                if lname.startswith('(') and is_function(f"{ltyp}{lname}"):
                    dprint(f"{ltyp}{lname} is a function.\nSkipping.")
                    continue
            
                if '(' in lname and is_function(lname):
                    dprint(f"{lname} is a function.\nSkipping.")
                    continue
                llut=sym_lut.get(lname,None)
                if not llut:
                    if not ltyp:
                        ltyp="int"
                    sym_lut[lname]=ltyp
                valid_def_vars.append(def_var)

            for dd,def_var in enumerate(valid_def_vars):
                n,lut,un=get_type_var_info(def_var)
                #for nn in n:
                #    print(f"{nn[0]} : {get_string2(nn[1])}")
                #for nn in un:
                #    print(f"{nn[0]} : {get_string2(nn[1])} {get_string2(nn[2])}")
                # we're just going to assume a singly declared variable
                ltyp=n[0][0]
                lname=get_string2(n[0][1])
                if '[' in lname:
                    term=list(find_multictx(n[0][1],[tree.Tree.TerminalNodeImpl]))
                    value_subterms= [get_string2(v) for v in term]
                    while value_subterms[0]!='[':
                        value_subterms=value_subterms[1:]
                    while value_subterms[-1]!=']':
                        value_subterms=value_subterms[0:-1]
                    for v in value_subterms:
                        if v==']':
                            break
                        is_op = is_operator(v) 
                        is_lit= is_literal(v)
                        if not is_op and not is_lit:
                            vtype = sym_lut.get(v,None)
                            if not vtype:
                                vtype="int"
                            ainfo=(vtype,v,None)
                            is_macrodef=False
                            if defines:
                                srchk='|'.join(defines)
                                if re.search(r"\b("+srchk+r")\b",v):
                                    is_macrodef=True
                            if is_macrodef:
                                dprint(f"Skipping {v} => #define")
                            elif (ainfo,None) in uniq_init:
                                uniq_init.pop(uniq_init.index((ainfo,None)))
                                uniq_init.insert(0,(ainfo,"1"))
                            elif (ainfo,"1") not in uniq_init:
                                uniq_init.insert(0,(ainfo,"1"))
                #####
                num_k=len(val_s+cval_s)
                for k,x in enumerate(val_s+cval_s):
                    try:
                        type_info,var,varinfo,value_node=x
                        scope_uniq.append([])
                        if not value_node:
                            dprint(f"empty value_node: continuing {x}")
                            continue

                        term=list(find_multictx(value_node,[tree.Tree.TerminalNodeImpl]))
                        value_subterms= [get_string2(v) for v in term]
                        val=" ".join(value_subterms)
                        value=get_string2(value_node)
                        rtyp=re.sub(r"\bconst\b",r' ',type_info)
                        info=(ltyp,lname,value,rtyp)
                        dont_check_me=any([\
                                info[0]==x[0] and \
                                info[1]==x[1] and \
                                info[2]==x[2] and \
                                info[3]==x[3] \
                                for x in uniques])
                        if dont_check_me:
                            continue
                        uniques.append(info)
                        # if we can't cast the RHS to LHS type, then go to next
                        if not can_cast(ltyp,rtyp): 
                            continue
                        is_fn,okay_fn=is_okay_func_call(val,eval_me)
                        has_multiptrs=has_multiptr_refs(val)
                        proceed=False if has_multiptrs else True if not is_fn else okay_fn
                        dprint(f"[i={i}/{num_i}][j={j}/{num_j}][dd={dd}/{num_d}][k={k}/{num_k}] | type: {type_info} ; var : {var} ; varinfo : {varinfo} ; value_node : {get_string2(value_node)} ({type(value_node)});\n proceed : {proceed} [not({has_multiptrs}) && ( not ({is_fn}) || {okay_fn} )]")
                        if proceed:
                            scope_uniq[k].append(info)
                            dprint(f"Subterms : {','.join(value_subterms)}")
                            # if any RHS uses a variable, obtain its type from var_s (variable look-up table)
                            # and add it to the unique scope list of required variables
                            for v in value_subterms:
                                is_op = is_operator(v) 
                                is_lit= is_literal(v)
                                if not is_op and not is_lit:
                                    vtype = sym_lut.get(v,None)
                                    dprint(f" => is literal ({is_lit}) | is operator ({is_op}) {v} [vtype={vtype}]")
                                    if vtype:
                                        # check to see if there are any array versions
                                        vtyp=vtype
                                        if '*' in vtyp:
                                            for isym in sym_lut.keys():
                                                if f"{v} [" in isym and isym.startswith(v):
                                                    dprint(f"BEFORE => literal (False) {v} => {vtyp}")
                                                    v=isym
                                                    vtyp=sym_lut[v]
                                                    ares=re.search(r"\[\s*(\w*)\s*\]",isym)
                                                    if not ares:
                                                        dprint(f"AFTER => literal (False) {v} => {vtyp}")
                                                        break
                                                    asize=ares.group(1)
                                                    dprint(f"AFTER => literal (False) {v} => {vtyp} [size={asize}]")
                                                    if len(asize)>0 and not is_literal(asize):
                                                        dprint(f"Array size is variable => '{asize}'")
                                                        asizetyp=sym_lut.get(asize,None)
                                                        if asizetyp:
                                                            ainfo=(asizetyp,asize,None)
                                                            if ainfo not in [x[0] for x in uniq_init]:
                                                                uniq_init.insert(0,(ainfo,"1"))
                                                    break
                                        subinfo=(vtyp,v,None)
                                        if type(vtype)!=str:
                                            vtyp=get_string2(vtype)
                                        is_macrodef=False
                                        if re.search(r"\b(void)\b",v):
                                            is_macrodef=True
                                        if is_macrodef:
                                            dprint(f"Skipping {v} => #define")
                                        elif subinfo in [x[0] for x in uniq_init]:
                                            dprint(f"not unique: {subinfo} ... continue!")
                                            continue
                                        else:
                                            dprint(f"unique : {subinfo}")
                                            uniq_init.append((subinfo,None))
                                else:
                                    dprint(f" => is literal ({is_lit}) | is operator ({is_op}) {v}")
                    except Exception as e:
                        print(f"Exception with x={x}")
                        print(e)
                        raise
            # now take the uniq_init list and generate the pre-req variable types
            # i : function id ; j : scope_id 
            decl_vars=[]
            tdecl_vars=[]

            s1_calls=""
            s1_fn_decl=""
            s1_fn_def=""
            has_ibody=False
            if len(scope_uniq)>0:
                s0_calls=""
                s0_fn_decl=""
                s0_fn_def=""
                s1_fn=f"{fname}_{i}_{j}"
                has_jbody=False
                for k in range(0,len(scope_uniq)):
                    s0_body_vals=""
                    s0_body_vars=""
                    valid=False
                    udecl_vars=[]
                    has_kbody=False
                    # and then take the scope_uniq list and generate the initialized values
                    for u in scope_uniq[k]:
                        utyp,uname,uval,rtyp=u
                        utyp=re.sub(r"\bregister\b",r"",utyp)
                        has_uname=re.search(r"\b("+uname+r")\b",uval)
                        comment=False
                        if has_uname:
                            dprint("not valid - "+ f"{utyp} {uname}; {uname} = (({utyp}){uval});\n")
                        elif (utyp,uname) not in udecl_vars and utyp != "UNDEF":
                            prefix_=list()
                            suffix_=list()
                            if "/" in uval or "%" in uval:
                                x_re=re.search(r"[/%]\s*(\w+)",uval)
                                found=False
                                if x_re:
                                    v=x_re.group(1)
                                    if v in [x[0][1] for x in uniq_init]:
                                        prefix_.append(f"    {v} = 1;\n         ")
                                        found=True
                                if not found:
                                    prefix_.append(" /* [not yet implemented] modulo/divisor initialization \n")
                                    suffix_.insert(0,"\n */ ")
                                    comment=True
                            if "[" in uval:
                                x_re=re.search(r"(\w+)\s*\[\s*(\S+)\s*\]",uval)
                                if x_re:
                                    av=x_re.group(1)
                                    v=x_re.group(2)
                                    if av not in [x[0][1] for x in uniq_init]:
                                        prefix_.append(f"if ({av})"+'{')
                                        suffix_.insert(0,"}")
                                    if v in [x[0][1] for x in uniq_init]:
                                        prefix_.append(f"    {v} = 0;\n         ")
                                else:
                                    x_list=re.findall(r"\[\s*((([^]]+)\s*)+)\]",uval)
                                    y=[x in x_[0] for x_ in x_list for x in ["+","-","*","/"]]
                                    dprint(f" =====> {x_list} '{uval}' => {y} ")
                                    if any(y):
                                        if not comment:
                                            prefix_.append(" /* [not yet implemented] array based initialization \n")
                                            suffix_.insert(0,"\n */ ")
                                            comment=True
                                        else:
                                            prefix_.append(" // [not yet implemented] array based initialization \n")
                                            suffix_.insert(0,"\n")
                                        dprint(f" === FOUND IT ===> {x_list} [{uval}] ")
                                        
                                
                            prefix="".join(prefix_)
                            suffix="".join(suffix_)
                            if "[ ]" in uname:
                                xname=uname.replace("[ ]","")
                                s0_body_vars+="    {"+prefix+f"{utyp}* {xname}; {xname} = ({utyp}*)({uval}); "+suffix+"}\n"
                                if not comment:
                                    has_kbody=True
                            elif "[" in uname:
                                xnames=uname.split('[')
                                xname=xnames[0]
                                for x in xnames[1:]:
                                    x_=re.sub(']','',x)
                                    val="[ ("+x_+")-1 ]"
                                    xname+=val
                                s0_body_vars+="    {"+prefix+f"{utyp} {uname}; {xname} = ({utyp})({uval}); "+suffix+"}\n"
                                if not comment:
                                    has_kbody=True
                            else:
                                s0_body_vars+="    {"+prefix+f"{utyp} {uname}; {uname} = ({utyp})({uval}); "+suffix+"}\n"
                                if not comment:
                                    has_kbody=True
                            udecl_vars.append((utyp,uname))
                            valid=True
                        elif utyp != "UNDEF":
                            # we shouldn't really be hitting this line, but it's a fail-case
                            s0_body_vars+="    "+f"{uname} = ({utyp})({uval});"+"\n"
                            valid=True
                            has_kbody=True
                        else:
                            dprint("not valid - "+ f"{utyp} {uname}; {uname} = (({utyp}){uval});\n")
                    # only need to generate if we've found a unique (type,variable) tuple
                    if valid and has_kbody:
                        has_jbody=True
                        dprint(f"----")
                        for u in uniq_init:
                            utyp,uname,uval=u[0]; uinit=u[1]
                            dprint(f"UNIQ_INIT: ('{utyp}','{uname}','{uval}','{uinit}');\n")
                            utyp=re.sub(r"\b(register)\b",r"",utyp).strip()
                            utyp_=re.sub(r"\b(static|const|register)\b",r"",utyp).strip()
                            ptr_=False
                            struct_ptr_base=None
                            if ptr_t and utyp in list(ptr_t.keys()):
                                struct_ptr_base=ptr_t.get(utyp)
                                dprint(f"ptr_t: {utyp}, base(ptr_t): {struct_ptr_base}")
                            if "*" in utyp or struct_ptr_base:
                                ptr_=True
                                ptr_cnt=utyp.count('*')
                                xtyp=None
                                if not struct_ptr_base:
                                    xtyp=utyp.replace("*","").rstrip()
                                else:
                                    xtyp=struct_ptr_base
                                xtyp_=re.sub(r"\b(static|const|register)\b",r"",xtyp).strip()
                                xname=uname.replace(" ","")+"_ref"
                                x1name=xname
                                x2name=x1name
                                size="1"
                                if "[" not in xname:
                                    # this is the code that handles pointers
                                    if xtyp_ != "void":
                                        uname=f"{uname} = &{x1name}"
                                        s0_body_vals+=f"{xtyp_} {x1name};\n"
                                        s0_body_vals+=f"    bzero(&{xname},{size}*sizeof({xtyp_}));\n"
                                    else:
                                        # choosing int as the default type to cast a void* to
                                        uname=f"{uname} = (void*)&{x1name}"
                                        s0_body_vals+=f"int {x1name};\n"
                                        s0_body_vals+=f"    bzero(&{xname},{size}*sizeof(int));\n"
                                    s0_body_vals+=f"{utyp} {uname};\n"
                                    pass
                                else:
                                    x1name=re.sub(r"\s+",r"",xname)
                                    first_index_found=False
                                    vals=[]
                                    while("]_ref" in x1name):
                                        x_re=re.search(r"(\[(\s*[\d\w]*\s*)\])",x1name)
                                        v1=x_re.group(1)
                                        val=x_re.group(2)
                                        vals.append(val)
                                        x1name=re.sub(r"\["+val+r"\]",r"",x1name,1).rstrip()
                                    xname=x1name # <var>_ref
                                    orig=re.sub(r"_ref$",r"",xname) # <var>
                                    size="1"
                                    array_size=""
                                    for x in vals:
                                        if x!="":
                                            size=f"{size}*({x})"
                                            array_size=f"{array_size}[{size}]"
                                        else:
                                            array_size=f"{array_size}[1]"

                                    s0_body_vals+=f"{xtyp} {xname}{array_size};\n"
                                    s0_body_vals+=f"    bzero(&{xname},{size}*sizeof({xtyp_}));\n"
                                    s0_body_vals+=f"{utyp} {orig}{array_size};\n"
                                    s0_body_vals+="{"+\
                                            f"  {xtyp} **dst_ref={orig}; {xtyp} *src_ref={xname};\n"\
                                            f"  for( int ref_i=0;ref_i<{size};ref_i++)"+\
                                            "{*dst_ref=src_ref;dst_ref++;src_ref++;}\n"+\
                                            "}\n"
                                    # this is the code that handles arrays of pointers
                                    #    int * myarray[100][100];
                                    #    (utyp,uname) = ("int *","myarray[100][100]")
                                    # needs to be
                                    #    int myarray_ref[100][100];
                                    #    (xtyp,x1name+vals) = ("int","myarray_ref"+"[100][100]")
                                    #    bzero(&myarray_ref,100*100*sizeof(int));
                                    #    (x1name,vals+"*"+"sizeof("+xtyp+")")=("myarray_ref","100*100*sizeof(int)")
                                    #    int * myarray[100][100];
                                    #    (utyp,uname) = ("int *","myarray[100][100]")
                                    #    { int **x=myarray; int * src_x=myarray_ref;
                                    #    for (int myref_i=0;myref_i<100*100; myref_i++) { *x=src_x; x++; src_x++;}
                            elif "[ ]" in uname:
                                x1name=uname.replace("[ ]","[0]",1)
                                s0_body_vals+=f"{utyp} {x1name};\n"
                                s0_body_vals+=f"    bzero(&{x1name},sizeof({utyp_}));\n"
                            elif "[" in uname:
                                uname_re=re.search("(\S+)\s*\[\s*(.*)\s*\]$",uname)
                                name=uname_re.group(1);
                                size=uname_re.group(2);
                                s0_body_vals+=f"{utyp} {uname};\n"
                                s0_body_vals+=f"    bzero(&{name},( {size}*sizeof({utyp_}) ) );\n"
                            else:
                                s0_body_vals+=f"{utyp} {uname};\n"
                                if not uinit:
                                   s0_body_vals+=f"    bzero(&{uname},sizeof({utyp_}));\n"
                                else:
                                   s0_body_vals+=f"    {uname}={uinit};\n"
                            decl_vars.append(uname)
                        s0_body=f"{s0_body_vals}{s0_body_vars}"
                        # scope 0 function
                        s0_fn=f"{s1_fn}_{k}()"
                        bl_funcs.append(f"{s1_fn}_{k}")
                        ## scope 0 function declaration
                        #s0_fn_decl+=f"void {s0_fn};\n"
                        # scope 0 function definition (with body)
                        s0_fn_def+=f"void {s0_fn}"+"{\n"+f"{s0_body}"+"}\n"
                        s2_fn_decls+=f"void {s0_fn};\n"
                        # scope 0 function call
                        s0_call_fn=f"{s0_fn};\n"
                        # set of scope 0 function calls
                        s0_calls+=f"{s0_call_fn}"
                    tdecl_vars.extend(udecl_vars)
                if has_jbody:
                    has_ibody=True
                    s1_body=""
                    # scope 1 function call (used in scope 2 function definition)
                    s1_call_fn=f"{s1_fn}();\n"
                    s2_fn_decls+=f"void {s1_call_fn}"
                    bl_funcs.append(f"{s1_fn}")
                    s1_calls+=f"{s1_call_fn}"
                    #s1_fn_decl="\n"+s0_fn_decl+"\n"+f"void {s1_call_fn}"+"\n"
                    s1_body=f"{s0_calls}"
                    # scope 0 function definition (with body)
                    s1_fn_def+=s0_fn_def+f"void {s1_fn}()"+"{\n"+f"{s1_body}"+"}\n"
                    dprint("==== Scope 1 ====\n"+f"{s1_fn_def}")
                    #s2_decls+=f"{s1_fn_decl}\n"
                    s2_body+=f"{s1_fn}();"+"\n"
                    #loc = get_end_loc(end)
                    #rewrites.append((s1_call_fn,loc))
                    s2_fn_def+=s1_fn_def
        s2_call_fn=f"{s2_fn}();\n"
        s2_fn_decls+=f"void {s2_fn}();\n"
        s2_calls+=f"{s2_call_fn}"
        s2_fn=f"{fname}_{i}()"
        bl_funcs.append(f"{fname}_{i}")
        s2_fn_def+=f"void {s2_fn}"+"{\n"+f"{s2_body}"+"}\n"
        all_fn_def+=s2_fn_def
        dprint("==== Scope 2 ====\n"+f"{s2_fn_def}")
        dprint("[Fix Ingredient functions]  -- START --")
        en_var="fix_ingred_enable"
        if not preface_included:
            prepend=generate_preface(en_var)+f"\n{s2_fn_decls}\n"
            preface_included=True
        else:
            #prepend=f"{s2_fn_def}"
            prepend=f"{s2_fn_decls}\n"
        dprint(prepend)
        loc= get_start_loc(fn)
        rewrites.append((prepend,loc))
        open_bracket=list(fn.getChildren())[-1].getChild(0)
        line,c = get_start_loc(open_bracket)
        func=f"    if ({en_var})"+"{ "+f"{s2_fn};"+" };"
        rewrites.append((func,(line+1,c)))
        dprint("[Fix Ingredient functions]  --  END  --")
    dprint("Fix Ingredient functions")
    for b in bl_funcs:
        dprint(f"- {b}")
    
    # putting repair ingredient function definitions at the end
    last_line=list(root.getChildren())[-1]
    if type(last_line)!=tree.Tree.TerminalNodeImpl:
        last_line=list(last_line.getChildren())[-1]
    line,c = get_start_loc(last_line)
    rewrites.append((all_fn_def,(line,c)))
    return rewrites,bl_funcs



    

def strip_array_decs(lst):
    for i in range(len(lst)):
        if '[' in lst[i]:
            lst[i] = lst[i][:lst[i].find('[')]

def get_string2(ctx,ignore_list=None):
    if ctx==None:
        return None
    elif type(ctx)==str:
        return ctx
    q=[ctx]
    st=[]
    while len(q)>0:
        node=q.pop()
        if ignore_list and node in ignore_list:
            continue
        if type(node)==tree.Tree.ErrorNodeImpl:
            #print(f"Encountered an error!!!!\n{get_string2(node.parentCtx)}")
            continue
        if type(node)==tree.Tree.TerminalNodeImpl:
            st.append(node.getText())
        else:
            children=list(node.getChildren())
            if children and len(children)>0:
                children.reverse()
                q.extend(children)
    return ' '.join(st)


def get_string(ctx):
    return ' '.join([c.parentCtx.getText() for c in find_ctx(ctx,"<class 'antlr4.tree.Tree.TerminalNodeImpl'>")])


def get_arg_names(ctx):
    try:
        ftlc = find_ctx(ctx, "<class 'CParser.CParser.ParameterTypeListContext'>")
        c = ftlc[0].getChild(0)
        cl = c.children
        cs = [c for c in cl if str(type(c)) != "<class 'antlr4.tree.Tree.TerminalNodeImpl'>"]
        rs = [c.getChild(1).getText() for c in cs]
        return rs
    except:
        return None

#Input: contex of a function
#Output: list of tuples [(type,var_name)]
def get_func_args(ctx):
    try:
        ftlc = find_ctx(ctx, "<class 'CParser.CParser.ParameterTypeListContext'>")

        #for the c89 standard of not declaring types in parameter list of functions
        if ctx.getChildCount() == 4 and not ctx.getChild(0).getText().startswith("extern"):
            args = ctx.getChild(2)
            #for every argument
            ts = []
            rs = []
            for e in args.getChildren():
                #all text from args but the ';' char
                c = e.getChild(0)
                #print(f"chiild 0 child count {c.getChildCount()}")
                #the last child is alwasy the variable
                #everything prior is the type e.g. 
                #1 = const 2 = char* 3 = inp_str
                cs = list(e.getChild(0).getChildren())
                #r = arg name
                r = cs[len(cs)-1]
                rs.append(r.getText())
                z = [a.getText() for a in cs[:-1]]
                #t = arg type
                t = "".join(z)
                ts.append(t)
            return list(zip(ts,rs))

        if len(ftlc) > 0:
            c = ftlc[0].getChild(0)
            #print(f"ftlc len = {len(ftlc)} text = {ftlc[0].getText()}")
            #print(ctx.getChild(0).getText())
            #print(ctx.getText())
            cl = c.children
            #looks like c.getChildCount() len of 1 is void and we don't care about funcs with no args
            cs = [c for c in cl if str(type(c)) != "<class 'antlr4.tree.Tree.TerminalNodeImpl'>" and c.getChildCount() > 1]
            rs = [c.getChild(1).getText() for c in cs]
            ts = [c.getChild(0).getText() for c in cs]
            #for some reason antlr does not deal with void pointers well
            for i in range(len(rs)):
                if rs[i].startswith("(*"):
                    ts[i] = f"{ts[i]}*"
                if rs[i].endswith("[]"):
                    ts[i] = f"{ts[i]}*"
            #print(list(zip(ts, rs)))
            return list(zip(ts, rs))
        else:
                #print("error")
                #print(ctx.getText())
                return []
    except Exception as e:
        print("Threw exception in get_func_args of antlr_funcs.py")
        print(e)
        print(ctx.getText())
        print(ctx.getChildCount())
        return None

#Output: list of tuples [(type'node,var_name)]
def get_func_args_nodes(ctx):
    try:
        ftlc = find_ctx(ctx, "<class 'CParser.CParser.ParameterTypeListContext'>")
        if len(ftlc) > 0:
            c = ftlc[0].getChild(0)
            cl = c.children
            cs = [c for c in cl if str(type(c)) != "<class 'antlr4.tree.Tree.TerminalNodeImpl'>"]
            rs = [c.getChild(1).getText() for c in cs]
            ts = [c.getChild(0) for c in cs]
            return list(zip(ts, rs))
        else:
            return None
    except:
        return None


#if conditions will be '<class 'CParser.CParser.SelectionStatementContext'>
def get_conditionals(ctx):
    ftlc = find_ctx(ctx, "<class 'CParser.CParser.SelectionStatementContext'>")
    return ftlc

def get_defines(ctx):
    return find_ctx(ctx,"<class 'CParser.ComplexDefine'>")

def get_functions(ctx):
    return find_ctx(ctx,"<class 'CParser.CParser.FunctionDefinitionContext'>")

def get_function_calls(ctx):
    funcs = find_ctx(ctx, "<class 'CParser.CParser.PostfixExpressionContext'>")
    return [x for x in funcs if x.getChildCount() > 1]

def get_function(ctx, f_name):
    fns = get_functions(ctx)
    for f in fns:
        if get_func_name(f) == f_name:
            return f

def test_functs():
    p,t =get_tree_from_file("test_files/form.c")
    ifs = find_ctx(t , "<class 'CParser.CParser.IterationStatementContext'>")
    return ifs

def get_func_args_from_inp(inp, func_name,inp_type):
    if inp_type == "file":
        p,t =get_tree_from_file(inp)
    if inp_type == "c_string":
        p,t =get_tree_from_string(inp)
    fn = get_function(t, func_name)
    return get_arg_names(fn)

#Input: A function context
#Output: List of variables used in the function including function parameters
def get_all_vars(func_ctx, ret_types):
    #print("new call to get_all_vars")
    #print(func_ctx.getText())
    try:
        r_vars = []
        r_types = []
        #Get function arguments if they exist
        f_args = get_arg_names(func_ctx)
        if f_args != None:
            r_vars.extend(f_args)

        #Get all declarations
        decs = find_ctx(func_ctx, "<class 'CParser.CParser.DeclarationContext'>")
        for d in decs:
            #print(f"d.getText() = {d.getText()}")
            # This works for ints, longs, floats etc
            if d.getChildCount() == 3:
                r_vars.append(d.getChild(1).getChild(0).getChild(0).getText())
                #print(d.getChild(1).getChild(0).getChild(0).getText())
                r_types.append(d.getChild(0).getChild(0).getText())
            #This works for structs
            if d.getChildCount() == 2:
                if d.getChild(0).getChildCount() == 2:
                    r_vars.append(d.getChild(0).getChild(1).getText())
                if d.getChild(0).getChildCount() == 3:
                    r_vars.append(d.getChild(0).getChild(2).getText())
                #r_vars.append(d.getChild(0).getChild(1).getText())
        s_r_vars = []
        for r in r_vars:
            if r.endswith('[]'):
                s_r_vars.append(r[:-2])
            else:
                s_r_vars.append(r)
        if ret_types == True:
            return (r_types,s_r_vars)
        else:
            return s_r_vars
    except:
        print("Error parsing get_all_vars")
        print(d.getText())
        print(d.getChildCount())
        return None

#Input: a context should be the whole parse tree
#Output: all the typedefine contexts that are basic data types that were just renamed
def get_typedefs_from_ctx(ctx):
    sel_stmt = "<class 'CParser.CParser.DeclarationSpecifiersContext'>"
    macs = find_ctx(ctx, sel_stmt)
    t_defs = [x for x in macs if x.getText().startswith("typedef")]
    #might be a good idea to add pointers to all these types
    base_types = set(['int','long','char','float','double','short','signed','unsigned'])
    ret = []
    for t in t_defs:
        brkn = set([t.getChild(x).getText() for x in range(t.getChildCount())][1:-1])
        if brkn.issubset(base_types) and brkn != set():
            ret.append(t)
    return ret

#Input: A set of contexts' that have typedefines with basic data types
#Output:The name of the typedef
def get_typedef_from_set(t_defs, type_set):
    ret = []
    for t in t_defs:
        brkn = [t.getChild(x).getText() for x in range(t.getChildCount())]
        #trim off "typedf" and type-name
        brkn_set = set(brkn[1:-1])
        if type_set == brkn_set:
            ret.append(brkn[-1])
    return ret

def get_tokens_form_ctx(ctx):
    #BFS to get all children, may need to DFS just try and print both
    #add every child into queue
    #put every child that is terminal in array
    #figure out all the tokens we want to print (will be int)
    stack = []
    tokens = []
    stack.extend(list(ctx.getChildren()))
    while stack != []:
        s = stack.pop()
        tokens.extend(all_tokens(s))
        if s.getChildCount() > 0:
            stack.extend(list(s.getChildren()))
    for t in tokens:
        print(t)
    return tokens

def parse_func_call_args(ctx):
    a = ctx.getChild(2)
    aes = [a.getChild(x) for x in range(a.getChildCount()) if x % 2 == 0]
    return aes

def get_line_num(ctx):
    c = ctx
    while c.getChildCount() > 0:
        c = c.getChild(0)
    #print (f"start symbol line {c.getSymbol().line}")
    return c.getSymbol().line

def get_last_line_num(ctx):
    c = ctx
    while c.getChildCount() > 0:
        c = c.getChild(c.getChildCount()-1)
    #print (f"end symbol line {c.getSymbol().line}")
    return c.getSymbol().line

def get_start_loc(ctx):
    c = ctx
    while c.getChildCount() > 0:
        c = c.getChild(0)
    return c.getSymbol().line, c.getSymbol().column+1

def get_end_loc(ctx):
    c = ctx
    while c.getChildCount() > 0:
        c = c.getChild(c.getChildCount()-1)
    return c.getSymbol().line, c.getSymbol().column

def all_tokens(ctx):
    try:
        for i in range(104):
            if ctx.getTokens(i) != []:
                return [ctx]
    except:
        return []
    return []

#This is the quick and dirty way of doing this, but is not going
#to affect the code enough to makem me want to make it faster
#if someone gets bored we can do this with a linked list so we
#don't have to reverse the list two times.
def pushq(q, lst):
    return q.extend(lst)

def popq(q):
    q.reverse()
    r = q.pop()
    q.reverse()
    return r

def get_json_data(fname,infile):
    rd = {}
    d1 = {}
    d2 = {}
    disable_eval=[]
    enable_eval=[]
    version=None
    struct_ptrs={} 
    keywords=[]
    defines=[]
    with open(fname, 'r') as j:
        data = json.load(j)
        if 'DEPEND_VERSION' in data.keys():
            version=data['DEPEND_VERSION']
        if "macros" in data.keys():
            mcs = data["macros"]
            for i in range(len(mcs)):
                rd[mcs[i]['name']] = mcs[i]['value']
        if 'filenames' in data.keys():
            #do the thing here
            fls = data["filenames"]
            flst = [x["name"] for x in fls]
        if 'ignore' in data.keys():
            fignore=data['ignore']
            for x in fignore:
                flst.remove(x)
            #add macro stuff and use pemma's preprocess() function 
            d1,d2 = parse_pre_process(flst,rd,infile)
        if 'disable_eval' in data.keys():
            disable_eval=list(data['disable_eval'])

        if 'enable_eval' in data.keys():
            enable_eval=list(data['enable_eval'])

        if 'struct_ptrs' in data.keys():
            struct_ptrs=dict(data['struct_ptrs'])

        if 'defines' in data.keys():
            defines=list(data['defines'])

        if 'keyword_types' in data.keys():
            keywords=list(data['keyword_types'])

        for i in enable_eval:
            if i in disable_eval:
                # let's make sure that if it's allowed to be evaluated as a RHS assignment (non-destructive)
                # then we don't disable it
                disable_eval.remove(i)
            
    return (d1,d2,rd,disable_eval,enable_eval,struct_ptrs,keywords,defines)

def resolve_included(includes, infile, pragmas):
    # this function walks through, identifies the #includes and then resolves processing order
    includes=list()
    prag_def={'name':None,'value':None}
    with open(infile,'r') as inf:
        l=inf.readlines()
        for i,line in enumerate(lines):
            pass


#Input a file with a list of .c files to search functions for
#ret_d = dictionary with functions(keys) and args(values)
#ret_d2 = dictionary with functions(keys) and return values(values)
def parse_pre_process(cnts, pragmas,infile):
    #return dictionary
    ret_d = {}
    ret_d2 = {}
    #printf has variable arguments, should skip it now
    cnts = [c for c in cnts if "printf" not in c]
    for c in cnts:
        #read all the files and pull out the functions from each file to return
        #open the file
        from os import path
        if path.exists(c):
            inf = open(c, 'r')
            print(f"Processing file {c}")
            src = remove_defines(inf.readlines())
            src,_ = preprocess_string(pragmas,src)
            inf.close()
            src = "\n".join(src)
            #kill preprocessing stuff
            #make the new call on the string
            p,t = get_tree_from_string(src)
            if c.endswith(".h"):
                #here if header file
                fns = find_ctx(t,"<class 'CParser.CParser.FunctionDeclarationContext'>")
            elif c.endswith(".c"):
                #here if c file
                fns = get_functions(t)
            else:
                #here if we have error
                print("ERROR parsing header and library files ")
                exit()
            for f in fns:
                ret_d[get_func_name(f)] = get_func_args(f)
                if f.getChild(0).getText() == 'extern':
                    ret_d2[get_func_name(f)] = f.getChild(1).getText()
                else:
                    ret_d2[get_func_name(f)] = f.getChild(0).getText()
    return ret_d,ret_d2

def get_all_decs(ctx):
    ret = {}
    #for all functions
    fns = get_functions(ctx)
    for f in fns:
        decs = find_ctx(f, "<class 'CParser.CParser.DeclarationContext'>")
        ret[get_func_name(f)] = decs
    return ret

def get_top_dec_parent(ctx):
    dec1 = CParser.SelectionStatementContext
    dec2 = CParser.StatementContext
    pctx = ctx.parentCtx
    if type(pctx.parentCtx) != dec1 and type(pctx.parentCtx) != dec2:
        return pctx
    while type(pctx) == dec1 or type(pctx) == dec2:
        pctx = pctx.parentCtx
    return pctx

def get_dec_diffs(d1,d2):
    ret = {}
    for key,value in d1.items():
        origs = []
        s_in = set()
        s_all = set()
        #get all the text of the original
        for v in value:
            origs.append(v.getText())
        # go trough all the new values and see if
        # the new values are in the old
        for v in d2[key]:
            s_all.add(v)
            for o in origs:
                if o.startswith(v.getText()[:-1]):
                    s_in.add(v)
        ret[key] = list(s_all - s_in)

    return ret

def remove_defines(src):
    rm_next = False
    new_src = ""
    for line in src:
        if line.startswith("#define") or rm_next or line.startswith("#undef"):
            if line.strip().endswith('\\'):
                rm_next = True
            else:
                rm_next = False
        else:
            new_src += line
    return new_src

if __name__ == "__main__":
    import atexit
    atexit.register(write_log)
    main()
else:
    import atexit
    atexit.register(write_log)