small

- do not call goal expansion on meta-calls (that is done by undef).
- docs updates
- fix init code

C/modules.c

@@ -25,6 +25,7 @@ static char SccsId[] = "%W% %G%";
 static Int current_module(USES_REGS1);
 static Int current_module1(USES_REGS1);
 static ModEntry *LookupModule(Term a);
+static ModEntry *LookupSystemModule(Term a);
 
  static ModEntry *FetchModuleEntry(Atom at)
 /* get predicate entry for ap/arity; create it if neccessary.              */
@@ -89,6 +90,17 @@ Term Yap_getUnknownModule(ModEntry *m) {
   }
 }
 
+bool Yap_getUnknown ( Term mod) {
+  ModEntry *m = LookupModule( mod );
+  if (m && m->flags & UNKNOWN_ERROR) {
+    return TermError;
+  } else if (m && m->flags & UNKNOWN_WARNING) {
+    return TermWarning;
+  } else {
+    return TermFail;
+  }
+}
+
 
  bool Yap_CharacterEscapes(Term mt) {
    if (mt == PROLOG_MODULE) mt = TermProlog;
@@ -118,6 +130,20 @@ Term Yap_Module_Name(PredEntry *ap) {
 
 }
 
+static ModEntry *LookupSystemModule(Term a) {
+  Atom at;
+  ModEntry *me;
+
+  /* prolog module */
+  if (a == 0) {
+    return GetModuleEntry(AtomProlog);
+  }
+  at = AtomOfTerm(a);
+  me = GetModuleEntry(at);
+  me->flags |= M_SYSTEM;
+  return me;}
+
+
 static ModEntry *LookupModule(Term a) {
   Atom at;
   ModEntry *me;
@@ -131,6 +157,13 @@ static ModEntry *LookupModule(Term a) {
   return me;
 }
 
+bool Yap_isSystemModule(Term a) {
+  ModEntry *me = LookupModule(a);
+  return
+    me != NULL &&
+    me->flags & M_SYSTEM;
+}
+
 Term Yap_Module(Term tmod) {
   LookupModule(tmod);
   return tmod;
@@ -141,6 +174,7 @@ ModEntry *Yap_GetModuleEntry(Term mod) {
   if (!(me = LookupModule(mod)))
     return NULL;
   return me;
+
 }
 
 Term Yap_GetModuleFromEntry(ModEntry *me) {
@@ -191,13 +225,6 @@ static Int
   return TRUE;
 }
 
-static Int current_module1(USES_REGS1) { /* $current_module(Old)
-                                              */
-  if (CurrentModule)
-    return Yap_unify_constant(ARG1, CurrentModule);
-  return Yap_unify_constant(ARG1, TermProlog);
-}
-
 static Int change_module(USES_REGS1) { /* $change_module(New)		 */
   Term mod = Deref(ARG1);
   LookupModule(mod);
@@ -206,6 +233,14 @@ static Int change_module(USES_REGS1) { /* $change_module(New)		 */
   return TRUE;
 }
 
+static Int current_module1(USES_REGS1) { /* $current_module(Old)
+                                              */
+  if (CurrentModule)
+    return Yap_unify_constant(ARG1, CurrentModule);
+  return Yap_unify_constant(ARG1, TermProlog);
+}
+
+
 static Int cont_current_module(USES_REGS1) {
   ModEntry *imod = AddressOfTerm(EXTRA_CBACK_ARG(1, 1)), *next;
   Term t = MkAtomTerm(imod->AtomOfME);
@@ -280,6 +315,42 @@ static Int init_ground_module(USES_REGS1) {
   return cont_ground_module(PASS_REGS1);
 }
 
+/** 
+ * @pred is_system_module( + _Mod_)
+ * 
+ * @param module 
+ * 
+ * @return 
+ */
+static Int is_system_module( USES_REGS1 )
+{
+  Term t;
+  if (IsVarTerm(t = Deref (ARG1))) {
+    return false;
+  }
+  if (!IsAtomTerm(t)) {
+    Yap_Error(TYPE_ERROR_ATOM, t, "load_files/2");
+    return false;
+  }
+  return Yap_isSystemModule( t );
+}
+
+static Int system_module( USES_REGS1 )
+{
+  ModEntry *me;
+  Term t;
+  if (IsVarTerm(t = Deref (ARG1))) {
+    Yap_Error( INSTANTIATION_ERROR, t, NULL);
+    return false;
+  }
+  if (!IsAtomTerm(t)) {
+    Yap_Error(TYPE_ERROR_ATOM, t, NULL);
+    return false;
+  }
+  me = LookupSystemModule( t );
+  return me != NULL;
+}
+
 static Int strip_module(USES_REGS1) {
   Term t1 = Deref(ARG1), tmod = CurrentModule;
   if (tmod == PROLOG_MODULE) {
@@ -359,9 +430,23 @@ static Int context_module(USES_REGS1) {
   return Yap_unify(ARG1, CurrentModule);
 }
 
+/** 
+ * @pred source_module(-Mod)
+ * 
+ * @param Mod is the current text source module. 
+ * 
+ *  : _Mod_ is the current read-in or source module.
+*/
+static Int source_module(USES_REGS1) {
+  if (LOCAL_SourceModule == PROLOG_MODULE) {
+    return Yap_unify(ARG1, TermProlog);
+  }
+  return Yap_unify(ARG1, LOCAL_SourceModule);
+}
+
 Term Yap_StripModule(Term t, Term *modp) {
   CACHE_REGS
-  Term tmod;
+ Term tmod;
 
   if (modp)
     tmod = *modp;
@@ -406,9 +491,12 @@ void Yap_InitModulesC(void) {
   Yap_InitCPred("$change_module", 1, change_module,
                 SafePredFlag | SyncPredFlag);
   Yap_InitCPred("strip_module", 3, strip_module, SafePredFlag | SyncPredFlag);
+  Yap_InitCPred("source_module", 1, source_module, SafePredFlag | SyncPredFlag);
   Yap_InitCPred("$yap_strip_module", 3, yap_strip_module,
                 SafePredFlag | SyncPredFlag);
   Yap_InitCPred("context_module", 1, context_module, 0);
+  Yap_InitCPred("system_module", 1, system_module, SafePredFlag);
+  Yap_InitCPred("is_system_module", 1, is_system_module, SafePredFlag);
   Yap_InitCPredBack("$all_current_modules", 1, 1, init_current_module,
                     cont_current_module, SafePredFlag | SyncPredFlag);
   Yap_InitCPredBack("$ground_module", 3, 1, init_ground_module,
@@ -417,19 +505,19 @@ void Yap_InitModulesC(void) {
 
 void Yap_InitModules(void) {
   CACHE_REGS
-  LookupModule(MkAtomTerm(AtomProlog));
+  LookupSystemModule(MkAtomTerm(AtomProlog));
   LOCAL_SourceModule = MkAtomTerm(AtomProlog);
   LookupModule(USER_MODULE);
   LookupModule(IDB_MODULE);
   LookupModule(ATTRIBUTES_MODULE);
-  LookupModule(CHARSIO_MODULE);
-  LookupModule(TERMS_MODULE);
-  LookupModule(SYSTEM_MODULE);
-  LookupModule(READUTIL_MODULE);
-  LookupModule(HACKS_MODULE);
+  LookupSystemModule(CHARSIO_MODULE);
+  LookupSystemModule(TERMS_MODULE);
+  LookupSystemModule(SYSTEM_MODULE);
+  LookupSystemModule(READUTIL_MODULE);
+  LookupSystemModule(HACKS_MODULE);
   LookupModule(ARG_MODULE);
-  LookupModule(GLOBALS_MODULE);
-  LookupModule(DBLOAD_MODULE);
-  LookupModule(RANGE_MODULE);
+  LookupSystemModule(GLOBALS_MODULE);
+  LookupSystemModule(DBLOAD_MODULE);
+  LookupSystemModule(RANGE_MODULE);
   CurrentModule = PROLOG_MODULE;
 }