bool reasoner::unify ( predicate* _s, const subst& ssub, predicate* _d, subst& dsub, bool f ) {
if ( !_s && !_d ) {
trace ( "Match two nulls." << endl );
return true;
}
// if ( !_s ) return _d && _d->pred >= 0; // ??
// if ( !_d ) return _s && _s->pred >= 0; // ??
predicate& s = *_s;
predicate& d = *_d;
trace ( "\tUnify s: " << s << " in " << ( ssub ) << " with " << d << " in " << dsub << endl );
// if (s.pred == d.pred) trace("we have local pred match"<<endl);
predicate* p;
if ( s.pred < 0 ) {
if (( p = evaluate ( s, ssub ) )) return unify ( p, ssub, _d, dsub, f );
else {
trace ( "Match." << endl );
return true;
}
}
if ( d.pred >= 0 ) {
if ( s.pred != d.pred || s.args.size() != d.args.size() ) return false;
const predlist& as = s.args, ad = d.args;
for ( auto sit = as.begin(), dit = ad.begin(); sit != as.end(); ++sit, ++dit )
if ( !unify ( *sit, ssub, *dit, dsub, f ) )
return false;
trace ( "Match." << endl );
return true;
}
p = evaluate ( d, dsub );
if ( ( p = evaluate ( d, dsub ) ) ) return unify ( _s, ssub, p, dsub, f );
if ( f ) dsub[d.pred] = evaluate ( s, ssub );
trace ( "Match with subst: " << dsub << endl );
return true;
}
boost::optional< substitution > forward_chaining( const atomic_sentence & sen )
{
for ( const atomic_sentence & se : known_facts )
{
auto ret = unify( se, sen );
if ( ret ) { return ret; }
}
bool have_new_inference = true;
std::set< std::string > var_name = variable_name( );
while ( have_new_inference )
{
have_new_inference = false;
for ( const definite_clause & dc : kb )
{
assert( ! dc.premise.empty( ) );
substitution rename =
rename_variable(
dc.premise.begin( ),
dc.premise.end( ),
[&]( const std::string & v ){ return var_name.count( v ) == 0; },
[]( const std::string & n ){ return n + "_"; } );
have_new_inference = try_infer_forward( dc.premise, dc.conclusion, rename, sen ) || have_new_inference;
auto ret = unify( known_facts.back( ), sen );
if ( ret ) { return ret; }
}
}
return boost::optional< substitution >( );
}
frame* reasoner::match_cases ( frame& current_frame, predicate& t, cases_t& cases, deque<frame*>& queue ) {
if ( cases.find ( t.pred ) == cases.end() ) return 0;
uint src = 0;
for ( rule* _rl : cases[t.pred] ) {
rule& rl = *_rl;
src++;
ground_t ground = current_frame.ground;
if ( rl.body.empty() )
ground.emplace_back ( &rl, subst() );
frame& candidate_frame = frames[nframes++].init ( this, &rl, src, 0, ¤t_frame, subst(), ground );
if ( unify ( &t, current_frame.substitution, rl.head, candidate_frame.substitution, true ) ) {
trace ( "unification of rule " << rl << " from cases against " << t << " passed" << endl );
frame& ep = current_frame;
while ( ep.parent ) {
ep = *ep.parent;
if ( ( ep.src == current_frame.src ) &&
unify ( ep.rul->head, ep.substitution, current_frame.rul->head, current_frame.substitution, false ) )
break;
}
if ( !ep.parent ) {
// cout << "pushing frame: " << candidate_frame << endl;
// return
queue.push_front(&candidate_frame);
}
} else {
trace ( "unification of rule " << rl << " from cases against " << t << " failed" << endl );
}
}
return 0;
}
/*
* This wordlist check is now the least important given the checks above
* and the support for passphrases (which are based on dictionary words,
* and checked by other means). It is still useful to trap simple short
* passwords (if short passwords are allowed) that are word-based, but
* passed the other checks due to uncommon capitalization, digits, and
* special characters. We (mis)use the same set of words that are used
* to generate random passwords. This list is much smaller than those
* used for password crackers, and it doesn't contain common passwords
* that aren't short English words. Perhaps support for large wordlists
* should still be added, even though this is now of little importance.
*/
static const char *is_word_based(const passwdqc_params_qc_t *params,
const char *needle, const char *original, int is_reversed)
{
char word[7];
char *unified;
unsigned int i;
int length;
int mode;
if (!params->match_length) /* disabled */
return NULL;
mode = is_reversed | 2;
for (i = 0; i < sizeof(seq) / sizeof(seq[0]); i++) {
unified = unify(NULL, seq[i]);
if (!unified)
return REASON_ERROR;
if (is_based(params, unified, needle, original, mode)) {
free(unified);
return REASON_SEQ;
}
free(unified);
}
mode = is_reversed | 1;
word[6] = '\0';
for (i = 0; i < 0x1000; i++) {
if (params->lang == 0) {
memcpy(word, _passwdqc_wordset_4k[i], 6);
} else {
memcpy(word, _passwdqc_wordset_4k_es[i], 6);
}
length = strlen(word);
if (length < params->match_length)
continue;
if (params->lang == 0 && i < 0xfff &&
!memcmp(word, _passwdqc_wordset_4k[i + 1], length))
continue;
if (params->lang == 1 && i < 0xfff &&
!memcmp(word, _passwdqc_wordset_4k_es[i + 1], length))
continue;
unify(word, word);
if (is_based(params, word, needle, original, mode))
return REASON_WORD;
}
mode = is_reversed | 2;
if (params->match_length <= 4)
for (i = 1900; i <= 2039; i++) {
sprintf(word, "%u", i);
if (is_based(params, word, needle, original, mode))
return REASON_SEQ;
}
return NULL;
}
void unify(char x[],char y[])
{char a[100],b[100];
if(strcmp(theta,"FAILURE")==0)
return;
if(strcmp(x,y)==0)
return;
else if(isvariable(x))
unify_var(x,y);
else if(isvariable(y))
unify_var(x,y);
else if(iscompound(x) && iscompound(y))
{
strcpy(a,arg(x));
strcpy(b,arg(y));
unify(a,b);
strcpy(a,op(x));
strcpy(b,op(y));
unify(a,b);
}
else if(islist(x) && islist(y))
{
strcpy(a,rest(x));
strcpy(b,rest(y));
unify(a,b);
strcpy(a,first(x));
strcpy(b,first(y));
unify(a,b);
}
else
sprintf(theta,"FAILURE",theta);
return;
}
int
main(void)
{
char buf[50];
char cmd[10];
int p , q;
init(array);
while( fgets(buf , 49 , stdin) != NULL )
{
if(sscanf(buf , "%s %d %d" , cmd , &p , &q) == 3)
{
if(strcmp(cmd , "test") == 0)
test(p , q);
else if(strcmp(cmd , "unify") == 0)
unify(p , q);
else
printf("unknow operations\n");
}
else
printf("input error\n");
}
return 0;
}
static
Clause conflicts(Clause a, Clause b)
{
if (!unit_clause(a) || !unit_clause(b))
return NULL;
else if (a->literals->sign == b->literals->sign)
return NULL;
else {
Clause empty = NULL;
Term a_atom = a->literals->atom;
Term b_atom = b->literals->atom;
Context ca = get_context();
Context cb = get_context();
Trail tr = NULL;
if (unify(a_atom, ca, b_atom, cb, &tr)) {
Ilist j = NULL;
undo_subst(tr);
empty = get_clause();
j = ilist_append(j, a->id);
j = ilist_append(j, 1);
j = ilist_append(j, b->id);
j = ilist_append(j, 1);
empty->justification = resolve_just(j, BINARY_RES_JUST);
upward_clause_links(empty);
assign_clause_id(empty);
}
free_context(ca);
free_context(cb);
return empty;
}
} /* conflicts */
bool isUnifyable(const TypePtr& typeA, const TypePtr& typeB) {
if (typeA == typeB) {
return true;
}
NodeManager tmp; // requires only temporary manager
return unify(tmp, typeA, typeB);
}
Router::Node* Router::Node::unify(Router::Node* const& root, Router::Node* const path, std::unordered_map<std::string, std::string>& params) {
if (Router::Node::unifiable(root, path)) {
if ((root->is_last() && (path->is_last() || root->is_splat())) ||
(path->is_last())) {
return root;
} else
if (root->is_last() && !path->is_last()) {
return nullptr;
}
}
Node* match;
for (auto next : root->children) {
if (!Router::Node::unifiable(next, path->next()))
continue;
if ((match = unify(next, path->next(), params)) != nullptr) {
if (match->service.empty())
continue;
next->inject(path->next(), params);
return match;
}
}
return nullptr;
}
/* compose -- evaluate a sequential composition or piping */
PRIVATE env compose(tree t, env e, tok ldec, tok rdec, char *kind)
{
env e1 = tc_sexp(t->x_arg1, e);
env e2 = tc_sexp(t->x_arg2, e);
env ee = new_env(e);
def q;
/* Get vars from left arg that don't match */
for (;;) {
def d = pop_def(e1);
if (d == NULL)
break;
else if (d->d_name->s_decor != ldec)
push_def(d, ee);
else {
sym rname = mk_symbol(d->d_name->s_basename, rdec);
type rtype = del_var(rname, e2);
if (rtype == NULL)
push_def(d, ee);
else if (! unify(d->d_type, rtype)) {
tc_error(t->x_loc, "Type mismatch in %s", kind);
tc_e_etc("Expression: %z", t);
tc_e_etc("Type of %n in LHS: %t", d->d_name, d->d_type);
tc_e_etc("Type of %n in RHS: %t", rname, rtype);
tc_e_end();
}
}
}
/* Now merge the unmatched vars from the right */
for (q = e2->e_defs; q != NULL; q = q->d_next)
merge_def(VAR, q->d_name, q->d_type, ee, t, t->x_loc);
return ee;
}
Matrix make_rotation ( Vector const& v_original, double a )
{
Vector v(v_original);
a = deg_to_rad(a);
Vector u = unify(v);
double c = cos(a);
double s = sin(a);
double omc = 1-c;
double ux = u[0];
double uy = u[1];
double uz = u[2];
double ux2 = ux*ux;
double uy2 = uy*uy;
double uz2 = uz*uz;
double uxy = ux*uy;
double uxz = ux*uz;
double uyz = uy*uz;
double uxs = ux*s;
double uys = uy*s;
double uzs = uz*s;
double const values[16] = {
ux2+(1-ux2)*c, uxy*omc-uzs, uxz*omc+uys, 0.0,
uxy*omc+uzs, uy2+(1-uy2)*c, uyz*omc-uxs, 0.0,
uxz*omc-uys, uyz*omc+uxs, uz2+(1-uz2)*c, 0.0,
0.0, 0.0, 0.0, 1.0
};
return values;
}
optional<expr> mk_class_instance(environment const & env, io_state const & ios, local_context const & ctx,
name const & prefix, expr const & type, bool relax_opaque, bool use_local_instances,
unifier_config const & cfg) {
auto C = std::make_shared<class_instance_context>(env, ios, prefix, relax_opaque, use_local_instances);
if (!is_ext_class(C->tc(), type))
return none_expr();
expr meta = ctx.mk_meta(C->m_ngen, some_expr(type), type.get_tag());
unsigned depth = 0;
constraint c = mk_class_instance_cnstr(C, ctx, meta, depth);
unifier_config new_cfg(cfg);
new_cfg.m_discard = true;
new_cfg.m_use_exceptions = true;
new_cfg.m_pattern = true;
new_cfg.m_kind = C->m_conservative ? unifier_kind::VeryConservative : unifier_kind::Liberal;
try {
auto seq = unify(env, 1, &c, C->m_ngen.mk_child(), substitution(), new_cfg);
while (true) {
auto p = seq.pull();
lean_assert(p);
substitution s = p->first.first;
expr r = s.instantiate_all(meta);
if (!has_expr_metavar_relaxed(r))
return some_expr(r);
seq = p->second;
}
} catch (exception &) {
return none_expr();
}
}
int immediate_depends_ptrlist(CTXTdeclc callnodeptr call1){
VariantSF subgoal;
int count = 0;
CPtr oldhreg = NULL;
calllistptr cl;
reg[4] = makelist(hreg);
new_heap_free(hreg);
new_heap_free(hreg);
if(IsNonNULL(call1)){ /* This can be called from some non incremental predicate */
cl= call1->inedges;
while(IsNonNULL(cl)){
subgoal = (VariantSF) cl->inedge_node->callnode->goal;
if(IsNonNULL(subgoal)){/* fact check */
count++;
check_glstack_overflow(4,pcreg,2);
oldhreg = hreg-2;
follow(oldhreg++) = makeint(subgoal);
follow(oldhreg) = makelist(hreg);
new_heap_free(hreg);
new_heap_free(hreg);
}
cl=cl->next;
}
if (count>0)
follow(oldhreg) = makenil;
else
reg[4] = makenil;
}
return unify(CTXTc reg_term(CTXTc 3),reg_term(CTXTc 4));
}
void ComplexInliner::immInline(BooleanDAG& dag){
map<string, int> fake;
DagFunctionInliner dfi(dag, functionMap, fake);
dfi.process(dag);
somethingChanged = dfi.changed();
if(mergeFunctions){
if(oldNfun > 0){
if( (dfi.nfuns() - oldNfun) > 3 && divFactor > (FRACTION + 1)){
divFactor--;
if( (dfi.nfuns() - oldNfun) > 12 ){
divFactor-= 4;
}
if( (dfi.nfuns() - oldNfun) > 40 ){
divFactor-= 4;
}
if(divFactor<(FRACTION + 1)){
divFactor = (FRACTION + 1);
}
cout<<"reducing divFactor "<<divFactor<<endl;
}
}
unifyTime.restart();
unify();
unifyTime.stop();
expectedNFuns++;
}
//cout<<" after all"<<endl;
oldNfun = dfi.nfuns();
Dout( cout<<" AFTER PROCESS "<<endl );
Dout(cout<<" end ElimFun "<<endl);
}
bool match_pattern(type_checker & tc, expr const & pattern, declaration const & d, unsigned max_steps, bool cheap) {
name_generator ngen = tc.mk_ngen();
buffer<level> ls;
unsigned num_ls = d.get_num_univ_params();
for (unsigned i = 0; i < num_ls; i++)
ls.push_back(mk_meta_univ(ngen.next()));
expr dt = instantiate_type_univ_params(d, to_list(ls.begin(), ls.end()));
unsigned num_e = get_expect_num_args(tc, pattern);
unsigned num_d = get_expect_num_args(tc, dt);
if (num_e > num_d)
return false;
for (unsigned i = 0; i < num_d - num_e; i++) {
dt = tc.whnf(dt).first;
expr local = mk_local(ngen.next(), binding_domain(dt));
dt = instantiate(binding_body(dt), local);
}
try {
unifier_config cfg;
cfg.m_max_steps = max_steps;
cfg.m_kind = cheap ? unifier_kind::Cheap : unifier_kind::Liberal;
cfg.m_ignore_context_check = true;
auto r = unify(tc.env(), pattern, dt, tc.mk_ngen(), substitution(), cfg);
return static_cast<bool>(r.pull());
} catch (exception&) {
return false;
}
}
frame* reasoner::next_frame ( const frame& current_frame, ground_t& g ) {
if ( !current_frame.rul->body.empty() ) g.emplace_front ( current_frame.rul, current_frame.substitution );
frame& new_frame = frames[nframes++].init ( this, *current_frame.parent );
new_frame.ground = g;
unify ( current_frame.rul->head, current_frame.substitution, new_frame.rul->body[new_frame.ind], new_frame.substitution, true );
new_frame.ind++;
return &new_frame;
}
int main()
{
bool varying(4) b = { true, true, false, false };
store( b );
return unify( g, 1, 1, 0, 0 );
}
pl_consonne_1 (struct coroutine *k, expr a0)
{
expr nx[MAX_NEW_CONS];
int pnx, i;
struct process_list *alt_process;
pnx = 0;
begin_decl ();
decl_expr (&a0);
for (i=0; i<MAX_NEW_CONS; i++)
dle (nx[i]);
#ifdef TRACE
printf ("\nconsonne: a0 = "); print_expr (a0);
#endif
if (alt (k, 1, 0))
{
/* clause */
expr val_X, var_X;
alt_process = getpl (k) -> alt;
dle(val_X) dle(var_X)
val_X=UNDEF; var_X=mk_var(&val_X);
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
unify (k, var_X, a0);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
pl_lettre_1 (k, var_X);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
pl_non_voyelle_1 (k, var_X);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
unify (k, a0, var_X);
for (i=0; i<pnx; i++)
nx[i] = 0;
pnx=0;
#ifdef TRACE
printf ("\n\ta0 = "); print_expr (a0);
#endif
} else
end (k);
free_expr ();
}
bool try_infer_forward(
const std::vector< atomic_sentence > & premise,
const atomic_sentence & conclusion,
const substitution & rename,
const atomic_sentence & query )
{
bool ret = false;
std::vector< atomic_sentence > new_known_facts;
substitution s;
std::vector< atomic_sentence > gp;
auto generate =
[&,this]( const auto & self, const substitution & sub )->void
{
if ( gp.size( ) == premise.size( ) ) { new_known_facts.push_back( sub( rename( conclusion ) ) ); }
else
{
this->matching_facts(
rename( premise[ gp.size( ) ] ),
sub,
make_function_output_iterator(
[&]( const std::pair< atomic_sentence, substitution > & p )
{
if ( ( new_known_facts.empty( ) ) || ( ! unify( new_known_facts.back( ), query ) ) )
{
gp.push_back( p.first );
self( self, p.second );
gp.pop_back( );
}
} ) );
}
};
generate( generate, s );
for ( const atomic_sentence & sen : new_known_facts )
{
if ( std::none_of(
known_facts.begin( ),
known_facts.end( ),
[&]( const atomic_sentence & s ){ return unify( sen, s ); } ) )
{
known_facts.push_back( sen );
ret = true;
}
}
return ret;
}
/* reg 1: tag for this call
reg 2: filter list of goals to keep (keep all if [])
reg 3: returned list of changed goals
reg 4: used as temp (in case of heap expansion)
*/
int create_changed_call_list(CTXTdecl){
callnodeptr call1;
VariantSF subgoal;
TIFptr tif;
int j, count = 0,arity;
Psc psc;
CPtr oldhreg = NULL;
reg[4] = makelist(hreg);
new_heap_free(hreg); // make heap consistent
new_heap_free(hreg);
while ((call1 = delete_calllist_elt(&changed_gl)) != EMPTY){
subgoal = (VariantSF) call1->goal;
tif = (TIFptr) subgoal->tif_ptr;
psc = TIF_PSC(tif);
if (in_reg2_list(CTXTc psc)) {
count++;
arity = get_arity(psc);
check_glstack_overflow(4,pcreg,2+arity*200); // guess for build_subgoal_args...
oldhreg = hreg-2;
if(arity>0){
sreg = hreg;
follow(oldhreg++) = makecs(hreg);
hreg += arity + 1;
new_heap_functor(sreg, psc);
for (j = 1; j <= arity; j++) {
new_heap_free(sreg);
cell_array1[arity-j] = cell(sreg-1);
}
build_subgoal_args(subgoal);
}else{
follow(oldhreg++) = makestring(get_name(psc));
}
follow(oldhreg) = makelist(hreg);
new_heap_free(hreg); // make heap consistent
new_heap_free(hreg);
}
}
if (count>0)
follow(oldhreg) = makenil;
else
reg[4] = makenil;
return unify(CTXTc reg_term(CTXTc 3),reg_term(CTXTc 4));
/*
int i;
for(i=0; i<callqptr; i++){
if(IsNonNULL(callq[i]) && (callq[i]->deleted==1)){
sfPrintGoal(stdout,(VariantSF)callq[i]->goal,NO);
printf(" %d %d\n",callq[i]->falsecount,callq[i]->deleted);
}
}
printf("-----------------------------\n");
*/
}
int main(void) {
GC_INIT();
GREG g;
int jval, jval2;
char c;
sym_tab_init();
ast_init();
type_init();
scope_init();
rel_assign_init();
jit_t * jit = llvm_init();
yyinit(&g);
printf("Welcome to Cesium v 0.2\n");
printf("To exit press CTRL-D\n\n");
printf("> ");
while (1)
{
if (!(jval = setjmp(exc)))
{
if (!yyparse(&g))
{
printf("Error parsing\n");
abort();
} else if (root != NULL)
{
rel_stack_init();
rel_assign_mark();
scope_mark();
annotate_ast(root);
if (TRACE)
ast_print(root, 0);
unify(rel_stack, rel_assign);
if (TRACE)
print_assigns(rel_assign);
exec_root(jit, root);
if (root->tag != AST_FNDEC)
rel_assign_rewind();
}
} else if (jval == 1)
root = NULL;
else if (jval == 2)
break;
printf("\n> ");
}
yydeinit(&g);
llvm_cleanup(jit);
return 0;
}
int
unify_callback_wrapper (Termlist tl, struct state_mgu_tmp *ptr_tmpstate)
{
// now the keys are unified (subst in this tl)
// and we try the inner terms
assert (ptr_tmpstate != NULL);
return unify (ptr_tmpstate->unifyt1, ptr_tmpstate->unifyt2, tl,
ptr_tmpstate->oldcallback, ptr_tmpstate->oldstate);
}
/* PUBLIC */
Term mindex_retrieve_next(Mindex_pos pos)
{
if (pos->index->unif_type == BACKTRACK_UNIF)
return retrieve_next_backtrack(pos);
else {
Term tq, tf;
Context cq, cf;
Trail tr;
BOOL ok;
tq = pos->query_term;
cq = pos->query_subst;
cf = pos->found_subst;
undo_subst(pos->tr); /* ok if NULL or not used */
pos->tr = NULL;
tf = next_candidate(pos);
if (tf != NULL && pos->index->index_type == DISCRIM_BIND)
ok = TRUE;
else
ok = FALSE;
while (tf && !ok) {
#if 0
printf("potential mate, %d: ", tf->INDEX_ID); p_term(tf);
#endif
tr = NULL;
switch (pos->query_type) {
case UNIFY:
ok = unify(tq, cq, tf, cf, &(pos->tr)); break;
case GENERALIZATION:
ok = match(tf, cf, tq, &(pos->tr)); break;
case INSTANCE:
ok = match(tq, cq, tf, &(pos->tr)); break;
case VARIANT:
ok = variant(tq, cq, tf, &(pos->tr)); break;
case IDENTICAL:
ok = term_ident(tq, tf); break;
default:
ok = FALSE; break;
}
if (!ok)
tf = next_candidate(pos);
}
if (ok) {
#if 0
printf(" MATE, %d: ", tf->INDEX_ID); p_term(tf);
#endif
return tf;
}
else {
free_mindex_pos(pos);
return NULL;
}
}
} /* mindex_retrieve_next */
int main()
{
bool varying(4) a = {true, true, false, false};
int varying(4) b = {0, 3, 2, 3};
int varying(4) x = a ? b : 5;
return unify(x, 0, 3, 5, 5);
}
Type * SpCandidate::toType(SourceContext * source, BindingEnv & env) {
TypeDefn * tdef = cast<TypeDefn>(def_);
if (AnalyzerBase::analyzeTypeDefn(tdef, Task_PrepMemberLookup)) {
SourceContext candidateSite(tdef->location(), source, tdef, Format_Type);
relabelTypeVars(env);
if (unify(&candidateSite, env)) {
env.updateAssignments(source->location());
QualifiedTypeVarMap vars;
env.toTypeVarMap(vars, this);
return const_cast<Type *>(
tdef->templateSignature()->instantiateType(source->location(), vars));
} else {
unify(&candidateSite, env);
DFAIL("Unify failed...");
}
}
return NULL;
}
Service::shared Router::find(Request::shared request, int worker_id) {
Node* node = unify(request->path, request->parameters);
if (node == nullptr)
return nullptr;
Service::shared service = node->find_service(worker_id);
return service;
}
ITER matching_facts( const atomic_sentence & match, const substitution & sub, ITER result ) const
{
for ( auto i = known_facts.begin( ); i != known_facts.end( ); ++i )
{
const auto & sen = * i;
assert( static_cast< bool >( sen.data ) );
auto res = unify( match, sen, sub );
if ( res ) { * result = std::make_pair( sen, * res ); }
}
return result;
}
void HuffmanCompression::compress(){
FileIO f("");
f.buildCharTable();
//f.browseHashTable();
list = new OrderedList;
list->insertMap(f.getMap());
copyExternalNodes();
unify(list->getFirst(),list->getFirst());
getCarEncode();
browseHashTable();
}
/*
For a callnode call1 returns a Prolog list of callnode on which call1
immediately depends.
*/
int immediate_inedges_list(CTXTdeclc callnodeptr call1){
VariantSF subgoal;
TIFptr tif;
int j, count = 0,arity;
Psc psc;
CPtr oldhreg = NULL;
calllistptr cl;
reg[4] = makelist(hreg);
new_heap_free(hreg);
new_heap_free(hreg);
if(IsNonNULL(call1)){ /* This can be called from some non incremental predicate */
cl= call1->inedges;
while(IsNonNULL(cl)){
subgoal = (VariantSF) cl->inedge_node->callnode->goal;
if(IsNonNULL(subgoal)){/* fact check */
count++;
tif = (TIFptr) subgoal->tif_ptr;
psc = TIF_PSC(tif);
arity = get_arity(psc);
check_glstack_overflow(4,pcreg,2+arity*200); // don't know how much for build_subgoal_args...
oldhreg = hreg-2;
if(arity>0){
sreg = hreg;
follow(oldhreg++) = makecs(hreg);
hreg += arity + 1;
new_heap_functor(sreg, psc);
for (j = 1; j <= arity; j++) {
new_heap_free(sreg);
cell_array1[arity-j] = cell(sreg-1);
}
build_subgoal_args(subgoal);
}else{
follow(oldhreg++) = makestring(get_name(psc));
}
follow(oldhreg) = makelist(hreg);
new_heap_free(hreg);
new_heap_free(hreg);
}
cl=cl->next;
}
if (count>0)
follow(oldhreg) = makenil;
else
reg[4] = makenil;
}else{
xsb_warn("Called with non-incremental predicate\n");
reg[4] = makenil;
}
return unify(CTXTc reg_term(CTXTc 3),reg_term(CTXTc 4));
}
Router::Node* Router::Node::unify(Router::Node* const& root, std::string const& path, std::unordered_map<std::string, std::string>& params) {
Node* node = from_path(path);
Node* match = unify(root, node, params);
delete node;
// if (match != nullptr) {
// std::cout << "Matched '"<< path <<"' to '"<<match->uri()<<"'\n";
// }
return match;
}
