YAP 7.1.0
YapText.h
1
2
3
4/*************************************************************************
5 * *
6 * YAP Prolog *
7 * *
8 * Yap Prolog was developed at NCCUP - Universidade do Porto *
9 * *
10 * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
11 * *
12 **************************************************************************
13 * *
14 * File: YapMirror.c *
15 * Last rev: 5/2/88 *
16 * mods: *
17 * comments: Term conversion C implemented support *
18 * *
19 *************************************************************************/
20#ifndef YAPTEXT_H_INCLUDED
21#define YAPTEXT_H_INCLUDED
22
23#ifndef YAP_TEXT_H
24#define YAP_TEXT_H
25#include "Yap.h"
26
27
28
29#include "YapUTF8.h"
30
31#ifndef Yap_Min
32#define Yap_Min(x, y) (x < y ? x : y)
33
34#endif
35
36/****************** character definition table **************************/
37
38#define NUMBER_OF_CHARS 256
39extern char *Yap_chtype;
40
41#define Yap_strlen(s) strlen((void *)(s))
42
43typedef enum {
44 BG = 0, /* initial state */
45 UC = 1, /* Upper case */
46 UL = 2, /* Underline */
47 LC = 3, /* Lower case */
48 NU = 4, /* digit */
49 QT = 5, /* single quote */
50 DC = 6, /* double quote */
51 SY = 7, /* Symbol character */
52 SL = 8, /* Solo character */
53 BK = 9, /* Brackets & friends */
54 BS = 10, /* Blank */
55 EF = 11, /* End of File marker */
56 CC = 12 /* comment,char % */
57} char_kind_t;
58
59extern char_kind_t Yap_chtype0[];
60
61#define Yap_chtype (Yap_chtype0 + 1)
62
63extern char_kind_t Yap_wide_chtype(int ch);
64
65
66inline static char_kind_t chtype(Int ch) {
67 if (ch < NUMBER_OF_CHARS)
68 return Yap_chtype[ch];
69 return Yap_wide_chtype(ch);
70}
71
72#ifndef __ANDROID__
73#define __android_log_print(...)
74#endif
75
76extern const char *Yap_tokText(void *tokptr);
80extern Term Yap_tokRep(void *tokptrXS);
81
82// standard strings
83
84typedef enum
85 {
86 YAP_STRING_STRING = 0x1,
87 YAP_STRING_CODES = 0x2,
88 YAP_STRING_ATOMS = 0x4,
89 YAP_STRING_ATOMS_CODES = 0x6,
90 YAP_STRING_CHARS = 0x8,
91 YAP_STRING_WCHARS = 0x10,
92 YAP_STRING_ATOM = 0x20,
93 YAP_STRING_INT = 0x40,
94 YAP_STRING_FLOAT = 0x80,
95 YAP_STRING_BIG = 0x100,
96 YAP_STRING_DATUM = 0x200,
97 YAP_STRING_LENGTH = 0x400,
98 YAP_STRING_NTH = 0x800,
99 YAP_STRING_TERM = 0x1000, // Generic term, if nothing else given
100 YAP_STRING_DIFF = 0x2000, // difference list
101 YAP_STRING_NCHARS = 0x4000, // size of input/result
102 YAP_STRING_TRUNC = 0x8000, // truncate on maximum size of input/result
103 YAP_STRING_WQ = 0x10000, // output with write_quote
104 YAP_STRING_WC = 0x20000, // output with write_canonical
105 YAP_STRING_WITH_BUFFER = 0x40000, // output on existing buffer
106 YAP_STRING_MALLOC = 0x80000, // output on malloced buffer
107 YAP_STRING_UPCASE = 0x100000, // output on malloced buffer
108 YAP_STRING_DOWNCASE = 0x200000, // output on malloced buffer
109 YAP_STRING_IN_TMP = 0x400000, // temporary space has been allocated
110 YAP_STRING_OUTPUT_TERM = 0x800000, // when we're not sure
111 YAP_STRING_PREFER_LIST = 0x1000000 // when we're not sure
112 } enum_seq_type_t;
113
114typedef UInt seq_type_t;
115
116#define YAP_TYPE_MASK 0x0FFF
117
118typedef union {
119 Float f;
120 Int i;
121 MP_INT *b;
122 const char *c0;
123 const wchar_t *w0;
124 char *c;
125 unsigned char *uc;
126 const unsigned char *uc0;
127 wchar_t *w;
128 Atom a;
129 size_t l;
130 int d;
131 Term t; // depends on other flags
132} seq_val_t;
133
134typedef struct text_cvt {
135 seq_type_t type;
136 seq_val_t val;
137 Term mod; // optional
138 Term dif; // diff-list, usually TermNil
139 size_t max; // max_size
140 encoding_t enc;
141} seq_tv_t;
142
143
144// string type depends on current module
145static inline seq_type_t mod_to_type(Term mod USES_REGS) {
146
147 // see pl-incl.h
148 unsigned int flags = Yap_GetModuleEntry(mod)->flags;
149 if (flags & DBLQ_ATOM) {
150 return YAP_STRING_ATOM | YAP_STRING_OUTPUT_TERM;
151 } else if (flags & DBLQ_STRING) {
152 return YAP_STRING_STRING;
153 } else if (flags & DBLQ_CHARS) {
154 return YAP_STRING_ATOMS;
155 }
156 return YAP_STRING_CODES;
157}
158
159// string type depends on current module
160static inline seq_type_t mod_to_atype(Term mod USES_REGS) {
161
162 // see pl-incl.h
163 unsigned int flags = Yap_GetModuleEntry(mod)->flags;
164 if (flags & SNGQ_ATOM) {
165 return YAP_STRING_ATOM | YAP_STRING_OUTPUT_TERM;
166 } else if (flags & SNGQ_STRING) {
167 return YAP_STRING_STRING;
168 } else if (flags & SNGQ_CHARS) {
169 return YAP_STRING_ATOMS;
170 }
171 return YAP_STRING_CODES;
172}
173
174// string type depends on current module
175static inline seq_type_t mod_to_bqtype(Term mod USES_REGS) {
176 Term t2;
177 // see pl-incl.h
178 unsigned int flags = Yap_GetModuleEntry(mod)->flags;
179 if (flags & BCKQ_STRING) {
180 return YAP_STRING_STRING;
181 } else if (flags & BCKQ_ATOM) {
182 return YAP_STRING_ATOM | YAP_STRING_OUTPUT_TERM;
183 } else if (flags & BCKQ_CHARS) {
184 return YAP_STRING_ATOMS;
185 }else if (flags & BCKQ_CODES) {
186 return YAP_STRING_CODES;
187 }
188 if ((t2 = GLOBAL_Flags[BACK_QUOTES_FLAG].at)) {
189 if (t2 == TermString) {
190 return YAP_STRING_STRING;
191 } else if (t2 == TermAtom) {
192 return YAP_STRING_ATOM | YAP_STRING_OUTPUT_TERM;
193 } else if (t2 == TermCodes) {
194 return YAP_STRING_CODES;
195 }
196 }
197 return YAP_STRING_ATOMS;
198}
199
200static inline seq_type_t Yap_TextType(Term t) {
201 if (IsVarTerm(t = Deref(t))) {
202 Yap_ThrowError(INSTANTIATION_ERROR, t, "expected text");
203 }
204 if (IsAtomTerm(t)) {
205 return YAP_STRING_ATOM;
206 }
207 if (IsStringTerm(t)) {
208 return YAP_STRING_STRING;
209 }
210 if (IsPairTerm(t)) {
211 Term hd = HeadOfTerm(t);
212 if (IsVarTerm(hd)) {
213 Yap_ThrowError(INSTANTIATION_ERROR, t, "expected text");
214 }
215 if (IsIntegerTerm(hd)) {
216 return YAP_STRING_CODES;
217 }
218 if (IsAtomTerm(hd)) {
219 return YAP_STRING_ATOMS;
220 }
221 }
222 Yap_ThrowError(TYPE_ERROR_TEXT, t, "expected text");
223 return YAP_STRING_ATOM;
224}
225
226// the routines
227
228extern unsigned char *Yap_readText(seq_tv_t *inp USES_REGS);
229extern bool write_Text(unsigned char *inp, seq_tv_t *out USES_REGS);
230extern bool Yap_CVT_Text(seq_tv_t *inp, seq_tv_t *out USES_REGS);
231extern bool Yap_Concat_Text(int n, seq_tv_t inp[], seq_tv_t *out USES_REGS);
232extern bool Yap_Splice_Text(int n, size_t cuts[], seq_tv_t *inp,
233 seq_tv_t outv[] USES_REGS);
234
235// user friendly interface
236
237static inline Atom Yap_AtomicToLowAtom(Term t0 USES_REGS) {
238 seq_tv_t inp, out;
239 inp.val.t = t0;
240 inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
241 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
242 YAP_STRING_BIG | YAP_STRING_TERM;
243 out.type = YAP_STRING_ATOM | YAP_STRING_DOWNCASE;
244 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
245 Yap_ThrowError(LOCAL_Error_TYPE, t0, "");
246 return out.val.a;
247}
248
249static inline Atom Yap_AtomicToUpAtom(Term t0 USES_REGS) {
250 seq_tv_t inp, out;
251 inp.val.t = t0;
252 inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
253 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
254 YAP_STRING_BIG | YAP_STRING_TERM;
255 out.type = YAP_STRING_ATOM | YAP_STRING_UPCASE;
256 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
257 Yap_ThrowError(LOCAL_Error_TYPE, t0, "");
258 return out.val.a;
259}
260
261static inline Term Yap_AtomicToLowString(Term t0 USES_REGS) {
262 seq_tv_t inp, out;
263 inp.val.t = t0;
264 inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
265 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
266 YAP_STRING_BIG | YAP_STRING_TERM;
267 out.type = YAP_STRING_STRING | YAP_STRING_DOWNCASE;
268 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
269 Yap_ThrowError(LOCAL_Error_TYPE, t0, "");
270 return out.val.t;
271}
272
273static inline Term Yap_AtomicToUpString(Term t0 USES_REGS) {
274 seq_tv_t inp, out;
275 inp.val.t = t0;
276 inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
277 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
278 YAP_STRING_BIG | YAP_STRING_TERM;
279 out.type = YAP_STRING_STRING | YAP_STRING_UPCASE;
280 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
281 Yap_ThrowError(LOCAL_Error_TYPE, t0, "");
282 return out.val.t;
283}
284
285static inline Term Yap_AtomicToLowListOfCodes(Term t0 USES_REGS) {
286 seq_tv_t inp, out;
287 inp.val.t = t0;
288 inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
289 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
290 YAP_STRING_BIG | YAP_STRING_TERM;
291 out.type = YAP_STRING_CODES | YAP_STRING_DOWNCASE;
292 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
293 return 0;
294 return out.val.t;
295}
296
297static inline Term Yap_AtomicToUpListOfCodes(Term t0 USES_REGS) {
298 seq_tv_t inp, out;
299 inp.val.t = t0;
300 inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
301 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
302 YAP_STRING_BIG | YAP_STRING_TERM;
303 out.type = YAP_STRING_CODES | YAP_STRING_UPCASE;
304 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
305 return 0;
306 return out.val.t;
307}
308
309static inline Term Yap_AtomicToLowListOfAtoms(Term t0 USES_REGS) {
310 seq_tv_t inp, out;
311 inp.val.t = t0;
312 inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
313 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
314 YAP_STRING_BIG | YAP_STRING_TERM;
315 out.type = YAP_STRING_ATOMS | YAP_STRING_DOWNCASE;
316 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
317 return 0;
318 return out.val.t;
319}
320
321static inline Term Yap_AtomicToUpListOfAtoms(Term t0 USES_REGS) {
322 seq_tv_t inp, out;
323 inp.val.t = t0;
324 inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
325 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
326 YAP_STRING_BIG | YAP_STRING_TERM;
327 out.type = YAP_STRING_ATOMS | YAP_STRING_UPCASE;
328 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
329 return 0;
330 return out.val.t;
331}
332
333static inline size_t Yap_AtomicToUnicodeLength(Term t0 USES_REGS) {
334 seq_tv_t inp, out;
335 inp.val.t = t0;
336 inp.type = YAP_STRING_STRING | YAP_STRING_CODES | YAP_STRING_ATOMS |
337 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
338 YAP_STRING_BIG | YAP_STRING_TERM;
339 out.type = YAP_STRING_CHARS | YAP_STRING_OUTPUT_TERM;
340 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
341 return 0;
342 return strlen_utf8(out.val.uc0);
343}
344
345static inline Term Yap_AtomicToListOfAtoms(Term t0 USES_REGS) {
346 seq_tv_t inp, out;
347 inp.val.t = t0;
348 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
349 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
350 out.type = YAP_STRING_ATOMS;
351 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
352 return 0;
353 return out.val.t;
354}
355
356static inline Term Yap_AtomicToListOfCodes(Term t0 USES_REGS) {
357 seq_tv_t inp, out;
358 inp.val.t = t0;
359 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
360 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
361 out.val.uc = NULL;
362 out.type = YAP_STRING_CODES;
363 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
364 return 0;
365 return out.val.t;
366}
367
368static inline Atom Yap_AtomicToAtom(Term t0 USES_REGS) {
369 seq_tv_t inp, out;
370 inp.val.t = t0;
371 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
372 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
373 out.val.uc = NULL;
374 out.type = YAP_STRING_ATOM;
375 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
376 return 0;
377 return out.val.a;
378}
379
380static inline size_t Yap_AtomToLength(Term t0 USES_REGS) {
381 if (!IsAtomTerm(t0)) {
382 return -TYPE_ERROR_ATOM;
383 }
384 return strlen(RepAtom(AtomOfTerm(t0))->StrOfAE);
385}
386
387static inline size_t Yap_AtomToUnicodeLength(Term t0 USES_REGS) {
388 if (!IsAtomTerm(t0)) {
389 return -TYPE_ERROR_ATOM;
390 }
391 return strlen_utf8(RepAtom(AtomOfTerm(t0))->UStrOfAE);
392}
393
394static inline Term Yap_AtomToListOfAtoms(Term t0 USES_REGS) {
395 seq_tv_t inp, out;
396 inp.val.t = t0;
397 inp.type = YAP_STRING_ATOM;
398 out.val.uc = NULL;
399 out.type = YAP_STRING_ATOMS;
400 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
401 return false;
402 return out.val.t;
403}
404
405static inline Term Yap_AtomSWIToListOfAtoms(Term t0 USES_REGS) {
406 seq_tv_t inp, out;
407
408 inp.val.t = t0;
409 inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT |
410 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES;
411 out.val.uc = NULL;
412 out.type = YAP_STRING_ATOMS;
413
414 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
415 return false;
416 return out.val.t;
417}
418
419static inline Term Yap_AtomToListOfCodes(Term t0 USES_REGS) {
420 seq_tv_t inp, out;
421 inp.val.t = t0;
422 inp.type = YAP_STRING_ATOM;
423 out.val.uc = NULL;
424 out.type = YAP_STRING_CODES;
425 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
426 return false;
427 return out.val.t;
428}
429
430static inline Term Yap_AtomSWIToListOfCodes(Term t0 USES_REGS) {
431 seq_tv_t inp, out;
432
433 inp.val.t = t0;
434 inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT |
435 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES | YAP_STRING_ATOMS_CODES | YAP_STRING_ATOMS_CODES |
436 YAP_STRING_TERM ;
437 out.val.uc = NULL;
438 out.type = YAP_STRING_CODES;
439
440 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
441 return false;
442 return out.val.t;
443}
444
445
446static inline Term Yap_AtomToNumber(Term t0 USES_REGS) {
447 seq_tv_t inp, out;
448 inp.val.t = t0;
449 inp.type = YAP_STRING_ATOM;
450 out.val.uc = NULL;
451 out.enc = ENC_ISO_UTF8;
452 out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG;
453 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
454 return false;
455 return out.val.t;
456}
457
458static inline Term Yap_AtomToString(Term t0 USES_REGS) {
459 seq_tv_t inp, out;
460
461 inp.val.t = t0;
462 inp.type = YAP_STRING_ATOM;
463 out.val.uc = NULL;
464 out.type = YAP_STRING_STRING;
465
466 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
467 return false;
468
469 return out.val.t;
470}
471
472static inline Term Yap_AtomSWIToString(Term t0 USES_REGS) {
473 seq_tv_t inp, out;
474
475 inp.val.t = t0;
476 inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_INT |
477 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES ;
478 out.val.uc = NULL;
479 out.type = YAP_STRING_STRING;
480 out.enc = ENC_ISO_UTF8;
481
482 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
483 return false;
484 return out.val.t;
485}
486
487static inline Term Yap_AtomicToString(Term t0 USES_REGS) {
488 seq_tv_t inp, out;
489
490 inp.val.t = t0;
491 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
492 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
493 out.val.uc = NULL;
494 out.type = YAP_STRING_STRING;
495
496 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
497 return false;
498 return out.val.t;
499}
500
501static inline Term Yap_AtomicToTDQ(Term t0, Term mod USES_REGS) {
502 seq_tv_t inp, out;
503
504 inp.val.t = t0;
505 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
506 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
507 out.val.uc = NULL;
508 out.type = mod_to_type(mod PASS_REGS);
509 out.enc = ENC_ISO_UTF8;
510 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
511 return false;
512 return out.val.t;
513}
514
515static inline wchar_t *Yap_AtomToWide(Atom at USES_REGS) {
516 seq_tv_t inp, out;
517 inp.val.a = at;
518 inp.type = YAP_STRING_ATOM;
519 out.val.uc = NULL;
520 out.type = YAP_STRING_WCHARS;
521 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
522 return NIL;
523 return out.val.w;
524}
525
526static inline Term Yap_AtomicToTBQ(Term t0, Term mod USES_REGS) {
527 seq_tv_t inp, out;
528
529 inp.val.t = t0;
530 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
531 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
532 out.val.uc = NULL;
533 out.type = mod_to_bqtype(mod PASS_REGS);
534
535 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
536 return 0;
537 return out.val.t;
538}
539
540static inline Atom Yap_CharsToAtom(const char *s, encoding_t enc USES_REGS) {
541 seq_tv_t inp, out;
542
543 inp.val.c0 = s;
544 inp.enc = enc;
545 inp.type = YAP_STRING_CHARS;
546 out.val.uc = NULL;
547 out.type = YAP_STRING_ATOM;
548 out.enc = ENC_ISO_UTF8;
549 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
550 return 0;
551 return out.val.a;
552}
553
554static inline Term Yap_CharsToListOfAtoms(const char *s,
555 encoding_t enc USES_REGS) {
556 seq_tv_t inp, out;
557
558 inp.val.c0 = s;
559 inp.enc = enc;
560 inp.type = YAP_STRING_CHARS;
561 out.val.uc = NULL;
562 out.type = YAP_STRING_ATOMS;
563 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
564 return false;
565 return out.val.t;
566}
567
568static inline Term Yap_CharsToListOfCodes(const char *s,
569 encoding_t enc USES_REGS) {
570 seq_tv_t inp, out;
571
572 inp.val.c0 = s;
573 inp.enc = enc;
574 inp.type = YAP_STRING_CHARS;
575 out.val.uc = NULL;
576 out.type = YAP_STRING_CODES;
577 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
578 return 0;
579 return out.val.t;
580}
581
582static inline Term Yap_UTF8ToListOfCodes(const char *s USES_REGS) {
583 seq_tv_t inp, out;
584
585 inp.val.c0 = s;
586 inp.type = YAP_STRING_CHARS;
587 inp.enc = ENC_ISO_UTF8;
588 out.type = YAP_STRING_CODES;
589 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
590 return 0;
591 return out.val.t;
592}
593
594static inline Atom Yap_UTF8ToAtom(const unsigned char *s USES_REGS) {
595 seq_tv_t inp, out;
596
597 inp.val.uc0 = s;
598 inp.type = YAP_STRING_CHARS;
599 inp.enc = ENC_ISO_UTF8;
600 out.type = YAP_STRING_ATOM;
601 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
602 return 0;
603 return out.val.a;
604}
605
606static inline Term Yap_CharsToDiffListOfCodes(const char *s, Term tail,
607 encoding_t enc USES_REGS) {
608 seq_tv_t inp, out;
609
610 inp.val.c0 = s;
611 inp.enc = enc;
612 inp.type = YAP_STRING_CHARS;
613 out.val.uc = NULL;
614 out.type = YAP_STRING_DIFF | YAP_STRING_CODES;
615 out.dif = tail;
616 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
617 return 0;
618 return out.val.t;
619}
620
621static inline Term Yap_UTF8ToDiffListOfCodes(const unsigned char *s,
622 Term tail USES_REGS) {
623 seq_tv_t inp, out;
624
625 inp.val.uc0 = s;
626 inp.type = YAP_STRING_CHARS;
627 inp.enc = ENC_ISO_UTF8;
628 out.type = YAP_STRING_DIFF | YAP_STRING_CODES;
629 out.val.uc = NULL;
630 out.dif = tail;
631 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
632 return 0;
633 return out.val.t;
634}
635
636static inline Term Yap_WCharsToDiffListOfCodes(const wchar_t *s,
637 Term tail USES_REGS) {
638 seq_tv_t inp, out;
639
640 inp.val.w0 = s;
641 inp.type = YAP_STRING_WCHARS;
642 out.type = YAP_STRING_DIFF | YAP_STRING_CODES;
643 out.val.uc = NULL;
644 out.dif = tail;
645 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
646 return 0;
647
648 return out.val.t;
649}
650
651static inline Term Yap_CharsToString(const char *s, encoding_t enc USES_REGS) {
652 seq_tv_t inp, out;
653
654 inp.val.c0 = s;
655 inp.enc = enc;
656 inp.type = YAP_STRING_CHARS;
657 out.type = YAP_STRING_STRING;
658 out.val.uc = NULL;
659 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
660 return 0;
661 return out.val.t;
662}
663
664static inline char *Yap_AtomToUTF8Text(Atom at USES_REGS) {
665 return RepAtom(at)->StrOfAE;
666}
667
668static inline Term Yap_CharsToTAQ(const char *s, Term mod,
669 encoding_t enc USES_REGS) {
670 seq_tv_t inp, out;
671
672 inp.val.c0 = s;
673 inp.type = YAP_STRING_CHARS;
674 inp.mod = mod;
675 inp.enc = enc;
676 out.type = mod_to_atype(mod PASS_REGS);
677 out.val.uc = NULL;
678 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
679 return 0;
680 return out.val.t;
681}
682
683static inline Term Yap_CharsToTDQ(const char *s, Term mod,
684 encoding_t enc USES_REGS) {
685 seq_tv_t inp, out;
686
687 inp.val.c0 = s;
688 inp.type = YAP_STRING_CHARS;
689 inp.mod = mod;
690 inp.enc = enc;
691 out.type = mod_to_type(mod PASS_REGS);
692 out.val.uc = NULL;
693 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
694 return 0;
695 return out.val.t;
696}
697
698static inline Term Yap_CharsToTBQ(const char *s, Term mod,
699 encoding_t enc USES_REGS) {
700 seq_tv_t inp, out;
701
702 inp.val.c0 = s;
703 inp.type = YAP_STRING_CHARS;
704 inp.mod = mod;
705 inp.enc = enc;
706 out.type = mod_to_bqtype(mod PASS_REGS);
707 out.val.uc = NULL;
708 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
709 return 0;
710 return out.val.t;
711}
712
713static inline Atom Yap_ListOfAtomsToAtom(Term t0 USES_REGS) {
714 seq_tv_t inp, out;
715 inp.val.t = t0;
716 inp.type = YAP_STRING_ATOMS|YAP_STRING_CODES;
717 out.type = YAP_STRING_ATOM;
718 out.val.uc = NULL;
719 out.enc = ENC_ISO_UTF8;
720 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
721 return (Atom)NULL;
722 return out.val.a;
723}
724
725static inline Term Yap_ListOfAtomsToNumber(Term t0 USES_REGS) {
726 seq_tv_t inp, out;
727 inp.val.t = t0;
728 inp.type = YAP_STRING_ATOMS|YAP_STRING_CODES;
729 out.type =
730 YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
731 out.val.uc = NULL;
732 out.enc = ENC_ISO_UTF8;
733 if (!Yap_CVT_Text(&inp, &out PASS_REGS) )
734 return 0;
735 return out.val.t;
736}
737
738static inline Term Yap_ListOfAtomsToString(Term t0 USES_REGS) {
739 seq_tv_t inp, out;
740 inp.val.t = t0;
741 inp.type = YAP_STRING_ATOMS|YAP_STRING_CODES;
742 out.type = YAP_STRING_STRING;
743 out.val.uc = NULL;
744 out.enc = ENC_ISO_UTF8;
745 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
746 return 0;
747 return out.val.t;
748}
749
750static inline Atom Yap_ListOfCodesToAtom(Term t0 USES_REGS) {
751 seq_tv_t inp, out;
752 inp.val.t = t0;
753 inp.type = YAP_STRING_CODES|YAP_STRING_ATOMS;
754 out.type = YAP_STRING_ATOM;
755 out.val.uc = NULL;
756 out.enc = ENC_ISO_UTF8;
757 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
758 return (Atom)NULL;
759 return out.val.a;
760}
761
762static inline Term Yap_ListOfCodesToNumber(Term t0 USES_REGS) {
763 seq_tv_t inp, out;
764 inp.val.t = t0;
765 inp.type = YAP_STRING_CODES|YAP_STRING_ATOMS;
766 out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG;
767 out.enc = ENC_ISO_UTF8;
768 out.val.uc = NULL;
769 if (!Yap_CVT_Text(&inp, &out PASS_REGS) )
770 return 0;
771 return out.val.t;
772}
773
774static inline Term Yap_ListOfCodesToString(Term t0 USES_REGS) {
775 seq_tv_t inp, out;
776
777 inp.val.t = t0;
778 inp.type = YAP_STRING_CODES|YAP_STRING_ATOMS;
779 out.val.uc = NULL;
780 out.type = YAP_STRING_STRING;
781 out.enc = ENC_ISO_UTF8;
782 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
783 return 0;
784 return out.val.t;
785}
786
787static inline Atom Yap_ListToAtom(Term t0 USES_REGS) {
788 seq_tv_t inp, out;
789 inp.val.t = t0;
790 inp.type = YAP_STRING_ATOMS_CODES|YAP_STRING_ATOM|YAP_STRING_STRING|YAP_STRING_INT|YAP_STRING_FLOAT|YAP_STRING_BIG;
791 out.val.uc = NULL;
792 out.type = YAP_STRING_ATOM;
793 out.enc = ENC_ISO_UTF8;
794 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
795 return 0;
796 return out.val.a;
797}
798
799static inline Term Yap_ListToAtomic(Term t0 USES_REGS) {
800 seq_tv_t inp,out;
801 inp.val.t = t0;
802 inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM;
803 out.val.uc = NULL;
804 out.enc = ENC_ISO_UTF8;
805 out.type = YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT |
806 YAP_STRING_BIG | YAP_STRING_OUTPUT_TERM;
807 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
808 return 0;
809 return out.val.t;
810}
811
812static inline Term Yap_ListToNumber(Term t0 USES_REGS) {
813 seq_tv_t inp, out;
814
815 inp.val.t = t0;
816 inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES;
817 out.val.uc = NULL;
818 out.enc = ENC_ISO_UTF8;
819 out.type = YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG;
820
821 if (!Yap_CVT_Text(&inp, &out PASS_REGS) )
822 return 0;
823 return out.val.t;
824}
825
826static inline Term Yap_ListToString(Term t0 USES_REGS) {
827 seq_tv_t inp, out;
828
829 inp.val.t = t0;
830 inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM;
831 out.val.uc = NULL;
832 out.type = YAP_STRING_STRING;
833 out.enc = ENC_ISO_UTF8;
834
835 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
836 return 0;
837 return out.val.t;
838}
839
840static inline Term Yap_ListSWIToString(Term t0 USES_REGS) {
841 seq_tv_t inp, out;
842
843 inp.val.t = t0;
844 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_ATOMS_CODES |
845 YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG |
846 YAP_STRING_OUTPUT_TERM | YAP_STRING_PREFER_LIST;
847 out.val.uc = NULL;
848 out.type = YAP_STRING_STRING;
849 out.enc = ENC_ISO_UTF8;
850
851 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
852 return 0;
853 return out.val.t;
854}
855
856static inline Term YapListToTDQ(Term t0, Term mod USES_REGS) {
857 seq_tv_t inp, out;
858
859 inp.val.t = t0;
860 inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM;
861 out.val.uc = NULL;
862 out.type = mod_to_type(mod PASS_REGS);
863 out.enc = ENC_ISO_UTF8;
864
865 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
866 return 0;
867 return out.val.t;
868}
869
870static inline Term YapListToTBQ(Term t0, Term mod USES_REGS) {
871 seq_tv_t inp, out;
872
873 inp.val.t = t0;
874 inp.type = YAP_STRING_STRING | YAP_STRING_ATOMS_CODES | YAP_STRING_TERM;
875 out.val.uc = NULL;
876 out.type = mod_to_bqtype(mod PASS_REGS);
877 out.enc = ENC_ISO_UTF8;
878
879 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
880 return 0;
881 return out.val.t;
882}
883
884static inline Atom Yap_NCharsToAtom(const char *s, size_t len,
885 encoding_t enc USES_REGS) {
886 seq_tv_t inp, out;
887
888 inp.val.c0 = s;
889 inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS;
890 inp.enc = enc;
891 out.enc = ENC_ISO_UTF8;
892 out.type = YAP_STRING_ATOM;
893 out.val.uc = NULL;
894 out.max = len;
895 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
896 return 0;
897 return out.val.a;
898}
899
900static inline Term Yap_CharsToDiffListOfAtoms(const char *s, encoding_t enc,
901 Term tail USES_REGS) {
902 seq_tv_t inp, out;
903
904 inp.val.c0 = s;
905 inp.type = YAP_STRING_CHARS;
906 inp.enc = enc;
907 out.type = YAP_STRING_ATOMS | YAP_STRING_DIFF;
908 out.dif = tail;
909 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
910 return 0;
911 return 0;
912}
913
914static inline Term Yap_NCharsToListOfCodes(const char *s, size_t len,
915 encoding_t enc USES_REGS) {
916 seq_tv_t inp, out;
917
918 inp.val.c0 = s;
919 inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS;
920 inp.enc = enc;
921 out.type = YAP_STRING_CODES;
922 out.max = len;
923 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
924 return 0;
925 return out.val.t;
926}
927
928static inline Term Yap_NCharsToString(const char *s, size_t len,
929 encoding_t enc USES_REGS) {
930 seq_tv_t inp, out;
931
932 inp.val.c0 = s;
933 inp.enc = enc;
934 inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS;
935 out.type = YAP_STRING_STRING;
936 out.max = len;
937 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
938 return 0;
939 return out.val.t;
940}
941
942static inline Term Yap_NCharsToTDQ(const char *s, size_t len, encoding_t enc,
943 Term mod USES_REGS) {
944 seq_tv_t inp, out;
945
946 inp.val.c0 = s;
947 inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS;
948 inp.enc = enc;
949 inp.mod = mod;
950 out.type = mod_to_type(mod PASS_REGS);
951 out.max = len;
952 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
953 return 0;
954 return out.val.t;
955}
956
957static inline Term Yap_NCharsToTBQ(const char *s, size_t len, encoding_t enc,
958 Term mod USES_REGS) {
959 seq_tv_t inp, out;
960
961 inp.val.c0 = s;
962 inp.type = YAP_STRING_CHARS | YAP_STRING_NCHARS;
963 inp.enc = enc;
964
965 out.type = mod_to_bqtype(mod PASS_REGS);
966 out.max = len;
967 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
968 return 0;
969 return out.val.t;
970}
971
972static inline Atom Yap_NumberToAtom(Term t0 USES_REGS) {
973 seq_tv_t inp, out;
974 inp.val.t = t0;
975 inp.type =
976 YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
977 out.type = YAP_STRING_ATOM;
978 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
979return 0;
980 return out.val.a;
981}
982
983static inline Term Yap_NumberToListOfAtoms(Term t0 USES_REGS) {
984 seq_tv_t inp, out;
985 inp.val.t = t0;
986 inp.type =
987 YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
988 out.type = YAP_STRING_ATOMS;
989 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
990return 0;
991 return out.val.t;
992}
993
994static inline Term Yap_NumberToListOfCodes(Term t0 USES_REGS) {
995 seq_tv_t inp, out;
996 inp.val.t = t0;
997 inp.type =
998 YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
999 out.type = YAP_STRING_CODES;
1000 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1001return 0;
1002 return out.val.t;
1003}
1004
1005static inline Term Yap_NumberToString(Term t0 USES_REGS) {
1006 seq_tv_t inp, out;
1007 inp.val.t = t0;
1008 inp.type =
1009 YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
1010 out.type = YAP_STRING_STRING;
1011 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1012return 0;
1013 return out.val.t;
1014}
1015
1016static inline Atom Yap_NWCharsToAtom(const wchar_t *s, size_t len USES_REGS) {
1017 seq_tv_t inp, out;
1018
1019 inp.val.w0 = s;
1020 inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS;
1021 out.type = YAP_STRING_ATOM;
1022 out.max = len;
1023 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1024 Yap_ThrowError(LOCAL_Error_TYPE, TermNil, "");
1025 return out.val.a;
1026}
1027
1028static inline Term Yap_NWCharsToListOfAtoms(const wchar_t *s,
1029 size_t len USES_REGS) {
1030 seq_tv_t inp, out;
1031
1032 inp.val.w0 = s;
1033 inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS;
1034 out.type = YAP_STRING_ATOMS;
1035 out.max = len;
1036 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1037 Yap_ThrowError(LOCAL_Error_TYPE, TermNil, "");
1038 return out.val.t;
1039}
1040
1041static inline Term Yap_NWCharsToListOfCodes(const wchar_t *s,
1042 size_t len USES_REGS) {
1043 seq_tv_t inp, out;
1044
1045 inp.val.w0 = s;
1046 inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS;
1047 out.type = YAP_STRING_CODES;
1048 out.val.uc = NULL;
1049 out.max = len;
1050 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1051 Yap_ThrowError(LOCAL_Error_TYPE, TermNil, "");
1052 return out.val.t;
1053}
1054
1055static inline Term Yap_NWCharsToString(const wchar_t *s, size_t len USES_REGS) {
1056 seq_tv_t inp, out;
1057
1058 inp.val.w0 = s;
1059 inp.type = YAP_STRING_WCHARS | YAP_STRING_NCHARS;
1060 out.val.uc = NULL;
1061 out.type = YAP_STRING_STRING;
1062 out.max = len;
1063 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1064 Yap_ThrowError(LOCAL_Error_TYPE, TermNil, "");
1065 return out.val.t;
1066}
1067
1068static inline Atom Yap_StringToAtom(Term t0 USES_REGS) {
1069 seq_tv_t inp, out;
1070 inp.val.t = t0;
1071 inp.type = YAP_STRING_STRING;
1072 out.val.uc = NULL;
1073 out.type = YAP_STRING_ATOM;
1074 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1075return 0;
1076 return out.val.a;
1077}
1078
1079static inline Atom Yap_StringSWIToAtom(Term t0 USES_REGS) {
1080 seq_tv_t inp, out;
1081 inp.val.t = t0;
1082 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
1083 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES |
1084 YAP_STRING_TERM;
1085 out.type = YAP_STRING_ATOM;
1086 out.val.uc = NULL;
1087 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1088 Yap_ThrowError(LOCAL_Error_TYPE, t0, "string_to_atom");
1089 return out.val.a;
1090}
1091
1092static inline Term Yap_StringToAtomic(Term t0 USES_REGS) {
1093 seq_tv_t inp, out;
1094 inp.val.t = t0;
1095 inp.type = YAP_STRING_STRING;
1096 out.type =
1097 YAP_STRING_ATOM | YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG;
1098 out.val.uc = NULL;
1099 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1100return 0;
1101 return out.val.t;
1102}
1103
1104static inline size_t Yap_StringToUnicodeLength(Term t0 USES_REGS) {
1105 if (!IsStringTerm(t0)) {
1106 return -TYPE_ERROR_STRING;
1107 }
1108 return strlen_utf8(UStringOfTerm(t0));
1109}
1110
1111static inline size_t Yap_StringToListOfAtoms(Term t0 USES_REGS) {
1112 seq_tv_t inp, out;
1113 inp.val.t = t0;
1114 inp.type = YAP_STRING_STRING;
1115 out.type = YAP_STRING_ATOMS;
1116 out.val.uc = NULL;
1117 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1118return 0;
1119 return out.val.t;
1120}
1121
1122static inline size_t Yap_StringSWIToListOfAtoms(Term t0 USES_REGS) {
1123 seq_tv_t inp, out;
1124 inp.val.t = t0;
1125 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
1126 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES |
1127 YAP_STRING_TERM;
1128 out.type = YAP_STRING_ATOMS;
1129 out.val.uc = NULL;
1130 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1131return 0;
1132 return out.val.t;
1133}
1134
1135static inline size_t Yap_StringToListOfCodes(Term t0 USES_REGS) {
1136 seq_tv_t inp, out;
1137 inp.val.t = t0;
1138 inp.type = YAP_STRING_STRING;
1139 out.type = YAP_STRING_CODES;
1140 out.val.uc = NULL;
1141 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1142return 0;
1143 return out.val.t;
1144}
1145
1146static inline size_t Yap_StringSWIToListOfCodes(Term t0 USES_REGS) {
1147 seq_tv_t inp, out;
1148 inp.val.t = t0;
1149 inp.type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
1150 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_ATOMS_CODES |
1151 YAP_STRING_TERM;
1152 out.type = YAP_STRING_CODES;
1153 out.val.uc = NULL;
1154 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1155return 0;
1156 return out.val.t;
1157}
1158
1159static inline Term Yap_StringToNumber(Term t0 USES_REGS) {
1160 seq_tv_t inp, out;
1161 inp.val.t = t0;
1162 inp.type = YAP_STRING_STRING;
1163 out.type =
1164 YAP_STRING_INT | YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
1165 out.val.uc = NULL;
1166 out.enc = ENC_ISO_UTF8;
1167 if (!Yap_CVT_Text(&inp, &out PASS_REGS) )
1168return 0;
1169 return out.val.t;
1170}
1171
1172static inline Atom Yap_TextToAtom(Term t0 USES_REGS) {
1173 seq_tv_t inp, out;
1174
1175 inp.val.t = t0;
1176 inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES |
1177 YAP_STRING_ATOMS_CODES;
1178 out.val.uc = NULL;
1179 out.type = YAP_STRING_ATOM;
1180
1181 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1182return 0;
1183 return out.val.a;
1184}
1185
1186static inline Term Yap_TextToString(Term t0 USES_REGS) {
1187 seq_tv_t inp, out;
1188
1189 inp.val.t = t0;
1190 inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES |
1191 YAP_STRING_ATOMS_CODES;
1192 out.val.uc = NULL;
1193 out.type = YAP_STRING_STRING;
1194
1195 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1196return 0 ;
1197 return out.val.t;
1198}
1199
1200static inline void Yap_OverwriteUTF8BufferToLowCase(void *buf USES_REGS) {
1201 unsigned char *s = (unsigned char *)buf;
1202 while (*s) {
1203 // assumes the two code have always the same size;
1204 utf8proc_int32_t chr;
1205 get_utf8(s, -1, &chr);
1206 chr = utf8proc_tolower(chr);
1207 s += put_utf8(s, chr);
1208 }
1209}
1210
1228static inline const char *Yap_TextTermToText(Term t0 USES_REGS) {
1229 seq_tv_t inp, out;
1230
1231 inp.val.t = t0;
1232 inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES |
1233 YAP_STRING_ATOMS_CODES | YAP_STRING_MALLOC;
1234 out.val.uc = NULL;
1235 out.type = YAP_STRING_CHARS| YAP_STRING_MALLOC;
1236 out.enc = ENC_ISO_UTF8;
1237
1238 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1239 return NULL;
1240 return out.val.c0;
1241}
1242
1243static inline const unsigned char *Yap_TextToUTF8Buffer(Term t0 USES_REGS) {
1244 seq_tv_t inp, out;
1245
1246 inp.val.t = t0;
1247 inp.type = YAP_STRING_ATOM | YAP_STRING_STRING | YAP_STRING_CODES |
1248 YAP_STRING_ATOMS_CODES;
1249 out.val.uc = NULL;
1250 out.type = YAP_STRING_CHARS | YAP_STRING_MALLOC;
1251 out.enc = ENC_ISO_UTF8;
1252
1253 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1254 return NULL;
1255 return out.val.uc0;
1256}
1257
1258static inline Term Yap_UTF8ToString(const char *s USES_REGS) {
1259 return MkStringTerm(s);
1260}
1261
1262static inline Atom UTF32ToAtom(const wchar_t *s USES_REGS) {
1263 seq_tv_t inp, out;
1264
1265 inp.val.w0 = s;
1266 inp.type = YAP_STRING_WCHARS;
1267 out.type = YAP_STRING_ATOM;
1268 out.max = -1;
1269 if (!Yap_CVT_Text(&inp, &out PASS_REGS)) {
1270 LOCAL_Error_TYPE = (LOCAL_Error_TYPE == TYPE_ERROR_TEXT ? TYPE_ERROR_ATOM : LOCAL_Error_TYPE );
1271 return NULL;
1272 }
1273 return out.val.a;
1274}
1275
1276static inline Term Yap_WCharsToListOfCodes(const wchar_t *s USES_REGS) {
1277 seq_tv_t inp, out;
1278 inp.val.w0 = s;
1279 inp.type = YAP_STRING_WCHARS;
1280 out.val.uc = NULL;
1281 out.type = YAP_STRING_CODES;
1282 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1283 Yap_ThrowError(LOCAL_Error_TYPE, TermNil, "");
1284 return out.val.t;
1285}
1286
1287static inline Term Yap_WCharsToTDQ(wchar_t *s, Term mod USES_REGS) {
1288 seq_tv_t inp, out;
1289
1290 inp.val.w0 = s;
1291 inp.type = YAP_STRING_WCHARS;
1292
1293 inp.mod = mod;
1294 out.type = mod_to_type(mod PASS_REGS);
1295 out.val.uc = NULL;
1296 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1297 Yap_ThrowError(LOCAL_Error_TYPE, TermNil, "");
1298 return out.val.t;
1299}
1300
1301static inline Term Yap_WCharsToTBQ(wchar_t *s, Term mod USES_REGS) {
1302 seq_tv_t inp, out;
1303
1304 inp.val.w = s;
1305 inp.type = YAP_STRING_WCHARS;
1306 inp.mod = mod;
1307 out.type = mod_to_bqtype(mod PASS_REGS);
1308 out.val.uc = NULL;
1309 if (!Yap_CVT_Text(&inp, &out PASS_REGS))
1310 Yap_ThrowError(LOCAL_Error_TYPE, TermNil, "");
1311 return out.val.t;
1312}
1313
1314static inline Term Yap_WCharsToString(const wchar_t *s USES_REGS) {
1315 seq_tv_t inp, out;
1316 inp.val.w0 = s;
1317 inp.type = YAP_STRING_WCHARS;
1318 out.type = YAP_STRING_STRING;
1319 out.val.uc = NULL;
1320 if (!Yap_CVT_Text(&inp, &out PASS_REGS)) {
1321 LOCAL_Error_TYPE = (LOCAL_Error_TYPE == TYPE_ERROR_TEXT ? TYPE_ERROR_STRING : LOCAL_Error_TYPE );
1322 Yap_ThrowError(LOCAL_Error_TYPE, TermNil, "");
1323 }
1324 return out.val.t;
1325}
1326
1327static inline Atom Yap_ConcatAtoms(Term t1, Term t2 USES_REGS) {
1328 seq_tv_t inpv[2], out;
1329 inpv[0].val.t = t1;
1330 inpv[0].type = YAP_STRING_ATOM ;
1331 inpv[1].val.t = t2;
1332 inpv[1].type = YAP_STRING_ATOM;
1333 out.type = YAP_STRING_ATOM;
1334 out.val.uc = NULL;
1335 if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)) {
1336 LOCAL_Error_TYPE = (LOCAL_Error_TYPE == TYPE_ERROR_TEXT ? TYPE_ERROR_ATOM : LOCAL_Error_TYPE );
1337 return NULL;
1338 }
1339 return out.val.a;
1340}
1341
1342static inline Atom Yap_ConcatAtomics(Term t1, Term t2 USES_REGS) {
1343 seq_tv_t inpv[2], out;
1344 inpv[0].val.t = t1;
1345 inpv[0].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
1346 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
1347 inpv[1].val.t = t2;
1348 inpv[1].type = YAP_STRING_STRING | YAP_STRING_ATOM | YAP_STRING_INT |
1349 YAP_STRING_FLOAT | YAP_STRING_BIG | YAP_STRING_TERM;
1350 out.type = YAP_STRING_ATOM;
1351 out.val.uc = NULL;
1352 if (!Yap_Concat_Text(2, inpv, &out PASS_REGS))
1353 return (Atom)NULL;
1354 return out.val.a;
1355}
1356
1357static inline Term Yap_ConcatStrings(Term t1, Term t2 USES_REGS) {
1358 seq_tv_t inpv[2], out;
1359 inpv[0].val.t = t1;
1360 inpv[0].type = YAP_STRING_STRING;
1361 inpv[1].val.t = t2;
1362 inpv[1].type = YAP_STRING_STRING;
1363 out.type = YAP_STRING_STRING;
1364
1365 if (!Yap_Concat_Text(2, inpv, &out PASS_REGS)){
1366 LOCAL_Error_TYPE = (LOCAL_Error_TYPE == TYPE_ERROR_TEXT ? TYPE_ERROR_STRING : LOCAL_Error_TYPE );
1367 Yap_ThrowError(LOCAL_Error_TYPE, t1, "");
1368 }
1369 return out.val.t;
1370}
1371
1372static inline Atom Yap_SpliceAtom(Term t1, Atom ats[], size_t cut,
1373 size_t max USES_REGS) {
1374 seq_tv_t outv[2], inp;
1375 size_t cuts[2];
1376 cuts[0] = cut;
1377 cuts[1] = max;
1378 inp.type = YAP_STRING_ATOM;
1379 inp.val.t = t1;
1380 outv[0].type = YAP_STRING_ATOM;
1381 outv[1].type = YAP_STRING_ATOM;
1382 if (!Yap_Splice_Text(2, cuts, &inp, outv PASS_REGS)) {
1383 LOCAL_Error_TYPE = (LOCAL_Error_TYPE == TYPE_ERROR_TEXT ? TYPE_ERROR_ATOM : LOCAL_Error_TYPE );
1384 return NULL;
1385 }
1386 ats[0] = outv[0].val.a;
1387 ats[1] = outv[1].val.a;
1388 return ats[0];
1389}
1390
1391static inline Atom Yap_SubtractHeadAtom(Term t1, Term th USES_REGS) {
1392 const char *s = RepAtom(AtomOfTerm(t1))->StrOfAE;
1393 const char *sh = RepAtom(AtomOfTerm(th))->StrOfAE;
1394 if (strncmp(s, sh, strlen(sh)) == 0)
1395 return Yap_LookupAtom(s+strlen(sh));
1396 return NULL;
1397
1398}
1399
1400static inline Atom Yap_SubtractTailAtom(Term t1, Term th USES_REGS) {
1401 const char *s = RepAtom(AtomOfTerm(t1))->StrOfAE;
1402 const char *sh = RepAtom(AtomOfTerm(th))->StrOfAE;
1403 size_t n = strlen(s);
1404 size_t nh = strlen(sh);
1405 if (strncmp(s+(n-nh) , sh, nh) == 0) {
1406 return Yap_LookupAtomWithLength(s, n-nh);
1407 }
1408 return NULL;
1409}
1410
1411static inline Term Yap_SpliceString(Term t1, Term ts[], size_t cut,
1412 size_t max USES_REGS) {
1413 seq_tv_t outv[2], inp;
1414 size_t cuts[2];
1415 inp.type = YAP_STRING_STRING;
1416 inp.val.t = t1;
1417 outv[0].type = YAP_STRING_STRING;
1418 outv[1].type = YAP_STRING_STRING;
1419 cuts[0] = cut;
1420 cuts[1] = max;
1421 if (!Yap_Splice_Text(2, cuts, &inp, outv PASS_REGS)){
1422 LOCAL_Error_TYPE = (LOCAL_Error_TYPE == TYPE_ERROR_TEXT ? TYPE_ERROR_STRING : LOCAL_Error_TYPE );
1423 Yap_ThrowError(LOCAL_Error_TYPE, t1, "");
1424 }
1425 ts[0] = outv[0].val.t;
1426 ts[1] = outv[1].val.t;
1427 return ts[0];
1428}
1429
1430static inline Term Yap_SubtractHeadString(Term t1, Term th USES_REGS) {
1431 seq_tv_t outv[2], inp;
1432 inp.type = YAP_STRING_STRING;
1433 inp.val.t = t1;
1434 outv[0].type = YAP_STRING_STRING;
1435 outv[0].val.t = th;
1436 outv[1].type = YAP_STRING_STRING;
1437 outv[1].val.t = 0;
1438 if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)){
1439 LOCAL_Error_TYPE = (LOCAL_Error_TYPE == TYPE_ERROR_TEXT ? TYPE_ERROR_STRING : LOCAL_Error_TYPE );
1440 Yap_ThrowError(LOCAL_Error_TYPE, t1, "");
1441 }
1442 return outv[1].val.t;
1443}
1444
1445static inline Term Yap_SubtractTailString(Term t1, Term th USES_REGS) {
1446 seq_tv_t outv[2], inp;
1447 inp.type = YAP_STRING_STRING;
1448 inp.val.t = t1;
1449 outv[0].type = YAP_STRING_STRING;
1450 outv[0].val.t = 0;
1451 outv[1].type = YAP_STRING_STRING;
1452 outv[1].val.t = th;
1453 if (!Yap_Splice_Text(2, (size_t *)NULL, &inp, outv PASS_REGS)){
1454 LOCAL_Error_TYPE = (LOCAL_Error_TYPE == TYPE_ERROR_TEXT ? TYPE_ERROR_STRING : LOCAL_Error_TYPE );
1455 Yap_ThrowError(LOCAL_Error_TYPE, t1, "");
1456 }
1457 return outv[0].val.t;
1458}
1459
1460#endif // ≈YAP_TEXT_H
1461
1462extern Term Yap_MkTextTerm(const char *s, int guide USES_REGS);
1463
1464#endif // YAPTEXT_H_INCLUDED
YapUTF8.h
uTF-8 codepoint translation and processing
Yap.h
Main definitions.
Yap_tokRep
Term Yap_tokRep(void *tokptrXS)
represent token *_tokptr_ in string s, maxlength is sz-1
Definition: scanner.c:747
MP_INT
Definition: TermExt.h:345
mod_entry::flags
unsigned int flags
module's owner file
Definition: Yatom.h:219
text_cvt
Definition: YapText.h:134
Yap_wide_chtype
char_kind_t Yap_wide_chtype(int ch)
Definition: text.c:60
Yap_MkTextTerm
Term Yap_MkTextTerm(const char *s, int guide USES_REGS)
Convert from a text buffer (8-bit) to a term that has the same type as Tguide
Definition: text.c:1133
seq_val_t
Definition: YapText.h:118