def ______mrepl_addsort_forall(matched):
sort_dict = context_operator.get_symbol_sorts_dict()
var_list = matched.group("var").split(",")
var_sort_list = [var + ":" + sort_dict[var] for var in var_list]
var_sort_str = ",".join(var_sort_list)
var_sort_str = matched.group(
"head") + "(" + var_sort_str + ")" + matched.group('body')
return Util.endecode_string(var_sort_str, Util.encode_pair_forall[0],
Util.encode_pair_forall[1])
def __find_var_sort_from_expression(
symbol,
expression,
symbol_sort=""
): #expression without quantifier and logical connection (and or =>)
#print symbol, expression
symbol_sort = context_operator.get_symbol_sorts_dict(
) if symbol_sort == "" else None
symbols = re.findall(r"\w+", expression)
symbol2 = copy.copy(symbol)
symbol1 = symbol.encode('utf-8') if isinstance(
symbol, unicode) else symbol.decode('utf-8')
#print [symbol2]
#print [symbol1]
#print symbols
if symbol1 not in symbols and symbol2 not in symbols:
return None
#if symbol not in symbols:
# raise Exception('No such vars in expression!%s %s'%(symbol, expression))
#symbol_sort = context_operator.get_symbol_sorts_dict()
para_pattern_str = r"(?P<fun>\w+)\((?P<body>[^\(\)]*?" + symbol + "[^\(\)]*?)\)"
value_pattern_str = r"(?P<fun>\w+)\(.*?\)\s*=\s*" + symbol
para_pattern = re.compile(para_pattern_str)
value_pattern = re.compile(value_pattern_str)
match1 = para_pattern.search(expression)
match2 = value_pattern.search(expression)
if match1:
#if match.group('fun') !="":
#print "heloo1"
symbols = [elem.strip() for elem in match1.group('body').split(',')]
para_list = [(e, elem.find(symbol)) for e, elem in enumerate(symbols)]
pre_sort = [(match1.group('fun'), index + 1)
for index, signal in para_list if signal != -1][0]
elif match2:
#print "hello2"
#print match2.group()
pre_sort = match2.group('fun')
elif re.search(r'[\+\-\*\/\>\<\%]|\>\=|\<\=', expression):
return 'Int'
else:
# numStone = Y find Y is numStone's sort
#symbols = [elem for elem in symbols if elem !=symbol]
#return None if symbols == [] else (symbol_sort[symbols.pop()] if symbol_sort!=None else symbols.pop())
#raise Exception('can not match any sort in expression!%s %s'%(symbol, expression))
#logger.info('can not match any sort in expression!%s %s'%(symbol, expression))
return None
return symbol_sort[pre_sort] if symbol_sort else pre_sort
def __get_equal_sorts(symbol_list):
symbol_sorts = context_operator.get_symbol_sorts_dict()
#print "-----symobs to sorts:", symbol_sorts
#print "-----equal symbols list:", symbol_list
if set(symbol_list) & set(symbol_sorts.keys()) == set():
return symbol_list
else:
return sum([
symbol_sorts[symbol]
for symbol in symbol_list if symbol in symbol_sorts.keys()
], [])
'''
def get_function_sort(function_name):
#print function_name
symbol_sort = context_operator.get_symbol_sorts_dict()
#print symbol_sort
function_sorts = [
symbol_sort[fun_para] for fun_para in symbol_sort.keys()
if type(fun_para) == type(tuple())
and fun_para[0].strip() == function_name.strip()
]
function_sorts = sorted(function_sorts, key=itemgetter(1))
if function_name in symbol_sort.keys():
function_sorts.append(symbol_sort[function_name])
else:
function_sorts.append('Bool')
return function_sorts
def generate_new_sorts(sorts_list):
for elem in sorts_list:
if 'Int' in elem:
context_operator.declare_sort('Int', elem)
else:
context_operator.declare_sort("", elem)
sorts = context_operator.get_sorts()
subsort_to_sort = {
key: value
for value in sorts.keys() for key in sorts[value]
}
symbol_to_sort = {
key: subsort_to_sort[values[0]]
for key, values in
context_operator.get_symbol_sorts_dict().iteritems()
}
#print "@test-----------subsort_to_sort",subsort_to_sort
#print "@test-----------symbol_to_sort",symbol_to_sort
symbols = context_operator.get_symbols_equal_list()
add_symbolsort_dict = dict()
for symbol, sort in symbol_to_sort.iteritems():
for elem_list in symbols:
if symbol in elem_list:
add_symbolsort_dict.update({elem: sort for elem in elem_list})
symbol_to_sort.update(add_symbolsort_dict)
#[context_operator.declare_sort("", elem) for elem in unknown_symbols]
#print "222",symbol_to_sort
symbol_to_sort.update(subsort_to_sort)
#print "333", symbol_to_sort
context_operator.set_symbol_sorts_dict(symbol_to_sort)
sort_constants = __get_sort_constants(symbol_to_sort)
#sort_constants.update(__get_add_sort_constants(context_operator.get_sorts()))
context_operator.set_sort_symbols_dict(sort_constants)
def parser(filename):
with open('./input/%s'%filename,"read") as sc_file, open('./input/default_axioms.sc',"read") as basic_file,\
open('./temp/game_rule_info','write') as sc_temp:
full_txt = " ".join(sc_file.readlines()).replace("\n", " ").replace(
"\t", " ")
full_txt += " ".join(basic_file.readlines()).replace(
"\n", " ").replace("\t", " ") + ";"
full_txt = full_txt.replace(' and ',
'&').replace(' or ', '|').replace(' ', "")
#logger.debug(full_txt)
rule_list = pattern.rule3.findall(full_txt) + pattern.rule4.findall(
full_txt) + pattern.rule5.findall(full_txt)
sc_temp.writelines('\n'.join([str(elem) for elem in rule_list]))
rule_list = __pre_parse(rule_list)
sc_temp.writelines('\n')
sc_temp.writelines('\n\n')
sc_temp.writelines('\n'.join([str(elem) for elem in rule_list]))
for k, g in groupby(sorted(rule_list, key=itemgetter(0)),
key=itemgetter(0)):
m_group = list(g)
#print "-------",k, m_group
eval("apply(__parse_" + k + "," + str(m_group) + ")")
predicates = __generate_predicates(
context_operator.get_fluents(),
context_operator.get_symbol_sorts_dict().keys())
fun_fluents = [
fluent for fluent in context_operator.get_fluents()
if fluent not in predicates
]
#print context_operator.get_feature()
sc_temp.writelines('\n\n')
sc_temp.writelines('feature pattern for regression:\n')
sc_temp.writelines('\n'.join(
[str(elem) for elem in context_operator.get_feature()]))
#exit(0)
sc_temp.writelines('\n')
sc_temp.writelines('\n actions:' + str(context_operator.get_actions()))
sc_temp.writelines('\n fluents:' + str(context_operator.get_fluents()))
sc_temp.writelines('\n 0arity-fluents:' +
str(context_operator.get_zero_fluents()))
sc_temp.writelines('\n predicates:' + str(predicates))
sc_temp.writelines('\n functional fluents:' + str(fun_fluents))
#logger.debug("\n actions :%s \n fluents %s"%(context_operator.get_actions(), context_operator.get_fluents()))
#print sort_system.get_function_sort('numStone')
#print context_operator.get_sort_symbols_dict()
sort_const = __get_sort_const_with_fluents(
context_operator.get_sort_symbols_dict(),
context_operator.get_fluents())
sort_const["Bool"] = ['True', 'False']
sort_funs = __get_funs_sorts(context_operator.get_fluents() +
context_operator.get_actions())
sort_preds = __generate_predicate_sorts(predicates, sort_funs)
sc_temp.writelines('\n')
sc_temp.writelines('\n sort for constants:' + str(sort_const))
sc_temp.writelines('\n sort for functions:' + str(sort_funs))
sc_temp.writelines('\n sort for predicates:' + str(sort_preds))
context_operator.set_sort_symbols_dict(sort_const)
context_operator.set_functions_sorts(sort_funs)
context_operator.add_predicates(predicates)
context_operator.add_predicate_sorts(sort_preds)
context_operator.add_nregx_function_patterns(
__generate_nregx_function_patterns(fun_fluents))
#print z3_header
context_operator.set_function_regress_lambda(
__generate_fun_regress_lambda(fun_fluents, sort_funs))
context_operator.set_predicate_regress_lambda(
__generate_pred_regress_lambda(predicates, sort_preds))
#exit(0)
domain_name = filename.split('.')[0]
__load_state_constaints(domain_name)
def get_fun_value_sort(function):
fun_name, fun_var, fun_value = Util.parse_relation_or_function(function)
return context_operator.get_symbol_sorts_dict()[fun_name]