def times_cont(value, solver):
if matched_times>0: matched_list.append(getvalue(template, solver.env))
for _ in unify(expect_times, matched_times, solver.env):
for _ in unify(result, matched_list, solver.env):
yield cont, True
next_cont = lazy_times_result_cont(item, cont, matched_times+1, matched_list, template, result)
yield solver.cont(item, next_cont), True
def sub_sequence_cont(value, solver):
if not isinstance(sub, Var):
if sub=='': return
if isinstance(before, Var): startbefore, stopbefore = 0, len(sequence)+1
else: startbefore, stopbefore = before, before+1
for _ in unify(length, len(sub), solver.env):
start = startbefore
while start<stopbefore:
start = sequence.find(sub, start)
if start<0: return
for _ in unify(before, start, solver.env):
for _ in unify(after, start+len(sub), solver.env):
yield cont, True
start += 1
else:
if not isinstance(before, Var) \
and not isinstance(length, Var)\
and not isinstance(after, Var):
if start+length!=after: return
for _ in sub.unify(sequence[before:after], solver.env):
yield cont, sequence[before:after]
elif not isinstance(before, Var) and not isinstance(length, Var):
if before+length>len(sequence): return
for _ in sub.unify(sequence[before:after], solver.env):
for _ in after.unify(before+length, solver.env):
yield cont, sequence[before:before+length]
elif not isinstance(length, Var) and not isinstance(after, Var):
if after-length<0: return
for _ in sub.unify(sequence[after-length:after], solver.env):
for _ in length.unify(length, solver.env):
yield cont, sequence[after-length:after:after]
elif not isinstance(before, Var):
for leng in range(1, len(sequence)-before+1):
for _ in sub.unify(sequence[before:before+leng], solver.env):
for _ in length.unify(leng, solver.env):
for _ in after.unify(before+leng, solver.env):
yield cont, sequence[before:before+leng]
elif not isinstance(after, Var):
for leng in range(1, after):
for _ in sub.unify(sequence[after-leng+1:after], solver.env):
for _ in length.unify(leng, solver.env):
for _ in before.unify(after-leng+1, solver.env):
yield cont, sequence[before:after]
elif not isinstance(length, Var):
for start in range(len(sequence)-length):
for _ in sub.unify(sequence[start:start+length], solver.env):
for _ in before.unify(start, solver.env):
for _ in after.unify(start+length, solver.env):
yield cont, sequence[start:start+length]
else:
for start in range(len(sequence)):
for leng in range(1, len(sequence)-start+1):
for _ in sub.unify(sequence[start:start+leng], solver.env):
for _ in before.unify(start, solver.env):
for _ in length.unify(leng, solver.env):
for _ in after.unify(start+leng, solver.env):
yield cont, sequence[start:start+leng]
def times_cont(value, solver):
if matched_times>0:
matched_list1 = matched_list+[getvalue(template, solver.env)]
else: matched_list1 = matched_list
next_cont = nongreedy_times_result_cont(item, expect_times, cont,
matched_times+1, matched_list1, template, result)
yield solver.cont(item, next_cont), True
for _ in unify(expect_times, matched_times, solver.env):
for _ in unify(result, matched_list1, solver.env):
yield cont, True
def times_cont(value, solver):
if matched_times>0: matched_list.append(getvalue(template, solver.env))
if expect_times==matched_times:
for _ in unify(result, matched_list, solver.env):
yield cont, True
else:
for _ in unify(result, matched_list, solver.env):
yield cont, True
next_cont = lazy_times_less_result_cont(item, expect_times, cont,
matched_times+1, matched_list, template, result)
for c, x in solver.exp_run_cont(item, next_cont):
yield next_cont, x
def times_cont(value, solver):
if matched_times>0: matched_list1 = matched_list+[getvalue(template, solver.env)]
else: matched_list1 = matched_list
if expect_times==matched_times:
for _ in unify(result, matched_list1, solver.env):
yield cont, True
else:
next_cont = nongreedy_times_less_result_cont(item, expect_times, cont,
matched_times+1, matched_list1, template, result)
for c, x in solver.exp_run_cont(item, next_cont):
yield c, x
for _ in unify(result, matched_list1, solver.env):
yield cont, True
def times_cont(value, solver):
if matched_times>0: matched_list.append(getvalue(template, solver.env))
matched = [False]
next_cont = greedy_times_result_cont(item, expect_times, cont,
matched_times+1, matched_list, template, result)
@mycont(next_cont)
def try_times_cont(value, solver):
matched[0] = True
yield next_cont, True
yield solver.cont(item, try_times_cont), value
if matched[0]: return
for _ in unify(expect_times, matched_times, solver.env):
for _ in unify(result, matched_list, solver.env):
yield cont, True
def seplist_times_less_bultin(solver, cont, item, separator, template, result):
expect_times = deref(expect_times, solver.env)
if not isinstance(expect_times, int): raise ValueError(expect_times)
if expect_times==0:
if result is None: yield cont, True
else:
for _ in unify(result, []):
yield cont, True
result1 = deref(result, solver.env)
if result1 is not None:
template1 = deref(template, solver.env)
temp_result = Var('temp_result')
else:
template1 = None
temp_result = None
if mode==greedy:
matched = False
for c, v in solver.exp_run_cont(item, cont):
matched = True
next_cont = make_times_less_cont(solver, cont, item1, separator1,
expect_times1-1, 1, [], template1, result1, mode)
yield c, v
if not matched:
if result1 is None:
yield cont, True
else:
for _ in unify(result1, []):
yield cont, True
elif mode==nongreedy:
for c, v in solver.exp_run_cont(item, cont):
next_cont = make_times_less_cont(solver, cont, item1, separator1,
expect_times1-1, 1, [], template1, result1, mode)
yield c, v
if result1 is None:
yield cont, True
else:
for _ in unify(result1, []):
yield cont, True
else: #mode==lazy
if result1 is None:
yield cont, True
else:
for _ in unify(result1, []):
yield cont, True
for c, v in solver.exp_run_cont(item, cont):
next_cont = make_times_less_cont(solver, cont, item1, separator1,
expect_times1-1, 1, [], template1, result1, mode)
yield c, v
def times_less(solver, cont, item, expect_times, template=None, result=None, mode=nongreedy):
item = deref(item, solver.env)
expect_times = getvalue(expect_times, solver.env)
template = deref(template, solver.env)
result = deref(result, solver.env)
if not isinstance(expect_times, int): raise ValueError(expect_times)
if expect_times<0: raise ValueError(self)
elif expect_times==0:
for c, _ in solver.exp_run_cont(nullword, cont):
if result is not None:
for _ in unify(result, [], solver.env):
yield c, True
else: yield cont, True
else:
if result is None:
if mode==greedy:
yield greedy_times_less_cont(item, expect_times, cont, 0), True
elif mode==nongreedy:
yield nongreedy_times_less_cont(item, expect_times, cont, 0), True
else:# mode==lazy:
yield lazy_times_less_cont(item, expect_times, cont, 0), True
else:
if mode==greedy:
yield greedy_times_less_result_cont(
item, expect_times, cont, 0, [], template, result), []
elif mode==nongreedy:
yield nongreedy_times_less_result_cont(
item, expect_times, cont, 0, [], template, result), []
else: # mode==lazy
yield lazy_times_less_result_cont(
item, expect_times, cont, 0, [], template, result), []
def times_cont(value, solver):
if matched_times>0: matched_list.append(getvalue(template, solver.env))
if expect_times==matched_times:
for _ in unify(result, matched_list, solver.env):
yield cont, True
return
else: yield solver.cont(item, greedy_times_result_cont(item, expect_times, cont,
matched_times+1, matched_list, template, result)), True
def seplist_bultin(solver, cont, item, separator):
for _ in unify(result, [], solver.env):
yield cont, True
separator1 = deref(separator, solver.env)
item1 = deref(item, solver.env)
yield solver.cont(item1, lazy_repeat_result_cont(
(and_p, separator1, item1), cont, 1, [],
deref(template, solver.env), deref(result, solver.env))), []
def operator(solver, arity, symbol, prior, assoc, operation):
arity = getvalue(arity, solver.env, {})
symbol = getvalue(symbol, solver.env, {})
text, pos = solver.parse_state
if not isinstance(symbol, Var):
if not text[pos:].startswith(symbol): return
for _ in unify(assoc, get_association(symbol, arity), solver.env):
for _ in unify(operation, get_operation(symbol, arity), solver.env):
for _ in unify(operation, get_operation(symbol, arity), solver.env):
solver.parse_state = text, pos+len(symbol)
#print 'operator'
yield cont, symbol
solver.parse_state = text, pos
return
length = operator_fsms[arity-1].match(text[pos:])
if length==0: return
else:
op_str = text[pos:pos+length]
for _ in unify(prior, get_priority(op_str, arity), solver.env):
for _ in unify(assoc, get_association(op_str, arity), solver.env):
for _ in unify(operation, get_operation(op_str, arity), solver.env):
for _ in unify(symbol, op_str, solver.env):
solver.parse_state = text, pos+length
#print 'operator'
yield cont, op_str
solver.parse_state = text, pos
def operator(solver, arity, symbol, prior, assoc, operation):
arity = getvalue(arity, solver.env, {})
symbol = getvalue(symbol, solver.env, {})
text, pos = solver.parse_state
if not isinstance(symbol, Var):
if not text[pos:].startswith(symbol): return
for _ in unify(assoc, get_association(symbol, arity), solver.env):
for _ in unify(operation, get_operation(symbol, arity),
solver.env):
for _ in unify(operation, get_operation(symbol, arity),
solver.env):
solver.parse_state = text, pos + len(symbol)
#print 'operator'
yield cont, symbol
solver.parse_state = text, pos
return
length = operator_fsms[arity - 1].match(text[pos:])
if length == 0: return
else:
op_str = text[pos:pos + length]
for _ in unify(prior, get_priority(op_str, arity), solver.env):
for _ in unify(assoc, get_association(op_str, arity), solver.env):
for _ in unify(operation, get_operation(op_str, arity),
solver.env):
for _ in unify(symbol, op_str, solver.env):
solver.parse_state = text, pos + length
#print 'operator'
yield cont, op_str
solver.parse_state = text, pos
def char(solver, cont, argument):
argument = deref(argument, solver.env)
text, pos = solver.parse_state
if pos==len(text):
return
for _ in unify(argument, text[pos], solver.env):
solver.parse_state = text, pos+1
yield cont, text[pos]
solver.parse_state = text, pos
def contain(solver, cont, container, member):
container = getvalue(container, solver.env)
member = getvalue(member, solver.env)
if isinstance(member, Var):
for x in container:
for _ in unify(member, x, solver.env):
yield cont, True
elif member in container:
yield cont, True
def func(solver, cont, arg0):
#assert isinstance(arg0, Var) and arg0.free(solver.env)
text, pos = solver.parse_state
c = text[pos]
if not test(c): return
for _ in unify(arg0, c, solver.env):
solver.parse_state = text, pos+1
yield cont, True
solver.parse_state = text, pos
def seplist_bultin(solver, cont, item, separator, template, result):
separator1 = deref(separator, solver.env)
item1 = deref(item, solver.env)
for c, _ in solver.exp_run_cont(item1, cont):
yield greedy_repeat_result_cont(
(and_p, separator1, item1), c, 1, [],
deref(template, solver.env), deref(result, solver.env)), []
return
for _ in unify(result, [], solver.env):
yield cont, True
def times_bultin(solver, cont, item, template, result):
expectTimes1 = getvalue(expect_times, solver.env)
if isinstance(expectTimes1, int):
if expectTimes1<0: raise Error
elif expectTimes1==0:
for _ in unify(result, [], solver.env): yield cont, True
return
yield lazy_times_result_cont(
deref(item, solver.env), expectTimes1, cont, 0, [],
deref(template, solver.env), deref(result, solver.env)), []
def get_label(solver, label=None):
if isinstance(label, str): yield cont, label
global new_label_id
new_label = 'label_%s$' % str(new_label_id)
new_label_id += 1
if isinstance(label, Var):
for _ in unify(label, new_label, solver.env):
yield cont, new_label
else:
yield cont, new_label
new_label_id -= 1
def get_label(solver, label=None):
if isinstance(label, str): yield cont, label
global new_label_id
new_label = 'label_%s$'%str(new_label_id)
new_label_id += 1
if isinstance(label, Var):
for _ in unify(label, new_label, solver.env):
yield cont, new_label
else:
yield cont, new_label
new_label_id -= 1
def times_cont(value, solver):
matched = [False]
next_cont = nongreedy_times_cont(item, expect_times, cont, matched_times+1)
@mycont(next_cont)
def try_times_cont(value, solver):
matched[0] = True
yield next_cont, value
yield solver.cont(item, try_times_cont), value
if matched[0]: return
for _ in unify(expect_times, matched_times, solver.env):
yield cont, True
def call(solver, args=None, kwargs=None):
args = deref(args, solver.env)
kwargs = deref(kwargs, solver.env)
syntax_result, pos = solver.parse_state
if pos==len(syntax_result): return
try:
if syntax_result[pos][0]!=__call__: return
except: return
if args is not None:
for _ in unify(args, syntax_result[pos][1], solver.env):
if kwargs is not None:
for _ in unify(kwargs, syntax_result[pos][2], solver.env):
solver.parse_state = syntax_result, pos+1
yield cont, True
else:
solver.parse_state = syntax_result, pos+1
yield cont, True
else:
solver.parse_state = syntax_result, pos+1
yield cont, True
solver.parse_state = syntax_result, pos
def seplist_bultin(solver, cont, item, separator, template, result):
separator1 = deref(separator, solver.env)
item1 = deref(item, solver.env)
expectTimes1 = getvalue(expect_times, solver.env)
if isinstance(expectTimes1, int):
if expectTimes1<0: raise Error
elif expectTimes1==0:
for _ in unify(result, [], solver.env): yield cont, True
return
yield solver.cont(item1, lazy_times_result_cont(
(and_p, separator1, item1), expectTimes1, cont, 1, [],
deref(template, solver.env), deref(result, solver.env))), []
def func(solver, cont, arg):
#assert isinstance(arg, Var) and arg.free(solver.env)
text, pos = solver.parse_state
string = ''
i = 0
while pos+i<len(text):
char = text[pos+i]
if not test(char): break
string += char
i += 1
if onceMore and string=='': return
for _ in unify(arg, string, solver.env):
solver.parse_state = text, pos+i
yield cont, True
solver.parse_state = text, pos
def number(solver, cont, arg0):
text, pos = solver.parse_state
length = len(text)
if pos>=length: return
if not '0'<=text[pos]<='9': return
p = pos
while p<length:
char = text[p]
if not '0'<=char<='9': break
p += 1
val = eval(text[pos:p])
for _ in unify(arg0, val, solver.env):
solver.parse_state = text, p
yield cont, True
solver.parse_state = text, pos
def func(solver, argument=None):
argument = deref(argument, solver.env)
syntax_result, pos = solver.parse_state
## print syntax_result, syntax_result[pos][1]
if pos==len(syntax_result): return
try:
if syntax_result[pos][0]!=attr: return
except: return
if argument is not None:
for _ in unify(argument, syntax_result[pos][1], solver.env):
solver.parse_state = syntax_result, pos+1
yield cont, True
else:
solver.parse_state = syntax_result, pos+1
yield cont, True
solver.parse_state = syntax_result, pos
def symbol(solver, result):
text, pos = solver.parse_state
if pos >= len(text): return
char = text[pos]
if char in _SYMBOL_FORBID_CHARS or '0' <= char <= '9':
return
p = pos
while p < len(text):
if text[p] in _SYMBOL_FORBID_CHARS: break
else: p += 1
name = text[pos:p]
sym = _builtins.get(name, var(name))
for _ in term.unify(result, sym, solver.env):
solver.parse_state = text, p
yield cont, True
solver.parse_state = text, pos
def symbol(solver, cont, result):
text, pos = solver.parse_state
if pos>=len(text): return
char = text[pos]
if char in _SYMBOL_FORBID_CHARS or '0'<=char<='9':
return
p = pos
while p<len(text):
if text[p] in _SYMBOL_FORBID_CHARS: break
else: p += 1
name = text[pos:p]
sym = _builtins.get(name, var(name))
for _ in term.unify(result, sym, solver.env):
solver.parse_state = text, p
yield cont, True
solver.parse_state = text, pos
def identifier(solver, arg):
text, pos = solver.parse_state
length = len(text)
if pos>=length: return
p = pos
if text[p]!='_' and not 'a'<=text[p]<='z' and not 'A'<=text[p]<='Z':
return
p += 1
while p<length and (text[p]=='_' or 'a'<=text[p]<='z' or 'A'<=text[p]<='Z'
'0'<=text[p]<='9'):
p += 1
w = text[pos:p]
if w in keywords: return
for _ in unify(arg, w, solver.env):
solver.parse_state = text, p
yield cont, w
solver.parse_state = text, pos
def func(solver, cont, arg0):
#assert isinstance(arg0, Var) and arg0.free(solver.env)
text, pos = solver.parse_state
if pos>=len(text): return
if text[pos]!=quote: return
p = pos+1
while p<len(text):
char = text[p]
p += 1
if char=='\\': p += 1
elif char==quote:
string = text[pos+1:p-1]
break
else: return
for _ in unify(arg0, string, solver.env):
solver.parse_state = text, p
yield cont, True
solver.parse_state = text, pos
def identifier(solver, arg):
text, pos = solver.parse_state
length = len(text)
if pos >= length: return
p = pos
if text[p] != '_' and not 'a' <= text[p] <= 'z' and not 'A' <= text[
p] <= 'Z':
return
p += 1
while p < length and (text[p] == '_' or 'a' <= text[p] <= 'z'
or 'A' <= text[p] <= 'Z'
'0' <= text[p] <= '9'):
p += 1
w = text[pos:p]
if w in keywords: return
for _ in unify(arg, w, solver.env):
solver.parse_state = text, p
yield cont, w
solver.parse_state = text, pos
def times_between_builtin(solver, cont, item, template, result):
min1 = deref(min, solver.env)
max1 = deref(max, solver.env)
if not isinstance(min1, int): raise ValueError(min1)
if not isinstance(max1, int): raise ValueError(max1)
if min1==0:
yield solver.cont((time_less, item, max1, template, result, mode), cont), True
if result is not None:
temp1 = Var('temp1')
temp2 = Var('temp2')
else:
temp1 = None
temp2 = None
for c, _ in solver.exp_run_cont(make_times(item, min, template, temp1, mode), cont):
for c, _ in solver.exp_run_cont((times_less, item, max-min, template, temp2, mode), cont):
if result is not None:
matched_list = getvalue(temp1, solver.env)+getvalue(temp2, solver.env)
for _ in unify(result, matched_list, solver.env):
yield c, True
else: yield cont, True
def concat(solver, cont, sequence1, sequence2, result):
sequence1 = deref(sequence1, solver.env)
sequence2 = deref(sequence2, solver.env)
result = deref(result, solver.env)
if isinstance(sequence1, Var):
index = 0
if isinstance(sequence2, Var):
for index in range(1, len(result)):
for _ in sequence1.unify(result[:index], solver.env):
for __ in sequence2.unify(result[index:], solver.env):
yield cont, True
else:
if result.endswith(sequence2):
for _ in sequence1.unify(result[:len(sequence2)], solver.env): yield cont, True
else:
if isinstance(sequence2, Var):
if result.startswith(sequence1):
for _ in sequence2.unify(result[len(sequence1):], solver.env): yield cont, True
else:
for _ in unify(result, sequence1+sequence2, solver.env): yield cont, True
def times_cont(value, solver):
for _ in unify(expect_times, matched_times, solver.env):
yield cont, True
next_cont = lazy_times_cont(item, expect_times, cont, matched_times+1)
for s, x in solver.exp_run_cont(item, next_cont):
yield c, x
def times_cont(value, solver):
yield solver.cont(item, nongreedy_times_cont(item, expect_times, cont, matched_times+1)), True
for _ in unify(expect_times, matched_times, solver.env):
yield cont, True
