diff --git a/.gitignore b/.gitignore index fcab32bfd..faccf25e8 100644 --- a/.gitignore +++ b/.gitignore @@ -12,6 +12,7 @@ *.dll docs/yap.info* .build +build tags TGSautom4te.cache cscope.* @@ -24,7 +25,6 @@ tmtags* .Rhistory .zedstate config.h -Yap.h YapConfig.h YapTermConfig.h .graffiti @@ -42,7 +42,6 @@ groups .cproject .dir-locals.el .DS_store -.kateproject .project .pydevproject .Rhistory @@ -150,7 +149,7 @@ yap-6.3.workspace yap-6.3.geany YAP.project CBlocks -yPQ +yPQ *.tmp YAP.sublime* yap32 @@ -215,4 +214,4 @@ cmake/cudd_config.h cmake/docs/Doxyfile *.stackdump -*.gz \ No newline at end of file +*.gz diff --git a/C/atomic.c b/C/atomic.c index 690afefd0..ea2aee3c0 100755 --- a/C/atomic.c +++ b/C/atomic.c @@ -268,12 +268,11 @@ static Int char_code(USES_REGS1) { Atom at = AtomOfTerm(t0); Term tf; unsigned char *c = RepAtom(at)->UStrOfAE; - int32_t v; - c += get_utf8(c, 1, &v); - if (c[0] != '\0') { - Yap_Error(TYPE_ERROR_CHARACTER, t0, "char_code/2"); - return FALSE; - } + int32_t v = IntegerOfTerm(ARG1); + + get_utf8(c, -1, &v); + if (!v) + return false; tf = MkIntTerm(v); return Yap_unify(ARG2, tf); } @@ -282,38 +281,38 @@ static Int char_code(USES_REGS1) { /** @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]. + ~~~~~ */ - static Int name(USES_REGS1) { /* name(?Atomic,?String) */ +static Int name(USES_REGS1) { /* name(?Atomic,?String) */ Term t2 = Deref(ARG2), NewT, t1 = Deref(ARG1); LOCAL_MAX_SIZE = 1024; int l = push_text_stack(); -restart_aux: + restart_aux: if (Yap_IsGroundTerm(t1)) { if (!IsVarTerm(t2) && !IsPairTerm(t2) && t2 != TermNil) { Yap_Error(TYPE_ERROR_LIST, ARG2, "name/2"); diff --git a/C/c_interface.c b/C/c_interface.c index 111a59e1e..92fb5d6ad 100755 --- a/C/c_interface.c +++ b/C/c_interface.c @@ -2239,276 +2239,275 @@ X_API int YAP_WriteDynamicBuffer(YAP_Term t, char *buf, size_t sze, char *b; BACKUP_MACHINE_REGS(); - b = Yap_TermToString(t, lengthp, enc, flags); - if (*lengthp >= sze) - *lengthp = sze; + b = Yap_TermToString(t, enc, flags); strncpy(buf, b, sze); + buf[sze] = 0; RECOVER_MACHINE_REGS(); return true; } X_API char *YAP_CompileClause(Term t) { - CACHE_REGS + CACHE_REGS yamop *codeaddr; - Term mod = CurrentModule; - Term tn = TermNil; + Term mod = CurrentModule; + Term tn = TermNil; - BACKUP_MACHINE_REGS(); + BACKUP_MACHINE_REGS(); - /* allow expansion during stack initialization */ - LOCAL_ErrorMessage = NULL; - ARG1 = t; - YAPEnterCriticalSection(); - codeaddr = Yap_cclause(t, 0, mod, t); - if (codeaddr != NULL) { - t = Deref(ARG1); /* just in case there was an heap overflow */ - if (!Yap_addclause(t, codeaddr, TermAssertz, mod, &tn)) { - YAPLeaveCriticalSection(); - return LOCAL_ErrorMessage; - } + /* allow expansion during stack initialization */ + LOCAL_ErrorMessage = NULL; + ARG1 = t; + YAPEnterCriticalSection(); + codeaddr = Yap_cclause(t, 0, mod, t); + if (codeaddr != NULL) { + t = Deref(ARG1); /* just in case there was an heap overflow */ + if (!Yap_addclause(t, codeaddr, TermAssertz, mod, &tn)) { + YAPLeaveCriticalSection(); + return LOCAL_ErrorMessage; } - YAPLeaveCriticalSection(); + } + YAPLeaveCriticalSection(); - if (Yap_get_signal(YAP_CDOVF_SIGNAL)) { - if (!Yap_locked_growheap(FALSE, 0, NULL)) { - Yap_Error(RESOURCE_ERROR_HEAP, TermNil, "YAP failed to grow heap: %s", - LOCAL_ErrorMessage); - } + if (Yap_get_signal(YAP_CDOVF_SIGNAL)) { + if (!Yap_locked_growheap(FALSE, 0, NULL)) { + Yap_Error(RESOURCE_ERROR_HEAP, TermNil, "YAP failed to grow heap: %s", + LOCAL_ErrorMessage); } - RECOVER_MACHINE_REGS(); - return (LOCAL_ErrorMessage); + } + RECOVER_MACHINE_REGS(); + return (LOCAL_ErrorMessage); } static int yap_lineno = 0; /* do initial boot by consulting the file boot.yap */ static void do_bootfile(const char *bootfilename USES_REGS) { - Term t; - int bootfile, osno; - Functor functor_query = Yap_MkFunctor(Yap_LookupAtom("?-"), 1); - Functor functor_command1 = Yap_MkFunctor(Yap_LookupAtom(":-"), 1); - char full[YAP_FILENAME_MAX + 1]; + Term t; + int bootfile, osno; + Functor functor_query = Yap_MkFunctor(Yap_LookupAtom("?-"), 1); + Functor functor_command1 = Yap_MkFunctor(Yap_LookupAtom(":-"), 1); + char full[YAP_FILENAME_MAX + 1]; - /* consult boot.pl */ - /* the consult mode does not matter here, really */ - bootfile = YAP_InitConsult(YAP_BOOT_MODE, bootfilename, full, &osno); - if (bootfile < 0) { - fprintf(stderr, "[ FATAL ERROR: could not open bootfile %s ]\n", - bootfilename); - exit(1); - } - do { - CACHE_REGS - YAP_Reset(YAP_FULL_RESET); + /* consult boot.pl */ + /* the consult mode does not matter here, really */ + bootfile = YAP_InitConsult(YAP_BOOT_MODE, bootfilename, full, &osno); + if (bootfile < 0) { + fprintf(stderr, "[ FATAL ERROR: could not open bootfile %s ]\n", + bootfilename); + exit(1); + } + do { + CACHE_REGS + YAP_Reset(YAP_FULL_RESET); Yap_StartSlots(); t = YAP_ReadClauseFromStream(bootfile); // Yap_DebugPlWriteln(t); if (t == 0) { - fprintf(stderr, - "[ SYNTAX ERROR: while parsing bootfile %s at line %d ]\n", - bootfilename, yap_lineno); + fprintf(stderr, + "[ SYNTAX ERROR: while parsing bootfile %s at line %d ]\n", + bootfilename, yap_lineno); } else if (YAP_IsVarTerm(t) || t == TermNil) { - fprintf(stderr, "[ line %d: term cannot be compiled ]", yap_lineno); + fprintf(stderr, "[ line %d: term cannot be compiled ]", yap_lineno); } else if (YAP_IsPairTerm(t)) { - fprintf(stderr, "[ SYSTEM ERROR: consult not allowed in boot file ]\n"); - fprintf(stderr, "error found at line %d and pos %d", yap_lineno, - fseek(GLOBAL_Stream[bootfile].file, 0L, SEEK_CUR)); + fprintf(stderr, "[ SYSTEM ERROR: consult not allowed in boot file ]\n"); + fprintf(stderr, "error found at line %d and pos %d", yap_lineno, + fseek(GLOBAL_Stream[bootfile].file, 0L, SEEK_CUR)); } else if (IsApplTerm(t) && (FunctorOfTerm(t) == functor_query || FunctorOfTerm(t) == functor_command1)) { - YAP_RunGoalOnce(ArgOfTerm(1, t)); + YAP_RunGoalOnce(ArgOfTerm(1, t)); } else { - Term ts[2]; - char *ErrorMessage; - Functor fun = Yap_MkFunctor(Yap_LookupAtom("$prepare_clause"), 2); - PredEntry *pe = RepPredProp(PredPropByFunc(fun, PROLOG_MODULE)); + Term ts[2]; + char *ErrorMessage; + Functor fun = Yap_MkFunctor(Yap_LookupAtom("$prepare_clause"), 2); + PredEntry *pe = RepPredProp(PredPropByFunc(fun, PROLOG_MODULE)); - if (pe->OpcodeOfPred != UNDEF_OPCODE && pe->OpcodeOfPred != FAIL_OPCODE) { - ts[0] = t; - RESET_VARIABLE(ts + 1); - if (YAP_RunGoal(Yap_MkApplTerm(fun, 2, ts))) - t = ts[1]; - } - ErrorMessage = YAP_CompileClause(t); - if (ErrorMessage) { - fprintf(stderr, "%s", ErrorMessage); - } + if (pe->OpcodeOfPred != UNDEF_OPCODE && pe->OpcodeOfPred != FAIL_OPCODE) { + ts[0] = t; + RESET_VARIABLE(ts + 1); + if (YAP_RunGoal(Yap_MkApplTerm(fun, 2, ts))) + t = ts[1]; + } + ErrorMessage = YAP_CompileClause(t); + if (ErrorMessage) { + fprintf(stderr, "%s", ErrorMessage); + } } - } while (t != TermEof); + } while (t != TermEof); - YAP_EndConsult(bootfile, &osno); + YAP_EndConsult(bootfile, &osno); #if DEBUG - if (Yap_output_msg) + if (Yap_output_msg) fprintf(stderr, "Boot loaded\n"); #endif -} + } -/** - YAP_DelayInit() + /** + YAP_DelayInit() - ensures initialization is done after engine creation. - It receives a pointer to function and a string describing - the module. + ensures initialization is done after engine creation. + It receives a pointer to function and a string describing + the module. */ -X_API bool YAP_initialized = false; -static int n_mdelays = 0; -static YAP_delaymodule_t *m_delays; + X_API bool YAP_initialized = false; + static int n_mdelays = 0; + static YAP_delaymodule_t *m_delays; -X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) { - if (m_delays) { + X_API bool YAP_DelayInit(YAP_ModInit_t f, const char s[]) { + if (m_delays) { m_delays = realloc(m_delays, (n_mdelays + 1) * sizeof(YAP_delaymodule_t)); - } else { + } else { m_delays = malloc(sizeof(YAP_delaymodule_t)); + } + m_delays[n_mdelays].f = f; + m_delays[n_mdelays].s = s; + n_mdelays++; + return true; } - m_delays[n_mdelays].f = f; - m_delays[n_mdelays].s = s; - n_mdelays++; - return true; -} -bool Yap_LateInit(const char s[]) { - int i; - for (i = 0; i < n_mdelays; i++) { + bool Yap_LateInit(const char s[]) { + int i; + for (i = 0; i < n_mdelays; i++) { if (!strcmp(m_delays[i].s, s)) { - m_delays[i].f(); - return true; + m_delays[i].f(); + return true; } + } + return false; } - return false; -} -static void start_modules(void) { - Term cm = CurrentModule; - size_t i; - for (i = 0; i < n_mdelays; i++) { + static void start_modules(void) { + Term cm = CurrentModule; + size_t i; + for (i = 0; i < n_mdelays; i++) { CurrentModule = MkAtomTerm(YAP_LookupAtom(m_delays[i].s)); m_delays[i].f(); + } + CurrentModule = cm; } - CurrentModule = cm; -} -/// whether Yap is under control of some other system -bool Yap_embedded = true; + /// whether Yap is under control of some other system + bool Yap_embedded = true; -/* this routine is supposed to be called from an external program - that wants to control Yap */ + /* this routine is supposed to be called from an external program + that wants to control Yap */ -X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) { - YAP_file_type_t restore_result = yap_init->boot_file_type; - bool do_bootstrap = (restore_result & YAP_CONSULT_MODE); - CELL Trail = 0, Stack = 0, Heap = 0, Atts = 0; - char boot_file[YAP_FILENAME_MAX + 1]; - Int rc; - const char *yroot; + X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) { + YAP_file_type_t restore_result = yap_init->boot_file_type; + bool do_bootstrap = (restore_result & YAP_CONSULT_MODE); + CELL Trail = 0, Stack = 0, Heap = 0, Atts = 0; + char boot_file[YAP_FILENAME_MAX + 1]; + Int rc; + const char *yroot; - /* ignore repeated calls to YAP_Init */ - if (YAP_initialized) + /* ignore repeated calls to YAP_Init */ + if (YAP_initialized) return YAP_FOUND_BOOT_ERROR; - Yap_embedded = yap_init->Embedded; - Yap_page_size = Yap_InitPageSize(); /* init memory page size, required by - later functions */ + Yap_embedded = yap_init->Embedded; + Yap_page_size = Yap_InitPageSize(); /* init memory page size, required by + later functions */ #if defined(YAPOR_COPY) || defined(YAPOR_COW) || defined(YAPOR_SBA) - Yap_init_yapor_global_local_memory(); + Yap_init_yapor_global_local_memory(); #endif /* YAPOR_COPY || YAPOR_COW || YAPOR_SBA */ - if (!yap_init->Embedded) { + if (!yap_init->Embedded) { GLOBAL_PrologShouldHandleInterrupts = ~yap_init->PrologCannotHandleInterrupts; Yap_InitSysbits(0); /* init signal handling and time, required by later - functions */ + functions */ GLOBAL_argv = yap_init->Argv; GLOBAL_argc = yap_init->Argc; if (0 && ((YAP_QLY && yap_init->SavedState) || (YAP_BOOT_PL && (yap_init->YapPrologBootFile)))) { - yroot = "."; + yroot = "."; } else { - yroot = BootFilePath; + yroot = BootFilePath; } - } - if (yap_init->SavedState == NULL) { + } + if (yap_init->SavedState == NULL) { yap_init->SavedState = YAP_STARTUP; - } + } #if USE_DL_MALLOC - if (yap_init->SavedState == NULL) - yap_init->SavedState = YAP_STARTUP; + if (yap_init->SavedState == NULL) + yap_init->SavedState = YAP_STARTUP; #else - yap_init->SavedState = Yap_findFile(yap_init->SavedState, YAP_STARTUP, yap_init->YapLibDir, - boot_file, true, YAP_QLY, true, true); + yap_init->SavedState = Yap_findFile(yap_init->SavedState, YAP_STARTUP, yap_init->YapLibDir, + boot_file, true, YAP_QLY, true, true); #endif - if (yap_init->SavedState == NULL) { + if (yap_init->SavedState == NULL) { restore_result = YAP_BOOT_PL; - } + } - if (restore_result == YAP_BOOT_PL) { + if (restore_result == YAP_BOOT_PL) { #if USE_DL_MALLOC if (yap_init->YapPrologBootFile == NULL) yap_init->YapPrologBootFile = BootFile; #else yap_init->YapPrologBootFile = - Yap_findFile(yap_init->YapPrologBootFile, BootFile, yroot, boot_file, - true, YAP_BOOT_PL, true, true); + Yap_findFile(yap_init->YapPrologBootFile, BootFile, yroot, boot_file, + true, YAP_BOOT_PL, true, true); #endif - } + } - if (yap_init->TrailSize == 0) { + if (yap_init->TrailSize == 0) { if (Trail == 0) - Trail = DefTrailSpace; - } else { + Trail = DefTrailSpace; + } else { Trail = yap_init->TrailSize; - } - // Atts = yap_init->AttsSize; - if (yap_init->StackSize == 0) { + } + // Atts = yap_init->AttsSize; + if (yap_init->StackSize == 0) { Stack = DefStackSpace; - } else { + } else { Stack = yap_init->StackSize; - } + } #ifndef USE_SYSTEM_MALLOC - if (yap_init->HeapSize == 0) { - if (Heap == 0) - Heap = DefHeapSpace; - } else { - Heap = yap_init->HeapSize; - } + if (yap_init->HeapSize == 0) { + if (Heap == 0) + Heap = DefHeapSpace; + } else { + Heap = yap_init->HeapSize; + } #endif - Yap_InitWorkspace(yap_init, Heap, Stack, Trail, Atts, yap_init->MaxTableSpaceSize, - yap_init->NumberWorkers, yap_init->SchedulerLoop, - yap_init->DelayedReleaseLoad); - // + Yap_InitWorkspace(yap_init, Heap, Stack, Trail, Atts, yap_init->MaxTableSpaceSize, + yap_init->NumberWorkers, yap_init->SchedulerLoop, + yap_init->DelayedReleaseLoad); + // - CACHE_REGS - if (Yap_embedded) - if (yap_init->QuietMode) { + CACHE_REGS + if (Yap_embedded) + if (yap_init->QuietMode) { setVerbosity(TermSilent); - } - { + } + { if (yap_init->YapPrologRCFile != NULL) { - /* - This must be done before restore, otherwise - restore will print out messages .... - */ - setBooleanGlobalPrologFlag(HALT_AFTER_CONSULT_FLAG, - yap_init->HaltAfterConsult); + /* + This must be done before restore, otherwise + restore will print out messages .... + */ + setBooleanGlobalPrologFlag(HALT_AFTER_CONSULT_FLAG, + yap_init->HaltAfterConsult); } /* tell the system who should cope with interrupts */ Yap_ExecutionMode = yap_init->ExecutionMode; if (do_bootstrap) { - restore_result |= YAP_BOOT_PL; + restore_result |= YAP_BOOT_PL; } else { // try always to boot from the saved state. - if (restore_result == YAP_QLY) { - if (!Yap_SavedInfo(yap_init->SavedState, yap_init->YapLibDir, &Trail, - &Stack, &Heap)) { - restore_result = YAP_BOOT_PL; - } else { - restore_result = - Yap_Restore(yap_init->SavedState, yap_init->YapLibDir); - } - if (restore_result == YAP_FOUND_BOOT_ERROR) { - restore_result = YAP_BOOT_PL; - } - } + if (restore_result == YAP_QLY) { + if (!Yap_SavedInfo(yap_init->SavedState, yap_init->YapLibDir, &Trail, + &Stack, &Heap)) { + restore_result = YAP_BOOT_PL; + } else { + restore_result = + Yap_Restore(yap_init->SavedState, yap_init->YapLibDir); + } + if (restore_result == YAP_FOUND_BOOT_ERROR) { + restore_result = YAP_BOOT_PL; + } + } } GLOBAL_FAST_BOOT_FLAG = yap_init->FastBoot; #if defined(YAPOR) || defined(TABLING) @@ -2519,98 +2518,98 @@ X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) { #if YAPOR_THREADS if (Yap_thread_self() != 0) { #else - if (worker_id != 0) { + if (worker_id != 0) { #endif #if defined(YAPOR_COPY) || defined(YAPOR_SBA) - /* - In the SBA we cannot just happily inherit registers - from the other workers - */ - Yap_InitYaamRegs(worker_id); + /* + In the SBA we cannot just happily inherit registers + from the other workers + */ + Yap_InitYaamRegs(worker_id); #endif /* YAPOR_COPY || YAPOR_SBA */ #ifndef YAPOR_THREADS - Yap_InitPreAllocCodeSpace(0); + Yap_InitPreAllocCodeSpace(0); #endif /* YAPOR_THREADS */ - /* slaves, waiting for work */ - CurrentModule = USER_MODULE; - P = GETWORK_FIRST_TIME; - Yap_exec_absmi(FALSE, YAP_EXEC_ABSMI); - Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, - "abstract machine unexpected exit (YAP_Init)"); - } + /* slaves, waiting for work */ + CurrentModule = USER_MODULE; + P = GETWORK_FIRST_TIME; + Yap_exec_absmi(FALSE, YAP_EXEC_ABSMI); + Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, + "abstract machine unexpected exit (YAP_Init)"); + } #endif /* YAPOR */ - RECOVER_MACHINE_REGS(); - } - /* make sure we do this after restore */ - if (yap_init->MaxStackSize) { - GLOBAL_AllowLocalExpansion = FALSE; - } else { - GLOBAL_AllowLocalExpansion = TRUE; - } - if (yap_init->MaxGlobalSize) { - GLOBAL_AllowGlobalExpansion = FALSE; - } else { - GLOBAL_AllowGlobalExpansion = TRUE; - } - if (yap_init->MaxTrailSize) { - GLOBAL_AllowTrailExpansion = FALSE; - } else { - GLOBAL_AllowTrailExpansion = TRUE; - } - if (yap_init->YapPrologRCFile) { - Yap_PutValue(AtomConsultOnBoot, - MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologRCFile))); - /* - This must be done again after restore, as yap_flags - has been overwritten .... - */ - setBooleanGlobalPrologFlag(HALT_AFTER_CONSULT_FLAG, - yap_init->HaltAfterConsult); - } - if (yap_init->YapPrologTopLevelGoal) { - Yap_PutValue(AtomTopLevelGoal, - MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologTopLevelGoal))); - } - if (yap_init->YapPrologGoal) { - Yap_PutValue(AtomInitGoal, - MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologGoal))); - } - if (yap_init->YapPrologAddPath) { - Yap_PutValue(AtomExtendFileSearchPath, - MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologAddPath))); - } - if (yap_init->YapShareDir) { - setAtomicGlobalPrologFlag(PROLOG_LIBRARY_DIRECTORY_FLAG, - MkAtomTerm(Yap_LookupAtom(yap_init->YapShareDir))); - } - if (yap_init->YapLibDir) { - setAtomicGlobalPrologFlag(PROLOG_FOREIGN_DIRECTORY_FLAG, - MkAtomTerm(Yap_LookupAtom(yap_init->YapLibDir))); - } - if (yap_init->QuietMode) { - setVerbosity(TermSilent); - } - if (restore_result == YAP_QLY) { - setAtomicGlobalPrologFlag(RESOURCE_DATABASE_FLAG, - MkAtomTerm(Yap_LookupAtom(yap_init->SavedState))); - LOCAL_PrologMode &= ~BootMode; - CurrentModule = LOCAL_SourceModule = USER_MODULE; - setBooleanGlobalPrologFlag(SAVED_PROGRAM_FLAG, true); - rc = YAP_QLY; - } else { - if (!yap_init->YapPrologBootFile) + RECOVER_MACHINE_REGS(); + } + /* make sure we do this after restore */ + if (yap_init->MaxStackSize) { + GLOBAL_AllowLocalExpansion = FALSE; + } else { + GLOBAL_AllowLocalExpansion = TRUE; + } + if (yap_init->MaxGlobalSize) { + GLOBAL_AllowGlobalExpansion = FALSE; + } else { + GLOBAL_AllowGlobalExpansion = TRUE; + } + if (yap_init->MaxTrailSize) { + GLOBAL_AllowTrailExpansion = FALSE; + } else { + GLOBAL_AllowTrailExpansion = TRUE; + } + if (yap_init->YapPrologRCFile) { + Yap_PutValue(AtomConsultOnBoot, + MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologRCFile))); + /* + This must be done again after restore, as yap_flags + has been overwritten .... + */ + setBooleanGlobalPrologFlag(HALT_AFTER_CONSULT_FLAG, + yap_init->HaltAfterConsult); + } + if (yap_init->YapPrologTopLevelGoal) { + Yap_PutValue(AtomTopLevelGoal, + MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologTopLevelGoal))); + } + if (yap_init->YapPrologGoal) { + Yap_PutValue(AtomInitGoal, + MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologGoal))); + } + if (yap_init->YapPrologAddPath) { + Yap_PutValue(AtomExtendFileSearchPath, + MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologAddPath))); + } + if (yap_init->YapShareDir) { + setAtomicGlobalPrologFlag(PROLOG_LIBRARY_DIRECTORY_FLAG, + MkAtomTerm(Yap_LookupAtom(yap_init->YapShareDir))); + } + if (yap_init->YapLibDir) { + setAtomicGlobalPrologFlag(PROLOG_FOREIGN_DIRECTORY_FLAG, + MkAtomTerm(Yap_LookupAtom(yap_init->YapLibDir))); + } + if (yap_init->QuietMode) { + setVerbosity(TermSilent); + } + if (restore_result == YAP_QLY) { + setAtomicGlobalPrologFlag(RESOURCE_DATABASE_FLAG, + MkAtomTerm(Yap_LookupAtom(yap_init->SavedState))); + LOCAL_PrologMode &= ~BootMode; + CurrentModule = LOCAL_SourceModule = USER_MODULE; + setBooleanGlobalPrologFlag(SAVED_PROGRAM_FLAG, true); + rc = YAP_QLY; + } else { + if (!yap_init->YapPrologBootFile) yap_init->YapPrologBootFile = BootFile; - rc = YAP_BOOT_PL; - do_bootfile(yap_init->YapPrologBootFile); - setAtomicGlobalPrologFlag( - RESOURCE_DATABASE_FLAG, - MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologBootFile))); - setBooleanGlobalPrologFlag(SAVED_PROGRAM_FLAG, false); - } - start_modules(); - YAP_initialized = true; - return rc; -} + rc = YAP_BOOT_PL; + do_bootfile(yap_init->YapPrologBootFile); + setAtomicGlobalPrologFlag( + RESOURCE_DATABASE_FLAG, + MkAtomTerm(Yap_LookupAtom(yap_init->YapPrologBootFile))); + setBooleanGlobalPrologFlag(SAVED_PROGRAM_FLAG, false); + } + start_modules(); + YAP_initialized = true; + return rc; + } #if (DefTrailSpace < MinTrailSpace) #undef DefTrailSpace @@ -2631,858 +2630,858 @@ X_API YAP_file_type_t YAP_Init(YAP_init_args *yap_init) { #define DEFAULT_SCHEDULERLOOP 10 #define DEFAULT_DELAYEDRELEASELOAD 3 -X_API YAP_file_type_t YAP_FastInit(char saved_state[], int argc, char *argv[]) { - YAP_init_args init_args; - YAP_file_type_t out; + X_API YAP_file_type_t YAP_FastInit(char saved_state[], int argc, char *argv[]) { + YAP_init_args init_args; + YAP_file_type_t out; - if ((out = Yap_InitDefaults(&init_args, saved_state, argc, argv)) != - YAP_FOUND_BOOT_ERROR) - out = YAP_Init(&init_args); - if (out == YAP_FOUND_BOOT_ERROR) { - Yap_Error(init_args.ErrorNo, TermNil, init_args.ErrorCause); - } - return out; -} + if ((out = Yap_InitDefaults(&init_args, saved_state, argc, argv)) != + YAP_FOUND_BOOT_ERROR) + out = YAP_Init(&init_args); + if (out == YAP_FOUND_BOOT_ERROR) { + Yap_Error(init_args.ErrorNo, TermNil, init_args.ErrorCause); + } + return out; + } -X_API void YAP_PutValue(Atom at, Term t) { Yap_PutValue(at, t); } + X_API void YAP_PutValue(Atom at, Term t) { Yap_PutValue(at, t); } -X_API Term YAP_GetValue(Atom at) { return (Yap_GetValue(at)); } + X_API Term YAP_GetValue(Atom at) { return (Yap_GetValue(at)); } -X_API int YAP_CompareTerms(Term t1, Term t2) { - return Yap_compare_terms(t1, t2); -} + X_API int YAP_CompareTerms(Term t1, Term t2) { + return Yap_compare_terms(t1, t2); + } -X_API int YAP_Reset(yap_reset_t mode) { - int res = TRUE; - BACKUP_MACHINE_REGS(); - res = Yap_Reset(mode); - RECOVER_MACHINE_REGS(); - return res; -} + X_API int YAP_Reset(yap_reset_t mode) { + int res = TRUE; + BACKUP_MACHINE_REGS(); + res = Yap_Reset(mode); + RECOVER_MACHINE_REGS(); + return res; + } -X_API void YAP_Exit(int retval) { Yap_exit(retval); } + X_API void YAP_Exit(int retval) { Yap_exit(retval); } -X_API int YAP_InitSocks(const char *host, long port) { return 0; } + X_API int YAP_InitSocks(const char *host, long port) { return 0; } -X_API void YAP_SetOutputMessage(void) { + X_API void YAP_SetOutputMessage(void) { #if DEBUG - Yap_output_msg = TRUE; + Yap_output_msg = TRUE; #endif -} + } -X_API int YAP_StreamToFileNo(Term t) { return (Yap_StreamToFileNo(t)); } + X_API int YAP_StreamToFileNo(Term t) { return (Yap_StreamToFileNo(t)); } -X_API void YAP_CloseAllOpenStreams(void) { - BACKUP_H(); + X_API void YAP_CloseAllOpenStreams(void) { + BACKUP_H(); - Yap_CloseStreams(FALSE); + Yap_CloseStreams(FALSE); - RECOVER_H(); -} + RECOVER_H(); + } -X_API void YAP_FlushAllStreams(void) { - BACKUP_H(); + X_API void YAP_FlushAllStreams(void) { + BACKUP_H(); - // VSC?? Yap_FlushStreams(); + // VSC?? Yap_FlushStreams(); - RECOVER_H(); -} + RECOVER_H(); + } -X_API void YAP_Throw(Term t) { - BACKUP_MACHINE_REGS(); - Yap_JumpToEnv(t); - RECOVER_MACHINE_REGS(); -} + X_API void YAP_Throw(Term t) { + BACKUP_MACHINE_REGS(); + Yap_JumpToEnv(t); + RECOVER_MACHINE_REGS(); + } -X_API void YAP_AsyncThrow(Term t) { - CACHE_REGS - BACKUP_MACHINE_REGS(); - LOCAL_PrologMode |= AsyncIntMode; - Yap_JumpToEnv(t); - LOCAL_PrologMode &= ~AsyncIntMode; - RECOVER_MACHINE_REGS(); -} + X_API void YAP_AsyncThrow(Term t) { + CACHE_REGS + BACKUP_MACHINE_REGS(); + LOCAL_PrologMode |= AsyncIntMode; + Yap_JumpToEnv(t); + LOCAL_PrologMode &= ~AsyncIntMode; + RECOVER_MACHINE_REGS(); + } -X_API void YAP_Halt(int i) { Yap_exit(i); } + X_API void YAP_Halt(int i) { Yap_exit(i); } -X_API CELL *YAP_TopOfLocalStack(void) { - CACHE_REGS - return (ASP); -} + X_API CELL *YAP_TopOfLocalStack(void) { + CACHE_REGS + return (ASP); + } -X_API void *YAP_Predicate(Atom a, UInt arity, Term m) { - if (arity == 0) { - return ((void *) RepPredProp(PredPropByAtom(a, m))); - } else { - Functor f = Yap_MkFunctor(a, arity); - return ((void *) RepPredProp(PredPropByFunc(f, m))); - } -} + X_API void *YAP_Predicate(Atom a, UInt arity, Term m) { + if (arity == 0) { + return ((void *) RepPredProp(PredPropByAtom(a, m))); + } else { + Functor f = Yap_MkFunctor(a, arity); + return ((void *) RepPredProp(PredPropByFunc(f, m))); + } + } -X_API void YAP_PredicateInfo(void *p, Atom *a, UInt *arity, Term *m) { - PredEntry *pd = (PredEntry *) p; - if (pd->ArityOfPE) { - *arity = pd->ArityOfPE; - *a = NameOfFunctor(pd->FunctorOfPred); - } else { - *arity = 0; - *a = (Atom) (pd->FunctorOfPred); - } - if (pd->ModuleOfPred) - *m = pd->ModuleOfPred; - else - *m = TermProlog; -} + X_API void YAP_PredicateInfo(void *p, Atom *a, UInt *arity, Term *m) { + PredEntry *pd = (PredEntry *) p; + if (pd->ArityOfPE) { + *arity = pd->ArityOfPE; + *a = NameOfFunctor(pd->FunctorOfPred); + } else { + *arity = 0; + *a = (Atom) (pd->FunctorOfPred); + } + if (pd->ModuleOfPred) + *m = pd->ModuleOfPred; + else + *m = TermProlog; + } -X_API void YAP_UserCPredicate(const char *name, CPredicate def, arity_t arity) { - Yap_InitCPred(name, arity, def, UserCPredFlag); -} + X_API void YAP_UserCPredicate(const char *name, CPredicate def, arity_t arity) { + Yap_InitCPred(name, arity, def, UserCPredFlag); + } -X_API void YAP_UserBackCPredicate_(const char *name, CPredicate init, - CPredicate cont, arity_t arity, - arity_t extra) { - Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag); -} + X_API void YAP_UserBackCPredicate_(const char *name, CPredicate init, + CPredicate cont, arity_t arity, + arity_t extra) { + Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag); + } -X_API void YAP_UserBackCutCPredicate(const char *name, CPredicate init, - CPredicate cont, CPredicate cut, - arity_t arity, arity_t extra) { - Yap_InitCPredBackCut(name, arity, extra, init, cont, cut, UserCPredFlag); -} + X_API void YAP_UserBackCutCPredicate(const char *name, CPredicate init, + CPredicate cont, CPredicate cut, + arity_t arity, arity_t extra) { + Yap_InitCPredBackCut(name, arity, extra, init, cont, cut, UserCPredFlag); + } -X_API void YAP_UserBackCPredicate(const char *name, CPredicate init, - CPredicate cont, arity_t arity, - arity_t extra) { - Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag); -} + X_API void YAP_UserBackCPredicate(const char *name, CPredicate init, + CPredicate cont, arity_t arity, + arity_t extra) { + Yap_InitCPredBackCut(name, arity, extra, init, cont, NULL, UserCPredFlag); + } -X_API void YAP_UserCPredicateWithArgs(const char *a, CPredicate f, - arity_t arity, Term mod) { - CACHE_REGS - PredEntry *pe; - Term cm = CurrentModule; - CurrentModule = mod; - YAP_UserCPredicate(a, f, arity); - if (arity == 0) { - pe = RepPredProp(PredPropByAtom(Yap_LookupAtom(a), mod)); - } else { - Functor f = Yap_MkFunctor(Yap_LookupAtom(a), arity); - pe = RepPredProp(PredPropByFunc(f, mod)); - } - pe->PredFlags |= CArgsPredFlag; - CurrentModule = cm; -} + X_API void YAP_UserCPredicateWithArgs(const char *a, CPredicate f, + arity_t arity, Term mod) { + CACHE_REGS + PredEntry *pe; + Term cm = CurrentModule; + CurrentModule = mod; + YAP_UserCPredicate(a, f, arity); + if (arity == 0) { + pe = RepPredProp(PredPropByAtom(Yap_LookupAtom(a), mod)); + } else { + Functor f = Yap_MkFunctor(Yap_LookupAtom(a), arity); + pe = RepPredProp(PredPropByFunc(f, mod)); + } + pe->PredFlags |= CArgsPredFlag; + CurrentModule = cm; + } -X_API Term YAP_CurrentModule(void) { - CACHE_REGS - return (CurrentModule); -} + X_API Term YAP_CurrentModule(void) { + CACHE_REGS + return (CurrentModule); + } -X_API Term YAP_SetCurrentModule(Term new) { - CACHE_REGS - Term omod = CurrentModule; - LOCAL_SourceModule = CurrentModule = new; - return omod; -} + X_API Term YAP_SetCurrentModule(Term new) { + CACHE_REGS + Term omod = CurrentModule; + LOCAL_SourceModule = CurrentModule = new; + return omod; + } -X_API Term YAP_CreateModule(Atom at) { - Term t; - WRITE_LOCK(RepAtom(at)->ARWLock); - t = Yap_Module(MkAtomTerm(at)); - WRITE_UNLOCK(RepAtom(at)->ARWLock); - return t; -} + X_API Term YAP_CreateModule(Atom at) { + Term t; + WRITE_LOCK(RepAtom(at)->ARWLock); + t = Yap_Module(MkAtomTerm(at)); + WRITE_UNLOCK(RepAtom(at)->ARWLock); + return t; + } -X_API Term YAP_StripModule(Term t, Term *modp) { - return Yap_StripModule(t, modp); -} + X_API Term YAP_StripModule(Term t, Term *modp) { + return Yap_StripModule(t, modp); + } -X_API int YAP_ThreadSelf(void) { + X_API int YAP_ThreadSelf(void) { #if THREADS - return Yap_thread_self(); + return Yap_thread_self(); #else - return -2; + return -2; #endif -} + } -X_API int YAP_ThreadCreateEngine(struct YAP_thread_attr_struct *attr) { + X_API int YAP_ThreadCreateEngine(struct YAP_thread_attr_struct *attr) { #if THREADS - return Yap_thread_create_engine(attr); + return Yap_thread_create_engine(attr); #else - return -1; + return -1; #endif -} + } -X_API int YAP_ThreadAttachEngine(int wid) { + X_API int YAP_ThreadAttachEngine(int wid) { #if THREADS - return Yap_thread_attach_engine(wid); + return Yap_thread_attach_engine(wid); #else - return FALSE; + return FALSE; #endif -} + } -X_API int YAP_ThreadDetachEngine(int wid) { + X_API int YAP_ThreadDetachEngine(int wid) { #if THREADS - return Yap_thread_detach_engine(wid); + return Yap_thread_detach_engine(wid); #else - return FALSE; + return FALSE; #endif -} + } -X_API int YAP_ThreadDestroyEngine(int wid) { + X_API int YAP_ThreadDestroyEngine(int wid) { #if THREADS - return Yap_thread_destroy_engine(wid); + return Yap_thread_destroy_engine(wid); #else - return FALSE; + return FALSE; #endif -} + } -X_API Term YAP_TermNil(void) { return TermNil; } + X_API Term YAP_TermNil(void) { return TermNil; } -X_API int YAP_IsTermNil(Term t) { return t == TermNil; } + X_API int YAP_IsTermNil(Term t) { return t == TermNil; } -X_API int YAP_AtomGetHold(Atom at) { return Yap_AtomIncreaseHold(at); } + X_API int YAP_AtomGetHold(Atom at) { return Yap_AtomIncreaseHold(at); } -X_API int YAP_AtomReleaseHold(Atom at) { return Yap_AtomDecreaseHold(at); } + X_API int YAP_AtomReleaseHold(Atom at) { return Yap_AtomDecreaseHold(at); } -X_API Agc_hook YAP_AGCRegisterHook(Agc_hook hook) { - Agc_hook old = GLOBAL_AGCHook; - GLOBAL_AGCHook = hook; - return old; -} + X_API Agc_hook YAP_AGCRegisterHook(Agc_hook hook) { + Agc_hook old = GLOBAL_AGCHook; + GLOBAL_AGCHook = hook; + return old; + } -X_API int YAP_HaltRegisterHook(HaltHookFunc hook, void *closure) { - return Yap_HaltRegisterHook(hook, closure); -} + X_API int YAP_HaltRegisterHook(HaltHookFunc hook, void *closure) { + return Yap_HaltRegisterHook(hook, closure); + } -X_API char *YAP_cwd(void) { - CACHE_REGS - char *buf = NULL; - int len; - if (!Yap_getcwd(LOCAL_FileNameBuf, YAP_FILENAME_MAX)) - return FALSE; - len = strlen(LOCAL_FileNameBuf); - buf = Yap_AllocCodeSpace(len + 1); - if (!buf) - return NULL; - strncpy(buf, LOCAL_FileNameBuf, len); - return buf; -} + X_API char *YAP_cwd(void) { + CACHE_REGS + char *buf = NULL; + int len; + if (!Yap_getcwd(LOCAL_FileNameBuf, YAP_FILENAME_MAX)) + return FALSE; + len = strlen(LOCAL_FileNameBuf); + buf = Yap_AllocCodeSpace(len + 1); + if (!buf) + return NULL; + strncpy(buf, LOCAL_FileNameBuf, len); + return buf; + } -X_API Term YAP_FloatsToList(double *dblp, size_t sz) { - CACHE_REGS - Term t; - CELL *oldH; - BACKUP_H(); + X_API Term YAP_FloatsToList(double *dblp, size_t sz) { + CACHE_REGS + Term t; + CELL *oldH; + BACKUP_H(); - if (!sz) - return TermNil; - while (ASP - 1024 < HR + sz * (2 + 2 + SIZEOF_DOUBLE / SIZEOF_INT_P)) { - if ((CELL *) dblp > H0 && (CELL *) dblp < HR) { + if (!sz) + return TermNil; + while (ASP - 1024 < HR + sz * (2 + 2 + SIZEOF_DOUBLE / SIZEOF_INT_P)) { + if ((CELL *) dblp > H0 && (CELL *) dblp < HR) { /* we are in trouble */ LOCAL_OpenArray = (CELL *) dblp; - } - if (!Yap_dogc(0, NULL PASS_REGS)) { + } + if (!Yap_dogc(0, NULL PASS_REGS)) { RECOVER_H(); return 0L; - } - dblp = (double *) LOCAL_OpenArray; - LOCAL_OpenArray = NULL; - } - t = AbsPair(HR); - while (sz) { - oldH = HR; - HR += 2; - oldH[0] = MkFloatTerm(*dblp++); - oldH[1] = AbsPair(HR); - sz--; - } - oldH[1] = TermNil; - RECOVER_H(); - return t; -} + } + dblp = (double *) LOCAL_OpenArray; + LOCAL_OpenArray = NULL; + } + t = AbsPair(HR); + while (sz) { + oldH = HR; + HR += 2; + oldH[0] = MkFloatTerm(*dblp++); + oldH[1] = AbsPair(HR); + sz--; + } + oldH[1] = TermNil; + RECOVER_H(); + return t; + } -X_API Int YAP_ListToFloats(Term t, double *dblp, size_t sz) { - size_t i = 0; + X_API Int YAP_ListToFloats(Term t, double *dblp, size_t sz) { + size_t i = 0; - t = Deref(t); - do { - Term hd; - if (IsVarTerm(t)) + t = Deref(t); + do { + Term hd; + if (IsVarTerm(t)) return -1; - if (t == TermNil) + if (t == TermNil) return i; - if (!IsPairTerm(t)) + if (!IsPairTerm(t)) return -1; - hd = HeadOfTerm(t); - if (IsFloatTerm(hd)) { + hd = HeadOfTerm(t); + if (IsFloatTerm(hd)) { dblp[i++] = FloatOfTerm(hd); - } else { + } else { extern double Yap_gmp_to_float(Term hd); if (IsIntTerm(hd)) - dblp[i++] = IntOfTerm(hd); + dblp[i++] = IntOfTerm(hd); else if (IsLongIntTerm(hd)) - dblp[i++] = LongIntOfTerm(hd); + dblp[i++] = LongIntOfTerm(hd); #if USE_GMP else if (IsBigIntTerm(hd)) - dblp[i++] = Yap_gmp_to_float(hd); + dblp[i++] = Yap_gmp_to_float(hd); #endif else - return -1; - } - if (i == sz) + return -1; + } + if (i == sz) return sz; - t = TailOfTerm(t); - } while (TRUE); -} + t = TailOfTerm(t); + } while (TRUE); + } -X_API Term YAP_IntsToList(Int *dblp, size_t sz) { - CACHE_REGS - Term t; - CELL *oldH; - BACKUP_H(); + X_API Term YAP_IntsToList(Int *dblp, size_t sz) { + CACHE_REGS + Term t; + CELL *oldH; + BACKUP_H(); - if (!sz) - return TermNil; - while (ASP - 1024 < HR + sz * 3) { - if ((CELL *) dblp > H0 && (CELL *) dblp < HR) { + if (!sz) + return TermNil; + while (ASP - 1024 < HR + sz * 3) { + if ((CELL *) dblp > H0 && (CELL *) dblp < HR) { /* we are in trouble */ LOCAL_OpenArray = (CELL *) dblp; - } - if (!Yap_dogc(0, NULL PASS_REGS)) { + } + if (!Yap_dogc(0, NULL PASS_REGS)) { RECOVER_H(); return 0L; - } - dblp = (Int *) LOCAL_OpenArray; - LOCAL_OpenArray = NULL; - } - t = AbsPair(HR); - while (sz) { - oldH = HR; - HR += 2; - oldH[0] = MkIntegerTerm(*dblp++); - oldH[1] = AbsPair(HR); - sz--; - } - oldH[1] = TermNil; - RECOVER_H(); - return t; -} + } + dblp = (Int *) LOCAL_OpenArray; + LOCAL_OpenArray = NULL; + } + t = AbsPair(HR); + while (sz) { + oldH = HR; + HR += 2; + oldH[0] = MkIntegerTerm(*dblp++); + oldH[1] = AbsPair(HR); + sz--; + } + oldH[1] = TermNil; + RECOVER_H(); + return t; + } -X_API Int YAP_ListToInts(Term t, Int *dblp, size_t sz) { - size_t i = 0; + X_API Int YAP_ListToInts(Term t, Int *dblp, size_t sz) { + size_t i = 0; - t = Deref(t); - do { - Term hd; - if (IsVarTerm(t)) + t = Deref(t); + do { + Term hd; + if (IsVarTerm(t)) return -1; - if (t == TermNil) + if (t == TermNil) return i; - if (!IsPairTerm(t)) + if (!IsPairTerm(t)) return -1; - hd = HeadOfTerm(t); - if (!IsIntTerm(hd)) + hd = HeadOfTerm(t); + if (!IsIntTerm(hd)) return -1; - dblp[i++] = IntOfTerm(hd); - if (i == sz) + dblp[i++] = IntOfTerm(hd); + if (i == sz) return sz; - t = TailOfTerm(t); - } while (TRUE); -} + t = TailOfTerm(t); + } while (TRUE); + } -X_API Term YAP_OpenList(int n) { - CACHE_REGS - Term t; - BACKUP_H(); + X_API Term YAP_OpenList(int n) { + CACHE_REGS + Term t; + BACKUP_H(); - while (HR + 2 * n > ASP - 1024) { - if (!Yap_dogc(0, NULL PASS_REGS)) { + while (HR + 2 * n > ASP - 1024) { + if (!Yap_dogc(0, NULL PASS_REGS)) { RECOVER_H(); return FALSE; - } - } - t = AbsPair(HR); - HR += 2 * n; + } + } + t = AbsPair(HR); + HR += 2 * n; - RECOVER_H(); - return t; -} + RECOVER_H(); + return t; + } -X_API Term YAP_ExtendList(Term t0, Term inp) { - Term t; - CELL *ptr = RepPair(t0); - BACKUP_H(); + X_API Term YAP_ExtendList(Term t0, Term inp) { + Term t; + CELL *ptr = RepPair(t0); + BACKUP_H(); - ptr[0] = inp; - ptr[1] = AbsPair(ptr + 2); - t = AbsPair(ptr + 2); + ptr[0] = inp; + ptr[1] = AbsPair(ptr + 2); + t = AbsPair(ptr + 2); - RECOVER_H(); - return t; -} + RECOVER_H(); + return t; + } -X_API int YAP_CloseList(Term t0, Term tail) { - CELL *ptr = RepPair(t0); + X_API int YAP_CloseList(Term t0, Term tail) { + CELL *ptr = RepPair(t0); - RESET_VARIABLE(ptr - 1); - if (!Yap_unify((Term) (ptr - 1), tail)) - return FALSE; - return TRUE; -} + RESET_VARIABLE(ptr - 1); + if (!Yap_unify((Term) (ptr - 1), tail)) + return FALSE; + return TRUE; + } -X_API int YAP_IsAttVar(Term t) { - CACHE_REGS - t = Deref(t); - if (!IsVarTerm(t)) - return FALSE; - return IsAttVar(VarOfTerm(t)); -} + X_API int YAP_IsAttVar(Term t) { + CACHE_REGS + t = Deref(t); + if (!IsVarTerm(t)) + return FALSE; + return IsAttVar(VarOfTerm(t)); + } -X_API Term YAP_AttsOfVar(Term t) { - CACHE_REGS - attvar_record *attv; + X_API Term YAP_AttsOfVar(Term t) { + CACHE_REGS + attvar_record *attv; - t = Deref(t); - if (!IsVarTerm(t)) - return TermNil; - if (!IsAttVar(VarOfTerm(t))) - return TermNil; - attv = RepAttVar(VarOfTerm(t)); - return attv->Atts; -} + t = Deref(t); + if (!IsVarTerm(t)) + return TermNil; + if (!IsAttVar(VarOfTerm(t))) + return TermNil; + attv = RepAttVar(VarOfTerm(t)); + return attv->Atts; + } -X_API int YAP_FileNoFromStream(Term t) { + X_API int YAP_FileNoFromStream(Term t) { - t = Deref(t); - if (IsVarTerm(t)) - return -1; - return Yap_StreamToFileNo(t); -} + t = Deref(t); + if (IsVarTerm(t)) + return -1; + return Yap_StreamToFileNo(t); + } -X_API void *YAP_FileDescriptorFromStream(Term t) { + X_API void *YAP_FileDescriptorFromStream(Term t) { - t = Deref(t); - if (IsVarTerm(t)) - return NULL; - return Yap_FileDescriptorFromStream(t); -} + t = Deref(t); + if (IsVarTerm(t)) + return NULL; + return Yap_FileDescriptorFromStream(t); + } -X_API void *YAP_Record(Term t) { - DBTerm *dbterm; - DBRecordList *dbt; + X_API void *YAP_Record(Term t) { + DBTerm *dbterm; + DBRecordList *dbt; - dbterm = Yap_StoreTermInDB(Deref(t), 0); - if (dbterm == NULL) - return NULL; - dbt = (struct record_list *) Yap_AllocCodeSpace(sizeof(struct record_list)); - while (dbt == NULL) { - if (!Yap_growheap(FALSE, sizeof(struct record_list), NULL)) { + dbterm = Yap_StoreTermInDB(Deref(t), 0); + if (dbterm == NULL) + return NULL; + dbt = (struct record_list *) Yap_AllocCodeSpace(sizeof(struct record_list)); + while (dbt == NULL) { + if (!Yap_growheap(FALSE, sizeof(struct record_list), NULL)) { /* be a good neighbor */ Yap_FreeCodeSpace((void *) dbterm); Yap_Error(RESOURCE_ERROR_HEAP, TermNil, "using YAP_Record"); return NULL; - } - } - if (Yap_Records) { - Yap_Records->prev_rec = dbt; - } - dbt->next_rec = Yap_Records; - dbt->prev_rec = NULL; - dbt->dbrecord = dbterm; - Yap_Records = dbt; - return dbt; -} + } + } + if (Yap_Records) { + Yap_Records->prev_rec = dbt; + } + dbt->next_rec = Yap_Records; + dbt->prev_rec = NULL; + dbt->dbrecord = dbterm; + Yap_Records = dbt; + return dbt; + } -X_API Term YAP_Recorded(void *handle) { - CACHE_REGS - Term t; - DBTerm *dbterm = ((DBRecordList *) handle)->dbrecord; + X_API Term YAP_Recorded(void *handle) { + CACHE_REGS + Term t; + DBTerm *dbterm = ((DBRecordList *) handle)->dbrecord; - BACKUP_MACHINE_REGS(); - do { - LOCAL_Error_TYPE = YAP_NO_ERROR; - t = Yap_FetchTermFromDB(dbterm); - if (LOCAL_Error_TYPE == YAP_NO_ERROR) { + BACKUP_MACHINE_REGS(); + do { + LOCAL_Error_TYPE = YAP_NO_ERROR; + t = Yap_FetchTermFromDB(dbterm); + if (LOCAL_Error_TYPE == YAP_NO_ERROR) { RECOVER_MACHINE_REGS(); return t; - } else if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) { + } else if (LOCAL_Error_TYPE == RESOURCE_ERROR_ATTRIBUTED_VARIABLES) { LOCAL_Error_TYPE = YAP_NO_ERROR; if (!Yap_growglobal(NULL)) { - Yap_Error(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, TermNil, - LOCAL_ErrorMessage); - RECOVER_MACHINE_REGS(); - return FALSE; + Yap_Error(RESOURCE_ERROR_ATTRIBUTED_VARIABLES, TermNil, + LOCAL_ErrorMessage); + RECOVER_MACHINE_REGS(); + return FALSE; } - } else { + } else { LOCAL_Error_TYPE = YAP_NO_ERROR; if (!Yap_growstack(dbterm->NOfCells * CellSize)) { - Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage); - RECOVER_MACHINE_REGS(); - return FALSE; + Yap_Error(RESOURCE_ERROR_STACK, TermNil, LOCAL_ErrorMessage); + RECOVER_MACHINE_REGS(); + return FALSE; } - } - } while (t == (CELL) 0); - RECOVER_MACHINE_REGS(); - return t; -} + } + } while (t == (CELL) 0); + RECOVER_MACHINE_REGS(); + return t; + } -X_API int YAP_Erase(void *handle) { - DBRecordList *dbr = (DBRecordList *) handle; - if (dbr->next_rec) - dbr->next_rec->prev_rec = dbr->prev_rec; - if (dbr->prev_rec) - dbr->prev_rec->next_rec = dbr->next_rec; - else if (Yap_Records == dbr) { - Yap_Records = dbr->next_rec; - } - Yap_ReleaseTermFromDB(dbr->dbrecord); - Yap_FreeCodeSpace(handle); - return 1; -} + X_API int YAP_Erase(void *handle) { + DBRecordList *dbr = (DBRecordList *) handle; + if (dbr->next_rec) + dbr->next_rec->prev_rec = dbr->prev_rec; + if (dbr->prev_rec) + dbr->prev_rec->next_rec = dbr->next_rec; + else if (Yap_Records == dbr) { + Yap_Records = dbr->next_rec; + } + Yap_ReleaseTermFromDB(dbr->dbrecord); + Yap_FreeCodeSpace(handle); + return 1; + } -X_API yhandle_t YAP_ArgsToSlots(int n) { - CACHE_REGS - return Yap_NewSlots(n); -} + X_API yhandle_t YAP_ArgsToSlots(int n) { + CACHE_REGS + return Yap_NewSlots(n); + } -X_API void YAP_SlotsToArgs(int n, yhandle_t slot) { - CACHE_REGS - CELL *ptr0 = Yap_AddressFromSlot(slot), *ptr1 = &ARG1; - while (n--) { - *ptr1++ = *ptr0++; - } -} + X_API void YAP_SlotsToArgs(int n, yhandle_t slot) { + CACHE_REGS + CELL *ptr0 = Yap_AddressFromSlot(slot), *ptr1 = &ARG1; + while (n--) { + *ptr1++ = *ptr0++; + } + } -X_API void YAP_signal(int sig) { Yap_signal(sig); } + X_API void YAP_signal(int sig) { Yap_signal(sig); } -X_API int YAP_SetYAPFlag(Term flag, Term val) { return setYapFlag(flag, val); } + X_API int YAP_SetYAPFlag(Term flag, Term val) { return setYapFlag(flag, val); } -/* yhandle_t YAP_VarSlotToNumber(yhandle_t) */ -X_API yhandle_t YAP_VarSlotToNumber(yhandle_t s) { - CACHE_REGS - Term *t = (CELL *) Deref(Yap_GetFromSlot(s)); - if (t < HR) - return t - H0; - return t - LCL0; -} + /* yhandle_t YAP_VarSlotToNumber(yhandle_t) */ + X_API yhandle_t YAP_VarSlotToNumber(yhandle_t s) { + CACHE_REGS + Term *t = (CELL *) Deref(Yap_GetFromSlot(s)); + if (t < HR) + return t - H0; + return t - LCL0; + } -/* Term YAP_ModuleUser() */ -X_API Term YAP_ModuleUser(void) { return MkAtomTerm(AtomUser); } + /* Term YAP_ModuleUser() */ + X_API Term YAP_ModuleUser(void) { return MkAtomTerm(AtomUser); } -/* int YAP_PredicateHasClauses() */ -X_API yhandle_t YAP_NumberOfClausesForPredicate(PredEntry *pe) { - return pe->cs.p_code.NOfClauses; -} + /* int YAP_PredicateHasClauses() */ + X_API yhandle_t YAP_NumberOfClausesForPredicate(PredEntry *pe) { + return pe->cs.p_code.NOfClauses; + } -X_API int YAP_MaxOpPriority(Atom at, Term module) { - AtomEntry *ae = RepAtom(at); - OpEntry *info; - WRITE_LOCK(ae->ARWLock); - info = Yap_GetOpPropForAModuleHavingALock(ae, module); - if (!info) { - WRITE_UNLOCK(ae->ARWLock); - return 0; - } - int ret = info->Prefix; - if (info->Infix > ret) - ret = info->Infix; - if (info->Posfix > ret) - ret = info->Posfix; - WRITE_UNLOCK(ae->ARWLock); - return ret; -} + X_API int YAP_MaxOpPriority(Atom at, Term module) { + AtomEntry *ae = RepAtom(at); + OpEntry *info; + WRITE_LOCK(ae->ARWLock); + info = Yap_GetOpPropForAModuleHavingALock(ae, module); + if (!info) { + WRITE_UNLOCK(ae->ARWLock); + return 0; + } + int ret = info->Prefix; + if (info->Infix > ret) + ret = info->Infix; + if (info->Posfix > ret) + ret = info->Posfix; + WRITE_UNLOCK(ae->ARWLock); + return ret; + } -X_API int YAP_OpInfo(Atom at, Term module, int opkind, int *yap_type, int *prio) { - AtomEntry *ae = RepAtom(at); - OpEntry *info; - int n; + X_API int YAP_OpInfo(Atom at, Term module, int opkind, int *yap_type, int *prio) { + AtomEntry *ae = RepAtom(at); + OpEntry *info; + int n; - WRITE_LOCK(ae->ARWLock); - info = Yap_GetOpPropForAModuleHavingALock(ae, module); - if (!info) { - /* try system operators */ - info = Yap_GetOpPropForAModuleHavingALock(ae, PROLOG_MODULE); - if (!info) { + WRITE_LOCK(ae->ARWLock); + info = Yap_GetOpPropForAModuleHavingALock(ae, module); + if (!info) { + /* try system operators */ + info = Yap_GetOpPropForAModuleHavingALock(ae, PROLOG_MODULE); + if (!info) { WRITE_UNLOCK(ae->ARWLock); return 0; - } - } - if (opkind == PREFIX_OP) { - SMALLUNSGN p = info->Prefix; - if (!p) { + } + } + if (opkind == PREFIX_OP) { + SMALLUNSGN p = info->Prefix; + if (!p) { WRITE_UNLOCK(ae->ARWLock); return FALSE; - } - if (p & DcrrpFlag) { + } + if (p & DcrrpFlag) { n = 6; *prio = (p ^ DcrrpFlag); - } else { + } else { n = 7; *prio = p; - } - } else if (opkind == INFIX_OP) { - SMALLUNSGN p = info->Infix; - if (!p) { + } + } else if (opkind == INFIX_OP) { + SMALLUNSGN p = info->Infix; + if (!p) { WRITE_UNLOCK(ae->ARWLock); return FALSE; - } - if ((p & DcrrpFlag) && (p & DcrlpFlag)) { + } + if ((p & DcrrpFlag) && (p & DcrlpFlag)) { n = 1; *prio = (p ^ (DcrrpFlag | DcrlpFlag)); - } else if (p & DcrrpFlag) { + } else if (p & DcrrpFlag) { n = 3; *prio = (p ^ DcrrpFlag); - } else if (p & DcrlpFlag) { + } else if (p & DcrlpFlag) { n = 2; *prio = (p ^ DcrlpFlag); - } else { + } else { n = 4; *prio = p; - } - } else { - SMALLUNSGN p = info->Posfix; - if (p & DcrlpFlag) { + } + } else { + SMALLUNSGN p = info->Posfix; + if (p & DcrlpFlag) { n = 4; *prio = (p ^ DcrlpFlag); - } else { + } else { n = 5; *prio = p; - } - } - *yap_type = n; - WRITE_UNLOCK(ae->ARWLock); - return 1; -} + } + } + *yap_type = n; + WRITE_UNLOCK(ae->ARWLock); + return 1; + } -X_API int YAP_Argv(char ***argvp) { - if (argvp) { - *argvp = GLOBAL_argv; - } - return GLOBAL_argc; -} + X_API int YAP_Argv(char ***argvp) { + if (argvp) { + *argvp = GLOBAL_argv; + } + return GLOBAL_argc; + } -X_API YAP_tag_t YAP_TagOfTerm(Term t) { - if (IsVarTerm(t)) { - CELL *pt = VarOfTerm(t); - if (IsUnboundVar(pt)) { + X_API YAP_tag_t YAP_TagOfTerm(Term t) { + if (IsVarTerm(t)) { + CELL *pt = VarOfTerm(t); + if (IsUnboundVar(pt)) { CACHE_REGS - if (IsAttVar(pt)) + if (IsAttVar(pt)) return YAP_TAG_ATT; return YAP_TAG_UNBOUND; - } - return YAP_TAG_REF; - } - if (IsPairTerm(t)) - return YAP_TAG_PAIR; - if (IsAtomOrIntTerm(t)) { - if (IsAtomTerm(t)) + } + return YAP_TAG_REF; + } + if (IsPairTerm(t)) + return YAP_TAG_PAIR; + if (IsAtomOrIntTerm(t)) { + if (IsAtomTerm(t)) return YAP_TAG_ATOM; - return YAP_TAG_INT; - } else { - Functor f = FunctorOfTerm(t); + return YAP_TAG_INT; + } else { + Functor f = FunctorOfTerm(t); - if (IsExtensionFunctor(f)) { + if (IsExtensionFunctor(f)) { if (f == FunctorDBRef) { - return YAP_TAG_DBREF; + return YAP_TAG_DBREF; } if (f == FunctorLongInt) { - return YAP_TAG_LONG_INT; + return YAP_TAG_LONG_INT; } if (f == FunctorBigInt) { - big_blob_type bt = RepAppl(t)[1]; - switch (bt) { - case BIG_INT: - return YAP_TAG_BIG_INT; - case BIG_RATIONAL: - return YAP_TAG_RATIONAL; - default: - return YAP_TAG_OPAQUE; - } + big_blob_type bt = RepAppl(t)[1]; + switch (bt) { + case BIG_INT: + return YAP_TAG_BIG_INT; + case BIG_RATIONAL: + return YAP_TAG_RATIONAL; + default: + return YAP_TAG_OPAQUE; + } } - } - return YAP_TAG_APPL; - } -} + } + return YAP_TAG_APPL; + } + } -int YAP_BPROLOG_exception; -Term YAP_BPROLOG_curr_toam_status; + int YAP_BPROLOG_exception; + Term YAP_BPROLOG_curr_toam_status; -/** - * Output the number of bytes needed to represent a string in UTF-8 - * Note that the terminating zero is not included. No error checking - * is performed (the programmer should have that done). - * - * @param t a list of codes, chars, string or atom. - * - * @return a positive number with the size, or 0. - */ -X_API size_t YAP_UTF8_TextLength(Term t) { - utf8proc_uint8_t dst[8]; - size_t sz = 0; + /** + * Output the number of bytes needed to represent a string in UTF-8 + * Note that the terminating zero is not included. No error checking + * is performed (the programmer should have that done). + * + * @param t a list of codes, chars, string or atom. + * + * @return a positive number with the size, or 0. + */ + X_API size_t YAP_UTF8_TextLength(Term t) { + utf8proc_uint8_t dst[8]; + size_t sz = 0; - if (IsPairTerm(t)) { - while (t != TermNil) { + if (IsPairTerm(t)) { + while (t != TermNil) { int c; Term hd = HeadOfTerm(t); if (IsAtomTerm(hd)) { - Atom at = AtomOfTerm(hd); - unsigned char *s = RepAtom(at)->UStrOfAE; - int32_t ch; - get_utf8(s, 1, &ch); - c = ch; + Atom at = AtomOfTerm(hd); + unsigned char *s = RepAtom(at)->UStrOfAE; + int32_t ch; + get_utf8(s, 1, &ch); + c = ch; } else if (IsIntegerTerm(hd)) { - c = IntegerOfTerm(hd); + c = IntegerOfTerm(hd); } else { - c = '\0'; + c = '\0'; } sz += utf8proc_encode_char(c, dst); t = TailOfTerm(t); - } - } else if (IsAtomTerm(t)) { - Atom at = AtomOfTerm(t); - char *s = RepAtom(at)->StrOfAE; - sz = strlen(s); - } else if (IsStringTerm(t)) { - sz = strlen(StringOfTerm(t)); - } - return sz; -} + } + } else if (IsAtomTerm(t)) { + Atom at = AtomOfTerm(t); + char *s = RepAtom(at)->StrOfAE; + sz = strlen(s); + } else if (IsStringTerm(t)) { + sz = strlen(StringOfTerm(t)); + } + return sz; + } -X_API Int YAP_ListLength(Term t) { - Term *aux; + X_API Int YAP_ListLength(Term t) { + Term *aux; - Int n = Yap_SkipList(&t, &aux); - if (IsVarTerm(*aux)) - return -1; - if (*aux == TermNil) - return n; - return -1; -} + Int n = Yap_SkipList(&t, &aux); + if (IsVarTerm(*aux)) + return -1; + if (*aux == TermNil) + return n; + return -1; + } -X_API Int YAP_NumberVars(Term t, Int nbv) { return Yap_NumberVars(t, nbv, FALSE); } + X_API Int YAP_NumberVars(Term t, Int nbv) { return Yap_NumberVars(t, nbv, FALSE); } -X_API Term YAP_UnNumberVars(Term t) { - /* don't allow sharing of ground terms */ - return Yap_UnNumberTerm(t, FALSE); -} + X_API Term YAP_UnNumberVars(Term t) { + /* don't allow sharing of ground terms */ + return Yap_UnNumberTerm(t, FALSE); + } -X_API int YAP_IsNumberedVariable(Term t) { - return IsApplTerm(t) && FunctorOfTerm(t) == FunctorDollarVar && - IsIntegerTerm(ArgOfTerm(1, t)); -} + X_API int YAP_IsNumberedVariable(Term t) { + return IsApplTerm(t) && FunctorOfTerm(t) == FunctorDollarVar && + IsIntegerTerm(ArgOfTerm(1, t)); + } -X_API size_t YAP_ExportTerm(Term inp, char *buf, size_t len) { - if (!len) - return 0; - return Yap_ExportTerm(inp, buf, len, current_arity()); -} + X_API size_t YAP_ExportTerm(Term inp, char *buf, size_t len) { + if (!len) + return 0; + return Yap_ExportTerm(inp, buf, len, current_arity()); + } -X_API size_t YAP_SizeOfExportedTerm(char *buf) { - if (!buf) - return 0; - return Yap_SizeOfExportedTerm(buf); -} + X_API size_t YAP_SizeOfExportedTerm(char *buf) { + if (!buf) + return 0; + return Yap_SizeOfExportedTerm(buf); + } -X_API Term YAP_ImportTerm(char *buf) { return Yap_ImportTerm(buf); } + X_API Term YAP_ImportTerm(char *buf) { return Yap_ImportTerm(buf); } -X_API int YAP_RequiresExtraStack(size_t sz) { - CACHE_REGS + X_API int YAP_RequiresExtraStack(size_t sz) { + CACHE_REGS - if (sz < 16 * 1024) - sz = 16 * 1024; - if (HR <= ASP - sz) { - return FALSE; - } - BACKUP_H(); - while (HR > ASP - sz) { - CACHE_REGS - RECOVER_H(); - if (!Yap_dogc(0, NULL PASS_REGS)) { + if (sz < 16 * 1024) + sz = 16 * 1024; + if (HR <= ASP - sz) { + return FALSE; + } + BACKUP_H(); + while (HR > ASP - sz) { + CACHE_REGS + RECOVER_H(); + if (!Yap_dogc(0, NULL PASS_REGS)) { return -1; - } - BACKUP_H(); - } - RECOVER_H(); - return TRUE; -} + } + BACKUP_H(); + } + RECOVER_H(); + return TRUE; + } -atom_t *TR_Atoms; -functor_t *TR_Functors; -size_t AtomTranslations, MaxAtomTranslations; -size_t FunctorTranslations, MaxFunctorTranslations; + atom_t *TR_Atoms; + functor_t *TR_Functors; + size_t AtomTranslations, MaxAtomTranslations; + size_t FunctorTranslations, MaxFunctorTranslations; -X_API Int YAP_AtomToInt(Atom At) { - TranslationEntry *te = Yap_GetTranslationProp(At, 0); - if (te != NIL) - return te->Translation; - TR_Atoms[AtomTranslations] = At; - Yap_PutAtomTranslation(At, 0, AtomTranslations); - AtomTranslations++; - if (AtomTranslations == MaxAtomTranslations) { - atom_t *ot = TR_Atoms; - atom_t *nt = (atom_t *) malloc(sizeof(atom_t) * 2 * MaxAtomTranslations); - if (nt == NULL) { + X_API Int YAP_AtomToInt(Atom At) { + TranslationEntry *te = Yap_GetTranslationProp(At, 0); + if (te != NIL) + return te->Translation; + TR_Atoms[AtomTranslations] = At; + Yap_PutAtomTranslation(At, 0, AtomTranslations); + AtomTranslations++; + if (AtomTranslations == MaxAtomTranslations) { + atom_t *ot = TR_Atoms; + atom_t *nt = (atom_t *) malloc(sizeof(atom_t) * 2 * MaxAtomTranslations); + if (nt == NULL) { Yap_Error(SYSTEM_ERROR_INTERNAL, MkAtomTerm(At), "No more room for translations"); return -1; - } - memcpy(nt, ot, sizeof(atom_t) * MaxAtomTranslations); - TR_Atoms = nt; - free(ot); - MaxAtomTranslations *= 2; - } - return AtomTranslations - 1; -} + } + memcpy(nt, ot, sizeof(atom_t) * MaxAtomTranslations); + TR_Atoms = nt; + free(ot); + MaxAtomTranslations *= 2; + } + return AtomTranslations - 1; + } -X_API Atom YAP_IntToAtom(Int i) { return TR_Atoms[i]; } + X_API Atom YAP_IntToAtom(Int i) { return TR_Atoms[i]; } -X_API Int YAP_FunctorToInt(Functor f) { - Atom At = NameOfFunctor(f); - arity_t arity = ArityOfFunctor(f); - TranslationEntry *te = Yap_GetTranslationProp(At, arity); - if (te != NIL) - return te->Translation; - TR_Functors[FunctorTranslations] = f; - Yap_PutAtomTranslation(At, arity, FunctorTranslations); - FunctorTranslations++; - if (FunctorTranslations == MaxFunctorTranslations) { - functor_t *nt = (functor_t *) malloc(sizeof(functor_t) * 2 * - MaxFunctorTranslations), - *ot = TR_Functors; - if (nt == NULL) { + X_API Int YAP_FunctorToInt(Functor f) { + Atom At = NameOfFunctor(f); + arity_t arity = ArityOfFunctor(f); + TranslationEntry *te = Yap_GetTranslationProp(At, arity); + if (te != NIL) + return te->Translation; + TR_Functors[FunctorTranslations] = f; + Yap_PutAtomTranslation(At, arity, FunctorTranslations); + FunctorTranslations++; + if (FunctorTranslations == MaxFunctorTranslations) { + functor_t *nt = (functor_t *) malloc(sizeof(functor_t) * 2 * + MaxFunctorTranslations), + *ot = TR_Functors; + if (nt == NULL) { Yap_Error(SYSTEM_ERROR_INTERNAL, MkAtomTerm(At), "No more room for translations"); return -1; - } - memcpy(nt, ot, sizeof(functor_t) * MaxFunctorTranslations); - TR_Functors = nt; - free(ot); - MaxFunctorTranslations *= 2; - } - return FunctorTranslations - 1; -} + } + memcpy(nt, ot, sizeof(functor_t) * MaxFunctorTranslations); + TR_Functors = nt; + free(ot); + MaxFunctorTranslations *= 2; + } + return FunctorTranslations - 1; + } -X_API void *YAP_foreign_stream(int sno) { return GLOBAL_Stream[sno].u.private_data; } + X_API void *YAP_foreign_stream(int sno) { return GLOBAL_Stream[sno].u.private_data; } -X_API Functor YAP_IntToFunctor(Int i) { return TR_Functors[i]; } + X_API Functor YAP_IntToFunctor(Int i) { return TR_Functors[i]; } -X_API void *YAP_shared(void) { return LOCAL_shared; } + X_API void *YAP_shared(void) { return LOCAL_shared; } -X_API PredEntry *YAP_TopGoal(void) { - YAP_Functor f = Yap_MkFunctor(Yap_LookupAtom("yap_query"), 3); - Term tmod = MkAtomTerm(Yap_LookupAtom("yapi")); - PredEntry *p = RepPredProp(Yap_GetPredPropByFunc(f, tmod)); - return p; -} + X_API PredEntry *YAP_TopGoal(void) { + YAP_Functor f = Yap_MkFunctor(Yap_LookupAtom("yap_query"), 3); + Term tmod = MkAtomTerm(Yap_LookupAtom("yapi")); + PredEntry *p = RepPredProp(Yap_GetPredPropByFunc(f, tmod)); + return p; + } -void yap_init(void) {} + void yap_init(void) {} #endif // C_INTERFACE_C -/** - @} -*/ + /** + @} + */ diff --git a/C/modules.c b/C/modules.c index 3aa974b07..aec2f26dc 100644 --- a/C/modules.c +++ b/C/modules.c @@ -53,6 +53,7 @@ static ModEntry *initMod(AtomEntry *toname, AtomEntry *ae) { n->NextME = CurrentModules; CurrentModules = n; n->AtomOfME = ae; + n->NextOfPE =NULL; n->OwnerFile = Yap_ConsultingFile(PASS_REGS1); AddPropToAtom(ae, (PropEntry *)n); Yap_setModuleFlags(n, parent); @@ -385,25 +386,20 @@ static Int strip_module(USES_REGS1) { } static Int yap_strip_clause(USES_REGS1) { - Functor f; Term t1 = Deref(ARG1), tmod = LOCAL_SourceModule; if (tmod == PROLOG_MODULE) { tmod = TermProlog; } t1 = Yap_StripModule(t1, &tmod); - if (IsVarTerm(t1)) { + if (IsVarTerm(t1) || IsVarTerm(tmod)) { Yap_Error(INSTANTIATION_ERROR, t1, "trying to obtain module"); return false; - } else if (IsVarTerm(tmod)) { - Yap_Error(INSTANTIATION_ERROR, tmod, "trying to obtain module"); - return false; - } else if (IsIntTerm(t1) || (IsApplTerm(t1) && IsExtensionFunctor((f = FunctorOfTerm(t1))))) { - Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module"); - return false; - } else if (!IsAtomTerm(tmod)) { - Yap_Error(TYPE_ERROR_ATOM, tmod, "trying to obtain module"); - return false; - } + } else if (IsApplTerm(t1)) { + Functor f = FunctorOfTerm(t1); + if (IsExtensionFunctor(f)) { + Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module"); + return false; + } if (f == FunctorAssert || f == FunctorDoubleArrow) { Term thmod = tmod; Term th = ArgOfTerm(1, t1); @@ -411,7 +407,7 @@ static Int yap_strip_clause(USES_REGS1) { if (IsVarTerm(th)) { Yap_Error(INSTANTIATION_ERROR, t1, "trying to obtain module"); return false; - } else if (IsVarTerm(thmod)) { + } else if (IsVarTerm(thmod)) { Yap_Error(INSTANTIATION_ERROR, thmod, "trying to obtain module"); return false; } else if (IsIntTerm(th) || (IsApplTerm(th) && IsExtensionFunctor(FunctorOfTerm(t1)))) { @@ -422,6 +418,11 @@ static Int yap_strip_clause(USES_REGS1) { return false; } } + + } else if (IsIntTerm(t1) || IsIntTerm(tmod) ) { + Yap_Error(TYPE_ERROR_CALLABLE, t1, "trying to obtain module"); + return false; + } return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod); } diff --git a/C/scanner.c b/C/scanner.c index e2d69db66..48f077858 100755 --- a/C/scanner.c +++ b/C/scanner.c @@ -1,19 +1,19 @@ /************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 * -* * -************************************************************************** -* * -* File: %W% %G% * -* Last rev: 22-1-03 * -* mods: * -* comments: Prolog's scanner * -* * -*************************************************************************/ + * * + * YAP Prolog * + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 * + * * + ************************************************************************** + * * + * File: %W% %G% * + * Last rev: 22-1-03 * + * mods: * + * comments: Prolog's scanner * + * * + *************************************************************************/ /* * Description: @@ -404,10 +404,10 @@ writing, writing a BOM can be requested using the option */ #include "Yap.h" +#include "YapEval.h" #include "YapHeap.h" #include "Yatom.h" #include "alloc.h" -#include "YapEval.h" #include "yapio.h" /* stuff we want to use in standard YAP code */ #include "YapText.h" @@ -462,7 +462,7 @@ char_kind_t Yap_chtype0[NUMBER_OF_CHARS + 1] = { BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us - */ + */ BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, /* sp ! " # $ % & ' ( ) * + , - . / */ @@ -484,11 +484,11 @@ char_kind_t Yap_chtype0[NUMBER_OF_CHARS + 1] = { LC, LC, LC, LC, LC, LC, LC, LC, LC, LC, LC, BK, BK, BK, SY, BS, /* 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 - */ + */ BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, /* 144 145 ’ 147 148 149 150 151 152 153 154 155 156 157 158 159 - */ + */ BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, BS, /* ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ */ @@ -871,7 +871,7 @@ static int num_send_error_message(char s[]) { #define number_overflow() \ { \ - size_t nsz = Yap_Min(max_size * 2, max_size); \ + size_t nsz = Yap_Min(max_size * 2, max_size); \ char *nbuf; \ \ if (buf == buf0) { \ @@ -1104,7 +1104,7 @@ Term Yap_scan_num(StreamDesc *inp, bool error_on) { CACHE_REGS Term out; int sign = 1; - int ch, cherr; + int ch, cherr = 0; char *ptr; void *old_tr = TR; @@ -1225,8 +1225,8 @@ const char *Yap_tokText(void *tokptre) { case eot_tok: return "EOT"; case Ponctuation_tok: - if (info == Terml) - return "("; + if (info == Terml) + return "("; case Error_tok: case BQString_tok: case String_tok: @@ -1604,7 +1604,6 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments, if (!(t->TokInfo)) { return CodeSpaceError(t, p, l); } - Free(TokImage); t->Tok = Ord(kind = String_tok); } else if (quote == '`') { t->TokInfo = Yap_CharsToTBQ((char *)TokImage, CurrentModule, @@ -1612,7 +1611,6 @@ TokEntry *Yap_tokenizer(struct stream_desc *inp_stream, bool store_comments, if (!(t->TokInfo)) { return CodeSpaceError(t, p, l); } - Free(TokImage); t->Tok = Ord(kind = String_tok); } else { t->TokInfo = MkAtomTerm(Yap_ULookupAtom(TokImage)); diff --git a/C/stdpreds.c b/C/stdpreds.c index 71e38efe0..10679dd18 100755 --- a/C/stdpreds.c +++ b/C/stdpreds.c @@ -948,9 +948,10 @@ static Int current_predicate(USES_REGS1) { static OpEntry *NextOp(Prop pp USES_REGS) { - while (!EndOfPAEntr(pp) && pp->KindOfPE != OpProperty && - (RepOpProp(pp)->OpModule != PROLOG_MODULE - || RepOpProp(pp)->OpModule != CurrentModule) ) + while (!EndOfPAEntr(pp) && + pp->KindOfPE != OpProperty && + (RepOpProp(pp)->OpModule != PROLOG_MODULE || RepOpProp(pp)->OpModule != CurrentModule) + ) pp = pp->NextOfPE; return RepOpProp(pp); } diff --git a/C/text.c b/C/text.c index 5873f7bf4..618373324 100644 --- a/C/text.c +++ b/C/text.c @@ -1,19 +1,19 @@ /************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V. Santos Costa and Universidade do Porto 1985-- * -* * -************************************************************************** -* * -* File: strings.c * -* comments: General-conversion of character sequences. * -* * -* Last rev: $Date: 2008-07-24 16:02:00 $,$Author: vsc $ * -* * -*************************************************************************/ + * * + * YAP Prolog * + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V. Santos Costa and Universidade do Porto 1985-- * + * * + ************************************************************************** + * * + * File: strings.c * + * comments: General-conversion of character sequences. * + * * + * Last rev: $Date: 2008-07-24 16:02:00 $,$Author: vsc $ * + * * + *************************************************************************/ #include "Yap.h" #include "YapEval.h" @@ -38,336 +38,323 @@ inline static size_t min_size(size_t i, size_t j) { return (i < j ? i : j); } #define MAX_PATHNAME 2048 struct mblock { - struct mblock *prev, *next; - int lvl; - size_t sz; + struct mblock *prev, *next; + int lvl; + size_t sz; }; typedef struct TextBuffer_manager { - void *buf, *ptr; - size_t sz; - struct mblock *first[16]; - struct mblock *last[16]; - int lvl; + void *buf, *ptr; + size_t sz; + struct mblock *first[16]; + struct mblock *last[16]; + int lvl; } text_buffer_t; -int push_text_stack(USES_REGS1) { - - return LOCAL_TextBuffer->lvl++; -} +int push_text_stack(USES_REGS1) { return LOCAL_TextBuffer->lvl++; } int pop_text_stack(int i) { - int lvl = LOCAL_TextBuffer->lvl; - while (lvl >= i) { - struct mblock *p = LOCAL_TextBuffer->first[lvl]; - while (p) { - struct mblock *np = p->next; - free(p); - p = np; - } - LOCAL_TextBuffer->first[lvl] = NULL; - LOCAL_TextBuffer->last[lvl] = NULL; - lvl--; + int lvl = LOCAL_TextBuffer->lvl; + while (lvl >= i) { + struct mblock *p = LOCAL_TextBuffer->first[lvl]; + while (p) { + struct mblock *np = p->next; + free(p); + p = np; } - LOCAL_TextBuffer->lvl = i; - return lvl; -} - -void *protected_pop_text_stack(int i, void *protected, bool tmp, - size_t sz USES_REGS) { - void *out = protected; - int lvl = LOCAL_TextBuffer->lvl; - while (lvl > i) { - struct mblock *p = LOCAL_TextBuffer->first[lvl]; - while (p) { - struct mblock *np = p->next; - if (p + 1 == protected) { - if (tmp) - out = LOCAL_FileNameBuf; - else - out = p; - memcpy(out, protected, sz); - } else { - free(p); - } - p = np; - } - LOCAL_TextBuffer->first[lvl] = NULL; - LOCAL_TextBuffer->last[lvl] = NULL; - lvl--; - } - LOCAL_TextBuffer->lvl = lvl; - return out; + LOCAL_TextBuffer->first[lvl] = NULL; + LOCAL_TextBuffer->last[lvl] = NULL; + lvl--; + } + LOCAL_TextBuffer->lvl = i; + return lvl; } // void pop_text_stack(int i) { LOCAL_TextBuffer->lvl = i; } +void insert_block(struct mblock *o) { + int lvl = o->lvl; + o->prev = LOCAL_TextBuffer->last[lvl]; + if (o->prev) { + o->prev->next = o; + } + if (LOCAL_TextBuffer->first[lvl]) { + LOCAL_TextBuffer->last[lvl] = o; + } else { + LOCAL_TextBuffer->first[lvl] = LOCAL_TextBuffer->last[lvl] = o; + } + o->next = NULL; +} + +void release_block(struct mblock *o) { + if (o->prev) + o->prev->next = o->next; + if (o->next) + o->next->prev = o->prev; + int lvl = o->lvl; + if (LOCAL_TextBuffer->first[lvl] == o) { + if (LOCAL_TextBuffer->last[lvl] == o) { + LOCAL_TextBuffer->first[lvl] = LOCAL_TextBuffer->last[lvl] = NULL; + } + LOCAL_TextBuffer->first[lvl] = o->next; + } else if (LOCAL_TextBuffer->last[lvl] == o) { + LOCAL_TextBuffer->last[lvl] = o->prev; + } +} void *Malloc(size_t sz USES_REGS) { - int lvl = LOCAL_TextBuffer->lvl; - if (sz == 0) - sz = 1024; - sz = ALIGN_BY_TYPE(sz + sizeof(struct mblock), CELL); - struct mblock *o = malloc(sz); - if (!o) - return NULL; - o->prev = LOCAL_TextBuffer->last[lvl]; - if (o->prev) { - o->prev->next = o; - } - if (LOCAL_TextBuffer->first[lvl]) { - LOCAL_TextBuffer->last[lvl] = o; - } else { - LOCAL_TextBuffer->first[lvl] = LOCAL_TextBuffer->last[lvl] = o; - } - o->next = NULL; - o->sz = sz; - o->lvl = lvl; - return o + 1; + int lvl = LOCAL_TextBuffer->lvl; + if (sz == 0) + sz = 1024; + sz = ALIGN_BY_TYPE(sz + sizeof(struct mblock), CELL); + struct mblock *o = malloc(sz); + if (!o) + return NULL; + o->sz = sz; + o->lvl = lvl; + o->prev = o->next = 0; + insert_block(o); + return o + 1; } void *Realloc(void *pt, size_t sz USES_REGS) { - sz = ALIGN_BY_TYPE(sz + sizeof(struct mblock), CELL); - struct mblock *old = pt, *o; - old--; - int lvl = old->lvl; - o = realloc(old, sz); - if (o->prev) - o->prev->next = o; - if (o->next) - o->next->prev = o; - if (LOCAL_TextBuffer->first[lvl] == old) { - LOCAL_TextBuffer->first[lvl] = o; - } - if (LOCAL_TextBuffer->last[lvl] == old) { - LOCAL_TextBuffer->last[lvl] = o; - } + sz = ALIGN_BY_TYPE(sz + sizeof(struct mblock), CELL); + struct mblock *old = pt, *o; + old--; + int lvl = old->lvl; + o = realloc(old, sz); + if (o->prev) + o->prev->next = o; + if (o->next) + o->next->prev = o; + if (LOCAL_TextBuffer->first[lvl] == old) { + LOCAL_TextBuffer->first[lvl] = o; + } + if (LOCAL_TextBuffer->last[lvl] == old) { + LOCAL_TextBuffer->last[lvl] = o; + } + o->sz = sz; - return o + 1; + return o + 1; +} + +void *export_block(int i, void *protected USES_REGS) { + struct mblock *o = ((struct mblock *)protected) - 1; + release_block(o); + if (i >= 0) { + o->lvl = i; + insert_block(o); + return protected; + } else { + memcpy(o, protected, o->sz); + return o; + } } void Free(void *pt USES_REGS) { - struct mblock *o = pt; - o--; - if (o->prev) - o->prev->next = o->next; - if (o->next) - o->next->prev = o->prev; - int lvl = o->lvl; - if (LOCAL_TextBuffer->first[lvl] == o) { - if (LOCAL_TextBuffer->last[lvl] == o) { - LOCAL_TextBuffer->first[lvl] = LOCAL_TextBuffer->last[lvl] = NULL; - } - LOCAL_TextBuffer->first[lvl] = o->next; - } else if (LOCAL_TextBuffer->last[lvl] == o) { - LOCAL_TextBuffer->last[lvl] = o->prev; - } - free(o); + struct mblock *o = pt; + o--; + release_block(o); + free(o); } void *Yap_InitTextAllocator(void) { - struct TextBuffer_manager *new = calloc(sizeof(struct TextBuffer_manager), 1); - return new; + struct TextBuffer_manager *new = calloc(sizeof(struct TextBuffer_manager), 1); + return new; } static size_t MaxTmp(USES_REGS1) { - return ((char *) LOCAL_TextBuffer->buf + LOCAL_TextBuffer->sz) - - (char *) LOCAL_TextBuffer->ptr; + return ((char *)LOCAL_TextBuffer->buf + LOCAL_TextBuffer->sz) - + (char *)LOCAL_TextBuffer->ptr; } static Term Globalize(Term v USES_REGS) { - if (!IsVarTerm(v = Deref(v))) { - return v; - } - if (VarOfTerm(v) > HR && VarOfTerm(v) < LCL0) { - Bind_Local(VarOfTerm(v), MkVarTerm()); - v = Deref(v); - } + if (!IsVarTerm(v = Deref(v))) { return v; + } + if (VarOfTerm(v) > HR && VarOfTerm(v) < LCL0) { + Bind_Local(VarOfTerm(v), MkVarTerm()); + v = Deref(v); + } + return v; } static Int SkipListCodes(unsigned char **bufp, Term *l, Term **tailp, Int *atoms, bool *wide, seq_tv_t *inp USES_REGS) { - Int length = 0; - Term v; /* temporary */ - *wide = false; - unsigned char *st0 = *bufp, *st; - bool atomst; - size_t max_lim = 1024; + Int length = 0; + Term v; /* temporary */ + *wide = false; + unsigned char *st0 = *bufp, *st; + bool atomst; + size_t max_lim = 1024; - if (!st0) { - st0 = Malloc(1024); - } + if (!st0) { + st0 = Malloc(1024); + } - do_derefa(v, l, derefa_unk, derefa_nonvar); - *tailp = l; + do_derefa(v, l, derefa_unk, derefa_nonvar); + *tailp = l; - *bufp = st = st0; + *bufp = st = st0; - if (*l == TermNil) { - st[0] = '\0'; - return 0; - } - if (IsPairTerm(*l)) { - Term hd0 = HeadOfTerm(*l); - if (IsVarTerm(hd0)) { - return -INSTANTIATION_ERROR; - } - // are we looking for atoms/codes? - // whatever the case, we should be consistent throughout, - // so we should be consistent with the first arg. - if (st > st0 + max_lim) { - max_lim += 2048; - *bufp = st0 = Realloc(st0, max_lim); - } - if (IsAtomTerm(hd0)) { - atomst = true; - - } else { - atomst = false; - } - - while (IsPairTerm(*l)) { - int ch; - length++; - { - Term hd = Deref(RepPair(*l)[0]); - if (IsVarTerm(hd)) { - return -INSTANTIATION_ERROR; - } else if (IsAtomTerm(hd)) { - if (!atomst) { - return -REPRESENTATION_ERROR_CHARACTER; - } else { - AtomEntry *ae = RepAtom(AtomOfTerm(hd)); - st = (unsigned char *) stpcpy((char *) st, ae->StrOfAE); - } - } else if (IsIntegerTerm(hd)) { - ch = IntegerOfTerm(hd); - if (atomst) - return -REPRESENTATION_ERROR_CHARACTER; - else if (ch < 0) { - *tailp = l; - return -REPRESENTATION_ERROR_CHARACTER_CODE; - } else { - st += put_utf8(st, ch); - } - } else { - return -TYPE_ERROR_INTEGER; - } - if (length < 0) { - *tailp = l; - return length; - } - } - - l = RepPair(*l) + 1; - do_derefa(v, l, derefa2_unk, derefa2_nonvar); - - } - } - if (IsVarTerm(*l)) { - return -INSTANTIATION_ERROR; - } - if (*l != TermNil) { - return -TYPE_ERROR_LIST; - } + if (*l == TermNil) { st[0] = '\0'; - *tailp = l; - *atoms = length; - length = (st - st0); - - return length; -} - -static unsigned char *latin2utf8(seq_tv_t *inp, size_t *lengp) { - unsigned char *b0 = inp->val.uc; - size_t sz = *lengp = strlen(inp->val.c); - sz *= 2; - int ch; - unsigned char *buf = Malloc(sz + 1), *pt = buf; - *lengp = strlen(inp->val.c); - if (!buf) - return NULL; - while ((ch = *b0++)) { - int off = put_utf8(pt, ch); - if (off < 0) - continue; - pt += off; + return 0; + } + if (IsPairTerm(*l)) { + Term hd0 = HeadOfTerm(*l); + if (IsVarTerm(hd0)) { + return -INSTANTIATION_ERROR; } - *pt++ = '\0'; - return buf; + // are we looking for atoms/codes? + // whatever the case, we should be consistent throughout, + // so we should be consistent with the first arg. + if (st > st0 + max_lim) { + max_lim += 2048; + *bufp = st0 = Realloc(st0, max_lim); + } + if (IsAtomTerm(hd0)) { + atomst = true; + + } else { + atomst = false; + } + + while (IsPairTerm(*l)) { + int ch; + length++; + { + Term hd = Deref(RepPair(*l)[0]); + if (IsVarTerm(hd)) { + return -INSTANTIATION_ERROR; + } else if (IsAtomTerm(hd)) { + if (!atomst) { + return -REPRESENTATION_ERROR_CHARACTER; + } else { + AtomEntry *ae = RepAtom(AtomOfTerm(hd)); + st = (unsigned char *)stpcpy((char *)st, ae->StrOfAE); + } + } else if (IsIntegerTerm(hd)) { + ch = IntegerOfTerm(hd); + if (atomst) + return -REPRESENTATION_ERROR_CHARACTER; + else if (ch < 0) { + *tailp = l; + return -REPRESENTATION_ERROR_CHARACTER_CODE; + } else { + st += put_utf8(st, ch); + } + } else { + return -TYPE_ERROR_INTEGER; + } + if (length < 0) { + *tailp = l; + return length; + } + } + + l = RepPair(*l) + 1; + do_derefa(v, l, derefa2_unk, derefa2_nonvar); + } + } + if (IsVarTerm(*l)) { + return -INSTANTIATION_ERROR; + } + if (*l != TermNil) { + return -TYPE_ERROR_LIST; + } + st[0] = '\0'; + *tailp = l; + *atoms = length; + length = (st - st0); + + return length; } -static unsigned char *wchar2utf8(seq_tv_t *inp, size_t *lengp) { - *lengp = wcslen(inp->val.w); - size_t sz = *lengp * 4; - wchar_t *b0 = inp->val.w; - unsigned char *buf = Malloc(sz + 1), *pt = buf; - int ch; - if (!buf) - return NULL; - while ((ch = *b0++)) - pt += put_utf8(pt, ch); - *pt++ = '\0'; - return buf; +static unsigned char *latin2utf8(seq_tv_t *inp) { + unsigned char *b0 = inp->val.uc; + size_t sz = strlen(inp->val.c); + sz *= 2; + int ch; + unsigned char *buf = Malloc(sz + 1), *pt = buf; + if (!buf) + return NULL; + while ((ch = *b0++)) { + int off = put_utf8(pt, ch); + if (off < 0) + continue; + pt += off; + } + *pt++ = '\0'; + return buf; +} + +static unsigned char *wchar2utf8(seq_tv_t *inp) { + size_t sz = wcslen(inp->val.w) * 4; + wchar_t *b0 = inp->val.w; + unsigned char *buf = Malloc(sz + 1), *pt = buf; + int ch; + if (!buf) + return NULL; + while ((ch = *b0++)) + pt += put_utf8(pt, ch); + *pt++ = '\0'; + return buf; } static void *slice(size_t min, size_t max, const unsigned char *buf USES_REGS); static unsigned char *to_buffer(unsigned char *buf, Term t, seq_tv_t *inp, - bool *widep, Int *atoms, - size_t *lenp USES_REGS) { - CELL *r = NULL; - Int n; + bool *widep, Int *atoms USES_REGS) { + CELL *r = NULL; + Int n; - if (!buf) { - inp->max = *lenp; - } - unsigned char *bufc = buf; - n = SkipListCodes(&bufc, &t, &r, atoms, widep, inp PASS_REGS); - if (n < 0) { - LOCAL_Error_TYPE = -n; - return NULL; - } - *lenp = n; - return bufc; + unsigned char *bufc = buf; + if (bufc == NULL) { + bufc = malloc(1024); + } + n = SkipListCodes(&bufc, &t, &r, atoms, widep, inp PASS_REGS); + if (n < 0) { + LOCAL_Error_TYPE = -n; + return NULL; + } + return bufc; } static unsigned char *Yap_ListOfCodesToBuffer(unsigned char *buf, Term t, - seq_tv_t *inp, bool *widep, - size_t *lenp USES_REGS) { - Int atoms = 1; // we only want lists of atoms - return to_buffer(buf, t, inp, widep, &atoms, lenp PASS_REGS); + seq_tv_t *inp, + bool *widep USES_REGS) { + Int atoms = 1; // we only want lists of atoms + return to_buffer(buf, t, inp, widep, &atoms PASS_REGS); } static unsigned char *Yap_ListOfAtomsToBuffer(unsigned char *buf, Term t, - seq_tv_t *inp, bool *widep, - size_t *lenp USES_REGS) { - Int atoms = 2; // we only want lists of integer codes - return to_buffer(buf, t, inp, widep, &atoms, lenp PASS_REGS); + seq_tv_t *inp, + bool *widep USES_REGS) { + Int atoms = 2; // we only want lists of integer codes + return to_buffer(buf, t, inp, widep, &atoms PASS_REGS); } static unsigned char *Yap_ListToBuffer(unsigned char *buf, Term t, - seq_tv_t *inp, bool *widep, - size_t *lenp USES_REGS) { - Int atoms = 0; // we accept both types of lists. - return to_buffer(buf, t, inp, widep, &atoms, lenp PASS_REGS); + seq_tv_t *inp, bool *widep USES_REGS) { + Int atoms = 0; // we accept both types of lists. + return to_buffer(buf, t, inp, widep, &atoms PASS_REGS); } #if USE_GEN_TYPE_ERROR static yap_error_number gen_type_error(int flags) { if ((flags & (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_ATOMS_CODES | YAP_STRING_BIG)) == - (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | - YAP_STRING_ATOMS_CODES | YAP_STRING_BIG)) + YAP_STRING_FLOAT | YAP_STRING_ATOMS_CODES | YAP_STRING_BIG)) == + (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | + YAP_STRING_ATOMS_CODES | YAP_STRING_BIG)) return TYPE_ERROR_TEXT; if ((flags & (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG)) == - (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | - YAP_STRING_BIG)) + YAP_STRING_FLOAT | YAP_STRING_BIG)) == + (YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | + YAP_STRING_BIG)) return TYPE_ERROR_ATOMIC; if ((flags & (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) == - (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) + (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) return TYPE_ERROR_NUMBER; if (flags & YAP_STRING_ATOM) return TYPE_ERROR_ATOM; @@ -381,671 +368,668 @@ static yap_error_number gen_type_error(int flags) { // static int cnt; -unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp) { - unsigned char *s0 = NULL; - bool wide; +unsigned char *Yap_readText(seq_tv_t *inp USES_REGS) { + unsigned char *s0 = NULL; + bool wide; - if (LOCAL_Error_TYPE != YAP_NO_ERROR) { - fprintf(stderr, "Spurious error %u\n", LOCAL_Error_TYPE); - LOCAL_Error_TYPE = YAP_NO_ERROR; - } - /* we know what the term is */ - if (!(inp->type & (YAP_STRING_CHARS | YAP_STRING_WCHARS))) { - if (!(inp->type & YAP_STRING_TERM)) { - if (IsVarTerm(inp->val.t)) { - LOCAL_Error_TYPE = INSTANTIATION_ERROR; - } else if (!IsAtomTerm(inp->val.t) && inp->type == YAP_STRING_ATOM) { - LOCAL_Error_TYPE = TYPE_ERROR_ATOM; - } else if (!IsStringTerm(inp->val.t) && inp->type == YAP_STRING_STRING) { - LOCAL_Error_TYPE = TYPE_ERROR_STRING; - } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) && - inp->type == (YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) { - LOCAL_Error_TYPE = TYPE_ERROR_LIST; - } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) - && !IsAtomTerm(inp->val.t) && !(inp->type & YAP_STRING_DATUM)) { - LOCAL_Error_TYPE = TYPE_ERROR_TEXT; - } - } - } - if (LOCAL_Error_TYPE != YAP_NO_ERROR) - return NULL; - - if (IsAtomTerm(inp->val.t) && inp->type & YAP_STRING_ATOM) { - // this is a term, extract to a buffer, and representation is wide - // Yap_DebugPlWriteln(inp->val.t); - Atom at = AtomOfTerm(inp->val.t); - size_t sz = strlen(at->StrOfAE); - if (lengp) - *lengp = sz; - if (inp->type & YAP_STRING_WITH_BUFFER) - return at->UStrOfAE; - inp->type |= YAP_STRING_IN_TMP; - char *o = Malloc(sz + 1); - strcpy(o, at->StrOfAE); - return (unsigned char *) o; - } - if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) { - // this is a term, extract to a buffer, and representation is wide - // Yap_DebugPlWriteln(inp->val.t); - const char *s = StringOfTerm(inp->val.t); - size_t sz = strlen(s); - if (lengp) - *lengp = sz; - if (inp->type & YAP_STRING_WITH_BUFFER) - return (unsigned char *) UStringOfTerm(inp->val.t); - inp->type |= YAP_STRING_IN_TMP; - char *o = Malloc(sz + 1); - strcpy(o, s); - return (unsigned char *) o; - } - if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) == - (YAP_STRING_CODES | YAP_STRING_ATOMS)) && - IsPairOrNilTerm(inp->val.t)) { - // Yap_DebugPlWriteln(inp->val.t); - return Yap_ListToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS); - // this is a term, extract to a sfer, and representation is wide - } - if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) { - // Yap_DebugPlWriteln(inp->val.t); - return Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS); - // this is a term, extract to a sfer, and representation is wide - } - if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) { - // Yap_DebugPlWriteln(inp->val.t); - return Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide, lengp PASS_REGS); - // this is a term, extract to a buffer, and representation is wide - } - if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) { - // ASCII, so both LATIN1 and UTF-8 - // Yap_DebugPlWriteln(inp->val.t); - char *s; - s = Malloc(0); - if (snprintf(s, MaxTmp(PASS_REGS1) - 1, Int_FORMAT, - IntegerOfTerm(inp->val.t)) < 0) { - AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char); - } - if (lengp) - *lengp = strlen(s); - return (unsigned char *) s; - } - if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) { - char *s; - // Yap_DebugPlWriteln(inp->val.t); - if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &s, 1024)) { - return NULL; - } - if (lengp) - *lengp = strlen(s); - return (unsigned char *) s; - } -#if USE_GMP - if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) { - // Yap_DebugPlWriteln(inp->val.t); - char *s; - s = Malloc(0); - if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), s, MaxTmp() - 1, 10)) { - AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char); - } - if (lengp) - *lengp = strlen(s); - return inp->val.uc = (unsigned char *) s; - } -#endif - if (inp->type & YAP_STRING_TERM) { - // Yap_DebugPlWriteln(inp->val.t); - char *s = (char *) Yap_TermToString(inp->val.t, lengp, ENC_ISO_UTF8, 0); - return inp->val.uc = (unsigned char *) s; - } - if (inp->type & YAP_STRING_CHARS) { - if (inp->enc == ENC_ISO_LATIN1) { - return latin2utf8(inp, lengp); - } else if (inp->enc == ENC_ISO_ASCII) { - if (lengp) - *lengp = strlen(inp->val.c); - return inp->val.uc; - } else { //if (inp->enc == ENC_ISO_UTF8) { - if (lengp) - *lengp = strlen(inp->val.c); - return inp->val.uc; - } - } - if (inp->type & YAP_STRING_WCHARS) { - // printf("%S\n",inp->val.w); - return wchar2utf8(inp, lengp); + if (LOCAL_Error_TYPE != YAP_NO_ERROR) { + fprintf(stderr, "Spurious error %u\n", LOCAL_Error_TYPE); + LOCAL_Error_TYPE = YAP_NO_ERROR; + } + /* we know what the term is */ + if (!(inp->type & (YAP_STRING_CHARS | YAP_STRING_WCHARS))) { + if (!(inp->type & YAP_STRING_TERM)) { + if (IsVarTerm(inp->val.t)) { + LOCAL_Error_TYPE = INSTANTIATION_ERROR; + } else if (!IsAtomTerm(inp->val.t) && inp->type == YAP_STRING_ATOM) { + LOCAL_Error_TYPE = TYPE_ERROR_ATOM; + } else if (!IsStringTerm(inp->val.t) && inp->type == YAP_STRING_STRING) { + LOCAL_Error_TYPE = TYPE_ERROR_STRING; + } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) && + inp->type == (YAP_STRING_ATOMS_CODES | YAP_STRING_STRING)) { + LOCAL_Error_TYPE = TYPE_ERROR_LIST; + } else if (!IsPairOrNilTerm(inp->val.t) && !IsStringTerm(inp->val.t) && + !IsAtomTerm(inp->val.t) && !(inp->type & YAP_STRING_DATUM)) { + LOCAL_Error_TYPE = TYPE_ERROR_TEXT; + } } + } + if (LOCAL_Error_TYPE != YAP_NO_ERROR) return NULL; + + if (IsAtomTerm(inp->val.t) && inp->type & YAP_STRING_ATOM) { + // this is a term, extract to a buffer, and representation is wide + // Yap_DebugPlWriteln(inp->val.t); + Atom at = AtomOfTerm(inp->val.t); + if (inp->type & YAP_STRING_WITH_BUFFER) + return at->UStrOfAE; + size_t sz = strlen(at->StrOfAE); + inp->type |= YAP_STRING_IN_TMP; + char *o = Malloc(sz + 1); + strcpy(o, at->StrOfAE); + o = export_block(0, o); + return (unsigned char *)o; + } + if (IsStringTerm(inp->val.t) && inp->type & YAP_STRING_STRING) { + // this is a term, extract to a buffer, and representation is wide + // Yap_DebugPlWriteln(inp->val.t); + const char *s = StringOfTerm(inp->val.t); + if (inp->type & YAP_STRING_WITH_BUFFER) + return (unsigned char *)UStringOfTerm(inp->val.t); + inp->type |= YAP_STRING_IN_TMP; + size_t sz = strlen(s); + char *o = Malloc(sz + 1); + o = export_block(0, o); + strcpy(o, s); + return (unsigned char *)o; + } + if (((inp->type & (YAP_STRING_CODES | YAP_STRING_ATOMS)) == + (YAP_STRING_CODES | YAP_STRING_ATOMS)) && + IsPairOrNilTerm(inp->val.t)) { + // Yap_DebugPlWriteln(inp->val.t); + return Yap_ListToBuffer(s0, inp->val.t, inp, &wide PASS_REGS); + // this is a term, extract to a sfer, and representation is wide + } + if (inp->type & YAP_STRING_CODES && IsPairOrNilTerm(inp->val.t)) { + // Yap_DebugPlWriteln(inp->val.t); + return Yap_ListOfCodesToBuffer(s0, inp->val.t, inp, &wide PASS_REGS); + // this is a term, extract to a sfer, and representation is wide + } + if (inp->type & YAP_STRING_ATOMS && IsPairOrNilTerm(inp->val.t)) { + // Yap_DebugPlWriteln(inp->val.t); + return Yap_ListOfAtomsToBuffer(s0, inp->val.t, inp, &wide PASS_REGS); + // this is a term, extract to a buffer, and representation is wide + } + if (inp->type & YAP_STRING_INT && IsIntegerTerm(inp->val.t)) { + // ASCII, so both LATIN1 and UTF-8 + // Yap_DebugPlWriteln(inp->val.t); + char *s; + s = Malloc(2 * MaxTmp(PASS_REGS1)); + if (snprintf(s, MaxTmp(PASS_REGS1) - 1, Int_FORMAT, + IntegerOfTerm(inp->val.t)) < 0) { + AUX_ERROR(inp->val.t, 2 * MaxTmp(PASS_REGS1), s, char); + } + return (unsigned char *)s; + } + if (inp->type & YAP_STRING_FLOAT && IsFloatTerm(inp->val.t)) { + char *s; + // Yap_DebugPlWriteln(inp->val.t); + if (!Yap_FormatFloat(FloatOfTerm(inp->val.t), &s, 1024)) { + return NULL; + } + return (unsigned char *)s; + } +#if USE_GMP + if (inp->type & YAP_STRING_BIG && IsBigIntTerm(inp->val.t)) { + // Yap_DebugPlWriteln(inp->val.t); + char *s; + s = Malloc(MaxTmp()); + if (!Yap_mpz_to_string(Yap_BigIntOfTerm(inp->val.t), s, MaxTmp() - 1, 10)) { + AUX_ERROR(inp->val.t, MaxTmp(PASS_REGS1), s, char); + } + return inp->val.uc = (unsigned char *)s; + } +#endif + if (inp->type & YAP_STRING_TERM) { + // Yap_DebugPlWriteln(inp->val.t); + char *s = (char *)Yap_TermToString(inp->val.t, ENC_ISO_UTF8, 0); + return inp->val.uc = (unsigned char *)s; + } + if (inp->type & YAP_STRING_CHARS) { + if (inp->enc == ENC_ISO_LATIN1) { + return latin2utf8(inp); + } else if (inp->enc == ENC_ISO_ASCII) { + return inp->val.uc; + } else { // if (inp->enc == ENC_ISO_UTF8) { + return inp->val.uc; + } + } + if (inp->type & YAP_STRING_WCHARS) { + // printf("%S\n",inp->val.w); + return wchar2utf8(inp); + } + return NULL; } -static Term write_strings(unsigned char *s0, seq_tv_t *out, - size_t leng USES_REGS) { - size_t min = 0, max = leng; +static Term write_strings(unsigned char *s0, seq_tv_t *out USES_REGS) { + size_t min = 0, max = strlen((char *)s0); - if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { - if (out->type & YAP_STRING_NCHARS) - min = out->max; - if (out->type & YAP_STRING_TRUNC && out->max < max) { - max = out->max; - s0[max] = '\0'; - } + if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { + if (out->type & YAP_STRING_NCHARS) + min = out->max; + if (out->type & YAP_STRING_TRUNC && out->max < max) { + max = out->max; + s0[max] = '\0'; } + } - char *s = (char *) s0; - Term t = init_tstring(PASS_REGS1); - LOCAL_TERM_ERROR(t, 2 * max); - unsigned char *buf = buf_from_tstring(HR); - strcpy((char *) buf, s); - if (max + 1 < min) { - LOCAL_TERM_ERROR(t, 2 * min); - memset(buf + min, '\0', max); - buf += min; + char *s = (char *)s0; + Term t = init_tstring(PASS_REGS1); + LOCAL_TERM_ERROR(t, 2 * max); + unsigned char *buf = buf_from_tstring(HR); + strcpy((char *)buf, s); + if (max + 1 < min) { + LOCAL_TERM_ERROR(t, 2 * min); + memset(buf + min, '\0', max); + buf += min; + } else { + buf += max + 1; + } + close_tstring(buf PASS_REGS); + out->val.t = t; + + return out->val.t; +} + +static Term write_atoms(void *s0, seq_tv_t *out USES_REGS) { + Term t = AbsPair(HR); + char *s1 = (char *)s0; + size_t sz = 0; + size_t max = strlen(s1); + if (s1[0] == '\0') { + out->val.t = TermNil; + return TermNil; + } + if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { + if (out->type & YAP_STRING_TRUNC && out->max < max) + max = out->max; + } + + unsigned char *s = s0, *lim = s + strnlen((char *)s, max); + unsigned char *cp = s; + unsigned char w[10]; + int wp = 0; + LOCAL_TERM_ERROR(t, 2 * (lim - s)); + while (cp < lim && *cp) { + utf8proc_int32_t chr; + CELL *cl; + s += get_utf8(s, -1, &chr); + if (chr == '\0') { + w[0] = '\0'; + break; + } + wp = put_utf8(w, chr); + w[wp] = '\0'; + cl = HR; + HR += 2; + cl[0] = MkAtomTerm(Yap_ULookupAtom(w)); + cl[1] = AbsPair(HR); + sz++; + if (sz == max) + break; + } + if (out->type & YAP_STRING_DIFF) { + if (sz == 0) + t = out->dif; + else + HR[-1] = Globalize(out->dif PASS_REGS); + } else { + if (sz == 0) + t = TermNil; + else + HR[-1] = TermNil; + } + out->val.t = t; + return (t); +} + +static Term write_codes(void *s0, seq_tv_t *out USES_REGS) { + Term t; + size_t sz = strlen(s0); + if (sz == 0) { + if (out->type & YAP_STRING_DIFF) { + out->val.t = Globalize(out->dif PASS_REGS); } else { - buf += max + 1; + out->val.t = TermNil; } - close_tstring(buf PASS_REGS); - out->val.t = t; - return out->val.t; + } + unsigned char *s = s0, *lim = s + sz; + unsigned char *cp = s; + + t = AbsPair(HR); + LOCAL_TERM_ERROR(t, 2 * (lim - s)); + t = AbsPair(HR); + while (*cp) { + utf8proc_int32_t chr; + CELL *cl; + cp += get_utf8(cp, -1, &chr); + if (chr == '\0') + break; + cl = HR; + HR += 2; + cl[0] = MkIntegerTerm(chr); + cl[1] = AbsPair(HR); + } + if (sz == 0) { + HR[-1] = Globalize(out->dif PASS_REGS); + } else { + HR[-1] = TermNil; + } + out->val.t = t; + return (t); } -static Term write_atoms(void *s0, seq_tv_t *out, size_t leng USES_REGS) { - Term t = AbsPair(HR); - size_t sz = 0; - size_t max = leng; - if (leng == 0) { - out->val.t = t; - return TermNil; - } - if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { - if (out->type & YAP_STRING_TRUNC && out->max < max) - max = out->max; - } - - unsigned char *s = s0, *lim = s + strnlen((char *) s, max); - unsigned char *cp = s; - unsigned char w[10]; - int wp = 0; - LOCAL_TERM_ERROR(t, 2 * (lim - s)); - while (cp < lim && *cp) { - utf8proc_int32_t chr; - CELL *cl; - s += get_utf8(s, -1, &chr); - if (chr == '\0') { - w[0] = '\0'; - break; - } - wp = put_utf8(w, chr); - w[wp] = '\0'; - cl = HR; - HR += 2; - cl[0] = MkAtomTerm(Yap_ULookupAtom(w)); - cl[1] = AbsPair(HR); - sz++; - if (sz == max) - break; - } - if (out->type & YAP_STRING_DIFF) { - if (sz == 0) - t = out->dif; - else - HR[-1] = Globalize(out->dif PASS_REGS); - } else { - if (sz == 0) - t = TermNil; - else - HR[-1] = TermNil; - } - out->val.t = t; - return (t); +static Atom write_atom(void *s0, seq_tv_t *out USES_REGS) { + unsigned char *s = s0; + int32_t ch; + size_t leng = strlen(s0); + if (leng == 0) { + return Yap_LookupAtom(""); + } + if (strlen_utf8(s0) <= leng) { + return Yap_LookupAtom(s0); + } else { + size_t n = get_utf8(s, -1, &ch); + unsigned char *buf = Malloc(n + 1); + memcpy(buf, s0, n + 1); + return Yap_ULookupAtom(buf); + } } -static Term write_codes(void *s0, seq_tv_t *out, size_t leng USES_REGS) { - Term t = AbsPair(HR); - size_t sz = 0; - size_t max = leng; - if (leng == 0) { - out->val.t = t; - return TermNil; +size_t write_buffer(unsigned char *s0, seq_tv_t *out USES_REGS) { + size_t leng = strlen((char *)s0); + size_t min = 0, max = leng, room_end; + if (out->enc == ENC_ISO_UTF8) { + room_end = strlen((char *)s0) + 1; + if (out->val.uc == NULL) { // this should always be the case + out->val.uc = malloc(room_end < 16 ? 16 : room_end); } - if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { - if (out->type & YAP_STRING_TRUNC && out->max < max) - max = out->max; + if (out->val.uc != s0) { + strcpy(out->val.c, (char *)s0); } - - unsigned char *s = s0, *lim = s + strlen((char *) s); - unsigned char *cp = s; - - LOCAL_TERM_ERROR(t, 2 * (lim - s)); - while (*cp) { - utf8proc_int32_t chr; - CELL *cl; - cp += get_utf8(cp, -1, &chr); - if (chr == '\0') - break; - cl = HR; - HR += 2; - cl[0] = MkIntegerTerm(chr); - cl[1] = AbsPair(HR); - sz++; - if (sz == max) - break; - } - if (out->type & YAP_STRING_DIFF) { - if (sz == 0) - t = out->dif; - else - HR[-1] = Globalize(out->dif PASS_REGS); - } else { - if (sz == 0) - t = TermNil; - else - HR[-1] = TermNil; - } - out->val.t = t; - return (t); -} - -static Atom write_atom(void *s0, seq_tv_t *out, size_t leng USES_REGS) { + } else if (out->enc == ENC_ISO_LATIN1) { + room_end = strlen((char *)s0) + 1; unsigned char *s = s0; - int32_t ch; - if (leng == 0) { - return Yap_LookupAtom(""); + unsigned char *cp = s; + unsigned char *buf = out->val.uc; + if (!buf) + return -1; + while (*cp) { + utf8proc_int32_t chr; + int off = get_utf8(cp, -1, &chr); + if (off <= 0 || chr > 255) + return -1; + if (off == max) + break; + cp += off; + *buf++ = chr; } - if (strlen_utf8(s0) <= leng) { - return Yap_LookupAtom(s0); - } else { - size_t n = get_utf8(s, -1, &ch); - unsigned char *buf = Malloc(n + 1); - memcpy(buf, s0, n + 1); - return Yap_ULookupAtom(buf); + if (max >= min) + *buf++ = '\0'; + else + while (max < min) { + utf8proc_int32_t chr; + max++; + cp += get_utf8(cp, -1, &chr); + *buf++ = chr; + } + room_end = buf - out->val.uc; + } else if (out->enc == ENC_WCHAR) { + unsigned char *s = s0, *lim = s + (max = strnlen((char *)s0, max)); + unsigned char *cp = s; + wchar_t *buf0, *buf; + + buf = buf0 = out->val.w; + if (!buf) + return -1; + while (*cp && cp < lim) { + utf8proc_int32_t chr; + cp += get_utf8(cp, -1, &chr); + *buf++ = chr; } + if (max >= min) + *buf++ = '\0'; + else + while (max < min) { + utf8proc_int32_t chr; + max++; + cp += get_utf8(cp, -1, &chr); + *buf++ = chr; + } + *buf = '\0'; + room_end = (buf - buf0) + 1; + } else { + // no other encodings are supported. + room_end = -1; + } + return room_end; } -size_t write_buffer(unsigned char *s0, seq_tv_t *out, size_t leng USES_REGS) { - size_t min = 0, max = leng, room_end; - if (out->enc == ENC_ISO_UTF8) { - room_end = strlen((char *) s0) + 1; - if (out->val.uc == NULL) { // this should always be the case - out->val.uc = malloc(room_end < 16 ? 16 : room_end); - } - if (out->val.uc != s0) { - strcpy(out->val.c, (char *) s0); - } - } else if (out->enc == ENC_ISO_LATIN1) { - room_end = strlen((char *) s0) + 1; - unsigned char *s = s0; - unsigned char *cp = s; - unsigned char *buf = out->val.uc; - if (!buf) - return -1; - while (*cp) { - utf8proc_int32_t chr; - int off = get_utf8(cp, -1, &chr); - if (off <= 0 || chr > 255) - return -1; - if (off == max) - break; - cp += off; - *buf++ = chr; - } - if (max >= min) - *buf++ = '\0'; - else - while (max < min) { - utf8proc_int32_t chr; - max++; - cp += get_utf8(cp, -1, &chr); - *buf++ = chr; - } - room_end = buf - out->val.uc; - } else if (out->enc == ENC_WCHAR) { - unsigned char *s = s0, *lim = s + (max = strnlen((char *) s0, max)); - unsigned char *cp = s; - wchar_t *buf0, *buf; - - buf = buf0 = out->val.w; - if (!buf) - return -1; - while (*cp && cp < lim) { - utf8proc_int32_t chr; - cp += get_utf8(cp, -1, &chr); - *buf++ = chr; - } - if (max >= min) - *buf++ = '\0'; - else - while (max < min) { - utf8proc_int32_t chr; - max++; - cp += get_utf8(cp, -1, &chr); - *buf++ = chr; - } - *buf = '\0'; - room_end = (buf - buf0) + 1; - } else { - // no other encodings are supported. - room_end = -1; - } - return room_end; +static size_t write_length(const unsigned char *s0, seq_tv_t *out USES_REGS) { + return strlen_utf8(s0); } -static size_t write_length(const unsigned char *s0, seq_tv_t *out, - size_t leng USES_REGS) { - return leng; -} - -static Term write_number(unsigned char *s, seq_tv_t *out, int size, +static Term write_number(unsigned char *s, seq_tv_t *out, bool error_on USES_REGS) { - Term t; - yap_error_number erro = LOCAL_Error_TYPE; - int i = push_text_stack(); - t = Yap_StringToNumberTerm((char *) s, &out->enc, error_on); - pop_text_stack(i); - LOCAL_Error_TYPE = erro; - return t; + Term t; + yap_error_number erro = LOCAL_Error_TYPE; + int i = push_text_stack(); + t = Yap_StringToNumberTerm((char *)s, &out->enc, error_on); + pop_text_stack(i); + LOCAL_Error_TYPE = erro; + return t; } -static Term string_to_term(void *s, seq_tv_t *out, size_t leng USES_REGS) { - Term o; - yap_error_number erro = LOCAL_Error_TYPE; - o = out->val.t = Yap_BufferToTerm(s, strlen(s) + 1, TermNil); - LOCAL_Error_TYPE = erro; +static Term string_to_term(void *s, seq_tv_t *out USES_REGS) { + Term o; + yap_error_number erro = LOCAL_Error_TYPE; + o = out->val.t = Yap_BufferToTerm(s, TermNil); + LOCAL_Error_TYPE = erro; - return o; + return o; } -bool write_Text(unsigned char *inp, seq_tv_t *out, size_t leng USES_REGS) { - /* we know what the term is */ - if (out->type == 0) { - return true; +bool write_Text(unsigned char *inp, seq_tv_t *out USES_REGS) { + /* we know what the term is */ + if (out->type == 0) { + return true; + } + + if (out->type & YAP_STRING_DATUM) { + if ((out->val.t = string_to_term(inp, out PASS_REGS)) != 0L) + return out->val.t != 0; + } + if (out->type & (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) { + if ((out->val.t = write_number( + inp, out, !(out->type & YAP_STRING_ATOM) PASS_REGS)) != 0L) { + // Yap_DebugPlWriteln(out->val.t); + + return true; } - if (out->type & YAP_STRING_DATUM) { - if ((out->val.t = string_to_term(inp, out, leng PASS_REGS)) != 0L) - return out->val.t != 0; + if (!(out->type & YAP_STRING_ATOM)) + return false; + } + if (out->type & (YAP_STRING_ATOM)) { + if ((out->val.a = write_atom(inp, out PASS_REGS)) != NIL) { + Atom at = out->val.a; + if (at && (out->type & YAP_STRING_OUTPUT_TERM)) + out->val.t = MkAtomTerm(at); + // Yap_DebugPlWriteln(out->val.t); + return at != NIL; } - if (out->type & (YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG)) { - if ((out->val.t = write_number( - inp, out, leng, !(out->type & YAP_STRING_ATOM) PASS_REGS)) != 0L) { - // Yap_DebugPlWriteln(out->val.t); + } - return true; - } - - if (!(out->type & YAP_STRING_ATOM)) - return false; - } - if (out->type & (YAP_STRING_ATOM)) { - if ((out->val.a = write_atom(inp, out, leng PASS_REGS)) != NIL) { - Atom at = out->val.a; - if (at && (out->type & YAP_STRING_OUTPUT_TERM)) - out->val.t = MkAtomTerm(at); - // Yap_DebugPlWriteln(out->val.t); - return at != NIL; - } - } - - switch (out->type & YAP_TYPE_MASK) { - case YAP_STRING_CHARS: { - size_t room = write_buffer(inp, out, leng PASS_REGS); - // printf("%s\n", out->val.c); - return ((Int) room > 0); - } - case YAP_STRING_WCHARS: { - size_t room = write_buffer(inp, out, leng PASS_REGS); - // printf("%S\n", out->val.w); - return ((Int) room > 0); - } - case YAP_STRING_STRING: - out->val.t = write_strings(inp, out, leng PASS_REGS); - // Yap_DebugPlWriteln(out->val.t); - return out->val.t != 0; - case YAP_STRING_ATOMS: - out->val.t = write_atoms(inp, out, leng PASS_REGS); - // Yap_DebugPlWriteln(out->val.t); - return out->val.t != 0; - case YAP_STRING_CODES: - out->val.t = write_codes(inp, out, leng PASS_REGS); - // Yap_DebugPlWriteln(out->val.t); - return out->val.t != 0; - case YAP_STRING_LENGTH: - out->val.l = write_length(inp, out, leng PASS_REGS); - // printf("s\n",out->val.l); - return out->val.l != (size_t) (-1); - case YAP_STRING_ATOM: - out->val.a = write_atom(inp, out, leng PASS_REGS); - // Yap_DebugPlWriteln(out->val.t); - return out->val.a != NULL; - case YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG: - out->val.t = write_number(inp, out, leng, true PASS_REGS); - // Yap_DebugPlWriteln(out->val.t); - return out->val.t != 0; - default: { - return true; - } - } - return false; + switch (out->type & YAP_TYPE_MASK) { + case YAP_STRING_CHARS: { + size_t room = write_buffer(inp, out PASS_REGS); + // printf("%s\n", out->val.c); + return ((Int)room > 0); + } + case YAP_STRING_WCHARS: { + size_t room = write_buffer(inp, out PASS_REGS); + // printf("%S\n", out->val.w); + return ((Int)room > 0); + } + case YAP_STRING_STRING: + out->val.t = write_strings(inp, out PASS_REGS); + // Yap_DebugPlWriteln(out->val.t); + return out->val.t != 0; + case YAP_STRING_ATOMS: + out->val.t = write_atoms(inp, out PASS_REGS); + // Yap_DebugPlWriteln(out->val.t); + return out->val.t != 0; + case YAP_STRING_CODES: + out->val.t = write_codes(inp, out PASS_REGS); + // Yap_DebugPlWriteln(out->val.t); + return out->val.t != 0; + case YAP_STRING_LENGTH: + out->val.l = write_length(inp, out PASS_REGS); + // printf("s\n",out->val.l); + return out->val.l != (size_t)(-1); + case YAP_STRING_ATOM: + out->val.a = write_atom(inp, out PASS_REGS); + // Yap_DebugPlWriteln(out->val.t); + return out->val.a != NULL; + case YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG: + out->val.t = write_number(inp, out, true PASS_REGS); + // Yap_DebugPlWriteln(out->val.t); + return out->val.t != 0; + default: { return true; } + } + return false; } static size_t upcase(void *s0, seq_tv_t *out USES_REGS) { - unsigned char *s = s0; - while (*s) { - // assumes the two code have always the same size; - utf8proc_int32_t chr; - get_utf8(s, -1, &chr); - chr = utf8proc_toupper(chr); - s += put_utf8(s, chr); - } - return true; + unsigned char *s = s0; + while (*s) { + // assumes the two code have always the same size; + utf8proc_int32_t chr; + get_utf8(s, -1, &chr); + chr = utf8proc_toupper(chr); + s += put_utf8(s, chr); + } + return true; } static size_t downcase(void *s0, seq_tv_t *out USES_REGS) { - unsigned char *s = s0; - while (*s) { - // assumes the two code have always the same size; - utf8proc_int32_t chr; - get_utf8(s, -1, &chr); - chr = utf8proc_tolower(chr); - s += put_utf8(s, chr); - } - return true; + unsigned char *s = s0; + while (*s) { + // assumes the two code have always the same size; + utf8proc_int32_t chr; + get_utf8(s, -1, &chr); + chr = utf8proc_tolower(chr); + s += put_utf8(s, chr); + } + return true; } -bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) { - unsigned char *buf; - bool rc; - - size_t leng; - /* - f//printfmark(stderr, "[ %d ", n++) ; - if (inp->type & (YAP_STRING_TERM|YAP_STRING_ATOM|YAP_STRING_ATOMS_CODES - |YAP_STRING_STRING)) - //Yap_DebugPlWriteln(inp->val.t); - else if (inp->type & YAP_STRING_WCHARS) fprintf(stderr,"S %S\n", inp->val - .w); - else fprintf(stderr,"s %s\n", inp->val.c); - */ - // cnt++; - buf = Yap_readText(inp, &leng PASS_REGS); - if (!buf) { - return 0L; - } - if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { - if (out->max < leng) { - const unsigned char *ptr = skip_utf8(buf, out->max); - size_t diff = (ptr - buf); - char *nbuf = Malloc(diff + 1); - memcpy(nbuf, buf, diff); - nbuf[diff] = '\0'; - leng = diff; - } - // else if (out->type & YAP_STRING_NCHARS && - // const unsigned char *ptr = skip_utf8(buf, leng) +bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS) { + unsigned char *buf; + bool rc; + /* + f//printfmark(stderr, "[ %d ", n++) ; + if (inp->type & (YAP_STRING_TERM|YAP_STRING_ATOM|YAP_STRING_ATOMS_CODES + |YAP_STRING_STRING)) + //Yap_DebugPlWriteln(inp->val.t); + else if (inp->type & YAP_STRING_WCHARS) fprintf(stderr,"S %S\n", inp->val + .w); + else fprintf(stderr,"s %s\n", inp->val.c); + */ + // cnt++; + int l = push_text_stack(); + buf = Yap_readText(inp PASS_REGS); + if (!buf) { + pop_text_stack(l); + return 0L; + } + size_t leng = strlen_utf8(buf); + if (out->type & (YAP_STRING_NCHARS | YAP_STRING_TRUNC)) { + if (out->max < leng) { + const unsigned char *ptr = skip_utf8(buf, out->max); + size_t diff = (ptr - buf); + char *nbuf = Malloc(diff + 1); + memcpy(nbuf, buf, diff); + nbuf[diff] = '\0'; + leng = diff; } + // else if (out->type & YAP_STRING_NCHARS && + // const unsigned char *ptr = skip_utf8(buf) + } - if (out->type & (YAP_STRING_UPCASE | YAP_STRING_DOWNCASE)) { - if (out->type & YAP_STRING_UPCASE) { - if (!upcase(buf, out)) { - return false; - } - } - if (out->type & YAP_STRING_DOWNCASE) { - if (!downcase(buf, out)) { - return false; - } - } + if (out->type & (YAP_STRING_UPCASE | YAP_STRING_DOWNCASE)) { + if (out->type & YAP_STRING_UPCASE) { + if (!upcase(buf, out)) { + pop_text_stack(l); + return false; + } } + if (out->type & YAP_STRING_DOWNCASE) { + if (!downcase(buf, out)) { + pop_text_stack(l); + return false; + } + } + } - rc = write_Text(buf, out, leng PASS_REGS); - /* fprintf(stderr, " -> "); - if (!rc) fprintf(stderr, "NULL"); - else if (out->type & - (YAP_STRING_TERM|YAP_STRING_ATOMS_CODES - |YAP_STRING_STRING)) //Yap_DebugPlWrite(out->val.t); - else if (out->type & - YAP_STRING_ATOM) //Yap_DebugPlWriteln(MkAtomTerm(out->val.a)); - else if (out->type & YAP_STRING_WCHARS) fprintf(stderr, "%S", - out->val.w); - else - fprintf(stderr, "%s", out->val.c); - fprintf(stderr, "\n]\n"); */ - return rc; + rc = write_Text(buf, out PASS_REGS); + /* fprintf(stderr, " -> "); + if (!rc) fprintf(stderr, "NULL"); + else if (out->type & + (YAP_STRING_TERM|YAP_STRING_ATOMS_CODES + |YAP_STRING_STRING)) //Yap_DebugPlWrite(out->val.t); + else if (out->type & + YAP_STRING_ATOM) //Yap_DebugPlWriteln(MkAtomTerm(out->val.a)); + else if (out->type & YAP_STRING_WCHARS) fprintf(stderr, "%S", + out->val.w); + else + fprintf(stderr, "%s", out->val.c); + fprintf(stderr, "\n]\n"); */ + pop_text_stack(l); + return rc; } - static unsigned char *concat(int n, void *sv[] USES_REGS) { - void *buf; - unsigned char *buf0; - size_t room = 0; - int i; + void *buf; + unsigned char *buf0; + size_t room = 0; + int i; - for (i = 0; i < n; i++) { - room += strlen((char *) sv[i]); - } - buf = Malloc(room + 1); - buf0 = buf; - for (i = 0; i < n; i++) { + for (i = 0; i < n; i++) { + char *s = sv[i]; + if (s[0]) + room += strlen(s); + } + buf = Malloc(room + 1); + buf0 = buf; + for (i = 0; i < n; i++) { + char *s = sv[i]; + if (!s[0]) + continue; #if _WIN32 || defined(__ANDROID__) - strcpy(buf, sv[i]); - buf = (char *)buf + strlen(buf); + strcpy(buf, s); + buf = (char *)buf + strlen(buf); #else - buf = stpcpy(buf, sv[i]); + buf = stpcpy(buf, s); #endif - } - return buf0; + } + return buf0; } static void *slice(size_t min, size_t max, const unsigned char *buf USES_REGS) { - unsigned char *nbuf = Malloc((max - min) * 4 + 1); - const unsigned char *ptr = skip_utf8(buf, min); - unsigned char *nptr = nbuf; - utf8proc_int32_t chr; + unsigned char *nbuf = Malloc((max - min) * 4 + 1); + const unsigned char *ptr = skip_utf8(buf, min); + unsigned char *nptr = nbuf; + utf8proc_int32_t chr; - while (min++ < max) { - ptr += get_utf8(ptr, -1, &chr); - nptr += put_utf8(nptr, chr); - } - nptr[0] = '\0'; - return nbuf; + while (min++ < max) { + ptr += get_utf8(ptr, -1, &chr); + nptr += put_utf8(nptr, chr); + } + nptr[0] = '\0'; + return nbuf; } // // Out must be an atom or a string bool Yap_Concat_Text(int tot, seq_tv_t inp[], seq_tv_t *out USES_REGS) { - void **bufv; - unsigned char *buf; - int i; - size_t leng; + void **bufv; + unsigned char *buf; + int i, j; + bufv = Malloc(tot * sizeof(unsigned char *)); + if (!bufv) { + return NULL; + } + for (i = 0, j = 0; i < tot; i++) { + inp[j].type |= YAP_STRING_WITH_BUFFER; + unsigned char *nbuf = Yap_readText(inp + i PASS_REGS); - bufv = Malloc(tot * sizeof(unsigned char *)); - if (!bufv) { - return NULL; - } - for (i = 0; i < tot; i++) { - inp[i].type |= YAP_STRING_WITH_BUFFER; - unsigned char *nbuf = Yap_readText(inp + i, &leng PASS_REGS); - - if (!nbuf) { - return NULL; - } - bufv[i] = nbuf; + if (!nbuf) { + return NULL; } + if (!nbuf[0]) + continue; + bufv[j++] = nbuf; + } + if (j == 0) { + buf = malloc(8); + memset(buf, 0, 4); + } else if (j == 1) { + buf = bufv[0]; + } else { buf = concat(tot, bufv PASS_REGS); - bool rc = write_Text(buf, out, strlen_utf8(buf) PASS_REGS); + } + bool rc = write_Text(buf, out PASS_REGS); - return rc; + return rc; } // bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp, seq_tv_t outv[] USES_REGS) { - const unsigned char *buf; - size_t b_l, u_l; + const unsigned char *buf; + size_t b_l, u_l; - inp->type |= YAP_STRING_IN_TMP; - buf = Yap_readText(inp, &b_l PASS_REGS); - if (!buf) { - return false; - } - u_l = strlen_utf8(buf); - if (!cuts) { - if (n == 2) { - size_t b_l0, b_l1, u_l0, u_l1; - unsigned char *buf0, *buf1; + inp->type |= YAP_STRING_IN_TMP; + buf = Yap_readText(inp PASS_REGS); + if (!buf) { + return false; + } + b_l = strlen((char *)buf); + u_l = strlen_utf8(buf); + if (!cuts) { + if (n == 2) { + size_t b_l0, b_l1, u_l0, u_l1; + unsigned char *buf0, *buf1; - if (outv[0].val.t) { - buf0 = Yap_readText(outv, &b_l0 PASS_REGS); - if (!buf0) { - return false; - } - if (bcmp(buf, buf0, b_l0) != 0) { - return false; - } - u_l0 = strlen_utf8(buf0); - u_l1 = u_l - u_l0; - - buf1 = slice(u_l0, u_l, buf PASS_REGS); - b_l1 = strlen((const char *) buf1); - bool rc = write_Text(buf1, outv + 1, b_l1 PASS_REGS); - if (!rc) { - return false; - } - return rc; - } else /* if (outv[1].val.t) */ { - buf1 = Yap_readText(outv + 1, &b_l1 PASS_REGS); - if (!buf1) { - return false; - } - u_l1 = strlen_utf8(buf1); - b_l0 = b_l - b_l1; - u_l0 = u_l - u_l1; - if (bcmp(skip_utf8((const unsigned char *) buf, b_l0), buf1, b_l1) != - 0) { - return false; - } - buf0 = slice(0, u_l0, buf PASS_REGS); - bool rc = write_Text(buf0, outv, b_l0 PASS_REGS); - return rc; - } + if (outv[0].val.t) { + buf0 = Yap_readText(outv PASS_REGS); + if (!buf0) { + return false; } - } - int i, next; - for (i = 0; i < n; i++) { - if (i == 0) - next = 0; - else - next = cuts[i - 1]; - if (i > 0 && cuts[i] == 0) - break; - void *bufi = slice(next, cuts[i], buf PASS_REGS); - if (!write_Text(bufi, outv + i, strlen(bufi) PASS_REGS)) { - return false; + b_l0 = strlen((const char *)buf0); + if (bcmp(buf, buf0, b_l0) != 0) { + return false; } - } + u_l0 = strlen_utf8(buf0); + u_l1 = u_l - u_l0; - return true; + b_l1 = b_l - b_l0; + buf1 = slice(u_l0, u_l, buf PASS_REGS); + b_l1 = strlen((const char *)buf1); + bool rc = write_Text(buf1, outv + 1 PASS_REGS); + if (!rc) { + return false; + } + return rc; + } else /* if (outv[1].val.t) */ { + buf1 = Yap_readText(outv + 1 PASS_REGS); + if (!buf1) { + return false; + } + b_l1 = strlen((char *)buf1); + u_l1 = strlen_utf8(buf1); + b_l0 = b_l - b_l1; + u_l0 = u_l - u_l1; + if (bcmp(skip_utf8((const unsigned char *)buf, b_l0), buf1, b_l1) != + 0) { + return false; + } + buf0 = slice(0, u_l0, buf PASS_REGS); + bool rc = write_Text(buf0, outv PASS_REGS); + return rc; + } + } + } + int i, next; + for (i = 0; i < n; i++) { + if (i == 0) + next = 0; + else + next = cuts[i - 1]; + if (i > 0 && cuts[i] == 0) + break; + void *bufi = slice(next, cuts[i], buf PASS_REGS); + if (!write_Text(bufi, outv + i PASS_REGS)) { + return false; + } + } + + return true; } /** @@ -1063,28 +1047,27 @@ bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp, * @return the buffer, or NULL in case of failure. If so, Yap_Error may be called. */ -const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc) { - CACHE_REGS - seq_tv_t inp, out; - inp.val.t = t; - if (IsAtomTerm(t) && t != TermNil) { - inp.type = YAP_STRING_ATOM; - inp.enc = ENC_ISO_UTF8; - } else if (IsStringTerm(t)) { - inp.type = YAP_STRING_STRING; - inp.enc = ENC_ISO_UTF8; - } else if (IsPairOrNilTerm(t)) { - inp.type = (YAP_STRING_CODES | YAP_STRING_ATOMS); - } else { - Yap_Error(TYPE_ERROR_TEXT, t, NULL); - return false; - } - out.enc = enc; - out.type = YAP_STRING_CHARS; - out.val.c = buf; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return NULL; - return out.val.c; +const char *Yap_TextTermToText(Term t, char *buf, encoding_t enc USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t; + if (IsAtomTerm(t) && t != TermNil) { + inp.type = YAP_STRING_ATOM; + inp.enc = ENC_ISO_UTF8; + } else if (IsStringTerm(t)) { + inp.type = YAP_STRING_STRING; + inp.enc = ENC_ISO_UTF8; + } else if (IsPairOrNilTerm(t)) { + inp.type = (YAP_STRING_CODES | YAP_STRING_ATOMS); + } else { + Yap_Error(TYPE_ERROR_TEXT, t, NULL); + return false; + } + out.enc = enc; + out.type = YAP_STRING_CHARS; + out.val.c = buf; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return NULL; + return out.val.c; } /** @@ -1099,61 +1082,59 @@ const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc) { * @return the temporary string */ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) { - CACHE_REGS - Atom at; - arity_t arity = 0; - Functor f; - char *s, *smax, *s0; - s = s0 = malloc(1024); - smax = s + 1024; - Term tmod = ap->ModuleOfPred; - if (tmod) { - Yap_AtomToUTF8Text(AtomOfTerm(tmod), s); - s += strlen(s); - if (smax - s > 1) { - strcat(s, ":"); - } else { - return NULL; - } - s++; - } else { - if (smax - s > strlen("prolog:")) { - s = strcpy(s, "prolog:"); - } else { - return NULL; - } - } - // follows the actual functor - if (ap->ModuleOfPred == IDB_MODULE) { - if (ap->PredFlags & NumberDBPredFlag) { - Int key = ap->src.IndxId; - snprintf(s, smax - s, "%" - PRIdPTR, key); - return LOCAL_FileNameBuf; - } else if (ap->PredFlags & AtomDBPredFlag) { - at = (Atom) (ap->FunctorOfPred); - if (!Yap_AtomToUTF8Text(at, s)) - return NULL; - } else { - f = ap->FunctorOfPred; - at = NameOfFunctor(f); - arity = ArityOfFunctor(f); - } - } else { - arity = ap->ArityOfPE; - if (arity) { - at = NameOfFunctor(ap->FunctorOfPred); - } else { - at = (Atom) (ap->FunctorOfPred); - } - } - if (!Yap_AtomToUTF8Text(at, s)) { - return NULL; - } + CACHE_REGS + Atom at; + arity_t arity = 0; + Functor f; + char *s, *smax, *s0; + s = s0 = malloc(1024); + smax = s + 1024; + Term tmod = ap->ModuleOfPred; + if (tmod) { + Yap_AtomToUTF8Text(AtomOfTerm(tmod), s); s += strlen(s); - snprintf(s, smax - s, "/%" - PRIdPTR, arity); - return s0; + if (smax - s > 1) { + strcat(s, ":"); + } else { + return NULL; + } + s++; + } else { + if (smax - s > strlen("prolog:")) { + s = strcpy(s, "prolog:"); + } else { + return NULL; + } + } + // follows the actual functor + if (ap->ModuleOfPred == IDB_MODULE) { + if (ap->PredFlags & NumberDBPredFlag) { + Int key = ap->src.IndxId; + snprintf(s, smax - s, "%" PRIdPTR, key); + return LOCAL_FileNameBuf; + } else if (ap->PredFlags & AtomDBPredFlag) { + at = (Atom)(ap->FunctorOfPred); + if (!Yap_AtomToUTF8Text(at, s)) + return NULL; + } else { + f = ap->FunctorOfPred; + at = NameOfFunctor(f); + arity = ArityOfFunctor(f); + } + } else { + arity = ap->ArityOfPE; + if (arity) { + at = NameOfFunctor(ap->FunctorOfPred); + } else { + at = (Atom)(ap->FunctorOfPred); + } + } + if (!Yap_AtomToUTF8Text(at, s)) { + return NULL; + } + s += strlen(s); + snprintf(s, smax - s, "/%" PRIdPTR, arity); + return s0; } /** @@ -1165,14 +1146,13 @@ const char *Yap_PredIndicatorToUTF8String(PredEntry *ap) { * ≈ * @return the term */ -Term Yap_MkTextTerm(const char *s, encoding_t enc, Term tguide) { - CACHE_REGS - if (IsAtomTerm(tguide)) - return MkAtomTerm(Yap_LookupAtom(s)); - if (IsStringTerm(tguide)) - return MkStringTerm(s); - if (IsPairTerm(tguide) && IsAtomTerm(HeadOfTerm(tguide))) { - return Yap_CharsToListOfAtoms(s, enc PASS_REGS); - } - return Yap_CharsToListOfCodes(s, enc PASS_REGS); +Term Yap_MkTextTerm(const char *s, encoding_t enc, Term tguide USES_REGS) { + if (IsAtomTerm(tguide)) + return MkAtomTerm(Yap_LookupAtom(s)); + if (IsStringTerm(tguide)) + return MkStringTerm(s); + if (IsPairTerm(tguide) && IsAtomTerm(HeadOfTerm(tguide))) { + return Yap_CharsToListOfAtoms(s, enc PASS_REGS); + } + return Yap_CharsToListOfCodes(s, enc PASS_REGS); } diff --git a/C/tracer.c b/C/tracer.c index 0a606efca..c53b75de3 100644 --- a/C/tracer.c +++ b/C/tracer.c @@ -87,7 +87,7 @@ static char *send_tracer_message(char *start, char *name, arity_t arity, continue; } } - const char *sn = Yap_TermToString(args[i], NULL, LOCAL_encoding, + const char *sn = Yap_TermToString(args[i], LOCAL_encoding, Quote_illegal_f | Handle_vars_f); size_t sz; if (sn == NULL) { diff --git a/C/utilpreds.c b/C/utilpreds.c index 0f629a59f..121461c36 100644 --- a/C/utilpreds.c +++ b/C/utilpreds.c @@ -4585,6 +4585,9 @@ renumbervar(Term t, Int id USES_REGS) ts[1] = MkIntegerTerm(id); } +extern int vsc; + +int vsc; static Int numbervars_in_complex_term(register CELL *pt0, register CELL *pt0_end, Int numbv, int singles USES_REGS) { @@ -4604,6 +4607,7 @@ static Int numbervars_in_complex_term(register CELL *pt0, register CELL *pt0_end deref_head(d0, vars_in_term_unk); vars_in_term_nvar: { + vsc++; if (IsPairTerm(d0)) { if (to_visit + 1024 >= (CELL **)AuxSp) { goto aux_overflow; diff --git a/C/write.c b/C/write.c index 8b7841b50..d331f8108 100644 --- a/C/write.c +++ b/C/write.c @@ -390,7 +390,7 @@ int Yap_FormatFloat(Float f, char **s, size_t sz) { wglb.stream = GLOBAL_Stream + sno; wrputf(f, &wglb); so = Yap_MemExportStreamPtr(sno); - *s = Malloc( strlen(so) )+1; + *s = Malloc( strlen(so)+1 ); strcpy(*s, so ); Yap_CloseStream(sno); return true; @@ -398,884 +398,884 @@ int Yap_FormatFloat(Float f, char **s, size_t sz) { /* writes a data base reference */ static void wrputref(CODEADDR ref, int Quote_illegal, - struct write_globs *wglb) { - char s[256]; - wrf stream = wglb->stream; + struct write_globs *wglb) { + char s[256]; + wrf stream = wglb->stream; - putAtom(AtomDBref, Quote_illegal, wglb); + putAtom(AtomDBref, Quote_illegal, wglb); #if defined(__linux__) || defined(__APPLE__) - sprintf(s, "(%p," UInt_FORMAT ")", ref, ((LogUpdClause *)ref)->ClRefCount); + sprintf(s, "(%p," UInt_FORMAT ")", ref, ((LogUpdClause *)ref)->ClRefCount); #else - sprintf(s, "(0x%p," UInt_FORMAT ")", ref, ((LogUpdClause *)ref)->ClRefCount); + sprintf(s, "(0x%p," UInt_FORMAT ")", ref, ((LogUpdClause *)ref)->ClRefCount); #endif - wrputs(s, stream); - lastw = alphanum; -} - -/* writes a blob (default) */ -static int wrputblob(AtomEntry *ref, int Quote_illegal, - struct write_globs *wglb) { - wrf stream = wglb->stream; - int rc; - int Yap_write_blob(AtomEntry * ref, StreamDesc * stream); - - if ((rc = Yap_write_blob(ref, stream))) { - return rc; + wrputs(s, stream); + lastw = alphanum; } - lastw = alphanum; - return 1; -} -static int legalAtom(unsigned char *s) /* Is this a legal atom ? */ -{ - wchar_t ch = *s; + /* writes a blob (default) */ + static int wrputblob(AtomEntry *ref, int Quote_illegal, + struct write_globs *wglb) { + wrf stream = wglb->stream; + int rc; + int Yap_write_blob(AtomEntry * ref, StreamDesc * stream); - if (ch == '\0') - return FALSE; - if (Yap_chtype[ch] != LC) { - if (ch == '[') { - return (s[1] == ']' && !s[2]); - } else if (ch == '{') { - return (s[1] == '}' && !s[2]); - } else if (Yap_chtype[ch] == SL) { - return (!s[1]); - } else if (ch == '`') { - return false; - } else if ((ch == ',' || ch == '.') && !s[1]) { - return false; - } else { - if (ch == '/') { - if (s[1] == '*') - return false; + if ((rc = Yap_write_blob(ref, stream))) { + return rc; + } + lastw = alphanum; + return 1; + } + + static int legalAtom(unsigned char *s) /* Is this a legal atom ? */ + { + wchar_t ch = *s; + + if (ch == '\0') + return FALSE; + if (Yap_chtype[ch] != LC) { + if (ch == '[') { + return (s[1] == ']' && !s[2]); + } else if (ch == '{') { + return (s[1] == '}' && !s[2]); + } else if (Yap_chtype[ch] == SL) { + return (!s[1]); + } else if (ch == '`') { + return false; + } else if ((ch == ',' || ch == '.') && !s[1]) { + return false; + } else { + if (ch == '/') { + if (s[1] == '*') + return false; + } + while (ch) { + if (Yap_chtype[ch] != SY) { + return false; + } + ch = *++s; + } } - while (ch) { - if (Yap_chtype[ch] != SY) { - return false; - } - ch = *++s; + return true; + } else + while ((ch = *++s) != 0) + if (Yap_chtype[ch] > NU) + return false; + return true; + } + + static wtype + AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */ + { + int ch; + if (Yap_chtype[(int)s[0]] == SL && s[1] == '\0') + return (separator); + while ((ch = *s++) != '\0') { + if (Yap_chtype[ch] != SY) + return alphanum; + } + return symbol; + } + + static void write_quoted(wchar_t ch, wchar_t quote, wrf stream) { + CACHE_REGS + if (!(Yap_GetModuleEntry(CurrentModule)->flags & M_CHARESCAPE)) { + wrputc(ch, stream); + if (ch == '\'') + wrputc('\'', stream); /* be careful about quotes */ + return; + } + if (!(ch < 0xff && chtype(ch) == BS) && ch != '\'' && ch != '\\' && + ch != '`') { + wrputc(ch, stream); + } else { + switch (ch) { + case '\\': + wrputc('\\', stream); + wrputc('\\', stream); + break; + case '\'': + if (ch == quote) + wrputc('\\', stream); + wrputc(ch, stream); + break; + case '"': + if (ch == quote) + wrputc('\\', stream); + wrputc(ch, stream); + break; + case '`': + if (ch == quote) + wrputc('`', stream); + wrputc(ch, stream); + break; + case 7: + wrputc('\\', stream); + wrputc('a', stream); + break; + case '\b': + wrputc('\\', stream); + wrputc('b', stream); + break; + case '\t': + wrputc('\\', stream); + wrputc('t', stream); + break; + case ' ': + case 160: + wrputc(' ', stream); + break; + case '\n': + wrputc('\\', stream); + wrputc('n', stream); + break; + case 11: + wrputc('\\', stream); + wrputc('v', stream); + break; + case '\r': + wrputc('\\', stream); + wrputc('r', stream); + break; + case '\f': + wrputc('\\', stream); + wrputc('f', stream); + break; + default: + if (ch <= 0xff) { + char esc[8]; + + /* last backslash in ISO mode */ + sprintf(esc, "\\%03o\\", ch); + wrputs(esc, stream); + } } } - return true; - } else - while ((ch = *++s) != 0) - if (Yap_chtype[ch] > NU) - return false; - return true; -} - -static wtype -AtomIsSymbols(unsigned char *s) /* Is this atom just formed by symbols ? */ -{ - int ch; - if (Yap_chtype[(int)s[0]] == SL && s[1] == '\0') - return (separator); - while ((ch = *s++) != '\0') { - if (Yap_chtype[ch] != SY) - return alphanum; } - return symbol; -} -static void write_quoted(wchar_t ch, wchar_t quote, wrf stream) { - CACHE_REGS - if (!(Yap_GetModuleEntry(CurrentModule)->flags & M_CHARESCAPE)) { - wrputc(ch, stream); - if (ch == '\'') - wrputc('\'', stream); /* be careful about quotes */ + static void write_string(const unsigned char *s, + struct write_globs *wglb) /* writes an integer */ + { + StreamDesc *stream = wglb->stream; + utf8proc_int32_t chr, qt; + unsigned char *ptr = (unsigned char *)s; + + if (wglb->Write_strings) + qt = '`'; + else + qt = '"'; + wrputc(qt, stream); + do { + int delta; + ptr += (delta = get_utf8(ptr, -1, &chr) ); + + if (chr == '\0') { + break; + } + if (delta == 0) {chr = *ptr++; } + write_quoted(chr, qt, stream); + } while (true); + wrputc(qt, stream); + } + + /* writes an atom */ + static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) { + unsigned char *s; + wtype atom_or_symbol; + wrf stream = wglb->stream; + + if (IsBlob(atom)) { + wrputblob(RepAtom(atom), Quote_illegal, wglb); return; } - if (!(ch < 0xff && chtype(ch) == BS) && ch != '\'' && ch != '\\' && - ch != '`') { - wrputc(ch, stream); - } else { - switch (ch) { - case '\\': - wrputc('\\', stream); - wrputc('\\', stream); - break; - case '\'': - if (ch == quote) - wrputc('\\', stream); - wrputc(ch, stream); - break; - case '"': - if (ch == quote) - wrputc('\\', stream); - wrputc(ch, stream); - break; - case '`': - if (ch == quote) - wrputc('`', stream); - wrputc(ch, stream); - break; - case 7: - wrputc('\\', stream); - wrputc('a', stream); - break; - case '\b': - wrputc('\\', stream); - wrputc('b', stream); - break; - case '\t': - wrputc('\\', stream); - wrputc('t', stream); - break; - case ' ': - case 160: - wrputc(' ', stream); - break; - case '\n': - wrputc('\\', stream); - wrputc('n', stream); - break; - case 11: - wrputc('\\', stream); - wrputc('v', stream); - break; - case '\r': - wrputc('\\', stream); - wrputc('r', stream); - break; - case '\f': - wrputc('\\', stream); - wrputc('f', stream); - break; - default: - if (ch <= 0xff) { - char esc[8]; - - /* last backslash in ISO mode */ - sprintf(esc, "\\%03o\\", ch); - wrputs(esc, stream); - } - } - } -} - -static void write_string(const unsigned char *s, - struct write_globs *wglb) /* writes an integer */ -{ - StreamDesc *stream = wglb->stream; - utf8proc_int32_t chr, qt; - unsigned char *ptr = (unsigned char *)s; - - if (wglb->Write_strings) - qt = '`'; - else - qt = '"'; - wrputc(qt, stream); - do { - int delta; - ptr += (delta = get_utf8(ptr, -1, &chr) ); - - if (chr == '\0') { - break; - } - if (delta == 0) {chr = *ptr++; } - write_quoted(chr, qt, stream); - } while (true); - wrputc(qt, stream); -} - -/* writes an atom */ -static void putAtom(Atom atom, int Quote_illegal, struct write_globs *wglb) { - unsigned char *s; - wtype atom_or_symbol; - wrf stream = wglb->stream; - - if (IsBlob(atom)) { - wrputblob(RepAtom(atom), Quote_illegal, wglb); - return; - } - s = RepAtom(atom)->UStrOfAE; - /* #define CRYPT_FOR_STEVE 1*/ + s = RepAtom(atom)->UStrOfAE; + /* #define CRYPT_FOR_STEVE 1*/ #ifdef CRYPT_FOR_STEVE - if (Yap_GetValue(AtomCryptAtoms) != TermNil && - Yap_GetAProp(atom, OpProperty) == NIL) { - char s[16]; - sprintf(s, "x%x", (CELL)s); - wrputs(s, stream); - return; - } + if (Yap_GetValue(AtomCryptAtoms) != TermNil && + Yap_GetAProp(atom, OpProperty) == NIL) { + char s[16]; + sprintf(s, "x%x", (CELL)s); + wrputs(s, stream); + return; + } #endif - /* if symbol then last_minus is important */ - last_minus = FALSE; - atom_or_symbol = AtomIsSymbols(s); - if (lastw == atom_or_symbol && atom_or_symbol != separator /* solo */) - wrputc(' ', stream); - lastw = atom_or_symbol; - if (Quote_illegal && !legalAtom(s)) { - wrputc('\'', stream); - while (*s) { - int32_t ch; - s += get_utf8(s, -1, &ch); - write_quoted( ch, '\'', stream); - } - wrputc('\'', stream); - } else { - wrputs((char *)s, stream); - } -} - -void Yap_WriteAtom(StreamDesc *s, Atom atom) { - struct write_globs wglb; - wglb.stream = s; - wglb.Quote_illegal = FALSE; - putAtom(atom, 0, &wglb); -} - -static int IsCodesTerm(Term string) /* checks whether this is a string */ -{ - if (IsVarTerm(string)) - return FALSE; - do { - Term hd; - int ch; - - if (!IsPairTerm(string)) - return (FALSE); - hd = HeadOfTerm(string); - if (IsVarTerm(hd)) - return (FALSE); - if (!IsIntTerm(hd)) - return (FALSE); - ch = IntOfTerm(HeadOfTerm(string)); - if ((ch < ' ' || ch > MAX_ISO_LATIN1) && ch != '\n' && ch != '\t') - return (FALSE); - string = TailOfTerm(string); - if (IsVarTerm(string)) - return (FALSE); - } while (string != TermNil); - return (TRUE); -} - -/* writes a string */ -static void putString(Term string, struct write_globs *wglb) - -{ - wrf stream = wglb->stream; - wrputc('"', stream); - while (string != TermNil) { - wchar_t ch = IntOfTerm(HeadOfTerm(string)); - write_quoted(ch, '"', stream); - string = TailOfTerm(string); - } - wrputc('"', stream); - lastw = alphanum; -} - -/* writes a string */ -static void putUnquotedString(Term string, struct write_globs *wglb) - -{ - wrf stream = wglb->stream; - while (string != TermNil) { - int ch = IntOfTerm(HeadOfTerm(string)); - wrputc(ch, stream); - string = TailOfTerm(string); - } - lastw = alphanum; -} - -static Term from_pointer(CELL *ptr0, struct rewind_term *rwt, - struct write_globs *wglb) { - CACHE_REGS - Term t; - CELL *ptr = ptr0; - - while (IsVarTerm(*ptr) && !IsUnboundVar(ptr)) - ptr = (CELL *)*ptr; - t = *ptr; - if (wglb->Keep_terms) { - struct rewind_term *x = rwt->parent; - - rwt->u_sd.s.old = Yap_InitSlot(t); - rwt->u_sd.s.ptr = Yap_InitSlot((CELL)ptr0); - - if (!IsAtomicTerm(t) && !IsVarTerm(t)) { - while (x) { - if (Yap_GetDerefedFromSlot(x->u_sd.s.old) == t) - return TermFoundVar; - x = x->parent; + /* if symbol then last_minus is important */ + last_minus = FALSE; + atom_or_symbol = AtomIsSymbols(s); + if (lastw == atom_or_symbol && atom_or_symbol != separator /* solo */) + wrputc(' ', stream); + lastw = atom_or_symbol; + if (Quote_illegal && !legalAtom(s)) { + wrputc('\'', stream); + while (*s) { + int32_t ch; + s += get_utf8(s, -1, &ch); + write_quoted( ch, '\'', stream); } + wrputc('\'', stream); + } else { + wrputs((char *)s, stream); } - } else { - rwt->u_sd.d.old = t; - rwt->u_sd.d.ptr = ptr0; - if (!IsVarTerm(t) && !IsAtomicTerm(t)) { + } + + void Yap_WriteAtom(StreamDesc *s, Atom atom) { + struct write_globs wglb; + wglb.stream = s; + wglb.Quote_illegal = FALSE; + putAtom(atom, 0, &wglb); + } + + static int IsCodesTerm(Term string) /* checks whether this is a string */ + { + if (IsVarTerm(string)) + return FALSE; + do { + Term hd; + int ch; + + if (!IsPairTerm(string)) + return (FALSE); + hd = HeadOfTerm(string); + if (IsVarTerm(hd)) + return (FALSE); + if (!IsIntTerm(hd)) + return (FALSE); + ch = IntOfTerm(HeadOfTerm(string)); + if ((ch < ' ' || ch > MAX_ISO_LATIN1) && ch != '\n' && ch != '\t') + return (FALSE); + string = TailOfTerm(string); + if (IsVarTerm(string)) + return (FALSE); + } while (string != TermNil); + return (TRUE); + } + + /* writes a string */ + static void putString(Term string, struct write_globs *wglb) + + { + wrf stream = wglb->stream; + wrputc('"', stream); + while (string != TermNil) { + wchar_t ch = IntOfTerm(HeadOfTerm(string)); + write_quoted(ch, '"', stream); + string = TailOfTerm(string); + } + wrputc('"', stream); + lastw = alphanum; + } + + /* writes a string */ + static void putUnquotedString(Term string, struct write_globs *wglb) + + { + wrf stream = wglb->stream; + while (string != TermNil) { + int ch = IntOfTerm(HeadOfTerm(string)); + wrputc(ch, stream); + string = TailOfTerm(string); + } + lastw = alphanum; + } + + static Term from_pointer(CELL *ptr0, struct rewind_term *rwt, + struct write_globs *wglb) { + CACHE_REGS + Term t; + CELL *ptr = ptr0; + + while (IsVarTerm(*ptr) && !IsUnboundVar(ptr)) + ptr = (CELL *)*ptr; + t = *ptr; + if (wglb->Keep_terms) { struct rewind_term *x = rwt->parent; - while (x) { - if (x->u_sd.d.old == t) - return TermFoundVar; - x = x->parent; + rwt->u_sd.s.old = Yap_InitSlot(t); + rwt->u_sd.s.ptr = Yap_InitSlot((CELL)ptr0); + + if (!IsAtomicTerm(t) && !IsVarTerm(t)) { + while (x) { + if (Yap_GetDerefedFromSlot(x->u_sd.s.old) == t) + return TermFoundVar; + x = x->parent; + } + } + } else { + rwt->u_sd.d.old = t; + rwt->u_sd.d.ptr = ptr0; + if (!IsVarTerm(t) && !IsAtomicTerm(t)) { + struct rewind_term *x = rwt->parent; + + while (x) { + if (x->u_sd.d.old == t) + return TermFoundVar; + x = x->parent; + } } } + return t; } - return t; -} -static CELL *restore_from_write(struct rewind_term *rwt, - struct write_globs *wglb) { - CACHE_REGS - CELL *ptr; + static CELL *restore_from_write(struct rewind_term *rwt, + struct write_globs *wglb) { + CACHE_REGS + CELL *ptr; - if (wglb->Keep_terms) { - ptr = Yap_GetPtrFromSlot(rwt->u_sd.s.ptr); - Yap_RecoverSlots(2, rwt->u_sd.s.old); - // printf("leak=%d %d\n", LOCALCurSlot,rwt->u_sd.s.old) ; - } else { - ptr = rwt->u_sd.d.ptr; - } - rwt->u_sd.s.ptr = 0; - return ptr; -} - -/* writes an unbound variable */ -static void write_var(CELL *t, struct write_globs *wglb, - struct rewind_term *rwt) { - CACHE_REGS - if (lastw == alphanum) { - wrputc(' ', wglb->stream); - } - wrputc('_', wglb->stream); - /* make sure we don't get no creepy spaces where they shouldn't be */ - lastw = separator; - if (IsAttVar(t)) { - Int vcount = (t - H0); - if (wglb->Portray_delays) { - exts ext = ExtFromCell(t); - struct rewind_term nrwt; - nrwt.parent = rwt; - nrwt.u_sd.s.ptr = 0; - - wglb->Portray_delays = FALSE; - if (ext == attvars_ext) { - attvar_record *attv = RepAttVar(t); - CELL *l = &attv->Value; /* dirty low-level hack, check atts.h */ - - wrputs("$AT(", wglb->stream); - write_var(t, wglb, rwt); - wrputc(',', wglb->stream); - writeTerm(from_pointer(l, &nrwt, wglb), 999, 1, FALSE, wglb, &nrwt); - l = restore_from_write(&nrwt, wglb); - wrputc(',', wglb->stream); - l++; - writeTerm(from_pointer(l, &nrwt, wglb), 999, 1, FALSE, wglb, &nrwt); - restore_from_write(&nrwt, wglb); - wrclose_bracket(wglb, TRUE); - } - wglb->Portray_delays = TRUE; - return; - } - wrputc('D', wglb->stream); - wrputn(vcount, wglb); - } else { - wrputn(((Int)(t - H0)), wglb); - } -} - -static Term check_infinite_loop(Term t, struct rewind_term *x, - struct write_globs *wglb) { - CACHE_REGS if (wglb->Keep_terms) { - while (x) { - if (Yap_GetFromSlot(x->u_sd.s.old) == t) - return TermFoundVar; - x = x->parent; - } + ptr = Yap_GetPtrFromSlot(rwt->u_sd.s.ptr); + Yap_RecoverSlots(2, rwt->u_sd.s.old); + // printf("leak=%d %d\n", LOCALCurSlot,rwt->u_sd.s.old) ; } else { - while (x) { - if (x->u_sd.d.old == t) - return TermFoundVar; - x = x->parent; - } + ptr = rwt->u_sd.d.ptr; } - return t; -} + rwt->u_sd.s.ptr = 0; + return ptr; + } -static void write_list(Term t, int direction, int depth, - struct write_globs *wglb, struct rewind_term *rwt) { - Term ti; - struct rewind_term nrwt; - nrwt.parent = rwt; - nrwt.u_sd.s.ptr = 0; + /* writes an unbound variable */ + static void write_var(CELL *t, struct write_globs *wglb, + struct rewind_term *rwt) { + CACHE_REGS + if (lastw == alphanum) { + wrputc(' ', wglb->stream); + } + wrputc('_', wglb->stream); + /* make sure we don't get no creepy spaces where they shouldn't be */ + lastw = separator; + if (IsAttVar(t)) { + Int vcount = (t - H0); + if (wglb->Portray_delays) { + exts ext = ExtFromCell(t); + struct rewind_term nrwt; + nrwt.parent = rwt; + nrwt.u_sd.s.ptr = 0; - while (1) { - int ndirection; - int do_jump; + wglb->Portray_delays = FALSE; + if (ext == attvars_ext) { + attvar_record *attv = RepAttVar(t); + CELL *l = &attv->Value; /* dirty low-level hack, check atts.h */ - writeTerm(from_pointer(RepPair(t), &nrwt, wglb), 999, depth + 1, FALSE, - wglb, &nrwt); - t = AbsPair(restore_from_write(&nrwt, wglb)); - ti = TailOfTerm(t); - if (IsVarTerm(ti)) - break; - if (!IsPairTerm(ti) || - !IsPairTerm((ti = check_infinite_loop(ti, rwt, wglb)))) - break; - ndirection = RepPair(ti) - RepPair(t); - /* make sure we're not trapped in loops */ - if (ndirection > 0) { - do_jump = (direction <= 0); - } else if (ndirection == 0) { - wrputc(',', wglb->stream); - putAtom(AtomFoundVar, wglb->Quote_illegal, wglb); + wrputs("$AT(", wglb->stream); + write_var(t, wglb, rwt); + wrputc(',', wglb->stream); + writeTerm(from_pointer(l, &nrwt, wglb), 999, 1, FALSE, wglb, &nrwt); + l = restore_from_write(&nrwt, wglb); + wrputc(',', wglb->stream); + l++; + writeTerm(from_pointer(l, &nrwt, wglb), 999, 1, FALSE, wglb, &nrwt); + restore_from_write(&nrwt, wglb); + wrclose_bracket(wglb, TRUE); + } + wglb->Portray_delays = TRUE; + return; + } + wrputc('D', wglb->stream); + wrputn(vcount, wglb); + } else { + wrputn(((Int)(t - H0)), wglb); + } + } + + static Term check_infinite_loop(Term t, struct rewind_term *x, + struct write_globs *wglb) { + CACHE_REGS + if (wglb->Keep_terms) { + while (x) { + if (Yap_GetFromSlot(x->u_sd.s.old) == t) + return TermFoundVar; + x = x->parent; + } + } else { + while (x) { + if (x->u_sd.d.old == t) + return TermFoundVar; + x = x->parent; + } + } + return t; + } + + static void write_list(Term t, int direction, int depth, + struct write_globs *wglb, struct rewind_term *rwt) { + Term ti; + struct rewind_term nrwt; + nrwt.parent = rwt; + nrwt.u_sd.s.ptr = 0; + + while (1) { + int ndirection; + int do_jump; + + writeTerm(from_pointer(RepPair(t), &nrwt, wglb), 999, depth + 1, FALSE, + wglb, &nrwt); + t = AbsPair(restore_from_write(&nrwt, wglb)); + ti = TailOfTerm(t); + if (IsVarTerm(ti)) + break; + if (!IsPairTerm(ti) || + !IsPairTerm((ti = check_infinite_loop(ti, rwt, wglb)))) + break; + ndirection = RepPair(ti) - RepPair(t); + /* make sure we're not trapped in loops */ + if (ndirection > 0) { + do_jump = (direction <= 0); + } else if (ndirection == 0) { + wrputc(',', wglb->stream); + putAtom(AtomFoundVar, wglb->Quote_illegal, wglb); + lastw = separator; + return; + } else { + do_jump = (direction >= 0); + } + if (wglb->MaxDepth != 0 && depth > wglb->MaxDepth) { + if (lastw == symbol || lastw == separator) { + wrputc(' ', wglb->stream); + } + wrputc('|', wglb->stream); + putAtom(Atom3Dots, wglb->Quote_illegal, wglb); + return; + } lastw = separator; - return; - } else { - do_jump = (direction >= 0); + direction = ndirection; + depth++; + if (do_jump) + break; + wrputc(',', wglb->stream); + t = ti; } - if (wglb->MaxDepth != 0 && depth > wglb->MaxDepth) { + if (IsPairTerm(ti)) { + Term nt = from_pointer(RepPair(t) + 1, &nrwt, wglb); + /* we found an infinite loop */ + if (IsAtomTerm(nt)) { + if (lastw == symbol || lastw == separator) { + wrputc(' ', wglb->stream); + } + wrputc('|', wglb->stream); + writeTerm(nt, 999, depth, FALSE, wglb, rwt); + } else { + /* keep going on the list */ + wrputc(',', wglb->stream); + write_list(nt, direction, depth, wglb, &nrwt); + } + restore_from_write(&nrwt, wglb); + } else if (ti != MkAtomTerm(AtomNil)) { if (lastw == symbol || lastw == separator) { - wrputc(' ', wglb->stream); + wrputc(' ', wglb->stream); } wrputc('|', wglb->stream); + lastw = separator; + writeTerm(from_pointer(RepPair(t) + 1, &nrwt, wglb), 999, depth, FALSE, + wglb, &nrwt); + restore_from_write(&nrwt, wglb); + } + } + + static void writeTerm(Term t, int p, int depth, int rinfixarg, + struct write_globs *wglb, struct rewind_term *rwt) + /* term to write */ + /* context priority */ + + { + CACHE_REGS + struct rewind_term nrwt; + nrwt.parent = rwt; + nrwt.u_sd.s.ptr = 0; + + if (wglb->MaxDepth != 0 && depth > wglb->MaxDepth) { putAtom(Atom3Dots, wglb->Quote_illegal, wglb); return; } - lastw = separator; - direction = ndirection; - depth++; - if (do_jump) - break; - wrputc(',', wglb->stream); - t = ti; - } - if (IsPairTerm(ti)) { - Term nt = from_pointer(RepPair(t) + 1, &nrwt, wglb); - /* we found an infinite loop */ - if (IsAtomTerm(nt)) { - if (lastw == symbol || lastw == separator) { - wrputc(' ', wglb->stream); + DBTerm *ex; + Yap_ResetException(worker_id); + t = Deref(t); + if (IsVarTerm(t)) { + write_var((CELL *)t, wglb, &nrwt); + } else if (IsIntTerm(t)) { + + wrputn((Int)IntOfTerm(t), wglb); + } else if (IsAtomTerm(t)) { + putAtom(AtomOfTerm(t), wglb->Quote_illegal, wglb); + } else if (IsPairTerm(t)) { + if (wglb->Ignore_ops) { + wrputs("'.'(", wglb->stream); + lastw = separator; + + writeTerm(from_pointer(RepPair(t), &nrwt, wglb), 999, depth + 1, FALSE, + wglb, &nrwt); + t = AbsPair(restore_from_write(&nrwt, wglb)); + wrputs(",", wglb->stream); + writeTerm(from_pointer(RepPair(t) + 1, &nrwt, wglb), 999, depth + 1, + FALSE, wglb, &nrwt); + restore_from_write(&nrwt, wglb); + wrclose_bracket(wglb, TRUE); + return; } - wrputc('|', wglb->stream); - writeTerm(nt, 999, depth, FALSE, wglb, rwt); - } else { - /* keep going on the list */ - wrputc(',', wglb->stream); - write_list(nt, direction, depth, wglb, &nrwt); - } - restore_from_write(&nrwt, wglb); - } else if (ti != MkAtomTerm(AtomNil)) { - if (lastw == symbol || lastw == separator) { - wrputc(' ', wglb->stream); - } - wrputc('|', wglb->stream); - lastw = separator; - writeTerm(from_pointer(RepPair(t) + 1, &nrwt, wglb), 999, depth, FALSE, - wglb, &nrwt); - restore_from_write(&nrwt, wglb); - } -} - -static void writeTerm(Term t, int p, int depth, int rinfixarg, - struct write_globs *wglb, struct rewind_term *rwt) -/* term to write */ -/* context priority */ - -{ - CACHE_REGS - struct rewind_term nrwt; - nrwt.parent = rwt; - nrwt.u_sd.s.ptr = 0; - - if (wglb->MaxDepth != 0 && depth > wglb->MaxDepth) { - putAtom(Atom3Dots, wglb->Quote_illegal, wglb); - return; - } - DBTerm *ex; - Yap_ResetException(worker_id); - t = Deref(t); - if (IsVarTerm(t)) { - write_var((CELL *)t, wglb, &nrwt); - } else if (IsIntTerm(t)) { - - wrputn((Int)IntOfTerm(t), wglb); - } else if (IsAtomTerm(t)) { - putAtom(AtomOfTerm(t), wglb->Quote_illegal, wglb); - } else if (IsPairTerm(t)) { - if (wglb->Ignore_ops) { - wrputs("'.'(", wglb->stream); - lastw = separator; - - writeTerm(from_pointer(RepPair(t), &nrwt, wglb), 999, depth + 1, FALSE, - wglb, &nrwt); - t = AbsPair(restore_from_write(&nrwt, wglb)); - wrputs(",", wglb->stream); - writeTerm(from_pointer(RepPair(t) + 1, &nrwt, wglb), 999, depth + 1, - FALSE, wglb, &nrwt); - restore_from_write(&nrwt, wglb); - wrclose_bracket(wglb, TRUE); - return; - } - if (wglb->Use_portray) - if (callPortray(t, &ex, wglb->stream - GLOBAL_Stream PASS_REGS)) { - Yap_CopyException(ex); - Yap_RaiseException(); - return; + if (wglb->Use_portray) + if (callPortray(t, &ex, wglb->stream - GLOBAL_Stream PASS_REGS)) { + Yap_CopyException(ex); + Yap_RaiseException(); + return; + } + if (trueGlobalPrologFlag(WRITE_STRINGS_FLAG) && IsCodesTerm(t)) { + putString(t, wglb); + } else { + wrputc('[', wglb->stream); + lastw = separator; + /* we assume t was already saved in the stack */ + write_list(t, 0, depth, wglb, rwt); + wrputc(']', wglb->stream); + lastw = separator; } - if (trueGlobalPrologFlag(WRITE_STRINGS_FLAG) && IsCodesTerm(t)) { - putString(t, wglb); - } else { - wrputc('[', wglb->stream); - lastw = separator; - /* we assume t was already saved in the stack */ - write_list(t, 0, depth, wglb, rwt); - wrputc(']', wglb->stream); - lastw = separator; - } - } else { /* compound term */ - Functor functor = FunctorOfTerm(t); - int Arity; - Atom atom; - int op, lp, rp; + } else { /* compound term */ + Functor functor = FunctorOfTerm(t); + int Arity; + Atom atom; + int op, lp, rp; - if (IsExtensionFunctor(functor)) { - switch ((CELL)functor) { - case (CELL)FunctorDouble: - wrputf(FloatOfTerm(t), wglb); - return; - case (CELL)FunctorString: - write_string(UStringOfTerm(t), wglb); - return; - case (CELL)FunctorAttVar: - write_var(RepAppl(t) + 1, wglb, &nrwt); - return; - case (CELL)FunctorDBRef: - wrputref(RefOfTerm(t), wglb->Quote_illegal, wglb); - return; - case (CELL)FunctorLongInt: - wrputn(LongIntOfTerm(t), wglb); - return; - /* case (CELL)FunctorBigInt: */ - default: - writebig(t, p, depth, rinfixarg, wglb, rwt); - return; + if (IsExtensionFunctor(functor)) { + switch ((CELL)functor) { + case (CELL)FunctorDouble: + wrputf(FloatOfTerm(t), wglb); + return; + case (CELL)FunctorString: + write_string(UStringOfTerm(t), wglb); + return; + case (CELL)FunctorAttVar: + write_var(RepAppl(t) + 1, wglb, &nrwt); + return; + case (CELL)FunctorDBRef: + wrputref(RefOfTerm(t), wglb->Quote_illegal, wglb); + return; + case (CELL)FunctorLongInt: + wrputn(LongIntOfTerm(t), wglb); + return; + /* case (CELL)FunctorBigInt: */ + default: + writebig(t, p, depth, rinfixarg, wglb, rwt); + return; + } } - } - Arity = ArityOfFunctor(functor); - atom = NameOfFunctor(functor); + Arity = ArityOfFunctor(functor); + atom = NameOfFunctor(functor); #ifdef SFUNC - if (Arity == SFArity) { - int argno = 1; - CELL *p = ArgsOfSFTerm(t); - putAtom(atom, wglb->Quote_illegal, wglb); - wropen_bracket(wglb, FALSE); - lastw = separator; - while (*p) { - Int sl = 0; + if (Arity == SFArity) { + int argno = 1; + CELL *p = ArgsOfSFTerm(t); + putAtom(atom, wglb->Quote_illegal, wglb); + wropen_bracket(wglb, FALSE); + lastw = separator; + while (*p) { + Int sl = 0; - while (argno < *p) { - wrputc('_', wglb->stream), wrputc(',', wglb->stream); - ++argno; - } - *p++; - lastw = separator; - /* cannot use the term directly with the SBA */ - writeTerm(from_pointer(p, &nrwt, wglb), 999, depth + 1, FALSE, wglb, - &nrwt); - p = restore_from_write(&nrwt, wglb) + 1; - if (*p) - wrputc(',', wglb->stream); - argno++; + while (argno < *p) { + wrputc('_', wglb->stream), wrputc(',', wglb->stream); + ++argno; + } + *p++; + lastw = separator; + /* cannot use the term directly with the SBA */ + writeTerm(from_pointer(p, &nrwt, wglb), 999, depth + 1, FALSE, wglb, + &nrwt); + p = restore_from_write(&nrwt, wglb) + 1; + if (*p) + wrputc(',', wglb->stream); + argno++; + } + wrclose_bracket(wglb, TRUE); + return; } - wrclose_bracket(wglb, TRUE); - return; - } #endif - if (wglb->Use_portray) { - if (callPortray(t, &ex, wglb->stream - GLOBAL_Stream PASS_REGS)) { - Yap_CopyException(ex); - Yap_RaiseException(); - return; + if (wglb->Use_portray) { + if (callPortray(t, &ex, wglb->stream - GLOBAL_Stream PASS_REGS)) { + Yap_CopyException(ex); + Yap_RaiseException(); + return; + } } - } - if (!wglb->Ignore_ops && Arity == 1 && Yap_IsPrefixOp(atom, &op, &rp)) { - Term tright = ArgOfTerm(1, t); - int bracket_right = !IsVarTerm(tright) && IsAtomTerm(tright) && - Yap_IsOp(AtomOfTerm(tright)); - if (op > p) { - wropen_bracket(wglb, TRUE); - } - putAtom(atom, wglb->Quote_illegal, wglb); - if (bracket_right) { - /* avoid stuff such as \+ (a,b) being written as \+(a,b) */ - wropen_bracket(wglb, TRUE); - } else if (atom == AtomMinus) { - last_minus = TRUE; - } - writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), rp, depth + 1, TRUE, - wglb, &nrwt); - restore_from_write(&nrwt, wglb); - if (bracket_right) { - wrclose_bracket(wglb, TRUE); - } - if (op > p) { - wrclose_bracket(wglb, TRUE); - } - } else if (!wglb->Ignore_ops && - (Arity == 1 || - ((atom == AtomEmptyBrackets || atom == AtomCurly || - atom == AtomEmptySquareBrackets) && - Yap_IsListTerm(ArgOfTerm(1, t)))) && - Yap_IsPosfixOp(atom, &op, &lp)) { - Term tleft = ArgOfTerm(1, t); + if (!wglb->Ignore_ops && Arity == 1 && Yap_IsPrefixOp(atom, &op, &rp)) { + Term tright = ArgOfTerm(1, t); + int bracket_right = !IsVarTerm(tright) && IsAtomTerm(tright) && + Yap_IsOp(AtomOfTerm(tright)); + if (op > p) { + wropen_bracket(wglb, TRUE); + } + putAtom(atom, wglb->Quote_illegal, wglb); + if (bracket_right) { + /* avoid stuff such as \+ (a,b) being written as \+(a,b) */ + wropen_bracket(wglb, TRUE); + } else if (atom == AtomMinus) { + last_minus = TRUE; + } + writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), rp, depth + 1, TRUE, + wglb, &nrwt); + restore_from_write(&nrwt, wglb); + if (bracket_right) { + wrclose_bracket(wglb, TRUE); + } + if (op > p) { + wrclose_bracket(wglb, TRUE); + } + } else if (!wglb->Ignore_ops && + (Arity == 1 || + ((atom == AtomEmptyBrackets || atom == AtomCurly || + atom == AtomEmptySquareBrackets) && + Yap_IsListTerm(ArgOfTerm(1, t)))) && + Yap_IsPosfixOp(atom, &op, &lp)) { + Term tleft = ArgOfTerm(1, t); - int bracket_left, offset; + int bracket_left, offset; - if (Arity != 1) { - tleft = ArgOfTerm(1, t); - offset = 2; - } else { - tleft = ArgOfTerm(1, t); - offset = 1; - } - bracket_left = - !IsVarTerm(tleft) && IsAtomTerm(tleft) && Yap_IsOp(AtomOfTerm(tleft)); - if (op > p) { - /* avoid stuff such as \+ (a,b) being written as \+(a,b) */ - wropen_bracket(wglb, TRUE); - } - if (bracket_left) { - wropen_bracket(wglb, TRUE); - } - writeTerm(from_pointer(RepAppl(t) + offset, &nrwt, wglb), lp, depth + 1, - rinfixarg, wglb, &nrwt); - restore_from_write(&nrwt, wglb); - if (bracket_left) { - wrclose_bracket(wglb, TRUE); - } - if (Arity > 1) { - if (atom == AtomEmptyBrackets) { - wrputc('(', wglb->stream); - } else if (atom == AtomEmptySquareBrackets) { - wrputc('[', wglb->stream); - } else if (atom == AtomCurly) { - wrputc('{', wglb->stream); - } - lastw = separator; - write_list(tleft, 0, depth, wglb, rwt); - if (atom == AtomEmptyBrackets) { - wrputc(')', wglb->stream); - } else if (atom == AtomEmptySquareBrackets) { - wrputc(']', wglb->stream); - } else if (atom == AtomCurly) { - wrputc('}', wglb->stream); - } - lastw = separator; - } else { - putAtom(atom, wglb->Quote_illegal, wglb); - } - if (op > p) { - wrclose_bracket(wglb, TRUE); - } - } else if (!wglb->Ignore_ops && Arity == 2 && - Yap_IsInfixOp(atom, &op, &lp, &rp)) { - Term tleft = ArgOfTerm(1, t); - Term tright = ArgOfTerm(2, t); - int bracket_left = - !IsVarTerm(tleft) && IsAtomTerm(tleft) && Yap_IsOp(AtomOfTerm(tleft)); - int bracket_right = !IsVarTerm(tright) && IsAtomTerm(tright) && - Yap_IsOp(AtomOfTerm(tright)); + if (Arity != 1) { + tleft = ArgOfTerm(1, t); + offset = 2; + } else { + tleft = ArgOfTerm(1, t); + offset = 1; + } + bracket_left = + !IsVarTerm(tleft) && IsAtomTerm(tleft) && Yap_IsOp(AtomOfTerm(tleft)); + if (op > p) { + /* avoid stuff such as \+ (a,b) being written as \+(a,b) */ + wropen_bracket(wglb, TRUE); + } + if (bracket_left) { + wropen_bracket(wglb, TRUE); + } + writeTerm(from_pointer(RepAppl(t) + offset, &nrwt, wglb), lp, depth + 1, + rinfixarg, wglb, &nrwt); + restore_from_write(&nrwt, wglb); + if (bracket_left) { + wrclose_bracket(wglb, TRUE); + } + if (Arity > 1) { + if (atom == AtomEmptyBrackets) { + wrputc('(', wglb->stream); + } else if (atom == AtomEmptySquareBrackets) { + wrputc('[', wglb->stream); + } else if (atom == AtomCurly) { + wrputc('{', wglb->stream); + } + lastw = separator; + write_list(tleft, 0, depth, wglb, rwt); + if (atom == AtomEmptyBrackets) { + wrputc(')', wglb->stream); + } else if (atom == AtomEmptySquareBrackets) { + wrputc(']', wglb->stream); + } else if (atom == AtomCurly) { + wrputc('}', wglb->stream); + } + lastw = separator; + } else { + putAtom(atom, wglb->Quote_illegal, wglb); + } + if (op > p) { + wrclose_bracket(wglb, TRUE); + } + } else if (!wglb->Ignore_ops && Arity == 2 && + Yap_IsInfixOp(atom, &op, &lp, &rp)) { + Term tleft = ArgOfTerm(1, t); + Term tright = ArgOfTerm(2, t); + int bracket_left = + !IsVarTerm(tleft) && IsAtomTerm(tleft) && Yap_IsOp(AtomOfTerm(tleft)); + int bracket_right = !IsVarTerm(tright) && IsAtomTerm(tright) && + Yap_IsOp(AtomOfTerm(tright)); - if (op > p) { - /* avoid stuff such as \+ (a,b) being written as \+(a,b) */ - wropen_bracket(wglb, TRUE); - lastw = separator; - } - if (bracket_left) { - wropen_bracket(wglb, TRUE); - } - writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), lp, depth + 1, - rinfixarg, wglb, &nrwt); - t = AbsAppl(restore_from_write(&nrwt, wglb) - 1); - if (bracket_left) { - wrclose_bracket(wglb, TRUE); - } - /* avoid quoting commas and bars */ - if (!strcmp((char *)RepAtom(atom)->StrOfAE, ",")) { - wrputc(',', wglb->stream); - lastw = separator; - } else if (!strcmp((char *)RepAtom(atom)->StrOfAE, "|")) { - if (lastw == symbol || lastw == separator) { - wrputc(' ', wglb->stream); - } - wrputc('|', wglb->stream); - lastw = separator; - } else - putAtom(atom, wglb->Quote_illegal, wglb); - if (bracket_right) { - wropen_bracket(wglb, TRUE); - } - writeTerm(from_pointer(RepAppl(t) + 2, &nrwt, wglb), rp, depth + 1, TRUE, - wglb, &nrwt); - restore_from_write(&nrwt, wglb); - if (bracket_right) { - wrclose_bracket(wglb, TRUE); - } - if (op > p) { - wrclose_bracket(wglb, TRUE); - } - } else if (functor == FunctorDollarVar) { - Term ti = ArgOfTerm(1, t); - if (lastw == alphanum) { - wrputc(' ', wglb->stream); - } - if (wglb->Handle_vars && !IsVarTerm(ti) && - (IsIntTerm(ti) || IsCodesTerm(ti) || IsAtomTerm(ti) || - IsStringTerm(ti))) { - if (IsIntTerm(ti)) { - Int k = IntOfTerm(ti); - if (k == -1) { - wrputc('_', wglb->stream); - lastw = alphanum; - return; - } else { - wrputc((k % 26) + 'A', wglb->stream); - if (k >= 26) { - /* make sure we don't get confused about our context */ - lastw = separator; - wrputn(k / 26, wglb); - } else - lastw = alphanum; - } - } else if (IsAtomTerm(ti)) { - putAtom(AtomOfTerm(ti), FALSE, wglb); - } else if (IsStringTerm(ti)) { - putString(ti, wglb); - } else { - putUnquotedString(ti, wglb); - } + if (op > p) { + /* avoid stuff such as \+ (a,b) being written as \+(a,b) */ + wropen_bracket(wglb, TRUE); + lastw = separator; + } + if (bracket_left) { + wropen_bracket(wglb, TRUE); + } + writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), lp, depth + 1, + rinfixarg, wglb, &nrwt); + t = AbsAppl(restore_from_write(&nrwt, wglb) - 1); + if (bracket_left) { + wrclose_bracket(wglb, TRUE); + } + /* avoid quoting commas and bars */ + if (!strcmp((char *)RepAtom(atom)->StrOfAE, ",")) { + wrputc(',', wglb->stream); + lastw = separator; + } else if (!strcmp((char *)RepAtom(atom)->StrOfAE, "|")) { + if (lastw == symbol || lastw == separator) { + wrputc(' ', wglb->stream); + } + wrputc('|', wglb->stream); + lastw = separator; + } else + putAtom(atom, wglb->Quote_illegal, wglb); + if (bracket_right) { + wropen_bracket(wglb, TRUE); + } + writeTerm(from_pointer(RepAppl(t) + 2, &nrwt, wglb), rp, depth + 1, TRUE, + wglb, &nrwt); + restore_from_write(&nrwt, wglb); + if (bracket_right) { + wrclose_bracket(wglb, TRUE); + } + if (op > p) { + wrclose_bracket(wglb, TRUE); + } + } else if (functor == FunctorDollarVar) { + Term ti = ArgOfTerm(1, t); + if (lastw == alphanum) { + wrputc(' ', wglb->stream); + } + if (wglb->Handle_vars && !IsVarTerm(ti) && + (IsIntTerm(ti) || IsCodesTerm(ti) || IsAtomTerm(ti) || + IsStringTerm(ti))) { + if (IsIntTerm(ti)) { + Int k = IntOfTerm(ti); + if (k == -1) { + wrputc('_', wglb->stream); + lastw = alphanum; + return; + } else { + wrputc((k % 26) + 'A', wglb->stream); + if (k >= 26) { + /* make sure we don't get confused about our context */ + lastw = separator; + wrputn(k / 26, wglb); + } else + lastw = alphanum; + } + } else if (IsAtomTerm(ti)) { + putAtom(AtomOfTerm(ti), FALSE, wglb); + } else if (IsStringTerm(ti)) { + putString(ti, wglb); + } else { + putUnquotedString(ti, wglb); + } + } else { + wrputs("'$VAR'(", wglb->stream); + lastw = separator; + writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), 999, depth + 1, + FALSE, wglb, &nrwt); + restore_from_write(&nrwt, wglb); + wrclose_bracket(wglb, TRUE); + } + } else if (!wglb->Ignore_ops && functor == FunctorBraces) { + wrputc('{', wglb->stream); + lastw = separator; + writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), GLOBAL_MaxPriority, + depth + 1, FALSE, wglb, &nrwt); + restore_from_write(&nrwt, wglb); + wrputc('}', wglb->stream); + lastw = separator; + } else if (atom == AtomArray) { + wrputc('{', wglb->stream); + lastw = separator; + for (op = 1; op <= Arity; ++op) { + if (op == wglb->MaxArgs) { + wrputs("...", wglb->stream); + break; + } + writeTerm(from_pointer(RepAppl(t) + op, &nrwt, wglb), 999, depth + 1, + FALSE, wglb, &nrwt); + t = AbsAppl(restore_from_write(&nrwt, wglb) - op); + if (op != Arity) { + wrputc(',', wglb->stream); + lastw = separator; + } + } + wrputc('}', wglb->stream); + lastw = separator; } else { - wrputs("'$VAR'(", wglb->stream); - lastw = separator; - writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), 999, depth + 1, - FALSE, wglb, &nrwt); - restore_from_write(&nrwt, wglb); - wrclose_bracket(wglb, TRUE); + putAtom(atom, wglb->Quote_illegal, wglb); + lastw = separator; + wropen_bracket(wglb, FALSE); + for (op = 1; op <= Arity; ++op) { + if (op == wglb->MaxArgs) { + wrputc('.', wglb->stream); + wrputc('.', wglb->stream); + wrputc('.', wglb->stream); + break; + } + writeTerm(from_pointer(RepAppl(t) + op, &nrwt, wglb), 999, depth + 1, + FALSE, wglb, &nrwt); + restore_from_write(&nrwt, wglb); + if (op != Arity) { + wrputc(',', wglb->stream); + lastw = separator; + } + } + wrclose_bracket(wglb, TRUE); } - } else if (!wglb->Ignore_ops && functor == FunctorBraces) { - wrputc('{', wglb->stream); - lastw = separator; - writeTerm(from_pointer(RepAppl(t) + 1, &nrwt, wglb), GLOBAL_MaxPriority, - depth + 1, FALSE, wglb, &nrwt); - restore_from_write(&nrwt, wglb); - wrputc('}', wglb->stream); - lastw = separator; - } else if (atom == AtomArray) { - wrputc('{', wglb->stream); - lastw = separator; - for (op = 1; op <= Arity; ++op) { - if (op == wglb->MaxArgs) { - wrputs("...", wglb->stream); - break; - } - writeTerm(from_pointer(RepAppl(t) + op, &nrwt, wglb), 999, depth + 1, - FALSE, wglb, &nrwt); - t = AbsAppl(restore_from_write(&nrwt, wglb) - op); - if (op != Arity) { - wrputc(',', wglb->stream); - lastw = separator; - } - } - wrputc('}', wglb->stream); - lastw = separator; - } else { - putAtom(atom, wglb->Quote_illegal, wglb); - lastw = separator; - wropen_bracket(wglb, FALSE); - for (op = 1; op <= Arity; ++op) { - if (op == wglb->MaxArgs) { - wrputc('.', wglb->stream); - wrputc('.', wglb->stream); - wrputc('.', wglb->stream); - break; - } - writeTerm(from_pointer(RepAppl(t) + op, &nrwt, wglb), 999, depth + 1, - FALSE, wglb, &nrwt); - restore_from_write(&nrwt, wglb); - if (op != Arity) { - wrputc(',', wglb->stream); - lastw = separator; - } - } - wrclose_bracket(wglb, TRUE); } } -} -void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags, - int priority) -/* term to be written */ -/* consumer */ -/* write options */ -{ - CACHE_REGS - struct write_globs wglb; - struct rewind_term rwt; - yhandle_t sls = Yap_CurrentSlot(); - - if (!mywrite) { + void Yap_plwrite(Term t, StreamDesc *mywrite, int max_depth, int flags, + int priority) + /* term to be written */ + /* consumer */ + /* write options */ + { CACHE_REGS - wglb.stream = GLOBAL_Stream + LOCAL_c_error_stream; - } else - wglb.stream = mywrite; - wglb.lw = start; - wglb.last_atom_minus = FALSE; - wglb.Quote_illegal = flags & Quote_illegal_f; - wglb.Handle_vars = flags & Handle_vars_f; - wglb.Use_portray = flags & Use_portray_f; - wglb.Portray_delays = flags & AttVar_Portray_f; - wglb.MaxDepth = max_depth; - wglb.MaxArgs = max_depth; - /* notice: we must have ASP well set when using portray, otherwise - we cannot make recursive Prolog calls */ - wglb.Keep_terms = (flags & (Use_portray_f | To_heap_f)); - /* initialize wglb */ - rwt.parent = NULL; - wglb.Ignore_ops = flags & Ignore_ops_f; - wglb.Write_strings = flags & BackQuote_String_f; - /* protect slots for portray */ - writeTerm(from_pointer(&t, &rwt, &wglb), priority, 1, FALSE, &wglb, &rwt); - if (flags & New_Line_f) { - if (flags & Fullstop_f) { - wrputc('.', wglb.stream); - wrputc('\n', wglb.stream); + struct write_globs wglb; + struct rewind_term rwt; + yhandle_t sls = Yap_CurrentSlot(); + + if (!mywrite) { + CACHE_REGS + wglb.stream = GLOBAL_Stream + LOCAL_c_error_stream; + } else + wglb.stream = mywrite; + wglb.lw = start; + wglb.last_atom_minus = FALSE; + wglb.Quote_illegal = flags & Quote_illegal_f; + wglb.Handle_vars = flags & Handle_vars_f; + wglb.Use_portray = flags & Use_portray_f; + wglb.Portray_delays = flags & AttVar_Portray_f; + wglb.MaxDepth = max_depth; + wglb.MaxArgs = max_depth; + /* notice: we must have ASP well set when using portray, otherwise + we cannot make recursive Prolog calls */ + wglb.Keep_terms = (flags & (Use_portray_f | To_heap_f)); + /* initialize wglb */ + rwt.parent = NULL; + wglb.Ignore_ops = flags & Ignore_ops_f; + wglb.Write_strings = flags & BackQuote_String_f; + /* protect slots for portray */ + writeTerm(from_pointer(&t, &rwt, &wglb), priority, 1, FALSE, &wglb, &rwt); + if (flags & New_Line_f) { + if (flags & Fullstop_f) { + wrputc('.', wglb.stream); + wrputc('\n', wglb.stream); + } else { + wrputc('\n', wglb.stream); + } } else { - wrputc('\n', wglb.stream); - } - } else { - if (flags & Fullstop_f) { - wrputc('.', wglb.stream); - wrputc(' ', wglb.stream); + if (flags & Fullstop_f) { + wrputc('.', wglb.stream); + wrputc(' ', wglb.stream); + } } + restore_from_write(&rwt, &wglb); + Yap_CloseSlots(sls); } - restore_from_write(&rwt, &wglb); - Yap_CloseSlots(sls); -} -char *Yap_TermToString(Term t, size_t *lengthp, encoding_t enc, int flags) { - CACHE_REGS - int sno = Yap_open_buf_write_stream(enc, flags); - const char *sf; - DBTerm *e = LOCAL_BallTerm; + char *Yap_TermToString(Term t, encoding_t enc, int flags) { + CACHE_REGS + int sno = Yap_open_buf_write_stream(enc, flags); + const char *sf; + DBTerm *e = LOCAL_BallTerm; - if (sno < 0) - return NULL; - LOCAL_c_output_stream = sno; - if (enc) - GLOBAL_Stream[sno].encoding = enc; - else - GLOBAL_Stream[sno].encoding = LOCAL_encoding; - Yap_plwrite(t, GLOBAL_Stream + sno, 0, flags, GLOBAL_MaxPriority); + if (sno < 0) + return NULL; + LOCAL_c_output_stream = sno; + if (enc) + GLOBAL_Stream[sno].encoding = enc; + else + GLOBAL_Stream[sno].encoding = LOCAL_encoding; + Yap_plwrite(t, GLOBAL_Stream + sno, 0, flags, GLOBAL_MaxPriority); - sf = Yap_MemExportStreamPtr(sno); - size_t len = strlen(sf); - char *new = malloc( len + 1 ); - strcpy( new, sf ); - Yap_CloseStream(sno); - if (e) - LOCAL_BallTerm = e; - return new; -} + sf = Yap_MemExportStreamPtr(sno); + size_t len = strlen(sf); + char *new = malloc( len + 1 ); + strcpy( new, sf ); + Yap_CloseStream(sno); + if (e) + LOCAL_BallTerm = e; + return new; + } diff --git a/CXX/yapi.cpp b/CXX/yapi.cpp index ab3aedbb0..4d7c41852 100644 --- a/CXX/yapi.cpp +++ b/CXX/yapi.cpp @@ -12,18 +12,18 @@ extern "C" { #include "YapInterface.h" #include "blobs.h" -X_API char *Yap_TermToString(Term t, size_t *length, encoding_t encodingp, +X_API char *Yap_TermToString(Term t, encoding_t encodingp, int flags); -X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, arity_t arity); -X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t, - YAP_Term); -X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred, - arity_t, arity_t); + X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, arity_t arity); + X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t, + YAP_Term); + X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred, + arity_t, arity_t); - #if YAP_PYTHON +#if YAP_PYTHON X_API bool do_init_python(void); - #endif +#endif } diff --git a/CXX/yapt.hh b/CXX/yapt.hh index 520270166..e97132148 100644 --- a/CXX/yapt.hh +++ b/CXX/yapt.hh @@ -226,18 +226,17 @@ public: /// return a string with a textual representation of the term virtual const char *text() { CACHE_REGS - size_t length = 0; encoding_t enc = LOCAL_encoding; char *os; BACKUP_MACHINE_REGS(); - if (!(os = Yap_TermToString(Yap_GetFromSlot(t), &length, enc, + if (!(os = Yap_TermToString(Yap_GetFromSlot(t), enc, Handle_vars_f))) { RECOVER_MACHINE_REGS(); return 0; } RECOVER_MACHINE_REGS(); - length = strlen(os) + 1; + size_t length = strlen(os); char *sm = (char *)malloc(length + 1); strcpy(sm, os); return sm; diff --git a/H/YapText.h b/H/YapText.h index bb6f268ae..065d6bf40 100644 --- a/H/YapText.h +++ b/H/YapText.h @@ -1,19 +1,19 @@ /************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * -* * -************************************************************************** -* * -* File: YapMirror.c * -* Last rev: 5/2/88 * -* mods: * -* comments: Term conversion C implemented support * -* * -*************************************************************************/ + * * + * YAP Prolog * + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * + * * + ************************************************************************** + * * + * File: YapMirror.c * + * Last rev: 5/2/88 * + * mods: * + * comments: Term conversion C implemented support * + * * + *************************************************************************/ #ifndef YAP_TEXT_H #define YAP_TEXT_H @@ -31,22 +31,21 @@ #include "../utf8proc/utf8proc.h" #include "Yap.h" -#define ReleaseAndReturn(r) \ - { \ - pop_text_stack(l); \ - return r; \ +#define ReleaseAndReturn(r) \ + { \ + pop_text_stack(l); \ + return r; \ } -#define release_cut_fail() \ - { \ - pop_text_stack(l); \ - cut_fail(); \ - } -#define release_cut_succeed() \ - { \ - pop_text_stack(l); \ - cut_succeed(); \ +#define release_cut_fail() \ + { \ + pop_text_stack(l); \ + cut_fail(); \ + } +#define release_cut_succeed() \ + { \ + pop_text_stack(l); \ + cut_succeed(); \ } - /// allocate a temporary text block /// @@ -56,8 +55,7 @@ extern void Free(void *buf USES_REGS); extern int push_text_stack(USES_REGS1); extern int pop_text_stack(int lvl USES_REGS); -extern void *protected_pop_text_stack(int lvl, void *safe, bool tmp, - size_t sz USES_REGS); +extern void *export_block(int lvl, void *exp USES_REGS); #ifndef Yap_Min #define Yap_Min(x, y) (x < y ? x : y) @@ -187,8 +185,10 @@ INLINE_ONLY inline EXTERN utf8proc_ssize_t get_utf8(const utf8proc_uint8_t *ptr, utf8proc_int32_t *valp) { utf8proc_ssize_t rc = utf8proc_iterate(ptr, n, valp); if (rc < 0) { - if (rc == UTF8PROC_ERROR_INVALIDUTF8) Yap_Warning("get_utf8 found bad UTF-8 char %s, skipping...", ptr); - else Yap_Warning("UTF-8 error %d, skipping...", *ptr); + if (rc == UTF8PROC_ERROR_INVALIDUTF8) + Yap_Warning("get_utf8 found bad UTF-8 char %s, skipping...", ptr); + else + Yap_Warning("UTF-8 error %d, skipping...", *ptr); rc = 1; } return rc; @@ -200,7 +200,8 @@ INLINE_ONLY inline EXTERN utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr, INLINE_ONLY inline EXTERN utf8proc_ssize_t put_utf8(utf8proc_uint8_t *ptr, utf8proc_int32_t val) { utf8proc_ssize_t rc = utf8proc_encode_char(val, ptr); - if (rc == 0) Yap_Warning("UTF-8 error at %s", ptr); + if (rc == 0) + Yap_Warning("UTF-8 error at %s", ptr); return rc; } @@ -213,8 +214,11 @@ inline static const utf8proc_uint8_t *skip_utf8(const utf8proc_uint8_t *pt, if (b == 0) return pt; if (l < 0) { - if (l == UTF8PROC_ERROR_INVALIDUTF8) Yap_Warning("skip_utf8: found bad UTF-8 in char %s[%d], skipping...", pt, i); - else Yap_Warning("UTF-8 error %d at %s[%d], skipping...", l,pt,i); + if (l == UTF8PROC_ERROR_INVALIDUTF8) + Yap_Warning("skip_utf8: found bad UTF-8 in char %s[%d], skipping...", + pt, i); + else + Yap_Warning("UTF-8 error %d at %s[%d], skipping...", l, pt, i); l = 1; } pt += l; @@ -237,8 +241,10 @@ inline static utf8proc_ssize_t strlen_utf8(const utf8proc_uint8_t *pt) { pt += l; rc++; } else { - if (l == UTF8PROC_ERROR_INVALIDUTF8) Yap_Warning("found bad UTF-8 char %d, skipping %s...", *pt, pt); - else Yap_Warning("UTF-8 error %d, skipping...", l); + if (l == UTF8PROC_ERROR_INVALIDUTF8) + Yap_Warning("found bad UTF-8 char %d, skipping %s...", *pt, pt); + else + Yap_Warning("UTF-8 error %d, skipping...", l); pt++; } } @@ -451,9 +457,8 @@ static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) { // the routines -extern unsigned char *Yap_readText(seq_tv_t *inp, size_t *lengp USES_REGS); -extern bool write_Text(unsigned char *inp, seq_tv_t *out, - size_t leng USES_REGS); +extern unsigned char *Yap_readText(seq_tv_t *inp USES_REGS); +extern bool write_Text(unsigned char *inp, seq_tv_t *out USES_REGS); extern bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS); extern bool Yap_Concat_Text(int n, seq_tv_t inp[], seq_tv_t *out USES_REGS); extern bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp, @@ -563,7 +568,7 @@ static inline size_t Yap_AtomicToUnicodeLength(Term t0 USES_REGS) { inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS | YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_CHARS|YAP_STRING_OUTPUT_TERM; + out.type = YAP_STRING_CHARS | YAP_STRING_OUTPUT_TERM; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return strlen_utf8(out.val.uc0); @@ -605,1029 +610,1031 @@ static inline Atom Yap_AtomicToAtom(Term t0 USES_REGS) { } static inline size_t Yap_AtomToLength(Term t0 USES_REGS) { - if (!IsAtomTerm(t0)) { - return -TYPE_ERROR_ATOM; - } - return strlen(RepAtom(AtomOfTerm(t0))->StrOfAE); + if (!IsAtomTerm(t0)) { + return -TYPE_ERROR_ATOM; + } + return strlen(RepAtom(AtomOfTerm(t0))->StrOfAE); } - static inline size_t Yap_AtomToUnicodeLength(Term t0 USES_REGS) { - if (!IsAtomTerm(t0)) { - return -TYPE_ERROR_ATOM; - } - return strlen_utf8(RepAtom(AtomOfTerm(t0))->UStrOfAE); - } - - static inline Term Yap_AtomToListOfAtoms(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_ATOM; - out.val.uc = NULL; - out.type = YAP_STRING_ATOMS; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_AtomSWIToListOfAtoms(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | - YAP_STRING_TERM; - out.val.uc = NULL; - out.type = YAP_STRING_ATOMS; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_AtomToListOfCodes(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_ATOM; - out.val.uc = NULL; - out.type = YAP_STRING_CODES; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_AtomToNumber(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_ATOM; - out.val.uc = NULL; - out.enc = ENC_ISO_UTF8; - out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_AtomToString(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_ATOM; - out.val.uc = NULL; - out.type = YAP_STRING_STRING; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_AtomSWIToString(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES; - out.val.uc = NULL; - out.type = YAP_STRING_STRING; - out.enc = ENC_ISO_UTF8; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_AtomicToString(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.val.uc = NULL; - out.type = YAP_STRING_STRING; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_AtomicToTDQ(Term t0, Term mod USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.val.uc = NULL; - out.type = mod_to_type(mod PASS_REGS); - out.enc = ENC_ISO_UTF8; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline wchar_t *Yap_AtomToWide(Atom at USES_REGS) { - seq_tv_t inp, out; - inp.val.a = at; - inp.type = YAP_STRING_ATOM; - out.val.uc = NULL; - out.type = YAP_STRING_WCHARS; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return NIL; - return out.val.w; - } - - static inline Term Yap_AtomicToTBQ(Term t0, Term mod USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.val.uc = NULL; - out.type = mod_to_bqtype(mod PASS_REGS); - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_CharsToAtom(const char *s, encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.enc = enc; - inp.type = YAP_STRING_CHARS; - out.val.uc = NULL; - out.type = YAP_STRING_ATOM; - out.enc = ENC_ISO_UTF8; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline Term Yap_CharsToListOfAtoms(const char *s, - encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.enc = enc; - inp.type = YAP_STRING_CHARS; - out.val.uc = NULL; - out.type = YAP_STRING_ATOMS; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_CharsToListOfCodes(const char *s, - encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.enc = enc; - inp.type = YAP_STRING_CHARS; - out.val.uc = NULL; - out.type = YAP_STRING_CODES; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_UTF8ToListOfCodes(const char *s USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.type = YAP_STRING_CHARS; - inp.enc = ENC_ISO_UTF8; - out.type = YAP_STRING_CODES; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_UTF8ToAtom(const unsigned char *s USES_REGS) { - seq_tv_t inp, out; - - inp.val.uc0 = s; - inp.type = YAP_STRING_CHARS; - inp.enc = ENC_ISO_UTF8; - out.type = YAP_STRING_ATOM; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline Term Yap_CharsToDiffListOfCodes(const char *s, Term tail, - encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.enc = enc; - inp.type = YAP_STRING_CHARS; - out.val.uc = NULL; - out.type = YAP_STRING_DIFF | YAP_STRING_CODES; - out.dif = tail; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_UTF8ToDiffListOfCodes(const char *s, - Term tail USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.type = YAP_STRING_CHARS; - inp.enc = ENC_ISO_UTF8; - out.type = YAP_STRING_DIFF | YAP_STRING_CODES; - out.val.uc = NULL; - out.dif = tail; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_WCharsToDiffListOfCodes(const wchar_t *s, - Term tail USES_REGS) { - seq_tv_t inp, out; - - inp.val.w0 = s; - inp.type = YAP_STRING_WCHARS; - out.type = YAP_STRING_DIFF | YAP_STRING_CODES; - out.val.uc = NULL; - out.dif = tail; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - - return out.val.t; - } - - static inline Term Yap_CharsToString(const char *s, encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.enc = enc; - inp.type = YAP_STRING_CHARS; - out.type = YAP_STRING_STRING; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline char *Yap_AtomToUTF8Text(Atom at, const char *s USES_REGS) { - seq_tv_t inp, out; - - inp.val.a = at; - inp.type = YAP_STRING_ATOM; - out.type = YAP_STRING_CHARS; - out.val.uc = NULL; - out.enc = ENC_ISO_UTF8; - if (s) { - out.val.c0 = s; - out.type |= YAP_STRING_WITH_BUFFER; - } else { - out.type |= YAP_STRING_MALLOC; - out.val.c = NULL; - } - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.c; - } - - static inline Term Yap_CharsToTDQ(const char *s, Term mod, - encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.type = YAP_STRING_CHARS; - inp.mod = mod; - inp.enc = enc; - out.type = mod_to_type(mod PASS_REGS); - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_CharsToTBQ(const char *s, Term mod, - encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.type = YAP_STRING_CHARS; - inp.mod = mod; - inp.enc = enc; - out.type = mod_to_bqtype(mod PASS_REGS); - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_ListOfAtomsToAtom(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_ATOMS; - out.type = YAP_STRING_ATOM; - out.val.uc = NULL; - out.enc = ENC_ISO_UTF8; - out.enc = ENC_ISO_UTF8; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return (Atom)NULL; - return out.val.a; - } - - static inline Term Yap_ListOfAtomsToNumber(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_ATOMS; - out.type = - YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.val.uc = NULL; - out.enc = ENC_ISO_UTF8; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_ListOfAtomsToString(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_ATOMS; - out.type = YAP_STRING_STRING; - out.val.uc = NULL; - out.enc = ENC_ISO_UTF8; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_ListOfCodesToAtom(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_CODES; - out.type = YAP_STRING_ATOM; - out.val.uc = NULL; - out.enc = ENC_ISO_UTF8; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return (Atom)NULL; - return out.val.a; - } - - static inline Term Yap_ListOfCodesToNumber(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_CODES; - out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; - out.enc = ENC_ISO_UTF8; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_ListOfCodesToString(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_CODES; - out.val.uc = NULL; - out.type = YAP_STRING_STRING; - out.enc = ENC_ISO_UTF8; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_ListToAtom(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_ATOMS_CODES; - out.val.uc = NULL; - out.type = YAP_STRING_ATOM; - out.enc = ENC_ISO_UTF8; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline Term Yap_ListToAtomic(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; - out.val.uc = NULL; - out.enc = ENC_ISO_UTF8; - out.type = YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | - YAP_STRING_BIG | YAP_STRING_OUTPUT_TERM; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_ListToNumber(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES; - out.val.uc = NULL; - out.enc = ENC_ISO_UTF8; - out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_ListToString(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; - out.val.uc = NULL; - out.type = YAP_STRING_STRING; - out.enc = ENC_ISO_UTF8; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_ListSWIToString(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_ATOMS_CODES | - YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | - YAP_STRING_OUTPUT_TERM; - out.val.uc = NULL; - out.type = YAP_STRING_STRING; - out.enc = ENC_ISO_UTF8; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term YapListToTDQ(Term t0, Term mod USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; - out.val.uc = NULL; - out.type = mod_to_type(mod PASS_REGS); - out.enc = ENC_ISO_UTF8; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term YapListToTBQ(Term t0, Term mod USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; - out.val.uc = NULL; - out.type = mod_to_bqtype(mod PASS_REGS); - out.enc = ENC_ISO_UTF8; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_NCharsToAtom(const char *s, size_t len, - encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; - inp.enc = enc; - out.enc = ENC_ISO_UTF8; - out.type = YAP_STRING_ATOM; - out.val.uc = NULL; - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline Term Yap_CharsToDiffListOfAtoms(const char *s, encoding_t enc, - Term tail USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.type = YAP_STRING_CHARS; - inp.enc = enc; - out.type = YAP_STRING_ATOMS | YAP_STRING_DIFF; - out.dif = tail; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_NCharsToListOfCodes(const char *s, size_t len, - encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; - inp.enc = enc; - out.type = YAP_STRING_CODES; - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_NCharsToString(const char *s, size_t len, - encoding_t enc USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.enc = enc; - inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; - out.type = YAP_STRING_STRING; - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_NCharsToTDQ(const char *s, size_t len, encoding_t enc, - Term mod USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; - inp.enc = enc; - inp.mod = mod; - out.type = mod_to_type(mod PASS_REGS); - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_NCharsToTBQ(const char *s, size_t len, encoding_t enc, - Term mod USES_REGS) { - seq_tv_t inp, out; - - inp.val.c0 = s; - inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; - inp.enc = enc; - - out.type = mod_to_bqtype(mod PASS_REGS); - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_NumberToAtom(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = - YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_ATOM; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline Term Yap_NumberToListOfAtoms(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = - YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_ATOMS; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_NumberToListOfCodes(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = - YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_CODES; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_NumberToString(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = - YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_STRING; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_NWCharsToAtom(const wchar_t *s, size_t len USES_REGS) { - seq_tv_t inp, out; - - inp.val.w0 = s; - inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; - out.type = YAP_STRING_ATOM; - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline Term Yap_NWCharsToListOfAtoms(const wchar_t *s, - size_t len USES_REGS) { - seq_tv_t inp, out; - - inp.val.w0 = s; - inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; - out.type = YAP_STRING_ATOMS; - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_NWCharsToListOfCodes(const wchar_t *s, - size_t len USES_REGS) { - seq_tv_t inp, out; - - inp.val.w0 = s; - inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; - out.type = YAP_STRING_CODES; - out.val.uc = NULL; - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_NWCharsToString(const wchar_t *s, size_t len USES_REGS) { - seq_tv_t inp, out; - - inp.val.w0 = s; - inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; - out.val.uc = NULL; - out.type = YAP_STRING_STRING; - out.max = len; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_StringToAtom(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_STRING; - out.val.uc = NULL; - out.type = YAP_STRING_ATOM; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline Atom Yap_StringSWIToAtom(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | - YAP_STRING_TERM; - out.type = YAP_STRING_ATOM; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline size_t Yap_StringToAtomic(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_STRING; - out.type = - YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline size_t Yap_StringToUnicodeLength(Term t0 USES_REGS) { - if (!IsStringTerm(t0)) { - return -TYPE_ERROR_STRING; - } - return strlen_utf8(UStringOfTerm(t0)); - } - - static inline size_t Yap_StringToListOfAtoms(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_STRING; - out.type = YAP_STRING_ATOMS; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline size_t Yap_StringSWIToListOfAtoms(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | - YAP_STRING_TERM; - out.type = YAP_STRING_ATOMS; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline size_t Yap_StringToListOfCodes(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_STRING; - out.type = YAP_STRING_CODES; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline size_t Yap_StringSWIToListOfCodes(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | - YAP_STRING_TERM; - out.type = YAP_STRING_CODES; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_StringToNumber(Term t0 USES_REGS) { - seq_tv_t inp, out; - inp.val.t = t0; - inp.type = YAP_STRING_STRING; - out.type = - YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_TextToAtom(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES | - YAP_STRING_ATOMS_CODES; - out.val.uc = NULL; - out.type = YAP_STRING_ATOM; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline Term Yap_TextToString(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES | - YAP_STRING_ATOMS_CODES; - out.val.uc = NULL; - out.type = YAP_STRING_STRING; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline void Yap_OverwriteUTF8BufferToLowCase(void *buf USES_REGS) { - unsigned char *s = (unsigned char *)buf; - while (*s) { - // assumes the two code have always the same size; - utf8proc_int32_t chr; - get_utf8(s, -1, &chr); - chr = utf8proc_tolower(chr); - s += put_utf8(s, chr); - } - } - - static inline const unsigned char *Yap_TextToUTF8Buffer(Term t0 USES_REGS) { - seq_tv_t inp, out; - - inp.val.t = t0; - inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES | - YAP_STRING_ATOMS_CODES | YAP_STRING_MALLOC; - out.val.uc = NULL; - out.type = YAP_STRING_CHARS; - out.enc = ENC_ISO_UTF8; - - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.uc0; - } - - static inline Term Yap_UTF8ToString(const char *s USES_REGS) { - return MkStringTerm(s); - } - - static inline Atom UTF32ToAtom(const wchar_t *s USES_REGS) { - seq_tv_t inp, out; - - inp.val.w0 = s; - inp.type = YAP_STRING_WCHARS; - out.type = YAP_STRING_ATOM; - out.max = -1; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.a; - } - - static inline Term Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) { - seq_tv_t inp, out; - inp.val.w0 = s; - inp.type = YAP_STRING_WCHARS; - out.val.uc = NULL; - out.type = YAP_STRING_CODES; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_WCharsToTDQ(wchar_t *s, Term mod USES_REGS) { - seq_tv_t inp, out; - - inp.val.w0 = s; - inp.type = YAP_STRING_WCHARS; - - inp.mod = mod; - out.type = mod_to_type(mod PASS_REGS); - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_WCharsToTBQ(wchar_t *s, Term mod USES_REGS) { - seq_tv_t inp, out; - - inp.val.w = s; - inp.type = YAP_STRING_WCHARS; - inp.mod = mod; - out.type = mod_to_bqtype(mod PASS_REGS); - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Term Yap_WCharsToString(const wchar_t *s USES_REGS) { - seq_tv_t inp, out; - inp.val.w0 = s; - inp.type = YAP_STRING_WCHARS; - out.type = YAP_STRING_STRING; - out.val.uc = NULL; - if (!Yap_CVT_Text(&inp, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_ConcatAtoms(Term t1, Term t2 USES_REGS) { - seq_tv_t inpv[2], out; - inpv[0].val.t = t1; - inpv[0].type = YAP_STRING_ATOM; - inpv[1].val.t = t2; - inpv[1].type = YAP_STRING_ATOM; - out.type = YAP_STRING_ATOM; - out.val.uc = NULL; - if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) - return (Atom)NULL; - return out.val.a; - } - - static inline Atom Yap_ConcatAtomics(Term t1, Term t2 USES_REGS) { - seq_tv_t inpv[2], out; - inpv[0].val.t = t1; - inpv[0].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - inpv[1].val.t = t2; - inpv[1].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | - YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; - out.type = YAP_STRING_ATOM; - out.val.uc = NULL; - if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) - return (Atom)NULL; - return out.val.a; - } - - static inline Term Yap_ConcatStrings(Term t1, Term t2 USES_REGS) { - seq_tv_t inpv[2], out; - inpv[0].val.t = t1; - inpv[0].type = YAP_STRING_STRING; - inpv[1].val.t = t2; - inpv[1].type = YAP_STRING_STRING; - out.type = YAP_STRING_STRING; - - if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) - return 0L; - return out.val.t; - } - - static inline Atom Yap_SpliceAtom(Term t1, Atom ats[], size_t cut, - size_t max USES_REGS) { - seq_tv_t outv[2], inp; - size_t cuts[2]; - cuts[0] = cut; - cuts[1] = max; - inp.type = YAP_STRING_ATOM; - inp.val.t = t1; - outv[0].type = YAP_STRING_ATOM; - outv[1].type = YAP_STRING_ATOM; - if (!Yap_Splice_Text(2, cuts, &inp, outv PASS_REGS)) - return (Atom)NULL; - ats[0] = outv[0].val.a; - ats[1] = outv[1].val.a; - return ats[0]; - } - - static inline Atom Yap_SubtractHeadAtom(Term t1, Term th USES_REGS) { - seq_tv_t outv[2], inp; - inp.type = YAP_STRING_ATOM; - inp.val.t = t1; - outv[0].type = YAP_STRING_ATOM; - outv[0].val.t = th; - outv[1].type = YAP_STRING_ATOM; - outv[1].val.t = 0; - if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) - return (Atom)NULL; - return outv[1].val.a; - } - - static inline Atom Yap_SubtractTailAtom(Term t1, Term th USES_REGS) { - seq_tv_t outv[2], inp; - inp.type = YAP_STRING_ATOM; - inp.val.t = t1; - outv[0].type = YAP_STRING_ATOM; - outv[0].val.t = 0; - outv[1].type = YAP_STRING_ATOM; - outv[1].val.t = th; - if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) - return (Atom)NULL; - return outv[0].val.a; - } - - static inline Term Yap_SpliceString(Term t1, Term ts[], size_t cut, - size_t max USES_REGS) { - seq_tv_t outv[2], inp; - size_t cuts[2]; - inp.type = YAP_STRING_STRING; - inp.val.t = t1; - outv[0].type = YAP_STRING_STRING; - outv[1].type = YAP_STRING_STRING; - cuts[0] = cut; - cuts[1] = max; - if (!Yap_Splice_Text(2, cuts, &inp, outv PASS_REGS)) - return 0L; - ts[0] = outv[0].val.t; - ts[1] = outv[1].val.t; - return ts[0]; - } - - static inline Term Yap_SubtractHeadString(Term t1, Term th USES_REGS) { - seq_tv_t outv[2], inp; - inp.type = YAP_STRING_STRING; - inp.val.t = t1; - outv[0].type = YAP_STRING_STRING; - outv[0].val.t = th; - outv[1].type = YAP_STRING_STRING; - outv[1].val.t = 0; - if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) - return 0L; - return outv[1].val.t; - } - - static inline Term Yap_SubtractTailString(Term t1, Term th USES_REGS) { - seq_tv_t outv[2], inp; - inp.type = YAP_STRING_STRING; - inp.val.t = t1; - outv[0].type = YAP_STRING_STRING; - outv[0].val.t = 0; - outv[1].type = YAP_STRING_STRING; - outv[1].val.t = th; - if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) - return 0L; - return outv[0].val.t; - } +static inline size_t Yap_AtomToUnicodeLength(Term t0 USES_REGS) { + if (!IsAtomTerm(t0)) { + return -TYPE_ERROR_ATOM; + } + return strlen_utf8(RepAtom(AtomOfTerm(t0))->UStrOfAE); +} + +static inline Term Yap_AtomToListOfAtoms(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_ATOM; + out.val.uc = NULL; + out.type = YAP_STRING_ATOMS; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_AtomSWIToListOfAtoms(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | + YAP_STRING_TERM; + out.val.uc = NULL; + out.type = YAP_STRING_ATOMS; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_AtomToListOfCodes(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_ATOM; + out.val.uc = NULL; + out.type = YAP_STRING_CODES; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_AtomToNumber(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_ATOM; + out.val.uc = NULL; + out.enc = ENC_ISO_UTF8; + out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_AtomToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_ATOM; + out.val.uc = NULL; + out.type = YAP_STRING_STRING; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_AtomSWIToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES; + out.val.uc = NULL; + out.type = YAP_STRING_STRING; + out.enc = ENC_ISO_UTF8; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_AtomicToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.val.uc = NULL; + out.type = YAP_STRING_STRING; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_AtomicToTDQ(Term t0, Term mod USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.val.uc = NULL; + out.type = mod_to_type(mod PASS_REGS); + out.enc = ENC_ISO_UTF8; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline wchar_t *Yap_AtomToWide(Atom at USES_REGS) { + seq_tv_t inp, out; + inp.val.a = at; + inp.type = YAP_STRING_ATOM; + out.val.uc = NULL; + out.type = YAP_STRING_WCHARS; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return NIL; + return out.val.w; +} + +static inline Term Yap_AtomicToTBQ(Term t0, Term mod USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.val.uc = NULL; + out.type = mod_to_bqtype(mod PASS_REGS); + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_CharsToAtom(const char *s, encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.enc = enc; + inp.type = YAP_STRING_CHARS; + out.val.uc = NULL; + out.type = YAP_STRING_ATOM; + out.enc = ENC_ISO_UTF8; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_CharsToListOfAtoms(const char *s, + encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.enc = enc; + inp.type = YAP_STRING_CHARS; + out.val.uc = NULL; + out.type = YAP_STRING_ATOMS; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_CharsToListOfCodes(const char *s, + encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.enc = enc; + inp.type = YAP_STRING_CHARS; + out.val.uc = NULL; + out.type = YAP_STRING_CODES; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_UTF8ToListOfCodes(const char *s USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.type = YAP_STRING_CHARS; + inp.enc = ENC_ISO_UTF8; + out.type = YAP_STRING_CODES; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_UTF8ToAtom(const unsigned char *s USES_REGS) { + seq_tv_t inp, out; + + inp.val.uc0 = s; + inp.type = YAP_STRING_CHARS; + inp.enc = ENC_ISO_UTF8; + out.type = YAP_STRING_ATOM; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_CharsToDiffListOfCodes(const char *s, Term tail, + encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.enc = enc; + inp.type = YAP_STRING_CHARS; + out.val.uc = NULL; + out.type = YAP_STRING_DIFF | YAP_STRING_CODES; + out.dif = tail; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_UTF8ToDiffListOfCodes(const char *s, + Term tail USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.type = YAP_STRING_CHARS; + inp.enc = ENC_ISO_UTF8; + out.type = YAP_STRING_DIFF | YAP_STRING_CODES; + out.val.uc = NULL; + out.dif = tail; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_WCharsToDiffListOfCodes(const wchar_t *s, + Term tail USES_REGS) { + seq_tv_t inp, out; + + inp.val.w0 = s; + inp.type = YAP_STRING_WCHARS; + out.type = YAP_STRING_DIFF | YAP_STRING_CODES; + out.val.uc = NULL; + out.dif = tail; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + + return out.val.t; +} + +static inline Term Yap_CharsToString(const char *s, encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.enc = enc; + inp.type = YAP_STRING_CHARS; + out.type = YAP_STRING_STRING; + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline char *Yap_AtomToUTF8Text(Atom at, const char *s USES_REGS) { + seq_tv_t inp, out; + + inp.val.a = at; + inp.type = YAP_STRING_ATOM; + out.type = YAP_STRING_CHARS; + out.val.uc = NULL; + out.enc = ENC_ISO_UTF8; + if (s) { + out.val.c0 = s; + out.type |= YAP_STRING_WITH_BUFFER; + } else { + out.type |= YAP_STRING_MALLOC; + out.val.c = NULL; + } + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.c; +} + +static inline Term Yap_CharsToTDQ(const char *s, Term mod, + encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.type = YAP_STRING_CHARS; + inp.mod = mod; + inp.enc = enc; + out.type = mod_to_type(mod PASS_REGS); + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_CharsToTBQ(const char *s, Term mod, + encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.type = YAP_STRING_CHARS; + inp.mod = mod; + inp.enc = enc; + out.type = mod_to_bqtype(mod PASS_REGS); + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_ListOfAtomsToAtom(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_ATOMS; + out.type = YAP_STRING_ATOM; + out.val.uc = NULL; + out.enc = ENC_ISO_UTF8; + out.enc = ENC_ISO_UTF8; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return (Atom)NULL; + return out.val.a; +} + +static inline Term Yap_ListOfAtomsToNumber(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_ATOMS; + out.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.val.uc = NULL; + out.enc = ENC_ISO_UTF8; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_ListOfAtomsToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_ATOMS; + out.type = YAP_STRING_STRING; + out.val.uc = NULL; + out.enc = ENC_ISO_UTF8; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_ListOfCodesToAtom(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_CODES; + out.type = YAP_STRING_ATOM; + out.val.uc = NULL; + out.enc = ENC_ISO_UTF8; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return (Atom)NULL; + return out.val.a; +} + +static inline Term Yap_ListOfCodesToNumber(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_CODES; + out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; + out.enc = ENC_ISO_UTF8; + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_ListOfCodesToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_CODES; + out.val.uc = NULL; + out.type = YAP_STRING_STRING; + out.enc = ENC_ISO_UTF8; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_ListToAtom(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_ATOMS_CODES; + out.val.uc = NULL; + out.type = YAP_STRING_ATOM; + out.enc = ENC_ISO_UTF8; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_ListToAtomic(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; + out.val.uc = NULL; + out.enc = ENC_ISO_UTF8; + out.type = YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | + YAP_STRING_BIG | YAP_STRING_OUTPUT_TERM; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_ListToNumber(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES; + out.val.uc = NULL; + out.enc = ENC_ISO_UTF8; + out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_ListToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; + out.val.uc = NULL; + out.type = YAP_STRING_STRING; + out.enc = ENC_ISO_UTF8; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_ListSWIToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_ATOMS_CODES | + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | + YAP_STRING_OUTPUT_TERM; + out.val.uc = NULL; + out.type = YAP_STRING_STRING; + out.enc = ENC_ISO_UTF8; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term YapListToTDQ(Term t0, Term mod USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; + out.val.uc = NULL; + out.type = mod_to_type(mod PASS_REGS); + out.enc = ENC_ISO_UTF8; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term YapListToTBQ(Term t0, Term mod USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM; + out.val.uc = NULL; + out.type = mod_to_bqtype(mod PASS_REGS); + out.enc = ENC_ISO_UTF8; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_NCharsToAtom(const char *s, size_t len, + encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; + inp.enc = enc; + out.enc = ENC_ISO_UTF8; + out.type = YAP_STRING_ATOM; + out.val.uc = NULL; + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_CharsToDiffListOfAtoms(const char *s, encoding_t enc, + Term tail USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.type = YAP_STRING_CHARS; + inp.enc = enc; + out.type = YAP_STRING_ATOMS | YAP_STRING_DIFF; + out.dif = tail; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_NCharsToListOfCodes(const char *s, size_t len, + encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; + inp.enc = enc; + out.type = YAP_STRING_CODES; + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_NCharsToString(const char *s, size_t len, + encoding_t enc USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.enc = enc; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; + out.type = YAP_STRING_STRING; + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_NCharsToTDQ(const char *s, size_t len, encoding_t enc, + Term mod USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; + inp.enc = enc; + inp.mod = mod; + out.type = mod_to_type(mod PASS_REGS); + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_NCharsToTBQ(const char *s, size_t len, encoding_t enc, + Term mod USES_REGS) { + seq_tv_t inp, out; + + inp.val.c0 = s; + inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS; + inp.enc = enc; + + out.type = mod_to_bqtype(mod PASS_REGS); + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_NumberToAtom(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.type = YAP_STRING_ATOM; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_NumberToListOfAtoms(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.type = YAP_STRING_ATOMS; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_NumberToListOfCodes(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.type = YAP_STRING_CODES; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_NumberToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.type = YAP_STRING_STRING; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_NWCharsToAtom(const wchar_t *s, size_t len USES_REGS) { + seq_tv_t inp, out; + + inp.val.w0 = s; + inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; + out.type = YAP_STRING_ATOM; + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_NWCharsToListOfAtoms(const wchar_t *s, + size_t len USES_REGS) { + seq_tv_t inp, out; + + inp.val.w0 = s; + inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; + out.type = YAP_STRING_ATOMS; + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_NWCharsToListOfCodes(const wchar_t *s, + size_t len USES_REGS) { + seq_tv_t inp, out; + + inp.val.w0 = s; + inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; + out.type = YAP_STRING_CODES; + out.val.uc = NULL; + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_NWCharsToString(const wchar_t *s, size_t len USES_REGS) { + seq_tv_t inp, out; + + inp.val.w0 = s; + inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS; + out.val.uc = NULL; + out.type = YAP_STRING_STRING; + out.max = len; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_StringToAtom(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_STRING; + out.val.uc = NULL; + out.type = YAP_STRING_ATOM; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Atom Yap_StringSWIToAtom(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | + YAP_STRING_TERM; + out.type = YAP_STRING_ATOM; + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline size_t Yap_StringToAtomic(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_STRING; + out.type = + YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG; + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline size_t Yap_StringToUnicodeLength(Term t0 USES_REGS) { + if (!IsStringTerm(t0)) { + return -TYPE_ERROR_STRING; + } + return strlen_utf8(UStringOfTerm(t0)); +} + +static inline size_t Yap_StringToListOfAtoms(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_STRING; + out.type = YAP_STRING_ATOMS; + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline size_t Yap_StringSWIToListOfAtoms(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | + YAP_STRING_TERM; + out.type = YAP_STRING_ATOMS; + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline size_t Yap_StringToListOfCodes(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_STRING; + out.type = YAP_STRING_CODES; + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline size_t Yap_StringSWIToListOfCodes(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | + YAP_STRING_TERM; + out.type = YAP_STRING_CODES; + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_StringToNumber(Term t0 USES_REGS) { + seq_tv_t inp, out; + inp.val.t = t0; + inp.type = YAP_STRING_STRING; + out.type = + YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.val.uc = NULL; + out.enc = ENC_ISO_UTF8; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_TextToAtom(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES | + YAP_STRING_ATOMS_CODES; + out.val.uc = NULL; + out.type = YAP_STRING_ATOM; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_TextToString(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES | + YAP_STRING_ATOMS_CODES; + out.val.uc = NULL; + out.type = YAP_STRING_STRING; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline void Yap_OverwriteUTF8BufferToLowCase(void *buf USES_REGS) { + unsigned char *s = (unsigned char *)buf; + while (*s) { + // assumes the two code have always the same size; + utf8proc_int32_t chr; + get_utf8(s, -1, &chr); + chr = utf8proc_tolower(chr); + s += put_utf8(s, chr); + } +} + +static inline const unsigned char *Yap_TextToUTF8Buffer(Term t0 USES_REGS) { + seq_tv_t inp, out; + + inp.val.t = t0; + inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES | + YAP_STRING_ATOMS_CODES | YAP_STRING_MALLOC; + out.val.uc = NULL; + out.type = YAP_STRING_CHARS; + out.enc = ENC_ISO_UTF8; + + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.uc0; +} + +static inline Term Yap_UTF8ToString(const char *s USES_REGS) { + return MkStringTerm(s); +} + +static inline Atom UTF32ToAtom(const wchar_t *s USES_REGS) { + seq_tv_t inp, out; + + inp.val.w0 = s; + inp.type = YAP_STRING_WCHARS; + out.type = YAP_STRING_ATOM; + out.max = -1; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.a; +} + +static inline Term Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) { + seq_tv_t inp, out; + inp.val.w0 = s; + inp.type = YAP_STRING_WCHARS; + out.val.uc = NULL; + out.type = YAP_STRING_CODES; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_WCharsToTDQ(wchar_t *s, Term mod USES_REGS) { + seq_tv_t inp, out; + + inp.val.w0 = s; + inp.type = YAP_STRING_WCHARS; + + inp.mod = mod; + out.type = mod_to_type(mod PASS_REGS); + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_WCharsToTBQ(wchar_t *s, Term mod USES_REGS) { + seq_tv_t inp, out; + + inp.val.w = s; + inp.type = YAP_STRING_WCHARS; + inp.mod = mod; + out.type = mod_to_bqtype(mod PASS_REGS); + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Term Yap_WCharsToString(const wchar_t *s USES_REGS) { + seq_tv_t inp, out; + inp.val.w0 = s; + inp.type = YAP_STRING_WCHARS; + out.type = YAP_STRING_STRING; + out.val.uc = NULL; + if (!Yap_CVT_Text(&inp, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_ConcatAtoms(Term t1, Term t2 USES_REGS) { + seq_tv_t inpv[2], out; + inpv[0].val.t = t1; + inpv[0].type = YAP_STRING_ATOM; + inpv[1].val.t = t2; + inpv[1].type = YAP_STRING_ATOM; + out.type = YAP_STRING_ATOM; + out.val.uc = NULL; + if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) + return (Atom)NULL; + return out.val.a; +} + +static inline Atom Yap_ConcatAtomics(Term t1, Term t2 USES_REGS) { + seq_tv_t inpv[2], out; + inpv[0].val.t = t1; + inpv[0].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + inpv[1].val.t = t2; + inpv[1].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT | + YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM; + out.type = YAP_STRING_ATOM; + out.val.uc = NULL; + if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) + return (Atom)NULL; + return out.val.a; +} + +static inline Term Yap_ConcatStrings(Term t1, Term t2 USES_REGS) { + seq_tv_t inpv[2], out; + inpv[0].val.t = t1; + inpv[0].type = YAP_STRING_STRING; + inpv[1].val.t = t2; + inpv[1].type = YAP_STRING_STRING; + out.type = YAP_STRING_STRING; + + if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) + return 0L; + return out.val.t; +} + +static inline Atom Yap_SpliceAtom(Term t1, Atom ats[], size_t cut, + size_t max USES_REGS) { + seq_tv_t outv[2], inp; + size_t cuts[2]; + cuts[0] = cut; + cuts[1] = max; + inp.type = YAP_STRING_ATOM; + inp.val.t = t1; + outv[0].type = YAP_STRING_ATOM; + outv[1].type = YAP_STRING_ATOM; + if (!Yap_Splice_Text(2, cuts, &inp, outv PASS_REGS)) + return (Atom)NULL; + ats[0] = outv[0].val.a; + ats[1] = outv[1].val.a; + return ats[0]; +} + +static inline Atom Yap_SubtractHeadAtom(Term t1, Term th USES_REGS) { + seq_tv_t outv[2], inp; + inp.type = YAP_STRING_ATOM; + inp.val.t = t1; + outv[0].type = YAP_STRING_ATOM; + outv[0].val.t = th; + outv[1].type = YAP_STRING_ATOM; + outv[1].val.t = 0; + if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) + return (Atom)NULL; + return outv[1].val.a; +} + +static inline Atom Yap_SubtractTailAtom(Term t1, Term th USES_REGS) { + seq_tv_t outv[2], inp; + inp.type = YAP_STRING_ATOM; + inp.val.t = t1; + outv[0].type = YAP_STRING_ATOM; + outv[0].val.t = 0; + outv[1].type = YAP_STRING_ATOM; + outv[1].val.t = th; + if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) + return (Atom)NULL; + return outv[0].val.a; +} + +static inline Term Yap_SpliceString(Term t1, Term ts[], size_t cut, + size_t max USES_REGS) { + seq_tv_t outv[2], inp; + size_t cuts[2]; + inp.type = YAP_STRING_STRING; + inp.val.t = t1; + outv[0].type = YAP_STRING_STRING; + outv[1].type = YAP_STRING_STRING; + cuts[0] = cut; + cuts[1] = max; + if (!Yap_Splice_Text(2, cuts, &inp, outv PASS_REGS)) + return 0L; + ts[0] = outv[0].val.t; + ts[1] = outv[1].val.t; + return ts[0]; +} + +static inline Term Yap_SubtractHeadString(Term t1, Term th USES_REGS) { + seq_tv_t outv[2], inp; + inp.type = YAP_STRING_STRING; + inp.val.t = t1; + outv[0].type = YAP_STRING_STRING; + outv[0].val.t = th; + outv[1].type = YAP_STRING_STRING; + outv[1].val.t = 0; + if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) + return 0L; + return outv[1].val.t; +} + +static inline Term Yap_SubtractTailString(Term t1, Term th USES_REGS) { + seq_tv_t outv[2], inp; + inp.type = YAP_STRING_STRING; + inp.val.t = t1; + outv[0].type = YAP_STRING_STRING; + outv[0].val.t = 0; + outv[1].type = YAP_STRING_STRING; + outv[1].val.t = th; + if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)) + return 0L; + return outv[0].val.t; +} #endif // ≈YAP_TEXT_H - const char *Yap_TextTermToText(Term t, char *buf, size_t len, encoding_t enc); - Term Yap_MkTextTerm(const char *s, encoding_t e, Term tguide); +const char *Yap_TextTermToText(Term t, char *bufwrite_Text, + encoding_t e USES_REGS); +Term Yap_MkTextTerm(const char *s, encoding_t e, Term tguide); diff --git a/library/dialect/swi/fli/swi.c b/library/dialect/swi/fli/swi.c index cc02b9567..5f125c9cc 100755 --- a/library/dialect/swi/fli/swi.c +++ b/library/dialect/swi/fli/swi.c @@ -11,13 +11,13 @@ Moyle. All rights reserved. */ /** -* -* @file swi.c -* -* @addtogroup swi-c-interface -* -* @{ -*/ + * + * @file swi.c + * + * @addtogroup swi-c-interface + * + * @{ + */ #define PL_KERNEL 1 #define _EXPORT_KERNEL 1 @@ -119,8 +119,8 @@ static void UserCPredicate(char *a, CPredicate def, unsigned long int arity, //! @{ /** @defgroup swi-ATOMS Atom Construction -* @ingroup swi-c-interface -* */ + * @ingroup swi-c-interface + * */ static UInt cvtFlags(unsigned flags) { UInt inptype = 0; @@ -156,8 +156,8 @@ static UInt cvtFlags(unsigned flags) { /* void PL_agc_hook(void) */ /** @brief Atom garbage collection hook -* -*/ + * + */ X_API PL_agc_hook_t PL_agc_hook(PL_agc_hook_t entry) { return (PL_agc_hook_t)YAP_AGCRegisterHook((YAP_agc_hook)entry); } @@ -227,9 +227,7 @@ X_API int PL_get_nchars(term_t l, size_t *lengthp, char **s, unsigned flags) { pop_text_stack(lvl); return false; } - out.val.c = protected_pop_text_stack(lvl, out.val.c, - flags & (BUF_RING | BUF_DISCARDABLE), - strlen(out.val.c) + 1 PASS_REGS); + out.val.c = export_block(-1, out.val.c PASS_REGS); *s = out.val.c; return true; } @@ -281,15 +279,15 @@ X_API int PL_unify_chars(term_t l, int flags, size_t length, const char *s) { } else if (flags & PL_CHAR_LIST) { out.type = YAP_STRING_ATOMS; } - out.max = length; + out.max = length; if (!Yap_CVT_Text(&inp, &out PASS_REGS)) return 0L; return Yap_unify(Yap_GetFromSlot(l), out.val.t); } /** @brief extract the text representation from atom -* -*/ + * + */ X_API char *PL_atom_chars(atom_t a) /* SAM check type */ { Atom at = SWIAtomToAtom(a); @@ -297,8 +295,8 @@ X_API char *PL_atom_chars(atom_t a) /* SAM check type */ } /** @brief extract the text representation from atom, including its length -* -*/ + * + */ X_API char *PL_atom_nchars(atom_t a, size_t *len) /* SAM check type */ { char *s = RepAtom(SWIAtomToAtom(a))->StrOfAE; @@ -309,14 +307,14 @@ X_API char *PL_atom_nchars(atom_t a, size_t *len) /* SAM check type */ //! @} /** @{ -* -* @defgroup swi-term_references Term References -* @ingroup swi-c-interface -* */ + * + * @defgroup swi-term_references Term References + * @ingroup swi-c-interface + * */ /** @brief create a clean term reference -* -*/ + * + */ X_API term_t PL_new_term_ref(void) { CACHE_REGS term_t to = Yap_NewSlots(1); @@ -324,17 +322,17 @@ X_API term_t PL_new_term_ref(void) { } /** @brief duplicate a term reference -* -*/ + * + */ X_API term_t PL_copy_term_ref(term_t from) { CACHE_REGS return Yap_InitSlot(Yap_GetFromSlot(from)); } /** @brief create several new term references -* -* @par n is the number of references -*/ + * + * @par n is the number of references + */ X_API term_t PL_new_term_refs(int n) { CACHE_REGS term_t to = Yap_NewSlots(n); @@ -342,31 +340,31 @@ X_API term_t PL_new_term_refs(int n) { } /** @brief dispose of all term references created since after -* -*/ + * + */ X_API void PL_reset_term_refs(term_t after) { CACHE_REGS LOCAL_CurSlot = after; } /** @} -*/ + */ //! @{ /** @defgroup swi-term_manipulation Term Manipulation -* @ingroup swi-c-interface -* */ + * @ingroup swi-c-interface + * */ /** -* @defgroup swi-get-operations Reading Terms -* @ingroup swi-term_manipulation -* */ + * @defgroup swi-get-operations Reading Terms + * @ingroup swi-term_manipulation + * */ /** @brief *name is assigned the name and *arity the arity if term ts, or the * operaton fails. -* -*/ + * + */ X_API int PL_get_name_arity(term_t ts, atom_t *name, int *arity) { CACHE_REGS YAP_Term t = Yap_GetFromSlot(ts); @@ -399,8 +397,8 @@ X_API int PL_get_name_arity(term_t ts, atom_t *name, int *arity) { } /** @brief a is assigned the argument index from term ts -* -*/ + * + */ X_API int PL_get_arg(int index, term_t ts, term_t a) { CACHE_REGS YAP_Term t = Yap_GetFromSlot(ts); @@ -429,8 +427,8 @@ X_API int PL_get_arg(int index, term_t ts, term_t a) { } /** @brief *ap is assigned the name and *ip the arity from term ts -* -*/ + * + */ X_API int PL_get_compound_name_arity(term_t ts, atom_t *ap, int *ip) { CACHE_REGS YAP_Term t = Yap_GetFromSlot(ts); @@ -456,8 +454,8 @@ X_API int PL_get_compound_name_arity(term_t ts, atom_t *ap, int *ip) { } /** @brief *a is assigned the atom in term ts, or the operation fails -* -*/ + * + */ X_API int PL_get_atom(term_t ts, atom_t *a) { CACHE_REGS YAP_Term t = Yap_GetFromSlot(ts); @@ -468,8 +466,8 @@ X_API int PL_get_atom(term_t ts, atom_t *a) { } /** @brief *i is assigned the int in term ts, or the operation fails -* -*/ + * + */ /* int PL_get_integer(term_t t, int *i) YAP: long int YAP_IntOfTerm(Term) */ X_API int PL_get_integer(term_t ts, int *i) { @@ -483,8 +481,8 @@ X_API int PL_get_integer(term_t ts, int *i) { /** @brief *i is assigned the boolean atom `true` or `false` in term ts, or the * operation fails -* -*/ + * + */ X_API int PL_get_long(term_t ts, long *i) { CACHE_REGS YAP_Term t = Yap_GetFromSlot(ts); @@ -524,8 +522,8 @@ X_API int PL_get_bool(term_t ts, int *i) { } /** @brief *a is assigned the int64 in term ts, or the operation fails -* -*/ + * + */ X_API int PL_get_int64(term_t ts, int64_t *i) { CACHE_REGS YAP_Term t = Yap_GetFromSlot(ts); @@ -575,8 +573,8 @@ X_API int PL_get_int64(term_t ts, int64_t *i) { X_API int PL_get_int64_ex(term_t ts, int64_t *i) { return PL_get_int64(ts, i); } /** @brief *a is assigned the intptr_t in term ts, or the operation fails -* -*/ + * + */ X_API int PL_get_intptr(term_t ts, intptr_t *a) { CACHE_REGS Term t = Yap_GetFromSlot(ts); @@ -587,8 +585,8 @@ X_API int PL_get_intptr(term_t ts, intptr_t *a) { } /** @brief *a is assigned the uintptr_t in term ts, or the operation fails -* -*/ + * + */ X_API int PL_get_uintptr(term_t ts, uintptr_t *a) { CACHE_REGS Term t = Yap_GetFromSlot(ts); @@ -599,8 +597,8 @@ X_API int PL_get_uintptr(term_t ts, uintptr_t *a) { } #ifdef do_not_ld /** @brief a is assigned the argument index from term ts -* -*/ + * + */ X_API int _PL_get_arg(int index, term_t ts, term_t a) { CACHE_REGS YAP_Term t = Yap_GetFromSlot(ts); @@ -623,8 +621,8 @@ X_API int _PL_get_arg(int index, term_t ts, term_t a) { /** @brief *a is assigned the string representation of the atom in term ts, or * the operation fails -* -*/ + * + */ X_API int PL_get_atom_chars(term_t ts, char **a) /* SAM check type */ { CACHE_REGS @@ -645,8 +643,8 @@ X_API int PL_get_atom_chars(term_t ts, char **a) /* SAM check type */ /** @brief *a is assigned the string representation of the atom in term ts, and * *len its size, or the operation fails -* -*/ + * + */ X_API int PL_get_atom_nchars(term_t ts, size_t *len, char **s) /* SAM check type */ { @@ -655,11 +653,11 @@ X_API int PL_get_atom_nchars(term_t ts, size_t *len, if (!IsAtomTerm(t)) { return 0; } - if (s) - *s = (char*)RepAtom(AtomOfTerm(t))->StrOfAE; + if (s) + *s = (char *)RepAtom(AtomOfTerm(t))->StrOfAE; if (len) { - *len = strlen(*s); -} + *len = strlen(*s); + } return 1; } @@ -693,8 +691,8 @@ X_API int PL_get_atom_nchars(term_t ts, size_t *len, */ /** @brief *f is assigned the functor of term ts, or the operation fails -* -*/ + * + */ X_API int PL_get_functor(term_t ts, functor_t *f) { CACHE_REGS Term t = Yap_GetFromSlot(ts); @@ -710,8 +708,8 @@ X_API int PL_get_functor(term_t ts, functor_t *f) { /** @brief *f is assigned the floating point number of term ts, or the * operation fails -* -*/ + * + */ X_API int PL_get_float(term_t ts, double *f) /* SAM type check*/ { CACHE_REGS @@ -740,8 +738,8 @@ X_API int PL_get_string_chars(term_t t, char **s, size_t *len) { /** @brief *s is assigned the string representation of the string in term ts, * and *len its size, or the operation fails -* -*/ + * + */ X_API int PL_get_string(term_t t, char **s, size_t *len) { CACHE_REGS Term tt = Yap_GetFromSlot(t); @@ -762,8 +760,8 @@ X_API int PL_get_string(term_t t, char **s, size_t *len) { /** @brief h is assigned the head of the pair term ts, and tl its tail, or the * operation fails -* -*/ + * + */ X_API int PL_get_list(term_t ts, term_t h, term_t tl) { CACHE_REGS @@ -777,8 +775,8 @@ X_API int PL_get_list(term_t ts, term_t h, term_t tl) { } /** @brief h is assigned the head of the pair term ts, or the operation fails -* -*/ + * + */ X_API int PL_get_head(term_t ts, term_t h) { CACHE_REGS YAP_Term t = Yap_GetFromSlot(ts); @@ -790,8 +788,8 @@ X_API int PL_get_head(term_t ts, term_t h) { } /** -* @} -* */ + * @} + * */ //! @{ /** @@ -801,8 +799,8 @@ X_API int PL_get_head(term_t ts, term_t h) { * */ /*b* @brief t unifies with the true/false value in a. -* -*/ + * + */ X_API int PL_unify_bool(term_t t, int a) { CACHE_REGS Term iterm = (a ? MkAtomTerm(AtomTrue) : MkAtomTerm(AtomFalse)); @@ -813,7 +811,7 @@ X_API int PL_unify_bool(term_t t, int a) { /******************************* * GMP * -*******************************/ + *******************************/ X_API int PL_get_mpz(term_t t, mpz_t mpz) { CACHE_REGS @@ -1554,7 +1552,7 @@ X_API int PL_unify_string_nchars(term_t t, size_t len, const char *chars) { } /* int PL_unify_wchars(term_t ?t, int type, size_t len,, const pl_wchar_t *s) -*/ + */ X_API int PL_unify_wchars(term_t t, int type, size_t len, const pl_wchar_t *chars) { CACHE_REGS @@ -1786,8 +1784,9 @@ int PL_unify_termv(term_t l, va_list ap) { Term t = Yap_MkNewApplTerm(ff, arity); if (nels) { if (depth == MAX_DEPTH) { - fprintf(stderr, "ERROR: very deep term in PL_unify_term, change " - "MAX_DEPTH from %d\n", + fprintf(stderr, + "ERROR: very deep term in PL_unify_term, change " + "MAX_DEPTH from %d\n", MAX_DEPTH); return FALSE; } @@ -2525,8 +2524,9 @@ X_API void PL_register_foreign_in_module(const char *module, const char *name, #ifdef DEBUG if (flags & (PL_FA_CREF)) { - fprintf(stderr, "PL_register_foreign_in_module called with non-implemented " - "flag %x when creating predicate %s:%s/%d\n", + fprintf(stderr, + "PL_register_foreign_in_module called with non-implemented " + "flag %x when creating predicate %s:%s/%d\n", flags, module, name, arity); } #endif @@ -3139,6 +3139,6 @@ char *PL_cwd(char *cwd, size_t cwdlen) { } /** -* @} -* @} -*/ + * @} + * @} + */ diff --git a/os/files.c b/os/files.c index 00e79f338..588186a47 100644 --- a/os/files.c +++ b/os/files.c @@ -42,7 +42,7 @@ bool Yap_GetFileName(Term t, char *buf, size_t len, encoding_t enc) { t = ArgOfTerm(2, t); len -= (szl + 1); } - return Yap_TextTermToText(t, buf, len, enc); + return Yap_TextTermToText(t, buf, enc); } static Int file_name_extension(USES_REGS1) { @@ -78,8 +78,7 @@ static Int file_name_extension(USES_REGS1) { Yap_unify(t2, t); } else { f2 = ss + (strlen(ss) + 1); - if (!Yap_TextTermToText(t2, f2, YAP_FILENAME_MAX - 1 - (f2 - f), - ENC_ISO_UTF8)) + if (!Yap_TextTermToText(t2, f2, ENC_ISO_UTF8)) return false; #if __APPLE__ || _WIN32 Yap_OverwriteUTF8BufferToLowCase(f2); @@ -113,12 +112,11 @@ static Int file_name_extension(USES_REGS1) { return true; } else { char *f2; - if (!Yap_TextTermToText(t1, f, YAP_FILENAME_MAX - 2, ENC_ISO_UTF8)) { + if (!Yap_TextTermToText(t1, f, ENC_ISO_UTF8)) { return false; } f2 = f + strlen(f); - if (!Yap_TextTermToText(t2, f2, YAP_FILENAME_MAX - 2 - (f2 - f), - ENC_ISO_UTF8)) { + if (!Yap_TextTermToText(t2, f2, ENC_ISO_UTF8)) { return false; } if (f2[0] != '.') { @@ -460,7 +458,7 @@ static Int is_absolute_file_name(USES_REGS1) { /* file_base_name(Stream,N) */ Yap_Error(INSTANTIATION_ERROR, t, "file_base_name/2"); return false; } - const char *buf = Yap_TextTermToText(t, NULL, 0, LOCAL_encoding); + const char *buf = Yap_TextTermToText(t, NULL, LOCAL_encoding); if (buf) { rc = Yap_IsAbsolutePath(buf); } else { diff --git a/os/fmem.c b/os/fmem.c index a2a3c82cc..38a54d57f 100644 --- a/os/fmem.c +++ b/os/fmem.c @@ -1,19 +1,19 @@ /************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * -* * -************************************************************************** -* * -* File: mem.c * -* Last rev: 5/2/88 * -* mods: * -* comments: Input/Output C implemented predicates * -* * -*************************************************************************/ + * * + * YAP Prolog * + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * + * * + ************************************************************************** + * * + * File: mem.c * + * Last rev: 5/2/88 * + * mods: * + * comments: Input/Output C implemented predicates * + * * + *************************************************************************/ #ifdef SCCS static char SccsId[] = "%W% %G%"; #endif @@ -23,29 +23,27 @@ static char SccsId[] = "%W% %G%"; * */ -#include "sysbits.h" #include "format.h" +#include "sysbits.h" #if HAVE_FMEMOPEN - - - int format_synch(int sno, int sno0, format_info *fg) { +int format_synch(int sno, int sno0, format_info *fg) { const char *s; int n; if (sno != sno0) { - fflush(GLOBAL_Stream[sno].file); - n = ftell(GLOBAL_Stream[sno].file); - s = GLOBAL_Stream[sno].nbuf; - if (GLOBAL_Stream[sno0].vfs) { - int ch; - int (*f)() = GLOBAL_Stream[sno0].vfs->put_char; - while ((ch = *s++)) { - f(sno0, ch); - } - } else { - fwrite(s, n, 1, GLOBAL_Stream[sno0].file); + fflush(GLOBAL_Stream[sno].file); + n = ftell(GLOBAL_Stream[sno].file); + s = GLOBAL_Stream[sno].nbuf; + if (GLOBAL_Stream[sno0].vfs) { + int ch; + int (*f)() = GLOBAL_Stream[sno0].vfs->put_char; + while ((ch = *s++)) { + f(sno0, ch); } + } else { + fwrite(s, n, 1, GLOBAL_Stream[sno0].file); + } rewind(GLOBAL_Stream[sno].file); fg->lstart = 0; fg->phys_start = 0; @@ -55,9 +53,9 @@ static char SccsId[] = "%W% %G%"; return sno; } - bool fill_pads(int sno, int sno0, int total, format_info *fg USES_REGS) +bool fill_pads(int sno, int sno0, int total, format_info *fg USES_REGS) // uses directly the buffer in the memory stream. - { +{ int nfillers, fill_space, lfill_space, nchars; int (*f_putc)(int, int); const char *buf; @@ -115,20 +113,20 @@ static char SccsId[] = "%W% %G%"; return true; } - -bool Yap_set_stream_to_buf(StreamDesc *st, const char *buf, encoding_t enc, size_t nchars) { +bool Yap_set_stream_to_buf(StreamDesc *st, const char *buf, encoding_t enc, + size_t nchars) { FILE *f; // like any file stream. st->file = f = fmemopen((void *)buf, nchars, "r"); st->status = Input_Stream_f | InMemory_Stream_f | Seekable_Stream_f; st->vfs = NULL; - st->encoding = enc; + st->encoding = enc; Yap_DefaultStreamOps(st); return true; } -int Yap_open_buf_read_stream(const char *buf, size_t nchars, encoding_t *encp, +int Yap_open_buf_read_stream(const char *buf, size_t nchars, encoding_t *encp, memBufSource src) { CACHE_REGS int sno; @@ -139,8 +137,7 @@ int Yap_open_buf_read_stream(const char *buf, size_t nchars, enc sno = GetFreeStreamD(); if (sno < 0) - return (PlIOError(RESOURCE_ERROR_MAX_STREAMS, - TermNil, + return (PlIOError(RESOURCE_ERROR_MAX_STREAMS, TermNil, "new stream not available for open_mem_read_stream/1")); st = GLOBAL_Stream + sno; if (encp) @@ -151,7 +148,7 @@ int Yap_open_buf_read_stream(const char *buf, size_t nchars, enc f = st->file = fmemopen((void *)buf, nchars, "r"); flags = Input_Stream_f | InMemory_Stream_f | Seekable_Stream_f; Yap_initStream(sno, f, NULL, TermNil, encoding, flags, AtomRead, NULL); -// like any file stream. + // like any file stream. Yap_DefaultStreamOps(st); UNLOCK(st->streamlock); return sno; @@ -165,7 +162,7 @@ open_mem_read_stream(USES_REGS1) /* $open_mem_read_stream(+List,-Stream) */ const char *buf; ti = Deref(ARG1); - buf = Yap_TextTermToText(ti, NULL, 0, LOCAL_encoding); + buf = Yap_TextTermToText(ti, NULL, LOCAL_encoding); if (!buf) { return false; } @@ -290,10 +287,9 @@ void Yap_MemOps(StreamDesc *st) { st->stream_putc = FilePutc; st->stream_getc = PlGetc; - } - static int sssno; +static int sssno; bool Yap_CloseMemoryStream(int sno) { sssno++; diff --git a/os/format.h b/os/format.h index a5c580978..4ee03aeca 100644 --- a/os/format.h +++ b/os/format.h @@ -1,8 +1,10 @@ #define FORMAT_MAX_SIZE 1024 +#include + typedef struct { - Int filler; + intptr_t filler; /* character to dump */ int phys; /* position in buffer */ diff --git a/os/iopreds.c b/os/iopreds.c index e99368235..159d4fda0 100644 --- a/os/iopreds.c +++ b/os/iopreds.c @@ -294,7 +294,7 @@ static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp) { s->status = flags; s->linepos = 0; s->linecount = 1; - s->charcount = 0.; + s->charcount = 0; s->vfs = vfsp; s->encoding = ENC_ISO_UTF8; INIT_LOCK(s->streamlock); @@ -305,11 +305,11 @@ static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp) { return; } } else { - unix_upd_stream_info(s); -} + unix_upd_stream_info(s); + } /* Getting streams to prompt is a mess because we need for cooperation - between readers and writers to the stream :-( - */ + between readers and writers to the stream :-( + */ InitFileIO(s); switch (sno) { case 0: @@ -330,7 +330,7 @@ static void InitStdStream(int sno, SMALLUNSGN flags, FILE *file, VFS_t *vfsp) { #if HAVE_SETBUF if (s->status & Tty_Stream_f && sno == 0) { /* make sure input is unbuffered if it comes from stdin, this - makes life simpler for interrupt handling */ + makes life simpler for interrupt handling */ setbuf(stdin, NULL); // fprintf(stderr,"here I am\n"); } diff --git a/os/readterm.c b/os/readterm.c index 6f2cf1fe7..bda712c89 100644 --- a/os/readterm.c +++ b/os/readterm.c @@ -286,7 +286,7 @@ form: + symbols, including `(`, `)`, `,`, `;` */ -static Int scan_to_list(USES_ARGS1) { +static Int scan_to_list(USES_REGS1) { int inp_stream; Term tpos, tout; @@ -1350,214 +1350,206 @@ static Int style_checker(USES_REGS1) { return TRUE; } -Term Yap_BufferToTerm(const unsigned char *s, size_t len, Term opts) { +Term Yap_BufferToTerm(const unsigned char *s, Term opts) { Term rval; int sno; encoding_t l = ENC_ISO_UTF8; - sno = Yap_open_buf_read_stream((char *)s, len, &l, MEM_BUF_USER); + sno = Yap_open_buf_read_stream((char *)s, strlen((const char*)s), &l, MEM_BUF_USER); rval = Yap_read_term(sno, opts, false); Yap_CloseStream(sno); return rval; } -X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s, size_t len, - Term opts, int prio, - Term bindings) { - CACHE_REGS - Term ctl; + X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s, size_t len, + Term opts, int prio, + Term bindings) { + CACHE_REGS + Term ctl; - ctl = opts; - if (bindings) { - ctl = add_names(bindings, TermNil); - } - if (prio != 1200) { - ctl = add_priority(bindings, ctl); - } - return Yap_BufferToTerm(s, len, ctl); -} + ctl = opts; + if (bindings) { + ctl = add_names(bindings, TermNil); + } + if (prio != 1200) { + ctl = add_priority(bindings, ctl); + } + return Yap_BufferToTerm(s, ctl); + } -/** - * @pred read_term_from_atom( +Atom , -T , +Options ) - * - * read a term _T_ stored in constant _Atom_ according to _Options_ - * - * @param _Atom_ the source _Atom_ - * @param _T_ the output term _T_, may be any term - * @param _Options_ read_term/3 options. - * - * @notes Originally from SWI-Prolog, in YAP only works with internalised - *atoms - * Check read_term_from_atomic/3 for the general version. Also, the built-in - *is - *supposed to - * use YAP's internal encoding, so please avoid the encoding/1 option. - */ -static Int read_term_from_atom(USES_REGS1) { - Term t1 = Deref(ARG1); - Atom at; - const unsigned char *s; - size_t len; + /** + * @pred read_term_from_atom( +Atom , -T , +Options ) + * + * read a term _T_ stored in constant _Atom_ according to _Options_ + * + * @param _Atom_ the source _Atom_ + * @param _T_ the output term _T_, may be any term + * @param _Options_ read_term/3 options. + * + * @notes Originally from SWI-Prolog, in YAP only works with internalised + *atoms + * Check read_term_from_atomic/3 for the general version. Also, the built-in + *is + *supposed to + * use YAP's internal encoding, so please avoid the encoding/1 option. + */ + static Int read_term_from_atom(USES_REGS1) { + Term t1 = Deref(ARG1); + Atom at; + const unsigned char *s; - if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR, t1, "style_check/1"); - return false; - } else if (!IsAtomTerm(t1)) { - Yap_Error(TYPE_ERROR_ATOM, t1, "style_check/1"); - return false; - } else { - at = AtomOfTerm(t1); - s = at->UStrOfAE; - len = strlen_utf8(s); - } - Term ctl = add_output(ARG2, ARG3); + if (IsVarTerm(t1)) { + Yap_Error(INSTANTIATION_ERROR, t1, "style_check/1"); + return false; + } else if (!IsAtomTerm(t1)) { + Yap_Error(TYPE_ERROR_ATOM, t1, "style_check/1"); + return false; + } else { + at = AtomOfTerm(t1); + s = at->UStrOfAE; + } + Term ctl = add_output(ARG2, ARG3); - return Yap_BufferToTerm(s, len, ctl); -} + return Yap_BufferToTerm(s, ctl); + } -/** - * @pred read_term_from_atomic( +Atomic , - T , +Options ) - * - * read a term _T_ stored in text _Atomic_ according to _Options_ - * - * @param _Atomic_ the source may be an atom, string, list of codes, or list - *of - *chars. - * @param _T_ the output term _T_, may be any term - * @param _Options_ read_term/3 options. - * - * @notes Idea originally from SWI-Prolog, but in YAP we separate atomic and - *atom. - * Encoding is fixed in atoms and strings. - */ -static Int read_term_from_atomic(USES_REGS1) { - Term t1 = Deref(ARG1); - const unsigned char *s; - size_t len; - if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_atomic/3"); - return (FALSE); - } else if (!IsAtomicTerm(t1)) { - Yap_Error(TYPE_ERROR_ATOMIC, t1, "read_term_from_atomic/3"); - return (FALSE); - } else { - Term t = Yap_AtomicToString(t1 PASS_REGS); - s = UStringOfTerm(t); - len = strlen_utf8(s); - } - Term ctl = add_output(ARG2, ARG3); + /** + * @pred read_term_from_atomic( +Atomic , - T , +Options ) + * + * read a term _T_ stored in text _Atomic_ according to _Options_ + * + * @param _Atomic_ the source may be an atom, string, list of codes, or list + *of + *chars. + * @param _T_ the output term _T_, may be any term + * @param _Options_ read_term/3 options. + * + * @notes Idea originally from SWI-Prolog, but in YAP we separate atomic and + *atom. + * Encoding is fixed in atoms and strings. + */ + static Int read_term_from_atomic(USES_REGS1) { + Term t1 = Deref(ARG1); + const unsigned char *s; - return Yap_BufferToTerm(s, len, ctl); -} + if (IsVarTerm(t1)) { + Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_atomic/3"); + return (FALSE); + } else if (!IsAtomicTerm(t1)) { + Yap_Error(TYPE_ERROR_ATOMIC, t1, "read_term_from_atomic/3"); + return (FALSE); + } else { + Term t = Yap_AtomicToString(t1 PASS_REGS); + s = UStringOfTerm(t); + } + Term ctl = add_output(ARG2, ARG3); -/** - * @pred read_term_from_string( +String , - T , + Options ) - * - * read a term _T_ stored in constant _String_ according to _Options_ - * - * @param _String_ the source _String_ - * @param _T_ the output term _T_, may be any term - * @param _Options_ read_term/3 options. - * - * @notes Idea from SWI-Prolog, in YAP only works with strings - * Check read_term_from_atomic/3 for the general version. - */ -static Int read_term_from_string(USES_REGS1) { - Term t1 = Deref(ARG1), rc; - const unsigned char *s; - size_t len; - if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); - return (FALSE); - } else if (!IsStringTerm(t1)) { - Yap_Error(TYPE_ERROR_STRING, t1, "read_term_from_string/3"); - return (FALSE); - } else { - s = UStringOfTerm(t1); - len = strlen_utf8(s); - } - char *ss = (char *)s; - encoding_t enc = ENC_ISO_UTF8; - int sno = Yap_open_buf_read_stream(ss, len, &enc, MEM_BUF_USER); - rc = Yap_read_term(sno, Deref(ARG3), 3); - Yap_CloseStream(sno); - if (!rc) - return false; - return Yap_unify(rc, ARG2); -} + return Yap_BufferToTerm(s, ctl); + } -static Int atomic_to_term(USES_REGS1) { - Term t1 = Deref(ARG1); - size_t len; - if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); - return (FALSE); - } else if (!IsAtomicTerm(t1)) { - Yap_Error(TYPE_ERROR_ATOMIC, t1, "read_term_from_atomic/3"); - return (FALSE); - } else { - Term t = Yap_AtomicToString(t1 PASS_REGS); - const unsigned char *us = UStringOfTerm(t); - len = strlen_utf8(us); - return Yap_BufferToTerm(us, len, - add_output(ARG2, add_names(ARG3, TermNil))); - } -} + /** + * @pred read_term_from_string( +String , - T , + Options ) + * + * read a term _T_ stored in constant _String_ according to _Options_ + * + * @param _String_ the source _String_ + * @param _T_ the output term _T_, may be any term + * @param _Options_ read_term/3 options. + * + * @notes Idea from SWI-Prolog, in YAP only works with strings + * Check read_term_from_atomic/3 for the general version. + */ + static Int read_term_from_string(USES_REGS1) { + Term t1 = Deref(ARG1), rc; + const unsigned char *s; + size_t len; + if (IsVarTerm(t1)) { + Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); + return (FALSE); + } else if (!IsStringTerm(t1)) { + Yap_Error(TYPE_ERROR_STRING, t1, "read_term_from_string/3"); + return (FALSE); + } else { + s = UStringOfTerm(t1); + len = strlen_utf8(s); + } + char *ss = (char *)s; + encoding_t enc = ENC_ISO_UTF8; + int sno = Yap_open_buf_read_stream(ss, len, &enc, MEM_BUF_USER); + rc = Yap_read_term(sno, Deref(ARG3), 3); + Yap_CloseStream(sno); + if (!rc) + return false; + return Yap_unify(rc, ARG2); + } -static Int atom_to_term(USES_REGS1) { - Term t1 = Deref(ARG1); - size_t len; - if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); - return (FALSE); - } else if (!IsAtomTerm(t1)) { - Yap_Error(TYPE_ERROR_ATOM, t1, "read_term_from_atomic/3"); - return (FALSE); - } else { - Term t = Yap_AtomicToString(t1 PASS_REGS); - const unsigned char *us = UStringOfTerm(t); - len = strlen_utf8(us); - return Yap_BufferToTerm(us, len, - add_output(ARG2, add_names(ARG3, TermNil))); - } -} + static Int atomic_to_term(USES_REGS1) { + Term t1 = Deref(ARG1); + if (IsVarTerm(t1)) { + Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); + return (FALSE); + } else if (!IsAtomicTerm(t1)) { + Yap_Error(TYPE_ERROR_ATOMIC, t1, "read_term_from_atomic/3"); + return (FALSE); + } else { + Term t = Yap_AtomicToString(t1 PASS_REGS); + const unsigned char *us = UStringOfTerm(t); + return Yap_BufferToTerm(us, + add_output(ARG2, add_names(ARG3, TermNil))); + } + } -static Int string_to_term(USES_REGS1) { - Term t1 = Deref(ARG1); - size_t len; - if (IsVarTerm(t1)) { - Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); - return (FALSE); - } else if (!IsStringTerm(t1)) { - Yap_Error(TYPE_ERROR_STRING, t1, "read_term_from_string/3"); - return (FALSE); - } else { - const unsigned char *us = UStringOfTerm(t1); - len = strlen_utf8(us); - return Yap_BufferToTerm(us, len, - add_output(ARG2, add_names(ARG3, TermNil))); - } -} + static Int atom_to_term(USES_REGS1) { + Term t1 = Deref(ARG1); + if (IsVarTerm(t1)) { + Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); + return (FALSE); + } else if (!IsAtomTerm(t1)) { + Yap_Error(TYPE_ERROR_ATOM, t1, "read_term_from_atomic/3"); + return (FALSE); + } else { + Term t = Yap_AtomicToString(t1 PASS_REGS); + const unsigned char *us = UStringOfTerm(t); + return Yap_BufferToTerm(us, + add_output(ARG2, add_names(ARG3, TermNil))); + } + } -void Yap_InitReadTPreds(void) { - Yap_InitCPred("read_term", 2, read_term2, SyncPredFlag); - Yap_InitCPred("read_term", 3, read_term, SyncPredFlag); + static Int string_to_term(USES_REGS1) { + Term t1 = Deref(ARG1); - Yap_InitCPred("scan_to_list", 2, scan_to_list, SyncPredFlag); - Yap_InitCPred("read", 1, read1, SyncPredFlag); - Yap_InitCPred("read", 2, read2, SyncPredFlag); - Yap_InitCPred("read_clause", 2, read_clause2, SyncPredFlag); - Yap_InitCPred("read_clause", 3, read_clause, 0); - Yap_InitCPred("read_term_from_atom", 3, read_term_from_atom, 0); - Yap_InitCPred("read_term_from_atomic", 3, read_term_from_atomic, 0); - Yap_InitCPred("read_term_from_string", 3, read_term_from_string, 0); - Yap_InitCPred("atom_to_term", 3, atom_to_term, 0); - Yap_InitCPred("atomic_to_term", 3, atomic_to_term, 0); - Yap_InitCPred("string_to_term", 3, string_to_term, 0); + if (IsVarTerm(t1)) { + Yap_Error(INSTANTIATION_ERROR, t1, "read_term_from_string/3"); + return (FALSE); + } else if (!IsStringTerm(t1)) { + Yap_Error(TYPE_ERROR_STRING, t1, "read_term_from_string/3"); + return (FALSE); + } else { + const unsigned char *us = UStringOfTerm(t1); + return Yap_BufferToTerm(us, + add_output(ARG2, add_names(ARG3, TermNil))); + } + } - Yap_InitCPred("fileerrors", 0, fileerrors, SyncPredFlag); - Yap_InitCPred("nofileeleerrors", 0, nofileerrors, SyncPredFlag); - Yap_InitCPred("source_location", 2, source_location, SyncPredFlag); - Yap_InitCPred("$style_checker", 1, style_checker, - SyncPredFlag | HiddenPredFlag); -} + void Yap_InitReadTPreds(void) { + Yap_InitCPred("read_term", 2, read_term2, SyncPredFlag); + Yap_InitCPred("read_term", 3, read_term, SyncPredFlag); + + Yap_InitCPred("scan_to_list", 2, scan_to_list, SyncPredFlag); + Yap_InitCPred("read", 1, read1, SyncPredFlag); + Yap_InitCPred("read", 2, read2, SyncPredFlag); + Yap_InitCPred("read_clause", 2, read_clause2, SyncPredFlag); + Yap_InitCPred("read_clause", 3, read_clause, 0); + Yap_InitCPred("read_term_from_atom", 3, read_term_from_atom, 0); + Yap_InitCPred("read_term_from_atomic", 3, read_term_from_atomic, 0); + Yap_InitCPred("read_term_from_string", 3, read_term_from_string, 0); + Yap_InitCPred("atom_to_term", 3, atom_to_term, 0); + Yap_InitCPred("atomic_to_term", 3, atomic_to_term, 0); + Yap_InitCPred("string_to_term", 3, string_to_term, 0); + + Yap_InitCPred("fileerrors", 0, fileerrors, SyncPredFlag); + Yap_InitCPred("nofileeleerrors", 0, nofileerrors, SyncPredFlag); + Yap_InitCPred("source_location", 2, source_location, SyncPredFlag); + Yap_InitCPred("$style_checker", 1, style_checker, + SyncPredFlag | HiddenPredFlag); + } diff --git a/os/sysbits.c b/os/sysbits.c index d8aba81ca..0007c07fa 100644 --- a/os/sysbits.c +++ b/os/sysbits.c @@ -1,19 +1,19 @@ /************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * -* * -************************************************************************** -* * -* File: sysbits.c * -* Last rev: 4/03/88 * -* mods: * -* comments: very much machine dependent routines * -* * -*************************************************************************/ + * * + * YAP Prolog * + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * + * * + ************************************************************************** + * * + * File: sysbits.c * + * Last rev: 4/03/88 * + * mods: * + * comments: very much machine dependent routines * + * * + *************************************************************************/ #ifdef SCCS static char SccsId[] = "%W% %G%"; #endif @@ -487,8 +487,8 @@ const char *Yap_AbsoluteFile(const char *spec, char *rc0, bool ok) { } static Term - /* Expand the string for the program to run. */ - do_glob(const char *spec, bool glob_vs_wordexp) { +/* Expand the string for the program to run. */ +do_glob(const char *spec, bool glob_vs_wordexp) { CACHE_REGS if (spec == NULL) { return TermNil; @@ -847,7 +847,7 @@ static Int absolute_file_system_path(USES_REGS1) { const char *fp; bool rc; char s[MAXPATHLEN + 1]; - const char *text = Yap_TextTermToText(t, s, MAXPATHLEN, LOCAL_encoding); + const char *text = Yap_TextTermToText(t, s, LOCAL_encoding); if (text == NULL) { return false; @@ -1042,7 +1042,7 @@ static bool initSysPath(Term tlib, Term tcommons, bool dir_done, if (!commons_done && is_directory(LOCAL_FileNameBuf)) { if (!Yap_unify(tcommons, MkAtomTerm(Yap_LookupAtom(LOCAL_FileNameBuf)))) return FALSE; - commons_done = true; + commons_done = true; } #endif return dir_done && commons_done; @@ -1163,19 +1163,19 @@ static Int working_directory(USES_REGS1) { } /** Yap_findFile(): tries to locate a file, no expansion should be performed/ - * - * - * @param isource the proper file - * @param idef the default name fothe file, ie, startup.yss - * @param root the prefix - * @param result the output - * @param access verify whether the file has access permission - * @param ftype saved state, object, saved file, prolog file - * @param expand_root expand $ ~, etc - * @param in_lib library file - * - * @return - */ + * + * + * @param isource the proper file + * @param idef the default name fothe file, ie, startup.yss + * @param root the prefix + * @param result the output + * @param access verify whether the file has access permission + * @param ftype saved state, object, saved file, prolog file + * @param expand_root expand $ ~, etc + * @param in_lib library file + * + * @return + */ const char *Yap_findFile(const char *isource, const char *idef, const char *iroot, char *result, bool access, YAP_file_type_t ftype, bool expand_root, bool in_lib) { @@ -1199,7 +1199,7 @@ const char *Yap_findFile(const char *isource, const char *idef, source = (isource ? isource : idef); } if (source) { - abspath = Yap_IsAbsolutePath(source); + abspath = Yap_IsAbsolutePath(source); } if (!abspath && !root && ftype == YAP_BOOT_PL) { root = YAP_PL_SRCDIR; @@ -1359,7 +1359,7 @@ static Int p_expand_file_name(USES_REGS1) { Yap_Error(INSTANTIATION_ERROR, t, "argument to true_file_name unbound"); return FALSE; } - text = Yap_TextTermToText(t, NULL, 0, LOCAL_encoding); + text = Yap_TextTermToText(t, NULL, LOCAL_encoding); if (!text) return false; if (!(text2 = PlExpandVars(text, NULL, NULL))) @@ -1808,9 +1808,9 @@ static Int p_env_separator(USES_REGS1) { } /* - * This is responsable for the initialization of all machine dependant - * predicates - */ + * This is responsable for the initialization of all machine dependant + * predicates + */ void Yap_InitSysbits(int wid) { CACHE_REGS #if __simplescalar__ @@ -1925,7 +1925,7 @@ static HKEY reg_open_key(const wchar_t *which, int create) { #define MAXREGSTRLEN 1024 static wchar_t *WideStringFromAtom(Atom KeyAt USES_REGS) { - return Yap_AtomToWide( KeyAt ); + return Yap_AtomToWide(KeyAt); } static Int p_win_registry_get_value(USES_REGS1) { @@ -1942,24 +1942,24 @@ static Int p_win_registry_get_value(USES_REGS1) { if (IsVarTerm(Key)) { Yap_Error(INSTANTIATION_ERROR, Key, "argument to win_registry_get_value unbound"); - pop_text_stack(l); - return FALSE; + pop_text_stack(l); + return FALSE; } if (!IsAtomTerm(Key)) { Yap_Error(TYPE_ERROR_ATOM, Key, "argument to win_registry_get_value"); - pop_text_stack(l); - return FALSE; + pop_text_stack(l); + return FALSE; } KeyAt = AtomOfTerm(Key); if (IsVarTerm(Name)) { Yap_Error(INSTANTIATION_ERROR, Key, "argument to win_registry_get_value unbound"); - pop_text_stack(l); - return FALSE; + pop_text_stack(l); + return FALSE; } if (!IsAtomTerm(Name)) { Yap_Error(TYPE_ERROR_ATOM, Key, "argument to win_registry_get_value"); -pop_text_stack(l); + pop_text_stack(l); return FALSE; } NameAt = AtomOfTerm(Name); @@ -1967,7 +1967,7 @@ pop_text_stack(l); k = WideStringFromAtom(KeyAt PASS_REGS); if (!(key = reg_open_key(k, FALSE))) { Yap_Error(EXISTENCE_ERROR_KEY, Key, "argument to win_registry_get_value"); -pop_text_stack(l); + pop_text_stack(l); return FALSE; } name = WideStringFromAtom(NameAt PASS_REGS); @@ -1979,19 +1979,18 @@ pop_text_stack(l); ((wchar_t *)data)[len] = '\0'; Atom at = Yap_NWCharsToAtom((wchar_t *)data, len PASS_REGS); pop_text_stack(l); - return Yap_unify(MkAtomTerm(at),ARG3); - case REG_DWORD: - { - DWORD *d = (DWORD *)data; -pop_text_stack(l); - return Yap_unify(MkIntegerTerm((Int)d[0]), ARG3); - } + return Yap_unify(MkAtomTerm(at), ARG3); + case REG_DWORD: { + DWORD *d = (DWORD *)data; + pop_text_stack(l); + return Yap_unify(MkIntegerTerm((Int)d[0]), ARG3); + } default: - pop_text_stack(l); - return FALSE; + pop_text_stack(l); + return FALSE; } } -pop_text_stack(l); + pop_text_stack(l); return FALSE; } diff --git a/os/writeterm.c b/os/writeterm.c index 0c385c79a..bc8697446 100644 --- a/os/writeterm.c +++ b/os/writeterm.c @@ -1,19 +1,19 @@ /************************************************************************* -* * -* YAP Prolog * -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * -* * -************************************************************************** -* * -* File: iopreds.c * -* Last rev: 5/2/88 * -* mods: * -* comments: Input/Output C implemented predicates * -* * -*************************************************************************/ + * * + * YAP Prolog * + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * + * * + ************************************************************************** + * * + * File: iopreds.c * + * Last rev: 5/2/88 * + * mods: * + * comments: Input/Output C implemented predicates * + * * + *************************************************************************/ #ifdef SCCS static char SccsId[] = "%W% %G%"; #endif @@ -25,10 +25,10 @@ static char SccsId[] = "%W% %G%"; */ #include "Yap.h" +#include "YapEval.h" #include "YapHeap.h" #include "YapText.h" #include "Yatom.h" -#include "YapEval.h" #include "yapio.h" #include #if HAVE_STDARG_H @@ -678,8 +678,7 @@ static Int term_to_string(USES_REGS1) { Term t2 = Deref(ARG2), rc = false, t1 = Deref(ARG1); const char *s; if (IsVarTerm(t2)) { - size_t length; - s = Yap_TermToString(ARG1, &length, LOCAL_encoding, + s = Yap_TermToString(ARG1,LOCAL_encoding, Quote_illegal_f | Handle_vars_f); if (!s || !MkStringTerm(s)) { Yap_Error(RESOURCE_ERROR_HEAP, t1, @@ -700,8 +699,7 @@ static Int term_to_atom(USES_REGS1) { Term t2 = Deref(ARG2), ctl, rc = false; Atom at; if (IsVarTerm(t2)) { - size_t length; - const char *s = Yap_TermToString(Deref(ARG1), &length, LOCAL_encoding, + const char *s = Yap_TermToString(Deref(ARG1), LOCAL_encoding, Quote_illegal_f | Handle_vars_f); if (!s || !(at = Yap_UTF8ToAtom((const unsigned char *)s))) { Yap_Error(RESOURCE_ERROR_HEAP, t2, @@ -716,8 +714,7 @@ static Int term_to_atom(USES_REGS1) { at = AtomOfTerm(t2); } ctl = TermNil; - return (rc = Yap_BufferToTerm(RepAtom(at)->UStrOfAE, - strlen(RepAtom(at)->StrOfAE), ctl)) && + return ((rc = Yap_BufferToTerm(RepAtom(at)->UStrOfAE, ctl))) && Yap_unify(rc, ARG1); } diff --git a/os/yapio.h b/os/yapio.h index 4a9dbadc6..29240e888 100644 --- a/os/yapio.h +++ b/os/yapio.h @@ -1,19 +1,18 @@ /************************************************************************* -* * -* YAP Prolog %W% %G% -* * -* Yap Prolog was developed at NCCUP - Universidade do Porto * -* * -* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 * -* * -************************************************************************** -* * -* File: yapio.h * -* Last rev: 22/1/03 * -* mods: * -* comments: Input/Output information * -* * -*************************************************************************/ + * * + * YAP Prolog %W% %G% + * * + * Yap Prolog was developed at NCCUP - Universidade do Porto * + * * + * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-2003 * + * * + ************************************************************************** + * * + * File: yapio.h * Last + *rev: 22/1/03 * mods: + ** comments: Input/Output information * + * * + *************************************************************************/ #ifndef YAPIO_H @@ -78,8 +77,7 @@ extern int Yap_PlFGetchar(void); extern int Yap_GetCharForSIGINT(void); extern Int Yap_StreamToFileNo(Term); extern int Yap_OpenStream(FILE *, char *, Term, int); -extern char *Yap_TermToString(Term t, size_t *length, encoding_t encoding, - int flags); +extern char *Yap_TermToString(Term t, encoding_t encoding, int flags); extern char *Yap_HandleToString(yhandle_t l, size_t sz, size_t *length, encoding_t *encoding, int flags); extern int Yap_GetFreeStreamD(void); @@ -110,10 +108,10 @@ extern Term Yap_StringToNumberTerm(const char *s, encoding_t *encp, extern int Yap_FormatFloat(Float f, char **s, size_t sz); extern int Yap_open_buf_read_stream(const char *buf, size_t nchars, encoding_t *encp, memBufSource src); -extern bool Yap_set_stream_to_buf(struct stream_desc *st, const char *buf, encoding_t enc, - size_t nchars); +extern bool Yap_set_stream_to_buf(struct stream_desc *st, const char *buf, + encoding_t enc, size_t nchars); extern int Yap_open_buf_write_stream(encoding_t enc, memBufSource src); -extern Term Yap_BufferToTerm(const unsigned char *s, size_t sz, Term opts); +extern Term Yap_BufferToTerm(const unsigned char *s, Term opts); extern X_API Term Yap_BufferToTermWithPrioBindings(const unsigned char *s, size_t sz, Term opts, int prio, Term bindings); diff --git a/packages/python/swig/setup.py b/packages/python/swig/setup.py index afcb8026d..ad9c1bf2d 100644 --- a/packages/python/swig/setup.py +++ b/packages/python/swig/setup.py @@ -71,13 +71,13 @@ native_sources = ["yap.i"] for i in '/home/vsc/github/yap-6.3/packages/python/swig/yap4py/yapi.py;/home/vsc/github/yap-6.3/packages/python/swig/yap4py/__init__.py;/home/vsc/github/yap-6.3/packages/python/swig/yap4py/__main__.py'.split(";"): copy2(i, 'yap4py') -for i in '/home/vsc/github/yap-6.3/packages/python/python.pl;/home/vsc/github/yap-6.3/library/INDEX.pl;/home/vsc/github/yap-6.3/library/apply.yap;/home/vsc/github/yap-6.3/library/apply_macros.yap;/home/vsc/github/yap-6.3/library/arg.yap;/home/vsc/github/yap-6.3/library/assoc.yap;/home/vsc/github/yap-6.3/library/atts.yap;/home/vsc/github/yap-6.3/library/autoloader.yap;/home/vsc/github/yap-6.3/library/avl.yap;/home/vsc/github/yap-6.3/library/bhash.yap;/home/vsc/github/yap-6.3/library/charsio.yap;/home/vsc/github/yap-6.3/library/clauses.yap;/home/vsc/github/yap-6.3/library/coinduction.yap;/home/vsc/github/yap-6.3/library/dbqueues.yap;/home/vsc/github/yap-6.3/library/dbusage.yap;/home/vsc/github/yap-6.3/library/dgraphs.yap;/home/vsc/github/yap-6.3/library/exo_interval.yap;/home/vsc/github/yap-6.3/library/expand_macros.yap;/home/vsc/github/yap-6.3/library/gensym.yap;/home/vsc/github/yap-6.3/library/hacks.yap;/home/vsc/github/yap-6.3/library/heaps.yap;/home/vsc/github/yap-6.3/library/lambda.pl;/home/vsc/github/yap-6.3/library/lineutils.yap;/home/vsc/github/yap-6.3/library/listing.yap;/home/vsc/github/yap-6.3/library/lists.yap;/home/vsc/github/yap-6.3/library/log2md.yap;/home/vsc/github/yap-6.3/library/nb.yap;/home/vsc/github/yap-6.3/library/ordsets.yap;/home/vsc/github/yap-6.3/library/mapargs.yap;/home/vsc/github/yap-6.3/library/maplist.yap;/home/vsc/github/yap-6.3/library/maputils.yap;/home/vsc/github/yap-6.3/library/matlab.yap;/home/vsc/github/yap-6.3/library/matrix.yap;/home/vsc/github/yap-6.3/library/prandom.yap;/home/vsc/github/yap-6.3/library/queues.yap;/home/vsc/github/yap-6.3/library/random.yap;/home/vsc/github/yap-6.3/library/range.yap;/home/vsc/github/yap-6.3/library/rbtrees.yap;/home/vsc/github/yap-6.3/library/regexp.yap;/home/vsc/github/yap-6.3/library/readutil.yap;/home/vsc/github/yap-6.3/library/rltree.yap;/home/vsc/github/yap-6.3/library/sockets.yap;/home/vsc/github/yap-6.3/library/splay.yap;/home/vsc/github/yap-6.3/library/stringutils.yap;/home/vsc/github/yap-6.3/library/system.yap;/home/vsc/github/yap-6.3/library/terms.yap;/home/vsc/github/yap-6.3/library/tries.yap;/home/vsc/github/yap-6.3/library/itries.yap;/home/vsc/github/yap-6.3/library/timeout.yap;/home/vsc/github/yap-6.3/library/trees.yap;/home/vsc/github/yap-6.3/library/ugraphs.yap;/home/vsc/github/yap-6.3/library/undgraphs.yap;/home/vsc/github/yap-6.3/library/varnumbers.yap;/home/vsc/github/yap-6.3/library/wdgraphs.yap;/home/vsc/github/yap-6.3/library/wgraphs.yap;/home/vsc/github/yap-6.3/library/wundgraphs.yap;/home/vsc/github/yap-6.3/library/lam_mpi.yap;/home/vsc/github/yap-6.3/library/ypp.yap;/home/vsc/github/yap-6.3/library/ytest.yap;/home/vsc/github/yap-6.3/library/c_alarms.yap;/home/vsc/github/yap-6.3/library/flags.yap;/home/vsc/github/yap-6.3/library/block_diagram.yap;/home/vsc/github/yap-6.3/packages/real/real.pl;/home/vsc/github/yap-6.3/packages/python/swig/prolog/jupyter.yap;/home/vsc/github/yap-6.3/packages/python/swig/prolog/yapi.yap'.split(";") + '/home/vsc/github/yap-6.3/swi/library/aggregate.pl;/home/vsc/github/yap-6.3/swi/library/base64.pl;/home/vsc/github/yap-6.3/swi/library/broadcast.pl;/home/vsc/github/yap-6.3/swi/library/ctypes.pl;/home/vsc/github/yap-6.3/swi/library/date.pl;/home/vsc/github/yap-6.3/swi/library/debug.pl;/home/vsc/github/yap-6.3/swi/library/edit.pl;/home/vsc/github/yap-6.3/swi/library/error.pl;/home/vsc/github/yap-6.3/swi/library/main.pl;/home/vsc/github/yap-6.3/swi/library/menu.pl;/home/vsc/github/yap-6.3/swi/library/nb_set.pl;/home/vsc/github/yap-6.3/swi/library/occurs.yap;/home/vsc/github/yap-6.3/swi/library/operators.pl;/home/vsc/github/yap-6.3/swi/library/option.pl;/home/vsc/github/yap-6.3/swi/library/pairs.pl;/home/vsc/github/yap-6.3/swi/library/plunit.pl;/home/vsc/github/yap-6.3/swi/library/predicate_options.pl;/home/vsc/github/yap-6.3/swi/library/predopts.pl;/home/vsc/github/yap-6.3/swi/library/prolog_clause.pl;/home/vsc/github/yap-6.3/swi/library/prolog_colour.pl;/home/vsc/github/yap-6.3/swi/library/prolog_source.pl;/home/vsc/github/yap-6.3/swi/library/prolog_xref.pl;/home/vsc/github/yap-6.3/swi/library/pure_input.pl;/home/vsc/github/yap-6.3/swi/library/quasi_quotations.pl;/home/vsc/github/yap-6.3/swi/library/quintus.pl;/home/vsc/github/yap-6.3/swi/library/record.pl;/home/vsc/github/yap-6.3/swi/library/settings.pl;/home/vsc/github/yap-6.3/swi/library/shlib.pl;/home/vsc/github/yap-6.3/swi/library/thread_pool.pl;/home/vsc/github/yap-6.3/swi/library/unix.pl;/home/vsc/github/yap-6.3/swi/library/url.pl;/home/vsc/github/yap-6.3/swi/library/utf8.pl;/home/vsc/github/yap-6.3/swi/library/win_menu.pl;/home/vsc/github/yap-6.3/swi/library/www_browser.pl;/home/vsc/github/yap-6.3/swi/library/dcg/basics.pl'.split(";") : +for i in '/home/vsc/github/yap-6.3/packages/python/python.pl;/home/vsc/github/yap-6.3/library/INDEX.pl;/home/vsc/github/yap-6.3/library/apply.yap;/home/vsc/github/yap-6.3/library/apply_macros.yap;/home/vsc/github/yap-6.3/library/arg.yap;/home/vsc/github/yap-6.3/library/assoc.yap;/home/vsc/github/yap-6.3/library/atts.yap;/home/vsc/github/yap-6.3/library/autoloader.yap;/home/vsc/github/yap-6.3/library/avl.yap;/home/vsc/github/yap-6.3/library/bhash.yap;/home/vsc/github/yap-6.3/library/charsio.yap;/home/vsc/github/yap-6.3/library/clauses.yap;/home/vsc/github/yap-6.3/library/coinduction.yap;/home/vsc/github/yap-6.3/library/dbqueues.yap;/home/vsc/github/yap-6.3/library/dbusage.yap;/home/vsc/github/yap-6.3/library/dgraphs.yap;/home/vsc/github/yap-6.3/library/exo_interval.yap;/home/vsc/github/yap-6.3/library/expand_macros.yap;/home/vsc/github/yap-6.3/library/gensym.yap;/home/vsc/github/yap-6.3/library/hacks.yap;/home/vsc/github/yap-6.3/library/heaps.yap;/home/vsc/github/yap-6.3/library/lambda.pl;/home/vsc/github/yap-6.3/library/lineutils.yap;/home/vsc/github/yap-6.3/library/listing.yap;/home/vsc/github/yap-6.3/library/lists.yap;/home/vsc/github/yap-6.3/library/log2md.yap;/home/vsc/github/yap-6.3/library/nb.yap;/home/vsc/github/yap-6.3/library/ordsets.yap;/home/vsc/github/yap-6.3/library/mapargs.yap;/home/vsc/github/yap-6.3/library/maplist.yap;/home/vsc/github/yap-6.3/library/maputils.yap;/home/vsc/github/yap-6.3/library/matlab.yap;/home/vsc/github/yap-6.3/library/matrix.yap;/home/vsc/github/yap-6.3/library/prandom.yap;/home/vsc/github/yap-6.3/library/queues.yap;/home/vsc/github/yap-6.3/library/random.yap;/home/vsc/github/yap-6.3/library/range.yap;/home/vsc/github/yap-6.3/library/rbtrees.yap;/home/vsc/github/yap-6.3/library/regexp.yap;/home/vsc/github/yap-6.3/library/readutil.yap;/home/vsc/github/yap-6.3/library/rltree.yap;/home/vsc/github/yap-6.3/library/sockets.yap;/home/vsc/github/yap-6.3/library/splay.yap;/home/vsc/github/yap-6.3/library/stringutils.yap;/home/vsc/github/yap-6.3/library/system.yap;/home/vsc/github/yap-6.3/library/terms.yap;/home/vsc/github/yap-6.3/library/tries.yap;/home/vsc/github/yap-6.3/library/itries.yap;/home/vsc/github/yap-6.3/library/timeout.yap;/home/vsc/github/yap-6.3/library/trees.yap;/home/vsc/github/yap-6.3/library/ugraphs.yap;/home/vsc/github/yap-6.3/library/undgraphs.yap;/home/vsc/github/yap-6.3/library/varnumbers.yap;/home/vsc/github/yap-6.3/library/wdgraphs.yap;/home/vsc/github/yap-6.3/library/wgraphs.yap;/home/vsc/github/yap-6.3/library/wundgraphs.yap;/home/vsc/github/yap-6.3/library/lam_mpi.yap;/home/vsc/github/yap-6.3/library/ypp.yap;/home/vsc/github/yap-6.3/library/ytest.yap;/home/vsc/github/yap-6.3/library/c_alarms.yap;/home/vsc/github/yap-6.3/library/flags.yap;/home/vsc/github/yap-6.3/library/block_diagram.yap;/home/vsc/github/yap-6.3/packages/real/real.pl;/home/vsc/github/yap-6.3/packages/python/swig/prolog/jupyter.yap;/home/vsc/github/yap-6.3/packages/python/swig/prolog/yapi.yap'.split(";") + '/home/vsc/github/yap-6.3/swi/library/aggregate.pl;/home/vsc/github/yap-6.3/swi/library/base64.pl;/home/vsc/github/yap-6.3/swi/library/broadcast.pl;/home/vsc/github/yap-6.3/swi/library/ctypes.pl;/home/vsc/github/yap-6.3/swi/library/date.pl;/home/vsc/github/yap-6.3/swi/library/debug.pl;/home/vsc/github/yap-6.3/swi/library/edit.pl;/home/vsc/github/yap-6.3/swi/library/error.pl;/home/vsc/github/yap-6.3/swi/library/main.pl;/home/vsc/github/yap-6.3/swi/library/menu.pl;/home/vsc/github/yap-6.3/swi/library/nb_set.pl;/home/vsc/github/yap-6.3/swi/library/occurs.yap;/home/vsc/github/yap-6.3/swi/library/operators.pl;/home/vsc/github/yap-6.3/swi/library/option.pl;/home/vsc/github/yap-6.3/swi/library/pairs.pl;/home/vsc/github/yap-6.3/swi/library/plunit.pl;/home/vsc/github/yap-6.3/swi/library/predicate_options.pl;/home/vsc/github/yap-6.3/swi/library/predopts.pl;/home/vsc/github/yap-6.3/swi/library/prolog_clause.pl;/home/vsc/github/yap-6.3/swi/library/prolog_colour.pl;/home/vsc/github/yap-6.3/swi/library/prolog_source.pl;/home/vsc/github/yap-6.3/swi/library/prolog_xref.pl;/home/vsc/github/yap-6.3/swi/library/pure_input.pl;/home/vsc/github/yap-6.3/swi/library/quasi_quotations.pl;/home/vsc/github/yap-6.3/swi/library/quintus.pl;/home/vsc/github/yap-6.3/swi/library/record.pl;/home/vsc/github/yap-6.3/swi/library/settings.pl;/home/vsc/github/yap-6.3/swi/library/shlib.pl;/home/vsc/github/yap-6.3/swi/library/thread_pool.pl;/home/vsc/github/yap-6.3/swi/library/unix.pl;/home/vsc/github/yap-6.3/swi/library/url.pl;/home/vsc/github/yap-6.3/swi/library/utf8.pl;/home/vsc/github/yap-6.3/swi/library/win_menu.pl;/home/vsc/github/yap-6.3/swi/library/www_browser.pl;/home/vsc/github/yap-6.3/swi/library/dcg/basics.pl;/home/vsc/github/yap-6.3/swi/library/aggregate.pl;/home/vsc/github/yap-6.3/swi/library/base64.pl;/home/vsc/github/yap-6.3/swi/library/broadcast.pl;/home/vsc/github/yap-6.3/swi/library/ctypes.pl;/home/vsc/github/yap-6.3/swi/library/date.pl;/home/vsc/github/yap-6.3/swi/library/debug.pl;/home/vsc/github/yap-6.3/swi/library/edit.pl;/home/vsc/github/yap-6.3/swi/library/error.pl;/home/vsc/github/yap-6.3/swi/library/main.pl;/home/vsc/github/yap-6.3/swi/library/menu.pl;/home/vsc/github/yap-6.3/swi/library/nb_set.pl;/home/vsc/github/yap-6.3/swi/library/occurs.yap;/home/vsc/github/yap-6.3/swi/library/operators.pl;/home/vsc/github/yap-6.3/swi/library/option.pl;/home/vsc/github/yap-6.3/swi/library/pairs.pl;/home/vsc/github/yap-6.3/swi/library/plunit.pl;/home/vsc/github/yap-6.3/swi/library/predicate_options.pl;/home/vsc/github/yap-6.3/swi/library/predopts.pl;/home/vsc/github/yap-6.3/swi/library/prolog_clause.pl;/home/vsc/github/yap-6.3/swi/library/prolog_colour.pl;/home/vsc/github/yap-6.3/swi/library/prolog_source.pl;/home/vsc/github/yap-6.3/swi/library/prolog_xref.pl;/home/vsc/github/yap-6.3/swi/library/pure_input.pl;/home/vsc/github/yap-6.3/swi/library/quasi_quotations.pl;/home/vsc/github/yap-6.3/swi/library/quintus.pl;/home/vsc/github/yap-6.3/swi/library/record.pl;/home/vsc/github/yap-6.3/swi/library/settings.pl;/home/vsc/github/yap-6.3/swi/library/shlib.pl;/home/vsc/github/yap-6.3/swi/library/thread_pool.pl;/home/vsc/github/yap-6.3/swi/library/unix.pl;/home/vsc/github/yap-6.3/swi/library/url.pl;/home/vsc/github/yap-6.3/swi/library/utf8.pl;/home/vsc/github/yap-6.3/swi/library/win_menu.pl;/home/vsc/github/yap-6.3/swi/library/www_browser.pl;/home/vsc/github/yap-6.3/swi/library/dcg/basics.pl;/home/vsc/github/yap-6.3/swi/library/aggregate.pl;/home/vsc/github/yap-6.3/swi/library/base64.pl;/home/vsc/github/yap-6.3/swi/library/broadcast.pl;/home/vsc/github/yap-6.3/swi/library/ctypes.pl;/home/vsc/github/yap-6.3/swi/library/date.pl;/home/vsc/github/yap-6.3/swi/library/debug.pl;/home/vsc/github/yap-6.3/swi/library/edit.pl;/home/vsc/github/yap-6.3/swi/library/error.pl;/home/vsc/github/yap-6.3/swi/library/main.pl;/home/vsc/github/yap-6.3/swi/library/menu.pl;/home/vsc/github/yap-6.3/swi/library/nb_set.pl;/home/vsc/github/yap-6.3/swi/library/occurs.yap;/home/vsc/github/yap-6.3/swi/library/operators.pl;/home/vsc/github/yap-6.3/swi/library/option.pl;/home/vsc/github/yap-6.3/swi/library/pairs.pl;/home/vsc/github/yap-6.3/swi/library/plunit.pl;/home/vsc/github/yap-6.3/swi/library/predicate_options.pl;/home/vsc/github/yap-6.3/swi/library/predopts.pl;/home/vsc/github/yap-6.3/swi/library/prolog_clause.pl;/home/vsc/github/yap-6.3/swi/library/prolog_colour.pl;/home/vsc/github/yap-6.3/swi/library/prolog_source.pl;/home/vsc/github/yap-6.3/swi/library/prolog_xref.pl;/home/vsc/github/yap-6.3/swi/library/pure_input.pl;/home/vsc/github/yap-6.3/swi/library/quasi_quotations.pl;/home/vsc/github/yap-6.3/swi/library/quintus.pl;/home/vsc/github/yap-6.3/swi/library/record.pl;/home/vsc/github/yap-6.3/swi/library/settings.pl;/home/vsc/github/yap-6.3/swi/library/shlib.pl;/home/vsc/github/yap-6.3/swi/library/thread_pool.pl;/home/vsc/github/yap-6.3/swi/library/unix.pl;/home/vsc/github/yap-6.3/swi/library/url.pl;/home/vsc/github/yap-6.3/swi/library/utf8.pl;/home/vsc/github/yap-6.3/swi/library/win_menu.pl;/home/vsc/github/yap-6.3/swi/library/www_browser.pl;/home/vsc/github/yap-6.3/swi/library/dcg/basics.pl;/home/vsc/github/yap-6.3/swi/library/aggregate.pl;/home/vsc/github/yap-6.3/swi/library/base64.pl;/home/vsc/github/yap-6.3/swi/library/broadcast.pl;/home/vsc/github/yap-6.3/swi/library/ctypes.pl;/home/vsc/github/yap-6.3/swi/library/date.pl;/home/vsc/github/yap-6.3/swi/library/debug.pl;/home/vsc/github/yap-6.3/swi/library/edit.pl;/home/vsc/github/yap-6.3/swi/library/error.pl;/home/vsc/github/yap-6.3/swi/library/main.pl;/home/vsc/github/yap-6.3/swi/library/menu.pl;/home/vsc/github/yap-6.3/swi/library/nb_set.pl;/home/vsc/github/yap-6.3/swi/library/occurs.yap;/home/vsc/github/yap-6.3/swi/library/operators.pl;/home/vsc/github/yap-6.3/swi/library/option.pl;/home/vsc/github/yap-6.3/swi/library/pairs.pl;/home/vsc/github/yap-6.3/swi/library/plunit.pl;/home/vsc/github/yap-6.3/swi/library/predicate_options.pl;/home/vsc/github/yap-6.3/swi/library/predopts.pl;/home/vsc/github/yap-6.3/swi/library/prolog_clause.pl;/home/vsc/github/yap-6.3/swi/library/prolog_colour.pl;/home/vsc/github/yap-6.3/swi/library/prolog_source.pl;/home/vsc/github/yap-6.3/swi/library/prolog_xref.pl;/home/vsc/github/yap-6.3/swi/library/pure_input.pl;/home/vsc/github/yap-6.3/swi/library/quasi_quotations.pl;/home/vsc/github/yap-6.3/swi/library/quintus.pl;/home/vsc/github/yap-6.3/swi/library/record.pl;/home/vsc/github/yap-6.3/swi/library/settings.pl;/home/vsc/github/yap-6.3/swi/library/shlib.pl;/home/vsc/github/yap-6.3/swi/library/thread_pool.pl;/home/vsc/github/yap-6.3/swi/library/unix.pl;/home/vsc/github/yap-6.3/swi/library/url.pl;/home/vsc/github/yap-6.3/swi/library/utf8.pl;/home/vsc/github/yap-6.3/swi/library/win_menu.pl;/home/vsc/github/yap-6.3/swi/library/www_browser.pl;/home/vsc/github/yap-6.3/swi/library/dcg/basics.pl;/home/vsc/github/yap-6.3/swi/library/aggregate.pl;/home/vsc/github/yap-6.3/swi/library/base64.pl;/home/vsc/github/yap-6.3/swi/library/broadcast.pl;/home/vsc/github/yap-6.3/swi/library/ctypes.pl;/home/vsc/github/yap-6.3/swi/library/date.pl;/home/vsc/github/yap-6.3/swi/library/debug.pl;/home/vsc/github/yap-6.3/swi/library/edit.pl;/home/vsc/github/yap-6.3/swi/library/error.pl;/home/vsc/github/yap-6.3/swi/library/main.pl;/home/vsc/github/yap-6.3/swi/library/menu.pl;/home/vsc/github/yap-6.3/swi/library/nb_set.pl;/home/vsc/github/yap-6.3/swi/library/occurs.yap;/home/vsc/github/yap-6.3/swi/library/operators.pl;/home/vsc/github/yap-6.3/swi/library/option.pl;/home/vsc/github/yap-6.3/swi/library/pairs.pl;/home/vsc/github/yap-6.3/swi/library/plunit.pl;/home/vsc/github/yap-6.3/swi/library/predicate_options.pl;/home/vsc/github/yap-6.3/swi/library/predopts.pl;/home/vsc/github/yap-6.3/swi/library/prolog_clause.pl;/home/vsc/github/yap-6.3/swi/library/prolog_colour.pl;/home/vsc/github/yap-6.3/swi/library/prolog_source.pl;/home/vsc/github/yap-6.3/swi/library/prolog_xref.pl;/home/vsc/github/yap-6.3/swi/library/pure_input.pl;/home/vsc/github/yap-6.3/swi/library/quasi_quotations.pl;/home/vsc/github/yap-6.3/swi/library/quintus.pl;/home/vsc/github/yap-6.3/swi/library/record.pl;/home/vsc/github/yap-6.3/swi/library/settings.pl;/home/vsc/github/yap-6.3/swi/library/shlib.pl;/home/vsc/github/yap-6.3/swi/library/thread_pool.pl;/home/vsc/github/yap-6.3/swi/library/unix.pl;/home/vsc/github/yap-6.3/swi/library/url.pl;/home/vsc/github/yap-6.3/swi/library/utf8.pl;/home/vsc/github/yap-6.3/swi/library/win_menu.pl;/home/vsc/github/yap-6.3/swi/library/www_browser.pl;/home/vsc/github/yap-6.3/swi/library/dcg/basics.pl'.split(";") : copy2(i, 'yap4py/prolog') for i in '/home/vsc/github/yap-6.3/os/edio.yap;/home/vsc/github/yap-6.3/os/chartypes.yap'.split(";") : copy2(i, 'yap4py/prolog/os') for i in '/home/vsc/github/yap-6.3/pl/absf.yap;/home/vsc/github/yap-6.3/pl/arith.yap;/home/vsc/github/yap-6.3/pl/arithpreds.yap;/home/vsc/github/yap-6.3/pl/arrays.yap;/home/vsc/github/yap-6.3/pl/atoms.yap;/home/vsc/github/yap-6.3/pl/attributes.yap;/home/vsc/github/yap-6.3/pl/boot.yap;/home/vsc/github/yap-6.3/pl/bootlists.yap;/home/vsc/github/yap-6.3/pl/callcount.yap;/home/vsc/github/yap-6.3/pl/checker.yap;/home/vsc/github/yap-6.3/pl/consult.yap;/home/vsc/github/yap-6.3/pl/control.yap;/home/vsc/github/yap-6.3/pl/corout.yap;/home/vsc/github/yap-6.3/pl/dbload.yap;/home/vsc/github/yap-6.3/pl/debug.yap;/home/vsc/github/yap-6.3/pl/depth_bound.yap;/home/vsc/github/yap-6.3/pl/dialect.yap;/home/vsc/github/yap-6.3/pl/directives.yap;/home/vsc/github/yap-6.3/pl/eam.yap;/home/vsc/github/yap-6.3/pl/error.yap;/home/vsc/github/yap-6.3/pl/errors.yap;/home/vsc/github/yap-6.3/pl/eval.yap;/home/vsc/github/yap-6.3/pl/flags.yap;/home/vsc/github/yap-6.3/pl/grammar.yap;/home/vsc/github/yap-6.3/pl/ground.yap;/home/vsc/github/yap-6.3/pl/hacks.yap;/home/vsc/github/yap-6.3/pl/init.yap;/home/vsc/github/yap-6.3/pl/listing.yap;/home/vsc/github/yap-6.3/pl/load_foreign.yap;/home/vsc/github/yap-6.3/pl/messages.yap;/home/vsc/github/yap-6.3/pl/meta.yap;/home/vsc/github/yap-6.3/pl/modules.yap;/home/vsc/github/yap-6.3/pl/newmod.yap;/home/vsc/github/yap-6.3/pl/os.yap;/home/vsc/github/yap-6.3/pl/pathconf.yap;/home/vsc/github/yap-6.3/pl/preddecls.yap;/home/vsc/github/yap-6.3/pl/preddyns.yap;/home/vsc/github/yap-6.3/pl/preds.yap;/home/vsc/github/yap-6.3/pl/profile.yap;/home/vsc/github/yap-6.3/pl/protect.yap;/home/vsc/github/yap-6.3/pl/qly.yap;/home/vsc/github/yap-6.3/pl/save.yap;/home/vsc/github/yap-6.3/pl/setof.yap;/home/vsc/github/yap-6.3/pl/signals.yap;/home/vsc/github/yap-6.3/pl/sort.yap;/home/vsc/github/yap-6.3/pl/spy.yap;/home/vsc/github/yap-6.3/pl/statistics.yap;/home/vsc/github/yap-6.3/pl/strict_iso.yap;/home/vsc/github/yap-6.3/pl/swi.yap;/home/vsc/github/yap-6.3/pl/tabling.yap;/home/vsc/github/yap-6.3/pl/threads.yap;/home/vsc/github/yap-6.3/pl/udi.yap;/home/vsc/github/yap-6.3/pl/undefined.yap;/home/vsc/github/yap-6.3/pl/utils.yap;/home/vsc/github/yap-6.3/pl/yapor.yap;/home/vsc/github/yap-6.3/pl/yio.yap'.split(";") : copy2(i, 'yap4py/prolog/pl') -my_libs0 = '/home/vsc/github/yap-6.3/packages/python/*YAPPython*.so;/home/vsc/github/yap-6.3/packages/python/*Py4YAP*.so;/home/vsc/github/yap-6.3/*libYap*.so;/home/vsc/github/yap-6.3/packages/myddas/sqlite3/*Yapsqlite3*.so;/home/vsc/github/yap-6.3/packages/myddas/mysql/*Yapmysql*.so;/home/vsc/github/yap-6.3/packages/myddas/odbc/*Yapodbc*.so;/home/vsc/github/yap-6.3/CXX/*YAP++*.so;/home/vsc/github/yap-6.3/library/matrix/*matrix*.so;/home/vsc/github/yap-6.3/library/random/*yap_random*.so;/home/vsc/github/yap-6.3/library/regex/*regexp*.so;/home/vsc/github/yap-6.3/library/rltree/*yap_rl*.so;/home/vsc/github/yap-6.3/library/system/*sys*.so;/home/vsc/github/yap-6.3/library/tries/*tries*.so;/home/vsc/github/yap-6.3/library/tries/*itries*.so;/home/vsc/github/yap-6.3/packages/raptor/*libxml2*.so;/home/vsc/github/yap-6.3/packages/raptor/*raptor*.so;/home/vsc/github/yap-6.3/packages/CLPBN/horus/*horus*.so;/home/vsc/github/yap-6.3/packages/gecode/*gecode_yap*.so;/home/vsc/github/yap-6.3/packages/real/*real*.so;/home/vsc/github/yap-6.3/packages/jpl/src/c/*jplYap*.so;/home/vsc/github/yap-6.3/packages/swi-minisat2/C/*minisat2*.so;/home/vsc/github/yap-6.3/library/lammpi/*yap_mpi*.so'.split(";")+['/home/vsc/github/yap-6.3/startup.yss'] +my_libs0 = '/home/vsc/github/yap-6.3/packages/python/*YAPPython*.so;/home/vsc/github/yap-6.3/packages/python/*Py4YAP*.so;/home/vsc/github/yap-6.3/*libYap*.so;/home/vsc/github/yap-6.3/packages/myddas/sqlite3/*Yapsqlite3*.so;/home/vsc/github/yap-6.3/packages/myddas/mysql/*Yapmysql*.so;/home/vsc/github/yap-6.3/packages/myddas/odbc/*Yapodbc*.so;/home/vsc/github/yap-6.3/CXX/*YAP++*.so;/home/vsc/github/yap-6.3/library/matrix/*matrix*.so;/home/vsc/github/yap-6.3/library/random/*yap_random*.so;/home/vsc/github/yap-6.3/library/regex/*regexp*.so;/home/vsc/github/yap-6.3/library/rltree/*yap_rl*.so;/home/vsc/github/yap-6.3/library/system/*sys*.so;/home/vsc/github/yap-6.3/library/tries/*tries*.so;/home/vsc/github/yap-6.3/library/tries/*itries*.so;/home/vsc/github/yap-6.3/packages/raptor/*libxml2*.so;/home/vsc/github/yap-6.3/packages/raptor/*raptor*.so;/home/vsc/github/yap-6.3/packages/CLPBN/horus/*horus*.so;/home/vsc/github/yap-6.3/packages/gecode/*gecode_yap*.so;/home/vsc/github/yap-6.3/packages/real/*real*.so;/home/vsc/github/yap-6.3/packages/jpl/src/c/*jplYap*.so;/home/vsc/github/yap-6.3/packages/swi-minisat2/C/*minisat2*.so;/home/vsc/github/yap-6.3/library/lammpi/*yap_mpi*.so;/home/vsc/github/yap-6.3/packages/python/*YAPPython*.so;/home/vsc/github/yap-6.3/packages/python/*Py4YAP*.so;/home/vsc/github/yap-6.3/*libYap*.so;/home/vsc/github/yap-6.3/packages/myddas/sqlite3/*Yapsqlite3*.so;/home/vsc/github/yap-6.3/packages/myddas/mysql/*Yapmysql*.so;/home/vsc/github/yap-6.3/packages/myddas/odbc/*Yapodbc*.so;/home/vsc/github/yap-6.3/CXX/*YAP++*.so;/home/vsc/github/yap-6.3/library/matrix/*matrix*.so;/home/vsc/github/yap-6.3/library/random/*yap_random*.so;/home/vsc/github/yap-6.3/library/regex/*regexp*.so;/home/vsc/github/yap-6.3/library/rltree/*yap_rl*.so;/home/vsc/github/yap-6.3/library/system/*sys*.so;/home/vsc/github/yap-6.3/library/tries/*tries*.so;/home/vsc/github/yap-6.3/library/tries/*itries*.so;/home/vsc/github/yap-6.3/packages/raptor/*libxml2*.so;/home/vsc/github/yap-6.3/packages/raptor/*raptor*.so;/home/vsc/github/yap-6.3/packages/CLPBN/horus/*horus*.so;/home/vsc/github/yap-6.3/packages/gecode/*gecode_yap*.so;/home/vsc/github/yap-6.3/packages/real/*real*.so;/home/vsc/github/yap-6.3/packages/jpl/src/c/*jplYap*.so;/home/vsc/github/yap-6.3/packages/swi-minisat2/C/*minisat2*.so;/home/vsc/github/yap-6.3/library/lammpi/*yap_mpi*.so;/home/vsc/github/yap-6.3/packages/python/*YAPPython*.so;/home/vsc/github/yap-6.3/packages/python/*Py4YAP*.so;/home/vsc/github/yap-6.3/*libYap*.so;/home/vsc/github/yap-6.3/packages/myddas/sqlite3/*Yapsqlite3*.so;/home/vsc/github/yap-6.3/packages/myddas/mysql/*Yapmysql*.so;/home/vsc/github/yap-6.3/packages/myddas/odbc/*Yapodbc*.so;/home/vsc/github/yap-6.3/CXX/*YAP++*.so;/home/vsc/github/yap-6.3/library/matrix/*matrix*.so;/home/vsc/github/yap-6.3/library/random/*yap_random*.so;/home/vsc/github/yap-6.3/library/regex/*regexp*.so;/home/vsc/github/yap-6.3/library/rltree/*yap_rl*.so;/home/vsc/github/yap-6.3/library/system/*sys*.so;/home/vsc/github/yap-6.3/library/tries/*tries*.so;/home/vsc/github/yap-6.3/library/tries/*itries*.so;/home/vsc/github/yap-6.3/packages/raptor/*libxml2*.so;/home/vsc/github/yap-6.3/packages/raptor/*raptor*.so;/home/vsc/github/yap-6.3/packages/CLPBN/horus/*horus*.so;/home/vsc/github/yap-6.3/packages/gecode/*gecode_yap*.so;/home/vsc/github/yap-6.3/packages/real/*real*.so;/home/vsc/github/yap-6.3/packages/jpl/src/c/*jplYap*.so;/home/vsc/github/yap-6.3/packages/swi-minisat2/C/*minisat2*.so;/home/vsc/github/yap-6.3/library/lammpi/*yap_mpi*.so;/home/vsc/github/yap-6.3/packages/python/*YAPPython*.so;/home/vsc/github/yap-6.3/packages/python/*Py4YAP*.so;/home/vsc/github/yap-6.3/*libYap*.so;/home/vsc/github/yap-6.3/packages/myddas/sqlite3/*Yapsqlite3*.so;/home/vsc/github/yap-6.3/packages/myddas/mysql/*Yapmysql*.so;/home/vsc/github/yap-6.3/packages/myddas/odbc/*Yapodbc*.so;/home/vsc/github/yap-6.3/CXX/*YAP++*.so;/home/vsc/github/yap-6.3/library/matrix/*matrix*.so;/home/vsc/github/yap-6.3/library/random/*yap_random*.so;/home/vsc/github/yap-6.3/library/regex/*regexp*.so;/home/vsc/github/yap-6.3/library/rltree/*yap_rl*.so;/home/vsc/github/yap-6.3/library/system/*sys*.so;/home/vsc/github/yap-6.3/library/tries/*tries*.so;/home/vsc/github/yap-6.3/library/tries/*itries*.so;/home/vsc/github/yap-6.3/packages/raptor/*libxml2*.so;/home/vsc/github/yap-6.3/packages/raptor/*raptor*.so;/home/vsc/github/yap-6.3/packages/CLPBN/horus/*horus*.so;/home/vsc/github/yap-6.3/packages/gecode/*gecode_yap*.so;/home/vsc/github/yap-6.3/packages/real/*real*.so;/home/vsc/github/yap-6.3/packages/jpl/src/c/*jplYap*.so;/home/vsc/github/yap-6.3/packages/swi-minisat2/C/*minisat2*.so;/home/vsc/github/yap-6.3/library/lammpi/*yap_mpi*.so;/home/vsc/github/yap-6.3/packages/python/*YAPPython*.so;/home/vsc/github/yap-6.3/packages/python/*Py4YAP*.so;/home/vsc/github/yap-6.3/*libYap*.so;/home/vsc/github/yap-6.3/packages/myddas/sqlite3/*Yapsqlite3*.so;/home/vsc/github/yap-6.3/packages/myddas/mysql/*Yapmysql*.so;/home/vsc/github/yap-6.3/packages/myddas/odbc/*Yapodbc*.so;/home/vsc/github/yap-6.3/CXX/*YAP++*.so;/home/vsc/github/yap-6.3/library/matrix/*matrix*.so;/home/vsc/github/yap-6.3/library/random/*yap_random*.so;/home/vsc/github/yap-6.3/library/regex/*regexp*.so;/home/vsc/github/yap-6.3/library/rltree/*yap_rl*.so;/home/vsc/github/yap-6.3/library/system/*sys*.so;/home/vsc/github/yap-6.3/library/tries/*tries*.so;/home/vsc/github/yap-6.3/library/tries/*itries*.so;/home/vsc/github/yap-6.3/packages/raptor/*libxml2*.so;/home/vsc/github/yap-6.3/packages/raptor/*raptor*.so;/home/vsc/github/yap-6.3/packages/CLPBN/horus/*horus*.so;/home/vsc/github/yap-6.3/packages/gecode/*gecode_yap*.so;/home/vsc/github/yap-6.3/packages/real/*real*.so;/home/vsc/github/yap-6.3/packages/jpl/src/c/*jplYap*.so;/home/vsc/github/yap-6.3/packages/swi-minisat2/C/*minisat2*.so;/home/vsc/github/yap-6.3/library/lammpi/*yap_mpi*.so'.split(";")+['/home/vsc/github/yap-6.3/startup.yss'] my_libs = [] for i in my_libs0: my_libs = glob(i) + my_libs @@ -97,13 +97,13 @@ extensions = [Extension('_yap', native_sources, ('_YAP_NOT_INSTALLED_', '1'), ('YAP_PYTHON', '1'), ('_GNU_SOURCE', '1')], - runtime_library_dirs=['yap4py', '/usr/local/lib', '/usr/local/bin', '', ''], + runtime_library_dirs=['yap4py', '/home/vsc/lib', '/home/vsc/bin', '', ''], swig_opts=['-modern', '-c++', '-py3', '-DX_API', '-I/home/vsc/github/yap-6.3/CXX', '-I/home/vsc/github/yap-6.3/include', '-I/home/vsc/github/yap-6.3/H', '-I/home/vsc/github/yap-6.3/H/generated', '-I/home/vsc/github/yap-6.3/os', '-I/home/vsc/github/yap-6.3/OPTYap', '-I/home/vsc/github/yap-6.3/packages/python'], - library_dirs=['../../..', '../../../CXX', '..', "/usr/local/bin"], + library_dirs=['../../..', '../../../CXX', '..', "/home/vsc/bin"], extra_link_args=my_extra_link_args, libraries=['Yap','gmp']+win_libs+local_libs, include_dirs=['../../..', diff --git a/packages/python/yap_kernel/setup.py.in b/packages/python/yap_kernel/setup.py.in index 3eb5c9f82..583d3d347 100644 --- a/packages/python/yap_kernel/setup.py.in +++ b/packages/python/yap_kernel/setup.py.in @@ -97,25 +97,29 @@ if any(a.startswith(('bdist', 'build', 'install')) for a in sys.argv): argv = make_yap_kernel_cmd(executable='python') dest = os.path.join(here, 'resources') - if os.path.exists(dest): + try: shutil.rmtree(dest) - write_kernel_spec(dest, overrides={'argv': argv}) - shutil.copy('${CMAKE_CURRENT_SOURCE_DIR}/kernel.js',dest) - shutil.copy('${CMAKE_SOURCE_DIR}/misc/editors/prolog.js',dest) - shutil.copy('${CMAKE_SOURCE_DIR}/docs/icons/yap_32x32x32.png',os.path.join(dest,'logo-32x32.png')) - shutil.copy('${CMAKE_SOURCE_DIR}/docs/icons/yap_64x64x32.png',os.path.join(dest,'logo-64x64.png')) - setup_args['data_files'] = [ - (pjoin('share', 'jupyter', 'kernels', KERNEL_NAME), glob(pjoin(dest, '*'))), - ] + os.makedirs( dest ) + shutil.copy2('${CMAKE_SOURCE_DIR}/docs/icons/yap_32x32x32.png',dest) + shutil.copy2('${CMAKE_SOURCE_DIR}/docs/icons/yap_64x64x32.png',dest) + write_kernel_spec(dest, overrides={'argv': argv}) + except: + pass + # shutil.copy('${CMAKE_CURRENT_SOURCE_DIR}/kernel.js',dest) + # shutil.copy('${CMAKE_SOURCE_DIR}/misc/editors/prolog.js',dest) + setup_args['data_files'] = [ + (pjoin('share', 'jupyter', 'kernels', KERNEL_NAME), glob(pjoin(dest, '*'))), + ] mode_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'components', 'codemirror', 'mode', 'prolog') custom_loc = pjoin( sysconfig.get_path('platlib'), 'notebook', 'static', 'custom') try: - os.makedirs(mode_loc) + shutil.copy( pjoin( custom_loc, "custom.js") , pjoin( custom_loc, "custom.js.orig")) + shutil.copy( "${CMAKE_CURRENT_SOURCE_DIR}/custom.js" , pjoin( custom_loc, "custom.js")) + if not os.path.exists(mode_loc): + os.makedirs(mode_loc) shutil.copy( "${CMAKE_SOURCE_DIR}/misc/editors/prolog.js" , mode_loc) except: pass - shutil.copy( pjoin( custom_loc, "custom.js") , pjoin( custom_loc, "custom.js.orig")) - shutil.copy( "${CMAKE_CURRENT_SOURCE_DIR}/custom.js" , pjoin( custom_loc, "custom.js")) extras_require = setuptools_args['extras_require'] = { 'test:python_version=="2.7"': ['mock'], @@ -126,4 +130,4 @@ if 'setuptools' in sys.modules: setup_args.update(setuptools_args) if __name__ == '__main__': - setup(**setup_args) \ No newline at end of file + setup(**setup_args)