/** * Specify an alias to the stream. The alias <tt>Name</tt> must be an atom. The * alias can be used instead of the stream descriptor for every operation * concerning the stream. * * @param + _tname_ Name of Alias * @param + _tstream_ stream identifier * * @return */ static Int add_alias_to_stream (USES_REGS1) { Term tname = Deref(ARG1); Term tstream = Deref(ARG2); Atom at; Int sno; if (IsVarTerm(tname)) { Yap_Error(INSTANTIATION_ERROR, tname, "$add_alias_to_stream"); return (FALSE); } else if (!IsAtomTerm (tname)) { Yap_Error(TYPE_ERROR_ATOM, tname, "$add_alias_to_stream"); return (FALSE); } if (IsVarTerm(tstream)) { Yap_Error(INSTANTIATION_ERROR, tstream, "$add_alias_to_stream"); return (FALSE); } else if (!IsApplTerm (tstream) || FunctorOfTerm (tstream) != FunctorStream || !IsIntTerm(ArgOfTerm(1,tstream))) { Yap_Error(DOMAIN_ERROR_STREAM_OR_ALIAS, tstream, "$add_alias_to_stream"); return (FALSE); } at = AtomOfTerm(tname); sno = (int)IntOfTerm(ArgOfTerm(1,tstream)); if (Yap_AddAlias(at, sno)) return(TRUE); /* we could not create the alias, time to close the stream */ Yap_CloseStream(sno); Yap_Error(PERMISSION_ERROR_NEW_ALIAS_FOR_STREAM, tname, "open/3"); return (FALSE); }
int Yap_SWIHandleError(const char *s, ...) { CACHE_REGS yap_error_number err = LOCAL_Error_TYPE; char *serr; if (s) { serr = (char *)s; } switch (err) { case RESOURCE_ERROR_STACK: if (!Yap_gc(2, ENV, gc_P(P, CP))) { Yap_Error(RESOURCE_ERROR_STACK, TermNil, serr); return (FALSE); } return TRUE; case RESOURCE_ERROR_AUXILIARY_STACK: if (LOCAL_MAX_SIZE < (char *)AuxSp - AuxBase) { LOCAL_MAX_SIZE += 1024; } if (!Yap_ExpandPreAllocCodeSpace(0, NULL, TRUE)) { /* crash in flames */ Yap_Error(RESOURCE_ERROR_AUXILIARY_STACK, ARG1, serr); return FALSE; } return true; case RESOURCE_ERROR_HEAP: if (!Yap_growheap(false, 0, NULL)) { Yap_Error(RESOURCE_ERROR_HEAP, ARG2, serr); return false; } default: Yap_Error(err, TermNil, serr); return false; } }
static CELL * mark_global_cell(CELL *pt) { CELL reg = *pt; if (IsVarTerm(reg)) { /* skip bitmaps */ switch(reg) { case (CELL)FunctorDouble: #if SIZEOF_DOUBLE == 2*SIZEOF_INT_P return pt + 4; #else return pt + 3; #endif case (CELL)FunctorString: return pt + 3 + pt[1]; case (CELL)FunctorBigInt: { Int sz = 3 + (sizeof(MP_INT)+ (((MP_INT *)(pt+2))->_mp_alloc*sizeof(mp_limb_t)))/sizeof(CELL); Opaque_CallOnGCMark f; Opaque_CallOnGCRelocate f2; Term t = AbsAppl(pt); if ( (f = Yap_blob_gc_mark_handler(t)) ) { CELL ar[256]; Int i,n = (f)(Yap_BlobTag(t), Yap_BlobInfo(t), ar, 256); if (n < 0) { Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"not enough space for slot internal variables in agc"); } for (i = 0; i< n; i++) { CELL *pt = ar+i; CELL reg = *pt; if (!IsVarTerm(reg) && IsAtomTerm(reg)) { *pt = AtomTermAdjust(reg); } } if ( (f2 = Yap_blob_gc_relocate_handler(t)) < 0 ) { int out = (f2)(Yap_BlobTag(t), Yap_BlobInfo(t), ar, n); if (out < 0) Yap_Error(OUT_OF_HEAP_ERROR,TermNil,"bad restore of slot internal variables in agc"); } } return pt + sz; } case (CELL)FunctorLongInt: return pt + 3; break; } } else if (IsAtomTerm(reg)) { MarkAtomEntry(RepAtom(AtomOfTerm(reg))); return pt+1; } return pt+1; }
static int OpDec(int p, const char *type, Atom a, Term m) { int i; AtomEntry *ae = RepAtom(a); OpEntry *info; if (m == TermProlog) m = PROLOG_MODULE; else if (m == USER_MODULE) m = PROLOG_MODULE; for (i = 1; i <= 7; ++i) if (strcmp(type, optypes[i]) == 0) break; if (i > 7) { Yap_Error(DOMAIN_ERROR_OPERATOR_SPECIFIER,MkAtomTerm(Yap_LookupAtom(type)),"op/3"); return(FALSE); } if (p) { if (i == 1 || i == 2 || i == 4) p |= DcrlpFlag; if (i == 1 || i == 3 || i == 6) p |= DcrrpFlag; } WRITE_LOCK(ae->ARWLock); info = Yap_GetOpPropForAModuleHavingALock(ae, m); if (EndOfPAEntr(info)) { info = (OpEntry *) Yap_AllocAtomSpace(sizeof(OpEntry)); info->KindOfPE = Ord(OpProperty); info->OpModule = m; info->OpName = a; //LOCK(OpListLock); info->OpNext = OpList; OpList = info; //UNLOCK(OpListLock); AddPropToAtom(ae, (PropEntry *)info); INIT_RWLOCK(info->OpRWLock); WRITE_LOCK(info->OpRWLock); WRITE_UNLOCK(ae->ARWLock); info->Prefix = info->Infix = info->Posfix = 0; } else { WRITE_LOCK(info->OpRWLock); WRITE_UNLOCK(ae->ARWLock); } if (i <= 3) { GET_LD if (truePrologFlag(PLFLAG_ISO) && info->Posfix != 0) /* there is a posfix operator */ { /* ISO dictates */ WRITE_UNLOCK(info->OpRWLock); Yap_Error(PERMISSION_ERROR_CREATE_OPERATOR,MkAtomTerm(a),"op/3"); return FALSE; } info->Infix = p; } else if (i <= 5) {
/** @pred get_value(+ _A_,- _V_) In YAP, atoms can be associated with constants. If one such association exists for atom _A_, unify the second argument with the constant. Otherwise, unify _V_ with `[]`. This predicate is YAP specific. */ static Int p_value(USES_REGS1) { /* '$get_value'(+Atom,?Val) */ Term t1 = Deref(ARG1); if (IsVarTerm(t1)) { Yap_Error(INSTANTIATION_ERROR, t1, "get_value/2"); return (FALSE); } if (!IsAtomTerm(t1)) { Yap_Error(TYPE_ERROR_ATOM, t1, "get_value/2"); return (FALSE); } return (Yap_unify_constant(ARG2, Yap_GetValue(AtomOfTerm(t1)))); }
static Int check_if_valid_new_alias (USES_REGS1) { Term tname = Deref(ARG1); Atom at; if (IsVarTerm(tname)) { Yap_Error(INSTANTIATION_ERROR, tname, "$add_alias_to_stream"); return (FALSE); } else if (!IsAtomTerm (tname)) { Yap_Error(TYPE_ERROR_ATOM, tname, "$add_alias_to_stream"); return (FALSE); } at = AtomOfTerm(tname); return(Yap_CheckAlias(at) == -1); }
static BBProp PutBBProp(AtomEntry *ae, Term mod USES_REGS) /* get BBentry for at; */ { Prop p0; BBProp p; WRITE_LOCK(ae->ARWLock); p = RepBBProp(p0 = ae->PropsOfAE); while (p0 != NIL && (!IsBBProperty(p->KindOfPE) || (p->ModuleOfBB != mod))) { p = RepBBProp(p0 = p->NextOfPE); } if (p0 == NIL) { p = (BBProp)Yap_AllocAtomSpace(sizeof(*p)); if (p == NULL) { WRITE_UNLOCK(ae->ARWLock); Yap_Error(OUT_OF_HEAP_ERROR,ARG1,"could not allocate space in bb_put/2"); return(NULL); } AddPropToAtom(ae, (PropEntry *)p); p->ModuleOfBB = mod; p->Element = 0L; p->KeyOfBB = AbsAtom(ae); p->KindOfPE = BBProperty; INIT_RWLOCK(p->BBRWLock); } WRITE_UNLOCK(ae->ARWLock); return (p); }
void Yap_LookupAtomWithAddress(const char *atom, AtomEntry *ae) { /* lookup atom in atom table */ register CELL hash; register const unsigned char *p; Atom a; /* compute hash */ p = (const unsigned char *)atom; hash = HashFunction(p) % AtomHashTableSize; /* ask for a WRITE lock because it is highly unlikely we shall find anything */ WRITE_LOCK(HashChain[hash].AERWLock); a = HashChain[hash].Entry; /* search atom in chain */ if (SearchAtom(p, a) != NIL) { Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "repeated initialization for atom %s", ae); WRITE_UNLOCK(HashChain[hash].AERWLock); return; } /* add new atom to start of chain */ NOfAtoms++; ae->NextOfAE = a; HashChain[hash].Entry = AbsAtom(ae); ae->PropsOfAE = NIL; strcpy((char *)ae->StrOfAE, (char *)atom); INIT_RWLOCK(ae->ARWLock); WRITE_UNLOCK(HashChain[hash].AERWLock); }
static Int p_profiling_start_point( USES_REGS1 ) { // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { Term t = Deref(ARG1); Float v; // valid value for ARG1 is just 'float' if (IsFloatTerm(t)) { v = FloatOfTerm(t); if (v < 0.0 || v >= 1.0) { // value passed by argument is out of known range Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } ExpEnv.config_struc.profiling_startp = v; return TRUE; } else { // ARG1 is not float Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"profiling_start_point/1 (1st arg)"); return FALSE; } } else { // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' Yap_NilError(INCOMPATIBLEMODE_WARNING,""); return FALSE; } }
static Int file_directory_name(USES_REGS1) { /* file_directory_name(Stream,N) */ Term t = Deref(ARG1); Atom at; if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, t, "file_directory_name/2"); return false; } at = AtomOfTerm(t); const char *c = RepAtom(at)->StrOfAE; #if HAVE_BASENAME && 0 // DISABLED: Linux basename is not compatible with // file_base_name in SWI and GNU const char *s; char c1[YAP_FILENAME_MAX + 1]; strncpy(c1, c, YAP_FILENAME_MAX); s = dirname(c1); #else char s[YAP_FILENAME_MAX + 1]; Int i = strlen(c); strncpy(s, c, YAP_FILENAME_MAX); while (--i) { if (Yap_dir_separator((int)c[i])) break; } if (i == 0) { s[0] = '.'; i = 1; } s[i] = '\0'; #endif return Yap_unify(ARG2, MkAtomTerm(Yap_LookupAtom(s))); }
/* copy to a new list of terms */ static Int build_new_list(CELL *pt, Term t USES_REGS) { Int out = 0; if (IsVarTerm(t)) return(-1); if (t == TermNil) return(0); restart: while (IsPairTerm(t)) { out++; pt[0] = HeadOfTerm(t); t = TailOfTerm(t); if (IsVarTerm(t)) return(-1); if (t == TermNil) { return(out); } pt += 2; if (pt > ASP - 4096) { if (!Yap_gcl((ASP-HR)*sizeof(CELL), 2, ENV, gc_P(P,CP))) { Yap_Error(OUT_OF_STACK_ERROR, TermNil, LOCAL_ErrorMessage); return(FALSE); } t = Deref(ARG1); pt = HR; out = 0; goto restart; } } return(-1); }
static Int file_base_name(USES_REGS1) { /* file_base_name(Stream,N) */ Term t = Deref(ARG1); Atom at; if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, t, "file_base_name/2"); return FALSE; } at = AtomOfTerm(t); const char *c = RepAtom(at)->StrOfAE; const char *s; #if HAVE_BASENAME && 0 // DISABLED: Linux basename is not compatible with // file_base_name in SWI and GNU char c1[YAP_FILENAME_MAX + 1]; strncpy(c1, c, YAP_FILENAME_MAX); s = basename(c1); #else Int i = strlen(c); while (i && !Yap_dir_separator((int)c[--i])) ; if (Yap_dir_separator((int)c[i])) { i++; } s = c + i; #endif return Yap_unify(ARG2, MkAtomTerm(Yap_LookupAtom(s))); }
static void QLYR_ERROR(qlfr_err_t my_err) { // __android_log_print(ANDROID_LOG_INFO, "YAP ", "error %s in saved state %s",GLOBAL_RestoreFile, qlyr_error[my_err]); Yap_Error(SAVED_STATE_ERROR,TermNil,"error %s in saved state %s",GLOBAL_RestoreFile, qlyr_error[my_err]); Yap_exit(1); }
static Int a_le(Term t1, Term t2) { /* A <= B */ Int out = a_cmp(Deref(t1),Deref(t2)); if (ArithError) { Yap_Error(Yap_Error_TYPE, Yap_Error_Term, Yap_ErrorMessage); return FALSE; } return out <= 0; }
static void InitAtoms(void) { int i; AtomHashTableSize = MaxHash; HashChain = (AtomHashEntry *)Yap_AllocAtomSpace(sizeof(AtomHashEntry) * MaxHash); if (HashChain == NULL) { Yap_Error(SYSTEM_ERROR_FATAL, MkIntTerm(0), "allocating initial atom table"); } for (i = 0; i < MaxHash; ++i) { INIT_RWLOCK(HashChain[i].AERWLock); HashChain[i].Entry = NIL; } NOfAtoms = 0; #if OLD_STYLE_INITIAL_ATOMS Yap_LookupAtomWithAddress("**", (AtomEntry *)&(SF_STORE->AtFoundVar)); Yap_ReleaseAtom(AtomFoundVar); Yap_LookupAtomWithAddress("?", (AtomEntry *)&(SF_STORE->AtFreeTerm)); Yap_ReleaseAtom(AtomFreeTerm); Yap_LookupAtomWithAddress("[]", (AtomEntry *)&(SF_STORE->AtNil)); Yap_LookupAtomWithAddress(".", (AtomEntry *)&(SF_STORE->AtDot)); #else SF_STORE->AtFoundVar = Yap_LookupAtom("**"); Yap_ReleaseAtom(AtomFoundVar); SF_STORE->AtFreeTerm = Yap_LookupAtom("?"); Yap_ReleaseAtom(AtomFreeTerm); SF_STORE->AtNil = Yap_LookupAtom("[]"); SF_STORE->AtDot = Yap_LookupAtom("."); #endif }
static Int p_stream_to_terms(void) { int sno = Yap_CheckStream (ARG1, Input_Stream_f, "read_line_to_codes/2"); Term t = Deref(ARG3), tpos = TermNil; if (sno < 0) return FALSE; while (!(Stream[sno].status & Eof_Stream_f)) { /* skip errors */ TokEntry *tokstart = Yap_tokptr = Yap_toktide = Yap_tokenizer(sno, &tpos); if (!Yap_ErrorMessage) { Term th = Yap_Parse(); if (H >= ASP-1024) { UNLOCK(Stream[sno].streamlock); Yap_Error(OUT_OF_STACK_ERROR, ARG1, "read_stream_to_terms/3"); return FALSE; } if (!th || Yap_ErrorMessage) break; if (th == MkAtomTerm (AtomEof)) { UNLOCK(Stream[sno].streamlock); Yap_clean_tokenizer(tokstart, Yap_VarTable, Yap_AnonVarTable); return Yap_unify(t,ARG2); } else { t = MkPairTerm(th,t); } } Yap_clean_tokenizer(tokstart, Yap_VarTable, Yap_AnonVarTable); } UNLOCK(Stream[sno].streamlock); return Yap_unify(t,ARG2); }
static Int qq_open(USES_REGS1) { PRED_LD Term t = Deref(ARG1); if (!IsVarTerm(t) && IsApplTerm(t) && FunctorOfTerm(t) = FunctorDQuasiQuotation) { void *ptr; char *start; size_t l int s; Term t0, t1, t2; if (IsPointerTerm((t0 = ArgOfTerm(1, t))) && IsPointerTerm((t1 = ArgOfTerm(2, t))) && IsIntegerTerm((t2 = ArgOfTerm(3, t)))) { ptr = PointerOfTerm(t0); start = PointerOfTerm(t1); len = IntegerOfTerm(t2); if ((s = Yap_open_buf_read_stream(start, len, ENC_UTF8, MEM_BUF_USER)) < 0) return false; return Yap_unify(ARG2, Yap_MkStream(s)); } else { Yap_Error(TYPE_ERROR_READ_CONTEXT, t); } return FALSE; } }
static bool bind_variable_names(Term t USES_REGS) { while (!IsVarTerm(t) && IsPairTerm(t)) { Term tl = HeadOfTerm(t); Functor f; Term tv, t2, t1; if (!IsApplTerm(tl)) return FALSE; if ((f = FunctorOfTerm(tl)) != FunctorEq) { return FALSE; } t1 = ArgOfTerm(1, tl); if (IsVarTerm(t1)) { Yap_Error(INSTANTIATION_ERROR, t1, "variable_names"); return false; } t2 = ArgOfTerm(2, tl); tv = Yap_MkApplTerm(FunctorDollarVar, 1, &t1); if (IsVarTerm(t2)) { YapBind(VarOfTerm(t2), tv); } t = TailOfTerm(t); } return true; }
static BBProp PutIntBBProp(Int key, Term mod USES_REGS) /* get BBentry for at; */ { Prop p0; BBProp p; UInt hash_key; if (INT_BB_KEYS == NULL) { INT_BB_KEYS = (Prop *)Yap_AllocCodeSpace(sizeof(Prop)*INT_BB_KEYS_SIZE); if (INT_BB_KEYS != NULL) { UInt i = 0; Prop *pp = INT_BB_KEYS; for (i = 0; i < INT_BB_KEYS_SIZE; i++) { pp[0] = NIL; pp++; } } else { Yap_Error(OUT_OF_HEAP_ERROR,ARG1,"could not allocate space in bb_put/2"); return(NULL); } } hash_key = (CELL)key % INT_BB_KEYS_SIZE; p0 = INT_BB_KEYS[hash_key]; p = RepBBProp(p0); while (p0 != NIL && (!IsBBProperty(p->KindOfPE) || key != (Int)(p->KeyOfBB) || (p->ModuleOfBB != mod))) { p = RepBBProp(p0 = p->NextOfPE); } if (p0 == NIL) { YAPEnterCriticalSection(); p = (BBProp)Yap_AllocAtomSpace(sizeof(*p)); if (p == NULL) { YAPLeaveCriticalSection(); Yap_Error(OUT_OF_HEAP_ERROR,ARG1,"could not allocate space in bb_put/2"); return(NULL); } p->ModuleOfBB = mod; p->Element = 0L; p->KeyOfBB = (Atom)key; p->KindOfPE = BBProperty; p->NextOfPE = INT_BB_KEYS[hash_key]; INT_BB_KEYS[hash_key] = AbsBBProp(p); YAPLeaveCriticalSection(); } return (p); }
static Int p_set_depth_limit_for_next_call( USES_REGS1 ) { Term d = Deref(ARG1); if (IsVarTerm(d)) { Yap_Error(INSTANTIATION_ERROR, d, "set-depth_limit"); return(FALSE); } else if (!IsIntegerTerm(d)) { Yap_Error(TYPE_ERROR_INTEGER, d, "set-depth_limit"); return(FALSE); } d = MkIntTerm(IntegerOfTerm(d)*2); DEPTH = d; return(TRUE); }
void Yap_init_yapor_workers(void) { CACHE_REGS int proc; #ifdef YAPOR_THREADS return; #endif /* YAPOR_THREADS */ #ifdef YAPOR_COW GLOBAL_master_worker = getpid(); if (GLOBAL_number_workers > 1) { int son; son = fork(); if (son == -1) Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "fork error (Yap_init_yapor_workers)"); if (son > 0) { /* I am the father, I must stay here and wait for my children to all die */ struct sigaction sigact; sigact.sa_handler = SIG_DFL; sigemptyset(&sigact.sa_mask); sigact.sa_flags = SA_RESTART; sigaction(SIGINT, &sigact, NULL); pause(); exit(0); } else GLOBAL_worker_pid(0) = getpid(); } #endif /* YAPOR_COW */ for (proc = 1; proc < GLOBAL_number_workers; proc++) { int son; son = fork(); if (son == -1) Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "fork error (Yap_init_yapor_workers)"); if (son == 0) { /* new worker */ worker_id = proc; Yap_remap_yapor_memory(); LOCAL = REMOTE(worker_id); memcpy(REMOTE(worker_id), REMOTE(0), sizeof(struct worker_local)); InitWorker(worker_id); break; } else GLOBAL_worker_pid(proc) = son; } }
static Int open_mem_read_stream (USES_REGS1) /* $open_mem_read_stream(+List,-Stream) */ { Term t, ti; int sno; Int sl = 0, nchars = 0; char *nbuf; ti = Deref(ARG1); while (ti != TermNil) { if (IsVarTerm(ti)) { Yap_Error(INSTANTIATION_ERROR, ti, "open_mem_read_stream"); return (FALSE); } else if (!IsPairTerm(ti)) { Yap_Error(TYPE_ERROR_LIST, ti, "open_mem_read_stream"); return (FALSE); } else { sl++; ti = TailOfTerm(ti); } } while ((nbuf = (char *)Yap_AllocAtomSpace((sl+1)*sizeof(char))) == NULL) { if (!Yap_growheap(FALSE, (sl+1)*sizeof(char), NULL)) { Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage); return(FALSE); } } ti = Deref(ARG1); while (ti != TermNil) { Term ts = HeadOfTerm(ti); if (IsVarTerm(ts)) { Yap_Error(INSTANTIATION_ERROR, ARG1, "open_mem_read_stream"); return (FALSE); } else if (!IsIntTerm(ts)) { Yap_Error(TYPE_ERROR_INTEGER, ARG1, "open_mem_read_stream"); return (FALSE); } nbuf[nchars++] = IntOfTerm(ts); ti = TailOfTerm(ti); } nbuf[nchars] = '\0'; sno = Yap_open_buf_read_stream(nbuf, nchars, &LOCAL_encoding, MEM_BUF_CODE); t = Yap_MkStream (sno); return (Yap_unify (ARG2, t)); }
/* static */ static int MemPutc(int sno, int ch) { StreamDesc *s = &GLOBAL_Stream[sno]; #if MAC || _MSC_VER if (ch == 10) { ch = '\n'; } #endif s->u.mem_string.buf[s->u.mem_string.pos++] = ch; if (s->u.mem_string.pos >= s->u.mem_string.max_size -8) { int old_src = s->u.mem_string.src, new_src; /* oops, we have reached an overflow */ Int new_max_size = s->u.mem_string.max_size + Yap_page_size; char *newbuf; if (old_src == MEM_BUF_CODE && (newbuf = Yap_AllocAtomSpace(new_max_size*sizeof(char))) != NULL) { new_src = MEM_BUF_CODE; #if HAVE_MEMMOVE memmove((void *)newbuf, (void *)s->u.mem_string.buf, (size_t)((s->u.mem_string.pos)*sizeof(char))); #else { Int n = s->u.mem_string.pos; char *to = newbuf; char *from = s->u.mem_string.buf; while (n-- >= 0) { *to++ = *from++; } } #endif Yap_FreeAtomSpace(s->u.mem_string.buf); #if !HAVE_SYSTEM_MALLOC } else if ((newbuf = (ADDR)realloc(s->u.mem_string.buf, new_max_size*sizeof(char))) != NULL) { new_src = MEM_BUF_MALLOC; #endif } else { if (GLOBAL_Stream[sno].u.mem_string.error_handler) { CACHE_REGS LOCAL_Error_Size = new_max_size*sizeof(char); save_machine_regs(); longjmp(*(jmp_buf *)GLOBAL_Stream[sno].u.mem_string.error_handler,1); } else { Yap_Error(RESOURCE_ERROR_HEAP, TermNil, "YAP could not grow heap for writing to string"); } return -1; } if (old_src == MEM_BUF_CODE) { } s->u.mem_string.buf = newbuf; s->u.mem_string.max_size = new_max_size; s->u.mem_string.src = new_src; } count_output_char(ch,s); return ((int) ch); }
static void * thread_run(void *widp) { CACHE_REGS Term tgoal, t; Term tgs[2]; int myworker_id = *((int *)widp); #ifdef OUTPUT_THREADS_TABLING char thread_name[25]; char filename[YAP_FILENAME_MAX]; sprintf(thread_name, "/thread_output_%d", myworker_id); strcpy(filename, YAP_BINDIR); strncat(filename, thread_name, 25); REMOTE_thread_output(myworker_id) = fopen(filename, "w"); #endif /* OUTPUT_THREADS_TABLING */ start_thread(myworker_id); REFRESH_CACHE_REGS; do { t = tgs[0] = Yap_PopTermFromDB(LOCAL_ThreadHandle.tgoal); if (t == 0) { if (LOCAL_Error_TYPE == OUT_OF_ATTVARS_ERROR) { LOCAL_Error_TYPE = YAP_NO_ERROR; if (!Yap_growglobal(NULL)) { Yap_Error(OUT_OF_ATTVARS_ERROR, TermNil, LOCAL_ErrorMessage); thread_die(worker_id, FALSE); return NULL; } } else { LOCAL_Error_TYPE = YAP_NO_ERROR; if (!Yap_growstack(LOCAL_ThreadHandle.tgoal->NOfCells*CellSize)) { Yap_Error(OUT_OF_STACK_ERROR, TermNil, LOCAL_ErrorMessage); thread_die(worker_id, FALSE); return NULL; } } } } while (t == 0); REMOTE_ThreadHandle(myworker_id).tgoal = NULL; tgs[1] = LOCAL_ThreadHandle.tdetach; tgoal = Yap_MkApplTerm(FunctorThreadRun, 2, tgs); Yap_RunTopGoal(tgoal); thread_die(worker_id, FALSE); return NULL; }
void Yap_init_yapor_global_local_memory(void) { Yap_local = (struct worker_local *)(MMAP_ADDR - GLOBAL_LOCAL_STRUCTS_AREA); Yap_global = (struct global_data *)(MMAP_ADDR - sizeof(struct global_data)); #ifdef MMAP_MEMORY_MAPPING_SCHEME { int fd_mapfile; if (getcwd(mapfile_path,PATH_MAX) == NULL) Yap_Error(FATAL_ERROR, TermNil, "getcwd error (Yap_init_yapor_global_local_memory)"); strcat(mapfile_path,"/mapfile"); itos(getpid(), &mapfile_path[strlen(mapfile_path)]); if (strlen(mapfile_path) >= PATH_MAX) Yap_Error(FATAL_ERROR, TermNil, "PATH_MAX error (Yap_init_yapor_global_local_memory)"); if ((fd_mapfile = open(mapfile_path, O_RDWR|O_CREAT|O_TRUNC, 0666)) < 0) Yap_Error(FATAL_ERROR, TermNil, "open error (Yap_init_yapor_global_local_memory)"); if (lseek(fd_mapfile, GLOBAL_LOCAL_STRUCTS_AREA, SEEK_SET) < 0) Yap_Error(FATAL_ERROR, TermNil, "lseek error (Yap_init_yapor_global_local_memory)"); if (write(fd_mapfile, "", 1) < 0) Yap_Error(FATAL_ERROR, TermNil, "write error (Yap_init_yapor_global_local_memory)"); if (mmap((void *) Yap_local, (size_t) GLOBAL_LOCAL_STRUCTS_AREA, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd_mapfile, 0) == (void *) -1) Yap_Error(FATAL_ERROR, TermNil, "mmap error (Yap_init_global_local_memory)"); if (close(fd_mapfile) == -1) Yap_Error(FATAL_ERROR, TermNil, "close error (Yap_init_yapor_global_local_memory)"); } #elif defined(SHM_MEMORY_MAPPING_SCHEME) /* place as segment MAX_WORKERS (0..MAX_WORKERS-1 reserved for worker areas) */ shm_map_memory(MAX_WORKERS, GLOBAL_LOCAL_STRUCTS_AREA, (void *) Yap_local); #endif /* MEMORY_MAPPING_SCHEME */ return; }
Term YAPListTerm::car() { Term to = gt(); if (IsPairTerm(to)) return (HeadOfTerm(to)); else { Yap_Error(TYPE_ERROR_LIST, to, ""); throw YAPError(); } }
static Int /* mpe_create_state(+Event,+Event,+Text,+Colour) */ p_create_state() { Term t_start = Deref(ARG1), t_end = Deref(ARG2), t_descr = Deref(ARG3), t_colour = Deref(ARG4); Int start_id, end_id; char *descr, *colour; int retv; /* The first and second args must be bount to integer event IDs. */ if (IsVarTerm(t_start)) { Yap_Error(INSTANTIATION_ERROR, t_start, "mpe_create_state"); return (FALSE); } else if( !IsIntegerTerm(t_start) ) { Yap_Error(TYPE_ERROR_INTEGER, t_start, "mpe_create_state"); return (FALSE); } else { start_id = IntOfTerm(t_start); } if (IsVarTerm(t_end)) { Yap_Error(INSTANTIATION_ERROR, t_end, "mpe_create_state"); return (FALSE); } else if( !IsIntegerTerm(t_end) ) { Yap_Error(TYPE_ERROR_INTEGER, t_end, "mpe_create_state"); return (FALSE); } else { end_id = IntOfTerm(t_end); } /* The third and fourth args must be bound to atoms. */ if (IsVarTerm(t_descr)) { Yap_Error(INSTANTIATION_ERROR, t_descr, "mpe_create_state"); return (FALSE); } else if( !IsAtomTerm(t_descr) ) { Yap_Error(TYPE_ERROR_ATOM, t_descr, "mpe_create_state"); return (FALSE); } else { descr = RepAtom(AtomOfTerm(t_descr))->StrOfAE; } if (IsVarTerm(t_colour)) { Yap_Error(INSTANTIATION_ERROR, t_colour, "mpe_create_state"); return (FALSE); } else if( !IsAtomTerm(t_colour) ) { Yap_Error(TYPE_ERROR_ATOM, t_colour, "mpe_create_state"); return (FALSE); } else { colour = RepAtom(AtomOfTerm(t_colour))->StrOfAE; } retv = MPE_Describe_state( (int)start_id, (int)end_id, descr, colour ); return (retv == 0); }
static Int /* mpe_close(+FileName) */ p_close() { Term t_str = Deref(ARG1); char *str; /* The arg must be bound to an atom. */ if (IsVarTerm(t_str)) { Yap_Error(INSTANTIATION_ERROR, t_str, "mpe_close"); return (FALSE); } else if( !IsAtomTerm(t_str) ) { Yap_Error(TYPE_ERROR_ATOM, t_str, "mpe_close"); return (FALSE); } else { str = RepAtom(AtomOfTerm(t_str))->StrOfAE; } return (MPE_Finish_log(str) == 0); }
static Int p_thread_new_tid( USES_REGS1 ) { int new_worker = allocate_new_tid(); if (new_worker == -1) { Yap_Error(RESOURCE_ERROR_MAX_THREADS, MkIntegerTerm(MAX_THREADS), ""); return FALSE; } return Yap_unify(MkIntegerTerm(new_worker), ARG1); }
int Yap_CloseForeignFile(void *handle) { if ( dlclose(handle) < 0) { CACHE_REGS Yap_Error(SYSTEM_ERROR, ARG1, "dlclose error %s\n", dlerror()); return -1; } return 0; }