39static void RestoreEntries(
PropEntry *,
int USES_REGS);
40static void CleanCode(
PredEntry *USES_REGS);
43 OUT_OF_TEMP_SPACE = 0,
44 OUT_OF_ATOM_SPACE = 1,
45 OUT_OF_CODE_SPACE = 2,
48 UNKNOWN_PRED_ENTRY = 5,
53 INCONSISTENT_CPRED = 10,
58static char *qlyr_error[] = {
59 "out of temporary space",
60 "out of temporary space",
62 "unknown atom in saved space",
63 "unknown functor in saved space",
64 "unknown predicate in saved space",
65 "unknown YAAM opcode in saved space",
66 "unknown data-base reference in saved space",
67 "corrupted atom in saved space",
68 "formatting mismatch in saved space",
69 "foreign predicate has different definition in saved space",
72static char *Yap_AlwaysAllocCodeSpace(UInt size) {
74 while (!(out = Yap_AllocCodeSpace(size))) {
75 if (!Yap_growheap(FALSE, size, NULL)) {
83#define QLYR_ERROR(err) \
84 QLYR_ERROR__(__FILE__, __FUNCTION__, __LINE__, err)
88static void QLYR_ERROR__(
const char *file,
const char *
function,
int lineno,
92 Yap_Error__(
false, file,
function, lineno, SYSTEM_ERROR_SAVED_STATE, TermNil,
"error %s in saved state %s",
93 GLOBAL_RestoreFile, qlyr_error[my_err]);
99 CELL hash = (CELL)(oat) % LOCAL_ImportAtomHashTableSize;
102 a = LOCAL_ImportAtomHashChain[hash];
104 if (a->oval == oat) {
111 QLYR_ERROR(UNKNOWN_ATOM);
115static void InsertAtom(
Atom oat,
Atom at) {
117 CELL hash = (CELL)(oat) % LOCAL_ImportAtomHashTableSize;
120 a = LOCAL_ImportAtomHashChain[hash];
122 if (a->oval == oat) {
133 a->next = LOCAL_ImportAtomHashChain[hash];
134 LOCAL_ImportAtomHashChain[hash] = a;
139 CELL hash = (CELL)(ofun) % LOCAL_ImportFunctorHashTableSize;
142 f = LOCAL_ImportFunctorHashChain[hash];
144 if (f->oval == ofun) {
149 QLYR_ERROR(UNKNOWN_FUNCTOR);
155 CELL hash = (CELL)(ofun) % LOCAL_ImportFunctorHashTableSize;
158 f = LOCAL_ImportFunctorHashChain[hash];
160 if (f->oval == ofun) {
172 f->next = LOCAL_ImportFunctorHashChain[hash];
173 LOCAL_ImportFunctorHashChain[hash] = f;
181 if (LOCAL_ImportPredEntryHashTableSize == 0)
183 hash = (CELL)(op) % LOCAL_ImportPredEntryHashTableSize;
184 p = LOCAL_ImportPredEntryHashChain[hash];
191 QLYR_ERROR(UNKNOWN_PRED_ENTRY);
200 if (LOCAL_ImportPredEntryHashTableSize == 0)
202 hash = (CELL)(op) % LOCAL_ImportPredEntryHashTableSize;
203 p = LOCAL_ImportPredEntryHashChain[hash];
217 p->next = LOCAL_ImportPredEntryHashChain[hash];
218 LOCAL_ImportPredEntryHashChain[hash] = p;
221static OPCODE LookupOPCODE(OPCODE op) {
223 CELL hash = (CELL)(op) % LOCAL_ImportOPCODEHashTableSize;
226 f = LOCAL_ImportOPCODEHashChain[hash];
233 QLYR_ERROR(UNKNOWN_OPCODE);
237static int OpcodeID(OPCODE op) {
239 CELL hash = (CELL)(op) % LOCAL_ImportOPCODEHashTableSize;
242 f = LOCAL_ImportOPCODEHashChain[hash];
249 QLYR_ERROR(UNKNOWN_OPCODE);
253static void InsertOPCODE(OPCODE op0,
int i, OPCODE op) {
255 CELL hash = (CELL)(op0) % LOCAL_ImportOPCODEHashTableSize;
257 f = LOCAL_ImportOPCODEHashChain[hash];
259 if (f->oval == op0) {
271 f->next = LOCAL_ImportOPCODEHashChain[hash];
272 LOCAL_ImportOPCODEHashChain[hash] = f;
275static DBRef LookupDBRef(
DBRef dbr,
int inc_ref) {
280 if (LOCAL_ImportDBRefHashTableSize == 0)
282 hash = (CELL)(dbr) % LOCAL_ImportDBRefHashTableSize;
283 p = LOCAL_ImportDBRefHashChain[hash];
285 if (p->oval == dbr) {
293 QLYR_ERROR(UNKNOWN_DBREF);
302 if (LOCAL_ImportDBRefHashTableSize == 0)
304 hash = (CELL)(dbr) % LOCAL_ImportDBRefHashTableSize;
305 p = LOCAL_ImportDBRefHashChain[hash];
307 if (p->oval == dbr) {
316static void InsertDBRef(
DBRef dbr0,
DBRef dbr) {
318 CELL hash = (CELL)(dbr0) % LOCAL_ImportDBRefHashTableSize;
321 p = LOCAL_ImportDBRefHashChain[hash];
323 if (p->oval == dbr0) {
335 p->next = LOCAL_ImportDBRefHashChain[hash];
336 LOCAL_ImportDBRefHashChain[hash] = p;
339static void InitHash(
void) {
341 LOCAL_ImportOPCODEHashTableSize = EXPORT_OPCODE_TABLE_SIZE;
347static void CloseHash(
void) {
350 for (i = 0; i < LOCAL_ImportFunctorHashTableSize; i++) {
358 LOCAL_ImportFunctorHashTableSize = 0;
359 free(LOCAL_ImportFunctorHashChain);
360 LOCAL_ImportFunctorHashChain = NULL;
361 for (i = 0; i < LOCAL_ImportAtomHashTableSize; i++) {
369 LOCAL_ImportAtomHashTableSize = 0;
370 free(LOCAL_ImportAtomHashChain);
371 LOCAL_ImportAtomHashChain = NULL;
372 for (i = 0; i < LOCAL_ImportOPCODEHashTableSize; i++) {
380 LOCAL_ImportOPCODEHashTableSize = 0;
381 free(LOCAL_ImportOPCODEHashChain);
382 LOCAL_ImportOPCODEHashChain = NULL;
383 for (i = 0; i < LOCAL_ImportPredEntryHashTableSize; i++) {
391 LOCAL_ImportPredEntryHashTableSize = 0;
392 free(LOCAL_ImportPredEntryHashChain);
393 LOCAL_ImportPredEntryHashChain = NULL;
394 for (i = 0; i < LOCAL_ImportDBRefHashTableSize; i++) {
400 fprintf(stderr,
"WARNING: unused reference %p %p\n", a->val, a->oval);
407 LOCAL_ImportDBRefHashTableSize = 0;
408 free(LOCAL_ImportDBRefHashChain);
409 LOCAL_ImportDBRefHashChain = NULL;
412static inline Atom AtomAdjust(
Atom a) {
return LookupAtom(a); }
415 return LookupFunctor(f);
419static inline Term AtomTermAdjust(Term t) {
420 return MkAtomTerm(LookupAtom(AtomOfTerm(t)));
423static inline Term TermToGlobalOrAtomAdjust(Term t) {
424 if (t && IsAtomTerm(t))
425 return AtomTermAdjust(t);
429#define IsOldCode(P) FALSE
430#define IsOldCodeCellPtr(P) FALSE
431#define IsOldDelay(P) FALSE
432#define IsOldDelayPtr(P) FALSE
433#define IsOldLocalInTR(P) FALSE
434#define IsOldLocalInTRPtr(P) FALSE
435#define IsOldGlobal(P) FALSE
436#define IsOldGlobalPtr(P) FALSE
437#define IsOldTrail(P) FALSE
438#define IsOldTrailPtr(P) FALSE
440#define CharP(X) ((char *)(X))
442#define REINIT_LOCK(P)
443#define REINIT_RWLOCK(P)
444#define BlobTypeAdjust(P) (P)
445#define NoAGCAtomAdjust(P) (P)
446#define OrArgAdjust(P)
447#define TabEntryAdjust(P)
448#define IntegerAdjust(D) (D)
449#define AddrAdjust(P) (P)
450#define MFileAdjust(P) (P)
452#define CodeVarAdjust(P) CodeVarAdjust__(P PASS_REGS)
453static inline Term CodeVarAdjust__(Term var USES_REGS) {
456 return (Term)(CharP(var) + LOCAL_HDiff);
459#define ConstantAdjust(P) (P)
460#define ArityAdjust(P) (P)
461#define DoubleInCodeAdjust(P)
462#define IntegerInCodeAdjust(Pxb)
465 return LookupPredEntry(p);
469 return LookupPredEntry(p);
472static inline OPCODE OpcodeAdjust(OPCODE OP) {
return LookupOPCODE(OP); }
474static inline Term ModuleAdjust(Term
M) {
477 return AtomTermAdjust(
M);
480#define ExternalFunctionAdjust(P) (P)
481#define DBRecordAdjust(P) (P)
482#define ModEntryPtrAdjust(P) (P)
483#define AtomEntryAdjust(P) (P)
484#define GlobalEntryAdjust(P) (P)
485#define BlobTermInCodeAdjust(P) BlobTermInCodeAdjust__(P PASS_REGS)
487static inline Term BlobTermInCodeAdjust__(Term t USES_REGS) {
488 return (Term)((
char *)(t)-LOCAL_HDiff);
491static inline Term BlobTermInCodeAdjust__(Term t USES_REGS) {
492 return (Term)((
char *)(t) + LOCAL_HDiff);
495#define DBTermAdjust(P) DBTermAdjust__(P PASS_REGS)
496static inline DBTerm *DBTermAdjust__(
DBTerm *dbtp USES_REGS) {
497 return (
DBTerm *)(CharP(dbtp) + LOCAL_HDiff);
500#define CellPtoHeapAdjust(P) CellPtoHeapAdjust__(P PASS_REGS)
501static inline CELL *CellPtoHeapAdjust__(CELL *dbtp USES_REGS) {
502 return (CELL *)(CharP(dbtp) + LOCAL_HDiff);
505#define PtoAtomHashEntryAdjust(P) (P)
506#define CellPtoHeapCellAdjust(P) (P)
507#define CellPtoTRAdjust(P) (P)
508#define CodeAddrAdjust(P) (P)
509#define ConsultObjAdjust(P) (P)
510#define DelayAddrAdjust(P) (P)
511#define DelayAdjust(P) (P)
512#define GlobalAdjust(P) (P)
514#define DBRefAdjust(P, Ref) DBRefAdjust__(P, Ref PASS_REGS)
515static inline DBRef DBRefAdjust__(
DBRef dbtp,
int do_reference USES_REGS) {
516 return LookupDBRef(dbtp, do_reference);
519#define DBRefPAdjust(P) DBRefPAdjust__(P PASS_REGS)
520static inline DBRef *DBRefPAdjust__(
DBRef *dbtp USES_REGS) {
521 return (
DBRef *)((
char *)(dbtp) + LOCAL_HDiff);
524#define LUIndexAdjust(P) (P)
525#define SIndexAdjust(P) (P)
526#define LocalAddrAdjust(P) (P)
527#define GlobalAddrAdjust(P) (P)
528#define OpListAdjust(P) (P)
530#define PtoLUCAdjust(P) PtoLUCAdjust__(P PASS_REGS)
531#define PtoLUClauseAdjust(P) PtoLUCAdjust__(P PASS_REGS)
536#define PtoStCAdjust(P) (P)
537#define PtoArrayEAdjust(P) (P)
538#define PtoArraySAdjust(P) (P)
539#define PtoGlobalEAdjust(P) (P)
540#define PtoDelayAdjust(P) (P)
541#define PtoGloAdjust(P) (P)
542#define PtoLocAdjust(P) (P)
544#define PtoHeapCellAdjust(P) PtoHeapCellAdjust__(P PASS_REGS)
545static inline CELL *PtoHeapCellAdjust__(CELL *ptr USES_REGS) {
547 if ((out = LookupMayFailDBRef((
DBRef)ptr)))
549 return (CELL *)(CharP(ptr) + LOCAL_HDiff);
552#define TermToGlobalAdjust(P) (P)
553#define PtoOpAdjust(P) PtoOpAdjust__(P PASS_REGS)
554static inline yamop *PtoOpAdjust__(
yamop *ptr USES_REGS) {
556 if (ptr == LOCAL_ImportFAILCODE)
558 return (
yamop *)((
char *)(ptr) + LOCAL_HDiff);
562#define PtoLUIndexAdjust(P) (P)
563#define PtoDBTLAdjust(P) (P)
564#define PtoPtoPredAdjust(P) (P)
565#define OpRTableAdjust(P) (P)
566#define OpEntryAdjust(P) (P)
567#define PropAdjust(P) (P)
568#define TrailAddrAdjust(P) (P)
569#if PRECOMPUTE_REGADDRESS
570#define XAdjust(P) XAdjust__(P PASS_REGS)
571static inline wamreg XAdjust__(wamreg reg USES_REGS) {
572 return (wamreg)((wamreg)((reg) + LOCAL_XDiff));
575#define XAdjust(X) (X)
577#define YAdjust(X) (X)
578#define HoldEntryAdjust(P) (P)
579#define CodeCharPAdjust(P) (P)
580#define CodeConstCharPAdjust(P) (P)
581#define CodeVoidPAdjust(P) (P)
582#define HaltHookAdjust(P) (P)
584#define recompute_mask(dbr)
586#define rehash(oldcode, NOfE, KindOfEntries)
588#define RestoreSWIHash()
590#define Yap_op_from_opcode(OP) OpcodeID(OP)
592static void RestoreFlags(UInt NFlags) {}
596static void RestoreHashPreds(USES_REGS1) {}
598static void RestoreAtomList(
Atom atm USES_REGS) {}
600static bool maybe_read_bytes(FILE *stream,
void *ptr,
size_t sz) {
603 if ((count = fread(ptr, 1, sz, stream)) == sz)
605 if (feof(stream) || ferror(stream))
612static size_t read_bytes(FILE *stream,
void *ptr,
size_t sz) {
614 size_t count = fread(ptr, 1, sz, stream);
618 PlIOError(PERMISSION_ERROR_INPUT_PAST_END_OF_STREAM, TermNil,
"read_qly/3: expected %ld bytes got %ld", sz, count);
620 }
else if (ferror(stream)) {
621 PlIOError(PERMISSION_ERROR_INPUT_STREAM, TermNil,
"read_qly/3: expected %ld bytes got error %s", sz, strerror(errno));
628static unsigned char read_byte(FILE *stream) {
return getc(stream); }
630static BITS16 read_bits16(FILE *stream) {
632 read_bytes(stream, &v,
sizeof(BITS16));
636static UInt read_UInt(FILE *stream) {
638 read_bytes(stream, &v,
sizeof(UInt));
642static Int read_Int(FILE *stream) {
644 read_bytes(stream, &v,
sizeof(Int));
648static qlf_tag_t read_tag(FILE *stream) {
649 int ch = read_byte(stream);
653static pred_flags_t read_predFlags(FILE *stream) {
655 read_bytes(stream, &v,
sizeof(pred_flags_t));
660static Atom do_header(FILE *stream) {
661 char s[2049], *p = s, *q;
662 char h0[] =
"#!/bin/sh\nexec_dir=${YAPBINDIR:-";
663 char h1[] =
"exec $exec_dir/yap $0 \"$@\"\nsaved ";
667 if (!maybe_read_bytes( stream, s, 2048) )
669 if (strstr(s, h0)!= s)
671 if ((p=strstr(s, h1)) == NULL) {
679 at = Yap_LookupAtom(p);
683static Int get_header(USES_REGS1) {
685 Term t1 = Deref(ARG1);
690 Yap_Error(INSTANTIATION_ERROR, t1,
"read_program/3");
693 if (!(stream = Yap_GetInputStream(t1,
"header scanning in qload"))) {
696 sigjmp_buf signew, *sighold = LOCAL_RestartEnv;
697 LOCAL_RestartEnv = &signew;
699 if (sigsetjmp(signew, 1) != 0) {
700 LOCAL_RestartEnv = sighold;
703 if ((at = do_header(stream)) == NIL)
706 rc = Yap_unify(ARG2, MkAtomTerm(at));
708 LOCAL_RestartEnv = sighold;
712static void ReadHash(FILE *stream) {
715 RCHECK(read_tag(stream) == QLY_START_X);
716 LOCAL_XDiff = (
char *)(&ARG1) - (
char *)read_UInt(stream);
717 RCHECK(read_tag(stream) == QLY_START_OPCODES);
718 RCHECK(read_Int(stream) == _std_top);
719 for (i = 0; i <= _std_top; i++) {
720 InsertOPCODE((OPCODE)read_UInt(stream), i, Yap_opcode(i));
722 RCHECK(read_tag(stream) == QLY_START_ATOMS);
723 LOCAL_ImportAtomHashTableNum = read_UInt(stream);
724 LOCAL_ImportAtomHashTableSize = LOCAL_ImportAtomHashTableNum * 2;
727 for (i = 0; i < LOCAL_ImportAtomHashTableNum; i++) {
730 qlf_tag_t tg = read_tag(stream);
732 if (tg == QLY_ATOM) {
733 char *rep = (
char *)AllocTempSpace();
736 len = read_UInt(stream);
737 if (!EnoughTempSpace(len))
738 QLYR_ERROR(OUT_OF_TEMP_SPACE);
739 read_bytes(stream, rep, (len + 1) *
sizeof(
char));
740 while (!(at = Yap_FullLookupAtom(rep))) {
741 if (!Yap_growheap(FALSE, 0, NULL)) {
746 QLYR_ERROR(OUT_OF_ATOM_SPACE);
748 QLYR_ERROR(BAD_ATOM);
754 RCHECK(read_tag(stream) == QLY_START_FUNCTORS);
755 LOCAL_ImportFunctorHashTableNum = read_UInt(stream);
756 LOCAL_ImportFunctorHashTableSize = 2 * LOCAL_ImportFunctorHashTableNum;
759 for (i = 0; i < LOCAL_ImportFunctorHashTableNum; i++) {
761 UInt arity = read_UInt(stream);
763 Atom at = AtomAdjust(oat);
765 while (!(f = Yap_MkFunctor(at, arity))) {
766 if (!Yap_growheap(FALSE, 0, NULL)) {
770 InsertFunctor(of, f);
772 RCHECK(read_tag(stream) == QLY_START_PRED_ENTRIES);
773 LOCAL_ImportPredEntryHashTableNum = read_UInt(stream);
774 LOCAL_ImportPredEntryHashTableSize = 2 * LOCAL_ImportPredEntryHashTableNum;
776 LOCAL_ImportPredEntryHashTableSize,
778 for (i = 0; i < LOCAL_ImportPredEntryHashTableNum; i++) {
780 UInt arity = read_UInt(stream);
781 Atom omod = (
Atom)read_UInt(stream);
785 mod = MkAtomTerm(AtomAdjust(omod));
786 if (mod == TermProlog)
792 if (mod != IDB_MODULE) {
796 while (!(pe = RepPredProp(PredPropByFuncAndMod(f, mod)))) {
797 if (!Yap_growheap(FALSE, 0, NULL)) {
803 Atom a = LookupAtom(oa);
804 pe = RepPredProp(PredPropByAtomAndMod(a, mod));
808 if (arity == (UInt)-1) {
809 UInt i = read_UInt(stream);
810 pe = Yap_FindLUIntKey(i);
811 }
else if (arity == (UInt)(-2)) {
813 Atom a = LookupAtom(oa);
814 pe = RepPredProp(PredPropByAtomAndMod(a, mod));
815 pe->PredFlags |= AtomDBPredFlag;
819 pe = RepPredProp(PredPropByFuncAndMod(f, mod));
821 pe->PredFlags |= LogUpdatePredFlag;
823 if (pe->OpcodeOfPred == UNDEF_OPCODE) {
824 pe->OpcodeOfPred = Yap_opcode(_op_fail);
825 pe->cs.p_code.TrueCodeOfPred = pe->CodeOfPred = FAILCODE;
828 InsertPredEntry(ope, pe);
830 RCHECK(read_tag(stream) == QLY_START_DBREFS);
831 LOCAL_ImportDBRefHashTableNum = read_UInt(stream);
832 LOCAL_ImportDBRefHashTableSize = 2 * LOCAL_ImportDBRefHashTableNum + 17;
835 for (i = 0; i < LOCAL_ImportDBRefHashTableNum; i++) {
837 UInt sz = read_UInt(stream);
838 UInt nrefs = read_UInt(stream);
840 Yap_LUClauseSpace += sz;
842 QLYR_ERROR(OUT_OF_CODE_SPACE);
844 ncl->Id = FunctorDBRef;
845 ncl->ClRefCount = nrefs;
848 RCHECK(read_tag(stream) == QLY_FAILCODE);
849 LOCAL_ImportFAILCODE = (
yamop *)read_UInt(stream);
852static void read_clauses(FILE *stream,
PredEntry *pp, UInt nclauses,
853 pred_flags_t flags) {
855 if (flags & LogUpdatePredFlag) {
857 while ((read_tag(stream) == QLY_START_LU_CLAUSE)) {
858 char *base = (
void *)read_UInt(stream);
859 UInt size = read_UInt(stream);
863 if ((cl = LookupMayFailDBRef((
DBRef)base))) {
864 nrefs = cl->ClRefCount;
867 Yap_LUClauseSpace += size;
869 read_bytes(stream, cl, size);
870 cl->ClFlags &= ~InUseMask;
871 cl->ClRefCount = nrefs;
872 LOCAL_HDiff = (
char *)cl - base;
873 RestoreLUClause(cl, pp PASS_REGS);
874 Yap_AssertzClause(pp, cl->ClCode);
876 }
else if (flags & MegaClausePredFlag) {
878 char *base = (
void *)read_UInt(stream);
879 UInt mask = read_UInt(stream);
880 UInt size = read_UInt(stream);
881 Yap_ClauseSpace += size;
887 LOCAL_HDiff = (
char *)cl - base;
888 read_bytes(stream, cl, size);
890 pp->cs.p_code.FirstClause = pp->cs.p_code.LastClause = cl->ClCode;
891 pp->PredFlags |= MegaClausePredFlag;
893 if (mask & ExoMask) {
895 pp->OpcodeOfPred = Yap_opcode(_enter_exo);
899 pp->OpcodeOfPred = INDEX_OPCODE;
901 pp->CodeOfPred = pp->cs.p_code.TrueCodeOfPred =
902 (
yamop *)(&(pp->OpcodeOfPred));
904 pp->cs.p_code.NOfClauses = nclauses;
905 RestoreMegaClause(cl PASS_REGS);
906 }
else if (flags & DynamicPredFlag) {
909 for (i = 0; i < nclauses; i++) {
910 char *base = (
void *)read_UInt(stream);
911 UInt size = read_UInt(stream);
913 Yap_LUClauseSpace += size;
915 LOCAL_HDiff = (
char *)cl - base;
916 read_bytes(stream, cl, size);
917 INIT_LOCK(cl->ClLock);
918 RestoreDynamicClause(cl, pp PASS_REGS);
919 Yap_AssertzClause(pp, cl->ClCode);
925 if (flags & SYSTEM_PRED_FLAGS) {
927 QLYR_ERROR(INCONSISTENT_CPRED);
931 if (pp->cs.p_code.NOfClauses) {
933 cl = ClauseCodeToStaticClause(pp->cs.p_code.FirstClause);
936 Yap_EraseStaticClause(cl, pp, CurrentModule);
938 }
while (cl != NULL);
939 }
else if (flags & MultiFileFlag) {
940 pp->CodeOfPred = pp->cs.p_code.TrueCodeOfPred = FAILCODE;
941 pp->OpcodeOfPred = FAIL_OPCODE;
944 for (i = 0; i < nclauses; i++) {
945 char *base = (
void *)read_UInt(stream);
946 UInt size = read_UInt(stream);
948 Yap_ClauseSpace += size;
950 LOCAL_HDiff = (
char *)cl - base;
951 read_bytes(stream, cl, size);
952 RestoreStaticClause(cl PASS_REGS);
953 Yap_AssertzClause(pp, cl->ClCode);
958static void read_pred(FILE *stream, Term mod) {
963 ap = LookupPredEntry((
PredEntry *)read_UInt(stream));
964 flags = read_predFlags(stream);
967 if (ap->ArityOfPE && ap->ModuleOfPred != IDB_MODULE)
970 else if (ap->ModuleOfPred != IDB_MODULE)
972 printf(
" %s/%ld %llx %llx\n", ((
Atom)(ap->FunctorOfPred))->StrOfAE, ap->ArityOfPE, ap->PredFlags, flags);
976if (flags & ForeignPredFlags) {
977 if (!(ap->PredFlags & (ForeignPredFlags))) {
978 fprintf(stderr,
"C-predicate does not exist in new engine: ");
979 Yap_DebugWriteIndicator(ap);
981 QLYR_ERROR(INCONSISTENT_CPRED);
983 if (flags & MetaPredFlag)
984 ap->PredFlags |= MetaPredFlag;
987 nclauses = read_UInt(stream);
988 if (ap->PredFlags & IndexedPredFlag) {
989 Yap_RemoveIndexation(ap);
991 if (ap->PredFlags & LogUpdatePredFlag) {
992 if (ap->cs.p_code.NOfClauses) {
994 cl = ClauseCodeToLogUpdClause(ap->cs.p_code.FirstClause);
999 }
while (cl != NULL);
1004 ap->PredFlags = flags & ~StatePredFlags;
1005 if (nclauses && (ap->PredFlags & UndefPredFlag)) {
1006 ap->PredFlags &= ~UndefPredFlag;
1008 if (flags & NumberDBPredFlag) {
1009 ap->src.IndxId = read_UInt(stream);
1011 ap->src.OwnerFile = (
Atom)read_UInt(stream);
1013 if (ap->src.OwnerFile) {
1014 ap->src.OwnerFile = AtomAdjust(ap->src.OwnerFile);
1017 ap->TimeStampOfPred = read_UInt(stream);
1022 if (flags & ( MultiFileFlag|LogUpdatePredFlag)) {
1023 ap->CodeOfPred = ap->cs.p_code.TrueCodeOfPred = FAILCODE;
1024 ap->OpcodeOfPred = FAIL_OPCODE;
1025 ap->cs.p_code.NOfClauses = 0;
1027 if (nclauses && !(ap->PredFlags & ForeignPredFlags))
1028 read_clauses(stream, ap, nclauses, flags);
1033 if (flags & HiddenPredFlag) {
1038static void read_ops(FILE *stream) {
1040 while ((x = read_tag(stream)) != QLY_END_OPS) {
1042 Term mod = (Term)read_UInt(stream);
1045 at = AtomAdjust(at);
1047 mod = MkAtomTerm(AtomAdjust(AtomOfTerm(mod)));
1048 op = Yap_OpPropForModule(at, mod);
1049 op->Prefix = read_bits16(stream);
1050 op->Infix = read_bits16(stream);
1051 op->Posfix = read_bits16(stream);
1052 WRITE_UNLOCK(op->OpRWLock);
1056static void read_module(FILE *stream) {
1061 while ((x = read_tag(stream)) == QLY_START_MODULE) {
1062 Term mod = (Term)read_UInt(stream);
1065 mod = MkAtomTerm(AtomAdjust(AtomOfTerm(mod)));
1067 while ((x = read_tag(stream)) == QLY_START_PREDICATE) {
1068 read_pred(stream, mod);
1075static Int p_read_module_preds(USES_REGS1) {
1077 Term t1 = Deref(ARG1);
1079 if (IsVarTerm(t1)) {
1080 Yap_Error(INSTANTIATION_ERROR, t1,
"read_qly/3");
1083 if (!IsAtomTerm(t1)) {
1084 Yap_Error(TYPE_ERROR_ATOM, t1,
"read_qly/3");
1087 if (!(stream = Yap_GetInputStream(t1,
"scanning preducate modules"))) {
1090 read_module(stream);
1094static void ReInitProlog(
void) {
1095 Term t = MkAtomTerm(AtomInitProlog);
1099static Int qload_program(USES_REGS1) {
1103 Term t1 = Deref(ARG1);
1105 if (IsVarTerm(t1)) {
1106 Yap_Error(INSTANTIATION_ERROR, t1,
"read_program/3");
1109 if ((stream = Yap_GetInputStream(t1,
"from read_program"))) {
1112 Yap_Reset(YAP_RESET_FROM_RESTORE,
true);
1113 if (do_header(stream) == NIL)
1115 read_module(stream);
1122YAP_file_type_t Yap_Restore(
const char *s) {
1125 int lvl = push_text_stack();
1128 FILE *stream = Yap_OpenRestore(tmp);
1131#define BUFSIX 4096*256
1132 char *buf = malloc(BUFSIZ);
1133 setvbuf(stream, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
1134 GLOBAL_RestoreFile = s;
1135 if (do_header(stream) == NIL) {
1136 pop_text_stack(lvl);
1139 read_module(stream);
1140 setBooleanGlobalPrologFlag(SAVED_PROGRAM_FLAG,
true);
1143 GLOBAL_RestoreFile = NULL;
1144 LOCAL_SourceModule = CurrentModule = USER_MODULE;
1145 pop_text_stack(lvl);
1149void Yap_InitQLYR(
void) {
1150 Yap_InitCPred(
"$qload_module_preds", 1, p_read_module_preds,
1151 SyncPredFlag | UserCPredFlag | HiddenPredFlag);
1152 Yap_InitCPred(
"$qload_file_preds", 1, p_read_module_preds,
1153 SyncPredFlag | HiddenPredFlag);
1154 Yap_InitCPred(
"$qload_program", 1, qload_program,
1155 SyncPredFlag | HiddenPredFlag);
1156 Yap_InitCPred(
"$q_header", 2, get_header, SyncPredFlag | HiddenPredFlag);
load_foreign_files/3 has works for the following configurations:
const char * Yap_AbsoluteFile(const char *spec, bool ok)
generate absolute path, if ok first expand SICStus Prolog style
yamop * Yap_Error__(bool throw, const char *file, const char *function, int lineno, yap_error_number type, Term where,...)
Yap_Error This function handles errors in the C code.