src/texsourc/tex9.c

   1 #ifdef _WINDOWS
   2   #define NOCOMM
   3   #define NOSOUND
   4   #define NODRIVERS
   5   #define STRICT
   6   #pragma warning(disable:4115) // kill rpcasync.h complaint
   7   #include <windows.h>
   8   #define MYLIBAPI __declspec(dllexport)
   9 #endif
  10
  11 #include "texwin.h"
  12
  13 #pragma warning(disable:4996)
  14 #pragma warning(disable:4131) // old style declarator
  15 #pragma warning(disable:4135) // conversion between different integral types
  16 #pragma warning(disable:4127) // conditional expression is constant
  17
  18 #include <setjmp.h>
  19
  20 #define EXTERN extern
  21
  22 #include "texd.h"
  23
  24 #pragma warning(disable:4244)       /* 96/Jan/10 */
  25
  26 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
  27
  28 /* end of the old tex8.c */
  29 /* sec 1284 */
  30 void give_err_help (void)
  31 {
  32   token_show(eqtb[(hash_size + 1321)].hh.v.RH);
  33 }
  34 /* sec 0524 */
  35 bool open_fmt_file (void)
  36 {/* 40 10 */
  37   register bool Result;
  38   integer j;
  39   j = cur_input.loc_field;
  40 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
  41 /* For Windows NT, lets allow + instead of & for format specification */
  42 /* if (buffer[cur_input.loc_field]== 38) */  /* 95/Jan/22 */
  43   if (buffer[cur_input.loc_field]== '&' || buffer[cur_input.loc_field]== '+')
  44   {
  45 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
  46 /*  User specified a format name on the command line */
  47     incr(cur_input.loc_field);
  48     j = cur_input.loc_field;
  49     buffer[last]= 32;
  50     while (buffer[j]!= 32) incr(j);
  51     pack_buffered_name(0, cur_input.loc_field, j - 1);
  52     if (w_open_in(fmt_file))
  53       goto lab40;  // format file opened OK
  54
  55 //  format file open failed
  56   if (knuth_flag) {
  57     (void) sprintf(log_line, "%s;%s\n", "Sorry, I can't find that format", " will try the default.");
  58     show_line(log_line, 1);
  59   }
  60   else {
  61     char *s=log_line;
  62 /*    null_terminate (name_of_file + 1); */
  63     name_of_file[name_length + 1] = '\0';  /* null terminate */
  64     (void) sprintf(s, "%s (%s);%s\n", "Sorry, I can't find that format", name_of_file+1, " will try the default.");
  65 /*    space_terminate (name_of_file + 1); */
  66     name_of_file[name_length + 1] = ' '; /* space terminate */
  67     s += strlen(s);
  68     (void) sprintf(s, "(Perhaps your %s environment variable is not set correctly)\n", "TEXFORMATS");
  69     s += strlen(s);
  70     {
  71       char *t;            /* extra info 97/June/13 */
  72       if ((t = grabenv("TEXFORMATS")) != NULL) {
  73           sprintf(s, "(%s=%s)\n", "TEXFORMATS", t);
  74       } else {
  75         sprintf(s, "%s environment variable not set\n", "TEXFORMATS");
  76       }
  77     }
  78     show_line(log_line, 1); // show all three lines at once
  79   }
  80 #ifndef _WINDOWS
  81     fflush(stdout);
  82 #endif
  83   }
  84 /*  Try the default format (either because no format specified or failed) */
  85   pack_buffered_name(format_default_length - 4, 1, 0);
  86   if (! w_open_in(fmt_file))
  87   {
  88  ;
  89   if (knuth_flag) {
  90       (void) sprintf(log_line, "%s!\n", "I can't find the default format file");
  91       show_line(log_line, 1);
  92   } else {
  93     char *s=log_line;
  94 /*    null_terminate (name_of_file + 1); */
  95     name_of_file[name_length + 1] = '\0';  /* null terminate */
  96     (void) sprintf(s, "%s (%s)!\n", "I can't find the default format file", name_of_file + 1);
  97 /*    space_terminate (name_of_file + 1); */
  98     name_of_file[name_length + 1] = ' '; /* space terminate */
  99     s += strlen(s);
 100     (void) sprintf(s, "(Perhaps your %s environment variable is not set correctly)\n", "TEXFORMATS");
 101     s += strlen(s);
 102     {
 103       char *t;            /* extra info 97/June/13 */
 104       if ((t = grabenv("TEXFORMATS")) != NULL) {
 105         sprintf(s, "(%s=%s)\n", "TEXFORMATS", t);
 106       } else {
 107         sprintf(s, "%s environment variable not set\n", "TEXFORMATS");
 108       }
 109     }
 110     show_line(log_line, 1);   // show all three lines at once
 111   }
 112     Result = false;
 113     return(Result);
 114   }
 115   lab40: cur_input.loc_field = j;
 116   Result = true;
 117   return Result;
 118 }
 119 /**************************************************************************/
 120 void print_char_string (unsigned char *s)
 121 {
 122   // 2000 Jun 18
 123   while (*s > 0) print_char(*s++);
 124 }
 125 void show_font_info (void);   // now in local.c
 126 extern int closed_already;     // make sure we don't try this more than once
 127 /* The following needs access to zdvibuf of ALLOCATEDVIBUF 94/Mar/24 */
 128 /* done in closefilesandterminate_regmem  in coerce.h */
 129 /* sec 1333 */
 130 void close_files_and_terminate (void)
 131 {
 132   integer k;
 133
 134   if (closed_already++) {
 135     show_line("close_files_and_terminated already ", 0);
 136     return;     // sanity check
 137   }
 138   if (trace_flag) show_line("\nclose_files_and_terminate ", 0);
 139 //  close all open files
 140   {
 141     register integer for_end;
 142     k = 0;
 143     for_end = 15;        /* CHECK LIMIT */
 144     if (k <= for_end) do
 145       if (write_open[k]){
 146         (void) a_close(write_file[k]);
 147       }
 148     while(k++ < for_end);
 149   }
 150 ;
 151
 152 #ifdef STAT
 153 /* if tracing_stats>0 then @<Output statistics about this job@>; */
 154 /*  if (eqtb[(hash_size + 3194)].cint > 0) */
 155   if (eqtb[(hash_size + 3194)].cint > 0 ||
 156      verbose_flag != 0)  /* 93/Nov/30 - bkph */
 157   if (log_opened) {
 158 /*   used to output paragraph breaking statistics here */
 159     (void) fprintf(log_file, "%c\n", ' ');
 160     (void) fprintf(log_file, "\n");
 161     (void) fprintf(log_file, "%s%s\n", "Here is how much of TeX's memory", " you used:");
 162     (void) fprintf(log_file, "%c%ld%s", ' ', (long)str_ptr - init_str_ptr, " string");
 163     if (str_ptr != init_str_ptr + 1)
 164       (void) putc('s',  log_file);
 165 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 166 #ifdef ALLOCATESTRING
 167   if (show_current)
 168     (void) fprintf(log_file, "%s%ld\n", " out of ", (long) current_max_strings - init_str_ptr);
 169   else
 170 #endif
 171 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 172     (void) fprintf(log_file, "%s%ld\n", " out of ", (long) max_strings - init_str_ptr);
 173 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 174 #ifdef ALLOCATESTRING
 175   if (show_current)
 176     (void) fprintf(log_file, "%c%ld%s%ld\n", ' ', (long) pool_ptr - init_pool_ptr, " string characters out of ", (long) current_pool_size - init_pool_ptr);
 177   else
 178 #endif
 179 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 180     (void) fprintf(log_file, "%c%ld%s%ld\n", ' ', (long) pool_ptr - init_pool_ptr, " string characters out of ", (long) pool_size - init_pool_ptr);
 181 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 182 #ifdef ALLOCATEMAIN
 183   if (show_current)
 184     (void) fprintf(log_file, "%c%ld%s%ld\n", ' ', (long)lo_mem_max - mem_min + mem_end - hi_mem_min + 2, " words of memory out of ", (long)current_mem_size);
 185   else
 186 #endif
 187     (void) fprintf(log_file, "%c%ld%s%ld\n", ' ', (long)lo_mem_max - mem_min + mem_end - hi_mem_min + 2, " words of memory out of ", (long)mem_end + 1 - mem_min);
 188 /*  (void) fprintf(log_file, "%c%ld%s%ld\n", ' ', (long)lo_mem_max - mem_min + mem_end - hi_mem_min + 2, " words of memory out of ", (long)max_mem_size); */
 189 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 190     (void) fprintf(log_file, "%c%ld%s%ld\n", ' ', (long)cs_count, " multiletter control sequences out of ", (long)(hash_size + hash_extra));
 191     (void) fprintf(log_file, "%c%ld%s%ld%s", ' ', (long)fmem_ptr, " words of font info for ", (long)font_ptr - 0, " font");
 192     if (font_ptr != 1)
 193       (void) putc('s',  log_file);
 194 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 195 #ifdef ALLOCATEFONT
 196   if (show_current)
 197     (void) fprintf(log_file, "%s%ld%s%ld\n", ", out of ", (long)current_font_mem_size, " for ", (long)font_max - 0);
 198    else
 199 #endif
 200 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 201     (void) fprintf(log_file, "%s%ld%s%ld\n", ", out of ", (long)font_mem_size, " for ", (long)font_max - 0);
 202     (void) fprintf(log_file, "%c%ld%s", ' ', (long)hyph_count, " hyphenation exception");
 203     if (hyph_count != 1)
 204       (void) putc('s',  log_file);
 205 /*  (void) fprintf(log_file, "%s%ld\n",  " out of ", (long)607);  */
 206     (void) fprintf(log_file, "%s%ld\n",  " out of ", (long) hyphen_prime);
 207     (void) fprintf(log_file, " ");
 208     (void) fprintf(log_file, "%ld%s", (long)max_in_stack, "i,");
 209     (void) fprintf(log_file, "%ld%s", (long)max_nest_stack, "n,");
 210     (void) fprintf(log_file, "%ld%s", (long)max_param_stack, "p,");
 211     (void) fprintf(log_file, "%ld%s", (long)max_buf_stack + 1, "b,");
 212     (void) fprintf(log_file, "%ld%s", (long)max_save_stack + 6, "s");
 213     (void) fprintf(log_file, " stack positions out of ");
 214 #ifdef ALLOCATESAVESTACK
 215   if (show_current)
 216     (void) fprintf(log_file, "%ld%s", (long)current_stack_size, "i,");
 217   else
 218 #endif
 219     (void) fprintf(log_file, "%ld%s", (long)stack_size, "i,");
 220 #ifdef ALLOCATENESTSTACK
 221   if (show_current)
 222     (void) fprintf(log_file, "%ld%s", (long)current_nest_size, "n,");
 223   else
 224 #endif
 225     (void) fprintf(log_file, "%ld%s", (long)nest_size, "n,");
 226 #ifdef ALLOCATEPARAMSTACK
 227   if (show_current)
 228     (void) fprintf(log_file, "%ld%s", (long)current_param_size, "p,");
 229   else
 230 #endif
 231     (void) fprintf(log_file, "%ld%s", (long)param_size, "p,");
 232 #ifdef ALLOCATEBUFFER
 233   if (show_current)
 234     (void) fprintf(log_file, "%ld%s", (long)current_buf_size, "b,");
 235   else
 236 #endif
 237     (void) fprintf(log_file, "%ld%s", (long)buf_size, "b,");
 238 #ifdef ALLOCATESAVESTACK
 239   if (show_current)
 240     (void) fprintf(log_file, "%ld%s", (long)current_save_size, "s");
 241   else
 242 #endif
 243     (void) fprintf(log_file, "%ld%s", (long)save_size, "s");
 244   (void) fprintf(log_file, "\n");
 245 /************************************************************************/
 246   if (! knuth_flag)
 247     fprintf(log_file, " (i = in_stack, n = nest_stack, p = param_stack, b = buf_stack, s = save_stack)\n");
 248 /************************************************************************/
 249   if (! knuth_flag)          /* 1999/Jan/17 */
 250     fprintf(log_file,
 251         " %d inputs open max out of %d\n",  /* (%d max parens open) */
 252         high_in_open, max_in_open);             /* max_open_parens */
 253 /************************************************************************/
 254 /*  Modified 98/Jan/14 to leave out lines with zero counts */
 255   if (show_line_break_stats && first_pass_count > 0) {     /* 96/Feb/8 */
 256     int first_count, secondcount, thirdcount;
 257     (void) fprintf(log_file, "\nSuccess at breaking %d paragraph%s:", first_pass_count, (first_pass_count == 1) ? "" : "s");
 258     if (singleline > 0)
 259       (void) fprintf(log_file, "\n %d single line `paragraph%s'", singleline, (singleline == 1) ? "" : "s");  /* 96/Apr/23 */
 260     first_count = first_pass_count-singleline-second_pass_count;
 261     if (first_count < 0) first_count = 0;       /* sanity check */
 262     secondcount = second_pass_count-final_pass_count;
 263     thirdcount = final_pass_count-paragraph_failed;
 264     if (first_count != 0 || secondcount != 0 || thirdcount != 0)
 265       (void) fprintf(log_file, "\n %d first pass (\\pretolerance = %d)", first_count, eqtb[(hash_size + 3163)].cint);
 266     if (secondcount != 0 || thirdcount != 0)
 267       (void) fprintf(log_file, "\n %d second pass (\\tolerance = %d)", secondcount, eqtb[(hash_size + 3164)].cint);
 268     if (final_pass_count > 0 || eqtb[(hash_size + 3750)].cint  > 0) {
 269       (void) fprintf(log_file, "\n %d third pass (\\emergencystretch = %lgpt)", thirdcount, (double) eqtb[(hash_size + 3750)].cint / 65536.0);
 270 /*      above converted from scaled points to printer's points */
 271     }
 272     if (paragraph_failed > 0)
 273       (void) fprintf(log_file, "\n %d failed", paragraph_failed);
 274     (void) putc('\n', log_file);
 275     if (overfull_hbox > 0)
 276       (void) fprintf(log_file, "\n %d overfull \\hbox%s", overfull_hbox, (overfull_hbox > 1) ? "es" : "");
 277     if (underfull_hbox > 0)
 278       (void) fprintf(log_file, "\n %d underfull \\hbox%s", underfull_hbox, (underfull_hbox > 1) ? "es" : "");
 279     if (overfull_vbox > 0)
 280       (void) fprintf(log_file, "\n %d overfull \\vbox%s", overfull_vbox, (overfull_vbox > 1) ? "es" : "");
 281     if (underfull_vbox > 0)
 282       (void) fprintf(log_file, "\n %d underfull \\vbox%s", underfull_vbox, (underfull_vbox > 1) ? "es" : "");
 283     if (overfull_hbox || underfull_hbox || overfull_vbox || underfull_vbox)
 284       (void) putc('\n', log_file);
 285   }
 286 /************************************************************************/
 287   } /* end of if (log_opened) */
 288 #endif /* STAT */
 289   while(cur_s > -1){
 290     if (cur_s > 0){
 291       dvi_buf[dvi_ptr]= 142;
 292       incr(dvi_ptr);
 293       if (dvi_ptr == dvi_limit)dvi_swap();
 294     }
 295     else {
 296       {
 297       dvi_buf[dvi_ptr]= 140;
 298       incr(dvi_ptr);
 299       if (dvi_ptr == dvi_limit)dvi_swap();
 300       }
 301       incr(total_pages);
 302     }
 303     decr(cur_s);
 304   }
 305
 306   if (total_pages == 0) print_nl("No pages of output.");  /*  */
 307   else {
 308     {
 309     dvi_buf[dvi_ptr]= 248;   /* post - start of postamble */
 310     incr(dvi_ptr);
 311     if (dvi_ptr == dvi_limit)dvi_swap();
 312   }
 313     dvi_four(last_bop);
 314     last_bop = dvi_offset + dvi_ptr - 5;
 315     dvi_four(25400000L);     /* magic DVI scale factor */
 316     dvi_four(473628672L);    /* 7227 * 65536 */
 317     prepare_mag();         /* in tex2.c */
 318     dvi_four(eqtb[(hash_size + 3180)].cint);   /* mag */
 319     dvi_four(max_v);        /* max height + depth */
 320     dvi_four(max_h);        /* max width */
 321     {
 322     dvi_buf[dvi_ptr]= max_push / 256;
 323     incr(dvi_ptr);
 324     if (dvi_ptr == dvi_limit)dvi_swap();
 325     }
 326     {
 327     dvi_buf[dvi_ptr]= max_push % 256;
 328     incr(dvi_ptr);
 329     if (dvi_ptr == dvi_limit)dvi_swap();
 330     }
 331   if (total_pages >= 65536) {    // 99/Oct/10 dvi_t 16 bit problem
 332     sprintf(
 333         log_line,
 334         "\nWARNING: page count (dvi_t) in DVI file will be %ld not %ld\n",
 335         (total_pages % 65536),
 336         total_pages);
 337     if (log_opened) fputs (log_line, log_file);
 338     show_line(log_line, 1);
 339   }
 340     {
 341     dvi_buf[dvi_ptr]=(total_pages / 256)% 256;
 342     incr(dvi_ptr);
 343     if (dvi_ptr == dvi_limit)dvi_swap();
 344     }
 345     {
 346     dvi_buf[dvi_ptr]= total_pages % 256;
 347     incr(dvi_ptr);
 348     if (dvi_ptr == dvi_limit) dvi_swap();
 349     }
 350
 351   if (show_fonts_used && log_opened)     /* 97/Dec/24 */
 352     show_font_info();           // now in local.c
 353
 354     while(font_ptr > 0){
 355     if (font_used[font_ptr])dvi_font_def(font_ptr);
 356     decr(font_ptr);
 357     }
 358     {
 359     dvi_buf[dvi_ptr]= 249;   /* post_post end of postamble */
 360     incr(dvi_ptr);
 361     if (dvi_ptr == dvi_limit)dvi_swap();
 362     }
 363     dvi_four(last_bop);
 364     {
 365     dvi_buf[dvi_ptr]= 2;
 366     incr(dvi_ptr);
 367     if (dvi_ptr == dvi_limit)dvi_swap();
 368     }
 369     k = 4 +((dvi_buf_size - dvi_ptr)% 4);
 370     while(k > 0){
 371       {
 372       dvi_buf[dvi_ptr]= 223; /* four to seven bytes of 223 */
 373       incr(dvi_ptr);
 374       if (dvi_ptr == dvi_limit)dvi_swap();
 375     }
 376     decr(k);
 377     }
 378 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 379   if (trace_flag) {          /* 93/Dec/28 - bkph */
 380     sprintf(log_line, "\ndviwrite %d", dvi_gone);
 381     show_line(log_line, 0);
 382   }
 383 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 384     if (dvi_limit == half_buf)writedvi(half_buf, dvi_buf_size - 1);
 385     if (dvi_ptr > 0)writedvi(0, dvi_ptr - 1);
 386     print_nl("Output written on ");
 387         if (full_file_name_flag && dvi_file_name != NULL)
 388                 print_char_string((unsigned char *) dvi_file_name);
 389         else
 390                 slow_print(output_file_name);
 391     print_string(" (");
 392     print_int(total_pages);
 393     print_string(" page");
 394     if (total_pages != 1) print_char('s');
 395     print_string(", ");
 396     print_int(dvi_offset + dvi_ptr);
 397     print_string(" bytes).");
 398     b_close(dvi_file);
 399   }
 400   if (log_opened) {
 401     (void) putc ('\n', log_file);
 402     (void) a_close(log_file);
 403     selector = selector - 2;
 404     if (selector == 17) {
 405     print_nl("Transcript written on ");
 406     if (full_file_name_flag && log_file_name != NULL)
 407                 print_char_string((unsigned char *) log_file_name);
 408     else
 409                 slow_print(texmf_log_name);
 410     print_char('.');
 411     }
 412   }
 413   print_ln();
 414   if ((edit_name_start != 0) && (interaction > 0)) {
 415     call_edit(str_pool, edit_name_start, edit_name_length, edit_line);
 416   }
 417 } /* end of close_files_and_terminate */
 418 #ifdef DEBUG
 419 /* sec 1338 */
 420 void debug_help (void)
 421 {/* 888 10 */
 422   integer k, l, m, n;
 423   while(true){
 424  ;
 425     print_nl(" debug # (-1 to exit):");  /*  */
 426 #ifndef _WINDOWS
 427     fflush(stdout);
 428 #endif
 429     read(stdin, m);  // ???
 430     if (m < 0)return;
 431     else if (m == 0)
 432     dumpcore();
 433     else {
 434       read(stdin, n);  // ???
 435       switch(m)
 436       {case 1 :
 437   print_word(mem[n]);
 438   break;
 439       case 2 :
 440   print_int(mem[n].hh.v.LH);
 441   break;
 442       case 3 :
 443   print_int(mem[n].hh.v.RH);
 444   break;
 445       case 4 :
 446   print_word(eqtb[n]);
 447   break;
 448       case 5 :
 449 #ifdef SHORTFONTINFO
 450   print_scaled(font_info[n].sc);  print_char(' ');
 451   print_int(font_info[n].qqq.b0);  print_char(':');
 452   print_int(font_info[n].qqq.b1);  print_char(':');
 453   print_int(font_info[n].qqq.b2);  print_char(':');
 454   print_int(font_info[n].qqq.b3);
 455 #else
 456   print_word(font_info[n]);
 457 #endif
 458   break;
 459       case 6 :
 460   print_word(save_stack[n]);
 461   break;
 462       case 7 :
 463   show_box(n);
 464   break;
 465       case 8 :
 466   {
 467     breadth_max = 10000;
 468 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 469 #ifdef ALLOCATESTRING
 470 /* About to output node list make some space in string pool 97/Mar/9 */
 471   if (pool_ptr + 32000 > current_pool_size)
 472     str_pool = realloc_str_pool (increment_pool_size);
 473 /* We don't bother to check whether this worked */
 474 #endif
 475 #ifdef ALLOCATESTRING
 476     depth_threshold = current_pool_size - pool_ptr - 10;
 477 #else
 478 /* *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** */
 479     depth_threshold = pool_size - pool_ptr - 10;
 480 #endif
 481     show_node_list(n);
 482   }
 483   break;
 484       case 9 :
 485   show_token_list(n, 0, 1000);
 486   break;
 487       case 10 :
 488   slow_print(n);
 489   break;
 490       case 11 :
 491   check_mem(n > 0);
 492   break;
 493       case 12 :
 494   search_mem(n);
 495   break;
 496       case 13 :
 497   {
 498     read(stdin, l);  // ???
 499     print_cmd_chr(n, l);
 500   }
 501   break;
 502       case 14 :
 503   {
 504     register integer for_end;
 505     k = 0;
 506     for_end = n;
 507     if (k <= for_end)
 508       do print(buffer[k]);
 509     while(k++ < for_end);
 510   }
 511   break;
 512       case 15 :
 513   {
 514     font_in_short_display = 0;
 515     short_display(n);
 516   }
 517   break;
 518       case 16 :
 519   panicking = ! panicking;
 520   break;
 521   default:
 522   print(63);    /* ? */
 523   break;
 524       }
 525     }
 526   }
 527 }
 528 #endif /* DEBUG */