40static void RestoreEntries(
PropEntry *,
int USES_REGS);
41static void CleanCode(
PredEntry *USES_REGS);
43static void GrowAtomTable(
void) {
45 UInt size = LOCAL_ExportAtomHashTableSize;
47 UInt new_size = size + (size > 1024 ? size : 1024);
56 for (i = 0; i < size; p++, i++) {
60 const unsigned char *apt;
64 apt = RepAtom(a)->UStrOfAE;
65 hash = HashFunction(apt) / (2 *
sizeof(CELL)) % new_size;
69 if (newp == newt + new_size)
74 LOCAL_ExportAtomHashChain = newt;
75 LOCAL_ExportAtomHashTableSize = new_size;
79static void LookupAtom(
Atom at) {
81 const unsigned char *p = RepAtom(at)->UStrOfAE;
82 CELL hash = HashFunction(p) % LOCAL_ExportAtomHashTableSize;
85 a = LOCAL_ExportAtomHashChain + hash;
91 if (a == LOCAL_ExportAtomHashChain + LOCAL_ExportAtomHashTableSize)
92 a = LOCAL_ExportAtomHashChain;
95 LOCAL_ExportAtomHashTableNum++;
96 if (LOCAL_ExportAtomHashTableNum > LOCAL_ExportAtomHashTableSize / 2) {
98 if (!LOCAL_ExportAtomHashChain) {
104static void GrowFunctorTable(
void) {
106 UInt size = LOCAL_ExportFunctorHashTableSize;
108 UInt new_size = size + (size > 1024 ? size : 1024);
117 for (i = 0; i < size; p++, i++) {
124 hash = ((CELL)(f)) / (2 *
sizeof(CELL)) % new_size;
128 if (newp == newt + new_size)
132 newp->arity = p->arity;
133 newp->name = p->name;
135 LOCAL_ExportFunctorHashChain = newt;
136 LOCAL_ExportFunctorHashTableSize = new_size;
140static void LookupFunctor(
Functor fun) {
143 ((CELL)(fun)) / (2 *
sizeof(CELL)) % LOCAL_ExportFunctorHashTableSize;
145 Atom name = NameOfFunctor(fun);
146 UInt arity = ArityOfFunctor(fun);
148 f = LOCAL_ExportFunctorHashChain + hash;
154 if (f == LOCAL_ExportFunctorHashChain + LOCAL_ExportFunctorHashTableSize)
155 f = LOCAL_ExportFunctorHashChain;
161 LOCAL_ExportFunctorHashTableNum++;
162 if (LOCAL_ExportFunctorHashTableNum > LOCAL_ExportFunctorHashTableSize / 2) {
164 if (!LOCAL_ExportFunctorHashChain) {
170static void GrowPredTable(
void) {
172 UInt size = LOCAL_ExportPredEntryHashTableSize;
174 *oldt = LOCAL_ExportPredEntryHashChain;
175 UInt new_size = size + (size > 1024 ? size : 1024);
184 for (i = 0; i < size; p++, i++) {
191 hash = ((CELL)(pe)) / (2 *
sizeof(CELL)) % new_size;
195 if (newp == newt + new_size)
199 newp->arity = p->arity;
200 newp->u_af.f = p->u_af.f;
201 newp->module = p->module;
203 LOCAL_ExportPredEntryHashChain = newt;
204 LOCAL_ExportPredEntryHashTableSize = new_size;
208static void LookupPredEntry(
PredEntry *pe) {
211 (((CELL)(pe)) / (2 *
sizeof(CELL))) % LOCAL_ExportPredEntryHashTableSize;
213 UInt arity = pe->ArityOfPE;
215 p = LOCAL_ExportPredEntryHashChain + hash;
222 LOCAL_ExportPredEntryHashChain + LOCAL_ExportPredEntryHashTableSize)
223 p = LOCAL_ExportPredEntryHashChain;
227 if (pe->ModuleOfPred != IDB_MODULE) {
229 p->u_af.f = pe->FunctorOfPred;
230 LookupFunctor(pe->FunctorOfPred);
232 p->u_af.a = (
Atom)(pe->FunctorOfPred);
233 LookupAtom((
Atom)(pe->FunctorOfPred));
236 if (pe->PredFlags & AtomDBPredFlag) {
237 p->u_af.a = (
Atom)(pe->FunctorOfPred);
238 p->arity = (CELL)(-2);
239 LookupAtom((
Atom)(pe->FunctorOfPred));
240 }
else if (!(pe->PredFlags & NumberDBPredFlag)) {
241 p->u_af.f = pe->FunctorOfPred;
242 p->arity = (CELL)(-1);
243 LookupFunctor(pe->FunctorOfPred);
245 p->u_af.f = pe->FunctorOfPred;
248 if (pe->ModuleOfPred) {
249 p->module = AtomOfTerm(pe->ModuleOfPred);
251 p->module = AtomProlog;
253 LookupAtom(p->module);
254 LOCAL_ExportPredEntryHashTableNum++;
255 if (LOCAL_ExportPredEntryHashTableNum >
256 LOCAL_ExportPredEntryHashTableSize / 2) {
258 if (!LOCAL_ExportPredEntryHashChain) {
264static void GrowDBRefTable(
void) {
266 UInt size = LOCAL_ExportDBRefHashTableSize;
268 UInt new_size = size + (size > 1024 ? size : 1024);
277 for (i = 0; i < size; p++, i++) {
284 hash = ((CELL)(dbr)) / (2 *
sizeof(CELL)) % new_size;
288 if (newp == newt + new_size)
293 newp->refs = p->refs;
295 LOCAL_ExportDBRefHashChain = newt;
296 LOCAL_ExportDBRefHashTableSize = new_size;
300static void LookupDBRef(
DBRef ref) {
303 ((CELL)(ref)) / (2 *
sizeof(CELL)) % LOCAL_ExportDBRefHashTableSize;
306 a = LOCAL_ExportDBRefHashChain + hash;
313 if (a == LOCAL_ExportDBRefHashChain + LOCAL_ExportDBRefHashTableSize)
314 a = LOCAL_ExportDBRefHashChain;
319 LOCAL_ExportDBRefHashTableNum++;
320 if (LOCAL_ExportDBRefHashTableNum > LOCAL_ExportDBRefHashTableSize / 2) {
322 if (!LOCAL_ExportDBRefHashChain) {
328static void InitHash(
void) {
330 LOCAL_ExportFunctorHashTableNum = 0;
331 LOCAL_ExportFunctorHashTableSize = EXPORT_FUNCTOR_TABLE_SIZE;
334 LOCAL_ExportAtomHashTableNum = 0;
335 LOCAL_ExportAtomHashTableSize = EXPORT_ATOM_TABLE_SIZE;
338 LOCAL_ExportPredEntryHashTableNum = 0;
339 LOCAL_ExportPredEntryHashTableSize = EXPORT_PRED_ENTRY_TABLE_SIZE;
341 LOCAL_ExportPredEntryHashTableSize,
343 LOCAL_ExportDBRefHashTableNum = 0;
344 LOCAL_ExportDBRefHashTableSize = EXPORT_DBREF_TABLE_SIZE;
349static void CloseHash(
void) {
351 LOCAL_ExportFunctorHashTableNum = 0;
352 LOCAL_ExportFunctorHashTableSize = 0L;
353 free(LOCAL_ExportFunctorHashChain);
354 LOCAL_ExportAtomHashTableNum = 0;
355 LOCAL_ExportAtomHashTableSize = 0L;
356 free(LOCAL_ExportAtomHashChain);
357 LOCAL_ExportPredEntryHashTableNum = 0;
358 LOCAL_ExportPredEntryHashTableSize = 0L;
359 free(LOCAL_ExportPredEntryHashChain);
360 LOCAL_ExportDBRefHashTableNum = 0;
361 LOCAL_ExportDBRefHashTableSize = 0L;
362 free(LOCAL_ExportDBRefHashChain);
365static inline Atom AtomAdjust(
Atom a) {
375static inline Term AtomTermAdjust(Term t) {
376 LookupAtom(AtomOfTerm(t));
380static inline Term TermToGlobalOrAtomAdjust(Term t) {
381 if (t && IsAtomTerm(t))
382 return AtomTermAdjust(t);
386#define IsOldCode(P) FALSE
387#define IsOldCodeCellPtr(P) FALSE
388#define IsOldDelay(P) FALSE
389#define IsOldDelayPtr(P) FALSE
390#define IsOldLocalInTR(P) FALSE
391#define IsOldLocalInTRPtr(P) FALSE
392#define IsOldGlobal(P) FALSE
393#define IsOldGlobalPtr(P) FALSE
394#define IsOldTrail(P) FALSE
395#define IsOldTrailPtr(P) FALSE
397#define CharP(X) ((char *)(X))
399#define REINIT_LOCK(P)
400#define REINIT_RWLOCK(P)
401#define BlobTypeAdjust(P) (P)
402#define NoAGCAtomAdjust(P) (P)
403#define OrArgAdjust(P)
404#define TabEntryAdjust(P)
405#define IntegerAdjust(D) (D)
406#define AddrAdjust(P) (P)
407#define MFileAdjust(P) (P)
408#define CodeVarAdjust(P) (P)
409#define ConstantAdjust(P) (P)
410#define ArityAdjust(P) (P)
411#define DoubleInCodeAdjust(P)
412#define IntegerInCodeAdjust(P)
413#define OpcodeAdjust(P) (P)
415static inline Term ModuleAdjust(Term t) {
418 return AtomTermAdjust(t);
431#define ExternalFunctionAdjust(P) (P)
432#define DBRecordAdjust(P) (P)
433#define ModEntryPtrAdjust(P) (P)
434#define AtomEntryAdjust(P) (P)
435#define GlobalEntryAdjust(P) (P)
436#define BlobTermInCodeAdjust(P) (P)
437#define CellPtoHeapAdjust(P) (P)
438#define PtoAtomHashEntryAdjust(P) (P)
439#define CellPtoHeapCellAdjust(P) (P)
440#define CellPtoTRAdjust(P) (P)
441#define CodeAddrAdjust(P) (P)
442#define ConsultObjAdjust(P) (P)
443#define DelayAddrAdjust(P) (P)
444#define DelayAdjust(P) (P)
445#define GlobalAdjust(P) (P)
447#define DBRefAdjust(P, DoRef) DBRefAdjust__(P PASS_REGS)
448static inline DBRef DBRefAdjust__(
DBRef dbt USES_REGS) {
453#define DBRefPAdjust(P) (P)
454#define DBTermAdjust(P) (P)
455#define LUIndexAdjust(P) (P)
456#define SIndexAdjust(P) (P)
457#define LocalAddrAdjust(P) (P)
458#define GlobalAddrAdjust(P) (P)
459#define OpListAdjust(P) (P)
460#define PtoLUCAdjust(P) (P)
461#define PtoStCAdjust(P) (P)
462#define PtoArrayEAdjust(P) (P)
463#define PtoArraySAdjust(P) (P)
464#define PtoGlobalEAdjust(P) (P)
465#define PtoDelayAdjust(P) (P)
466#define PtoGloAdjust(P) (P)
467#define PtoLocAdjust(P) (P)
468#define PtoHeapCellAdjust(P) (P)
469#define TermToGlobalAdjust(P) (P)
470#define PtoOpAdjust(P) (P)
471#define PtoLUClauseAdjust(P) (P)
472#define PtoLUIndexAdjust(P) (P)
473#define PtoDBTLAdjust(P) (P)
474#define PtoPtoPredAdjust(P) (P)
475#define OpRTableAdjust(P) (P)
476#define OpEntryAdjust(P) (P)
477#define PropAdjust(P) (P)
478#define TrailAddrAdjust(P) (P)
479#define XAdjust(P) (P)
480#define YAdjust(P) (P)
481#define HoldEntryAdjust(P) (P)
482#define CodeCharPAdjust(P) (P)
483#define CodeConstCharPAdjust(P) (P)
484#define CodeVoidPAdjust(P) (P)
485#define HaltHookAdjust(P) (P)
487#define recompute_mask(dbr)
489#define rehash(oldcode, NOfE, KindOfEntries)
491static void RestoreFlags(UInt NFlags) {}
495static void RestoreHashPreds(USES_REGS1) {}
497static void RestoreAtomList(
Atom atm USES_REGS) {}
499static size_t save_bytes(FILE *stream,
void *ptr,
size_t sz) {
500 return fwrite(ptr, sz, 1, stream);
503static size_t save_byte(FILE *stream,
int byte) {
508static size_t save_bits16(FILE *stream, BITS16 val) {
510 return save_bytes(stream, &v,
sizeof(BITS16));
513static size_t save_UInt(FILE *stream, UInt val) {
515 return save_bytes(stream, &v,
sizeof(UInt));
518static size_t save_Int(FILE *stream, Int val) {
520 return save_bytes(stream, &v,
sizeof(Int));
523static size_t save_tag(FILE *stream, qlf_tag_t tag) {
524 return save_byte(stream, tag);
527static size_t save_predFlags(FILE *stream, pred_flags_t predFlags) {
528 pred_flags_t v = predFlags;
529 return save_bytes(stream, &v,
sizeof(pred_flags_t));
532static int SaveHash(FILE *stream) {
536 CHECK(save_tag(stream, QLY_START_X));
537 save_UInt(stream, (UInt)&ARG1);
538 CHECK(save_tag(stream, QLY_START_OPCODES));
539 save_Int(stream, _std_top);
540 for (i = 0; i <= _std_top; i++) {
541 save_UInt(stream, (UInt)Yap_opcode(i));
543 CHECK(save_tag(stream, QLY_START_ATOMS));
544 CHECK(save_UInt(stream, LOCAL_ExportAtomHashTableNum));
545 for (i = 0; i < LOCAL_ExportAtomHashTableSize; i++) {
549 CHECK(save_UInt(stream, (UInt)at));
550 CHECK(save_tag(stream, QLY_ATOM));
551 CHECK(save_UInt(stream, strlen((
char *)RepAtom(at)->StrOfAE)));
552 CHECK(save_bytes(stream, (
char *)at->StrOfAE,
553 (strlen((
char *)at->StrOfAE) + 1) *
sizeof(
char)));
556 save_tag(stream, QLY_START_FUNCTORS);
557 save_UInt(stream, LOCAL_ExportFunctorHashTableNum);
558 for (i = 0; i < LOCAL_ExportFunctorHashTableSize; i++) {
562 CHECK(save_UInt(stream, (UInt)(f->val)));
563 CHECK(save_UInt(stream, f->arity));
564 CHECK(save_UInt(stream, (CELL)(f->name)));
566 save_tag(stream, QLY_START_PRED_ENTRIES);
567 save_UInt(stream, LOCAL_ExportPredEntryHashTableNum);
568 for (i = 0; i < LOCAL_ExportPredEntryHashTableSize; i++) {
572 CHECK(save_UInt(stream, (UInt)(p->val)));
573 CHECK(save_UInt(stream, p->arity));
574 CHECK(save_UInt(stream, (UInt)p->module));
575 CHECK(save_UInt(stream, (UInt)p->u_af.f));
577 save_tag(stream, QLY_START_DBREFS);
578 save_UInt(stream, LOCAL_ExportDBRefHashTableNum);
579 for (i = 0; i < LOCAL_ExportDBRefHashTableSize; i++) {
582 CHECK(save_UInt(stream, (UInt)(p->val)));
583 CHECK(save_UInt(stream, p->sz));
584 CHECK(save_UInt(stream, p->refs));
587 save_tag(stream, QLY_FAILCODE);
588 save_UInt(stream, (UInt)FAILCODE);
592static size_t save_clauses(FILE *stream,
PredEntry *pp) {
593 yamop *FirstC, *LastC;
595 FirstC = pp->cs.p_code.FirstClause;
596 LastC = pp->cs.p_code.LastClause;
597 if (FirstC == NULL && LastC == NULL) {
600 if (pp->PredFlags & LogUpdatePredFlag) {
604 if (IN_BETWEEN(cl->ClTimeStart, pp->TimeStampOfPred, cl->ClTimeEnd)) {
605 UInt size = cl->ClSize;
606 CHECK(save_tag(stream, QLY_START_LU_CLAUSE));
607 CHECK(save_UInt(stream, (UInt)cl));
608 CHECK(save_UInt(stream, size));
609 CHECK(save_bytes(stream, cl, size));
613 CHECK(save_tag(stream, QLY_END_LU_CLAUSES));
614 }
else if (pp->PredFlags & MegaClausePredFlag) {
615 MegaClause *cl = ClauseCodeToMegaClause(FirstC);
616 UInt size = cl->ClSize;
618 CHECK(save_UInt(stream, (UInt)cl));
619 CHECK(save_UInt(stream, (UInt)(cl->ClFlags)));
620 CHECK(save_UInt(stream, size));
621 CHECK(save_bytes(stream, cl, size));
622 }
else if (pp->PredFlags & DynamicPredFlag) {
627 UInt size = dcl->ClSize;
629 CHECK(save_UInt(stream, (UInt)cl));
630 CHECK(save_UInt(stream, size));
631 CHECK(save_bytes(stream, dcl, size));
634 cl = NextDynamicClause(cl);
639 if (pp->PredFlags & SYSTEM_PRED_FLAGS) {
643 UInt size = cl->ClSize;
645 CHECK(save_UInt(stream, (UInt)cl));
646 CHECK(save_UInt(stream, size));
647 CHECK(save_bytes(stream, cl, size));
648 if (cl->ClCode == LastC)
656static size_t save_pred(FILE *stream,
PredEntry *ap) {
657 CHECK(save_UInt(stream, (UInt)ap));
658 CHECK(save_predFlags(stream, ap->PredFlags));
659 if (ap->PredFlags & ForeignPredFlags)
661 CHECK(save_UInt(stream, ap->cs.p_code.NOfClauses));
662 CHECK(save_UInt(stream, ap->src.IndxId));
663 CHECK(save_UInt(stream, ap->TimeStampOfPred));
664 return save_clauses(stream, ap);
667static int clean_pred(
PredEntry *pp USES_REGS) {
668 if (pp->PredFlags & ForeignPredFlags) {
671 CleanClauses(pp->cs.p_code.FirstClause, pp->cs.p_code.LastClause,
679 if (ap->ModuleOfPred != IDB_MODULE) {
681 FuncAdjust(ap->FunctorOfPred);
683 AtomAdjust((
Atom)(ap->FunctorOfPred));
686 if (ap->PredFlags & AtomDBPredFlag) {
687 AtomAdjust((
Atom)(ap->FunctorOfPred));
688 }
else if (!(ap->PredFlags & NumberDBPredFlag)) {
689 FuncAdjust(ap->FunctorOfPred);
692 if (!(ap->PredFlags & (MultiFileFlag | NumberDBPredFlag)) &&
694 AtomAdjust(ap->src.OwnerFile);
697 CHECK(clean_pred(ap PASS_REGS));
701static size_t mark_ops(FILE *stream, Term mod) {
704 if (!mod || op->OpModule == mod) {
705 AtomAdjust(op->OpName);
707 AtomTermAdjust(op->OpModule);
714static size_t save_ops(FILE *stream, Term mod) {
717 if (!mod || op->OpModule == mod) {
718 CHECK(save_tag(stream, QLY_NEW_OP));
719 save_UInt(stream, (UInt)op->OpName);
720 save_UInt(stream, (UInt)op->OpModule);
721 save_bits16(stream, op->Prefix);
722 save_bits16(stream, op->Infix);
723 save_bits16(stream, op->Posfix);
727 CHECK(save_tag(stream, QLY_END_OPS));
731static size_t save_header(FILE *stream,
char type[]) {
734 memset(msg, 0, 2048);
736 "#!/bin/sh\nexec_dir=${YAPBINDIR:-%s}\nexec $exec_dir/yap $0 "
738 YAP_BINDIR, type, YAP_FULL_VERSION);
739 return save_bytes(stream, msg, 2048);
742static size_t save_module(FILE *stream, Term mod) {
744 save_header(stream,
"saved module,");
748 ap = PredEntryAdjust(ap);
749 CHECK(mark_pred(ap));
750 ap = ap->NextPredOfModule;
753 mark_ops(stream, mod);
755 CHECK(save_tag(stream, QLY_START_MODULE));
756 CHECK(save_UInt(stream, (UInt)mod));
757 ap = Yap_ModulePred(mod);
759 CHECK(save_tag(stream, QLY_START_PREDICATE));
760 CHECK(save_pred(stream, ap));
761 ap = ap->NextPredOfModule;
763 CHECK(save_tag(stream, QLY_END_PREDICATES));
764 CHECK(save_tag(stream, QLY_END_MODULES));
765 save_ops(stream, mod);
770static size_t save_program(FILE *stream) {
774 save_header(stream,
"saved state,");
784 pp = PredEntryAdjust(pp);
785 CHECK(mark_pred(pp));
786 pp = pp->NextPredOfModule;
798 CHECK(save_tag(stream, QLY_START_MODULE));
799 CHECK(save_UInt(stream, (UInt)MkAtomTerm(me->
AtomOfME)));
801 CHECK(save_tag(stream, QLY_START_PREDICATE));
802 CHECK(save_pred(stream, pp));
803 pp = pp->NextPredOfModule;
805 CHECK(save_tag(stream, QLY_END_PREDICATES));
808 CHECK(save_tag(stream, QLY_END_MODULES));
814static size_t save_file(FILE *stream,
Atom FileName) {
818 save_header(stream,
"saved file,");
825 pp = PredEntryAdjust(pp);
827 !(pp->PredFlags & (MultiFileFlag | NumberDBPredFlag | AtomDBPredFlag |
828 CPredFlag | AsmPredFlag | UserCPredFlag)) &&
829 pp->ModuleOfPred != IDB_MODULE && pp->src.OwnerFile == FileName) {
830 CHECK(mark_pred(pp));
832 pp = pp->NextPredOfModule;
844 CHECK(save_tag(stream, QLY_START_MODULE));
845 CHECK(save_UInt(stream, (UInt)MkAtomTerm(me->
AtomOfME)));
848 !(pp->PredFlags & (MultiFileFlag | NumberDBPredFlag | AtomDBPredFlag |
849 CPredFlag | AsmPredFlag | UserCPredFlag)) &&
850 pp->src.OwnerFile == FileName) {
851 CHECK(save_tag(stream, QLY_START_PREDICATE));
852 CHECK(save_pred(stream, pp));
854 pp = pp->NextPredOfModule;
856 CHECK(save_tag(stream, QLY_END_PREDICATES));
859 CHECK(save_tag(stream, QLY_END_MODULES));
865static Int qsave_module_preds(USES_REGS1) {
867 Term tmod = Deref(ARG2);
868 Term t1 = Deref(ARG1);
871 Yap_Error(INSTANTIATION_ERROR, t1,
"save_module/3");
874 if (!IsAtomTerm(t1)) {
875 Yap_Error(TYPE_ERROR_ATOM, t1,
"save_module/3");
878 if (!(stream = Yap_GetOutputStream(t1,
"save_module"))) {
881 if (IsVarTerm(tmod)) {
882 Yap_Error(INSTANTIATION_ERROR, tmod,
"save_module/2");
885 if (!IsAtomTerm(tmod)) {
886 Yap_Error(TYPE_ERROR_ATOM, tmod,
"save_module/2");
889 return save_module(stream, tmod) != 0;
892static Int qsave_program(USES_REGS1) {
894 Term t1 = Deref(ARG1);
896 if (!(stream = Yap_GetOutputStream(t1,
"save_program"))) {
899 return save_program(stream) != 0;
902static Int qsave_file(USES_REGS1) {
904 Term t1 = Deref(ARG1);
905 Term tfile = Deref(ARG2);
907 if (!(stream = Yap_GetOutputStream(t1,
"save_file/2"))) {
910 if (IsVarTerm(tfile)) {
911 Yap_Error(INSTANTIATION_ERROR, tfile,
"save_file/2");
914 if (!IsAtomTerm(tfile)) {
915 Yap_Error(TYPE_ERROR_ATOM, tfile,
"save_file/2");
918 return save_file(stream, AtomOfTerm(tfile)) != 0;
921void Yap_InitQLY(
void) {
922 Yap_InitCPred(
"$qsave_module_preds", 2, qsave_module_preds,
923 SyncPredFlag | UserCPredFlag);
924 Yap_InitCPred(
"$qsave_program", 1, qsave_program,
925 SyncPredFlag | UserCPredFlag);
926 Yap_InitCPred(
"$qsave_file_preds", 2, qsave_file,
927 SyncPredFlag | UserCPredFlag);
load_foreign_files/3 has works for the following configurations:
Module property: low-level data used to manage modes.
struct mod_entry * NextME
Module local flags (from SWI compat)
Atom AtomOfME
index in operator table
struct pred_entry * PredForME
kind of property