def setPointByFormat(point, type_pt, value=None):
if type_pt == 'list.append':
con = NetP('.[i]').con(point, value)
con.m_permission = 0
elif type_pt == 'list.+=':
for pt in value:
con = NetP('.[i]').con(point, pt)
con.m_permission = 0
elif type_pt == 'list.clear':
list_del = []
for con in point.m_con:
if con.m_name == '.[i]' and con.m_db[
0] == point and con.m_db[1] != None:
list_del.append(con)
for pt in list_del:
pt.delete()
del list_del[:]
elif type_pt == 'list.pop':
list_pt = getPointByFormat(point, 'list')
pt = list_pt[-1]
for con in pt.m_con:
if con.m_name == '.[i]' and con.m_db[0] == point and con.m_db[
1] == pt:
con.delete()
del con
del pt
elif type_pt == 'list.remove':
list_pt = getPointByFormat(point, 'list')
if value in list_pt:
for con in value.m_con:
if con.m_name == '.[i]' and con.m_db[0] == point and con.m_db[
1] == value:
con.delete()
del con
def initialize(self, point):
if point == None:
point = NetP('editor')
self.m_self = point
point.m_dev = self
point.m_permission = 0
pt_text = tools_basic.getPoint(point, 'm_plainText', 'text')
pt_pool = tools_basic.getPoint(point, 'm_pool', 'pool')
pt_motor = tools_basic.getPoint(point, 'm_motor', 'compiler')
pt_debugger = tools_basic.getPoint(point, 'm_debugger', 'debugger')
pt_screen = tools_basic.getPoint(point, 'm_screen', 'screen')
self.modifyPtStruct(pt_debugger, pt_motor, pt_pool)
self.m_plainText = pt_text
self.setReadPtr(pt_text)
self.m_pool = Pool(pt_pool)
self.m_motor = Motor(pt_motor)
self.m_debugger = Debugger(pt_debugger)
self.m_screen = Brain(pt_screen)
self.m_pool.register(self.m_screen.m_self)
self.m_pool.register(self.m_debugger.m_self)
self.updateByPts()
self.setFont(QFont('宋体'))
self.setStyleSheet('font: 20px;')
self.show()
def getPoint(point, key, default=''):
dict_pt = ptToDict(point)
con = dict_pt.get(key, None)
if con == None:
con = NetP(key).con(point, NetP(default))
con.m_permission = 0
pt = con.m_db[1]
pt.m_permission = 0
return pt
def initialize(self, point):
if point == None:
point = NetP('screen')
self.m_self = point
point.m_permission = 0
point.m_dev = self
pt_select = tools_basic.getPoint(point, 'm_select', 'list')
self.m_select = tools_basic.getPointByFormat(pt_select, 'list')
def inputToken(string,list_pt):
[inputs,string,list_pt]=formulaToken(string,list_pt)
last=inputs
while string!='' and string[0]==',':
relation=NetP('and')
list_pt.append(relation)
string=string[1:]
[point,string,list_pt]=formulaToken(string,list_pt)
relation.con(last,point)
last=point
return [inputs,string,list_pt]
def formulaToken(string,list_pt):
[formula,string,list_pt]=variableToken(string,list_pt)
if string=='':
return [formula,string,list_pt]
elif string[0]=='+' or string[0]=='-' or string[0]=='*' or string[0]=='/' or string[0]=='^':
relation=NetP(string[0])
list_pt.append(relation)
string=string[1:]
[point,string,list_pt]=formulaToken(string,list_pt)
relation.con(formula,point)
return [formula,string,list_pt]
def initialize(self, point):
if point == None:
point = NetP('debugger')
self.m_self = point
point.m_dev = self
point.m_permission = 0
pt_motor = tools_basic.getPoint(point, 'm_motor', 'compiler')
if pt_motor.m_dev == None:
self.m_motor = Motor(pt_motor)
else:
self.m_motor = pt_motor.m_dev
def varSmToken(code,list_pt):
nameFormat=r'^[\w\.]+'
name=re.match(nameFormat,code).group()
if name=='':
raise Exception('Error! Invalid name!')
code=re.sub(nameFormat,'',code)
if code=='' or code[0]!='=':
raise Exception('Error! Every variable must be assigned by some values.')
code=code[1:]
[code,content]=conSmToken(code)
var=NetP(name)
list_pt.append(var)
var.m_text=content
return [code,var]
def equationToken(string,list_pt=None):
sign=None
equation=None
equal=None
if list_pt==None:
list_pt=[]
if string[0]=='-':
sign=NetP('-')
list_pt.append(sign)
string=string[1:]
[formula,string,list_pt]=formulaToken(string,list_pt)
equation=formula
if sign!=None:
sign.con(None,formula)
if string=='':
return [equation,string,list_pt]
elif string[0]=='=':
equal=NetP('=')
list_pt.append(equal)
string=string[1:]
[point,string,list_pt]=equationToken(string,list_pt)
equal.con(equation,point)
if string=='':
return [equation,string,list_pt]
raise Exception('Error: wrong equation format!')
def buildNetP(self, name, con0_name='', con1_name=''):
recent = self.m_builtStack[-1]
undefined = self.m_undefinedStack[-1]
point = undefined.get(name, None)
if point == None:
point = NetP(re.sub(r'#.*$', '', name))
recent.update({name: point})
else:
undefined.pop(name)
if con0_name != '':
con0 = recent.get(con0_name, None)
if con0 == None:
con0 = NetP(re.sub(r'#.*$', '', con0_name))
recent.update({con0_name: con0})
undefined.update({con0_name: con0})
point.connect(con0, 0)
if con1_name != '':
con1 = recent.get(con1_name, None)
if con1 == None:
con1 = NetP(re.sub(r'#.*$', '', con1_name))
recent.update({con1_name: con1})
undefined.update({con1_name: con1})
point.connect(con1, 1)
return point
def initialize(self, point):
if point == None:
point = NetP('compiler')
self.m_self = point
point.m_dev = self
point.m_permission = 0
pt_source = tools_basic.getPoint(point, 'm_source', 'incomingPool')
pt_terms = tools_basic.getPoint(point, 'm_terms', 'list')
self.m_inputs = pt_source.m_dev.m_pool
self.m_terms = tools_basic.getPointByFormat(pt_terms, 'list')
for term in self.m_terms:
term.m_permission = 0
print(self.info())
def initialize(self, point):
if point == None:
point = NetP('library')
self.m_self = point
point.m_dev = self
point.m_permission = 0
pt_motor = tools_basic.getPoint(point, 'm_motor', 'compiler')
pt_terms = tools_basic.getPoint(point, 'm_terms', 'list')
self.m_motor = pt_motor.m_dev
self.m_terms = tools_basic.getPointByFormat(pt_terms, 'list')
for term in self.m_terms:
term.m_permission = 0
print(self.info())
def initializeSys(self):
if self.m_sysDict != {}:
return
self.m_sysDict = {
'system': [NetP('选中'), self.m_origin],
'selection': []
}
def __init__(self, point=None):
super().__init__()
self.m_self = None
self.m_pool = []
self.m_inPool = None
self.m_outPool = None
self.m_sysDict = {}
self.m_unit = 40
self.m_worldOrigin = [-5, -5]
self.m_sizeW = [500, 500]
self.m_posW = [100, 200]
self.m_select = []
self.m_mode = 0 # 0-normal, 1-connect left, 2-connect right
# discription:
self.m_origin = NetP('起点')
self.m_origin.m_pos = self.m_worldOrigin
self.initialize(point)
self.setWindow()
self.show()
self.initializeSys()
def readStdCode(code):
parts = re.split('[ \t\n]*_{3,}[ \t\n]*', code)
list_pt = NetP('').build(parts[0])
parts.pop(0)
list_km = []
for part in parts:
list_km.append(readStdCode_karma(part, list_pt))
return [list_km, list_pt]
def initialize(self,point):
if point==None:
point=NetP('pool')
self.m_self=point
point.m_dev=self
point.m_permission=0
pt_lib=tools_basic.getPoint(point,'m_lib','actions')
pt_contain=tools_basic.getPoint(point,'m_contain','points')
pt_pool=tools_basic.getPoint(point,'m_pool','list')
pt_lib.m_permission=0
pt_contain.m_permission=0
pt_pool.m_permission=0
self.m_lib=Library(pt_lib)
self.m_contain=pt_contain
self.m_pool=tools_basic.getPointByFormat(pt_pool,'list')
def str2struct(string):
list_pt=[]
this=None
for letter in string:
this=NetP(letter)
if list_pt!=[]:
list_pt[-1].connect(this,1)
list_pt.append(this)
return list_pt
def divideSents_tokener(code):
list_sent = []
code = re.sub(r'%.*\n', '\n', code)
code = re.sub(r'^[ \t\n]*', '', code)
code_keep = code
while code != '':
[code, karma, pointStack] = chainToken(code)
si = code_keep.rfind(code)
text = code_keep[0:si]
if code != '' and code[0] == ';':
code = code[1:]
code = re.sub(r'^[ \t\n]*', '', code)
code_keep = code
sent = NetP(karma.m_symbol.m_name, text)
list_sent.append(sent)
return list_sent
def register(self,dev_pt,mode=2):
if dev_pt.m_dev==None:
return
else:
device=dev_pt.m_dev
if mode==0 or mode==2:
if device not in self.m_outDev:
self.m_outDev.append(device)
device.m_inPool=self
con=NetP('output')
con.con(self.m_self,dev_pt)
# self.m_sysPool.append(con)
if mode==1 or mode==2:
if device not in self.m_inDev:
self.m_inDev.append(device)
device.m_outPool=self
con=NetP('input')
con.con(self.m_self,dev_pt)
def SmileiToken(code,title,list_pt=None):
if list_pt==None:
list_pt=[]
point=NetP('smilei')
point.m_text=title
list_pt.append(point)
code=re.sub(r'[ \t]','',code)
code=re.sub(r'#.*\n','',code)
while code!='':
code=re.sub(r'^\n*','',code)
if code=='':
break
else:
[code,line_pt]=lineSmToken(code,list_pt)
con=NetP('in')
list_pt.append(con)
con.con(point,line_pt)
return [code,list_pt]
def info(self):
information = '+++++++ MOTOR ++++++\nName: ' + self.m_self.m_name + '\nLibrary: '
for dirc in self.m_lib:
information += dirc + ';\n'
information += '\nterms: '
for term in self.m_terms:
information += term.m_name
if term != self.m_terms[-1]:
information += ', '
information += '\nMaps: '
for sent in self.m_mapDict:
information += sent.m_symbol.m_name + '('
for map in self.m_mapDict[sent]:
information += map.m_name
if map != self.m_mapDict[sent][-1]:
information += ', '
information += ') '
information += '\n'
return information
def print(self):
print(self.info())
if __name__ == '__main__':
test = Motor(None)
pool = NetP('').build('a(,);b(a,);c(d,b);d(,)')
test.m_inputs = pool
list_new = test.runCode('a(,)->+c(,a)')
for point in list_new:
point.print()
def variableToken(string,list_pt):
variable_name=''
variable=None
if string=='':
raise Exception('Error: empty variable.')
elif string[0]=='(':
sign=None
variable=NetP('括号')
list_pt.append(variable)
relation=NetP('in')
list_pt.append(relation)
string=string[1:]
if string[0]=='-':
sign=NetP('-')
list_pt.append(sign)
[point,string,list_pt]=formulaToken(string,list_pt)
relation.con(variable,point)
if sign!=None:
sign.con(None,point)
if string=='' or string[0]!=')':
raise Exception('Error: unbalanced bracket!')
else:
string=string[1:]
elif string[0].isdigit():
while True:
if string!='' and string[0].isdigit():
variable_name+=string[0]
string=string[1:]
else:
break
variable=NetP(variable_name)
list_pt.append(variable)
elif string[0].isalpha():
while True:
if string=='':
break
elif string[0].isdigit() or string[0].isalpha():
variable_name+=string[0]
string=string[1:]
else:
break
variable=NetP(variable_name)
list_pt.append(variable)
if string!='' and string[0]=='(':
relation=NetP('in')
list_pt.append(relation)
string=string[1:]
[inputs,string,list_pt]=inputToken(string,list_pt)
relation.con(variable,inputs)
if string=='' or string[0]!=')':
raise Exception('Error: unbalanced brackets.')
else:
string=string[1:]
return [variable,string,list_pt]
def lineSmToken(code,list_pt):
nameFormat=r'^[\w\.]+'
name=re.match(nameFormat,code).group()
if name=='':
raise Exception('Error! Invalid name of function or variable!')
code=re.sub(nameFormat,'',code)
line_pt=NetP(name)
list_pt.append(line_pt)
if code!='' and code[0]=='=':
code=code[1:]
[code,content]=conSmToken(code)
if content=='':
raise Exception('Error! Invalid assignment value!')
line_pt.m_text=content
elif code!='' and code[0]=='(':
code=code[1:]
code=re.sub(r'^\n*','',code)
[code,var]=varSmToken(code,list_pt)
con=NetP('in')
list_pt.append(con)
con.con(line_pt,var)
while True:
if code!='' and code[0]==',':
code=code[1:]
else:
break
code=re.sub(r'^\n*','',code)
if code!='' and code[0]==')':
break
[code,var]=varSmToken(code,list_pt)
con=NetP('in')
list_pt.append(con)
con.con(line_pt,var)
code=re.sub(r'^\n*','',code)
if code=='' or code[0]!=')':
raise Exception('Error! Unbalanced bracket!')
code=code[1:]
return [code,line_pt]
def buildPoint(point_str, recent, undefined):
aNetPoint = re.compile(
r'([\w.,\[\]#=+*\\\-^$_\'~:@/\(\)]*)\(([\w.,\[\]#=+*\\\-^$_\'~:@/\(\)]*), *([\w.,\[\]#=+*\\\-^$_\'~:@/\(\)]*)\)\[([-0-9]+),([-0-9]+)\]'
)
aNetPoint2 = re.compile(
r'([\w.,\[\]#=+*\\\-^$_\'~:@/\(\)]*)\(([\w.,\[\]#=+*\\\-^$_\'~:@/\(\)]*), *([\w.,\[\]#=+*\\\-^$_\'~:@/\(\)]*)\)(?![\[])'
)
# selfName=re.compile(r'([\w.,\[\]#=+*\\\-^$_\'~:@/\(\)]*)(?=[\(\[])')
# con0Name=re.compile(r'\(([\w.,\[\]#=+*\\\-^$_\'~:@/\(\)]*),')
# con1Name=re.compile(r', *([\w.,\[\]#=+*\\\-^$_\'~:@/\(\)]*)\)')
# posX=re.compile(r'\[([-0-9]+),')
# posY=re.compile(r',([-0-9]+)\]')
parts = aNetPoint.findall(point_str)
if parts == []:
parts = aNetPoint2.findall(point_str)
if parts == []:
print('Error! Invalid point!')
return [None, recent, undefined]
# building:
# find information:
name = parts[0][0]
con0_name = parts[0][1]
con1_name = parts[0][2]
if len(parts[0]) > 3:
x = parts[0][3]
y = parts[0][4]
else:
x = []
y = []
# build point:
point = undefined.get(name, None)
if point != None:
undefined.pop(name)
else:
point = NetP(name)
recent.update({name: point})
if con0_name != '':
con0 = recent.get(con0_name, None)
if con0 == None:
con0 = NetP(con0_name)
recent.update({con0_name: con0})
undefined.update({con0_name: con0})
point.connect(con0, 0)
if con1_name != '':
con1 = recent.get(con1_name, None)
if con1 == None:
con1 = NetP(con1_name)
recent.update({con1_name: con1})
undefined.update({con1_name: con1})
point.connect(con1, 1)
if x != []:
point.m_pos[0] = int(x)
if y != []:
point.m_pos[1] = int(y)
point.m_name = re.sub(r'#.*$', "", point.m_name)
return [point, recent, undefined]
actions+=actions_new
outputs+=outputs_new
self.input(outputs_new,0)
if action in self.m_pool:
action.con(None,None)
tools_basic.setPointByFormat(pt_pool,'list.remove',action)
self.m_pool.remove(action)
return outputs
def info(self):
info_str=''
for point in self.m_pool:
info_str+=point.info()+'\n'
return info_str
def printSysPool(self):
print('==============================')
print('System pool:')
for con in self.m_self.m_con:
con.print()
print('==============================')
if __name__=='__main__':
interior=Pool()
list_pt=NetP('').build('a(,)[1,2];b(,)[4,4];c(a,b)[2,3]')
interior.m_pool=list_pt
info += '=>>'
info = end.info_karma(info, head + 3)
n += 1
else:
if end.m_no == False:
info += '\n' + '->>'.rjust(head + 3)
else:
info += '\n' + '=>>'.rjust(head + 3)
info = end.info_karma(info, head)
return info
if __name__ == '__main__':
points = [
NetP('0'),
NetP('1'),
NetP('2'),
NetP('3'),
NetP('4'),
NetP('5'),
NetP('6'),
NetP('7'),
NetP('8'),
NetP('9')
]
test = Karma(NetP('[self]'))
f = open('test\\test.txt')
code = f.read()
test.build(code, points)
def setPoint(point, key, value):
for con in point.m_con:
if con.m_db[0] == point and con.m_name == key:
con.con(point, value)
return
NetP(key).con(point, value)
def newMap(self, pool, areaType, list_new):
if self.m_restricted == True: # restrict the map pool by m_listMP
list_map = self.m_listMP
elif self.m_ranger != None and self.m_ranger.buildingNewMap(
) == False: # restrict the map pool by m_cause
if self.m_rangType == True:
if self.m_ranger.m_map==None or self.m_ranger.m_map.m_con==[]:
list_map = dictToList(pool)
else:
list_map = self.m_ranger.m_map.m_con.copy()
elif self.m_ranger.m_symbol.m_db[
0] != None and self.m_ranger.m_symbol.m_db[
0] == self.m_symbol:
if self.m_ranger.m_map.m_db[0] == None:
list_map = dictToList(pool)
else:
list_map = [self.m_ranger.m_map.m_db[0]]
else:
if self.m_ranger.m_map.m_db[1] == None:
list_map = dictToList(pool)
else:
list_map = [self.m_ranger.m_map.m_db[1]]
elif self.selfType() == '实万用链节' or self.selfType(
) == '实否定链节': # '_point' and '' aren't restricted
list_map = dictToList(pool)
if len(self.m_symbol.m_name
) > 2 and self.m_symbol.m_name[1] == '_':
for mp in list_map:
if mp in list_new:
list_map.remove(mp)
else:
list_map = dictToList(pool)
# list_map=pool.get(self.m_symbol.m_name,[])
# print('pool:',pool)
if self.m_buildMode == False or areaType == False:
name = self.m_symbol.m_name
# function points
if self.isFunctionPoint() == 1:
if self.m_map == None:
point = NetP(name, self.m_symbol.m_text)
point.m_needed = self
point.m_creator = self
self.map(point)
else:
self.m_map.delete()
del self.m_map
self.map(None)
return
elif self.isFunctionPoint() == 2:
# function points [P] don't find map from pool
if self.m_map == None:
point = NetP(name, self.m_symbol.m_text)
point.m_needed = self
self.map(point)
self.m_interp = True
else:
self.m_map.delete()
self.m_map = m_needed = None
self.map(None)
return
# only take real points when karma is start with _ and ~
list_have = []
for point in list_map:
if self.selfType() == '实万用链节' or self.selfType() == '实否定链节':
if point.m_creator != None or point.m_needed == None:
list_have.append(point)
# else:
# pass
# print('Erased from map_list:',point.info(),', it should be an imagine point.')
else:
list_have.append(point)
mp = self.m_map
self.map(self.nextInlist(mp, list_have))
return
else:
name = self.m_symbol.m_name
# answer questions
# +word(,)
if name != '' and (name[0] != '[' or name[-1] != ']'):
if self.m_map != None:
self.m_map.m_creator = None
if self.m_map.m_needed == None:
self.m_map.delete()
self.map(None)
return
else:
self.m_map.m_name = '[' + self.m_map.m_name + ']'
list_need = []
for point in list_map:
if point.m_creator == None and point.m_needed != None:
list_need.append(point)
point = self.m_map
self.map(self.nextInlist(point, list_need))
if self.m_map == None:
if self.m_restricted == True:
self.map(None)
return
point = NetP(self.m_symbol.m_name, self.m_symbol.m_text)
self.map(point)
else:
self.m_map.m_name = self.m_map.m_name[1:-1]
self.m_map.m_creator = self
return
# +[word](,)
else:
if self.m_map == None:
point = NetP(name, self.m_symbol.m_text)
point.m_needed = self
self.map(point)
return
else:
self.m_map.m_needed = None
self.m_map.delete()
self.map(None)
return
self.map(None)
km.m_restricted=True
map_res=inputs.get(name[0],[])
if map_res==[]:
km.m_listMP=map_res
else:
km.m_listMP=[map_res]
pool=tools_basic.listToDict(pool_ls)
state_re,pool,list_new=karma.Reason_iterative(pool,show)
if state_re=='dark yellow':
return state_re,dict_out
name_op=re.compile(r'^\[output_?([\w]*)\]$')
for point in list_new:
name=name_op.findall(point.m_name)
if name!=[]:
list_out=dict_out.get(name[0],[])
if point.m_db[1]!=None and point.m_db[1] not in list_out:
list_out.append(point.m_db[1])
dict_out.update({name[0]:list_out})
return state_re,dict_out
if __name__=='__main__':
list_pt=NetP('').build('a(,);b(,);b#2(a,);c(,)')
list_pt[0].print()
state_re,dict_out=run('r\'\w\'(,)->a(,)->[eq](a,~b)->~b(,)->_[input_a](,)->+[output](,_[input_a])',list_pt,{'a':list_pt[0]},0)
print(dict_out)
for term in dict_out:
for point in dict_out[term]:
point.print()