def sl2ta(preds,sig,global_params,tiles,root_rule):
# create the finite tree automaton and a set of tiles based on
# the preprocessed system of predicates and its signatures
#'fin': 'f',
aut={'rules': [],'fin': root_rule}
eq_edges=0
for p in preds.keys():
(sig_fw,sig_bw,sig_eq)=sig[p]
(params,rules)= preds[p]
# check that root rule has no parameters
if p==root_rule and not (params==[''] or params==[]):
raise InputError("Root predicate has parameters")
for (al,pt,calls,equal) in rules:
x_sets=[]
lhs=[]
null=[]
self=[]
par=[]
if al in global_params:
par.append("al:%s"%al)
for x in equal:
if x in global_params:
par.append("al:%s"%x)
# sort the parameters (it will be done in equal way for all the rules)
par=sorted(par)
for x in range(0,len(pt)):
if (pt[x] in global_params) and not (pt[x] in [al]+equal):
par.append("%i:%s"%(x,pt[x]))
if pt[x]==al:
self.append(x)
if pt[x]=="nil":
null.append(x)
tmp=1
x_m1=[]
for x in sig_bw:
x_m1.append(pt.index(params[x]))
x_m1=sorted(x_m1)
for x in sig_eq:
if params[x] in equal+[al]:
x_m1.append("al")
elif params[x] in pt:
x_m1.append("s%i"%pt.index(params[x]))
else:
x_m1.append("X"+params[x])
eq_edges=1
# create the sets x_i^{fw} for i>=0 and place them into x_sets array
for (call_name,call_pars) in calls:
xi=[]
(c_fw,c_bw,c_eq)=sig[call_name]
for s in c_fw:
xi.append(pt.index(call_pars[s]))
xi=sorted(xi) # sort variable indicies
for s in c_eq:
if call_pars[s] in equal+[al]:
xi.append("al")
elif call_pars[s] in pt:
xi.append("s%i"%pt.index(call_pars[s]))
else:
xi.append("X"+call_pars[s])
eq_edges=1
x_sets.append(xi)
lhs.append(call_name)
# x_m1 contains input ports
# x_sets now contains output ports
#sort output ports according to selectors in paralel with lhs (the automata states)
(x_sets,lhs)=functions.paralel_sort(x_sets,lhs)
x_sets=[x_m1] + x_sets
tile=(x_sets,null,self,par)
tile=functions.tile_normalize(tile)
symbol=functions.tile_index(tile,tiles) # get an index to tiles list and use it as alphabet symbol
aut['rules'].append((symbol,lhs,p))
return aut,eq_edges
return 1 for i in range(1,len(a)): if a[i]==[]: return 0 return 1 def rotate_new_fin((symbol,lhs,rhs),qfin,pref,tiles): (aa,b,c,d)=tiles[symbol] a=list(aa) # !!!! call by value/call by name !!!! @#$%^%^&**( a.append(a[0]) del a[0] lhs.append(pref+rhs) # the output state "rhs" is changed to "pref+rhs" input state rhs=qfin # a new outpust state of the rule (a,lhs)=functions.paralel_sort(a,lhs) a=[[]]+a new_tile=functions.tile_normalize((a,b,c,d)) if check_tile_forward_connectivity(new_tile): symbol=functions.tile_index(new_tile,tiles) return((symbol,lhs,rhs)) else: # TILE NOT connected return(()) def rotate_old_root((symbol,lhs,rhs),lhs_num,pref,tiles): new_lhs=list(lhs) del new_lhs[lhs_num] tile_new_pt1=list(tiles[symbol][0]) tmp=tile_new_pt1.pop(lhs_num+1) tile_new_pt1[0]=tmp new_tile=(tile_new_pt1,tiles[symbol][1],tiles[symbol][2],tiles[symbol][3])
