18static char SccsId[] =
"%W% %G%";
73#define S_ISDIR(x) (((x)&_S_IFDIR) == _S_IFDIR)
79static Int p_change_type_of_char(USES_REGS1);
81int Yap_encoding_error(YAP_Int ch,
int code,
struct stream_desc *st) {
85 if (st->status & RepFail_Prolog_f)
87 if (
true||st->status & RepError_Prolog_f ||
88 trueGlobalPrologFlag(ISO_FLAG))
89 Yap_ThrowError(SYNTAX_ERROR, MkIntTerm(code),
"encoding error at stream %d %s:%lu, character %lu",st-GLOBAL_Stream,
90 AtomName((
Atom)st->name), st->linecount, st->charcount);
91 fprintf(stderr,
"encoding error at stream %ld %s:%lu, character %lu",st-GLOBAL_Stream,
92 RepAtom(st->name)->StrOfAE, st->linecount, st->charcount);
97int Yap_bad_nl_error( Term
string,
struct stream_desc *st) {
101if (trueLocalPrologFlag(MULTILINE_QUOTED_TEXT_FLAG)||
102 trueGlobalPrologFlag(ISO_FLAG)) {
103 if (st->status & RepFail_Prolog_f)
105 if (st->status & RepError_Prolog_f) {
106 Yap_ThrowError(SYNTAX_ERROR,
string,
"%s:%lu:0 error: quoted text terminates on newline",
107 AtomName((
Atom)st->name), st->linecount);
110 fprintf(stderr,
"%s:%lu:0 warning: quoted text terminates on newline",
112 st->name), st->linecount);
129 Yap_ThrowError__(AtomName(st->name),
"parser", st->linecount, SYNTAX_ERROR, MkIntTerm(ch),
130 "encoding error at character %l %s", code, s);
134Term Yap_StringToNumberTerm(
const char *s, encoding_t *encp,
bool error_on) {
137 Atom nat = AtomEmptyBrackets;
138 sno = Yap_open_buf_read_stream(NULL, s, strlen(s), encp, MEM_BUF_USER, nat, TermEvaluable);
142 GLOBAL_Stream[sno].encoding = *encp;
144 GLOBAL_Stream[sno].encoding = LOCAL_encoding;
149 GLOBAL_Stream[sno].status |= CloseOnException_Stream_f;
151 GLOBAL_Stream[sno].status |= RepFail_Prolog_f;
154 int i = push_text_stack();
156 Yap_CloseStream(sno);
157 UNLOCK(GLOBAL_Stream[sno].streamlock);
162const char *encvs[] = {
"LANG",
"LC_ALL",
"LC_CTYPE", NULL};
171 {
"UTF-8", ENC_ISO_UTF8},
172 {
"utf8", ENC_ISO_UTF8},
173 {
"UTF-16", ENC_UTF16_LE},
174 {
"UCS-2", ENC_UTF16_LE},
175 {
"ISO-LATIN1", ENC_ISO_LATIN1},
176 {
"ISO-8859-1", ENC_ISO_LATIN1},
177 {
"Windows-1252", ENC_ISO_LATIN1},
178 {
"CP-1252", ENC_ISO_LATIN1},
179 {
"C", ENC_ISO_ASCII},
181 {NULL, ENC_ISO_ASCII}
187static encoding_t enc_os_default(encoding_t rc) {
193 if (rc == ENC_ISO_ASCII) {
199encoding_t Yap_SystemEncoding(
void) {
201 while (i == -1 || encvs[i]) {
204 if ((v = setlocale(LC_CTYPE, NULL)) == NULL || !strcmp(v,
"C")) {
205 if ((v = getenv(
"LC_CTYPE")))
206 setlocale(LC_CTYPE, v);
207 else if ((v = getenv(
"LANG")))
208 setlocale(LC_CTYPE, v);
211 v = getenv(encvs[i]);
216 while ((coding = ematches[j].s) != NULL) {
218 if ((v1 = strstr(v, coding)) && strlen(v1) == strlen(coding)) {
219 return ematches[j].e;
226 return ENC_ISO_ASCII;
229static encoding_t DefaultEncoding(
void) {
230 return enc_os_default(Yap_SystemEncoding());
233encoding_t Yap_DefaultEncoding(
void) {
235 return LOCAL_encoding;
238void Yap_SetDefaultEncoding(encoding_t new_encoding) {
240 LOCAL_encoding = new_encoding;
243static Int get_default_encoding(USES_REGS1) {
244 Term out = MkIntegerTerm(Yap_DefaultEncoding());
245 return Yap_unify(ARG1, out);
248static Int p_encoding(USES_REGS1) {
250 Yap_CheckStream(ARG1, Input_Stream_f | Output_Stream_f,
"encoding/2");
251 Term t = Deref(ARG2);
255 UNLOCK(GLOBAL_Stream[sno].streamlock);
256 return Yap_unify(ARG2, MkIntegerTerm(GLOBAL_Stream[sno].
encoding));
258 GLOBAL_Stream[sno].encoding = IntegerOfTerm(Deref(ARG2));
259 UNLOCK(GLOBAL_Stream[sno].streamlock);
263static int get_char(Term t) {
264 if (IsVarTerm(t = Deref(t))) {
265 Yap_ThrowError(INSTANTIATION_ERROR, t, NULL);
268 if (!IsAtomTerm(t)) {
269 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t, NULL);
272 Atom at = AtomOfTerm(t);
273 unsigned char *s = RepAtom(at)->UStrOfAE;
275 s += get_utf8(s, 1, &c);
278 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t, NULL);
284static int get_code(Term t) {
285 if (IsVarTerm(t = Deref(t))) {
286 Yap_ThrowError(INSTANTIATION_ERROR, t, NULL);
289 if (!IsIntegerTerm(t)) {
290 Yap_ThrowError(TYPE_ERROR_CHARACTER_CODE, t, NULL);
293 Int ch = IntegerOfTerm(t);
295 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER_CODE, t, NULL);
301static int get_char_or_code(Term t,
bool *is_char) {
302 if (!IsAtomTerm(t)) {
303 if (!IsIntegerTerm(t)) {
304 Yap_ThrowError(TYPE_ERROR_CHARACTER, t, NULL);
307 Int ch = IntegerOfTerm(t);
309 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER_CODE, t, NULL);
315 unsigned char *s0 = RepAtom(AtomOfTerm(t))->UStrOfAE;
317 s0 += get_utf8(s0, 1, &val);
319 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t, NULL);
326static Int toupper2(USES_REGS1) {
327 bool is_char =
false;
329 if (!IsVarTerm(t = Deref(ARG1))) {
330 Int out = get_char_or_code(t, &is_char), uout;
334 uout = utf8proc_toupper(out);
336 return Yap_unify(ARG2, MkCharTerm(uout));
338 return Yap_unify(ARG2, MkIntegerTerm(uout));
339 }
else if (!IsVarTerm(t = Deref(ARG2))) {
340 Int uout = get_char_or_code(t, &is_char), out;
346 out = utf8proc_tolower(uout);
351 return Yap_unify(ARG1, MkCharTerm(out));
353 return Yap_unify(ARG1, MkIntegerTerm(out));
355 Yap_ThrowError(INSTANTIATION_ERROR, ARG1, NULL);
360static Int tolower2(USES_REGS1) {
361 bool is_char =
false;
363 if (!IsVarTerm(t = Deref(ARG1))) {
364 bool is_char =
false;
365 Int out = get_char_or_code(ARG1, &is_char), uout;
369 uout = utf8proc_tolower(out);
371 return Yap_unify(ARG2, MkCharTerm(uout));
373 return Yap_unify(ARG2, MkIntegerTerm(uout));
374 }
else if (IsVarTerm(t = Deref(ARG2))) {
375 Int uout = get_char_or_code(t, &is_char), out;
381 out = utf8proc_toupper(uout);
386 return Yap_unify(ARG1, MkCharTerm(out));
388 return Yap_unify(ARG1, MkIntegerTerm(out));
390 Yap_ThrowError(INSTANTIATION_ERROR, ARG1, NULL);
396 p_change_type_of_char(USES_REGS1) {
397 Term t1 = Deref(ARG1);
398 Term t2 = Deref(ARG2);
399 if (!IsVarTerm(t1) && !IsIntegerTerm(t1))
401 if (!IsVarTerm(t2) && !IsIntegerTerm(t2))
403 Yap_chtype[IntegerOfTerm(t1)] = IntegerOfTerm(t2);
407static Int char_type_alnum(USES_REGS1) {
408 int ch = get_char(ARG1);
410 return k == UC || k == LC || k == NU;
413static Int char_type_alpha(USES_REGS1) {
414 int ch = get_char(ARG1);
416 return k == UC || k == LC;
419static Int char_type_csym(USES_REGS1) {
420 int ch = get_char(ARG1);
422 return k >= UC && k <= NU;
425static Int char_type_csymf(USES_REGS1) {
426 int ch = get_char(ARG1);
428 return k >= UC && k <= LC;
431static Int char_type_ascii(USES_REGS1) {
432 int ch = get_char(ARG1);
436static Int char_type_white(USES_REGS1) {
437 int ch = get_char(ARG1);
439 char_kind_t k = Yap_chtype[ch];
442 utf8proc_category_t ct = utf8proc_category(ch);
443 return ct == UTF8PROC_CATEGORY_ZS;
446static Int char_type_cntrl(USES_REGS1) {
447 Int ch = get_char(ARG1);
452static Int char_type_digit(USES_REGS1) {
453 Int ch = get_char(ARG1);
458static Int char_type_xdigit(USES_REGS1) {
459 Int ch = get_char(ARG1);
461 return iswxdigit(ch);
462#elif HAVE_ISWHEXNUMBER
463 return iswhexnumber(ch);
465 return iswdigit(ch) || ((ch >=
'a' && ch <=
'f') && (ch >=
'A' && ch <=
'F'));
469static Int char_type_graph(USES_REGS1) {
470 Int ch = get_char(ARG1);
474static Int char_type_lower(USES_REGS1) {
476 int ch = get_char(ARG1);
485static Int char_type_upper(USES_REGS1) {
487 int ch = get_char(ARG1);
496static Int char_type_punct(USES_REGS1) {
497 int ch = get_char(ARG1);
499 return k >= QT && k <= BK;
502static Int char_type_space(USES_REGS1) {
503 int ch = get_char(ARG1);
505 return k >= QT && k <= BK;
508static Int char_type_end_of_file(USES_REGS1) {
509 Int ch = get_char(ARG1);
510 return ch == WEOF || ch == -1;
513static Int char_type_end_of_line(USES_REGS1) {
514 Int ch = get_char(ARG1);
516 return ch >= 10 && ch <= 13;
518 utf8proc_category_t ct = utf8proc_category(ch);
519 return (ct >= UTF8PROC_CATEGORY_ZL && ct <= UTF8PROC_CATEGORY_ZP);
522static Int char_type_newline(USES_REGS1) {
523 Int ch = get_char(ARG1);
530static Int char_type_period(USES_REGS1) {
531 Int ch = get_char(ARG1);
532 return ch ==
'.' || ch ==
'!' || ch ==
'?';
535static Int char_type_quote(USES_REGS1) {
536 Int ch = get_char(ARG1);
537 utf8proc_category_t ct = utf8proc_category(ch);
538 return ct == UTF8PROC_CATEGORY_PI || ct == UTF8PROC_CATEGORY_PF;
541static Int char_type_paren(USES_REGS1) {
542 Int ch = get_char(ARG1);
543 utf8proc_category_t ct = utf8proc_category(ch);
544 return ct == UTF8PROC_CATEGORY_PS || ct == UTF8PROC_CATEGORY_PE;
547static Int char_type_prolog_var_start(USES_REGS1) {
548 Int ch = get_char(ARG1);
550 return k == LC || ch ==
'_';
553static Int char_type_prolog_atom_start(USES_REGS1) {
554 Int ch = get_char(ARG1);
559static Int char_type_prolog_identifier_continue(USES_REGS1) {
560 int ch = get_char(ARG1);
562 return k >= UC && k <= NU;
565static Int char_type_prolog_prolog_symbol(USES_REGS1) {
566 int ch = get_char(ARG1);
568 return k == SL || k == SY;
571static Int code_type_alnum(USES_REGS1) {
572 int ch = get_code(ARG1);
574 return k == UC || k == LC || k == NU;
577static Int code_type_alpha(USES_REGS1) {
578 int ch = get_code(ARG1);
580 return k == UC || k == LC;
583static Int code_type_csym(USES_REGS1) {
584 int ch = get_code(ARG1);
586 return k >= UC && k <= NU;
589static Int code_type_csymf(USES_REGS1) {
590 int ch = get_code(ARG1);
592 return k >= UC && k <= LC;
595static Int code_type_ascii(USES_REGS1) {
596 int ch = get_code(ARG1);
600static Int code_type_white(USES_REGS1) {
601 int ch = get_code(ARG1);
603 char_kind_t k = Yap_chtype[ch];
606 utf8proc_category_t ct = utf8proc_category(ch);
607 return ct == UTF8PROC_CATEGORY_ZS;
610static Int code_type_cntrl(USES_REGS1) {
611 Int ch = get_code(ARG1);
616static Int code_type_digit(USES_REGS1) {
617 Int ch = get_code(ARG1);
622static Int code_type_xdigit(USES_REGS1) {
623 Int ch = get_code(ARG1);
625 return iswxdigit(ch);
626#elif HAVE_ISWHEXNUMBER
627 return iswhexnumber(ch);
629 return iswdigit(ch) || ((ch >=
'a' && ch <=
'f') && (ch >=
'A' && ch <=
'F'));
633static Int code_type_graph(USES_REGS1) {
634 Int ch = get_code(ARG1);
638static Int code_type_lower(USES_REGS1) {
639 int ch = get_code(ARG1);
644static Int code_type_upper(USES_REGS1) {
645 int ch = get_code(ARG1);
650static Int code_type_punct(USES_REGS1) {
651 int ch = get_char(ARG1);
653 char_kind_t k = Yap_chtype[ch];
654 return k >= QT && k <= BK;
659static Int code_type_space(USES_REGS1) {
660 int ch = get_code(ARG1);
662 char_kind_t k = Yap_chtype[ch];
665 utf8proc_category_t ct = utf8proc_category(ch);
666 return ct == UTF8PROC_CATEGORY_ZS;
669static Int code_type_end_of_file(USES_REGS1) {
670 Int ch = get_code(ARG1);
671 return ch == WEOF || ch == -1;
674static Int code_type_end_of_line(USES_REGS1) {
675 Int ch = get_code(ARG1);
677 return ch >= 10 && ch <= 13;
679 utf8proc_category_t ct = utf8proc_category(ch);
680 return (ct >= UTF8PROC_CATEGORY_ZL && ct <= UTF8PROC_CATEGORY_ZP);
683static Int code_type_newline(USES_REGS1) {
684 Int ch = get_code(ARG1);
691static Int code_type_period(USES_REGS1) {
692 Int ch = get_code(ARG1);
693 return ch ==
'.' || ch ==
'!' || ch ==
'?';
696static Int code_type_quote(USES_REGS1) {
697 Int ch = get_code(ARG1);
698 utf8proc_category_t ct = utf8proc_category(ch);
699 return ct == UTF8PROC_CATEGORY_PI || ct == UTF8PROC_CATEGORY_PF;
702static Int code_type_paren(USES_REGS1) {
703 Int ch = get_code(ARG1);
704 utf8proc_category_t ct = utf8proc_category(ch);
705 return ct == UTF8PROC_CATEGORY_PS || ct == UTF8PROC_CATEGORY_PE;
708static Int code_type_prolog_var_start(USES_REGS1) {
709 Int ch = get_code(ARG1);
711 return k == LC || ch ==
'_';
714static Int code_type_prolog_atom_start(USES_REGS1) {
715 Int ch = get_code(ARG1);
720static Int code_type_prolog_identifier_continue(USES_REGS1) {
721 int ch = get_code(ARG1);
723 return k >= UC && k <= NU;
726static Int code_type_prolog_prolog_symbol(USES_REGS1) {
727 int ch = get_code(ARG1);
729 return k == SL || k == SY;
732int ISOWGetc(
int sno) {
733 int ch = GLOBAL_Stream[sno].stream_wgetc(sno);
734 if (ch != EOF && GLOBAL_CharConversionTable != NULL) {
736 if (ch < NUMBER_OF_CHARS) {
738 return GLOBAL_CharConversionTable[ch];
744static Int p_force_char_conversion(USES_REGS1) {
748 if (GLOBAL_CharConversionTable2 == NULL)
750 for (i = 0; i < MaxStreams; i++) {
751 if (!(GLOBAL_Stream[i].status & Free_Stream_f))
752 GLOBAL_Stream[i].stream_wgetc_for_read = ISOWGetc;
754 GLOBAL_CharConversionTable = GLOBAL_CharConversionTable2;
758static Int p_disable_char_conversion(USES_REGS1) {
761 for (i = 0; i < MaxStreams; i++) {
762 if (!(GLOBAL_Stream[i].status & Free_Stream_f))
763 GLOBAL_Stream[i].stream_wgetc_for_read = GLOBAL_Stream[i].stream_wgetc;
765 GLOBAL_CharConversionTable = NULL;
770 Term t = Deref(ARG1), t1 = Deref(ARG2);
771 unsigned char *s0, *s1;
774 Yap_ThrowError(INSTANTIATION_ERROR, t,
"char_conversion/2");
777 if (!IsAtomTerm(t)) {
778 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t,
"char_conversion/2");
781 s0 = RepAtom(AtomOfTerm(t))->UStrOfAE;
783 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t,
"char_conversion/2");
787 Yap_ThrowError(INSTANTIATION_ERROR, t1,
"char_conversion/2");
790 if (!IsAtomTerm(t1)) {
791 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t1,
"char_conversion/2");
794 s1 = RepAtom(AtomOfTerm(t1))->UStrOfAE;
796 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t1,
"char_conversion/2");
800 if (GLOBAL_CharConversionTable2 == NULL) {
806 GLOBAL_CharConversionTable2 =
807 Yap_AllocCodeSpace(NUMBER_OF_CHARS *
sizeof(
char));
808 while (GLOBAL_CharConversionTable2 == NULL) {
809 if (!Yap_growheap(FALSE, NUMBER_OF_CHARS *
sizeof(
char), NULL)) {
810 Yap_ThrowError(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
814 if (trueGlobalPrologFlag(CHAR_CONVERSION_FLAG)) {
816 if (p_force_char_conversion(PASS_REGS1) == FALSE)
819 for (i = 0; i < NUMBER_OF_CHARS; i++)
820 GLOBAL_CharConversionTable2[i] = i;
823 GLOBAL_CharConversionTable2[(int)s0[0]] = s1[0];
828static Int p_current_char_conversion(USES_REGS1) {
830 unsigned char *s0, *s1;
832 if (GLOBAL_CharConversionTable == NULL) {
837 Yap_ThrowError(INSTANTIATION_ERROR, t,
"current_char_conversion/2");
840 if (!IsAtomTerm(t)) {
841 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t,
"current_char_conversion/2");
844 s0 = RepAtom(AtomOfTerm(t))->UStrOfAE;
846 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t,
"current_char_conversion/2");
852 if (GLOBAL_CharConversionTable[(
int)s0[0]] ==
'\0')
854 out[0] = GLOBAL_CharConversionTable[(int)s0[0]];
856 return (Yap_unify(ARG2, MkAtomTerm(Yap_LookupAtom(out))));
858 if (!IsAtomTerm(t1)) {
859 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t1,
"current_char_conversion/2");
862 s1 = RepAtom(AtomOfTerm(t1))->UStrOfAE;
864 Yap_ThrowError(REPRESENTATION_ERROR_CHARACTER, t1,
"current_char_conversion/2");
867 return (GLOBAL_CharConversionTable[(
int)s0[0]] ==
'\0' &&
868 GLOBAL_CharConversionTable[(
int)s0[0]] == s1[0]);
872static Int p_all_char_conversions(USES_REGS1) {
876 if (GLOBAL_CharConversionTable == NULL) {
879 for (i = NUMBER_OF_CHARS; i > 0;) {
881 if (GLOBAL_CharConversionTable[i] !=
'\0') {
885 s[0] = GLOBAL_CharConversionTable[i];
886 t1 = MkAtomTerm(Yap_LookupAtom(s));
887 out = MkPairTerm(t1, out);
889 t2 = MkAtomTerm(Yap_LookupAtom(s));
890 out = MkPairTerm(t2, out);
893 return (Yap_unify(ARG1, out));
896void Yap_InitChtypes(
void) {
898 LOCAL_encoding = DefaultEncoding();
899 Yap_InitCPred(
"$change_type_of_char", 2, p_change_type_of_char,
900 SafePredFlag | SyncPredFlag | HiddenPredFlag);
901 Yap_InitCPred(
"toupper", 2, toupper2, SafePredFlag);
902 Yap_InitCPred(
"tolower", 2, tolower2, SafePredFlag);
905 Yap_InitCPred(
"$get_default_encoding", 1, get_default_encoding,
906 SafePredFlag | HiddenPredFlag);
908 Yap_InitCPred(
"$encoding", 2, p_encoding, SafePredFlag | SyncPredFlag),
910 Yap_InitCPred(
"$current_char_conversion", 2, p_current_char_conversion,
911 SyncPredFlag | HiddenPredFlag);
912 Yap_InitCPred(
"$all_char_conversions", 1, p_all_char_conversions,
913 SyncPredFlag | HiddenPredFlag);
914 Yap_InitCPred(
"$force_char_conversion", 0, p_force_char_conversion,
915 SyncPredFlag | HiddenPredFlag);
916 Yap_InitCPred(
"$disable_char_conversion", 0, p_disable_char_conversion,
917 SyncPredFlag | HiddenPredFlag);
919 Yap_InitCPred(
"char_type_alnum", 1, char_type_alnum, SafePredFlag);
920 Yap_InitCPred(
"char_type_alpha", 1, char_type_alpha, SafePredFlag);
921 Yap_InitCPred(
"char_type_csym", 1, char_type_csym, SafePredFlag);
922 Yap_InitCPred(
"char_type_csymf", 1, char_type_csymf, SafePredFlag);
923 Yap_InitCPred(
"char_type_ascii", 1, char_type_ascii, SafePredFlag);
924 Yap_InitCPred(
"char_type_white", 1, char_type_white, SafePredFlag);
925 Yap_InitCPred(
"char_type_cntrl", 1, char_type_cntrl, SafePredFlag);
926 Yap_InitCPred(
"char_type_digit", 1, char_type_digit, SafePredFlag);
927 Yap_InitCPred(
"char_type_xdigit", 1, char_type_xdigit, SafePredFlag);
928 Yap_InitCPred(
"char_type_graph", 1, char_type_graph, SafePredFlag);
929 Yap_InitCPred(
"char_type_lower", 1, char_type_lower, SafePredFlag);
930 Yap_InitCPred(
"char_type_upper", 1, char_type_upper, SafePredFlag);
931 Yap_InitCPred(
"char_type_punct", 1, char_type_punct, SafePredFlag);
932 Yap_InitCPred(
"char_type_space", 1, char_type_space, SafePredFlag);
933 Yap_InitCPred(
"char_type_end_of_file", 1, char_type_end_of_file,
935 Yap_InitCPred(
"char_type_end_of_line", 1, char_type_end_of_line,
937 Yap_InitCPred(
"char_type_newline", 1, char_type_newline, SafePredFlag);
938 Yap_InitCPred(
"char_type_period", 1, char_type_period, SafePredFlag);
939 Yap_InitCPred(
"char_type_quote", 1, char_type_quote, SafePredFlag);
940 Yap_InitCPred(
"char_type_paren", 1, char_type_paren, SafePredFlag);
941 Yap_InitCPred(
"char_type_prolog_var_start", 1, char_type_prolog_var_start,
943 Yap_InitCPred(
"char_type_prolog_atom_start", 1, char_type_prolog_atom_start,
945 Yap_InitCPred(
"char_type_prolog_identifier_continue", 1,
946 char_type_prolog_identifier_continue, SafePredFlag);
947 Yap_InitCPred(
"char_type_prolog_prolog_symbol", 1,
948 char_type_prolog_prolog_symbol, SafePredFlag);
949 Yap_InitCPred(
"code_type_alnum", 1, code_type_alnum, SafePredFlag);
950 Yap_InitCPred(
"code_type_alpha", 1, code_type_alpha, SafePredFlag);
951 Yap_InitCPred(
"code_type_csym", 1, code_type_csym, SafePredFlag);
952 Yap_InitCPred(
"code_type_csymf", 1, code_type_csymf, SafePredFlag);
953 Yap_InitCPred(
"code_type_ascii", 1, code_type_ascii, SafePredFlag);
954 Yap_InitCPred(
"code_type_white", 1, code_type_white, SafePredFlag);
955 Yap_InitCPred(
"code_type_cntrl", 1, code_type_cntrl, SafePredFlag);
956 Yap_InitCPred(
"code_type_digit", 1, code_type_digit, SafePredFlag);
957 Yap_InitCPred(
"code_type_xdigit", 1, code_type_xdigit, SafePredFlag);
958 Yap_InitCPred(
"code_type_graph", 1, code_type_graph, SafePredFlag);
959 Yap_InitCPred(
"code_type_lower", 1, code_type_lower, SafePredFlag);
960 Yap_InitCPred(
"code_type_upper", 1, code_type_upper, SafePredFlag);
961 Yap_InitCPred(
"code_type_punct", 1, code_type_punct, SafePredFlag);
962 Yap_InitCPred(
"code_type_space", 1, code_type_space, SafePredFlag);
963 Yap_InitCPred(
"code_type_end_of_file", 1, code_type_end_of_file,
965 Yap_InitCPred(
"code_type_end_of_line", 1, code_type_end_of_line,
967 Yap_InitCPred(
"code_type_newline", 1, code_type_newline, SafePredFlag);
968 Yap_InitCPred(
"code_type_period", 1, code_type_period, SafePredFlag);
969 Yap_InitCPred(
"code_type_quote", 1, code_type_quote, SafePredFlag);
970 Yap_InitCPred(
"code_type_paren", 1, code_type_paren, SafePredFlag);
971 Yap_InitCPred(
"code_type_prolog_var_start", 1, code_type_prolog_var_start,
973 Yap_InitCPred(
"code_type_prolog_atom_start", 1, code_type_prolog_atom_start,
975 Yap_InitCPred(
"code_type_prolog_identifier_continue", 1,
976 code_type_prolog_identifier_continue, SafePredFlag);
977 Yap_InitCPred(
"code_type_prolog_prolog_symbol", 1,
978 code_type_prolog_prolog_symbol, SafePredFlag);
979 CurrentModule = PROLOG_MODULE;
int Yap_symbol_encoding_error(YAP_Int ch, int code, struct stream_desc *st, const char *s)
This is a bug while encoding a symbol, and should always result in a syntax error.
Term Yap_scan_num(StreamDesc *inp)
This routine is used when we need to parse a string into a number.
void Yap_ThrowError__(const char *file, const char *function, int lineno, yap_error_number type, Term where, const char *msg,...)
Throw an error directly to the error handler.
@ char_conversion
Writable flag telling whether a character conversion table is used when reading terms.
@ encoding
support for coding systens, YAP relies on UTF-8 internally
char_kind_t Yap_wide_chtype(int ch)