19#ifdef SCCSLookupSystemModule
20static char SccsId[] =
"%W% %G%";
27static Int current_module(USES_REGS1);
28static Int current_module1(USES_REGS1);
29static ModEntry *LookupModule(Term a);
30static ModEntry *LookupSystemModule(Term a);
49 parent = FetchModuleEntry(toname);
51 n = (
ModEntry *)Yap_AllocAtomSpace(
sizeof(*n));
52 INIT_RWLOCK(n->ModRWLock);
53 n->KindOfPE = ModProperty;
56 n->NextME = CurrentModules;
60 if (ae == AtomProlog || GLOBAL_Stream == NULL)
61 n->OwnerFile = AtomUserIn;
63 n->OwnerFile = Yap_ConsultingFile(PASS_REGS1);
65 Yap_setModuleFlags(n, parent);
80 READ_LOCK(ae->ARWLock);
85 READ_UNLOCK(ae->ARWLock);
90 READ_UNLOCK(ae->ARWLock);
93 (CurrentModule == PROLOG_MODULE ? NULL : AtomOfTerm(CurrentModule)), at);
101 READ_LOCK(ae->ARWLock);
106 READ_UNLOCK(ae->ARWLock);
111 READ_UNLOCK(ae->ARWLock);
116 if (
m &&
m->flags & UNKNOWN_ERROR) {
118 }
else if (
m &&
m->flags & UNKNOWN_WARNING) {
120 }
else if (
m &&
m->flags & UNKNOWN_FAST_FAIL) {
127bool Yap_getUnknown(Term mod) {
129 return Yap_getUnknownModule(
m);
132bool Yap_CharacterEscapes(Term mt) {
134 if (mt == PROLOG_MODULE)
136 return GetModuleEntry(AtomOfTerm(mt) PASS_REGS)->
flags & M_CHARESCAPE;
139#define ByteAdr(X) ((char *)&(X))
145 if (!ap->ModuleOfPred)
155 return ap->ModuleOfPred;
159static ModEntry *LookupSystemModule(Term a) {
169 me = GetModuleEntry(at PASS_REGS);
172 me->
flags |= M_SYSTEM;
177static ModEntry *LookupModule(Term a) {
184 return GetModuleEntry(AtomProlog PASS_REGS);
187 me = GetModuleEntry(at PASS_REGS);
191bool Yap_isSystemModule(Term a) {
193 return me != NULL && me->
flags & M_SYSTEM;
196Term Yap_Module(Term tmod) {
201ModEntry *Yap_GetModuleEntry(Term mod) {
204 if (!(me = LookupModule(mod)))
209Term Yap_GetModuleFromEntry(
ModEntry *me) {
216 if (!(me = LookupModule(mod)))
221void Yap_NewModulePred(Term mod,
struct pred_entry *ap) {
226 if (!(me = LookupModule(mod)))
228 WRITE_LOCK(me->ModRWLock);
231 WRITE_UNLOCK(me->ModRWLock);
235 current_module(USES_REGS1) {
239 if (!Yap_unify_constant(ARG1, CurrentModule))
242 if (!Yap_unify_constant(ARG1, TermProlog))
246 if (IsVarTerm(t) || !IsAtomTerm(t))
248 if (t == TermProlog) {
249 CurrentModule = PROLOG_MODULE;
255 LOCAL_SourceModule = CurrentModule;
259static Int change_module(USES_REGS1) {
260 Term mod = Deref(ARG1);
263 LOCAL_SourceModule = mod;
266static Int set_source_module(USES_REGS1) {
268 if (!Yap_unify(ARG1,(LOCAL_SourceModule? LOCAL_SourceModule:TermProlog)))
272 LOCAL_SourceModule = mod;
276static Int current_module1(USES_REGS1) {
279 return Yap_unify_constant(ARG1, CurrentModule);
280 return Yap_unify_constant(ARG1, TermProlog);
283static Int cont_current_module(USES_REGS1) {
284 ModEntry *imod = AddressOfTerm(EXTRA_CBACK_ARG(1, 1)), *next;
285 Term t = MkAtomTerm(imod->
AtomOfME);
292 EXTRA_CBACK_ARG(1, 1) = MkAddressTerm(next);
296static Int init_current_module(
298 Term t = Deref(ARG1);
300 if (!IsAtomTerm(t)) {
301 Yap_Error(TYPE_ERROR_ATOM, t,
"module name must be an atom");
304 if (FetchModuleEntry(AtomOfTerm(t)) != NULL)
308 EXTRA_CBACK_ARG(1, 1) = MkIntegerTerm((Int)CurrentModules);
309 return cont_current_module(PASS_REGS1);
312static Int cont_ground_module(USES_REGS1) {
313 ModEntry *imod = AddressOfTerm(EXTRA_CBACK_ARG(3, 1)), *next;
314 Term t2 = MkAtomTerm(imod->
AtomOfME);
320 EXTRA_CBACK_ARG(3, 1) = MkAddressTerm(next);
321 return Yap_unify(ARG2, t2);
324static Int init_ground_module(USES_REGS1) {
326 Term t1 = Deref(ARG1), tmod = CurrentModule, t3;
327 if (tmod == PROLOG_MODULE) {
330 t3 = Yap_YapStripModule(t1, &tmod);
332 Yap_Error(TYPE_ERROR_CALLABLE, t3,
"trying to obtain module");
335 if (!IsVarTerm(tmod)) {
336 if (!IsAtomTerm(tmod)) {
337 Yap_Error(TYPE_ERROR_ATOM, tmod,
"module name must be an atom");
340 if (FetchModuleEntry(AtomOfTerm(tmod)) != NULL && Yap_unify(tmod, ARG2) &&
341 Yap_unify(t3, ARG3)) {
346 if (!Yap_unify(ARG2, tmod) || !Yap_unify(ARG3, t3)) {
352 EXTRA_CBACK_ARG(3, 1) = MkAddressTerm(CurrentModules);
353 return cont_ground_module(PASS_REGS1);
363static Int is_system_module(USES_REGS1) {
365 if (IsVarTerm(t = Deref(ARG1))) {
368 if (!IsAtomTerm(t)) {
369 Yap_Error(TYPE_ERROR_ATOM, t,
"load_files/2");
372 return Yap_isSystemModule(t);
375static Int new_system_module(USES_REGS1) {
378 if (IsVarTerm(t = Deref(ARG1))) {
379 Yap_Error(INSTANTIATION_ERROR, t, NULL);
382 if (!IsAtomTerm(t)) {
383 Yap_Error(TYPE_ERROR_ATOM, t, NULL);
386 if ((me = LookupSystemModule(t)))
387 me->
OwnerFile = Yap_ConsultingFile(PASS_REGS1);
391static Int strip_module(USES_REGS1) {
392 Term t1 = Deref(ARG1), tmod = CurrentModule;
393 if (tmod == PROLOG_MODULE) {
396 t1 = Yap_StripModule(t1, &tmod);
398 Yap_Error(TYPE_ERROR_CALLABLE, t1,
"trying to obtain module");
401 return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod);
404static Int yap_strip_clause(USES_REGS1) {
405 Term t1 = Deref(ARG1), th, tbody, tmod = LOCAL_SourceModule, thmod;
406 if (tmod == PROLOG_MODULE) {
409 t1 = Yap_StripModule(t1, &tmod);
411 if (IsVarTerm(t1) || IsVarTerm(tmod)) {
412 Yap_Error(INSTANTIATION_ERROR, t1,
"trying to obtain module");
414 }
else if (IsApplTerm(t1)) {
416 if (IsExtensionFunctor(f)) {
417 Yap_Error(TYPE_ERROR_CALLABLE, t1,
"trying to obtain module");
420 if (f == FunctorAssert ) {
422 th = ArgOfTerm(1, t1);
423 tbody = ArgOfTerm(2, t1);
424 th = Yap_StripModule(th, &thmod);
426 Yap_Error(INSTANTIATION_ERROR, t1,
"trying to obtain module");
428 }
else if (IsVarTerm(thmod)) {
429 Yap_Error(INSTANTIATION_ERROR, thmod,
"trying to obtain module");
431 }
else if (IsIntTerm(th) ||
432 (IsApplTerm(th) && IsExtensionFunctor(FunctorOfTerm(t1)))) {
433 Yap_Error(TYPE_ERROR_CALLABLE, t1,
"trying to obtain module");
435 }
else if (!IsAtomTerm(thmod)) {
436 Yap_Error(TYPE_ERROR_ATOM, thmod,
"trying to obtain module");
444 }
else if (IsIntTerm(t1) || IsIntTerm(tmod)) {
445 Yap_Error(TYPE_ERROR_CALLABLE, t1,
"trying to obtain module");
452 return Yap_unify(ARG4, th) && Yap_unify(ARG2, tmod)
453 && Yap_unify(ARG3,thmod)
454 && Yap_unify(ARG5,tbody);
457Term Yap_YapStripModule(Term t, Term *modp) {
463 if (tmod == PROLOG_MODULE) {
464 *modp = tmod = TermProlog;
467 tmod = CurrentModule;
468 if (tmod == PROLOG_MODULE) {
469 tmod = CurrentModule = TermProlog;
473 if (IsVarTerm(t) || !IsApplTerm(t)) {
478 Functor fun = FunctorOfTerm(t);
479 if (fun == FunctorModule) {
480 Term t1 = ArgOfTerm(1, t);
482 if (!IsVarTerm(tmod) && !IsAtomTerm(tmod)) {
497static Int yap_strip_module(USES_REGS1) {
498 Term t1 = Deref(ARG1), tmod = CurrentModule;
499 if (tmod == PROLOG_MODULE) {
502 t1 = Yap_YapStripModule(t1, &tmod);
503 if (!t1 || (!IsVarTerm(tmod) && !IsAtomTerm(tmod))) {
504 Yap_Error(TYPE_ERROR_CALLABLE, t1,
"trying to obtain module");
507 return Yap_unify(ARG3, t1) && Yap_unify(ARG2, tmod);
510static Int context_module(USES_REGS1) {
514 if (ap->ModuleOfPred && !(ap->PredFlags & MetaPredFlag))
515 return Yap_unify(ARG1, ap->ModuleOfPred);
519 ap = EnvPreg(parentcp);
520 if (ap->ModuleOfPred && !(ap->PredFlags & MetaPredFlag))
521 return Yap_unify(ARG1, ap->ModuleOfPred);
522 parentcp = (
yamop *)yenv[E_CP];
523 yenv = (CELL *)yenv[E_E];
526 return Yap_unify(ARG1, CurrentModule);
528 return Yap_unify(ARG1, TermProlog);
538static Int source_module(USES_REGS1) {
539 if (LOCAL_SourceModule == PROLOG_MODULE) {
540 return Yap_unify(ARG1, TermProlog);
542 return Yap_unify(ARG1, LOCAL_SourceModule);
552static Int current_source_module(USES_REGS1) {
554 if (LOCAL_SourceModule == PROLOG_MODULE) {
555 LOCAL_SourceModule = TermProlog;
557 if (!Yap_unify(ARG1, LOCAL_SourceModule)) {
560 if (IsVarTerm(t = Deref(ARG2))) {
561 Yap_Error(INSTANTIATION_ERROR, t, NULL);
564 if (!IsAtomTerm(t)) {
565 Yap_Error(TYPE_ERROR_ATOM, t, NULL);
568 LOCAL_SourceModule = CurrentModule = t;
579static Int copy_operators(USES_REGS1) {
580 ModEntry *me = LookupModule(Deref(ARG1));
583 ModEntry *she = LookupModule(Deref(ARG2));
588 if (!Yap_dup_op(op, she)) {
596Term Yap_StripModule(Term t, Term *modp) {
603 tmod = CurrentModule;
604 if (tmod == PROLOG_MODULE) {
609 if (IsVarTerm(t) || !IsApplTerm(t)) {
614 Functor fun = FunctorOfTerm(t);
615 if (fun == FunctorModule) {
616 Term t1 = ArgOfTerm(1, t);
622 if (!IsVarTerm(tmod) && !IsAtomTerm(tmod)) {
635void Yap_InitModulesC(
void) {
636 Yap_InitCPred(
"$current_module", 2, current_module,
637 SafePredFlag | SyncPredFlag);
638 Yap_InitCPred(
"$current_module", 1, current_module1,
639 SafePredFlag | SyncPredFlag);
640 Yap_InitCPred(
"set_source_module", 2, set_source_module,
641 SafePredFlag | SyncPredFlag);
642 Yap_InitCPred(
"$change_module", 1, change_module,
643 SafePredFlag | SyncPredFlag);
644 Yap_InitCPred(
"strip_module", 3, strip_module, SafePredFlag | SyncPredFlag);
645 Yap_InitCPred(
"$yap_strip_module", 3, yap_strip_module,
646 SafePredFlag | SyncPredFlag);
647 Yap_InitCPred(
"source_module", 1, source_module, SafePredFlag | SyncPredFlag);
648 Yap_InitCPred(
"current_source_module", 2, current_source_module,
649 SafePredFlag | SyncPredFlag);
650 Yap_InitCPred(
"$yap_strip_clause", 5, yap_strip_clause,
652 Yap_InitCPred(
"context_module", 1, context_module, 0);
653 Yap_InitCPred(
"$is_system_module", 1, is_system_module, SafePredFlag);
654 Yap_InitCPred(
"$copy_operators", 2, copy_operators, 0);
655 Yap_InitCPred(
"new_system_module", 1, new_system_module, SafePredFlag);
656 Yap_InitCPredBack(
"$all_current_modules", 1, 1, init_current_module,
657 cont_current_module, SafePredFlag | SyncPredFlag);
658 Yap_InitCPredBack(
"$ground_module", 3, 1, init_ground_module,
659 cont_ground_module, SafePredFlag | SyncPredFlag);
662void Yap_InitModules(
void) {
664 CurrentModules = NULL;
665 LookupSystemModule(MkAtomTerm(AtomProlog));
666 LOCAL_SourceModule = MkAtomTerm(AtomProlog);
667 LookupModule(USER_MODULE);
668 LookupModule(IDB_MODULE);
669 LookupModule(ATTRIBUTES_MODULE);
670 LookupSystemModule(CHARSIO_MODULE);
671 LookupSystemModule(TERMS_MODULE);
672 LookupSystemModule(SYSTEM_MODULE);
673 LookupSystemModule(READUTIL_MODULE);
674 LookupSystemModule(HACKS_MODULE);
675 LookupModule(ARG_MODULE);
676 LookupSystemModule(GLOBALS_MODULE);
677 LookupSystemModule(DBLOAD_MODULE);
678 LookupSystemModule(RANGE_MODULE);
679 CurrentModule = PROLOG_MODULE;
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 operator_entry * OpForME
index in module table
Atom OwnerFile
module's name
struct pred_entry * PredForME
kind of property
PropFlags KindOfPE
chain of atom properties
unsigned int flags
module's owner file