parser.py

import re
import copy
import importlib as imp

from comsdk.graph import Graph, Func, State, Selector
from comsdk.edge import Edge


class Params():
    __slots__=(
        'module',
        'entry_func',
        'predicate',
        'selector',
        'function',
        'morphism',
        'parallelism',
        'comment',
        'order',
        'subgraph'
    )
    def __init__(self):
        for slot in self.__slots__:
            setattr(self, slot, None)
    
    def __str__(self):
        stri = ""
        for s in self.__slots__:
            stri += s+": {}, ".format(getattr(self, s))
        return stri

# entities = {}

class GraphFactory():
    __slots__ = (
        'name',
        'states', 
        'graph',
        'issub',
        'tocpp',
        'entities'
    )
    def __init__(self, tocpp=False):
        self.states = {}
        self.entities = {}
        self.tocpp = tocpp
        self.name = None
        self.issub = False

    def add_state(self, statename):
        if statename not in self.states:
            self.states[statename] = State(statename)
            if statename in self.entities:
                self.states[statename].comment = self.entities[statename].comment
    
    def _create_morphism(self, morphname=None):
        if morphname is None:
            return Func(), Func()
        pred_f, func_f = Func(), Func() 
        morph = self.entities[morphname]
        # print(morph)
        for m in morph.__slots__:
            if getattr(morph,m) != None:
                if m!="predicate" and m!="function":
                    raise Exception("ERROR: Morphisms could not have any params exept predicate and function!\n{}".format(morphname))
                if m=="predicate":
                    if getattr(morph,m) not in self.entities:
                        raise Exception("\tERROR: Predicate {} is not defined!".format(getattr(morph, m)))
                    pred = self.entities[getattr(morph, m)]
                    if self.tocpp:
                        pred_f = Func(pred.module, pred.entry_func, dummy=True)
                    else:
                        pred_f = Func(pred.module, pred.entry_func)
                if m=="function":
                    if getattr(morph,m) not in self.entities:
                       raise Exception("\tERROR: Function: {} is not defined!".format(getattr(morph, m)))
                    fu = self.entities[getattr(morph, m)]
                    if self.tocpp:
                        func_f = Func(fu.module, fu.entry_func, dummy=True)
                    else:
                        func_f = Func(fu.module, fu.entry_func)
        return pred_f, func_f


    def add_connection(self, st1, st2, morphism=None, ordr=0):
        pred, entr = self._create_morphism(morphism)
        self.states[st1].connect_to(self.states[st2], edge=Edge(pred, entr, order=ordr))
        print("{} -> {}".format(st1, st2))

    def build(self, nsub):
        print("BUILDING {}\nStates:".format(self.name))
        for s in self.states:
            print("\t"+ s)
        if self.issub:
            self.graph = Graph(self.states[self.name+str(nsub)+"_"+"__BEGIN__"], self.states[self.name+str(nsub)+"_"+"__END__"])
        else:    
            self.graph = Graph(self.states["__BEGIN__"], self.states["__END__"])
        self.graph.init_graph()
        for s in self.states:
            if s in self.entities and self.entities[s].selector is not None:
                selname = self.entities[s].selector
                if self.tocpp:
                    self.states[s].selector = Selector(len(self.states[s].transfers), self.entities[selname].module, self.entities[selname].entry_func, dummy=True)
                else:
                    self.states[s].selector = Selector(len(self.states[s].transfers), self.entities[selname].module, self.entities[selname].entry_func)
            else:
                self.states[s].selector =  Selector(len(self.states[s].transfers))
            if s in self.entities and self.entities[s].subgraph is not None:
                print("Replacing state {} with subgraph {}".format(s,self.entities[s].subgraph))
                parsr = Parser(subgraph=True)
                subgr = parsr.parse_file(self.entities[s].subgraph)
                self.states[s].replace_with_graph(subgr)
        return self.graph


class Parser():
    __slots__ = (
        'fact',
        'issub'
    )
    subgr_count = 0
    def __init__(self, tocpp=False, subgraph=False):
        self.fact = GraphFactory(tocpp=tocpp)
        self.fact.issub = subgraph
        self.issub = subgraph
        if subgraph:
            Parser.subgr_count+=1
    
    def _check_brackets(self, rawfile):
        br = 0
        qu = 0
        for char in rawfile:
            if char == "[":
                br+=1
            elif char == "{":
                br+=1
            elif char == "(":
                br+=1
            elif char == "]":
                br-=1
            elif char == "}":
                br-=1
            elif char == ")":
                br-=1
            elif char =="\"":
                qu+=1
        if br!=0 or qu%2!=0:
            raise Exception("Brackets or quotes do not match! Check your file")

    def _split_multiple(self,param):
        vals = {}
        first=True
        for s in param.__slots__:
            attr = getattr(param,s)
            if attr is not None and '\0' in attr:
                vals[s] = attr.split('\0')
        l=0
        for sl in vals:
            if l==0:
                l=len(vals[sl])
            elif l!=len(vals[sl]):
                raise Exception("\tERROR: Number of multiple params do not match", l)
        res = [copy.copy(param) for i in range(l)]
        for sl in vals:
            for i, _ in enumerate(res):
                setattr(res[i], sl, vals[sl][i])
        return res

    #Props is line "[proFp=smth, ...]"
    def _param_from_props(self,props):
        parm = Params()
        if props =="":
            return parm
        props = props.replace("]", '')
        if '(' in props:
            mchs = [m for m in re.finditer(r'\((\w+,)*\w+\)', props)]
            for m in mchs:
                props=props[:m.span()[0]]+(props[m.span()[0]:m.span()[1]]).replace(',','\0')+props[m.span()[1]:]
        if '\"' in props:
            mchs = [m for m in re.finditer(r'\".*\"', props)]
            for m in mchs:
                props=props[:m.span()[0]]+(props[m.span()[0]+1:m.span()[1]-1]).replace('\0',' ')+props[m.span()[1]:]
        props = props.replace("(","")
        props = props.replace(")","")
        rs =props.split(r",") #.split(r", ")
        for r in rs:
            r=r.split(r"=", 1)
            if r[0] in parm.__slots__:
                setattr(parm, r[0], r[1])
            else:
                raise Exception("\tERROR:Unknown parameter: "+ r[0])
        return parm

    def _param_from_entln(self, raw):
        res = re.split(r"\[", raw, 1)
        return res[0], self._param_from_props(res[1])

    def _multiple_morphs(self,props, n):
        p = self._param_from_props(props)
        if p.morphism is None:
            return  [copy.copy(p) for i in range(n)] 
        else:
            return self._split_multiple(p)

    def _topology(self,raw):
        spl = re.split(r"\s*(=>|->|\[|\])\s*", raw)
        spl = list(filter(lambda x: x!="[" and x!="]" and x!="", spl))
        left = spl[0].split(",")
        right = spl[2].split(",")
        if self.issub:
            for i in range(len(left)):
                left[i] = self.fact.name + str(Parser.subgr_count) + "_" + left[i]
            for i in range(len(right)):
                right[i] = self.fact.name + str(Parser.subgr_count) + "_" + right[i]
        if (len(left)>1) and (len(right)>1):
            raise Exception("ERROR: Ambigious multiple connection in line:\n\t{}".format(raw))
        # many to one conection
        elif len(left)>1:
            if len(spl) < 4:
                spl.append("")
            morphs = self._multiple_morphs(spl[3], len(left))
            if len(morphs)!=len(left):
                raise Exception("\tERROR: Count of edges do not match to count of states in many to one connection!\n\t\t{}".format(raw))
            self.fact.add_state(right[0])
            for i, st in enumerate(left):
                self.fact.add_state(st)
                self.fact.add_connection(st, right[0], morphs[i].morphism)
        # one to many connection, here could be selector
        elif len(right)>1:
            if len(spl) < 4:
                spl.append("")
            morphs = self._multiple_morphs(spl[3], len(right))
            self.fact.add_state(left[0])
            if len(morphs)!=len(right):
                raise Exception("\tERROR: Count of edges do not match to count of states in one to many connection!\n\t\t{}".format(raw))
            for i, st in enumerate(right):
                self.fact.add_state(st)
                self.fact.add_connection(left[0], st, morphs[i].morphism, morphs[i].order)
        # one to one connection
        else:
            self.fact.add_state(left[0])
            self.fact.add_state(right[0])
            if len(spl)==4:
                pr =self._param_from_props(spl[3])
                self.fact.add_connection(left[0], right[0], pr.morphism, ordr=pr.order if pr.order is not None else 0)
            elif len(spl)==3:
                self.fact.add_connection(left[0], right[0], None)

    def parse_file(self, filename):
        file = open(filename, "r")
        dot = file.read()
        self._check_brackets(dot)
        
        comments = [m for m in re.finditer(r'\".*\"', dot)]
        for m in comments:
            dot=dot[:m.span()[0]]+(dot[m.span()[0]:m.span()[1]]).replace(' ','\0')+dot[m.span()[1]:]
        dot = re.sub(r"[ \t\r]", "", dot) #deleting all spaces
        dot = re.sub(r"((digraph)|}|{)", "", dot)
        dot = re.sub(r"\/\/.*", "", dot)
        dot = re.sub(r"^\n$", "", dot)
        #print("Checking graph...")
        #graphcheck = re.search(r"\A(digraph)\w+\n?{((\/\/)*.*\n*)+}\Z", dot)
        #if graphcheck is None:
        #    print("Incorrect graph, check syntax!")
        #    exit()
        #
        #print("Graph id good, processing!")
        #dot = re.sub(r"//*$", "", dot) 
        dotlines = dot.splitlines()
        dotlines = list(filter(None, dotlines))
        self.fact.name = dotlines[0]
        dotlines = dotlines[1:]
        # ent_re - regular expr for edges, states, functions properties
        ent_re = re.compile(r"^\w+\[.*\]$")
        # top_re - regular expr for topology properties, most time consuming one
        top_re = re.compile(r"^(\w+,?)+(->|=>)(\w+,?)+(\[(\w+=(\(?\w+,?\)?)+,?)+\])?")
        # (r"^\w[\w\s,]*(->|=>)\s*\w[\w\s,=\[\]()]*$")
        for i, ln in enumerate(dotlines):
            if ent_re.match(ln):
                name, parm = self._param_from_entln(ln)
                self.fact.entities[name] = parm
            elif top_re.match(ln):
                self._topology(ln)
        return self.fact.build(Parser.subgr_count)

    toload = []
    edgemap = {}

    def _gen_branch(self,cur_state):
        root = cur_state.name
        edges = []
        while cur_state is not None:
            if len(cur_state.transfers)==0:
                cur_state = None
            elif len(cur_state.transfers)==1:
                edges.append({"pred": str(cur_state.transfers[0].edge.pred_f),
                              "morph": str(cur_state.transfers[0].edge.morph_f)})
                if str(cur_state.transfers[0].edge.pred_f) not in self.toload:
                    self.toload.append(str(cur_state.transfers[0].edge))
                if str(cur_state.transfers[0].edge.morph_f) not in self.toload:
                    self.toload.append(str(cur_state.transfers[0].edge))
                cur_state = cur_state.transfers[0].output_state
            else:
                pass
        self.edgemap[root] = list(filter(lambda x: x["morph"] != '', edges))
        return 

    def generate_cpp(self):
        self._gen_branch(self.fact.graph.init_state)
        print(self.edgemap)