w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

tex4ht.c
Go to the documentation of this file.
1 
2 
3 
4 /* tex4ht.c (2018-07-03-10:36), generated from tex4ht-c.tex
5  Copyright 2009-2018 TeX Users Group
6  Copyright 1996-2009 Eitan M. Gurari
7 
8 
9 
10 %
11 % This work may be distributed and/or modified under the
12 % conditions of the LaTeX Project Public License, either
13 % version 1.3c of this license or (at your option) any
14 % later version. The latest version of this license is in
15 % http://www.latex-project.org/lppl.txt
16 % and version 1.3c or later is part of all distributions
17 % of LaTeX version 2005/12/01 or later.
18 %
19 % This work has the LPPL maintenance status "maintained".
20 %
21 % The Current Maintainer of this work
22 % is the TeX4ht Project <http://tug.org/tex4ht>.
23 %
24 % If you modify this program, changing the
25 % version identification would be appreciated.
26  */
27 
28 
29 
30 /* Compiler options (uncommented | command line), as comments:
31 
32  Classic C (CC) default
33 #define ANSI ansi-c, c++
34 #define DOS_C
35 #define HAVE_STRING_H <string.h>
36 #define HAVE_DIRENT_H <dirent.h>
37 #define HAVE_SYS_NDIR_H <sys/ndir.h>
38 #define HAVE_SYS_DIR_H <sys/dir.h>
39 #define HAVE_NDIR_H <ndir.h>
40 #define HAVE_IO_H <io.h>
41 #define HAVE_UNISTD_H <unistd.h>
42 #define WIN32
43 #define KPATHSEA
44 #define CDECL .......
45 #define BCC32 bordland c++
46 
47 *************************************************
48  Tex4ht variables *
49  (uncommented | command line) *
50 ----------------------------------------------- */
51 
52 
53 
54 #ifndef LGFNT
55 #define LGFNT "Font(\"%s\",\"%s\",\"%d\",\"%d\")\n"
56 #endif
57 
58 
59 
60 
61 #ifndef LGCLS
62 #define LGCLS "Font_Class(%d,\"%s\"): %s\n"
63 #endif
64 
65 
66 
67 
68 #ifndef LGPIC
69 #define LGPIC "--- needs --- %%1.idv[%%2] ==> %%3 ---\n%"
70 #endif
71 
72 
73 
74 
75 #ifndef LGSEP
76 #define LGSEP "--- characters ---\n"
77 #endif
78 
79 
80 
81 
82 #ifndef LGTYP
83 #define LGTYP ".png"
84 #endif
85 
86 
87 
88 
89 #ifndef ENVFILE
90 
91 #endif
92 
93 
94 
95 
96 #ifndef TFMDIR
97 
98 #endif
99 
100 
101 
102 
103 #ifndef HTFDIR
104 
105 #endif
106 
107 
108 /* ******************************************** */
109 
110 
111 
112 
113 #ifdef BCC32
114 #define DOS_WIN32
115 #define ANSI
116 #define HAVE_DIRENT_H
117 #define PLATFORM "ms-win32"
118 #endif
119 
120 
121 
122 
123 
124 #ifdef BCC
125 #define DOS_C
126 #define ANSI
127 #define HAVE_DIRENT_H
128 #define PLATFORM "ms-dos"
129 #ifndef PATH_MAX
130 #define PATH_MAX 256
131 #endif
132 #endif
133 
134 
135 
136 
137 
138 #ifdef __DJGPP__
139 #define DOS_WIN
140 #define ANSI
141 #ifndef HAVE_STRING_H
142 #define HAVE_STRING_H 1
143 #endif
144 #endif
145 
146 
147 #ifdef DOS_C
148 #define DOS
149 #endif
150 #ifdef DOS
151 #define DOS_WIN32
152 #define HAVE_STRING_H <string.h>
153 #endif
154 #ifdef WIN32
155 #define DOS_WIN32
156 #ifndef KPATHSEA
157 #define HAVE_STRING_H <string.h>
158 #endif
159 #endif
160 
161 
162 
163 #ifdef DOS_WIN32
164 #define STRUCT_DIRENT
165 #endif
166 
167 
168 
169 
170 
171 #ifdef KPATHSEA
172 #ifdef WIN32
173 #define KWIN32
174 #endif
175 #endif
176 
177 
178 
179 
180 
181 #ifdef KPATHSEA
182 #include <kpathsea/config.h>
183 #endif
184 #include <stdio.h>
185 #include <stdlib.h>
186 
187 
188 
189 
190 #ifdef HAVE_STRING_H
191 #include <string.h>
192 #endif
193 
194 
195 
196 
197 #ifdef WIN32
198 #ifdef KPATHSEA
199 #undef CDECL
200 #define CDECL __cdecl
201 #else
202 #include <windows.h>
203 #endif
204 #else
205 #ifdef KPATHSEA
206 #define CDECL
207 #endif
208 #endif
209 
210 
211 
212 
213 #include <limits.h>
214 
215 
216 
217 
218 #include <signal.h>
219 
220 
221 
222 
223 #ifndef F_OK
224 #ifdef DOS_WIN32
225 #define F_OK 0
226 #endif
227 #ifndef KPATHSEA
228 #ifndef DOS_WIN32
229 #define HAVE_UNISTD_H
230 #endif
231 #endif
232 #endif
233 #ifdef HAVE_IO_H
234 #include <io.h>
235 #endif
236 #ifndef KPATHSEA
237 #ifdef HAVE_UNISTD_H
238 #include <unistd.h>
239 #endif
240 #endif
241 
242 
243 
244 
245 
246 
247 
248 #ifdef KPATHSEA
249 #include <kpathsea/c-errno.h>
250 #include <kpathsea/c-ctype.h>
251 #include <kpathsea/c-fopen.h>
252 #include <kpathsea/c-pathmx.h>
253 #include <kpathsea/proginit.h>
254 #include <kpathsea/tex-file.h>
255 #include <kpathsea/tex-make.h>
256 #include <kpathsea/variable.h>
257 #include <signal.h>
258 #if !defined(_AMIGA) && !defined(WIN32)
259 #include <sys/time.h>
260 #endif
261 #include <fcntl.h>
262 #include <setjmp.h>
263 #endif
264 
265 
266 
267 
268 
269 
270 #ifdef DOS_WIN32
271 #include <io.h>
272 #endif
273 
274 
275 
276 
277 #include <sys/stat.h>
278 
279 
280 
281 
282 
283 #ifdef HAVE_DIRENT_H
284 
285 
286 
287 #include <dirent.h>
288 
289 
290 #else
291 #ifndef STRUCT_DIRENT
292 #define STRUCT_DIRECT
293 #endif
294 
295 
296 
297 #ifdef HAVE_SYS_NDIR_H
298 #include <sys/ndir.h>
299 #endif
300 #ifdef HAVE_SYS_DIR_H
301 #include <sys/dir.h>
302 #endif
303 #ifdef HAVE_NDIR_H
304 #include <ndir.h>
305 #endif
306 
307 
308 #endif
309 
310 
311 
312 
313 
314 #ifdef DOS
315 #define HTM
316 #endif
317 
318 
319 
320 
321 
322 
323 #ifdef DOS
324 #define PROTOTYP
325 #endif
326 #ifdef ANSI
327 #define PROTOTYP
328 #endif
329 #ifdef KWIN32
330 #define PROTOTYP
331 #endif
332 
333 
334 
335 
336 
337 
338 
339 
340 
341 #ifndef EXIT_FAILURE
342 #define EXIT_FAILURE 1
343 #endif
344 
345 
346 
347 
348 #if INT_MAX < 2147483647L
349 #define LONG L
350 #endif
351 
352 
353 
354 
355 #ifdef LONG
356 #define INTEGER long
357 #else
358 #define INTEGER int
359 #endif
360 #define U_CHAR char
361 
362 
363 
364 
365 #define m_alloc(typ,n) (typ *) malloc_chk((int) ((n) * sizeof(typ)))
366 
367 
368 
369 
370 #ifndef PATH_MAX
371 #define PATH_MAX 512
372 #endif
373 
374 
375 
376 
377 #define IGNORED void
378 
379 
380 
381 
382 struct files_rec{
384  char* name;
385  struct files_rec *next, *prev;
386 };
387 
388 
389 
390 
391 struct sys_call_rec{
392  char* filter;
393  struct sys_call_rec *next;
394 };
395 
396 
397 
398 
399 #define HEIGHT 120
400 
401 
402 
403 
404 #define NULL_MAP (struct map_line_type*) 0
405 
406 
407 
408 
409 #define XRESOLUTION MARGINSP
410 #ifdef LONG
411 #define YRESOLUTION 786432L
412 #else
413 #define YRESOLUTION 786432
414 #endif
415 
416 
417 
418 
419 #define MAX_MAP_LINE 500
420 
421 
422 
423 
424 #define idv_int(val) int_to_dvi((long int) val,4)
425 
426 
427 
428 
429 struct halign_rec{
430  char * str;
431  int refs;
432 };
433 
434 
435 
436 
437 #define design_size_to_pt(n) ((double)n / (double)(1L<<20))
438 
439 
440 
441 
442 #define new_font font_tbl[font_tbl_size]
443 
444 
445 
446 
447 #ifdef LONG
448 #define MARGINSP 344061L
449 #else
450 #define MARGINSP 344061
451 #endif
452 
453 
454 
455 
456 #define HTF_ALIAS 10000000
457 
458 
459 
460 
461 #ifndef TRUE
462 #define TRUE 1
463 #endif
464 #ifndef FALSE
465 #define FALSE 0
466 #endif
467 #ifndef BOOL
468 #define BOOL int
469 #endif
470 
471 
472 
473 
474 #define GIF_I "-%x%s"
475 #define GIF_II "-%x-%x%s"
476 #define GIF_VII "%s"
477 
478 
479 
480 
481 #ifdef HTM
482 #define DOS_GIF_FILE
483 #endif
484 
485 
486 
487 
488 #define BASE 36
489 
490 
491 
492 
493 #define store_bit_I(ch,i) ch[(i)/8]|=(1<<((i)%8));
494 #define store_bit_Z(ch,i) ch[(i)/8]&=~(1<<((i)%8))
495 #define add_bit(ch,i,b) ch[(i)/8] |= ((b) << ((i)%8))
496 #define get_bit(ch,i) ((ch[(i)/8] >> ((i)%8)) & 1)
497 
498 
499 
500 
501 #define gif_open span_open
502 #define gif_alt span_name
503 #define gif_class span_size
504 #define gif_size span_mag
505 #define gif_mag span_ord
506 #define gif_ord span_ch
507 #define gif_end end_span
508 
509 
510 
511 
512 struct env_c_rec{
513  char *option;
514  struct env_c_rec *next;
515 };
516 
517 
518 
519 
520 #ifndef MAXFDIRS
521 #define MAXFDIRS 100
522 #endif
523 
524 
525 
526 
527 #if defined(__DJGPP__)
528 #define dir_path_slash(str) (is_forward_slash(str)? '/' : '\\')
529 #else
530 #define dir_path_slash(str) '/'
531 #endif
532 
533 
534 
535 
536 #ifndef S_ISDIR
537 #define S_ISDIR(M) (((M) & _S_IFMT)==_S_IFDIR)
538 #endif
539 
540 #ifndef _S_IFDIR
541 #define _S_IFDIR S_IFDIR
542 #endif
543 
544 #ifndef _S_IFMT
545 #define _S_IFMT S_IFMT
546 #endif
547 
548 
549 
550 
551 #if defined(DOS_WIN32) || !defined(S_ISLNK)
552 #define LSTAT stat
553 #else
554 #define LSTAT lstat
555 #endif
556 #define STSTAT stat
557 
558 
559 
560 
561 #define MAX_UNI_CODE 20
562 
563 
564 
565 
566 #define BASE_A 55
567 #define BASE_a 87
568 
569 
570 
571 
572 #define get_unt(n) fget_unt(dvi_file,n)
573 
574 
575 
576 
577 #define get_int(n) fget_int(dvi_file,n)
578 
579 
580 
581 
582 #define eq_str(x,y) (!strcmp(x,y))
583 #define gt_str(x,y) (strcmp(x,y)>0)
584 
585 
586 
587 
588 #define bad_arg err_i(0)
589 #define bad_in_file(name) err_i_str(1,name)
590 #define bad_out_file(name) err_i_str(2,name)
591 #define bad_special(name) warn_i_str(3,name)
592 #define bad_mem err_i(4)
593 #define bad_char(chr) warn_i_int(5,chr)
594 #define bad_dvi err_i(7)
595 
596 
597 
598 
599 #if defined(DOS_WIN32) || defined(__MSDOS__)
600 #define READ_BIN_FLAGS "rb"
601 #define READ_TEXT_FLAGS "r"
602 #define WRITE_BIN_FLAGS "wb"
603 #ifdef WIN32
604 #define WRITE_TEXT_FLAGS "wb"
605 #else
606 #define WRITE_TEXT_FLAGS "w"
607 #endif
608 #else
609 #define READ_BIN_FLAGS "r"
610 #define READ_TEXT_FLAGS "r"
611 #define WRITE_BIN_FLAGS "w"
612 #define WRITE_TEXT_FLAGS "w"
613 #endif
614 
615 
616 
617 
618 #ifdef PROTOTYP
619 #define MYVOID void
620 #define ARG_I(x) x
621 #define ARG_II(x,y) x,y
622 #define ARG_III(x,y,z) x,y,z
623 #define ARG_IV(x,y,z,w) x,y,z,w
624 #define ARG_V(x,y,z,w,v) x,y,z,w,v
625 #define ARG_VI(x,y,z,w,v,u) x,y,z,w,v,u
626 #define ARG_VII(x,y,z,w,v,u,t) x,y,z,w,v,u,t
627 #else
628 #define MYVOID
629 #define ARG_I(x)
630 #define ARG_II(x,y)
631 #define ARG_III(x,y,z)
632 #define ARG_IV(x,y,z,w)
633 #define ARG_V(x,y,z,w,v)
634 #define ARG_VI(x,y,z,w,v,u)
635 #define ARG_VII(x,y,z,w,v,u,t)
636 #endif
637 
638 
639 
640 
641 
642 struct hcode_repl_typ { char *str;
643  struct hcode_repl_typ *next; };
644 
645 
646 
647 
648 struct count_rec{
649  char* str;
650  int i, depth, max;
651  int* stack;
652  struct count_rec* next;
653 };
654 
655 
656 
657 
658 struct ch_map_rec{
659  char* line;
660  int max, chars;
661 };
662 
663 
664 
665 
666 struct stack_entry{
667  long int x_val, y_val;
670  BOOL
671 
672 
674 
675 ;
676 
677 
678 
679 struct halign_rec *halign[8];
681 
682 
683 
684 
686 struct group_info * begin;
688 
689 
690 
691 
693 
694 
695 
696 
701 
702 
703 };
704 
705 
706 
707 
708 struct group_info{
709  int stack_id;
711  struct group_info* next;
712 };
713 
714 
715 
716 
720 };
721 
722 
723 
724 
728  int fnt, id;
729 };
730 
731 
732 
733 
737  int id;
738 };
739 
740 
741 
742 
743 struct group_path{
747  struct group_path * next;
748 };
749 
750 
751 
752 
753 struct font_entry {
757 
758 
759 
761 
762 
763 
764 
765 
767 
768 
769 
770 
771 
773  int char_f, char_l;
776  int wtbl_n;
777  int htbl_n;
778  int dtbl_n;
785 
786 
787 
788 
789 
790 char *name, *gif_on, *ch_str, ch255;
791 unsigned U_CHAR **str, *ch, *gif1;
792 
793 
794 
795 
796 unsigned U_CHAR *accent, *accented;
798 
799 
800 
801 
802 
804 
805 
806 
807 
808 
810 unsigned long rgba_color;
811 
812 
813 };
814 
815 
816 
817 
818 struct html_font_rec{ char* name;
819  int i; };
820 
821 
822 
823 
824 
828  struct gif_file_rec *next; };
829 
830 
831 
832 
833 
834 struct css_ext_rec{ char* name;
835  struct css_ext_rec *next; };
836 
837 
838 
839 
840 struct visited_file_rec{ char *name;
841  struct visited_file_rec *next; };
842 
843 
844 
845 
846 struct env_var_rec{ char* base;
847  struct env_var_rec *next; };
848 
849 
850 
851 
852 struct cache_font_rec{ char* dir;
854  struct cache_font_rec* next; };
856  U_CHAR * file; };
857 
858 
859 
860 
861 struct htf_com_rec{ char* name;
862  struct htf_com_rec* next; };
863 
864 
865 
866 
867 struct charset_rec{ int ch;
868  char* str; };
869 
870 
871 
872 
873 struct htf_4hf_rec { int ch, type1, type2;
874  char* str; };
875 
876 
877 
878 
879 
880 #ifdef WIN32
881 static U_CHAR dirname[PATH_MAX];
882 #endif
883 
884 
885 
886 
888 #ifdef DOS_GIF_FILE
889  TRUE
890 #else
891  FALSE
892 #endif
893 ;
894 
895 
896 
897 
898 static FILE* dot_file;
899 
900 
901 
902 
903 static FILE* dvi_file;
904 
905 
906 
907 
908 static U_CHAR *ext = NULL;
909 
910 
911 
912 
913 static char* job_name;
914 static int job_name_n;
915 
916 
917 
918 
920 
921 
922 
923 
924 static FILE *out_file = (FILE *) 0,
925  *root_file = (FILE *) 0,
926  *cur_o_file = (FILE *) 0;
927 
928 
929 
930 
931 static int version_id;
932 
933 
934 
935 
936 static int stack_len;
937 
938 
939 
940 
942 
943 
944 
945 
947 static int trace_dvi_P = 0, trace_dvi_C = 0,
959 static int push_depth=0, push_id=0, push_st[256];
960 
961 
962 
963 
964 static long int x_val = 0, max_x_val = -10000,
966 
967 
968 
969 
970 static INTEGER dx_1 = 0, dx_2 = 0;
971 
972 
973 
974 
975 static INTEGER dy_1 = 0, dy_2 = 0;
976 static long int y_val = 0;
977 
978 
979 
980 
981 static U_CHAR *eoln_str = (char *)0;
982 
983 
984 
985 
986 static U_CHAR *space_str = (char *)0;
987 
988 
989 
990 
992 
993 
994 
995 
996 static BOOL text_on = FALSE;
997 
998 
999 
1000 
1001 static U_CHAR rule_ch = '_';
1002 static BOOL
1003 
1004 
1006 
1007  = FALSE;
1008 
1009 
1010 
1011 
1012 static int cur_fnt = -1;
1013 
1014 
1015 
1016 
1017 static U_CHAR special_hd[10];
1018 
1019 
1020 
1021 
1023  = (struct hcode_repl_typ*) 0;
1024 
1025 
1026 
1027 
1029 static int next_char = -1;
1030 static U_CHAR *next_str = (char *) 0;
1031 
1032 
1033 
1034 
1036 
1037 
1038 
1039 
1040 static struct files_rec
1041  *opened_files = (struct files_rec *) 0, *p;
1042 
1043 
1044 
1045 
1047 static struct sys_call_rec *system_calls = (struct sys_call_rec *) 0;
1048 
1049 
1050 
1051 
1052 static struct count_rec *counter = (struct count_rec *) 0;
1053 
1054 
1055 
1056 
1057 static struct ch_map_rec ch_map[HEIGHT];
1059 
1060 
1061 
1062 
1064 
1065 
1066 
1067 
1069 
1070 
1071 
1072 
1073 static U_CHAR ok_map = TRUE;
1074 
1075 
1076 
1077 
1078 static int prevcol = -1, prevrow;
1079 static double prev_x;
1080 
1081 
1082 
1083 
1085 static FILE *idv_file;
1086 
1087 
1088 
1089 
1090 static int errCode = 0;
1091 
1092 
1093 
1094 
1095 static int id_version = -1;
1096 
1097 
1098 
1099 
1100 static FILE* log_file;
1101 
1102 
1103 
1104 
1106 
1107 
1108 
1109 
1110 static int page_n, file_n;
1111 
1112 
1113 
1114 
1115 static struct halign_rec *halign[8];
1116 
1117 
1118 
1119 
1121 
1122 
1123 
1124 
1126 
1127 
1128 
1129 
1130 static int stack_n = 0;
1131 static struct stack_entry* stack;
1132 
1133 
1134 
1135 
1136 static int ignore_end_group;
1137 
1138 
1139 
1140 
1142 
1143 
1144 
1145 
1147 
1148 
1149 
1150 
1152 
1153 
1154 
1155 
1156 static BOOL pos_dvi = FALSE;
1160 static long int base_pos_x, base_pos_y, min_pos_x,
1162 static short rect_pos;
1163 
1164 
1165 
1166 
1167 static struct font_entry* font_tbl;
1168 static int font_tbl_size = 0;
1169 
1170 
1171 
1172 
1173 static char* new_font_name;
1174 
1175 
1176 
1177 
1179 
1180 
1181 
1182 
1183 static double word_sp = 999999.0, margin_sp;
1184 
1185 
1186 
1187 
1188 static int ignore_ch = 0;
1189 
1190 
1191 
1192 
1193 static unsigned U_CHAR null_str = '\0';
1194 
1195 
1196 
1197 
1198 static short dump_htf_files = 0;
1200 
1201 
1202 
1203 
1205 
1206 
1207 
1208 
1209 static BOOL verb_ch = FALSE;
1210 
1211 
1212 
1213 
1215 
1216 
1217 
1218 
1220 
1221 
1222 
1223 
1225 
1226 
1227 
1228 
1229 static U_CHAR *gif = NULL;
1230 
1231 
1232 
1233 
1234 
1235 static struct gif_file_rec * gif_file = (struct gif_file_rec *) 0;
1236 
1237 
1238 
1239 
1240 
1241 
1242 static U_CHAR xeh[]="0123456789abcdefghijklmnopqrstuvxyz";
1243 
1244 
1245 
1246 
1247 
1248 static BOOL gif_ch = TRUE;
1249 static int design_ch = 0;
1250 
1251 
1252 
1253 
1254 static int pause_style = 0, default_font = -1, base_font_size=6533;
1255 static BOOL
1258 
1259 
1260 
1261 
1263 
1264 
1265 
1266 
1267 static U_CHAR * span_name[256], * span_open[256], * span_size[256],
1268  * span_mag[256], * span_ch[256], * end_span[256],
1269  * span_ord[256], * gif_id[256];
1270 static U_CHAR class_on[32];
1271 
1272 
1273 
1274 
1276 static char * t_accent_template = (char *) 0,
1279  * m_accent_template = (char *) 0,
1282 
1283 
1284 
1285 
1287 static char * a_accent_template = (char *) 0,
1290 
1291 
1292 
1293 
1294 static char * i_accent_template = (char *) 0,
1297 
1298 
1299 
1300 
1303 
1304 
1305 
1306 
1309 
1310 
1311 
1312 
1314 
1315 
1316 82
1317 
1318 ],
1320 
1321 
1322 82
1323 
1324 ];
1325 
1326 
1327 
1328 
1330 
1331 
1332 
1333 
1334 static struct env_c_rec *envChoice
1335  = (struct env_c_rec*) 0;
1336 
1337 
1338 
1339 
1341 static int fontdir_count = 0;
1342 
1343 
1344 
1345 
1347 
1348 
1349 
1350 
1351 #ifndef KPATHSEA
1353 static char *tex4ht_fls_name = (char *) 0;
1354 #endif
1355 
1356 
1357 
1358 
1360 
1361 
1362 
1363 
1364 #ifndef KPATHSEA
1366 #endif
1367 
1368 
1369 
1370 
1371 
1372 #ifdef KPATHSEA
1373 static char * export_str_chars = (char *) 0;
1374 #endif
1375 
1376 
1377 
1378 
1380 
1381 
1382 
1383 
1384 static FILE* put_4ht_file = (FILE *) 0;
1385 static int put_4ht_off = 1;
1386 static char uni_code[MAX_UNI_CODE];
1387 static short uni_code_p = 0;
1388 
1389 
1390 
1391 
1392 static int charset_n = 0, max_charset_n;
1393 static struct charset_rec *charset;
1394 
1395 
1396 
1397 
1398 static BOOL u10 = FALSE;
1399 
1400 
1401 
1402 
1403 static BOOL utf8 = FALSE;
1404 
1405 
1406 
1407 
1408 static int htf_4hf_n = 0, max_htf_4hf_n;
1409 static struct htf_4hf_rec *htf_4hf;
1410 
1411 
1412 
1413 
1415 
1416 
1417 
1418 
1419 static const U_CHAR *warn_err_mssg[]={
1420 
1421 
1422 
1423 
1424 
1425 "improper command line\ntex4ht [-f<path-separator-ch>]in-file[.dvi]\n"
1426 " [-.<ext>] replacement to default file extension name .dvi\n"
1427 " [-c<tag name>] choose named segment in env file\n"
1428 " [-e<env-file>]\n"
1429 " [-f<path-separator-ch>] remove path from the file name\n"
1430 " [-F<ch-code>] replacement for missing font characters; 0--255; default 0\n"
1431 " [-g<bitmap-file-ext>]\n"
1432 " [-h[efFgsvVA]] trace: e-errors/warnings, f-htf, F-htf search\n"
1433 " g-groups, s-specials, v-env, V-env search, A-all\n"
1434 " [-i<htf-font-dir>]\n"
1435 " [-l<bookkeeping-file>]\n"
1436 " [-P(*|<filter>)] permission for system calls: *-always, filter\n"
1437 " [-S<image-script>]\n"
1438 " [-s<css-file-ext>] default: -s4cs; multiple entries allowed\n"
1439 " [-t<tfm-font-dir>]\n"
1440 " [-u10] base 10 for unicode characters\n"
1441 " [-utf8] utf-8 encoding for unicode characters\n"
1442 " [-v<idv version>] replacement for the given dvi version\n"
1443 " [-xs] ms-dos file names for automatically generated gifs\n"
1444 
1445 ,
1446 "Can't find/open file `%s'\n",
1447 "Can't open output file for `%s'\n",
1448 "Can't close file `%s' (file is not open)\n",
1449 "Insufficient memory\n",
1450 "Bad character code: %d\n",
1451 "Can't find font number %d\n",
1452 "Improper dvi file\n",
1453 "Improper op while scanning font defs in postamble\n",
1454 "Problem with command line\n",
1455 "Font definition repeated in postamble\n",
1456 "Empty entry in font environment variable\n",
1457 "Can't access directory `%s\n'",
1458 "Too many directories in font environment variable\n",
1459 "Missing fonts, can't proceed\n",
1460 "Invalid header in file `%s'\n",
1461 "Checksum inconsistent\n",
1462 "MAXFONTS too small: %d\n",
1463 "Improper signature at end of file `%s.htf'\n",
1464 "Improper signature at start of file `%s.htf'\n",
1465 "Improper file `%s.htf'\n",
1466 "Couldn't find font `%s.htf' (char codes: ",
1467 "File `%s.htf' starts/ends with character code %d (instead of %d)\n",
1468 "Implementation problem\n",
1469 "Improper groups in \\special{t4ht+}... idv[%d]\n",
1470 "Too many characters (> %d) for map line: `%c'\n",
1471 "Extra characters in \\special{t4ht%c...",
1472 "Page break within a ch map/picture\n",
1473 "Char code >255 in htf file: %d\n",
1474 "Improper char for code in htf file: %c\n",
1475 
1476 
1477 
1478 "Illegal storage address\n",
1479 "Floating-point\n",
1480 "Interrupt with Cntr-C\n",
1481 
1482 
1483 #ifdef DOS_WIN32
1484 "%c-script too long in tex4ht.env \n",
1485 #else
1486 "%c-script too long in tex4ht.env (.tex4ht)\n",
1487 #endif
1488 "Too many rows (> %d) for map: `%c'\n",
1489 "More than 256 strings in font\n",
1490 "\\special{t4ht;%c...}?\n",
1491 "\\special{t4ht;|%s}?\n",
1492 "\\special{t4ht~!%s}?\n",
1493 "\\special{t4ht\"...%s}?\n",
1494 "System error 40\n",
1495 "`%c' in \\special{t4ht@...} or \\special{t4ht@-...}?\n",
1496 "\\special{t4ht~...} without \\special{t4ht~}\n",
1497 "Ignoring \\special{t4ht.%s}\n",
1498 "PUSH for \\special{t4ht<...%s}?\n",
1499 "Bad character code (%d) in \\special{t4h~}...\n",
1500 "Page break in \\special{t4h~}...\n",
1501 "tex4ht.fls: Couldn't find file `%s'\n",
1502 "Improper entry (line %d)\n",
1503 "Improper environment variable %s: `%s'\n",
1504 "Missing %s\n",
1505 "Can't back from file `%s\n'",
1506 "\\special{t4ht%s}?\n",
1507 "Improper -v option\n",
1508 
1509  "" };
1510 
1511 
1512 
1513 
1515 
1516 
1517 
1518 
1519 static U_CHAR *err_mark = (char *) 0;
1520 
1521 
1522 
1523 
1525 
1526 
1527 
1528 
1529 
1530 #ifdef WIN32
1531 static BOOL sigint_handler(ARG_I(DWORD));
1532 #endif
1533 
1534 
1535 
1536 
1537 static void
1538 
1539 
1540 
1541 #ifdef CDECL
1542 CDECL
1543 #endif
1544 
1545 
1547 
1548 
1549 
1550 
1551 static void* malloc_chk(ARG_I(int));
1552 
1553 
1554 
1555 
1556 static void* r_alloc(ARG_II(void *, size_t));
1557 
1558 
1559 
1560 
1561 static void strct( ARG_II(char *, const U_CHAR *) );
1562 
1563 
1564 
1565 
1566 static void open_o_file( ARG_I(void) );
1567 
1568 
1569 
1570 
1571 static FILE* open_html_file( ARG_I(char*) );
1572 
1573 
1574 
1575 
1576 static void set_del( ARG_II(char **, U_CHAR **) );
1577 
1578 
1579 
1580 
1581 static void try_new_line( ARG_I(void) );
1582 
1583 
1584 
1585 
1586 static INTEGER move_x( ARG_I(register INTEGER) );
1587 
1588 
1589 
1590 
1591 static INTEGER move_y( ARG_I(register INTEGER) );
1592 
1593 
1594 
1595 
1596 static void rule_x( ARG_I(BOOL) );
1597 
1598 
1599 
1600 
1601 static BOOL tex4ht_special( ARG_II( int*, long int*) );
1602 
1603 
1604 
1605 
1606 static void init_ch_map( ARG_I(void) );
1607 
1608 
1609 
1610 
1611 static void insert_ch_map( ARG_II(char,BOOL) );
1612 
1613 
1614 
1615 
1616 static void dump_ch_map( ARG_I(void) );
1617 
1618 
1619 
1620 
1621 static void set_loc( ARG_II(int, long int) );
1622 
1623 
1624 
1625 
1626 static void idv_char( ARG_I(int) );
1627 
1628 
1629 
1630 
1631 static void cond_idv_char( ARG_I(int) );
1632 
1633 
1634 
1635 
1636 static void idv_copy( ARG_I(void) );
1637 
1638 
1639 
1640 
1641 static void cond_idv_int( ARG_II(long int, int) );
1642 
1643 
1644 
1645 
1646 static void int_to_dvi( ARG_II(long int, int) );
1647 
1648 
1649 
1650 
1651 static void cond_string( ARG_II(int, int) );
1652 
1653 
1654 
1655 
1657 
1658 
1659 
1660 
1661 static void store_mv( ARG_II( int, INTEGER) );
1662 
1663 
1664 
1665 
1666 static void push_stack( ARG_I(void) );
1667 
1668 
1669 
1670 
1671 static void pop_stack( ARG_I(void) );
1672 
1673 
1674 
1675 
1676 static struct del_stack_entry* push_del( ARG_II(char, int) );
1677 
1678 
1679 
1680 
1681 static struct del_stack_entry* pop_del( ARG_III(char,int,int) );
1682 
1683 
1684 
1685 
1686 static
1688 
1689 
1690 
1691 
1692 static struct send_back_entry *
1694 
1695 
1696 
1697 
1698 static double pos_dbl( ARG_I(long int *) );
1699 
1700 
1701 
1702 
1703 static void doGlyphArray( ARG_I(BOOL) );
1704 
1705 
1706 
1707 
1708 static int search_font_tbl( ARG_I(int) );
1709 
1710 
1711 
1712 
1713 static int get_html_ch( ARG_I(FILE*) );
1714 
1715 
1716 
1717 
1718 static FILE* f_open( ARG_II(const char*,const char*) );
1719 
1720 
1721 
1722 
1723 static void dump_htf( ARG_I(FILE*) );
1724 
1725 
1726 
1727 
1728 static void dump_env( ARG_I(void) );
1729 
1730 
1731 
1732 
1733 static void htf_to_lg( ARG_IV(struct html_font_rec*,char*,int,FILE*));
1734 
1735 
1736 
1737 
1738 static INTEGER get_html_file_id( ARG_IV(FILE*, int, int, int) );
1739 
1740 
1741 
1742 
1743 static void notify_class_info( ARG_I(int) );
1744 
1745 
1746 
1747 
1748 static void script( ARG_IV(char *, U_CHAR *, int, U_CHAR *) );
1749 
1750 
1751 
1752 
1753 
1754 static void dos_gif_file( ARG_III(char *, int, int) );
1755 
1756 
1757 
1758 
1759 
1760 static void put_alt_ch( ARG_II( int, BOOL) );
1761 
1762 
1763 
1764 
1765 static void get_open_accent(
1766  ARG_VII(char**, char**, char**, char**, char**, char**, long int*));
1767 
1768 
1769 
1770 
1771 static int scan_class( ARG_I(int) );
1772 
1773 
1774 
1775 
1776 static INTEGER set_ch_class( ARG_I(int) );
1777 
1778 
1779 
1780 
1781 static int math_class_of( ARG_II(int,int) );
1782 
1783 
1784 
1785 
1786 static char* get_script( ARG_III(char *, const U_CHAR *, int) );
1787 
1788 
1789 
1790 
1791 static BOOL search_dot_file( ARG_I( int) );
1792 
1793 
1794 
1795 
1796 static struct env_var_rec * get_env_var( ARG_I(const char *) );
1797 
1798 
1799 
1800 
1801 static void com_dir( ARG_I(char*) );
1802 
1803 
1804 
1805 
1806 #ifdef KPATHSEA
1807 static void export_htf( ARG_II(char**, char[]) );
1808 #endif
1809 
1810 
1811 
1812 
1813 static FILE* search_in_dot_file( ARG_IV( int, const U_CHAR *, const U_CHAR *,
1814  struct env_var_rec *) );
1815 
1816 
1817 
1818 
1819 static FILE* search_file_base( ARG_IV( const U_CHAR *, const U_CHAR *, const U_CHAR *,
1820  struct env_var_rec *) );
1821 
1822 
1823 
1824 
1825 static char * abs_addr( ARG_II( const U_CHAR *, const U_CHAR *) );
1826 
1827 
1828 
1829 
1830 static FILE* search_file( ARG_III(const char *, const U_CHAR *, const U_CHAR *) );
1831 
1832 
1833 
1834 
1835 static void add_to_cache( ARG_III(const char*,const char*,int) );
1836 
1837 
1838 
1839 
1840 static FILE* search_file_ext( ARG_III(const char *, const U_CHAR *, const U_CHAR *) );
1841 
1842 
1843 
1844 
1845 #if defined(__DJGPP__)
1846  static BOOL is_forward_slash( ARG_I(const char*) );
1847 #endif
1848 
1849 
1850 
1851 
1852 static FILE* f_open_pathed_filename( ARG_II(const char*,const char*) );
1853 
1854 
1855 
1856 
1857 static INTEGER put_4ht_ch( ARG_II(int,FILE *) );
1858 
1859 
1860 
1861 
1862 static void flush_uni( ARG_I(void) );
1863 
1864 
1865 
1866 
1867 static INTEGER insert_ch( ARG_I(int) );
1868 
1869 
1870 
1871 
1872 static void put_char( ARG_I(int) );
1873 
1874 
1875 
1876 
1877 static void print_f( ARG_I(const char*) );
1878 
1879 
1880 
1881 
1882 static void print_f_4ht( ARG_I(const char*) );
1883 
1884 
1885 
1886 
1887 static int get_char( ARG_I(void) );
1888 
1889 
1890 
1891 
1892 static int get_noop( ARG_I(void) );
1893 
1894 
1895 
1896 
1897 static char* get_str( ARG_I(int) );
1898 
1899 
1900 
1901 
1902 static long fget_unt( ARG_II(FILE*, int) );
1903 
1904 
1905 
1906 
1907 static long fget_int( ARG_II(FILE *, int) );
1908 
1909 
1910 
1911 
1912 static long cond_int( ARG_I(register INTEGER) );
1913 
1914 
1915 
1916 
1917 static void warn_i( ARG_I(int) );
1918 
1919 
1920 
1921 
1922 static void warn_i_int( ARG_II(int,int) );
1923 
1924 
1925 
1926 
1927 static void warn_i_int_2( ARG_III(int,int,int) );
1928 
1929 
1930 
1931 
1932 static void warn_i_str( ARG_II(int,const char *) );
1933 
1934 
1935 
1936 
1937 static void warn_i_str2( ARG_III(int,const char *,const char *) );
1938 
1939 
1940 
1941 
1942 static void err_i( ARG_I(int) );
1943 
1944 
1945 
1946 
1947 static void err_i_int( ARG_II(int,int) );
1948 
1949 
1950 
1951 
1952 static void err_i_str( ARG_II(int,char *) );
1953 
1954 
1955 
1956 
1957 static void show_err_context( ARG_I(void) );
1958 
1959 
1960 
1961 
1962 
1963 #ifdef WIN32
1964 
1965 
1966 
1967 static BOOL sigint_handler
1968 #ifdef ANSI
1969 #define SEP ,
1970 ( DWORD dwCtrlType
1971 )
1972 #undef SEP
1973 #else
1974 #define SEP ;
1975 (dwCtrlType) DWORD dwCtrlType
1976 ;
1977 #undef SEP
1978 #endif
1979 {
1980 
1981 
1982 
1983 if( dwCtrlType ){ (IGNORED) printf(" "); }
1984 
1985 
1986  err_i(32);
1987  return FALSE;
1988 }
1989 #endif
1990 
1991 
1992 
1993 
1994 
1995 static void
1996 
1997 
1998 
1999 #ifdef CDECL
2000 CDECL
2001 #endif
2002 
2003 
2004 sig_err
2005 #ifdef ANSI
2006 #define SEP ,
2007 ( int s
2008 )
2009 #undef SEP
2010 #else
2011 #define SEP ;
2012 (s) int s
2013 ;
2014 #undef SEP
2015 #endif
2016 {
2017  (void) signal(s,SIG_IGN);
2018  switch( s ){
2019 #ifdef SIGSEGV
2020  case SIGSEGV: err_i(30);
2021 #endif
2022  case SIGFPE : err_i(31);
2023 #if defined(SIGINT) && !defined(WIN32)
2024  case SIGINT : err_i(32);
2025 #endif
2026  }
2027 
2028 
2029 
2030 #ifdef __DJGPP__
2031  if (s != SIGINT && s != SIGQUIT)
2032  exit(EXIT_FAILURE);
2033 #endif
2034 
2035 
2036 }
2037 
2038 
2039 
2040 
2041 
2042 static void* malloc_chk
2043 #ifdef ANSI
2044 #define SEP ,
2045 ( int n
2046 )
2047 #undef SEP
2048 #else
2049 #define SEP ;
2050 ( n ) int n
2051 ;
2052 #undef SEP
2053 #endif
2054 { void* p;
2055  if((p = (void *) malloc( (size_t) n)) == NULL ) bad_mem;
2056  return p;
2057 }
2058 
2059 
2060 
2061 
2062 
2063 static void* r_alloc
2064 #ifdef ANSI
2065 #define SEP ,
2066 (
2067  void *q SEP
2068  size_t n
2069 )
2070 #undef SEP
2071 #else
2072 #define SEP ;
2073 ( q, n )
2074  void *q SEP
2075  size_t n
2076 ;
2077 #undef SEP
2078 #endif
2079 { void* p;
2080  if((p = (void *) realloc( q, (size_t) n)) == NULL) bad_mem;
2081  return p;
2082 }
2083 
2084 
2085 
2086 
2087 
2088 static void strct
2089 #ifdef ANSI
2090 #define SEP ,
2091 (
2092  U_CHAR * str1 SEP
2093  const U_CHAR * str2
2094 
2095 )
2096 #undef SEP
2097 #else
2098 #define SEP ;
2100  U_CHAR * str1 SEP
2101  const U_CHAR * str2
2102 
2103 ;
2104 #undef SEP
2105 #endif
2106 { U_CHAR * ch;
2107  ch = str1 + (int) strlen((char *) str1);
2108  (IGNORED) strcpy((char *) ch, str2 );
2109 }
2110 
2111 
2112 
2113 
2114 static void open_o_file(MYVOID)
2115 {
2116 
2117 
2118 
2119  struct files_rec* p;
2120 p = m_alloc(struct files_rec, 1);
2121 if( opened_files != (struct files_rec*) 0 ) opened_files->prev = p;
2122 p->prev = (struct files_rec *) 0;
2124 p->name = no_root_file;
2125 p->file =
2126 
2127 
2129  no_root_file = (char *) 0;
2130 }
2131 
2132 
2133 
2134 
2135 
2136 static FILE* open_html_file
2137 #ifdef ANSI
2138 #define SEP ,
2139 (
2140  char* name
2141 )
2142 #undef SEP
2143 #else
2144 #define SEP ;
2145 (name)
2146  char* name
2147 ;
2148 #undef SEP
2149 #endif
2150 { FILE* file;
2151  char* str;
2152  str = m_alloc(char, (int) strlen((char *) name) + 1);
2153  (IGNORED) strcpy((char *) str, (char *) name);
2154  (IGNORED) printf(" file %s\n", str);
2155  (IGNORED) fprintf(log_file, "File: %s\n", str);
2157  free((void *) str);
2158  return file;
2159 }
2160 
2161 
2162 
2163 
2164 
2165 static void set_del
2166 #ifdef ANSI
2167 #define SEP ,
2168 (
2169  U_CHAR ** del SEP
2170  U_CHAR ** end_del
2171 )
2172 #undef SEP
2173 #else
2174 #define SEP ;
2175 ( del, end_del )
2176  U_CHAR ** del SEP
2177  U_CHAR ** end_del
2178 ;
2179 #undef SEP
2180 #endif
2181 {
2182  *del = m_alloc(char, 1); **del = '\0';
2183  *end_del = m_alloc(char, 1); **end_del = '\0';
2184 }
2185 
2186 
2187 
2188 
2189 static void try_new_line(MYVOID)
2190 { long int v;
2191  double dy;
2192  dy = (cur_fnt == -1)? 0.0 : (
2193 
2194 
2195 (
2196 
2197 
2198 design_size_to_pt( 1.7 * (double) font_tbl[cur_fnt].ex )
2199 * (double) font_tbl[cur_fnt].scale
2200 
2201  < 0? -1 : 1)
2202 
2203  *
2204 
2205 
2206 design_size_to_pt( 1.7 * (double) font_tbl[cur_fnt].ex )
2207 * (double) font_tbl[cur_fnt].scale
2208 
2209 ) ;
2210  v = y_val - prev_y_val;
2211  if( !text_on && (y_val > max_y_val) ){
2212  if( v > dy/2.5 ){
2213 
2214 
2215 
2216 if( !no_root_file ){
2217 
2218 
2219 
2221 
2222 
2223 
2224 if( span_on && in_span_ch ){
2225  if( *end_span[0] ){
2226  in_span_ch = FALSE;
2227 
2228 
2229 
2230 if( no_root_file ){ open_o_file(); }
2231 
2232 
2233  (IGNORED) fprintf(cur_o_file, "%s", end_span[0]);
2234 } }
2235 
2236 
2239 
2240 
2242 
2243 
2244 }
2245 
2246 
2247  if( !
2248 
2249 
2251 
2252  ){ put_char('\n'); }
2253 }
2254 
2255  max_x_val = -10000;
2256  prev_y_val = max_y_val = stack_n? y_val : 0;
2257  }
2258  }else{
2259  if( v > dy ){
2260 
2261 
2262 if( !no_root_file ){
2263 
2264 
2265 
2267 
2268 
2269 
2270 if( span_on && in_span_ch ){
2271  if( *end_span[0] ){
2272  in_span_ch = FALSE;
2273 
2274 
2275 
2276 if( no_root_file ){ open_o_file(); }
2277 
2278 
2279  (IGNORED) fprintf(cur_o_file, "%s", end_span[0]);
2280 } }
2281 
2282 
2285 
2286 
2288 
2289 
2290 }
2291 
2292 
2293  if( !
2294 
2295 
2297 
2298  ){ put_char('\n'); }
2299 }
2300 
2301  max_x_val = x_val;
2302  prev_y_val = stack_n? y_val : 0;
2303  }else if( v < -(dy / 1.4) ) prev_y_val = stack_n? y_val : 0;
2304 } }
2305 
2306 
2307 
2308 
2309 
2310 static INTEGER move_x
2311 #ifdef ANSI
2312 #define SEP ,
2313 (
2314  register INTEGER d
2315 )
2316 #undef SEP
2317 #else
2318 #define SEP ;
2319 ( d )
2320  register INTEGER d
2321 ;
2322 #undef SEP
2323 #endif
2324 { register long i, dx;
2325  x_val += d;
2326  if( (x_val > max_x_val) && x_val ){
2327  if( max_x_val == -10000) max_x_val = x_val - d;
2328 
2329 
2330 
2331 i = (INTEGER) ( (double) (dx = x_val - max_x_val)
2332  / (text_on? word_sp : margin_sp)
2333  + 0.5 );
2334 
2335 
2336 
2337 if( i==0 ){
2338  i = (INTEGER) ( (double) dx
2339  / word_sp
2340  + 0.5 );
2341 }
2342 
2343 
2344 if( i<0 ) i=0;
2345 if( i==0 ){
2346 
2347 
2348  long curr_pos;
2349  BOOL done;
2350  int ch, cr_fnt;
2352 done = FALSE;
2353 while( !done ){
2354  ch = get_char();
2355  switch( ch ){
2356 
2357 
2358 
2359 
2360 
2361 case
2362 
2363 
2364 246
2365 : (void) get_char();
2366 case
2367 
2368 
2369 245
2370 : (void) get_char();
2371 case
2372 
2373 
2374 244
2375 : (void) get_char();
2376 case
2377 
2378 
2379 243
2380 : {
2381  for( i=0; i<14; i++ ){ ch = get_char(); }
2382  for( i=ch + get_char(); i>0; i--) (void) get_char();
2383  break;
2384 }
2385 
2386 
2387  case
2388 
2389 
2390 141
2391 :
2392  case
2393 
2394 
2395 142
2396 : { break; }
2397  default: {
2398  if( (ch <
2399 
2400 
2401 171
2402 ) || (ch >
2403 
2404 
2405 234
2406 ) ){
2407  done = TRUE;
2408  } else {
2409 
2410 
2411 
2412  double word_sp;
2413 cr_fnt = ch -
2414 
2415 
2416 171
2417 ;
2420  * (double) font_tbl[cr_fnt].scale;
2421 i = (INTEGER) ( (double) dx
2422  / (text_on? word_sp : margin_sp)
2423  + 0.5 );
2424 
2425 
2426 
2427 if( i==0 ){
2428  i = (INTEGER) ( (double) dx
2429  / word_sp
2430  + 0.5 );
2431 }
2432 
2433 
2434 if( i>0 ){ i =1; }
2435 
2436 
2437 } } } }
2439 
2440 
2441 0
2442 );
2443 
2444  }
2445 if( i ){
2446 
2447 
2448 if( trace_dvi_H && !ch_map_flag ){
2449  if( *trace_dvi_del_H != '\0' ){
2450  (IGNORED) fprintf(cur_o_file, "%s%d", trace_dvi_del_H, (int) dx);
2451  }
2453 }
2454 
2455  }
2456 if( !ignore_spaces ){
2457 
2458 
2459 
2461 
2462 
2463 
2464 if( span_on && in_span_ch ){
2465  if( *end_span[0] ){
2466  in_span_ch = FALSE;
2467 
2468 
2469 
2470 if( no_root_file ){ open_o_file(); }
2471 
2472 
2473  (IGNORED) fprintf(cur_o_file, "%s", end_span[0]);
2474 } }
2475 
2476 
2479 
2480 
2482 
2483 
2484 }
2485 
2486 
2487  while( i-- ) { text_on=TRUE; put_char(' '); }
2488 } else { recover_spaces = (int) i; }
2489 max_x_val = x_val;
2490 
2491 
2492  } else if( d && text_on && (x_val != max_x_val) ){
2493 
2494 
2495 
2496 if( !ignore_spaces ){
2497  i = (INTEGER) ( (double) (dx = d) / word_sp + 0.5 );
2498  if( i<0 ) i=0;
2499  if( !i ) i = dx>99999L;
2500  if( i ){ put_char(' '); }
2501 }
2502 
2503 
2504  }
2505  return d;
2506 }
2507 
2508 
2509 
2510 
2511 
2512 static INTEGER move_y
2513 #ifdef ANSI
2514 #define SEP ,
2515 ( register INTEGER d
2516 )
2517 #undef SEP
2518 #else
2519 #define SEP ;
2520 ( d ) register INTEGER d
2521 ;
2522 #undef SEP
2523 #endif
2524 { y_val += d;
2525 
2526 
2527 
2529  if( *trace_dvi_del_V != '\0' ){
2531  }
2533 }
2534 
2535 
2536  return d;
2537 }
2538 
2539 
2540 
2541 
2542 
2543 static void rule_x
2544 #ifdef ANSI
2545 #define SEP ,
2546 (
2547  BOOL tag
2548 )
2549 #undef SEP
2550 #else
2551 #define SEP ;
2552 ( tag )
2554 ;
2555 #undef SEP
2556 #endif
2557 { long i, right, up;
2560  if( ch_map_flag ){
2561 
2562 
2563  long int sv_x_val, sv_y_val, sv_right, sv;
2564  int ch;
2565 sv_x_val = x_val;
2566 sv_y_val = y_val;
2567 sv_right = right;
2568 y_val-=up;
2569 if( right < 0 ){ x_val += right; right = -right; }
2570 if( up < 0 ){ y_val += up; up = -up; }
2571 ch = ( (right > xresolution) && (up > yresolution) ) ?
2572 
2573 
2574 
2575 3
2576  : ( ( right > up )?
2577 
2578 
2579 1
2580  :
2581 
2582 
2583 2
2584  );
2585 right += x_val;
2586 up += sv = y_val;
2587 for( ; x_val < right; x_val += xresolution )
2588  for( y_val = sv ; y_val < up; y_val += yresolution )
2589  insert_ch_map((char) ch, FALSE);
2590 x_val = sv_x_val;
2591 y_val = sv_y_val;
2592 if( sv_x_val + sv_right > max_x_val ) max_x_val = sv_x_val + sv_right;
2593 if(
2594 
2595 
2596 tag
2597  ) x_val += sv_right;
2598 
2599  }
2600  else if( pos_dvi ){
2601 
2602 
2603 
2604  long int d;
2605 if( (up > 0) && (right > 0) ){
2606  if( *pos_line ){
2607  double from_x, from_y;
2608 
2609 
2610 
2611 if( no_root_file ){ open_o_file(); }
2612 
2613 
2614  from_x = pos_x_A * (x_val - base_pos_x) + pos_x_B;
2615  from_y = pos_y_C * (y_val - pos_y_E * up - base_pos_y) + pos_y_D;
2616  switch (rect_pos){
2617  case 1: {
2619  from_x, from_y,
2620  pos_x_A * right + pos_x_B + from_x,
2621  pos_y_C * up + pos_y_D + from_y );
2622  break; }
2623  case 2: {
2625  from_x, from_y,
2626  pos_x_A * right + pos_x_B + from_x,
2627  from_y,
2628  pos_y_C * up + pos_y_D );
2629  break; }
2630  default: {
2632  from_x, from_y,
2633  pos_x_A * right,
2634  pos_y_C * up);
2635  }
2636  }
2637  }
2638  if( x_val < min_pos_x ) min_pos_x = x_val;
2639  if( (d = x_val + right) > max_pos_x ) max_pos_x = d;
2640  if( (d = y_val - up) < min_pos_y ) min_pos_y = d;
2641  if( y_val > max_pos_y ) max_pos_y = y_val;
2642 }
2643 
2644 
2645  if( tag ) x_val += right;
2646  } else if( (up>0) && (right>0) ) {
2647 
2648 
2649 
2650 if( (x_val + right) &&
2651  ( ((x_val + right) > max_x_val)
2652  || ( !text_on && !ignore_chs )
2653  )
2654 ){
2655  if( (max_x_val == -10000) || ((x_val + right) <= max_x_val) )
2656  { max_x_val = x_val; }
2657  i = (INTEGER) ( (double) (x_val + right - max_x_val)
2658  / (text_on? word_sp : margin_sp)
2659  + 0.5 );
2660 
2661 
2662 
2663 if( i==0 ){
2664  i = (INTEGER) ( (double) (x_val + right - max_x_val)
2665  / word_sp
2666  + 0.5 );
2667 }
2668 
2669 
2670  if( i && !text_on ) try_new_line();
2671 
2672 
2673 
2674 if( trace_dvi_R && !ch_map_flag ){
2675  if( *trace_dvi_del_R != '\0' ){
2676  (IGNORED) fprintf(cur_o_file, "%s%d %d",
2677  trace_dvi_del_R, (int) x_val, (int) y_val);
2678  }
2680 }
2681 
2682 
2683  while( i-- ) { text_on=TRUE;
2684  if( rule_ch && !
2685 
2686 
2688 
2689  ){ put_char(rule_ch); }
2690  }
2691 
2692 
2693 
2694 if( trace_dvi_R && !ch_map_flag ){
2695  if( *trace_dvi_del_r != '\0' ){
2696  (IGNORED) fprintf(cur_o_file, "%s%d %d",
2697  trace_dvi_del_R, (int) right, (int) up);
2698  }
2700 }
2701 
2702 
2703  max_x_val = x_val + right;
2704 }
2705 
2706 
2707  if( tag ) x_val += right;
2708  } else {
2709 
2710 
2711 
2712 
2713 
2714 
2715 if( trace_dvi_R && !ch_map_flag ){
2716  if( *trace_dvi_del_R != '\0' ){
2717  (IGNORED) fprintf(cur_o_file, "%s%d %d",
2718  trace_dvi_del_R, (int) x_val, (int) y_val);
2719  }
2721 }
2722 
2723 
2724 
2725 
2726 
2727 if( trace_dvi_R && !ch_map_flag ){
2728  if( *trace_dvi_del_r != '\0' ){
2729  (IGNORED) fprintf(cur_o_file, "%s%d %d",
2730  trace_dvi_del_R, (int) right, (int) up);
2731  }
2733 }
2734 
2735 
2736 
2737 
2738  if( tag ) x_val += right;
2739 } }
2740 
2741 
2742 
2743 
2744 
2745 static BOOL tex4ht_special
2746 #ifdef ANSI
2747 #define SEP ,
2748 (
2749  int *chr SEP
2750  long int *special_n
2751 
2752 )
2753 #undef SEP
2754 #else
2755 #define SEP ;
2757  int *chr SEP
2758  long int *special_n
2759 
2760 ;
2761 #undef SEP
2762 #endif
2763 { BOOL tex4ht;
2764  int i;
2765  long unsigned N;
2767 
2768 
2769 
2770 *special_n = (long int) (N = get_unt(*chr -
2771 
2772 
2773 239
2774  + 1));
2775 for(i=4; i--; ){
2776  special_hd[i] = (unsigned char) (N & 0xFF);
2777  N = N >> 8; }
2778 
2779 
2780  if( *special_n > (long int) 4 ){
2781  for(i=4; i<9; i++) special_hd[i]=get_char();
2782  special_hd[9]='\0';
2783 
2784 
2785 
2786 tex4ht = (special_hd[4] == 't') || (special_hd[4] == 'T');
2787 tex4ht = tex4ht && special_hd[5] == '4';
2788 tex4ht = tex4ht && ((special_hd[6] == 'h') || (special_hd[6] == 'H'));
2789 tex4ht = tex4ht && ((special_hd[7] == 't') || (special_hd[7] == 'T'));
2790 if( tex4ht && trace_special ){
2791 
2792 
2793 
2794 { long curr_pos;
2795  int n, i;
2796  U_CHAR ch;
2797 
2798  curr_pos = ftell(dvi_file);
2799  print_f("\nSPECIAL: "); ch = special_hd[8]; i=60;
2800  for( n=*special_n - 3; n--;){
2801  if( !i ){ (IGNORED) putc( '\n', cur_o_file ); i=70; }
2802  else i--;
2803  (IGNORED) putc(( (ch>31) && (ch<127))? ch : ' ', cur_o_file);
2804  ch = get_char();
2805  }
2806  (IGNORED) putc( '\n', cur_o_file );
2808 
2809 
2810 0
2811 );
2812 }
2813 
2814 
2815 }
2816 
2817 
2818  *chr = special_hd[8];
2819  tex4ht = tex4ht && ( (*chr == '=') || (*chr == '<') ||
2820  (*chr == '>') || (*chr == '*') || (*chr == '@') ||
2821  (*chr == ':') || (*chr == '"') || (*chr == '~') ||
2822  (*chr == ';') || (*chr == '.') || (*chr == '^') ||
2823  (*chr == '|') || (*chr == '+') || (*chr == '!') );
2824  *special_n -= 5; }
2825  else{ special_hd[4]='\0'; }
2826  return tex4ht;
2827 }
2828 
2829 
2830 
2831 
2832 static void init_ch_map(MYVOID)
2833 { int i;
2834  for( i=0; i<HEIGHT; i++ ){
2835  ch_map[i].max = 0; ch_map[i].chars = 0; ch_map[i].line = NULL; }
2836  max_map_line = -1;
2837  min_map_line = HEIGHT;
2838 }
2839 
2840 
2841 
2842 
2843 
2844 static void insert_ch_map
2845 #ifdef ANSI
2846 #define SEP ,
2847 (
2848  U_CHAR ch SEP
2849  BOOL
2850 
2851 
2852 tag
2853 
2854 
2855 )
2856 #undef SEP
2857 #else
2858 #define SEP ;
2859 ( ch,
2860 
2861 
2862 tag
2863  )
2864  U_CHAR ch SEP
2865  BOOL
2866 
2867 
2868 tag
2869 
2870 
2871 ;
2872 #undef SEP
2873 #endif
2874 { int row, col;
2875 
2876 
2877 
2878 { double x;
2879  row = (int) ( (y_val>0? y_val : 0.0) / (double) yresolution + 0.5);
2880  if( row >= HEIGHT ){
2881  if( ok_map ){ warn_i_int_2( 34, row, ch); ok_map = FALSE; }
2882  return; }
2883  x = (x_val>0? x_val : 0.0 ) / (double) xresolution + 0.75;
2884  col = (int) x;
2885  if( (ch > ' ') && (ch != '-') && (ch != '|') ){
2886  if( row == prevrow ){
2887  if( (col == prevcol + 1) && (x > prev_x + 0.5) )
2888  insert_ch_map(' ', TRUE);
2889  else if( (col > prevcol + 1) && (x < prev_x+0.2)
2890  && ( ch != '&' ))
2891  col = prevcol + 1;
2892  }else prevrow = -1;
2893  prev_x = x
2894  + (
2895 
2896 
2898  + (int) (
2899 
2900 
2901 *(font_tbl[cur_fnt].char_wi + (int)
2902  ( (design_ch? design_ch : ch) - font_tbl[cur_fnt].char_f)% 256)
2903 
2904 )) )
2905  * (double) font_tbl[cur_fnt].scale
2906 
2907 )
2908  / (double) xresolution;
2909  prevcol = col;
2910  }else prevrow = -1;
2911  prevrow = row;
2912 }
2913 
2914 
2915  if(ch != 10){
2916  if( (ch_map[row].max > MAX_MAP_LINE) || (col > MAX_MAP_LINE) ){
2917  if( ok_map ){ warn_i_int_2( 25, MAX_MAP_LINE, ch);
2918  ok_map = FALSE; }
2919  }else{
2920  if( row < min_map_line ) min_map_line = row;
2921  if( row > max_map_line ) max_map_line = row;
2922  if( ch_map[row].max ){
2923 
2924 
2925  int n;
2926  char* p;
2927 if( ch_map[row].chars > col ){
2928 
2929 
2930 
2931 if(
2932 
2933 
2934 tag
2935  ){
2936  if( *(ch_map[row].line + ch_map[row].max - 1)
2937  || (ch_map[row].chars - col == 1) ){
2938 
2939 
2940 ch_map[row].max += 5;
2941 ch_map[row].line = (char *)
2942  r_alloc((void *) ch_map[row].line,
2943  (size_t) ch_map[row].max + 1 );
2944 for( n = 0; n<5; n++ )
2945  *(ch_map[row].line + ch_map[row].max - n) = 0;
2946 ch_map[row].chars += 5;
2947 
2948  }
2949  col = (ch_map[row].chars--) - col;
2950  p = ch_map[row].line + ch_map[row].max;
2951  while( col ){ unsigned char temp_ch;
2952  if( ((unsigned char) (*p)) <
2953 
2954 
2955 4
2956  ) col--;
2957  temp_ch = *(--p); *(p+1) = temp_ch; }
2958 } else {
2959  col = ch_map[row].chars - col;
2960  p = ch_map[row].line + ch_map[row].max;
2961  while( col ){
2962  if( ((unsigned char) (*p)) <
2963 
2964 
2965 4
2966  ) col--; p--; }
2967 }
2968 *(++p) = ch;
2969 
2970  }
2971 else{
2972 
2973 
2974 n = (col - ch_map[row].chars + 8) / 5 * 5;
2975 ch_map[row].chars += n -
2976 
2977 
2978 tag
2979 ;
2980 ch_map[row].max += n;
2981 ch_map[row].line = (char *)
2982  r_alloc((void *) ch_map[row].line,
2983  (size_t) ch_map[row].max + 1);
2984 while( n-- ) *(ch_map[row].line + ch_map[row].max - n) = 0;
2985 *(ch_map[row].line + ch_map[row].max
2986  - (ch_map[row].chars - col) + !
2987 
2988 
2989 tag
2990  ) = ch;
2991 
2992  }
2993 
2994  }
2995  else {
2996 
2997 
2998  int n;
2999  char* p;
3000 ch_map[row].chars = (n = (col + 2 + 5) / 5 * 5) -
3001 
3002 
3003 tag
3004 ;
3005 ch_map[row].max = n - 1;
3006 ch_map[row].line = p = m_alloc(char, n);
3007 while( n-- ){ *(p++) = 0; }
3008 *(ch_map[row].line + col) = ch;
3009 
3010  }
3011 } } }
3012 
3013 
3014 
3015 
3016 static void dump_ch_map(MYVOID)
3017 { int n, i, min, k, extra_sp;
3018  U_CHAR *p;
3019 
3020 
3021 
3022 
3023 { int max;
3024  min = 100; max = 0;
3025  for( i=min_map_line; i<=max_map_line; i++ ){
3026  p = ch_map[i].line;
3027  n = ch_map[i].max; if( max < n ) max = n;
3028  k = 0; while( n-- ){ if(*(p++)) break; k++; }
3029  if( ch_map[i].max && (k < min) ) min = k; }
3030  if( (max < 78) && !nomargin ) min = 0;
3031 }
3032 
3033 
3034  for( i=min_map_line; i<=max_map_line; i++ ){
3035  if( ( n = ch_map[i].max) > 0 ){
3036  p = ch_map[i].line; k = min; extra_sp = 0;
3037 
3038 
3039 
3040 { U_CHAR *s;
3041  s = p + n;
3042  while( n && !(*s) && !(*(s-1)) ){ n--; s--; }
3043  if( n && !(*s) && (((unsigned char) *(s-1)) <
3044 
3045 
3046 4
3047 ) ) n--;
3048 }
3049 
3050 
3051  while( 1 + n-- ){
3052  if( --k < 0 ){
3053  if( extra_sp && (((unsigned char) *p) <
3054 
3055 
3056 4
3057 )
3058  && (((unsigned char) *(p+1)) <
3059 
3060 
3061 4
3062 ) )
3063  { extra_sp--;
3064  } else { switch( *p ){
3065 
3066 
3067  case 0: { put_char(' '); break; }
3068  case
3069 
3070 
3071 1
3072 : { put_char('-'); break; }
3073  case
3074 
3075 
3076 2
3077 : { put_char('|'); break; }
3078 case
3079 
3080 
3081 3
3082 : { put_char('#'); break; }
3083  case ' ': { extra_sp++; }
3084  default: {
3085 
3086 
3087  BOOL tag;
3088  INTEGER count;
3089 tag = TRUE; count = 0;
3090 do{ if( *p == '<' ) tag = FALSE;
3091  else if( *p == '>' ) tag = TRUE;
3092  else count += tag;
3093  put_char( *p ); n--;
3094 }while( ((unsigned char) *(++p)) >=
3095 
3096 
3097 4
3098  );
3099 if( !count ){ n++; p--; }
3100 
3101  break; }
3102 
3103  } }
3104  }
3105  p++;
3106  }
3107  free((void *) ch_map[i].line );
3108  }
3109  if( i<max_map_line ) put_char('\n');
3110  }
3111  nomargin = FALSE;
3112 }
3113 
3114 
3115 
3116 
3117 
3118 static void set_loc
3119 #ifdef ANSI
3120 #define SEP ,
3121 (
3122  int op SEP
3123  long int d
3124 
3125 )
3126 #undef SEP
3127 #else
3128 #define SEP ;
3129 ( op, d )
3130  int op SEP
3131  long int d
3132 
3133 ;
3134 #undef SEP
3135 #endif
3136 {
3137  idv_char( op + 3 ); int_to_dvi( d, 4 ); file_n += 5;
3138 }
3139 
3140 
3141 
3142 
3143 
3144 static void idv_char
3145 #ifdef ANSI
3146 #define SEP ,
3147 ( int n
3148 )
3149 #undef SEP
3150 #else
3151 #define SEP ;
3152 ( n ) int n
3153 ;
3154 #undef SEP
3155 #endif
3156 { (IGNORED) putc( n, idv_file ); }
3157 
3158 
3159 
3160 
3161 
3162 static void cond_idv_char
3163 #ifdef ANSI
3164 #define SEP ,
3165 ( int n
3166 )
3167 #undef SEP
3168 #else
3169 #define SEP ;
3170 ( n ) int n
3171 ;
3172 #undef SEP
3173 #endif
3174 {
3175  if( dvi_flag ){ (IGNORED) putc( n, idv_file ); file_n++; }
3176 }
3177 
3178 
3179 
3180 
3181 static void idv_copy( MYVOID )
3182 { idv_char( get_char() ); file_n++; }
3183 
3184 
3185 
3186 
3187 
3188 static void cond_idv_int
3189 #ifdef ANSI
3190 #define SEP ,
3191 ( long int val SEP
3192  int n
3193 )
3194 #undef SEP
3195 #else
3196 #define SEP ;
3197 ( val, n ) long int val SEP
3198  int n
3199 ;
3200 #undef SEP
3201 #endif
3202 {
3203  if( dvi_flag ){ int_to_dvi((long int) val, n ); file_n += n; }
3204 }
3205 
3206 
3207 
3208 
3209 
3210 static void int_to_dvi
3211 #ifdef ANSI
3212 #define SEP ,
3213 ( long int val SEP
3214  int n
3215 
3216 )
3217 #undef SEP
3218 #else
3219 #define SEP ;
3220 ( val, n ) long int val SEP
3221  int n
3222 
3223 ;
3224 #undef SEP
3225 #endif
3226 { unsigned U_CHAR ch2, ch3, ch4;
3227  ch4 = (unsigned char) (val & 0xFF); val = val >> 8;
3228  ch3 = (unsigned char) (val & 0xFF); val = val >> 8;
3229  ch2 = (unsigned char) (val & 0xFF); val = val >> 8;
3230  switch( n ){
3231  case 4: idv_char( (int) val );
3232  case 3: idv_char( ch2 );
3233  case 2: idv_char( ch3 );
3234  case 1: idv_char( ch4 ); }
3235 
3236 }
3237 
3238 
3239 
3240 
3241 
3242 static void cond_string
3243 #ifdef ANSI
3244 #define SEP ,
3245 ( int ch SEP int n
3246 
3247 )
3248 #undef SEP
3249 #else
3250 #define SEP ;
3251 (ch, n) int ch SEP int n
3252 
3253 ;
3254 #undef SEP
3255 #endif
3256 { cond_idv_char( ch );
3257  while( n-- ) cond_idv_char( get_char() );
3258 }
3259 
3260 
3261 
3262 
3263 
3265 #ifdef ANSI
3266 #define SEP ,
3267 (
3268  INTEGER bop_addr SEP
3269  char* cur_font
3270 
3271 )
3272 #undef SEP
3273 #else
3274 #define SEP ;
3275 ( bop_addr, cur_font )
3276  INTEGER bop_addr SEP
3277  char* cur_font
3278 
3279 ;
3280 #undef SEP
3281 #endif
3282 { int i;
3283  if( page_n++ ){
3284  idv_char(
3285 
3286 
3287 142
3288 ); file_n++;
3289  idv_char(
3290 
3291 
3292 140
3293 ); file_n++;
3294  idv_char(
3295 
3296 
3297 139
3298  );
3299  idv_int( page_n ); for( i=36; i--; ) idv_char( 0);
3300  idv_int( bop_addr ); bop_addr = file_n; file_n += 45;
3301  idv_char(
3302 
3303 
3304 141
3305 ); file_n++;
3306  for( i=1; i<=cur_font[0]; i++ ){
3307  idv_char( cur_font[i] ); file_n++;
3308  } }
3309 
3310 
3311 
3312 store_mv(
3313 
3314 
3315 151
3316 , dx_1);
3317 store_mv(
3318 
3319 
3320 156
3321 , dx_2);
3322 store_mv(
3323 
3324 
3325 165
3326 , dy_1);
3327 store_mv(
3328 
3329 
3330 170
3331 , dy_2);
3332 
3333 
3334  return bop_addr;
3335 }
3336 
3337 
3338 
3339 
3340 
3341 static void store_mv
3342 #ifdef ANSI
3343 #define SEP ,
3344 ( int op SEP INTEGER d
3345 
3346 )
3347 #undef SEP
3348 #else
3349 #define SEP ;
3350 (op, d) int op SEP INTEGER d
3351 
3352 ;
3353 #undef SEP
3354 #endif
3355 {
3356  if( dvi_flag ){
3357  cond_idv_char(op); idv_int( (INTEGER) -d);
3358  cond_idv_char(op); idv_int( (INTEGER) d); file_n += 8; }
3359 }
3360 
3361 
3362 
3363 
3364 static void push_stack(MYVOID)
3365 {
3366  stack[stack_n].x_val = x_val;
3367  stack[stack_n].dx_1 = dx_1;
3368  stack[stack_n].dx_2 = dx_2;
3369  stack[stack_n].y_val = y_val;
3370  stack[stack_n].dy_1 = dy_1;
3371  stack[stack_n].dy_2 = dy_2;
3372 
3373 
3374 
3375 stack[stack_n+1].sv_no_left_del = stack[stack_n+1].no_left_del;
3376 stack[stack_n+1].no_left_del = stack[stack_n].no_left_del;
3377 
3378 
3379  stack_n++;
3380 if( stack_n >
3381 
3382 
3383 ((int) stack_len + 2)
3384 
3385  ){
3386  warn_i(40);
3387 }
3388 
3389 
3390 
3391 stack[stack_n].accented = FALSE;
3392 
3393 
3394 }
3395 
3396 
3397 
3398 
3399 static void pop_stack(MYVOID)
3400 {
3401 
3402 
3403 
3404 if( stack[stack_n].accented ){
3405 
3406 
3407 
3409 
3410 
3411  stack[stack_n].accented=FALSE;
3412 }
3413 
3414 
3415 
3416 
3417 
3418 stack[stack_n].no_left_del = stack[stack_n].sv_no_left_del;
3419 
3420 
3421  --stack_n;
3422  x_val = stack[stack_n].x_val;
3423  dx_1 = stack[stack_n].dx_1;
3424  dx_2 = stack[stack_n].dx_2;
3425  y_val = stack[stack_n].y_val;
3426  dy_1 = stack[stack_n].dy_1;
3427  dy_2 = stack[stack_n].dy_2;
3428 }
3429 
3430 
3431 
3432 
3433 
3434 static struct del_stack_entry* push_del
3435 #ifdef ANSI
3436 #define SEP ,
3437 ( U_CHAR ch SEP
3438  int cr_fnt
3439 )
3440 #undef SEP
3441 #else
3442 #define SEP ;
3443 (ch, cr_fnt) U_CHAR ch SEP
3445 ;
3446 #undef SEP
3447 #endif
3448 { struct del_stack_entry *p;
3449  p = m_alloc(struct del_stack_entry,1);
3451  p->ch = ch;
3452  p->fnt = cr_fnt;
3453  p->id = ch_id;
3454  return p;
3455 }
3456 
3457 
3458 
3459 
3460 
3461 static struct del_stack_entry* pop_del
3462 #ifdef ANSI
3463 #define SEP ,
3464 (
3465  U_CHAR ch SEP
3466  int id_hide SEP
3467  int cr_fnt
3468 )
3469 #undef SEP
3470 #else
3471 #define SEP ;
3473  U_CHAR ch SEP
3474  int id_hide SEP
3475  int cr_fnt
3476 ;
3477 #undef SEP
3478 #endif
3479 {
3480  if( del_stack != (struct del_stack_entry*) 0 ){
3481  if( (cr_fnt == del_stack->fnt) &&
3482  ( *(font_tbl[cr_fnt].math + (ch - font_tbl[cr_fnt].char_f))
3483  == del_stack->ch) ){
3484  struct del_stack_entry * p;
3485  if( !id_hide && !id_latex ){ sv_id = del_stack->id; }
3486  del_stack = (p = del_stack)->next; free((void *) p );
3487  } }
3488  return del_stack;
3489 }
3490 
3491 
3492 
3493 
3494 
3495 static struct send_back_entry * rev_list
3496 #ifdef ANSI
3497 #define SEP ,
3498 (
3499  struct send_back_entry *back_group
3500 )
3501 #undef SEP
3502 #else
3503 #define SEP ;
3504 (back_group)
3505  struct send_back_entry *back_group
3506 ;
3507 #undef SEP
3508 #endif
3509 { struct send_back_entry *p, *q, *t;
3510  if( back_group->id == -1 ){ return back_group; }
3512  while( p->id != -1 ){
3513  t = q->next; q->next = p; p = q; q = t;
3514  }
3515  back_group->next = p;
3516  return p->next;
3517 }
3518 
3519 
3520 
3521 
3522 
3523 static struct send_back_entry * back_insert
3524 #ifdef ANSI
3525 #define SEP ,
3526 (
3527  struct send_back_entry *back SEP
3528  int id
3529 )
3530 #undef SEP
3531 #else
3532 #define SEP ;
3534  struct send_back_entry *back SEP
3535  int id
3536 ;
3537 #undef SEP
3538 #endif
3539 {
3540  while( back->id == id ){
3541  struct send_back_entry *p;
3542  print_f( back->send );
3543  back = (p = back)->next;
3544  free((void *) p->send );
3545  free((void *) p );
3546  }
3547  return back;
3548 }
3549 
3550 
3551 
3552 
3553 
3554 static double pos_dbl
3555 #ifdef ANSI
3556 #define SEP ,
3557 ( long int * special_n
3558 )
3559 #undef SEP
3560 #else
3561 #define SEP ;
3562 ( special_n ) long int * special_n
3563 ;
3564 #undef SEP
3565 #endif
3566 {
3567  U_CHAR ch;
3568  double v;
3569  int d;
3570  v = 0.0; d = 10;
3571  while( --(*special_n) > 0 ){
3572  ch = get_char();
3573  if( ('0' <= ch ) && (ch <= '9' ) ){
3574  v += (double) (ch -'0') / d; d *= 10; }
3575  else break;
3576  }
3577  return v;
3578 }
3579 
3580 
3581 
3582 
3583 
3584 static void doGlyphArray
3585 #ifdef ANSI
3586 #define SEP ,
3587 (
3588  BOOL yLocs
3589 )
3590 #undef SEP
3591 #else
3592 #define SEP ;
3593 (yLocs)
3595 ;
3596 #undef SEP
3597 #endif
3598 { int i, glyphCount;
3601  for( i = 0; i < glyphCount; ++i ){
3602  (void) get_int(4);
3603  if( yLocs ){ (void) get_int(4); }
3604  }
3605  for (i = 0; i < glyphCount; ++i){
3606  (void) get_unt(2);
3607  }
3608 }
3609 
3610 
3611 
3612 
3613 
3614 static int search_font_tbl
3615 #ifdef ANSI
3616 #define SEP ,
3617 (
3618  int cur_fnt
3619 )
3620 #undef SEP
3621 #else
3622 #define SEP ;
3623 ( cur_fnt )
3624  int cur_fnt
3625 ;
3626 #undef SEP
3627 #endif
3628 { int i;
3629  for( i=0; i<font_tbl_size; i++){
3630  if( font_tbl[i].num == cur_fnt ){ return i; }
3631  }
3633  return 0;
3634 }
3635 
3636 
3637 
3638 
3639 
3640 static int get_html_ch
3641 #ifdef ANSI
3642 #define SEP ,
3643 ( FILE* file
3644 
3645 )
3646 #undef SEP
3647 #else
3648 #define SEP ;
3650 
3651 ;
3652 #undef SEP
3653 #endif
3654 { int ch;
3655  if( (ch = (int) getc(file)) == EOF ) {
3656  dump_htf( file );
3657  err_i_str(20, new_font_name);
3658  }
3659  return ch;
3660 }
3661 
3662 
3663 
3664 
3665 
3666 static FILE* f_open
3667 #ifdef ANSI
3668 #define SEP ,
3669 (
3670  const char* name SEP
3671  const char* flags
3672 )
3673 #undef SEP
3674 #else
3675 #define SEP ;
3676 ( name, flags )
3677  const char* name SEP
3678  const char* flags
3679 ;
3680 #undef SEP
3681 #endif
3682 { FILE* file;
3683  if( (file = fopen(name,flags) ) != NULL ) {
3684  (IGNORED) printf("(%s)\n",name);
3685  }
3686  return file;
3687 }
3688 
3689 
3690 
3691 
3692 
3693 static void dump_htf
3694 #ifdef ANSI
3695 #define SEP ,
3696 ( FILE* file
3697 
3698 )
3699 #undef SEP
3700 #else
3701 #define SEP ;
3702 ( file ) FILE* file
3703 
3704 ;
3705 #undef SEP
3706 #endif
3707 { int i, j, ch, chr=0;
3708  (IGNORED) fseek(file, 0L, 0);
3709  i=-1; j=0;
3710  while( (ch = getc(file)) != EOF ){
3711  if( !j ){ chr = ch; }
3712  j += ch==chr;
3713  (IGNORED) putc(ch,stderr);
3714  if( ch == '\n' ){
3715  if( (i>-1 ) && (j<4) && (dump_htf_files<2) ){
3716  (IGNORED) printf("missing delimiter \n");
3717  }
3718  (IGNORED) fprintf(stderr,"%d: ",++i);
3719  j=0;
3720 } } }
3721 
3722 
3723 
3724 
3725 static void dump_env( MYVOID )
3726 {
3727  int ch;
3728  if( !dumped_env ){
3729  dumped_env = TRUE;
3730  (IGNORED) fseek(dot_file, 0L,
3731 
3732 
3733 0
3734 );
3735  (IGNORED) fprintf(stderr,
3736  "\n----------------------------------------------------\n");
3737  (IGNORED) fprintf(stderr, "environment file\n");
3738  (IGNORED) fprintf(stderr,
3739  "----------------------------------------------------\n");
3740  while( (ch = getc(dot_file)) != EOF ){
3741  (IGNORED) putc(ch,stderr);
3742  }
3743  (IGNORED) fprintf(stderr,
3744  "----------------------------------------------------\n");
3745 } }
3746 
3747 
3748 
3749 
3750 
3751 static void htf_to_lg
3752 #ifdef ANSI
3753 #define SEP ,
3754 (
3755 
3756  struct html_font_rec* html_font SEP
3757  char* new_font_name SEP
3758  int fonts_n SEP
3759  FILE* file
3760 )
3761 #undef SEP
3762 #else
3763 #define SEP ;
3765 
3766  struct html_font_rec* html_font SEP
3767  char* new_font_name SEP
3768  int fonts_n SEP
3769  FILE* file
3770 ;
3771 #undef SEP
3772 #endif
3773 {
3774  int ch, i;
3775  for( i = 0 ; i<fonts_n; ){
3776  if( eq_str(html_font[i].name, new_font_name) ){ break; }
3777  i++;
3778  }
3779  if( i == fonts_n ){
3780  BOOL content;
3781  int prev_ch;
3782  prev_ch = '\n'; content = FALSE;
3783  while( (ch = (int) getc(file)) != EOF ) {
3784  if( (ch != '\n') || (prev_ch != '\n') ){
3785  (void) putc( ch, log_file );
3786  prev_ch = ch; content = TRUE;
3787  } }
3788  if( content && (prev_ch != '\n') ){
3789  (void) putc( '\n', log_file );
3790  }
3791 } }
3792 
3793 
3794 
3795 
3796 
3798 #ifdef ANSI
3799 #define SEP ,
3800 (
3801  FILE* file SEP
3802  int first SEP int last SEP int n
3803 
3804 )
3805 #undef SEP
3806 #else
3807 #define SEP ;
3809  FILE* file SEP
3810  int first SEP int last SEP int n
3811 
3812 ;
3813 #undef SEP
3814 #endif
3815 { int ch, i, bound, cnt;
3817  char* name;
3818  name = new_font_name;
3819  while( *name == (ch = get_html_ch(file)) ) name++;
3820 
3821 
3822 
3823 if( ( name == new_font_name ) && (n == 19) && (ch=='.') ){
3824  return HTF_ALIAS;
3825 }
3826 
3827 
3828  if( (*name != '\0') || (ch != ' ') ) warn_i_str(n, name);
3829  bound = first; diff = 0;
3830  for( cnt = 0; cnt < 2; cnt++ ){
3831  while( ch == ' ' ) ch = get_html_ch(file);
3832  i = 0;
3833  while( (ch >= '0') && (ch <= '9') ){
3834  i = i * 10 + ch - '0'; ch = get_html_ch(file); }
3835  if( i != bound ){
3836 
3837 
3838 
3839 (IGNORED) fprintf(stderr,"--- warning --- ");
3840 (IGNORED) fprintf(stderr, warn_err_mssg[22]
3841 
3842 , new_font_name, i, bound); show_err_context();
3843  diff = diff * 1000 + i - bound; }
3844  bound = last; }
3845  while( ch != '\n' ) ch = get_html_ch(file);
3846  return diff;
3847 }
3848 
3849 
3850 
3851 
3852 
3853 static void notify_class_info
3854 #ifdef ANSI
3855 #define SEP ,
3856 ( int gif_flag
3857 )
3858 #undef SEP
3859 #else
3860 #define SEP ;
3861 ( gif_flag ) int gif_flag
3862 ;
3863 #undef SEP
3864 #endif
3865 { U_CHAR str[256], *p;
3866  str[0] = '\0';
3867  p = gif_open[gif_flag];
3868  if( p )
3869  if( *p ) (IGNORED) strct(str,p);
3870  p = gif_alt[gif_flag];
3871  if( p )
3872  if( *p ) (IGNORED) strct(str,p);
3873  p = gif_class[gif_flag];
3874  if( p )
3875  if( *p ) (IGNORED) strct(str,p);
3876  p = gif_size[gif_flag];
3877  if( p )
3878  if( *p ) (IGNORED) strct(str,p);
3879  p = gif_mag[gif_flag];
3880  if( p )
3881  if( *p ) (IGNORED) strct(str,p);
3882  p = gif_ord[gif_flag];
3883  if( p )
3884  if( *p ) (IGNORED) strct(str,p);
3885  p = gif_end[gif_flag];
3886  if( p )
3887  if( *p ) (IGNORED) strct(str,p);
3888  p = str;
3889  while( *p ){
3890  if( *p == '\n' ) *p = ' ';
3891  p++;
3892  }
3894  gif_flag,
3895  gif_id[gif_flag]? gif_id[gif_flag] : "",
3896  str);
3897 }
3898 
3899 
3900 
3901 
3902 
3903 static void script
3904 #ifdef ANSI
3905 #define SEP ,
3906 (
3907  U_CHAR *templt SEP
3908  U_CHAR *job SEP
3909  int page SEP
3910  U_CHAR *font
3911 
3912 )
3913 #undef SEP
3914 #else
3915 #define SEP ;
3917  U_CHAR *templt SEP
3918  U_CHAR *job SEP
3919  int page SEP
3921 
3922 ;
3923 #undef SEP
3924 #endif
3925 { U_CHAR *ch, *p;
3926  U_CHAR fmt[256];
3927  job[ (int) strlen((char *) job) - 1 ] ='\0';
3928  p = ch = templt;
3929  while( TRUE ){
3930  if( *ch == '%' ){
3931 
3932 
3933 
3934 *ch = '\0'; (IGNORED) fprintf(log_file, "%s", p);
3935 *(ch++) = '%';
3936 
3937 
3938 
3939 
3940 
3941 p=fmt; *(p++) = '%';
3942 if( *ch == '\0' ){ job[ (int) strlen((char *) job) ] ='.'; return; }
3943 while( *ch != '%' ){ *(p++) = *(ch ++); }
3944 *(p+1) = '\0';
3945 
3946 
3947  switch( *(++ch) ){
3948  case '1':{ *p = 's';
3949  (IGNORED) fprintf(log_file, fmt, job); break;}
3950  case '2':{ *p = 'd';
3951  (IGNORED) fprintf(log_file, fmt, page); break;}
3952  case '3':{ *p = 's';
3953  (IGNORED) fprintf(log_file, fmt, font); break;}
3954  case '%':{ *p = 'c';
3955  (IGNORED) fprintf(log_file, fmt, '%'); break;}
3956  default:{ job[ (int) strlen((char *) job) ] ='.'; return;}
3957  }
3958  p = ++ch;
3959  }else ch++;
3960 } }
3961 
3962 
3963 
3964 
3965 
3966 
3967 static void dos_gif_file
3968 #ifdef ANSI
3969 #define SEP ,
3970 (
3971  U_CHAR *str SEP
3972  int mag SEP
3973  int design_ch
3974 
3975 )
3976 #undef SEP
3977 #else
3978 #define SEP ;
3980  U_CHAR *str SEP
3981  int mag SEP
3982  int design_ch
3983 
3984 ;
3985 #undef SEP
3986 #endif
3987 { int n, m, i;
3988  struct gif_file_rec * p, * q;
3989  U_CHAR *ch;
3990  m = n = (int) strlen((char *) str);
3991  if( n > 4 ){
3992 
3993 
3994 
3995 if( (p = gif_file) != NULL ){
3996  while( TRUE ){
3997  if( eq_str( str, p->name ) ) break;
3998  if( (p = p->next) == gif_file ){ p = NULL; break; }
3999 } }
4000 
4001 
4002  if( p == NULL ){
4003 
4004 
4005 p = m_alloc(struct gif_file_rec, 1);
4006 
4007 
4008 
4009 for(i=str[n]; n; ){ i+=str[--n]; if( i > (INT_MAX / 8) ) i/=2; }
4010 if( (n=i % BASE) <10 ) n+= 10 + i%(BASE-20);
4011 *(ch = p->code)= n; n += i;
4012 ch[1] = n%BASE; n += i;
4013 ch[2] = n%BASE; n += i;
4014 ch[3] = n%BASE;
4015 
4016 
4017 
4018 
4019 
4020 if( gif_file ){
4021  q = gif_file->next;
4022  while( TRUE ){
4023  if( (*(q->code) == *ch) && (*(q->code+1) == ch[1]) &&
4024  (*(q->code) == ch[2]) && (*(q->code+2) == ch[3]) ){
4025  ch[3] ++; ch[2] += ch[3]/ BASE; ch[3] = ch[3] % BASE;
4026  ch[1] += ch[2]/ BASE; ch[2] = ch[2] % BASE;
4027  ch[1] = ch[1] % BASE;
4028  q = gif_file;
4029  } else if( q == gif_file ) break;
4030  q = q->next;
4031 } }
4032 
4033 
4034 (IGNORED) printf("\nRenaming `%s____%s' to `%c%c%c%c____%s'\n",
4035  str, gif,
4036  xeh[(int)(ch[0])], xeh[(int)(ch[1])],
4037  xeh[(int)(ch[2])], xeh[(int)(ch[3])]
4038  , gif);
4039 p->name = m_alloc(char,m+1);
4040 (IGNORED) strcpy((char *) p->name, (char *) str );
4041 if( gif_file ){ p->next = gif_file->next; gif_file->next = p; }
4042  else p->next = p;
4043 
4044  }
4045  gif_file = p;
4046  for( n=0; n<4; n++ ) str[n] = xeh[(int)(*(p->code + n))];
4047  }
4048  str[n++] = xeh[mag<16? 0: mag / 16];
4049  str[n++] = xeh[mag % 16];
4050  str[n++] = xeh[design_ch<16? 0: design_ch / 16];
4051  str[n++] = xeh[design_ch % 16];
4052  str[n] = '\0';
4053 }
4054 
4055 
4056 
4057 
4058 
4059 
4060 static void put_alt_ch
4061 #ifdef ANSI
4062 #define SEP ,
4063 (
4064  int chr SEP
4066 )
4067 #undef SEP
4068 #else
4069 #define SEP ;
4070 (chr,ch_str_flag)
4071  int chr SEP
4073 ;
4074 #undef SEP
4075 #endif
4076 {
4077  if( !ch_str_flag ) put_char( chr );
4078  else if( chr > 0 ){
4079 
4080 
4081  unsigned U_CHAR * p;
4082 p = font_tbl[cur_fnt].str[chr-1];
4083 if( gif_ch ) print_f( (char *) p );
4084 else while( *p ){
4085  switch( *p ){
4086  case '<': { while( *p && (*p != '>') ) p++; break; }
4087  case '>':
4088  case '"': { p++; break; }
4089  case '\'': { p++; break; }
4090  default: { put_char( (int) *p ) ; p++; }
4091 } }
4092 
4093  }
4094 }
4095 
4096 
4097 
4098 
4099 
4100 static void get_open_accent
4101 #ifdef ANSI
4102 #define SEP ,
4103 (
4104  char **all SEP
4105  char **first SEP
4106  char **second SEP
4107  char **third SEP
4108  char **fourth SEP
4109  char **fifth SEP
4110  long int *n
4111 )
4112 #undef SEP
4113 #else
4114 #define SEP ;
4116  char **all SEP
4117  char **first SEP
4118  char **second SEP
4119  char **third SEP
4120  char **fourth SEP
4121  char **fifth SEP
4122  long int *n
4123 ;
4124 #undef SEP
4125 #endif
4126 { char *p, *q;
4127  int i;
4128  if( *all ){ free((void *) *all); }
4129  *all = p = get_str( (int) *n ); *n=0;
4130  i = 2;
4131  *first = q = p + 1;
4132  while ( TRUE ){
4133  if( *q == *p ){
4134  *q = '\0';
4135  switch( i ){
4136  case 2:{ *second = q+1; break; }
4137  case 3:{ *third = q+1; break; }
4138  case 4:{ *fourth = q+1; break; }
4139  case 5:{ *fifth = q+1; break; }
4140  }
4141  if( i++ == 5 ){ break; }
4142  } else if( !*q ){
4143  free((void *) *all); *all = (char *) 0; break;
4144  }
4145  q++;
4146 } }
4147 
4148 
4149 
4150 
4151 
4152 static int scan_class
4153 #ifdef ANSI
4154 #define SEP ,
4155 (
4156  int flag
4157 )
4158 #undef SEP
4159 #else
4160 #define SEP ;
4161 ( flag )
4162  int flag
4163 ;
4164 #undef SEP
4165 #endif
4166 { int math_class;
4167  math_class = get_char();
4168  if( (math_class >= '0' )
4169  && (math_class < '0' +
4170 
4171 
4172 79
4173 
4174 ) ){
4175  { math_class -= '0'; }
4176  } else {
4177  if( flag== 1 ) {
4178  switch( math_class ){
4179  case '-': { math_class =
4180 
4181 
4182 79
4183 
4184 ;
4185  pause_class++; break; }
4186  case '+': { math_class =
4187 
4188 
4189 79
4190 
4191 ;
4192  pause_class--; break; }
4193  default: { math_class = 0; }
4194  } } else if( flag== 2 ) {
4195  switch( math_class ){
4196  case
4197 
4198 
4199 ')'
4200 
4201 : {
4202  math_class =
4203 
4204 
4205 (
4206 
4207 
4208 79
4209 
4210  + 1)
4211 
4212 ; break; }
4213  case
4214 
4215 
4216 '('
4217 
4218 :
4219  { math_class =
4220 
4221 
4222 (
4223 
4224 
4225 79
4226 
4227  + 2)
4228 
4229 ; break; }
4230  default: { math_class = 0; }
4231  }
4232  } else { math_class = 0; }
4233  }
4234  return math_class;
4235 }
4236 
4237 
4238 
4239 
4240 
4241 static INTEGER set_ch_class
4242 #ifdef ANSI
4243 #define SEP ,
4244 ( int ch
4245 )
4246 #undef SEP
4247 #else
4248 #define SEP ;
4249 (ch) int ch
4250 ;
4251 #undef SEP
4252 #endif
4253 { int r_ch;
4255  if( math_class ==
4256 
4257 
4258 5
4259 
4260  ){
4261  store_bit_I( font_tbl[cur_fnt].math_closing, r_ch );
4262  *(font_tbl[cur_fnt].math + r_ch) =
4263  (char) ((open_del == 256)? ch : open_del);
4264  } else {
4265  store_bit_Z( font_tbl[cur_fnt].math_closing, r_ch );
4267  }
4268  open_del = ( math_class ==
4269 
4270 
4271 4
4272 
4273  )? ch : 256;
4274 
4275 
4276 
4277 return (INTEGER)(
4278 
4279 
4280 
4282  + (int) (
4283 
4284 
4285 *(font_tbl[cur_fnt].char_wi + (int)
4286  ( ch - font_tbl[cur_fnt].char_f)% 256)
4287 
4288 ) )
4289  )
4290 * (double) font_tbl[cur_fnt].scale
4291 
4292 
4293  );
4294 
4295 
4296 }
4297 
4298 
4299 
4300 
4301 
4302 static int math_class_of
4303 #ifdef ANSI
4304 #define SEP ,
4305 ( int ch SEP int cur_fnt
4306 )
4307 #undef SEP
4308 #else
4309 #define SEP ;
4310 (ch,cur_fnt) int ch SEP int cur_fnt
4311 ;
4312 #undef SEP
4313 #endif
4314 { int math_class;
4316  return ((get_bit( font_tbl[cur_fnt].math_closing, math_class))?
4317 
4318 
4319 
4320 5
4321 
4322  : *( math_class + font_tbl[cur_fnt].math));
4323 
4324 }
4325 
4326 
4327 
4328 
4329 #if defined(__MSDOS__)
4330 
4331 
4332 
4333 
4334 static char *get_env_dir
4335 #ifdef ANSI
4336 #define SEP ,
4337 (
4338  U_CHAR *progname
4339 
4340 )
4341 #undef SEP
4342 #else
4343 #define SEP ;
4344 (progname)
4345  U_CHAR *progname
4346 
4347 ;
4348 #undef SEP
4349 #endif
4350 { int i;
4351  U_CHAR *p;
4352  if(! progname || ! *progname) return NULL;
4353  i = (int) strlen((char *) progname);
4354  while( (progname[--i] != (int) dir_path_slash(progname) )
4355  && (i > 0) ) ;
4356  if(i == 0) return NULL;
4357  p = (char *) malloc(i+12);
4358  if(p == NULL) return NULL;
4359  strncpy(p, progname, i+1);
4360  (IGNORED) strcpy((char *) &p[i+1], "tex4ht.env");
4361  return p;
4362 }
4363 
4364 
4365 #endif
4366 
4367 
4368 
4369 
4370 
4371 static char* get_script
4372 #ifdef ANSI
4373 #define SEP ,
4374 (
4375  char * name SEP
4376  const U_CHAR * inln SEP
4377  int x
4378 
4379 )
4380 #undef SEP
4381 #else
4382 #define SEP ;
4384  char * name SEP
4385  const U_CHAR * inln SEP
4386  int x
4387 
4388 ;
4389 #undef SEP
4390 #endif
4391 {
4392  if( !name )
4393  { U_CHAR str[256], *ch;
4394  (IGNORED) fseek(dot_file, 0L,
4395 
4396 
4397 0
4398 );
4399  if( search_dot_file( x ) ){
4400 
4401 
4402 
4403 ch = str; str[254] = '\0';
4404 do{ int int_ch;
4405  while((*(ch++) = (char)
4406  (int_ch = (int) getc(dot_file))
4407  ) != '\n'){
4408  if( int_ch == EOF ){ *(ch-1)='\n'; break; }
4409  if( str[254] ){ warn_i_int(33, x); break; }
4410  }
4411 }while( (int) getc(dot_file) == x );
4412 *ch = '\0';
4413 
4414 
4415  } else {(IGNORED) strcpy((char *) str, inln); }
4416  ch = m_alloc(char, (int) strlen((char *) str)+2);
4417  (IGNORED) strcpy((char *) ch, (char *) str);
4418  return ch;
4419  }else return name;
4420 }
4421 
4422 
4423 
4424 
4425 
4426 static BOOL search_dot_file
4427 #ifdef ANSI
4428 #define SEP ,
4429 (
4430  int ch
4431 )
4432 #undef SEP
4433 #else
4434 #define SEP ;
4435 ( ch )
4436  int ch
4437 ;
4438 #undef SEP
4439 #endif
4440 { int chr;
4441 
4442  while( TRUE ){
4443  chr = getc(dot_file);
4444  if( chr == ch ){ return TRUE; }
4445  if( chr == '<' ) {
4446 
4447 
4448 
4449  U_CHAR match[256];
4450  int i;
4451 for( i = 0; (chr != '\n') && (chr != EOF ) ; i++){
4452  chr = (int) getc(dot_file);
4453  match[i] = (U_CHAR) chr;
4454 }
4455 match[i-1] = '\0';
4456 if( match[0] != '/' ){
4457  BOOL env_skip;
4458  for( i = 0;
4459  (match[i] != '>') && (match[i] != '\n') && (match[i] != EOF );
4460  i++){}
4461  if( match[i] == '>' ){ match[i] = '\0'; }
4462 
4463 
4464 
4465 if( envChoice == (struct env_c_rec*) 0 ){
4466  env_skip = !eq_str(match, "default" );
4467 } else {
4468  struct env_c_rec *p;
4469  env_skip = TRUE;
4470  for( p=envChoice; p!=(struct env_c_rec*) 0 ; p = p->next ){
4471  if( eq_str(match, p->option ) ){ env_skip = FALSE; }
4472 } }
4473 
4474 
4475  if( env_skip ){
4476 
4477 
4478 
4479  U_CHAR cur_block[90];
4480  BOOL status;
4481 (IGNORED) strcpy((char *) cur_block, (char *) match);
4482 status = FALSE;
4483 while( !status && (chr != EOF) ){
4484  chr = 'x';
4485  for( i = 0; (chr != '\n') && (chr != EOF ) ; i++){
4486  chr = (int) getc(dot_file);
4487  match[i] = (U_CHAR) chr;
4488  }
4489  match[i-1] = '\0';
4490  for(i=0; match[i]!='\0'; i++){
4491  if( match[i] == '>' ){ break; }
4492  }
4493  if( (match[0] == '<') && (match[1] == '/')
4494  && (match[i] == '>') ){
4495  match[i]='\0';
4496  status = eq_str(match+2, cur_block);
4497  } else { status = FALSE; }
4498 }
4499 
4500 
4501 } }
4502 
4503 
4504  continue;
4505  }
4506  if( chr == '\n' ){ continue; }
4507  do
4508  if( chr == EOF ) return FALSE;
4509  while( (chr = getc(dot_file)) != '\n' );
4510 } }
4511 
4512 
4513 
4514 
4515 
4516 static struct env_var_rec * get_env_var
4517 #ifdef ANSI
4518 #define SEP ,
4519 (
4520  const char *env_var
4521 )
4522 #undef SEP
4523 #else
4524 #define SEP ;
4525 ( env_var )
4526  const char *env_var
4527 ;
4528 #undef SEP
4529 #endif
4530 { U_CHAR *TEX4HTTFM, *from;
4533  tfm_dirs = (struct env_var_rec *) 0;
4535  if( TEX4HTTFM ){
4536  env_var_len = (int) strlen((char *) TEX4HTTFM);
4537  if ( *TEX4HTTFM == *(TEX4HTTFM + env_var_len - 1 ) ){
4538  from = TEX4HTTFM + env_var_len - 1;
4539  *from = '\0';
4540  do{
4541  from--;
4542  if( *from == *TEX4HTTFM ){ char * base;
4543  *from = '\0';
4544  base = from + 1;
4545 
4546 
4547 
4548 { U_CHAR *str;
4549  if( *(from+1) == '~' ){
4550  if( HOME_DIR ){
4551  str = m_alloc(char, strlen((char *) HOME_DIR)+strlen((char *) base));
4552  (IGNORED) sprintf(str,"%s%s", HOME_DIR, base+1);
4553  if( access(str,F_OK) ) {
4554  warn_i_str2(49, env_var, str); base = NULL; }
4555  free((void *) str);
4556  } else {
4557  if( access(base,F_OK) ) {
4558  warn_i_str2(49, env_var, base); base = NULL; }
4559  }
4560  } else {
4561  if( access(base,F_OK) ) {
4562  warn_i_str2(49, env_var, base); base = NULL; }
4563 } }
4564 
4565 
4566  if( base ){
4567 
4568 
4569 
4570 p = m_alloc(struct env_var_rec, 1);
4571 p->next = tfm_dirs;
4572 p->base = base;
4573 tfm_dirs = p;
4574 
4575 
4576  } }
4577  } while (from > TEX4HTTFM );
4578  } else { warn_i_str2( 49, env_var, TEX4HTTFM); }
4579  }
4580  return tfm_dirs;
4581 }
4582 
4583 
4584 
4585 
4586 
4587 static void com_dir
4588 #ifdef ANSI
4589 #define SEP ,
4590 (
4591  char* p
4592 )
4593 #undef SEP
4594 #else
4595 #define SEP ;
4596 (p)
4597  char* p
4598 ;
4599 #undef SEP
4600 #endif
4601 { int i; U_CHAR str[256];
4602  (IGNORED) strcpy((char *) str, (char *) p+2 );
4603  i = (int) strlen((char *) str) - 1;
4604  if( str[i] == '!' ) str[i] = '\0';
4605 }
4606 
4607 
4608 
4609 
4610 #ifdef KPATHSEA
4611 
4612 static void export_htf
4613 #ifdef ANSI
4614 #define SEP ,
4615 (
4616  char** export_str SEP
4617  char str[]
4618 )
4619 #undef SEP
4620 #else
4621 #define SEP ;
4622 (export_str, str)
4623  char** export_str SEP
4624  char str[]
4625 ;
4626 #undef SEP
4627 #endif
4628 { int i;
4629  char* p;
4630  BOOL found;
4631  i = (int) strlen((char *) str) - 1;
4632  while( (i>=0) && (str[i] == '\n') ){ str[i--] = '\0'; }
4633  while( (i>=0) && (str[i] == ' ') ) { str[i--] = '\0'; }
4634  if( (i>=0) && (str[i] == '!') ){ str[i--] = '\0'; }
4635  if( (i>=0) && ((str[i] == '/') || (str[i] == '\\')) ){
4636  str[i--] = '\0'; }
4637  i -= 8; found = FALSE;
4638  while( --i>=0 ){
4639  if( ((str[i] == '/') || (str[i] == '\\')) && (str[i+1]== 'h')
4640  && (str[i+2]=='t') && (str[i+3]=='-')
4641  && (str[i+4]=='f') && (str[i+5]=='o')
4642  && (str[i+6]=='n') && (str[i+7]=='t')
4643  && (str[i+8]=='s')
4644  && ((str[i+9] == '/') || (str[i+9] == '\\'))
4645  ){
4646  p = str + i + 10; i=0;
4647  while( *p ){ str[i++] = *(p++); }
4648  str[i] = '\0';
4649  found = TRUE; break;
4650  } }
4651  if( found ){
4652  *export_str = (char *) r_alloc((void *) *export_str,
4653  (int) strlen((char *) *export_str) + (int) strlen((char *) str) + 2 );
4654  if( (int) strlen((char *) *export_str) > 0 ){
4655  (IGNORED) strcat((char *) *export_str, ",");
4656  }
4657  (IGNORED) strcat((char *) *export_str, (char *) str);
4658  }
4659 }
4660 #endif
4661 
4662 
4663 
4664 
4665 
4666 static FILE* search_in_dot_file
4667 #ifdef ANSI
4668 #define SEP ,
4669 (
4670  int typ SEP
4671  const U_CHAR *name SEP
4672  const U_CHAR *flags SEP
4673  struct env_var_rec *env_dirs
4674 
4675 )
4676 #undef SEP
4677 #else
4678 #define SEP ;
4679 ( typ, name, flags, env_dirs)
4680  int typ SEP
4681  const U_CHAR *name SEP
4682  const U_CHAR *flags SEP
4683  struct env_var_rec *env_dirs
4684 
4685 ;
4686 #undef SEP
4687 #endif
4688 { U_CHAR *ch, dir[256];
4689  FILE* file;
4690 #ifndef KPATHSEA
4691  if( cache_files != (FILE *) 0 ){
4692 
4693 
4694 
4695  U_CHAR cache_dir[256], dot_dir[256], *p, *q;
4696  BOOL flag;
4697  int n, ch;
4698 (IGNORED) fseek(cache_files, 0L,
4699 
4700 
4701 0
4702 );
4703 ch = (int) getc(cache_files);
4704 while ( ch != EOF ){
4705  if ( ch == ' ' ) {
4706 
4707 
4708 q = cache_dir;
4709 do
4710  *(q++) = ch = (int) getc(cache_files);
4711 while( (ch !='\n') && (ch != EOF) );
4712 *(q-1 - (*(q-2) ==
4713 
4714 
4715 #if defined(__DJGPP__)
4716  '\\'
4717 #else
4718  '/'
4719 #endif
4720 
4721 )
4722 #ifdef DOS_WIN32
4723  - (*(q-2) == '/')
4724 #endif
4725  ) = '\0';
4726 
4727  }
4728  else {
4729 
4730 
4731 p = name; flag = FALSE;
4732 while( *(p++) == ch ){
4733  ch = (int) getc(cache_files);
4734 }
4735 if( (*(p-1) == '\0') && ((ch == '\n') || (ch == EOF)) ){ flag = TRUE; }
4736 else{
4737  while( (ch != '\n') && (ch != EOF) ) { ch = (int) getc(cache_files); }
4738 }
4739 
4740 
4741  if( flag ){
4742 
4743 
4744 
4745 flag = FALSE;
4746 (IGNORED) fseek(dot_file, 0L,
4747 
4748 
4749 0
4750 );
4751 while( search_dot_file( typ ) && !flag ){ U_CHAR *q, save_ch;
4752  int n, m;
4753  q = dot_dir;
4754  do
4755  *(q++) = ch = (int) getc(dot_file);
4756  while( (ch !='\n') && (ch != EOF) );
4757  flag = *(q - 2) = '!';
4758  q -= (flag? 2 : 1);
4759  *(q - (*(q-1) ==
4760 
4761 
4762 #if defined(__DJGPP__)
4763  '\\'
4764 #else
4765  '/'
4766 #endif
4767 
4768 )
4769 #ifdef DOS_WIN32
4770  - (*(q-1) == '/')
4771 #endif
4772  ) = '\0';
4773  if( (n = strlen((char *) dot_dir)) > (m = strlen((char *) cache_dir)) ){ flag = FALSE; }
4774  else {
4775  save_ch = *(cache_dir + n);
4776  *(cache_dir + n) = '\0';
4777  flag = eq_str(dot_dir,cache_dir) && ( flag || (m == n) );
4778  *(cache_dir + n) = save_ch;
4779  }
4780 }
4781 
4782 
4783  if( flag ){
4784 
4785 
4786 n = (int) strlen((char *) cache_dir);
4787 cache_dir[n] = dir_path_slash(cache_dir);
4788 cache_dir[n+1] = '\0';
4789 (IGNORED) strcat((char *) cache_dir, (char *) name);
4790 
4791  }
4792  } }
4793  if ( ch != EOF ){ ch = (int) getc(cache_files); }
4794 }
4795 
4796 
4797  }
4798 #endif
4799  (IGNORED) fseek(dot_file, 0L,
4800 
4801 
4802 0
4803 );
4804  while( search_dot_file( typ ) ){
4805  ch = dir;
4806  while((*(ch++) = (int) getc(dot_file)) > ' ');
4807  while(*(ch-1) != '\n'){
4808  *(ch-1) = (int) getc(dot_file);
4809  }
4810  *(ch-1) = '\0';
4812  if( file != NULL ){
4813 #ifndef KPATHSEA
4814  tex4ht_fls = TRUE;
4815 #endif
4816  return file;
4817  } }
4818  return NULL;
4819 }
4820 
4821 
4822 
4823 
4824 
4825 static FILE* search_file_base
4826 #ifdef ANSI
4827 #define SEP ,
4828 (
4829  const U_CHAR *name SEP
4830  const U_CHAR *dir SEP
4831  const U_CHAR *flags SEP
4832  struct env_var_rec *env_dirs
4833 
4834 )
4835 #undef SEP
4836 #else
4837 #define SEP ;
4839  const U_CHAR *name SEP
4840  const U_CHAR *dir SEP
4841  const U_CHAR *flags SEP
4843 
4844 ;
4845 #undef SEP
4846 #endif
4847 { U_CHAR *p;
4848  FILE* file;
4849  if( *dir == '~' ){
4850  while( TRUE ){
4852  file = search_file(name, p, flags);
4853  free((void *) p);
4854  if( file || !env_dirs ){ return file; }
4855  env_dirs = env_dirs->next;
4856  }
4857  } else {
4858  file = search_file(name, dir, flags);
4859  }
4860  return file;
4861 }
4862 
4863 
4864 
4865 
4866 
4867 static char * abs_addr
4868 #ifdef ANSI
4869 #define SEP ,
4870 (
4871  const U_CHAR *dir SEP
4872  const U_CHAR *base
4873 
4874 )
4875 #undef SEP
4876 #else
4877 #define SEP ;
4878 ( dir, base)
4879  const U_CHAR *dir SEP
4880  const U_CHAR *base
4881 
4882 ;
4883 #undef SEP
4884 #endif
4885 { U_CHAR *p;
4886  p = m_alloc(char, (int) strlen( dir ) +
4887  (base? (int) strlen( base ):0) +
4888  (int) strlen((char *) HOME_DIR ) + 1 );
4889  *p = '\0';
4890  if( (*(dir+1) == '~') && base ){
4891  if( *base == '~' ){
4892  (IGNORED) strct(p, HOME_DIR);
4893  (IGNORED) strct(p, base+1);
4894  } else {
4895  (IGNORED) strct(p, base);
4896  }
4897  (IGNORED) strct(p, dir+2);
4898  } else {
4899  (IGNORED) strct(p, HOME_DIR);
4901  }
4902  return p;
4903 }
4904 
4905 
4906 
4907 
4908 
4909 static FILE* search_file
4910 #ifdef ANSI
4911 #define SEP ,
4912 (
4913  const char *name SEP
4914  const U_CHAR *dir SEP
4915  const U_CHAR *flags
4916 
4917 )
4918 #undef SEP
4919 #else
4920 #define SEP ;
4921 ( name, dir, flags )
4922  const char *name SEP
4923  const U_CHAR *dir SEP
4924  const U_CHAR *flags
4925 
4926 ;
4927 #undef SEP
4928 #endif
4929 { FILE* file;
4930  U_CHAR str[256];
4931  int i;
4933 
4934 
4935 
4936 if( (file = f_open(name, flags)) != NULL ){
4937  return file; }
4938 
4939 
4940  (IGNORED) strcpy((char *) str, dir);
4941  i = (int) strlen((char *) str) - 1;
4942  subs = str[i] == '!';
4943  if( subs ) str[i] = '\0'; else i++;
4944 
4945 
4946 
4947 (IGNORED) strct(str,
4948 #if defined(__DJGPP__)
4949  (( dir[i-1] == '/') || ( dir[i-1] == '\\'))
4950  ? ""
4951  : (is_forward_slash(dir)? "/" : "\\" )
4952 #else
4953  (dir[i-1] == '/')? "" : "/"
4954 #endif
4955  );
4956 
4957 
4958 
4959 
4960 
4961 
4962 (IGNORED) strct(str,name);
4963 if( (file = f_open(str, flags)) != NULL ){
4964  str[i] = '\0'; add_to_cache(str,name,i);
4965  return file; }
4966 
4967 
4968  str[i] = '\0';
4969  return subs? search_file_ext( name, str, flags):
4970  NULL;
4971 }
4972 
4973 
4974 
4975 
4976 
4977 static void add_to_cache
4978 #ifdef ANSI
4979 #define SEP ,
4980 (
4981  const char* dir SEP const char* name SEP int n
4982 
4983 )
4984 #undef SEP
4985 #else
4986 #define SEP ;
4987 (dir,name,n)
4988  const char* dir SEP const char* name SEP int n
4989 
4990 ;
4991 #undef SEP
4992 #endif
4993 {
4995 
4996 
4997 
4998 
4999 { int found;
5004  { found = found || eq_str(cur_cache_font->dir, dir ) ;
5005  if( found ) break; }
5006  if( !found ){
5007  cur_cache_font = m_alloc(struct cache_font_rec, 1);
5008 
5009 
5010 
5011 cur_cache_font->cache_file = (struct cache_file_rec *) 0;
5012 
5013 
5014  cur_cache_font->dir = m_alloc(char, n+1);
5015  (IGNORED) strcpy((char *) cur_cache_font->dir, dir);
5016  if( !cache_font ){
5019  } else if ( gt_str(cache_font->dir, dir) ) {
5022  } else {
5023  struct cache_font_rec * after_cache_font;
5024  after_cache_font = cache_font;
5025  while( after_cache_font->next ){
5026  if ( gt_str(after_cache_font->next->dir, dir) ) { break; }
5027  after_cache_font = after_cache_font->next;
5028  }
5029  cur_cache_font->next = after_cache_font->next;
5030  after_cache_font->next = cur_cache_font;
5031 } } }
5032 
5033 
5034 
5035 
5036 
5037 {
5041  while( file_rec ) {
5042  if( !gt_str(name,file_rec->file) ) break;
5044  file_rec = file_rec->next;
5045  }
5046  {
5047  struct cache_file_rec * file_entry;
5048  BOOL flag;
5049  flag = TRUE;
5050  if( file_rec ) {
5051  if( eq_str(name,file_rec->file) ){ flag = FALSE; }
5052  }
5053  if( flag ) {
5054 
5055 
5056 
5057 file_entry = m_alloc(struct cache_file_rec, 1);
5058 file_entry->file = m_alloc(char, strlen(name)+1);
5059 (IGNORED) strcpy((char *) file_entry->file, name);
5060 if( ! cur_cache_font->cache_file ){
5061  cur_cache_font->cache_file = file_entry;
5062  file_entry->next = (struct cache_file_rec *) 0;
5063 } else if( !prev_file_rec ){
5064  file_entry->next = cur_cache_font->cache_file;
5065  cur_cache_font->cache_file = file_entry;
5066 } else {
5067  file_entry->next = prev_file_rec->next;
5068  prev_file_rec->next = file_entry;
5069 }
5070 
5071 
5072  }
5073  }
5074 }
5075 
5076 
5077 }
5078 
5079 
5080 
5081 
5082 
5083 static FILE* search_file_ext
5084 #ifdef ANSI
5085 #define SEP ,
5086 (
5087  const char *name SEP
5088  const U_CHAR *dir SEP
5089  const U_CHAR *flags
5090 
5091 )
5092 #undef SEP
5093 #else
5094 #define SEP ;
5095 ( name, dir, flags )
5096  const char *name SEP
5097  const U_CHAR *dir SEP
5098  const U_CHAR *flags
5099 
5100 ;
5101 #undef SEP
5102 #endif
5103 { U_CHAR str[256];
5104  FILE* file;
5105  int n;
5106  n = (int) strlen(dir);
5108 #if defined(__DJGPP__)
5109  (( dir[n-1] == '/') || ( dir[n-1] == '\\'))
5110  ? "%s%s"
5111  : (is_forward_slash(dir)? "%s/%s" : "%s\\%s" )
5112 #else
5113  (dir[n-1] == '/')? "%s%s" : "%s/%s"
5114 #endif
5115  , dir, name);
5116  if( (file = f_open(str,flags)) != NULL ){
5118  return file;
5119  }
5120  if( (str[n] ==
5121 
5122 
5123 #if defined(__DJGPP__)
5124  '\\'
5125 #else
5126  '/'
5127 #endif
5128 
5129 )
5130 #ifdef DOS_WIN32
5131  || (str[n] == '/' )
5132 #endif
5133  ) n++;
5134  str[n-1] = '\0';
5135 #ifndef NOSUBDIR
5136 #ifdef WIN32
5137 
5138 
5139 
5140 {
5141  WIN32_FIND_DATA find_file_data;
5142  HANDLE hnd;
5143  int proceed;
5144  (IGNORED) strcpy((char *) dirname, (char *) str);
5145  strct(dirname, "/*.*");
5146  hnd = FindFirstFile(dirname, &find_file_data);
5147  if (hnd != INVALID_HANDLE_VALUE) {
5148 
5149 
5150 
5151 proceed = 1;
5152 while (proceed) {
5153  if( !eq_str(find_file_data.cFileName, ".") &&
5154  !eq_str(find_file_data.cFileName, "..") )
5155  {
5156  (IGNORED) strcpy((char *) str+n, (char *) find_file_data.cFileName );
5157  str[n-1] = dir_path_slash(str);
5158  if (find_file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
5159  if( (file = search_file_ext(name, str, flags)) != NULL ){
5160  FindClose(hnd);
5161  return file; }
5162  }
5163  }
5164  proceed = FindNextFile(hnd, &find_file_data);
5165 }
5166 FindClose(hnd);
5167 
5168 
5169  }
5170 }
5171 
5172 
5173 #else
5174 
5175 
5176 
5177 { DIR *dp;
5178 
5179 
5180 
5181 
5182 #ifdef STRUCT_DIRECT
5183  struct direct
5184 #else
5185  struct dirent
5186 #endif
5187 
5188  *dirp;
5189  struct STSTAT buf;
5190  if( (dp = opendir( str )) != NULL ){
5191  while( (dirp = readdir(dp)) != NULL ){
5192  if( !eq_str(dirp->d_name, ".") &&
5193  !eq_str(dirp->d_name, "..") )
5194  {
5195 
5196 
5197 (IGNORED) strcpy((char *) str+n, (char *) dirp->d_name );
5198 str[n-1] = dir_path_slash(str);
5199 if( LSTAT(str, &buf) >= 0 )
5200  if( S_ISDIR( buf.st_mode ) )
5201  if( (file = search_file_ext(name, str, flags)) != NULL ){
5202  (void) closedir(dp);
5203  return file; }
5204 
5205 
5206  } }
5207  (void) closedir(dp);
5208 } }
5209 
5210 
5211 #endif
5212 #endif
5213  return NULL;
5214 }
5215 
5216 
5217 
5218 
5219 #if defined(__DJGPP__)
5220 
5221 static BOOL is_forward_slash
5222 #ifdef ANSI
5223 #define SEP ,
5224 (
5225  const char* str
5226 )
5227 #undef SEP
5228 #else
5229 #define SEP ;
5230 (str)
5231  const char* str
5232 ;
5233 #undef SEP
5234 #endif
5235 {
5236  while( *str ){ if( *(str++) == '/' ) { return TRUE; } }
5237  return FALSE;
5238 }
5239 #endif
5240 
5241 
5242 
5243 
5244 
5246 #ifdef ANSI
5247 #define SEP ,
5248 (
5249  const char* name SEP
5250  const char* flags
5251 )
5252 #undef SEP
5253 #else
5254 #define SEP ;
5255 ( name, flags )
5256  const char* name SEP
5257  const char* flags
5258 ;
5259 #undef SEP
5260 #endif
5261 { FILE* file;
5262  U_CHAR *str;
5263  file = NULL;
5264  if( *name == '~' ){
5265  if( HOME_DIR ){
5266  str = m_alloc(char, strlen((char *) HOME_DIR)+strlen(name));
5267  (IGNORED) sprintf(str,"%s%s", HOME_DIR, name+1);
5268  file = f_open(str,flags);
5269  free((void *) str);
5270  }
5271  } else { file = f_open( name, flags ); }
5272  return file;
5273 }
5274 
5275 
5276 
5277 
5278 
5279 static INTEGER put_4ht_ch
5280 #ifdef ANSI
5281 #define SEP ,
5282 ( int ch SEP FILE* htFile
5283 )
5284 #undef SEP
5285 #else
5286 #define SEP ;
5288 ;
5289 #undef SEP
5290 #endif
5291 {
5292  int c;
5293  c = ch;
5294  if( ch=='&' ){
5295 
5296 
5297 
5298 flush_uni();
5299 
5300 
5301  if( put_4ht_off ){
5302  c = putc( ch, htFile );
5303  } else {
5304  uni_code[0] = '&';
5305  uni_code_p = 1;
5306  put_4ht_file = htFile;
5307  }
5308  } else
5309  if( uni_code_p ){
5310  if( ch == ';' ){
5311 
5312 
5313 if( uni_code[1] != '#' ){
5314 
5315 
5316 
5317 flush_uni();
5318 
5319 
5320  (IGNORED) putc( ch, htFile );
5321 }
5322 else{
5323  int i, base, value, digit;
5324  if( (uni_code[2] == 'x') || (uni_code[2] == 'X') ){
5325  base =16; i=3;
5326  } else { base=10; i=2; }
5327  value = 0;
5328  for( ; i<uni_code_p; i++ ){
5329  digit = uni_code[i];
5330  if( (digit>='0') && (digit<='9') ){ digit -= '0'; }
5331  else if( (digit>='A') && (digit<='F') ){ digit -= BASE_A; }
5332  else if( (digit>='a') && (digit<='f') ){ digit -= BASE_a; }
5333  else { value = -1; break; }
5334  if( digit >= base ){ value=-1; break; }
5335  value = value*base + digit;
5336  }
5337  if( value<0 ){
5338 
5339 
5340 flush_uni();
5341 
5342 
5343  (IGNORED) putc( ch, htFile );
5344  } else {
5345 
5346 
5347 
5348  int bottom, mid, top;
5349  BOOL found=FALSE;
5350 bottom = 0; top = charset_n;
5351 while( !found ){
5352  mid = (bottom + top) / 2;
5353  if( value == charset[mid].ch ){
5354 
5355 
5356 
5357 { U_CHAR *p;
5358  p = charset[mid].str;
5359  while( *p != '\0' ){
5360  if( *p=='\\' ){
5361  p++;
5362  if( *p=='\\' ){
5363  (IGNORED) putc( '\\', htFile );
5364  } else {
5365  int i;
5366  i = *p - '0';
5367  while( *(++p) != '\\' ){ i = 10*i + *p - '0'; }
5368  (IGNORED) putc( i, htFile );
5369  } }
5370  else {
5371  (IGNORED) putc( *p, htFile );
5372  if ( (*p=='&') && u10 ){
5373 
5374 
5375 if ( *(p+1) == '#' ){
5376  p++;
5377  (IGNORED) putc( '#', htFile );
5378  if ( (*(p+1) == 'x') || (*(p+1) == 'X') ){
5379  int value, digit;
5380  U_CHAR *q;
5381  q = p+2;
5382  value = 0;
5383  digit = *(q++);
5384  while( digit!=0 ){
5385  if( (digit>='0') && (digit<='9') ){
5386  value = value*16 + digit - '0';
5387  }
5388  else if( (digit>='A') && (digit<='F') ){
5389  value = value*16 + digit - 'A'+10;
5390  }
5391  else if( (digit>='a') && (digit<='f') ){
5392  value = value*16 + digit - 'a'+10; }
5393  else {
5394  if( digit == ';' ){
5395 
5396 
5397 
5398  char uni_10[MAX_UNI_CODE];
5399  int n;
5400 n = 0;
5401 while( value>0 ){
5402  uni_10[ n++ ] = value % 10 + '0';
5403  value /= 10;
5404 }
5405 while( n>0 ){
5406  (IGNORED) putc( uni_10[--n], htFile );
5407 }
5408 
5409 
5410  p=q-2;
5411  }
5412  break;
5413  }
5414  digit = *(q++);
5415  }
5416 } }
5417 
5418  }
5419  }
5420  p++;
5421 } }
5422 
5423 
5424  found = TRUE;
5425  } else if( value < charset[mid].ch ){
5426  if( bottom == top ){ break; }
5427  top = mid;
5428  }
5429  else {
5430  if ( bottom < mid ){ bottom = mid; }
5431  else if ( bottom<top ){ bottom++; }
5432  else{ break; }
5433  }
5434 }
5435 if( ! found ){
5436  if( u10 || utf8 ){
5437 
5438 
5439  short n;
5440  long dec;
5441  int ch;
5442  char uni_10[MAX_UNI_CODE];
5443 if( (uni_code[2] == 'x') || (uni_code[2] == 'X') ) {
5444  dec = 0;
5445  for( n=3; n<uni_code_p; n++ ){
5446  ch = uni_code[n];
5447  dec = 16*dec +
5448  ((ch > '9')?
5449  ( 10 + ((ch > 'Z')? (ch-'a') : (ch-'A')) )
5450  : (ch-'0'));
5451  }
5452  if( u10 ){
5453 
5454 
5455  if( dec == 0 ){
5456  uni_code_p = 3; uni_code[2] = '0';
5457  } else {
5458  n = 0;
5459  while( dec > 0 ){ uni_10[ n++ ] = dec % 10 + '0'; dec /= 10; }
5460  uni_code_p = 2;
5461  while( n>0 ){ uni_code[ uni_code_p++ ] = uni_10[ --n ]; }
5462  }
5463 
5464  }
5465  else {
5466 
5467 
5468 
5469 
5470 
5471 if( dec < 0x80 ){
5472  uni_code_p = 1; uni_code[0] = dec;
5473 }
5474 else if( dec < 0x800 ){
5475  uni_code_p = 2;
5476  uni_code[0] = (dec >> 6) | 0xC0;
5477  uni_code[1] = (dec & 0x3F) | 0x80;
5478 }
5479 else if( dec < 0x10000 ){
5480  uni_code_p = 3;
5481  uni_code[0] = (dec >> 12) | 0xE0;
5482  uni_code[1] = ((dec >> 6) & 0x3F) | 0x80;
5483  uni_code[2] = (dec & 0x3F) | 0x80;
5484 }
5485 else if( dec < 0x200000 ){
5486  uni_code_p = 4;
5487  uni_code[0] = (dec >> 18) | 0xF0;
5488  uni_code[1] = ((dec >> 12) & 0x3F) | 0x80;
5489  uni_code[2] = ((dec >> 6) & 0x3F) | 0x80;
5490  uni_code[3] = (dec & 0x3F) | 0x80;
5491 }
5492 else if( dec < 0x4000000 ){
5493  uni_code_p = 5;
5494  uni_code[0] = (dec >> 24) | 0xF8;
5495  uni_code[1] = ((dec >> 18) & 0x3F) | 0x80;
5496  uni_code[2] = ((dec >> 12) & 0x3F) | 0x80;
5497  uni_code[3] = ((dec >> 6) & 0x3F) | 0x80;
5498  uni_code[4] = (dec & 0x3F) | 0x80;
5499 }
5500 else if( dec <= 0x7FFFFFFF ){
5501  uni_code_p = 6;
5502  uni_code[0] = (dec >> 30) | 0xFC;
5503  uni_code[1] = ((dec >> 24) & 0x3F) | 0x80;
5504  uni_code[2] = ((dec >> 18) & 0x3F) | 0x80;
5505  uni_code[3] = ((dec >> 12) & 0x3F) | 0x80;
5506  uni_code[4] = ((