diff --git a/C/atomic.c b/C/atomic.c index 80c1dcf21..342ca8d47 100644 --- a/C/atomic.c +++ b/C/atomic.c @@ -15,7 +15,7 @@ * * *************************************************************************/ #ifdef SCCS -static char SccsId[] = "%W% %G%"; +static char SccsId[] = "%W% %G%"; #endif /** @addgroup Predicates_on_Atoms Predicates on Atoms and Strings @@ -25,9 +25,8 @@ static char SccsId[] = "%W% %G%"; The following predicates are used to manipulate atoms: \toc - -*/ +*/ #define HAS_CACHE_REGS 1 /* @@ -54,32 +53,29 @@ The following predicates are used to manipulate atoms: #endif #include -static Int name( USES_REGS1 ); -static Int atom_chars( USES_REGS1 ); -static Int atom_codes( USES_REGS1 ); -static Int atom_length( USES_REGS1 ); -static Int string_length( USES_REGS1 ); -static Int atom_split( USES_REGS1 ); -static Int number_chars( USES_REGS1 ); -static Int number_codes( USES_REGS1 ); -static Int current_atom( USES_REGS1 ); -static Int cont_current_atom( USES_REGS1 ); +static Int name(USES_REGS1); +static Int atom_chars(USES_REGS1); +static Int atom_codes(USES_REGS1); +static Int atom_length(USES_REGS1); +static Int string_length(USES_REGS1); +static Int atom_split(USES_REGS1); +static Int number_chars(USES_REGS1); +static Int number_codes(USES_REGS1); +static Int current_atom(USES_REGS1); +static Int cont_current_atom(USES_REGS1); static int AlreadyHidden(unsigned char *); -static Int hide_atom( USES_REGS1 ); -static Int hidden_atom( USES_REGS1 ); -static Int unhide_atom( USES_REGS1 ); +static Int hide_atom(USES_REGS1); +static Int hidden_atom(USES_REGS1); +static Int unhide_atom(USES_REGS1); - - -static int -AlreadyHidden(unsigned char *name) -{ - AtomEntry *chain; +static int AlreadyHidden(unsigned char *name) { + AtomEntry *chain; READ_LOCK(INVISIBLECHAIN.AERWLock); chain = RepAtom(INVISIBLECHAIN.Entry); READ_UNLOCK(INVISIBLECHAIN.AERWLock); - while (!EndOfPAEntr(chain) && strcmp((char *)chain->StrOfAE, (char *)name) != 0) + while (!EndOfPAEntr(chain) && + strcmp((char *)chain->StrOfAE, (char *)name) != 0) chain = RepAtom(chain->NextOfAE); if (EndOfPAEntr(chain)) return (FALSE); @@ -93,44 +89,41 @@ AlreadyHidden(unsigned char *name) result in a different atom.xs **/ -static Int -hide_atom( USES_REGS1 ) -{ /* hide(+Atom) */ - Atom atomToInclude; +static Int hide_atom(USES_REGS1) { /* hide(+Atom) */ + Atom atomToInclude; Term t1 = Deref(ARG1); if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR,t1,"hide_atom/1"); - return(FALSE); + Yap_Error(INSTANTIATION_ERROR, t1, "hide_atom/1"); + return (FALSE); } if (!IsAtomTerm(t1)) { - Yap_Error(TYPE_ERROR_ATOM,t1,"hide_atom/1"); - return(FALSE); + Yap_Error(TYPE_ERROR_ATOM, t1, "hide_atom/1"); + return (FALSE); } atomToInclude = AtomOfTerm(t1); if (AlreadyHidden(RepAtom(atomToInclude)->UStrOfAE)) { - Yap_Error(SYSTEM_ERROR_INTERNAL,t1,"an atom of name %s was already hidden", - RepAtom(atomToInclude)->StrOfAE); - return(FALSE); + Yap_Error(SYSTEM_ERROR_INTERNAL, t1, + "an atom of name %s was already hidden", + RepAtom(atomToInclude)->StrOfAE); + return (FALSE); } AtomEntry *ae = RepAtom(atomToInclude); Prop p = ae->PropsOfAE; while (p) { - if (IsPredProperty(p->KindOfPE) || - IsDBProperty(p->KindOfPE ) ) { + if (IsPredProperty(p->KindOfPE) || IsDBProperty(p->KindOfPE)) { RepPredProp(p)->PredFlags |= HiddenPredFlag; - + } else if (p->KindOfPE == FunctorProperty) { Prop q = RepFunctorProp(p)->PropsOfFE; while (q) { - if (IsPredProperty(q->KindOfPE) || - IsDBProperty(q->KindOfPE) ) { + if (IsPredProperty(q->KindOfPE) || IsDBProperty(q->KindOfPE)) { RepPredProp(q)->PredFlags |= HiddenPredFlag; } q = q->NextOfPE; } } - p =p->NextOfPE; + p = p->NextOfPE; } Yap_ReleaseAtom(atomToInclude); WRITE_LOCK(INVISIBLECHAIN.AERWLock); @@ -142,15 +135,13 @@ hide_atom( USES_REGS1 ) return (TRUE); } -/** @pred hidden_atom( +Atom ) +/** @pred hidden_atom( +Atom ) Is the atom _Ãtom_ visible to Prolog? **/ -static Int -hidden_atom( USES_REGS1 ) -{ /* '$hidden_atom'(+F) */ - Atom at; - AtomEntry *chain; +static Int hidden_atom(USES_REGS1) { /* '$hidden_atom'(+F) */ + Atom at; + AtomEntry *chain; Term t1 = Deref(ARG1); if (IsVarTerm(t1)) @@ -171,37 +162,36 @@ hidden_atom( USES_REGS1 ) return (TRUE); } - -/** @pred unhide_atom(+ _Atom_) +/** @pred unhide_atom(+ _Atom_) Make hidden atom _Atom_ visible - - Note that the operation fails if another atom with name _Atom_ was defined since. + + Note that the operation fails if another atom with name _Atom_ was defined + since. **/ -static Int -unhide_atom( USES_REGS1 ) -{ /* unhide_atom(+Atom) */ - AtomEntry *atom, *old, *chain; +static Int unhide_atom(USES_REGS1) { /* unhide_atom(+Atom) */ + AtomEntry *atom, *old, *chain; Term t1 = Deref(ARG1); if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR,t1,"unhide_atom/1"); - return(FALSE); + Yap_Error(INSTANTIATION_ERROR, t1, "unhide_atom/1"); + return (FALSE); } if (!IsAtomTerm(t1)) { - Yap_Error(TYPE_ERROR_ATOM,t1,"unhide_atom/1"); - return(FALSE); + Yap_Error(TYPE_ERROR_ATOM, t1, "unhide_atom/1"); + return (FALSE); } atom = RepAtom(AtomOfTerm(t1)); WRITE_LOCK(atom->ARWLock); if (atom->PropsOfAE != NIL) { - Yap_Error(SYSTEM_ERROR_INTERNAL,t1,"cannot unhide_atom an atom in use"); - return(FALSE); + Yap_Error(SYSTEM_ERROR_INTERNAL, t1, "cannot unhide_atom an atom in use"); + return (FALSE); } WRITE_LOCK(INVISIBLECHAIN.AERWLock); chain = RepAtom(INVISIBLECHAIN.Entry); old = NIL; - while (!EndOfPAEntr(chain) && strcmp((char *)chain->StrOfAE, (char *)atom->StrOfAE) != 0) { + while (!EndOfPAEntr(chain) && + strcmp((char *)chain->StrOfAE, (char *)atom->StrOfAE) != 0) { old = chain; chain = RepAtom(chain->NextOfAE); } @@ -217,104 +207,99 @@ unhide_atom( USES_REGS1 ) return (TRUE); } -static Int -char_code( USES_REGS1 ) -{ +static Int char_code(USES_REGS1) { Int t0 = Deref(ARG1); if (IsVarTerm(t0)) { Term t1 = Deref(ARG2); if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR,t0,"char_code/2"); - return(FALSE); + Yap_Error(INSTANTIATION_ERROR, t0, "char_code/2"); + return (FALSE); } else if (!IsIntegerTerm(t1)) { if (!IsBigIntTerm(t1)) { - Yap_Error(REPRESENTATION_ERROR_INT,t1,"char_code/2"); - return(FALSE); + Yap_Error(REPRESENTATION_ERROR_INT, t1, "char_code/2"); + return (FALSE); } - Yap_Error(TYPE_ERROR_INTEGER,t1,"char_code/2"); - return(FALSE); + Yap_Error(TYPE_ERROR_INTEGER, t1, "char_code/2"); + return (FALSE); } else { Int code = IntegerOfTerm(t1); Term tout; if (code < 0) { - Yap_Error(REPRESENTATION_ERROR_CHARACTER_CODE,t1,"char_code/2"); - return(FALSE); + Yap_Error(REPRESENTATION_ERROR_CHARACTER_CODE, t1, "char_code/2"); + return (FALSE); } if (code > MAX_ISO_LATIN1) { - wchar_t wcodes[2]; + wchar_t wcodes[2]; - if (code > CHARCODE_MAX) { - Yap_Error(REPRESENTATION_ERROR_INT,t1,"char_code/2"); - return(FALSE); - } - wcodes[0] = code; - wcodes[1] = '\0'; - tout = MkAtomTerm(Yap_LookupWideAtom(wcodes)); + if (code > CHARCODE_MAX) { + Yap_Error(REPRESENTATION_ERROR_INT, t1, "char_code/2"); + return (FALSE); + } + wcodes[0] = code; + wcodes[1] = '\0'; + tout = MkAtomTerm(Yap_LookupWideAtom(wcodes)); } else { - char codes[2]; + char codes[2]; - codes[0] = code; - codes[1] = '\0'; - tout = MkAtomTerm(Yap_LookupAtom(codes)); + codes[0] = code; + codes[1] = '\0'; + tout = MkAtomTerm(Yap_LookupAtom(codes)); } - return Yap_unify(ARG1,tout); + return Yap_unify(ARG1, tout); } } else if (!IsAtomTerm(t0)) { - Yap_Error(TYPE_ERROR_CHARACTER,t0,"char_code/2"); - return(FALSE); + Yap_Error(TYPE_ERROR_CHARACTER, t0, "char_code/2"); + return (FALSE); } else { Atom at = AtomOfTerm(t0); Term tf; if (IsWideAtom(at)) { wchar_t *c = RepAtom(at)->WStrOfAE; - + if (c[1] != '\0') { - Yap_Error(TYPE_ERROR_CHARACTER,t0,"char_code/2"); - return FALSE; + Yap_Error(TYPE_ERROR_CHARACTER, t0, "char_code/2"); + return FALSE; } tf = MkIntegerTerm(c[0]); } else { unsigned char *c = RepAtom(at)->UStrOfAE; - + if (c[1] != '\0') { - Yap_Error(TYPE_ERROR_CHARACTER,t0,"char_code/2"); - return FALSE; + Yap_Error(TYPE_ERROR_CHARACTER, t0, "char_code/2"); + return FALSE; } tf = MkIntTerm((unsigned char)(c[0])); } - return Yap_unify(ARG2,tf); + return Yap_unify(ARG2, tf); } } -static Int -name( USES_REGS1 ) -{ /* name(?Atomic,?String) */ - Term t = Deref(ARG2), NewT, AtomNameT = Deref(ARG1); +static Int name(USES_REGS1) { /* name(?Atomic,?String) */ + Term t = Deref(ARG2), NewT, AtomNameT = Deref(ARG1); LOCAL_MAX_SIZE = 1024; - restart_aux: +restart_aux: if (Yap_IsGroundTerm(AtomNameT)) { if (!IsVarTerm(t) && !IsPairTerm(t) && t != TermNil) { - Yap_Error(TYPE_ERROR_LIST,ARG2, - "name/2"); + Yap_Error(TYPE_ERROR_LIST, ARG2, "name/2"); return FALSE; } // verify if an atom, int, float or bi§gnnum - NewT = Yap_AtomicToListOfCodes( AtomNameT PASS_REGS ); + NewT = Yap_AtomicToListOfCodes(AtomNameT PASS_REGS); if (NewT) return Yap_unify(NewT, ARG2); // else - } else if (IsVarTerm(t)){ - Yap_Error(INSTANTIATION_ERROR,t, - "name/2"); + } else if (IsVarTerm(t)) { + Yap_Error(INSTANTIATION_ERROR, t, "name/2"); return FALSE; } else { - Term at = Yap_ListToAtomic( t PASS_REGS ); - if (at) return Yap_unify(at, ARG1); + Term at = Yap_ListToAtomic(t PASS_REGS); + if (at) + return Yap_unify(at, ARG1); } - if (LOCAL_Error_TYPE && Yap_HandleError( "atom/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atom/2")) { AtomNameT = Deref(ARG1); t = Deref(ARG2); goto restart_aux; @@ -322,27 +307,27 @@ name( USES_REGS1 ) return FALSE; } -static Int -string_to_atomic( USES_REGS1 ) -{ /* string_to_atom(?String,?Atom) */ - Term t2 = Deref(ARG2), t1 = Deref(ARG1); +static Int string_to_atomic( + USES_REGS1) { /* string_to_atom(?String,?Atom) */ + Term t2 = Deref(ARG2), t1 = Deref(ARG1); LOCAL_MAX_SIZE = 1024; - restart_aux: +restart_aux: if (IsStringTerm(t1)) { Term t; // verify if an atom, int, float or bignnum - t = Yap_StringToAtomic( t1 PASS_REGS ); + t = Yap_StringToAtomic(t1 PASS_REGS); if (t != 0L) return Yap_unify(t, t2); // else } else if (IsVarTerm(t1)) { - Term t0 = Yap_AtomicToString( t2 PASS_REGS ); - if (t0) return Yap_unify(t0, t1); + Term t0 = Yap_AtomicToString(t2 PASS_REGS); + if (t0) + return Yap_unify(t0, t1); } else { LOCAL_Error_TYPE = TYPE_ERROR_STRING; } - if (LOCAL_Error_TYPE && Yap_HandleError( "string_to_atomic/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("string_to_atomic/2")) { t1 = Deref(ARG1); t2 = Deref(ARG2); goto restart_aux; @@ -350,27 +335,27 @@ string_to_atomic( USES_REGS1 ) return FALSE; } -static Int -string_to_atom( USES_REGS1 ) -{ /* string_to_atom(?String,?Atom) */ - Term t2 = Deref(ARG2), t1 = Deref(ARG1); +static Int string_to_atom( + USES_REGS1) { /* string_to_atom(?String,?Atom) */ + Term t2 = Deref(ARG2), t1 = Deref(ARG1); LOCAL_MAX_SIZE = 1024; - restart_aux: +restart_aux: if (IsStringTerm(t1)) { Atom at; // verify if an atom, int, float or bignnum - at = Yap_StringSWIToAtom( t1 PASS_REGS ); + at = Yap_StringSWIToAtom(t1 PASS_REGS); if (at) return Yap_unify(MkAtomTerm(at), t2); // else - } else if (IsVarTerm(t1)) { - Term t0 = Yap_AtomSWIToString( t2 PASS_REGS ); - if (t0) return Yap_unify(t0, t1); + } else if (IsVarTerm(t1)) { + Term t0 = Yap_AtomSWIToString(t2 PASS_REGS); + if (t0) + return Yap_unify(t0, t1); } else { LOCAL_Error_TYPE = TYPE_ERROR_ATOM; } - if (LOCAL_Error_TYPE && Yap_HandleError( "string_to_atom/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("string_to_atom/2")) { t1 = Deref(ARG1); t2 = Deref(ARG2); goto restart_aux; @@ -378,24 +363,22 @@ string_to_atom( USES_REGS1 ) return FALSE; } -static Int -string_to_list( USES_REGS1 ) -{ - Term list = Deref(ARG2), string = Deref(ARG1); +static Int string_to_list(USES_REGS1) { + Term list = Deref(ARG2), string = Deref(ARG1); LOCAL_MAX_SIZE = 1024; - restart_aux: +restart_aux: if (IsVarTerm(string)) { - Term t1 = Yap_ListToString( list PASS_REGS); + Term t1 = Yap_ListToString(list PASS_REGS); if (t1) - return Yap_unify( ARG1, t1 ); + return Yap_unify(ARG1, t1); } else if (IsStringTerm(string)) { Term tf = Yap_StringToListOfCodes(string PASS_REGS); - return Yap_unify( ARG2, tf ); + return Yap_unify(ARG2, tf); } else { LOCAL_Error_TYPE = TYPE_ERROR_STRING; } - if (LOCAL_Error_TYPE && Yap_HandleError( "string_to_list/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("string_to_list/2")) { string = Deref(ARG1); list = Deref(ARG2); goto restart_aux; @@ -403,27 +386,26 @@ string_to_list( USES_REGS1 ) return FALSE; } -static Int -atom_string( USES_REGS1 ) -{ - Term t1 = Deref(ARG1), t2 = Deref(ARG2); +static Int atom_string(USES_REGS1) { + Term t1 = Deref(ARG1), t2 = Deref(ARG2); LOCAL_MAX_SIZE = 1024; - restart_aux: +restart_aux: if (IsVarTerm(t1)) { Atom at; // verify if an atom, int, float or bignnum - at = Yap_StringSWIToAtom( t2 PASS_REGS ); + at = Yap_StringSWIToAtom(t2 PASS_REGS); if (at) return Yap_unify(MkAtomTerm(at), t1); // else } else if (IsAtomTerm(t1)) { - Term t0 = Yap_AtomSWIToString( t1 PASS_REGS ); - if (t0) return Yap_unify(t0, t2); + Term t0 = Yap_AtomSWIToString(t1 PASS_REGS); + if (t0) + return Yap_unify(t0, t2); } else { LOCAL_Error_TYPE = TYPE_ERROR_ATOM; } - if (LOCAL_Error_TYPE && Yap_HandleError( "atom_string/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atom_string/2")) { t1 = Deref(ARG1); t2 = Deref(ARG2); goto restart_aux; @@ -431,257 +413,241 @@ atom_string( USES_REGS1 ) return FALSE; } -static Int -atom_chars( USES_REGS1 ) -{ +static Int atom_chars(USES_REGS1) { Term t1; LOCAL_MAX_SIZE = 1024; - restart_aux: - t1 = Deref(ARG1); +restart_aux: + t1 = Deref(ARG1); if (IsAtomTerm(t1)) { Term tf = Yap_AtomSWIToListOfAtoms(t1 PASS_REGS); if (tf) - return Yap_unify( ARG2, tf ); - } else if (IsVarTerm(t1)) { + return Yap_unify(ARG2, tf); + } else if (IsVarTerm(t1)) { /* ARG1 unbound */ - Term t = Deref(ARG2); + Term t = Deref(ARG2); Atom af = Yap_ListOfAtomsToAtom(t PASS_REGS); if (af) - return Yap_unify( ARG1, MkAtomTerm(af) ); - /* error handling */ + return Yap_unify(ARG1, MkAtomTerm(af)); + /* error handling */ } else { LOCAL_Error_TYPE = TYPE_ERROR_ATOM; } - if (LOCAL_Error_TYPE && Yap_HandleError( "atom_chars/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atom_chars/2")) { goto restart_aux; } return false; } -static Int -atom_codes( USES_REGS1 ) -{ +static Int atom_codes(USES_REGS1) { Term t1; - t1 = Deref(ARG1); + t1 = Deref(ARG1); restart_aux: if (IsAtomTerm(t1)) { Term tf = Yap_AtomToListOfCodes(t1 PASS_REGS); if (tf) - return Yap_unify( ARG2, tf ); + return Yap_unify(ARG2, tf); } else if (IsVarTerm(t1)) { /* ARG1 unbound */ - Term t = Deref(ARG2); + Term t = Deref(ARG2); Atom af = Yap_ListToAtom(t PASS_REGS); if (af) - return Yap_unify( ARG1, MkAtomTerm(af) ); - } else if (IsVarTerm(t1)) { + return Yap_unify(ARG1, MkAtomTerm(af)); + } else if (IsVarTerm(t1)) { LOCAL_Error_TYPE = TYPE_ERROR_ATOM; } /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "atom_codes/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atom_codes/2")) { t1 = Deref(ARG1); goto restart_aux; } return FALSE; } -static Int -string_codes( USES_REGS1 ) -{ +static Int string_codes(USES_REGS1) { Term t1; - t1 = Deref(ARG1); + t1 = Deref(ARG1); restart_aux: if (IsStringTerm(t1)) { Term tf = Yap_StringSWIToListOfCodes(t1 PASS_REGS); if (tf) - return Yap_unify( ARG2, tf ); - } else if (IsVarTerm(t1)) { + return Yap_unify(ARG2, tf); + } else if (IsVarTerm(t1)) { /* ARG1 unbound */ - Term t = Deref(ARG2); + Term t = Deref(ARG2); Term tf = Yap_ListSWIToString(t PASS_REGS); if (tf) - return Yap_unify( ARG1, tf ); + return Yap_unify(ARG1, tf); } else { LOCAL_Error_TYPE = TYPE_ERROR_STRING; } /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "atom_codes/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atom_codes/2")) { t1 = Deref(ARG1); goto restart_aux; } return FALSE; } -static Int -string_chars( USES_REGS1 ) -{ +static Int string_chars(USES_REGS1) { Term t1; - t1 = Deref(ARG1); + t1 = Deref(ARG1); restart_aux: if (IsStringTerm(t1)) { Term tf = Yap_StringSWIToListOfAtoms(t1 PASS_REGS); if (tf) - return Yap_unify( ARG2, tf ); - } else if (IsVarTerm(t1)) { + return Yap_unify(ARG2, tf); + } else if (IsVarTerm(t1)) { /* ARG1 unbound */ - Term t = Deref(ARG2); + Term t = Deref(ARG2); Term tf = Yap_ListSWIToString(t PASS_REGS); if (tf) - return Yap_unify( ARG1, tf ); + return Yap_unify(ARG1, tf); } else { LOCAL_Error_TYPE = TYPE_ERROR_STRING; } /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "string_chars/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("string_chars/2")) { t1 = Deref(ARG1); goto restart_aux; } return FALSE; } -/** @pred number_chars(? _I_,? _L_) is iso +/** @pred number_chars(? _I_,? _L_) is iso The predicate holds when at least one of the arguments is ground (otherwise, an error message will be displayed). The argument _I_ must be unifiable with a number, and the argument _L_ with the list of the characters of the external representation of _I_. - + */ -static Int -number_chars( USES_REGS1 ) -{ +static Int number_chars(USES_REGS1) { Term t1; - restart_aux: - t1 = Deref(ARG1); +restart_aux: + t1 = Deref(ARG1); if (IsNumTerm(t1)) { Term tf; tf = Yap_NumberToListOfAtoms(t1 PASS_REGS); if (tf) { LOCAL_Error_TYPE = YAP_NO_ERROR; - return Yap_unify( ARG2, tf ); + return Yap_unify(ARG2, tf); } } else if (IsVarTerm(t1)) { /* ARG1 unbound */ - Term t = Deref(ARG2); + Term t = Deref(ARG2); Term tf = Yap_ListToNumber(t PASS_REGS); if (tf) { LOCAL_Error_TYPE = YAP_NO_ERROR; - return Yap_unify( ARG1, tf ); + return Yap_unify(ARG1, tf); } - } else if (IsVarTerm(t1)) { + } else if (IsVarTerm(t1)) { LOCAL_Error_TYPE = TYPE_ERROR_NUMBER; } /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "number_chars/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("number_chars/2")) { goto restart_aux; } return false; } -static Int -number_atom( USES_REGS1 ) -{ +static Int number_atom(USES_REGS1) { Term t1; - restart_aux: - t1 = Deref(ARG1); +restart_aux: + t1 = Deref(ARG1); if (IsNumTerm(t1)) { Atom af; af = Yap_NumberToAtom(t1 PASS_REGS); if (af) - return Yap_unify( ARG2, MkAtomTerm(af) ); + return Yap_unify(ARG2, MkAtomTerm(af)); } else if (IsVarTerm(t1)) { /* ARG1 unbound */ - Term t = Deref(ARG2); + Term t = Deref(ARG2); Term tf = Yap_AtomToNumber(t PASS_REGS); if (tf) - return Yap_unify( ARG1, tf ); - } else if (IsVarTerm(t1)) { + return Yap_unify(ARG1, tf); + } else if (IsVarTerm(t1)) { LOCAL_Error_TYPE = TYPE_ERROR_NUMBER; - } /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "number_atom/2")) { + } /* error handling */ + if (LOCAL_Error_TYPE && Yap_HandleError("number_atom/2")) { goto restart_aux; } return false; } -static Int -number_string( USES_REGS1 ) -{ +static Int number_string(USES_REGS1) { Term t1; - restart_aux: - t1 = Deref(ARG1); +restart_aux: + t1 = Deref(ARG1); if (IsNumTerm(t1)) { Term tf; tf = Yap_NumberToString(t1 PASS_REGS); if (tf) - return Yap_unify( ARG2, tf ); + return Yap_unify(ARG2, tf); } else if (IsVarTerm(t1)) { /* ARG1 unbound */ - Term t = Deref(ARG2); + Term t = Deref(ARG2); Term tf = Yap_StringToNumber(t PASS_REGS); if (tf) - return Yap_unify( ARG1, tf ); - } else { - LOCAL_Error_TYPE = TYPE_ERROR_NUMBER; - } - /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "number_string/2")) { - goto restart_aux; - } - return FALSE; -} - -static Int -number_codes( USES_REGS1 ) -{ - Term t1; - restart_aux: - t1 = Deref(ARG1); - if (IsNumTerm(t1)) { - Term tf; - tf = Yap_NumberToListOfCodes(t1 PASS_REGS); - if (tf) - return Yap_unify( ARG2, tf ); - } else if (IsVarTerm(t1)) { - /* ARG1 unbound */ - Term t = Deref(ARG2); - Term tf = Yap_ListToNumber(t PASS_REGS); - if (tf) - return Yap_unify( ARG1, tf ); + return Yap_unify(ARG1, tf); } else { LOCAL_Error_TYPE = TYPE_ERROR_NUMBER; } /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "number_codes/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("number_string/2")) { goto restart_aux; } return FALSE; } -static Int -cont_atom_concat3( USES_REGS1 ) -{ +static Int number_codes(USES_REGS1) { + Term t1; +restart_aux: + t1 = Deref(ARG1); + if (IsNumTerm(t1)) { + Term tf; + tf = Yap_NumberToListOfCodes(t1 PASS_REGS); + if (tf) + return Yap_unify(ARG2, tf); + } else if (IsVarTerm(t1)) { + /* ARG1 unbound */ + Term t = Deref(ARG2); + Term tf = Yap_ListToNumber(t PASS_REGS); + if (tf) + return Yap_unify(ARG1, tf); + } else { + LOCAL_Error_TYPE = TYPE_ERROR_NUMBER; + } + /* error handling */ + if (LOCAL_Error_TYPE && Yap_HandleError("number_codes/2")) { + goto restart_aux; + } + return FALSE; +} + +static Int cont_atom_concat3(USES_REGS1) { Term t3; Atom ats[2]; Int i, max; - restart_aux: +restart_aux: t3 = Deref(ARG3); - i = IntOfTerm(EXTRA_CBACK_ARG(3,1)); - max = IntOfTerm(EXTRA_CBACK_ARG(3,2)); - EXTRA_CBACK_ARG(3,1) = MkIntTerm(i+1); - if ( ! Yap_SpliceAtom( t3, ats, i, max PASS_REGS ) ) { + i = IntOfTerm(EXTRA_CBACK_ARG(3, 1)); + max = IntOfTerm(EXTRA_CBACK_ARG(3, 2)); + EXTRA_CBACK_ARG(3, 1) = MkIntTerm(i + 1); + if (!Yap_SpliceAtom(t3, ats, i, max PASS_REGS)) { cut_fail(); } else { - if (i < max) return Yap_unify( ARG1, MkAtomTerm(ats[0])) && - Yap_unify( ARG2, MkAtomTerm(ats[1])) ; - if (Yap_unify( ARG1, MkAtomTerm(ats[0])) && - Yap_unify( ARG2, MkAtomTerm(ats[1]))) cut_succeed(); + if (i < max) + return Yap_unify(ARG1, MkAtomTerm(ats[0])) && + Yap_unify(ARG2, MkAtomTerm(ats[1])); + if (Yap_unify(ARG1, MkAtomTerm(ats[0])) && + Yap_unify(ARG2, MkAtomTerm(ats[1]))) + cut_succeed(); cut_fail(); } /* Error handling */ if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "atom_concat/3" )) { + if (Yap_HandleError("atom_concat/3")) { goto restart_aux; } else { return FALSE; @@ -690,43 +656,43 @@ cont_atom_concat3( USES_REGS1 ) cut_fail(); } - -static Int -atom_concat3( USES_REGS1 ) -{ +static Int atom_concat3(USES_REGS1) { Term t1; Term t2, t3, ot; Atom at; - restart_aux: +restart_aux: t1 = Deref(ARG1); t2 = Deref(ARG2); t3 = Deref(ARG3); if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t2)) { - at = Yap_ConcatAtoms( t1, t2 PASS_REGS ); + at = Yap_ConcatAtoms(t1, t2 PASS_REGS); ot = ARG3; - } else if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t3) ) { - at = Yap_SubtractHeadAtom( Deref(ARG3), t1 PASS_REGS ); + } else if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t3)) { + at = Yap_SubtractHeadAtom(Deref(ARG3), t1 PASS_REGS); ot = ARG2; } else if (Yap_IsGroundTerm(t2) && Yap_IsGroundTerm(t3)) { - at = Yap_SubtractTailAtom( Deref(ARG3), t2 PASS_REGS ); + at = Yap_SubtractTailAtom(Deref(ARG3), t2 PASS_REGS); ot = ARG1; } else if (Yap_IsGroundTerm(t3)) { - EXTRA_CBACK_ARG(3,1) = MkIntTerm(0); - EXTRA_CBACK_ARG(3,2) = MkIntTerm(Yap_AtomToLength(t3 PASS_REGS)); - return cont_atom_concat3( PASS_REGS1 ); + EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0); + EXTRA_CBACK_ARG(3, 2) = MkIntTerm(Yap_AtomToLength(t3 PASS_REGS)); + return cont_atom_concat3(PASS_REGS1); } else { LOCAL_Error_TYPE = INSTANTIATION_ERROR; LOCAL_Error_Term = t1; - Yap_Error( INSTANTIATION_ERROR, IsVarTerm(t1) ? t1 : t2, "got atom_concat(X,atom,Z) or atom_concat(,atom,Y,Z)" ); + Yap_Error(INSTANTIATION_ERROR, IsVarTerm(t1) ? t1 : t2, + "got atom_concat(X,atom,Z) or atom_concat(,atom,Y,Z)"); return false; } if (at) { - if (Yap_unify(ot, MkAtomTerm(at))) cut_succeed(); - else cut_fail(); + if (Yap_unify(ot, MkAtomTerm(at))) + cut_succeed(); + else + cut_fail(); } /* Error handling */ if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "atom_concat/3" )) { + if (Yap_HandleError("atom_concat/3")) { goto restart_aux; } else { return FALSE; @@ -737,51 +703,44 @@ atom_concat3( USES_REGS1 ) #define CastToAtom(x) CastToAtom__(x PASS_REGS) -static Term -CastToAtom__(Term t USES_REGS) -{ +static Term CastToAtom__(Term t USES_REGS) { if (IsAtomTerm(t)) return t; - return MkAtomTerm(Yap_AtomicToAtom( t PASS_REGS)); + return MkAtomTerm(Yap_AtomicToAtom(t PASS_REGS)); } #define CastToNumeric(x) CastToNumeric__(x PASS_REGS) -static Term -CastToNumeric__(Atom at USES_REGS) -{ - Term t; - if ((t = Yap_AtomToNumber( MkAtomTerm( at ) PASS_REGS) ) ) +static Term CastToNumeric__(Atom at USES_REGS) { + Term t; + if ((t = Yap_AtomToNumber(MkAtomTerm(at) PASS_REGS))) return t; return MkAtomTerm(at); } - -static Int -cont_atomic_concat3( USES_REGS1 ) -{ +static Int cont_atomic_concat3(USES_REGS1) { Term t3; Atom ats[2]; size_t i, max; - restart_aux: +restart_aux: t3 = Deref(ARG3); - i = IntOfTerm(EXTRA_CBACK_ARG(3,1)); - max = IntOfTerm(EXTRA_CBACK_ARG(3,2)); - EXTRA_CBACK_ARG(3,1) = MkIntTerm(i+1); - if ( ! Yap_SpliceAtom( t3, ats, i, max PASS_REGS ) ) { + i = IntOfTerm(EXTRA_CBACK_ARG(3, 1)); + max = IntOfTerm(EXTRA_CBACK_ARG(3, 2)); + EXTRA_CBACK_ARG(3, 1) = MkIntTerm(i + 1); + if (!Yap_SpliceAtom(t3, ats, i, max PASS_REGS)) { cut_fail(); } else { - Term t1 = CastToNumeric(ats[0]); - Term t2 = CastToNumeric(ats[1]); - if (i < max) return Yap_unify( ARG1, t1) && - Yap_unify( ARG2, t2) ; - if (Yap_unify( ARG1, t1) && - Yap_unify( ARG2, t2)) cut_succeed(); + Term t1 = CastToNumeric(ats[0]); + Term t2 = CastToNumeric(ats[1]); + if (i < max) + return Yap_unify(ARG1, t1) && Yap_unify(ARG2, t2); + if (Yap_unify(ARG1, t1) && Yap_unify(ARG2, t2)) + cut_succeed(); cut_fail(); } /* Error handling */ if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "string_concat/3" )) { + if (Yap_HandleError("string_concat/3")) { goto restart_aux; } else { return FALSE; @@ -790,40 +749,40 @@ cont_atomic_concat3( USES_REGS1 ) cut_fail(); } -static Int -atomic_concat3( USES_REGS1 ) -{ +static Int atomic_concat3(USES_REGS1) { Term t1; Term t2, t3, ot; Atom at = NULL; - restart_aux: +restart_aux: t1 = Deref(ARG1); t2 = Deref(ARG2); t3 = Deref(ARG3); if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t2)) { - at = Yap_ConcatAtoms( CastToAtom(t1), CastToAtom(t2) PASS_REGS ); + at = Yap_ConcatAtoms(CastToAtom(t1), CastToAtom(t2) PASS_REGS); ot = ARG3; - } else if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t3) ) { - at = Yap_SubtractHeadAtom( t3, CastToAtom(t1) PASS_REGS ); + } else if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t3)) { + at = Yap_SubtractHeadAtom(t3, CastToAtom(t1) PASS_REGS); ot = ARG2; } else if (Yap_IsGroundTerm(t2) && Yap_IsGroundTerm(t3)) { - at = Yap_SubtractTailAtom( t3, CastToAtom(t2) PASS_REGS ); + at = Yap_SubtractTailAtom(t3, CastToAtom(t2) PASS_REGS); ot = ARG1; } else if (Yap_IsGroundTerm(t3)) { - EXTRA_CBACK_ARG(3,1) = MkIntTerm(0); - EXTRA_CBACK_ARG(3,2) = MkIntTerm(Yap_AtomicToLength(t3 PASS_REGS)); - return cont_atomic_concat3( PASS_REGS1 ); + EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0); + EXTRA_CBACK_ARG(3, 2) = MkIntTerm(Yap_AtomicToLength(t3 PASS_REGS)); + return cont_atomic_concat3(PASS_REGS1); } else { LOCAL_Error_TYPE = INSTANTIATION_ERROR; LOCAL_Error_Term = t1; } if (at) { - if (Yap_unify(ot, CastToNumeric(at))) cut_succeed(); - else cut_fail(); + if (Yap_unify(ot, CastToNumeric(at))) + cut_succeed(); + else + cut_fail(); } /* Error handling */ if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "atomic_concat/3" )) { + if (Yap_HandleError("atomic_concat/3")) { goto restart_aux; } else { return FALSE; @@ -832,30 +791,27 @@ atomic_concat3( USES_REGS1 ) cut_fail(); } - -static Int -cont_string_concat3( USES_REGS1 ) -{ +static Int cont_string_concat3(USES_REGS1) { Term t3; Term ts[2]; size_t i, max; - restart_aux: +restart_aux: t3 = Deref(ARG3); - i = IntOfTerm(EXTRA_CBACK_ARG(3,1)); - max = IntOfTerm(EXTRA_CBACK_ARG(3,2)); - EXTRA_CBACK_ARG(3,1) = MkIntTerm(i+1); - if ( ! Yap_SpliceString( t3, ts, i, max PASS_REGS ) ) { + i = IntOfTerm(EXTRA_CBACK_ARG(3, 1)); + max = IntOfTerm(EXTRA_CBACK_ARG(3, 2)); + EXTRA_CBACK_ARG(3, 1) = MkIntTerm(i + 1); + if (!Yap_SpliceString(t3, ts, i, max PASS_REGS)) { cut_fail(); } else { - if (i < max) return Yap_unify( ARG1, ts[0]) && - Yap_unify( ARG2, ts[1]) ; - if (Yap_unify( ARG1, ts[0]) && - Yap_unify( ARG2, ts[1])) cut_succeed(); + if (i < max) + return Yap_unify(ARG1, ts[0]) && Yap_unify(ARG2, ts[1]); + if (Yap_unify(ARG1, ts[0]) && Yap_unify(ARG2, ts[1])) + cut_succeed(); cut_fail(); } /* Error handling */ if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "string_concat/3" )) { + if (Yap_HandleError("string_concat/3")) { goto restart_aux; } else { return FALSE; @@ -864,134 +820,41 @@ cont_string_concat3( USES_REGS1 ) cut_fail(); } - -static Int -string_concat3( USES_REGS1 ) -{ +static Int string_concat3(USES_REGS1) { Term t1; Term t2, t3, ot; Term tf = 0; - restart_aux: +restart_aux: t1 = Deref(ARG1); t2 = Deref(ARG2); t3 = Deref(ARG3); if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t2)) { - tf = Yap_ConcatStrings( t1, t2 PASS_REGS ); + tf = Yap_ConcatStrings(t1, t2 PASS_REGS); ot = ARG3; - } else if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t3) ) { - tf = Yap_SubtractHeadString(t3, t1 PASS_REGS ); + } else if (Yap_IsGroundTerm(t1) && Yap_IsGroundTerm(t3)) { + tf = Yap_SubtractHeadString(t3, t1 PASS_REGS); ot = ARG2; } else if (Yap_IsGroundTerm(t2) && Yap_IsGroundTerm(t3)) { - tf = Yap_SubtractTailString( t3, t2 PASS_REGS ); + tf = Yap_SubtractTailString(t3, t2 PASS_REGS); ot = ARG1; } else if (Yap_IsGroundTerm(t3)) { - EXTRA_CBACK_ARG(3,1) = MkIntTerm(0); - EXTRA_CBACK_ARG(3,2) = MkIntTerm(Yap_StringToLength(t3 PASS_REGS)); - return cont_string_concat3( PASS_REGS1 ); + EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0); + EXTRA_CBACK_ARG(3, 2) = MkIntTerm(Yap_StringToLength(t3 PASS_REGS)); + return cont_string_concat3(PASS_REGS1); } else { LOCAL_Error_TYPE = INSTANTIATION_ERROR; LOCAL_Error_Term = t1; } if (tf) { - if (Yap_unify(ot, tf)) { cut_succeed(); } - else { cut_fail(); } - } - /* Error handling */ - if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "string_concat/3" )) { - goto restart_aux; + if (Yap_unify(ot, tf)) { + cut_succeed(); } else { - return FALSE; - } - } - cut_fail(); -} - - -static Int -cont_string_code3( USES_REGS1 ) -{ - Term t2; - Int i, j; - utf8proc_int32_t chr; - const unsigned char *s; - const unsigned char *s0; - restart_aux: - t2 = Deref(ARG2); - s0 = UStringOfTerm( t2 ); - i = IntOfTerm(EXTRA_CBACK_ARG(3,1)); // offset in coded string, increases by 1..6 - j = IntOfTerm(EXTRA_CBACK_ARG(3,2)); // offset in UNICODE string, always increases by 1 - s = (s0+i) + get_utf8( (unsigned char *)s0+i, -1, &chr ); - if (s[0]) { - EXTRA_CBACK_ARG(3,1) = MkIntTerm(s-s0); - EXTRA_CBACK_ARG(3,2) = MkIntTerm(j+1); - return Yap_unify(MkIntegerTerm( chr ), ARG3) && Yap_unify(MkIntegerTerm( j+1 ), ARG1); - } - if (Yap_unify(MkIntegerTerm( chr ), ARG3) && Yap_unify(MkIntegerTerm( j ), ARG1)) - cut_succeed(); - else - cut_fail(); - /* Error handling */ - if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "string_code/3" )) { - goto restart_aux; - } else { - return FALSE; - } - } - cut_fail(); -} - - -static Int -string_code3( USES_REGS1 ) -{ - Term t1; - Term t2; - const unsigned char *s; - restart_aux: - t1 = Deref(ARG1); - t2 = Deref(ARG2); - if (IsVarTerm(t2)) { - LOCAL_Error_TYPE = INSTANTIATION_ERROR; - LOCAL_Error_Term = t2; - } else if (!IsStringTerm(t2)) { - LOCAL_Error_TYPE = TYPE_ERROR_STRING; - LOCAL_Error_Term = t2; - } else { - s = UStringOfTerm( t2 ); - t1 = Deref(ARG1); - if (IsVarTerm(t1)) { - EXTRA_CBACK_ARG(3,1) = MkIntTerm(0); - EXTRA_CBACK_ARG(3,2) = MkIntTerm(0); - return cont_string_code3( PASS_REGS1 ); - } else if (!IsIntegerTerm( t1 )) { - LOCAL_Error_TYPE = TYPE_ERROR_INTEGER; - LOCAL_Error_Term = t1; - } else { - const unsigned char *ns = s; - utf8proc_int32_t chr; - Int indx = IntegerOfTerm( t1 ); - if (indx <= 0) { - if (indx < 0) { - LOCAL_Error_TYPE = DOMAIN_ERROR_NOT_LESS_THAN_ZERO; - LOCAL_Error_Term = t1; - } - cut_fail(); - } - ns = skip_utf8((unsigned char *)s, indx); - if (ns == NULL) { - cut_fail(); // silently fail? - } - get_utf8( (unsigned char *)ns, -1, &chr); - if ( chr == '\0') cut_fail(); - if (Yap_unify(ARG3, MkIntegerTerm(chr))) cut_succeed(); cut_fail(); } } /* Error handling */ if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "string_code/3" )) { + if (Yap_HandleError("string_concat/3")) { goto restart_aux; } else { return FALSE; @@ -1000,14 +863,46 @@ string_code3( USES_REGS1 ) cut_fail(); } +static Int cont_string_code3(USES_REGS1) { + Term t2; + Int i, j; + utf8proc_int32_t chr; + const unsigned char *s; + const unsigned char *s0; +restart_aux: + t2 = Deref(ARG2); + s0 = UStringOfTerm(t2); + i = IntOfTerm( + EXTRA_CBACK_ARG(3, 1)); // offset in coded string, increases by 1..6 + j = IntOfTerm( + EXTRA_CBACK_ARG(3, 2)); // offset in UNICODE string, always increases by 1 + s = (s0 + i) + get_utf8((unsigned char *)s0 + i, -1, &chr); + if (s[0]) { + EXTRA_CBACK_ARG(3, 1) = MkIntTerm(s - s0); + EXTRA_CBACK_ARG(3, 2) = MkIntTerm(j + 1); + return Yap_unify(MkIntegerTerm(chr), ARG3) && + Yap_unify(MkIntegerTerm(j + 1), ARG1); + } + if (Yap_unify(MkIntegerTerm(chr), ARG3) && Yap_unify(MkIntegerTerm(j), ARG1)) + cut_succeed(); + else + cut_fail(); + /* Error handling */ + if (LOCAL_Error_TYPE) { + if (Yap_HandleError("string_code/3")) { + goto restart_aux; + } else { + return FALSE; + } + } + cut_fail(); +} -static Int -get_string_code3( USES_REGS1 ) -{ +static Int string_code3(USES_REGS1) { Term t1; Term t2; const unsigned char *s; - restart_aux: +restart_aux: t1 = Deref(ARG1); t2 = Deref(ARG2); if (IsVarTerm(t2)) { @@ -1017,41 +912,99 @@ get_string_code3( USES_REGS1 ) LOCAL_Error_TYPE = TYPE_ERROR_STRING; LOCAL_Error_Term = t2; } else { - s = UStringOfTerm( t2 ); + s = UStringOfTerm(t2); + t1 = Deref(ARG1); + if (IsVarTerm(t1)) { + EXTRA_CBACK_ARG(3, 1) = MkIntTerm(0); + EXTRA_CBACK_ARG(3, 2) = MkIntTerm(0); + return cont_string_code3(PASS_REGS1); + } else if (!IsIntegerTerm(t1)) { + LOCAL_Error_TYPE = TYPE_ERROR_INTEGER; + LOCAL_Error_Term = t1; + } else { + const unsigned char *ns = s; + utf8proc_int32_t chr; + Int indx = IntegerOfTerm(t1); + if (indx <= 0) { + if (indx < 0) { + LOCAL_Error_TYPE = DOMAIN_ERROR_NOT_LESS_THAN_ZERO; + LOCAL_Error_Term = t1; + } + cut_fail(); + } + ns = skip_utf8((unsigned char *)s, indx); + if (ns == NULL) { + cut_fail(); // silently fail? + } + get_utf8((unsigned char *)ns, -1, &chr); + if (chr == '\0') + cut_fail(); + if (Yap_unify(ARG3, MkIntegerTerm(chr))) + cut_succeed(); + cut_fail(); + } + } + /* Error handling */ + if (LOCAL_Error_TYPE) { + if (Yap_HandleError("string_code/3")) { + goto restart_aux; + } else { + return FALSE; + } + } + cut_fail(); +} + +static Int get_string_code3(USES_REGS1) { + Term t1; + Term t2; + const unsigned char *s; +restart_aux: + t1 = Deref(ARG1); + t2 = Deref(ARG2); + if (IsVarTerm(t2)) { + LOCAL_Error_TYPE = INSTANTIATION_ERROR; + LOCAL_Error_Term = t2; + } else if (!IsStringTerm(t2)) { + LOCAL_Error_TYPE = TYPE_ERROR_STRING; + LOCAL_Error_Term = t2; + } else { + s = UStringOfTerm(t2); t1 = Deref(ARG1); if (IsVarTerm(t1)) { LOCAL_Error_TYPE = INSTANTIATION_ERROR; LOCAL_Error_Term = t1; - } else if (!IsIntegerTerm( t1 )) { + } else if (!IsIntegerTerm(t1)) { LOCAL_Error_TYPE = TYPE_ERROR_INTEGER; LOCAL_Error_Term = t1; } else { - unsigned char *ns = (unsigned char *)s; + unsigned char *ns = (unsigned char *)s; utf8proc_int32_t chr; - Int indx = IntegerOfTerm( t1 ); + Int indx = IntegerOfTerm(t1); if (indx <= 0) { - if (indx < 0) { - LOCAL_Error_TYPE = DOMAIN_ERROR_NOT_LESS_THAN_ZERO; - LOCAL_Error_Term = t1; - } else { - return FALSE; - } + if (indx < 0) { + LOCAL_Error_TYPE = DOMAIN_ERROR_NOT_LESS_THAN_ZERO; + LOCAL_Error_Term = t1; + } else { + return FALSE; + } } else { - indx -= 1; - ns = skip_utf8((unsigned char *)s,indx); - if (ns == NULL) { - return FALSE; - } else { - get_utf8( ns, -1, &chr); - if ( chr != '\0') return Yap_unify(ARG3, MkIntegerTerm(chr)); - } + indx -= 1; + ns = skip_utf8((unsigned char *)s, indx); + if (ns == NULL) { + return FALSE; + } else { + get_utf8(ns, -1, &chr); + if (chr != '\0') + return Yap_unify(ARG3, MkIntegerTerm(chr)); + } } return FALSE; // replace by error code } } /* Error handling */ if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "string_code/3" )) { + if (Yap_HandleError("string_code/3")) { goto restart_aux; } else { return FALSE; @@ -1060,22 +1013,20 @@ get_string_code3( USES_REGS1 ) cut_fail(); } -static Int -atom_concat2( USES_REGS1 ) -{ +static Int atom_concat2(USES_REGS1) { Term t1; Term *tailp; Int n; - restart_aux: +restart_aux: t1 = Deref(ARG1); n = Yap_SkipList(&t1, &tailp); if (*tailp != TermNil) { LOCAL_Error_TYPE = TYPE_ERROR_LIST; } else { - seq_tv_t *inpv = (seq_tv_t *)malloc(n*sizeof(seq_tv_t)), out; + seq_tv_t *inpv = (seq_tv_t *)malloc(n * sizeof(seq_tv_t)), out; int i = 0; Atom at; - + if (!inpv) { LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP; free(inpv); @@ -1094,13 +1045,14 @@ atom_concat2( USES_REGS1 ) goto error; } free(inpv); - at = out.val.a; - if (at) return Yap_unify(ARG2, MkAtomTerm(at)); + at = out.val.a; + if (at) + return Yap_unify(ARG2, MkAtomTerm(at)); } - error: +error: /* Error handling */ if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "atom_concat/2" )) { + if (Yap_HandleError("atom_concat/2")) { goto restart_aux; } else { return FALSE; @@ -1109,21 +1061,19 @@ atom_concat2( USES_REGS1 ) cut_fail(); } -static Int -string_concat2( USES_REGS1 ) -{ +static Int string_concat2(USES_REGS1) { Term t1; Term *tailp; Int n; - restart_aux: +restart_aux: t1 = Deref(ARG1); n = Yap_SkipList(&t1, &tailp); if (*tailp != TermNil) { LOCAL_Error_TYPE = TYPE_ERROR_LIST; } else { - seq_tv_t *inpv = (seq_tv_t *)malloc(n*sizeof(seq_tv_t)), out; + seq_tv_t *inpv = (seq_tv_t *)malloc(n * sizeof(seq_tv_t)), out; int i = 0; - + if (!inpv) { LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP; free(inpv); @@ -1142,12 +1092,13 @@ string_concat2( USES_REGS1 ) goto error; } free(inpv); - if (out.val.t) return Yap_unify(ARG2, out.val.t); + if (out.val.t) + return Yap_unify(ARG2, out.val.t); } - error: +error: /* Error handling */ if (LOCAL_Error_TYPE) { - if (Yap_HandleError( "string_code/3" )) { + if (Yap_HandleError("string_code/3")) { goto restart_aux; } else { return FALSE; @@ -1156,24 +1107,22 @@ string_concat2( USES_REGS1 ) cut_fail(); } - -static Int -atomic_concat2( USES_REGS1 ) -{ +static Int atomic_concat2(USES_REGS1) { Term t1; Term *tailp; Int n; - restart_aux: +restart_aux: t1 = Deref(ARG1); n = Yap_SkipList(&t1, &tailp); if (*tailp != TermNil) { LOCAL_Error_TYPE = TYPE_ERROR_LIST; } else { - seq_tv_t *inpv = (seq_tv_t *)malloc(n*sizeof(seq_tv_t)), out; + seq_tv_t *inpv = (seq_tv_t *)malloc(n * sizeof(seq_tv_t)), out; int i = 0; Atom at; - if (n == 1) return Yap_unify(ARG2, HeadOfTerm(t1)); + if (n == 1) + return Yap_unify(ARG2, HeadOfTerm(t1)); if (!inpv) { LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP; free(inpv); @@ -1181,7 +1130,9 @@ atomic_concat2( USES_REGS1 ) } while (t1 != TermNil) { - inpv[i].type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_CHARS|YAP_STRING_CODES; + inpv[i].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_CHARS | + YAP_STRING_CODES; inpv[i].val.t = HeadOfTerm(t1); i++; t1 = TailOfTerm(t1); @@ -1192,33 +1143,32 @@ atomic_concat2( USES_REGS1 ) goto error; } free(inpv); - at = out.val.a; - if (at) return Yap_unify(ARG2, MkAtomTerm(at)); + at = out.val.a; + if (at) + return Yap_unify(ARG2, MkAtomTerm(at)); } - error: +error: /* Error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "atom_concat/3" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atom_concat/3")) { goto restart_aux; } return FALSE; } -static Int -atomics_to_string2( USES_REGS1 ) -{ +static Int atomics_to_string2(USES_REGS1) { Term t1; Term *tailp; Int n; - restart_aux: +restart_aux: t1 = Deref(ARG1); n = Yap_SkipList(&t1, &tailp); if (*tailp != TermNil) { LOCAL_Error_TYPE = TYPE_ERROR_LIST; } else { - seq_tv_t *inpv = (seq_tv_t *)malloc(n*sizeof(seq_tv_t)), out; + seq_tv_t *inpv = (seq_tv_t *)malloc(n * sizeof(seq_tv_t)), out; int i = 0; Atom at; - + if (!inpv) { LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP; free(inpv); @@ -1226,7 +1176,8 @@ atomics_to_string2( USES_REGS1 ) } while (t1 != TermNil) { - inpv[i].type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inpv[i].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; inpv[i].val.t = HeadOfTerm(t1); i++; t1 = TailOfTerm(t1); @@ -1237,34 +1188,33 @@ atomics_to_string2( USES_REGS1 ) goto error; } free(inpv); - at = out.val.a; - if (at) return Yap_unify(ARG2, MkAtomTerm(at)); + at = out.val.a; + if (at) + return Yap_unify(ARG2, MkAtomTerm(at)); } - error: +error: /* Error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "atomics_to_string/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atomics_to_string/2")) { goto restart_aux; } return FALSE; } -static Int -atomics_to_string3( USES_REGS1 ) -{ +static Int atomics_to_string3(USES_REGS1) { Term t1, t2; Term *tailp; Int n; - restart_aux: +restart_aux: t1 = Deref(ARG1); t2 = Deref(ARG2); n = Yap_SkipList(&t1, &tailp); if (*tailp != TermNil) { LOCAL_Error_TYPE = TYPE_ERROR_LIST; } else { - seq_tv_t *inpv = (seq_tv_t *)malloc((n*2-1)*sizeof(seq_tv_t)), out; + seq_tv_t *inpv = (seq_tv_t *)malloc((n * 2 - 1) * sizeof(seq_tv_t)), out; int i = 0; Atom at; - + if (!inpv) { LOCAL_Error_TYPE = RESOURCE_ERROR_HEAP; free(inpv); @@ -1272,107 +1222,105 @@ atomics_to_string3( USES_REGS1 ) } while (t1 != TermNil) { - inpv[i].type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inpv[i].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; inpv[i].val.t = HeadOfTerm(t1); i++; - inpv[i].type = YAP_STRING_STRING|YAP_STRING_ATOM|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG|YAP_STRING_TERM; + inpv[i].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; inpv[i].val.t = t2; i++; t1 = TailOfTerm(t1); } out.type = YAP_STRING_STRING; - if (!Yap_Concat_Text(2*n-1, inpv, &out PASS_REGS)) { + if (!Yap_Concat_Text(2 * n - 1, inpv, &out PASS_REGS)) { free(inpv); goto error; } free(inpv); - at = out.val.a; - if (at) return Yap_unify(ARG3, MkAtomTerm(at)); + at = out.val.a; + if (at) + return Yap_unify(ARG3, MkAtomTerm(at)); } - error: +error: /* Error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "atomics_to_string/3" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atomics_to_string/3")) { goto restart_aux; } return FALSE; } -static Int -atom_length( USES_REGS1 ) -{ - Term t1 = Deref(ARG1);; +static Int atom_length(USES_REGS1) { + Term t1 = Deref(ARG1); + ; Term t2 = Deref(ARG2); ssize_t len; if (!Yap_IsGroundTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR, t1, "atom_length/2"); - return(FALSE); + Yap_Error(INSTANTIATION_ERROR, t1, "atom_length/2"); + return (FALSE); } else if (!IsAtomTerm(t1)) { - Yap_Error(TYPE_ERROR_ATOM, t1, "atom_length/2"); - return(FALSE); + Yap_Error(TYPE_ERROR_ATOM, t1, "atom_length/2"); + return (FALSE); } if (Yap_IsGroundTerm(t2)) { if (!IsIntegerTerm(t2)) { Yap_Error(TYPE_ERROR_INTEGER, t2, "atom_length/2"); - return(FALSE); + return (FALSE); } else if ((len = IntegerOfTerm(t2)) < 0) { Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t2, "atom_length/2"); - return(FALSE); + return (FALSE); } } restart_aux: len = Yap_AtomicToLength(t1 PASS_REGS); if (len != (size_t)-1) - return Yap_unify( ARG2, MkIntegerTerm(len) ); + return Yap_unify(ARG2, MkIntegerTerm(len)); /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "atom_length/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atom_length/2")) { goto restart_aux; } return FALSE; } -static Int -atomic_length( USES_REGS1 ) -{ +static Int atomic_length(USES_REGS1) { Term t1 = Deref(ARG1); Term t2 = Deref(ARG2); ssize_t len; if (!Yap_IsGroundTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR, t1, "atomic_length/2"); - return(FALSE); + Yap_Error(INSTANTIATION_ERROR, t1, "atomic_length/2"); + return (FALSE); } else if (!IsAtomicTerm(t1)) { - Yap_Error(TYPE_ERROR_ATOM, t1, "atomic_length/2"); - return(FALSE); + Yap_Error(TYPE_ERROR_ATOM, t1, "atomic_length/2"); + return (FALSE); } if (Yap_IsGroundTerm(t2)) { if (!IsIntegerTerm(t2)) { Yap_Error(TYPE_ERROR_INTEGER, t2, "atomic_length/2"); - return(FALSE); + return (FALSE); } if ((len = IntegerOfTerm(t2)) < 0) { Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t2, "atomic_length/2"); - return(FALSE); + return (FALSE); } } restart_aux: len = Yap_AtomicToLength(t1 PASS_REGS); if (len != (size_t)-1) - return Yap_unify( ARG2, MkIntegerTerm(len) ); + return Yap_unify(ARG2, MkIntegerTerm(len)); /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "atomic_length/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atomic_length/2")) { goto restart_aux; } return FALSE; } -static Int -string_length( USES_REGS1 ) -{ +static Int string_length(USES_REGS1) { Term t1; Term t2 = Deref(ARG2); ssize_t len; @@ -1381,29 +1329,26 @@ string_length( USES_REGS1 ) if (!IsIntegerTerm(t2)) { Yap_Error(TYPE_ERROR_INTEGER, t2, "string_length/2"); - return(FALSE); + return (FALSE); } if (FALSE && (len = IntegerOfTerm(t2)) < 0) { Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t2, "string_length/2"); - return(FALSE); + return (FALSE); } } restart_aux: - t1 = Deref(ARG1); + t1 = Deref(ARG1); len = Yap_AtomicToLength(t1 PASS_REGS); if (len != (size_t)-1) - return Yap_unify( ARG2, MkIntegerTerm(len) ); + return Yap_unify(ARG2, MkIntegerTerm(len)); /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "string_length/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("string_length/2")) { goto restart_aux; } return FALSE; } - -static int -is_wide(wchar_t *s) -{ +static int is_wide(wchar_t *s) { wchar_t ch; while ((ch = *s++)) { @@ -1414,9 +1359,7 @@ is_wide(wchar_t *s) } /* split an atom into two sub-atoms */ -static Int -atom_split( USES_REGS1 ) -{ +static Int atom_split(USES_REGS1) { Term t1 = Deref(ARG1); Term t2 = Deref(ARG2); size_t len; @@ -1426,25 +1369,25 @@ atom_split( USES_REGS1 ) if (IsVarTerm(t1)) { Yap_Error(INSTANTIATION_ERROR, t1, "$atom_split/4"); - return(FALSE); + return (FALSE); } if (!IsAtomTerm(t1)) { Yap_Error(TYPE_ERROR_ATOM, t1, "$atom_split/4"); - return(FALSE); + return (FALSE); } if (IsVarTerm(t2)) { Yap_Error(INSTANTIATION_ERROR, t2, "$atom_split/4"); - return(FALSE); + return (FALSE); } if (!IsIntTerm(t2)) { Yap_Error(TYPE_ERROR_INTEGER, t2, "$atom_split/4"); - return(FALSE); + return (FALSE); } if ((Int)(len = IntOfTerm(t2)) < 0) { Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, t2, "$atom_split/4"); - return(FALSE); + return (FALSE); } - at = AtomOfTerm(t1); + at = AtomOfTerm(t1); if (IsWideAtom(at)) { wchar_t *ws, *ws1 = (wchar_t *)HR; unsigned char *s1 = (unsigned char *)HR; @@ -1452,149 +1395,146 @@ atom_split( USES_REGS1 ) ws = (wchar_t *)RepAtom(at)->StrOfAE; wlen = wcslen(ws); - if (len > wlen) return FALSE; - if (s1+len > (unsigned char *)LCL0-1024) - Yap_Error(RESOURCE_ERROR_STACK,t1,"$atom_split/4"); - for (i = 0; i< len; i++) { + if (len > wlen) + return FALSE; + if (s1 + len > (unsigned char *)LCL0 - 1024) + Yap_Error(RESOURCE_ERROR_STACK, t1, "$atom_split/4"); + for (i = 0; i < len; i++) { if (ws[i] > MAX_ISO_LATIN1) { - break; + break; } s1[i] = ws[i]; } if (ws1[i] > MAX_ISO_LATIN1) { /* first sequence is wide */ - if (ws1+len > (wchar_t *)ASP-1024) - Yap_Error(RESOURCE_ERROR_STACK,t1,"$atom_split/4"); + if (ws1 + len > (wchar_t *)ASP - 1024) + Yap_Error(RESOURCE_ERROR_STACK, t1, "$atom_split/4"); ws = (wchar_t *)RepAtom(at)->StrOfAE; - for (i = 0; i< len; i++) { - ws1[i] = ws[i]; + for (i = 0; i < len; i++) { + ws1[i] = ws[i]; } ws1[len] = '\0'; to1 = MkAtomTerm(Yap_LookupWideAtom(ws1)); /* we don't know if the rest of the string is wide or not */ - if (is_wide(ws+len)) { - to2 = MkAtomTerm(Yap_LookupWideAtom(ws+len)); + if (is_wide(ws + len)) { + to2 = MkAtomTerm(Yap_LookupWideAtom(ws + len)); } else { - char *s2 = (char *)HR; - if (s2+(wlen-len) > (char *)ASP-1024) - Yap_Error(RESOURCE_ERROR_STACK,t1,"$atom_split/4"); - ws += len; - while ((*s2++ = *ws++)); - to2 = MkAtomTerm(Yap_LookupAtom(( char *)HR)); + char *s2 = (char *)HR; + if (s2 + (wlen - len) > (char *)ASP - 1024) + Yap_Error(RESOURCE_ERROR_STACK, t1, "$atom_split/4"); + ws += len; + while ((*s2++ = *ws++)) + ; + to2 = MkAtomTerm(Yap_LookupAtom((char *)HR)); } } else { s1[len] = '\0'; to1 = MkAtomTerm(Yap_ULookupAtom(s1)); /* second atom must be wide, if first wasn't */ - to2 = MkAtomTerm(Yap_LookupWideAtom(ws+len)); + to2 = MkAtomTerm(Yap_LookupWideAtom(ws + len)); } } else { unsigned char *s, *s1 = (unsigned char *)HR; s = RepAtom(at)->UStrOfAE; - if (len > (Int)strlen((char *)s)) return(FALSE); - if (s1+len > (unsigned char *)ASP-1024) - Yap_Error(RESOURCE_ERROR_STACK,t1,"$atom_split/4"); - for (i = 0; i< len; i++) { + if (len > (Int)strlen((char *)s)) + return (FALSE); + if (s1 + len > (unsigned char *)ASP - 1024) + Yap_Error(RESOURCE_ERROR_STACK, t1, "$atom_split/4"); + for (i = 0; i < len; i++) { s1[i] = s[i]; } s1[len] = '\0'; to1 = MkAtomTerm(Yap_ULookupAtom(s1)); - to2 = MkAtomTerm(Yap_ULookupAtom(s+len)); + to2 = MkAtomTerm(Yap_ULookupAtom(s + len)); } - return(Yap_unify_constant(ARG3,to1) && Yap_unify_constant(ARG4,to2)); + return (Yap_unify_constant(ARG3, to1) && Yap_unify_constant(ARG4, to2)); } -static Int -atom_number( USES_REGS1 ) -{ +static Int atom_number(USES_REGS1) { Term t1; - restart_aux: - t1 = Deref(ARG1); +restart_aux: + t1 = Deref(ARG1); if (Yap_IsGroundTerm(t1)) { Term tf = Yap_AtomToNumber(t1 PASS_REGS); if (tf) - return Yap_unify( ARG2, tf ); + return Yap_unify(ARG2, tf); } else { /* ARG1 unbound */ - Term t = Deref(ARG2); + Term t = Deref(ARG2); Atom af = Yap_NumberToAtom(t PASS_REGS); if (af) - return Yap_unify( ARG1, MkAtomTerm(af) ); + return Yap_unify(ARG1, MkAtomTerm(af)); } /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "atom_number/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("atom_number/2")) { t1 = Deref(ARG1); goto restart_aux; } return FALSE; } - -static Int -string_number( USES_REGS1 ) -{ +static Int string_number(USES_REGS1) { Term t1; - restart_aux: - t1 = Deref(ARG1); +restart_aux: + t1 = Deref(ARG1); if (Yap_IsGroundTerm(t1)) { Term tf = Yap_StringToNumber(t1 PASS_REGS); if (tf) - return Yap_unify( ARG2, tf ); + return Yap_unify(ARG2, tf); } else { /* ARG1 unbound */ - Term t = Deref(ARG2); + Term t = Deref(ARG2); Term tf = Yap_NumberToString(t PASS_REGS); if (tf) - return Yap_unify( ARG1, tf ); + return Yap_unify(ARG1, tf); } /* error handling */ - if (LOCAL_Error_TYPE && Yap_HandleError( "string_number/2" )) { + if (LOCAL_Error_TYPE && Yap_HandleError("string_number/2")) { t1 = Deref(ARG1); goto restart_aux; } return FALSE; } +#define SUB_ATOM_HAS_MIN 1 +#define SUB_ATOM_HAS_SIZE 2 +#define SUB_ATOM_HAS_AFTER 4 +#define SUB_ATOM_HAS_VAL 8 +#define SUB_ATOM_HAS_WIDE 16 +#define SUB_ATOM_HAS_UTF8 32 -#define SUB_ATOM_HAS_MIN 1 -#define SUB_ATOM_HAS_SIZE 2 -#define SUB_ATOM_HAS_AFTER 4 -#define SUB_ATOM_HAS_VAL 8 -#define SUB_ATOM_HAS_WIDE 16 -#define SUB_ATOM_HAS_UTF8 32 - -static void * -alloc_tmp_stack(size_t sz USES_REGS) { +static void *alloc_tmp_stack(size_t sz USES_REGS) { void *pt = (void *)HR; - while (HR > ASP-(1044+sz/sizeof(CELL))) { - if (!Yap_gc(5, ENV, gc_P(P,CP))) { + while (HR > ASP - (1044 + sz / sizeof(CELL))) { + if (!Yap_gc(5, ENV, gc_P(P, CP))) { Yap_Error(RESOURCE_ERROR_STACK, TermNil, "sub_atom/5"); - return(NULL); + return (NULL); } } return pt; } -static Term -build_new_atomic(int mask, wchar_t *wp, const unsigned char *p, size_t min, size_t len USES_REGS) -{ +static Term build_new_atomic(int mask, wchar_t *wp, const unsigned char *p, + size_t min, size_t len USES_REGS) { Atom nat; if (mask & SUB_ATOM_HAS_WIDE) { - wchar_t *src = wp+min; - wchar_t *d = alloc_tmp_stack((len+1)*sizeof(wchar_t) PASS_REGS); - if (!d) return NIL; - + wchar_t *src = wp + min; + wchar_t *d = alloc_tmp_stack((len + 1) * sizeof(wchar_t) PASS_REGS); + if (!d) + return NIL; + wcsncpy(d, src, len); d[len] = '\0'; nat = Yap_LookupMaybeWideAtom(d); if (nat) return MkAtomTerm(nat); } else if (!(mask & SUB_ATOM_HAS_UTF8)) { - const unsigned char *src = p+min; - unsigned char *d = alloc_tmp_stack((len+1)*sizeof(char) PASS_REGS); - if (!d) return NIL; - + const unsigned char *src = p + min; + unsigned char *d = alloc_tmp_stack((len + 1) * sizeof(char) PASS_REGS); + if (!d) + return NIL; + strncpy((char *)d, (char *)src, len); d[len] = '\0'; nat = Yap_ULookupAtom(d); @@ -1603,131 +1543,134 @@ build_new_atomic(int mask, wchar_t *wp, const unsigned char *p, size_t min, size } else { const unsigned char *src = p; unsigned char *buf; - Term t = init_tstring( PASS_REGS1 ); + Term t = init_tstring(PASS_REGS1); src = skip_utf8((unsigned char *)src, min); const unsigned char *cp = src; - LOCAL_TERM_ERROR( t, 4*(len+1) ); + LOCAL_TERM_ERROR(t, 4 * (len + 1)); buf = buf_from_tstring(HR); while (len) { - utf8proc_int32_t chr; - cp += get_utf8((unsigned char *)cp, -1, &chr); + utf8proc_int32_t chr; + cp += get_utf8((unsigned char *)cp, -1, &chr); buf += put_utf8((unsigned char *)buf, chr); len--; } *buf++ = '\0'; - - close_tstring( buf PASS_REGS ); + + close_tstring(buf PASS_REGS); return t; } return 0L; } -static Int wcsstrcmp(wchar_t *p, char *p2, size_t len) -{ +static Int wcsstrcmp(wchar_t *p, char *p2, size_t len) { while (len--) { - Int d = *p++-*p2++; - if (d) return d; + Int d = *p++ - *p2++; + if (d) + return d; } return 0; } -static int -check_sub_atom_at(int min, Atom at, Atom nat) -{ +static int check_sub_atom_at(int min, Atom at, Atom nat) { if (IsWideAtom(nat)) { wchar_t *p1, *p2; wchar_t c1; - if (!IsWideAtom(at)) return FALSE; - p1 = RepAtom(at)->WStrOfAE+min; + if (!IsWideAtom(at)) + return FALSE; + p1 = RepAtom(at)->WStrOfAE + min; p2 = RepAtom(nat)->WStrOfAE; - while ( (c1 = *p1++) == *p2++ && c1); + while ((c1 = *p1++) == *p2++ && c1) + ; return c1 == 0; } else { if (IsWideAtom(at)) { wchar_t *p1; unsigned char *p2; wchar_t c1; - p1 = RepAtom(at)->WStrOfAE+min; + p1 = RepAtom(at)->WStrOfAE + min; p2 = RepAtom(nat)->UStrOfAE; - while ( (c1 = *p1++) == *p2++ && c1); + while ((c1 = *p1++) == *p2++ && c1) + ; return c1 == 0; } else { unsigned char *p1, *p2; char c1; - p1 = RepAtom(at)->UStrOfAE+min; + p1 = RepAtom(at)->UStrOfAE + min; p2 = RepAtom(nat)->UStrOfAE; - while ( (c1 = *p1++) == *p2++ && c1); + while ((c1 = *p1++) == *p2++ && c1) + ; return c1 == 0; } } } -static int -check_sub_string_at(int min, const unsigned char *p1, const unsigned char *p2, size_t len) -{ +static int check_sub_string_at(int min, const unsigned char *p1, + const unsigned char *p2, size_t len) { p1 = skip_utf8((unsigned char *)p1, min); - return cmpn_utf8( p1, p2, len ) == 0; + return cmpn_utf8(p1, p2, len) == 0; } -static int -check_sub_atom_bef(int max, Atom at, Atom nat) -{ +static int check_sub_atom_bef(int max, Atom at, Atom nat) { if (IsWideAtom(nat)) { wchar_t *p1, *p2; wchar_t c1; size_t len = wcslen(RepAtom(nat)->WStrOfAE); - int min = max- len; - if (min < 0) return FALSE; - if (!IsWideAtom(at)) return FALSE; - p1 = RepAtom(at)->WStrOfAE+min; + int min = max - len; + if (min < 0) + return FALSE; + if (!IsWideAtom(at)) + return FALSE; + p1 = RepAtom(at)->WStrOfAE + min; p2 = RepAtom(nat)->WStrOfAE; - while ( (c1 = *p1++) == *p2++ && c1); + while ((c1 = *p1++) == *p2++ && c1) + ; return c1 == 0; } else { size_t len = strlen((char *)RepAtom(nat)->StrOfAE); - int min = max- len; - if ((Int)(min - len) < 0) return FALSE; + int min = max - len; + if ((Int)(min - len) < 0) + return FALSE; if (IsWideAtom(at)) { wchar_t *p1; unsigned char *p2; wchar_t c1; - p1 = RepAtom(at)->WStrOfAE+min; + p1 = RepAtom(at)->WStrOfAE + min; p2 = RepAtom(nat)->UStrOfAE; - while ( (c1 = *p1++) == *p2++ && c1); + while ((c1 = *p1++) == *p2++ && c1) + ; return c1 == 0; } else { unsigned char *p1, *p2; char c1; - p1 = RepAtom(at)->UStrOfAE+min; + p1 = RepAtom(at)->UStrOfAE + min; p2 = RepAtom(nat)->UStrOfAE; - while ( (c1 = *p1++) == *p2++ && c1); + while ((c1 = *p1++) == *p2++ && c1) + ; return c1 == 0; } } } -static int -check_sub_string_bef(int max, Term at, Term nat) -{ +static int check_sub_string_bef(int max, Term at, Term nat) { size_t len = strlen_utf8(UStringOfTerm(nat)); - int min = max- len; + int min = max - len; const unsigned char *p1, *p2; int c1; - if ((Int)(min - len) < 0) return FALSE; + if ((Int)(min - len) < 0) + return FALSE; - p1 = skip_utf8((unsigned char *)UStringOfTerm(at),min); + p1 = skip_utf8((unsigned char *)UStringOfTerm(at), min); p2 = UStringOfTerm(nat); - while ( (c1 = *p1++) == *p2++ && c1); + while ((c1 = *p1++) == *p2++ && c1) + ; return c1 == 0; } -static Int -cont_sub_atomic( USES_REGS1 ) -{ - Term tat1= Deref(ARG1); +static Int cont_sub_atomic(USES_REGS1) { + Term tat1 = Deref(ARG1); Atom at = NULL; int mask; size_t min, len, after, sz; @@ -1736,11 +1679,11 @@ cont_sub_atomic( USES_REGS1 ) Term nat; int sub_atom = TRUE; - mask = IntegerOfTerm(EXTRA_CBACK_ARG(5,1)); - min = IntegerOfTerm(EXTRA_CBACK_ARG(5,2)); - len = IntegerOfTerm(EXTRA_CBACK_ARG(5,3)); - after = IntegerOfTerm(EXTRA_CBACK_ARG(5,4)); - sz = IntegerOfTerm(EXTRA_CBACK_ARG(5,5)); + mask = IntegerOfTerm(EXTRA_CBACK_ARG(5, 1)); + min = IntegerOfTerm(EXTRA_CBACK_ARG(5, 2)); + len = IntegerOfTerm(EXTRA_CBACK_ARG(5, 3)); + after = IntegerOfTerm(EXTRA_CBACK_ARG(5, 4)); + sz = IntegerOfTerm(EXTRA_CBACK_ARG(5, 5)); if (mask & SUB_ATOM_HAS_UTF8) { sub_atom = FALSE; @@ -1759,96 +1702,104 @@ cont_sub_atomic( USES_REGS1 ) if (mask & SUB_ATOM_HAS_WIDE) { wp = RepAtom(at)->WStrOfAE; if (IsWideAtom(AtomOfTerm(nat))) { - while (!found) { - if (wcsncmp(wp+min, AtomOfTerm(nat)->WStrOfAE, len) == 0) { - Yap_unify(ARG2, MkIntegerTerm(min)); - Yap_unify(ARG3, MkIntegerTerm(len)); - Yap_unify(ARG4, MkIntegerTerm(after)); - found = TRUE; - /* found one, check if there is any left */ - while (min <= sz-len) { - after--; - min++; - if (wcsncmp(wp+min, AtomOfTerm(nat)->WStrOfAE, len) == 0) - break; - } - } else { - if (min == sz-len) break; - after--; - min++; - } - } + while (!found) { + if (wcsncmp(wp + min, AtomOfTerm(nat)->WStrOfAE, len) == 0) { + Yap_unify(ARG2, MkIntegerTerm(min)); + Yap_unify(ARG3, MkIntegerTerm(len)); + Yap_unify(ARG4, MkIntegerTerm(after)); + found = TRUE; + /* found one, check if there is any left */ + while (min <= sz - len) { + after--; + min++; + if (wcsncmp(wp + min, AtomOfTerm(nat)->WStrOfAE, len) == 0) + break; + } + } else { + if (min == sz - len) + break; + after--; + min++; + } + } } else { - while (!found) { - if (wcsstrcmp(wp+min, (char *)AtomOfTerm(nat)->StrOfAE, len) == 0) { - Yap_unify(ARG2, MkIntegerTerm(min)); - Yap_unify(ARG3, MkIntegerTerm(len)); - Yap_unify(ARG4, MkIntegerTerm(after)); - found = TRUE; - /* found one, check if there is any left */ - while (min <= sz-len) { - after--; - min++; - if (wcsstrcmp(wp+min, (char *)AtomOfTerm(nat)->StrOfAE, len) == 0) - break; - } - } else { - if (min == sz-len) break; - after--; - min++; - } - } - } + while (!found) { + if (wcsstrcmp(wp + min, (char *)AtomOfTerm(nat)->StrOfAE, len) == 0) { + Yap_unify(ARG2, MkIntegerTerm(min)); + Yap_unify(ARG3, MkIntegerTerm(len)); + Yap_unify(ARG4, MkIntegerTerm(after)); + found = TRUE; + /* found one, check if there is any left */ + while (min <= sz - len) { + after--; + min++; + if (wcsstrcmp(wp + min, (char *)AtomOfTerm(nat)->StrOfAE, len) == + 0) + break; + } + } else { + if (min == sz - len) + break; + after--; + min++; + } + } + } } else if (sub_atom) { p = RepAtom(at)->UStrOfAE; while (!found) { - if (strncmp((char *)p+min, (char *)AtomOfTerm(nat)->StrOfAE, len) == 0) { - Yap_unify(ARG2, MkIntegerTerm(min)); - Yap_unify(ARG3, MkIntegerTerm(len)); - Yap_unify(ARG4, MkIntegerTerm(after)); - found = TRUE; - /* found one, check if there is any left */ - while (min <= sz-len) { - after--; - min++; - if (strncmp((char *)p+min, (char *)AtomOfTerm(nat)->StrOfAE, len) == 0) - break; - } - } else { - if (min == sz-len) break; - after--; - min++; - } + if (strncmp((char *)p + min, (char *)AtomOfTerm(nat)->StrOfAE, len) == + 0) { + Yap_unify(ARG2, MkIntegerTerm(min)); + Yap_unify(ARG3, MkIntegerTerm(len)); + Yap_unify(ARG4, MkIntegerTerm(after)); + found = TRUE; + /* found one, check if there is any left */ + while (min <= sz - len) { + after--; + min++; + if (strncmp((char *)p + min, (char *)AtomOfTerm(nat)->StrOfAE, + len) == 0) + break; + } + } else { + if (min == sz - len) + break; + after--; + min++; + } } } else { - const unsigned char *p = UStringOfTerm( Deref(ARG1) ), *p1 = p; - const unsigned char *p5 = UStringOfTerm( Deref(ARG5) ); + const unsigned char *p = UStringOfTerm(Deref(ARG1)), *p1 = p; + const unsigned char *p5 = UStringOfTerm(Deref(ARG5)); while (!found) { - p = skip_utf8((unsigned char *)p1, min); + p = skip_utf8((unsigned char *)p1, min); if (cmpn_utf8(p, p5, len) == 0) { Yap_unify(ARG2, MkIntegerTerm(min)); Yap_unify(ARG3, MkIntegerTerm(len)); Yap_unify(ARG4, MkIntegerTerm(after)); found = TRUE; /* found one, check if there is any left */ - while (min <= sz-len) { - int chr; - p += get_utf8((unsigned char *)p, -1, &chr); + while (min <= sz - len) { + int chr; + p += get_utf8((unsigned char *)p, -1, &chr); after--; min++; if (cmpn_utf8(p, UStringOfTerm(nat), len) == 0) break; } } else { - if (min == sz-len) break; + if (min == sz - len) + break; after--; min++; } } } if (found) { - if (min > sz-len) cut_succeed(); + if (min > sz - len) + cut_succeed(); } else { cut_fail(); } @@ -1858,23 +1809,26 @@ cont_sub_atomic( USES_REGS1 ) Yap_unify(ARG4, MkIntegerTerm(after)); Yap_unify(ARG5, nat); min++; - if (after-- == 0) cut_succeed(); + if (after-- == 0) + cut_succeed(); } else if (mask & SUB_ATOM_HAS_MIN) { - after = sz-(min+len); + after = sz - (min + len); nat = build_new_atomic(mask, wp, p, min, len PASS_REGS); Yap_unify(ARG3, MkIntegerTerm(len)); Yap_unify(ARG4, MkIntegerTerm(after)); Yap_unify(ARG5, nat); len++; - if (after-- == 0) cut_succeed(); + if (after-- == 0) + cut_succeed(); } else if (mask & SUB_ATOM_HAS_AFTER) { - len = sz-(min+after); + len = sz - (min + after); nat = build_new_atomic(mask, wp, p, min, len PASS_REGS); Yap_unify(ARG2, MkIntegerTerm(min)); Yap_unify(ARG3, MkIntegerTerm(len)); Yap_unify(ARG5, nat); min++; - if (len-- == 0) cut_succeed(); + if (len-- == 0) + cut_succeed(); } else { nat = build_new_atomic(mask, wp, p, min, len PASS_REGS); Yap_unify(ARG2, MkIntegerTerm(min)); @@ -1883,23 +1837,22 @@ cont_sub_atomic( USES_REGS1 ) Yap_unify(ARG5, nat); len++; if (after-- == 0) { - if (min == sz) cut_succeed(); + if (min == sz) + cut_succeed(); min++; len = 0; - after = sz-min; + after = sz - min; } } - EXTRA_CBACK_ARG(5,1) = MkIntegerTerm(mask); - EXTRA_CBACK_ARG(5,2) = MkIntegerTerm(min); - EXTRA_CBACK_ARG(5,3) = MkIntegerTerm(len); - EXTRA_CBACK_ARG(5,4) = MkIntegerTerm(after); - EXTRA_CBACK_ARG(5,5) = MkIntegerTerm(sz); + EXTRA_CBACK_ARG(5, 1) = MkIntegerTerm(mask); + EXTRA_CBACK_ARG(5, 2) = MkIntegerTerm(min); + EXTRA_CBACK_ARG(5, 3) = MkIntegerTerm(len); + EXTRA_CBACK_ARG(5, 4) = MkIntegerTerm(after); + EXTRA_CBACK_ARG(5, 5) = MkIntegerTerm(sz); return TRUE; } -static Int -sub_atomic( int sub_atom USES_REGS ) -{ +static Int sub_atomic(int sub_atom USES_REGS) { Term tat1, tbef, tsize, tafter, tout; int mask = 0; size_t min, len, after, sz; @@ -1909,8 +1862,8 @@ sub_atomic( int sub_atom USES_REGS ) Term nat = 0L; Atom at = NULL; - tat1 = Deref(ARG1); - EXTRA_CBACK_ARG(5,3) = MkIntegerTerm(0); + tat1 = Deref(ARG1); + EXTRA_CBACK_ARG(5, 3) = MkIntegerTerm(0); if (IsVarTerm(tat1)) { Yap_Error(INSTANTIATION_ERROR, tat1, "sub_atom/5: first argument"); return FALSE; @@ -1921,7 +1874,7 @@ sub_atomic( int sub_atom USES_REGS ) Yap_Error(TYPE_ERROR_STRING, tat1, "sub_string/5"); return FALSE; } - tbef = Deref(ARG2); + tbef = Deref(ARG2); if (IsVarTerm(tbef)) { min = 0; } else if (!IsIntegerTerm(tbef)) { @@ -1929,10 +1882,10 @@ sub_atomic( int sub_atom USES_REGS ) return FALSE; } else { min = IntegerOfTerm(tbef); - if ((Int)min < 0) { - Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, tbef, "sub_string/5"); - return FALSE; - }; + if ((Int)min < 0) { + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, tbef, "sub_string/5"); + return FALSE; + }; mask |= SUB_ATOM_HAS_MIN; bnds++; } @@ -1943,10 +1896,10 @@ sub_atomic( int sub_atom USES_REGS ) return FALSE; } else { len = IntegerOfTerm(tsize); - if ((Int)len < 0) { - Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, tsize, "sub_string/5"); - return FALSE; - }; + if ((Int)len < 0) { + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, tsize, "sub_string/5"); + return FALSE; + }; mask |= SUB_ATOM_HAS_SIZE; bnds++; } @@ -1957,39 +1910,39 @@ sub_atomic( int sub_atom USES_REGS ) return FALSE; } else { after = IntegerOfTerm(tafter); - if ((Int)after < 0) { - Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, tafter, "sub_string/5"); - return FALSE; - }; + if ((Int)after < 0) { + Yap_Error(DOMAIN_ERROR_NOT_LESS_THAN_ZERO, tafter, "sub_string/5"); + return FALSE; + }; mask |= SUB_ATOM_HAS_AFTER; bnds++; } if (!IsVarTerm(tout = Deref(ARG5))) { if (sub_atom) { if (!IsAtomTerm(tout)) { - Yap_Error(TYPE_ERROR_ATOM, tout, "sub_atom/5"); - return FALSE; + Yap_Error(TYPE_ERROR_ATOM, tout, "sub_atom/5"); + return FALSE; } else { - Atom oat; - mask |= SUB_ATOM_HAS_VAL|SUB_ATOM_HAS_SIZE; - oat = AtomOfTerm(tout); - if (IsWideAtom(oat)) - len = wcslen(RepAtom(oat)->WStrOfAE); - else - len = strlen((const char *)RepAtom(oat)->StrOfAE); + Atom oat; + mask |= SUB_ATOM_HAS_VAL | SUB_ATOM_HAS_SIZE; + oat = AtomOfTerm(tout); + if (IsWideAtom(oat)) + len = wcslen(RepAtom(oat)->WStrOfAE); + else + len = strlen((const char *)RepAtom(oat)->StrOfAE); } } else { if (!IsStringTerm(tout)) { - Yap_Error(TYPE_ERROR_STRING, tout, "sub_string/5"); - return FALSE; + Yap_Error(TYPE_ERROR_STRING, tout, "sub_string/5"); + return FALSE; } else { - mask |= SUB_ATOM_HAS_VAL|SUB_ATOM_HAS_SIZE; - len = strlen_utf8( UStringOfTerm(tout) ); + mask |= SUB_ATOM_HAS_VAL | SUB_ATOM_HAS_SIZE; + len = strlen_utf8(UStringOfTerm(tout)); } } if (!Yap_unify(ARG3, MkIntegerTerm(len))) cut_fail(); - bnds+=2; + bnds += 2; } if (sub_atom) { at = AtomOfTerm(tat1); @@ -2002,96 +1955,105 @@ sub_atomic( int sub_atom USES_REGS ) sz = strlen((const char *)p); } } else { - mask |= SUB_ATOM_HAS_UTF8; - p = (unsigned char *)StringOfTerm(tat1); - sz = strlen_utf8(p); + mask |= SUB_ATOM_HAS_UTF8; + p = (unsigned char *)StringOfTerm(tat1); + sz = strlen_utf8(p); } /* the problem is deterministic if we have two cases */ if (bnds > 1) { int out = FALSE; - if ((mask & (SUB_ATOM_HAS_MIN|SUB_ATOM_HAS_SIZE)) == - (SUB_ATOM_HAS_MIN|SUB_ATOM_HAS_SIZE)) { - if (min+len > sz) cut_fail(); - if ((Int)(after = (sz-(min+len))) < 0) cut_fail(); + if ((mask & (SUB_ATOM_HAS_MIN | SUB_ATOM_HAS_SIZE)) == + (SUB_ATOM_HAS_MIN | SUB_ATOM_HAS_SIZE)) { + if (min + len > sz) + cut_fail(); + if ((Int)(after = (sz - (min + len))) < 0) + cut_fail(); nat = build_new_atomic(mask, wp, p, min, len PASS_REGS); - if (!nat) cut_fail(); - out = Yap_unify(ARG4,MkIntegerTerm(after)) && - Yap_unify(ARG5, nat); - } else if ((mask & (SUB_ATOM_HAS_MIN|SUB_ATOM_HAS_AFTER)) == - (SUB_ATOM_HAS_MIN|SUB_ATOM_HAS_AFTER)) { - if (sz < min+after) cut_fail(); - len = sz-(min+after); + if (!nat) + cut_fail(); + out = Yap_unify(ARG4, MkIntegerTerm(after)) && Yap_unify(ARG5, nat); + } else if ((mask & (SUB_ATOM_HAS_MIN | SUB_ATOM_HAS_AFTER)) == + (SUB_ATOM_HAS_MIN | SUB_ATOM_HAS_AFTER)) { + if (sz < min + after) + cut_fail(); + len = sz - (min + after); nat = build_new_atomic(mask, wp, p, min, len PASS_REGS); - if (!nat) cut_fail(); - out = Yap_unify(ARG3,MkIntegerTerm(len)) && - Yap_unify(ARG5, nat); - } else if ((mask & (SUB_ATOM_HAS_SIZE|SUB_ATOM_HAS_AFTER)) == - (SUB_ATOM_HAS_SIZE|SUB_ATOM_HAS_AFTER) ) { - if (len+after > sz) cut_fail(); - min = sz-(len+after); + if (!nat) + cut_fail(); + out = Yap_unify(ARG3, MkIntegerTerm(len)) && Yap_unify(ARG5, nat); + } else if ((mask & (SUB_ATOM_HAS_SIZE | SUB_ATOM_HAS_AFTER)) == + (SUB_ATOM_HAS_SIZE | SUB_ATOM_HAS_AFTER)) { + if (len + after > sz) + cut_fail(); + min = sz - (len + after); nat = build_new_atomic(mask, wp, p, min, len PASS_REGS); - if (!nat) cut_fail(); - out = Yap_unify(ARG2,MkIntegerTerm(min)) && - Yap_unify(ARG5, nat); - } else if ((mask & (SUB_ATOM_HAS_MIN|SUB_ATOM_HAS_VAL)) == - (SUB_ATOM_HAS_MIN|SUB_ATOM_HAS_VAL)) { + if (!nat) + cut_fail(); + out = Yap_unify(ARG2, MkIntegerTerm(min)) && Yap_unify(ARG5, nat); + } else if ((mask & (SUB_ATOM_HAS_MIN | SUB_ATOM_HAS_VAL)) == + (SUB_ATOM_HAS_MIN | SUB_ATOM_HAS_VAL)) { if (sub_atom) - out = check_sub_atom_at(min, at, AtomOfTerm(nat)); + out = check_sub_atom_at(min, at, AtomOfTerm(nat)); else - out = check_sub_string_at(min, p, UStringOfTerm( nat ), len); - } else if ((mask & (SUB_ATOM_HAS_AFTER|SUB_ATOM_HAS_VAL)) == - (SUB_ATOM_HAS_AFTER|SUB_ATOM_HAS_VAL)) { + out = check_sub_string_at(min, p, UStringOfTerm(nat), len); + } else if ((mask & (SUB_ATOM_HAS_AFTER | SUB_ATOM_HAS_VAL)) == + (SUB_ATOM_HAS_AFTER | SUB_ATOM_HAS_VAL)) { if (sub_atom) - out = check_sub_atom_bef(sz - after, at, AtomOfTerm(nat)); + out = check_sub_atom_bef(sz - after, at, AtomOfTerm(nat)); else - out = check_sub_string_bef(sz - after, tat1, tout); - } else if ((mask & (SUB_ATOM_HAS_SIZE|SUB_ATOM_HAS_VAL)) == - (SUB_ATOM_HAS_SIZE|SUB_ATOM_HAS_VAL)) { + out = check_sub_string_bef(sz - after, tat1, tout); + } else if ((mask & (SUB_ATOM_HAS_SIZE | SUB_ATOM_HAS_VAL)) == + (SUB_ATOM_HAS_SIZE | SUB_ATOM_HAS_VAL)) { if (!sub_atom) { - out = (strlen_utf8(UStringOfTerm(tout)) == len); - if (!out) cut_fail(); + out = (strlen_utf8(UStringOfTerm(tout)) == len); + if (!out) + cut_fail(); } else if (IsWideAtom(AtomOfTerm(tout))) { - if (!(mask & SUB_ATOM_HAS_VAL)) { - cut_fail(); - } - /* just check length, they may still be several occurrences :( */ - out = (wcslen(RepAtom(AtomOfTerm(tout))->WStrOfAE) == len); + if (!(mask & SUB_ATOM_HAS_VAL)) { + cut_fail(); + } + /* just check length, they may still be several occurrences :( */ + out = (wcslen(RepAtom(AtomOfTerm(tout))->WStrOfAE) == len); } else { - out = (strlen((const char *)RepAtom(AtomOfTerm(tout))->StrOfAE) == len); - if (!out) cut_fail(); + out = (strlen((const char *)RepAtom(AtomOfTerm(tout))->StrOfAE) == len); + if (!out) + cut_fail(); } if (len == sz) { - out = out && - Yap_unify(ARG1, ARG5) && - Yap_unify(ARG2, MkIntegerTerm(0)) && - Yap_unify(ARG4, MkIntegerTerm(0)); + out = out && Yap_unify(ARG1, ARG5) && + Yap_unify(ARG2, MkIntegerTerm(0)) && + Yap_unify(ARG4, MkIntegerTerm(0)); } else if (len > sz) { - cut_fail(); + cut_fail(); } else { - mask |= SUB_ATOM_HAS_SIZE; - min = 0; - after = sz-len; - goto backtrackable; + mask |= SUB_ATOM_HAS_SIZE; + min = 0; + after = sz - len; + goto backtrackable; } } - if (out) cut_succeed(); + if (out) + cut_succeed(); cut_fail(); } else { - if (!(mask & SUB_ATOM_HAS_MIN)) min = 0; - if (!(mask & SUB_ATOM_HAS_SIZE)) len = 0; - if (!(mask & SUB_ATOM_HAS_AFTER)) after = sz-(len+min); + if (!(mask & SUB_ATOM_HAS_MIN)) + min = 0; + if (!(mask & SUB_ATOM_HAS_SIZE)) + len = 0; + if (!(mask & SUB_ATOM_HAS_AFTER)) + after = sz - (len + min); } - backtrackable: - EXTRA_CBACK_ARG(5,1) = MkIntegerTerm(mask); - EXTRA_CBACK_ARG(5,2) = MkIntegerTerm(min); - EXTRA_CBACK_ARG(5,3) = MkIntegerTerm(len); - EXTRA_CBACK_ARG(5,4) = MkIntegerTerm(after); - EXTRA_CBACK_ARG(5,5) = MkIntegerTerm(sz); - return cont_sub_atomic( PASS_REGS1 ); +backtrackable: + EXTRA_CBACK_ARG(5, 1) = MkIntegerTerm(mask); + EXTRA_CBACK_ARG(5, 2) = MkIntegerTerm(min); + EXTRA_CBACK_ARG(5, 3) = MkIntegerTerm(len); + EXTRA_CBACK_ARG(5, 4) = MkIntegerTerm(after); + EXTRA_CBACK_ARG(5, 5) = MkIntegerTerm(sz); + return cont_sub_atomic(PASS_REGS1); } -/** @pred sub_atom(+ _A_,? _Bef_, ? _Size_, ? _After_, ? _At_out_) is iso +/** @pred sub_atom(+ _A_,? _Bef_, ? _Size_, ? _After_, ? _At_out_) is iso True when _A_ and _At_out_ are atoms such that the name of @@ -2103,18 +2065,14 @@ Note that _A_ must always be known, but _At_out_ can be unbound when calling this built-in. If all the arguments for sub_atom/5 but _A_ are unbound, the built-in will backtrack through all possible sub-strings of _A_. - + */ -static Int -sub_atom( USES_REGS1 ) -{ - return sub_atomic( TRUE PASS_REGS ); -} +static Int sub_atom(USES_REGS1) { return sub_atomic(TRUE PASS_REGS); } -/** @pred sub_string(+ _S_,? _Bef_, ? _Size_, ? _After_, ? _S_out_) is iso +/** @pred sub_string(+ _S_,? _Bef_, ? _Size_, ? _After_, ? _S_out_) is iso -True when _S_ and _S_out_ are strings such that the +True when _S_ and _S_out_ are strings such that the _S_out_ has size _Size_ and is a sub-string of _S_, _Bef_ is the number of characters before, and _After_ the number of characters afterwards. @@ -2123,27 +2081,21 @@ Note that _S_ must always be known, but _S_out_ can be unbound when calling this built-in. If all the arguments for sub_string/5 but _S_ are unbound, the built-in will generate all possible sub-strings of _S_. - - */ -static Int -sub_string( USES_REGS1 ) -{ - return sub_atomic( FALSE PASS_REGS ); -} -static Int -cont_current_atom( USES_REGS1 ) -{ - Atom catom; - Int i = IntOfTerm(EXTRA_CBACK_ARG(1,2)); - AtomEntry *ap; /* nasty hack for gcc on hpux */ + */ +static Int sub_string(USES_REGS1) { return sub_atomic(FALSE PASS_REGS); } + +static Int cont_current_atom(USES_REGS1) { + Atom catom; + Int i = IntOfTerm(EXTRA_CBACK_ARG(1, 2)); + AtomEntry *ap; /* nasty hack for gcc on hpux */ /* protect current hash table line */ - if (IsAtomTerm(EXTRA_CBACK_ARG(1,1))) - catom = AtomOfTerm(EXTRA_CBACK_ARG(1,1)); + if (IsAtomTerm(EXTRA_CBACK_ARG(1, 1))) + catom = AtomOfTerm(EXTRA_CBACK_ARG(1, 1)); else catom = NIL; - if (catom == NIL){ + if (catom == NIL) { i++; /* move away from current hash table line */ while (i < AtomHashTableSize) { @@ -2151,7 +2103,7 @@ cont_current_atom( USES_REGS1 ) catom = HashChain[i].Entry; READ_UNLOCK(HashChain[i].AERWLock); if (catom != NIL) { - break; + break; } i++; } @@ -2166,33 +2118,31 @@ cont_current_atom( USES_REGS1 ) READ_UNLOCK(ap->ARWLock); i++; while (i < AtomHashTableSize) { - READ_LOCK(HashChain[i].AERWLock); - catom = HashChain[i].Entry; - READ_UNLOCK(HashChain[i].AERWLock); - if (catom != NIL) { - break; - } - i++; + READ_LOCK(HashChain[i].AERWLock); + catom = HashChain[i].Entry; + READ_UNLOCK(HashChain[i].AERWLock); + if (catom != NIL) { + break; + } + i++; } if (i == AtomHashTableSize) { - cut_fail(); + cut_fail(); } else { - EXTRA_CBACK_ARG(1,1) = MkAtomTerm(catom); + EXTRA_CBACK_ARG(1, 1) = MkAtomTerm(catom); } } else { - EXTRA_CBACK_ARG(1,1) = MkAtomTerm(ap->NextOfAE); + EXTRA_CBACK_ARG(1, 1) = MkAtomTerm(ap->NextOfAE); READ_UNLOCK(ap->ARWLock); } - EXTRA_CBACK_ARG(1,2) = MkIntTerm(i); + EXTRA_CBACK_ARG(1, 2) = MkIntTerm(i); return TRUE; } else { return FALSE; } } -static Int -current_atom( USES_REGS1 ) -{ /* current_atom(?Atom) */ +static Int current_atom(USES_REGS1) { /* current_atom(?Atom) */ Term t1 = Deref(ARG1); if (!IsVarTerm(t1)) { if (IsAtomTerm(t1)) @@ -2202,29 +2152,26 @@ current_atom( USES_REGS1 ) } READ_LOCK(HashChain[0].AERWLock); if (HashChain[0].Entry != NIL) { - EXTRA_CBACK_ARG(1,1) = MkAtomTerm(HashChain[0].Entry); + EXTRA_CBACK_ARG(1, 1) = MkAtomTerm(HashChain[0].Entry); } else { - EXTRA_CBACK_ARG(1,1) = MkIntTerm(0); + EXTRA_CBACK_ARG(1, 1) = MkIntTerm(0); } READ_UNLOCK(HashChain[0].AERWLock); - EXTRA_CBACK_ARG(1,2) = MkIntTerm(0); - return (cont_current_atom( PASS_REGS1 )); + EXTRA_CBACK_ARG(1, 2) = MkIntTerm(0); + return (cont_current_atom(PASS_REGS1)); } - -static Int -cont_current_wide_atom( USES_REGS1 ) -{ - Atom catom; - Int i = IntOfTerm(EXTRA_CBACK_ARG(1,2)); - AtomEntry *ap; /* nasty hack for gcc on hpux */ +static Int cont_current_wide_atom(USES_REGS1) { + Atom catom; + Int i = IntOfTerm(EXTRA_CBACK_ARG(1, 2)); + AtomEntry *ap; /* nasty hack for gcc on hpux */ /* protect current hash table line */ - if (IsAtomTerm(EXTRA_CBACK_ARG(1,1))) - catom = AtomOfTerm(EXTRA_CBACK_ARG(1,1)); + if (IsAtomTerm(EXTRA_CBACK_ARG(1, 1))) + catom = AtomOfTerm(EXTRA_CBACK_ARG(1, 1)); else catom = NIL; - if (catom == NIL){ + if (catom == NIL) { i++; /* move away from current hash table line */ while (i < WideAtomHashTableSize) { @@ -2232,7 +2179,7 @@ cont_current_wide_atom( USES_REGS1 ) catom = WideHashChain[i].Entry; READ_UNLOCK(WideHashChain[i].AERWLock); if (catom != NIL) { - break; + break; } i++; } @@ -2247,33 +2194,32 @@ cont_current_wide_atom( USES_REGS1 ) READ_UNLOCK(ap->ARWLock); i++; while (i < WideAtomHashTableSize) { - READ_LOCK(WideHashChain[i].AERWLock); - catom = WideHashChain[i].Entry; - READ_UNLOCK(WideHashChain[i].AERWLock); - if (catom != NIL) { - break; - } - i++; + READ_LOCK(WideHashChain[i].AERWLock); + catom = WideHashChain[i].Entry; + READ_UNLOCK(WideHashChain[i].AERWLock); + if (catom != NIL) { + break; + } + i++; } if (i == WideAtomHashTableSize) { - cut_fail(); + cut_fail(); } else { - EXTRA_CBACK_ARG(1,1) = MkAtomTerm(catom); + EXTRA_CBACK_ARG(1, 1) = MkAtomTerm(catom); } } else { - EXTRA_CBACK_ARG(1,1) = MkAtomTerm(ap->NextOfAE); + EXTRA_CBACK_ARG(1, 1) = MkAtomTerm(ap->NextOfAE); READ_UNLOCK(ap->ARWLock); } - EXTRA_CBACK_ARG(1,2) = MkIntTerm(i); + EXTRA_CBACK_ARG(1, 2) = MkIntTerm(i); return TRUE; } else { return FALSE; } } -static Int -current_wide_atom( USES_REGS1 ) -{ /* current_atom(?Atom) */ +static Int current_wide_atom(USES_REGS1) { /* current_atom(?Atom) + */ Term t1 = Deref(ARG1); if (!IsVarTerm(t1)) { if (IsAtomTerm(t1)) @@ -2283,151 +2229,151 @@ current_wide_atom( USES_REGS1 ) } READ_LOCK(WideHashChain[0].AERWLock); if (WideHashChain[0].Entry != NIL) { - EXTRA_CBACK_ARG(1,1) = MkAtomTerm(WideHashChain[0].Entry); + EXTRA_CBACK_ARG(1, 1) = MkAtomTerm(WideHashChain[0].Entry); } else { - EXTRA_CBACK_ARG(1,1) = MkIntTerm(0); + EXTRA_CBACK_ARG(1, 1) = MkIntTerm(0); } READ_UNLOCK(WideHashChain[0].AERWLock); - EXTRA_CBACK_ARG(1,2) = MkIntTerm(0); - return (cont_current_wide_atom( PASS_REGS1 )); + EXTRA_CBACK_ARG(1, 2) = MkIntTerm(0); + return (cont_current_wide_atom(PASS_REGS1)); } -void -Yap_InitBackAtoms(void) -{ - Yap_InitCPredBack("$current_atom", 1, 2, current_atom, cont_current_atom,SafePredFlag|SyncPredFlag); - Yap_InitCPredBack("$current_wide_atom", 1, 2, current_wide_atom,cont_current_wide_atom,SafePredFlag|SyncPredFlag); +void Yap_InitBackAtoms(void) { + Yap_InitCPredBack("$current_atom", 1, 2, current_atom, cont_current_atom, + SafePredFlag | SyncPredFlag); + Yap_InitCPredBack("$current_wide_atom", 1, 2, current_wide_atom, + cont_current_wide_atom, SafePredFlag | SyncPredFlag); Yap_InitCPredBack("atom_concat", 3, 2, atom_concat3, cont_atom_concat3, 0); - Yap_InitCPredBack("atomic_concat", 3, 2, atomic_concat3, cont_atomic_concat3, 0); - Yap_InitCPredBack("string_concat", 3, 2, string_concat3, cont_string_concat3, 0); + Yap_InitCPredBack("atomic_concat", 3, 2, atomic_concat3, cont_atomic_concat3, + 0); + Yap_InitCPredBack("string_concat", 3, 2, string_concat3, cont_string_concat3, + 0); Yap_InitCPredBack("sub_atom", 5, 5, sub_atom, cont_sub_atomic, 0); Yap_InitCPredBack("sub_string", 5, 5, sub_string, cont_sub_atomic, 0); Yap_InitCPredBack("string_code", 3, 1, string_code3, cont_string_code3, 0); - } -void -Yap_InitAtomPreds(void) -{ +void Yap_InitAtomPreds(void) { Yap_InitCPred("name", 2, name, 0); -/** @pred name( _A_, _L_) + /** @pred name( _A_, _L_) -The predicate holds when at least one of the arguments is ground -(otherwise, an error message will be displayed). The argument _A_ will -be unified with an atomic symbol and _L_ with the list of the ASCII -codes for the characters of the external representation of _A_. + The predicate holds when at least one of the arguments is ground + (otherwise, an error message will be displayed). The argument _A_ will + be unified with an atomic symbol and _L_ with the list of the ASCII + codes for the characters of the external representation of _A_. -~~~~~{.prolog} - name(yap,L). -~~~~~ -will return: + ~~~~~{.prolog} + name(yap,L). + ~~~~~ + will return: -~~~~~{.prolog} - L = [121,97,112]. -~~~~~ -and + ~~~~~{.prolog} + L = [121,97,112]. + ~~~~~ + and -~~~~~{.prolog} - name(3,L). -~~~~~ -will return: + ~~~~~{.prolog} + name(3,L). + ~~~~~ + will return: -~~~~~{.prolog} - L = [51]. -~~~~~ + ~~~~~{.prolog} + L = [51]. + ~~~~~ - -*/ + + */ Yap_InitCPred("string_to_atom", 2, string_to_atom, 0); Yap_InitCPred("atom_string", 2, atom_string, 0); Yap_InitCPred("string_to_atomic", 2, string_to_atomic, 0); Yap_InitCPred("string_to_list", 2, string_to_list, 0); Yap_InitCPred("char_code", 2, char_code, SafePredFlag); -/** @pred char_code(? _A_,? _I_) is iso + /** @pred char_code(? _A_,? _I_) is iso -The built-in succeeds with _A_ bound to character represented as an -atom, and _I_ bound to the character code represented as an -integer. At least, one of either _A_ or _I_ must be bound before -the call. + The built-in succeeds with _A_ bound to character represented as an + atom, and _I_ bound to the character code represented as an + integer. At least, one of either _A_ or _I_ must be bound before + the call. - -*/ + + */ Yap_InitCPred("atom_chars", 2, atom_chars, 0); -/** @pred atom_chars(? _A_,? _L_) is iso + /** @pred atom_chars(? _A_,? _L_) is iso -The predicate holds when at least one of the arguments is ground -(otherwise, an error message will be displayed). The argument _A_ must -be unifiable with an atom, and the argument _L_ with the list of the -characters of _A_. + The predicate holds when at least one of the arguments is ground + (otherwise, an error message will be displayed). The argument _A_ must + be unifiable with an atom, and the argument _L_ with the list of the + characters of _A_. - -*/ + + */ Yap_InitCPred("atom_codes", 2, atom_codes, 0); Yap_InitCPred("string_codes", 2, string_codes, 0); Yap_InitCPred("string_chars", 2, string_chars, 0); Yap_InitCPred("atom_length", 2, atom_length, SafePredFlag); -/** @pred atom_length(+ _A_,? _I_) is iso + /** @pred atom_length(+ _A_,? _I_) is iso -The predicate holds when the first argument is an atom, and the second -unifies with the number of characters forming that atom. + The predicate holds when the first argument is an atom, and the second + unifies with the number of characters forming that atom. - -*/ + + */ Yap_InitCPred("atomic_length", 2, atomic_length, SafePredFlag); Yap_InitCPred("string_length", 2, string_length, SafePredFlag); Yap_InitCPred("$atom_split", 4, atom_split, SafePredFlag); Yap_InitCPred("number_chars", 2, number_chars, 0); Yap_InitCPred("number_atom", 2, number_atom, 0); -/** @pred number_atom(? _I_,? _L_) + /** @pred number_atom(? _I_,? _L_) -The predicate holds when at least one of the arguments is ground -(otherwise, an error message will be displayed). The argument _I_ must -be unifiable with a number, and the argument _L_ must be unifiable -with an atom representing the number. + The predicate holds when at least one of the arguments is ground + (otherwise, an error message will be displayed). The argument _I_ must + be unifiable with a number, and the argument _L_ must be unifiable + with an atom representing the number. - -*/ + + */ Yap_InitCPred("number_string", 2, number_string, 0); Yap_InitCPred("number_codes", 2, number_codes, 0); Yap_InitCPred("atom_number", 2, atom_number, 0); -/** @pred atom_number(? _Atom_,? _Number_) + /** @pred atom_number(? _Atom_,? _Number_) -The predicate holds when at least one of the arguments is ground -(otherwise, an error message will be displayed). If the argument - _Atom_ is an atom, _Number_ must be the number corresponding -to the characters in _Atom_, otherwise the characters in - _Atom_ must encode a number _Number_. + The predicate holds when at least one of the arguments is ground + (otherwise, an error message will be displayed). If the argument + _Atom_ is an atom, _Number_ must be the number corresponding + to the characters in _Atom_, otherwise the characters in + _Atom_ must encode a number _Number_. - -*/ + + */ Yap_InitCPred("string_number", 2, string_number, 0); Yap_InitCPred("$atom_concat", 2, atom_concat2, 0); Yap_InitCPred("$string_concat", 2, string_concat2, 0); Yap_InitCPred("atomic_concat", 2, atomic_concat2, 0); -/** @pred atomic_concat(+ _As_,? _A_) + /** @pred atomic_concat(+ _As_,? _A_) -The predicate holds when the first argument is a list of atomic terms, and -the second unifies with the atom obtained by concatenating all the -atomic terms in the first list. The first argument thus may contain -atoms or numbers. + The predicate holds when the first argument is a list of atomic terms, and + the second unifies with the atom obtained by concatenating all the + atomic terms in the first list. The first argument thus may contain + atoms or numbers. - -*/ + + */ Yap_InitCPred("atomics_to_string", 2, atomics_to_string2, 0); Yap_InitCPred("atomics_to_string", 3, atomics_to_string3, 0); Yap_InitCPred("get_string_code", 3, get_string_code3, 0); /* hiding and unhiding some predicates */ - Yap_InitCPred("hide_atom", 1, hide_atom, SafePredFlag|SyncPredFlag); - Yap_InitCPred("unhide_atom", 1, unhide_atom, SafePredFlag|SyncPredFlag); - Yap_InitCPred("$hidden_atom", 1, hidden_atom, HiddenPredFlag|SafePredFlag|SyncPredFlag); + Yap_InitCPred("hide_atom", 1, hide_atom, SafePredFlag | SyncPredFlag); + Yap_InitCPred("unhide_atom", 1, unhide_atom, SafePredFlag | SyncPredFlag); + Yap_InitCPred("$hidden_atom", 1, hidden_atom, + HiddenPredFlag | SafePredFlag | SyncPredFlag); } /**