home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / dump.c < prev    next >
C/C++ Source or Header  |  1993-10-11  |  36KB  |  1,405 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. /* Zeige benoetigte Zeit (Debug only) */
  5. #undef TIME
  6.  
  7.  
  8. #if defined(TIME) && defined(AMIGA)
  9. # include <time.h>
  10. #endif
  11.  
  12. /* Nur in Vielfachen von 4 dumpen...
  13.  * dies trifft hauptsaechlich fuer den String Pool zu.
  14.  * ==> Lesen der nachfolgenden Arrays aus dem fmt-file muss nicht von
  15.  *     ungeraden Adressen auf ungerade Adressen kopiert werden.
  16.  * ==> Lesen wird (hoffentlich) schneller.
  17.  */
  18. #define ROUND_FOUR(x)    (((x) + 3) & ~3L)
  19.  
  20.  
  21. /* Stringlaengenkomprimierung ?? (War in alter Version fehlerhaft!) */
  22. #define NEW_STRING
  23.  
  24.  
  25. /* CheckSum fuer fmt-file: (original @$ war: 127541235) */
  26. /* oberstes Wort besteht aus festem Teil: */
  27. #define FMT_CHECK    0x62720000L        /* "br" */
  28.  
  29. /* unterstes Wort ist eigentliches Magic Word: */
  30. #define CHECK_MASK    0xffffL
  31.  
  32. #define BIGTEX_FLAG    0x0080L
  33.  
  34. /* Release  16.Dezember 90 */
  35. /* besteht aus Datum: 1990 = 0, dez = c, 16. = 10 plus BIGTEX_FLAG */
  36. #if 0
  37. #define BIGFMT        0x0c90L
  38. #define NORMALFMT    0x0c10L
  39. #endif
  40.  
  41. /* Release  23.Juni 91:  (Werte sollen groesser sein als vorherige Version) */
  42. #if 0
  43. #define BIGFMT        0x1690L
  44. #define NORMALFMT    0x1610L
  45. #endif
  46.  
  47. /* Release  11. Oktober 93: */
  48. #define BIGFMT        0x3a8bL
  49. #define NORMALFMT    0x3a0bL
  50.  
  51.  
  52. /* For additional features, we mark the next long with a '+' and
  53.  * set 2 bit for each feature in the next 3 bytes (= 12 possible features ;-)
  54.  */
  55. /* For ML-TeX, we mark the second long in an fmt-file (normally membot-value)
  56.  * This is necessary, because eqtb has additional 256 + 3 mem_words.
  57.  * In the near future the dumping/undumping of eqtb should be modified to
  58.  * cover these changes.
  59.  */
  60. #define ADDITIONAL    0x2b000000L    /* '+\0\0\0' */
  61. #define MLTEXCHECK    0x0001L        /* features enabled */
  62. #define ADD_MLTEX    0x800000L    /* compiled with this feature? */
  63. #define TEXXETCHECK    0x0002L
  64. #define ADD_TEXXET    0x400000L
  65.  
  66. /* Beim Dumpen des `eqtb'-Arrays wird zwar versucht moeglichst platzsparend
  67.  * zu sein, indem jeweils ungleiche und gleiche Bereiche mit 2 Laengenangaben
  68.  * (n,m) gedumpt werden.  Jedoch wird sehr oft ein sehr kleiner Bereich (mit
  69.  * Laenge n=2 und kleinem m) gedumpt und die Platzersparnis wird durch die
  70.  * beiden Laengen wieder zunichte gemacht.
  71.  * Deshalb erst Dumpen, wenn `m' > EQTB_THRESHOLD.
  72.  * Am Undumpen aendert sich dabei nichts.
  73.  */
  74. #define EQTB_THRESHOLD    1
  75.  
  76.  
  77. /* Meine eigenen Routinen zum Dumpen und Undumpen. */
  78. /* Bei den kleinen Datentypen (char, short) sollte man beim Dumpen
  79.  * noch nachpruefen, ob sie ueberhaupt im Bereich liegen !
  80.  * (Sie sollten es eigentlich, aber besser ist besser)
  81.  * !!!! hash[] sollte genauso gross sein wie ein int !!!!
  82.  */
  83.  
  84. #undef dumpint
  85. #undef undumpint
  86.  
  87. #define dumpchar(x)    (void) putc((char) (x), dump_file);
  88. #define undumpchar(x)    (x) = getc(dump_file);
  89.  
  90. #define dumpshort(x)    my_putw((short) (x));
  91. #define undumpshort(x)    (x) = my_getw()
  92.  
  93. #define dumpint(x)     my_putl((long) (x))
  94. #define undumpint(x)    (x) = my_getl()
  95.  
  96. #undef dumphh
  97. #undef undumphh
  98. #define dumphh(x)     my_putl( *((long *) &(x)) )
  99. #define undumphh(x)    *((long *) &(x)) = my_getl()
  100.  
  101.  
  102. #ifdef INITEX
  103.   static void
  104. my_putw(short c)
  105. {
  106.   union {        /* sizeof(short) == 2 !! */
  107.     char part[2];
  108.     short n;
  109.   } x;
  110.  
  111.   x.n = c;
  112.  
  113.   (void) fputc(x.part[0], dump_file);
  114.   (void) fputc(x.part[1], dump_file);
  115. }
  116.  
  117.   static void
  118. my_putl(long c)
  119. {
  120.   union {        /* sizeof(long) == 4 !! */
  121.     char part[4];
  122.     long n;
  123.   } x;
  124.  
  125.   x.n = c;
  126.  
  127.   (void) fputc(x.part[0], dump_file);
  128.   (void) fputc(x.part[1], dump_file);
  129.   (void) fputc(x.part[2], dump_file);
  130.   (void) fputc(x.part[3], dump_file);
  131. }
  132. #endif
  133.  
  134.  
  135.   static short
  136. my_getw(void)
  137. {
  138.   register FILE *fp = dump_file;
  139.   short c;
  140.   union {
  141.     char part[2];
  142.     short n;
  143.   } x;
  144.  
  145.   if((c = getc(fp)) == EOF)
  146.     return(EOF);
  147.   x.part[0] = c;    /* n = (c << 8); */
  148.   if((c = getc(fp)) == EOF)
  149.     return(EOF);
  150.   x.part[1] = c;    /*  n |= (c & 0xFF);  n <<= 16; */
  151.  
  152.   return x.n;
  153. }
  154.  
  155.  
  156.   static long
  157. my_getl(void)
  158. {
  159.   register FILE *fp = dump_file;
  160.   short c;
  161.   union {
  162.     char part[4];
  163.     long n;
  164.   } x;
  165.  
  166.   if((c = getc(fp)) == EOF)
  167.     return(EOF);
  168.   x.part[0] = c;  /* n = (c << 8); */
  169.   if((c = getc(fp)) == EOF)
  170.     return(EOF);
  171.   x.part[1] = c;  /*  n |= (c & 0xFF);  n <<= 16; */
  172.  
  173.   if((c = getc(fp)) == EOF)
  174.     return(EOF);
  175.   x.part[2] = c;  /*  n |= ((c & 0xFF) << 8); */
  176.   if((c = getc(fp)) == EOF)
  177.     return(EOF);
  178.   x.part[3] = c;  /*  n |= (c & 0xFF); */
  179.  
  180.   return x.n;
  181. }
  182.  
  183.  
  184.  
  185. #ifdef INITEX
  186. void storefmtfile ( void )
  187. {/* 41 42 31 32 */ storefmtfile_regmem 
  188.   register integer j, k, l;
  189.   register halfword p, q;
  190.   register integer x;
  191.  
  192.   /* (br) Dumpe moeglichst viel auf einmal, deshalb ... */
  193.   long morethings[20];
  194.   long hash_low_count;
  195.  
  196.   if ( saveptr != 0 ) {
  197.     print_err("You can't dump inside a group");
  198.     zhelp1( STR_H_DUMPISANONO );
  199.     succumb ();
  200.   }
  201.   selector = newstring;
  202.   c_print(" (format=");  print( jobname );  printchar( 32 );
  203.   printint( zyear % 100 );  printchar( 46 );  printint( zmonth );
  204.   printchar( 46 );  printint( zday );  printchar( 41 );
  205.   if ( interaction <= batchmode )
  206.     selector = logonly;
  207.   else
  208.     selector = termandlog;
  209.   strroom(1);
  210.   formatident = makestring();
  211.   packjobname( STR_DOT_FMT );
  212.   while ( ! wopenout(fmtfile) )
  213.     promptfilename("format file name", STR_DOT_FMT);
  214.   c_printnl("Beginning to dump on file ");
  215. #if 0  /* TeX 3.141 */
  216.   print ( wmakenamestring ( fmtfile ) );
  217.   flushstring ;
  218.   printnl ( formatident );
  219. #else
  220.   slowprint ( wmakenamestring ( fmtfile ) );
  221.   flushstring ;
  222.   c_printnl ("");  slowprint ( formatident );
  223. #endif
  224.  
  225.   /* Dump the dynamic memory 1311 (I) */
  226.   /* Call sort_avail() before the dump, because it changes rover,... */
  227.   sortavail () ; 
  228.  
  229.   /* Dump constants for consistency checking 1307 */
  230.  
  231.   /* (br) ... Irgendwas magisches ;-) als erstes Wort */
  232. #ifdef BIG
  233.   morethings[0] = (FMT_CHECK | NORMALFMT | BIGTEX_FLAG);
  234. #else
  235.   morethings[0] = (FMT_CHECK | NORMALFMT);
  236. #endif
  237.  
  238. #if defined(MLTEX) && defined(TEXXET)
  239.   /* Mark this fmt-file only for ML-TeX & TEX--XET*/
  240.   morethings[1] = ADDITIONAL | ADD_MLTEX | ADD_TEXXET;
  241.   morethings[1] |= (( is_ML_TeX ) ? MLTEXCHECK : 0L);
  242.   morethings[1] |= (( is_TeX_XeT ) ? TEXXETCHECK : 0L);
  243. #else
  244. # ifdef MLTEX
  245.   morethings[1] = ADDITIONAL | ADD_MLTEX;
  246.   morethings[1] |= (( is_ML_TeX ) ? MLTEXCHECK : 0L);
  247. # endif
  248. # ifdef TEXXET
  249.   morethings[1] = ADDITIONAL | ADD_TEXXET;
  250.   morethings[1] |= (( is_TeX_XeT ) ? TEXXETCHECK : 0L);
  251. # endif
  252. # if !defined(MLTEX) && !defined(TEXXET)
  253.   morethings[1] = membot;    /* membot == 0,  forever... ??? */
  254. # endif
  255. #endif
  256.   morethings[2] = memtop;
  257.   morethings[3] = eqtbsize;        /* ist von ML-TEX abhaengig */
  258.   morethings[4] = hashprime;
  259.   morethings[5] = hyphsize;
  260.  
  261.   /* Dump the string pool 1309 (I) */
  262.   morethings[6] = poolptr;
  263.   morethings[7] = strptr;
  264.  
  265.   /* Dump the dynamic memory 1311 (II) */
  266.   morethings[8] = lomemmax;
  267.   morethings[9] = rover;
  268.   morethings[10] = himemmin;
  269.   morethings[11] = avail;
  270.  
  271.   /* Dump the table of equivalents 1313 (I) */
  272.   morethings[12] = parloc;
  273.   morethings[13] = writeloc;
  274.  
  275.   /* Dump the hash table 1318 (I) */
  276.   morethings[14] = hashused;
  277.   cscount = frozencontrolsequence - 1 - hashused ; 
  278.   hash_low_count = 0;
  279.   for( p = hashbase ; p <= hashused ; p++ ) {
  280.     if ( ztext ( p ) != 0 ) {
  281.     incr(hash_low_count);
  282.     incr ( cscount ) ; 
  283.     }
  284.   }
  285.   morethings[15] = cscount;
  286.   morethings[16] = hash_low_count;    /* merken, wie voll Hashtabelle */
  287. #ifndef NEW_STRING
  288.   dumpthings(morethings[0], 17);
  289.  
  290.   /* Dump the string pool 1309 (II) */
  291.   dumpthings( strstart[0], strptr + 1 );
  292. #else
  293.   /* Typically the most strings have length < 255;
  294.    * and strstart[i] <= strstart[j] for all i,j with i < j
  295.    * => dump only strstart[] differences.
  296.    */
  297.   { unsigned char *buf;
  298.     unsigned char *src;
  299.  
  300.     k = strstart[0];
  301.     buf = (unsigned char *)&strstart[1];
  302.     for(j = 1 ; j < strptr+1 ; j++) {
  303.     l = strstart[j] - k;    /* save only differences */
  304.     if( l >= 255 ) {
  305.       *buf++ = 255;        /* flag: strlen >= 255 */
  306.       *buf++ = l / 256;
  307.       *buf++ = l % 256;
  308.     } else {
  309.       *buf++ = (unsigned char) l;
  310.     }
  311.     k = strstart[j];
  312.     }
  313.  
  314.  
  315.     k = buf - (unsigned char *)&strstart[0];
  316.     /* `k' aufrunden auf Vielfaches von 4 */
  317.     j = (4 - (k % 4)) % 4;
  318.     while ( j > 0 ) {
  319.     *buf++ = 0;    /* Mit Nullen auffuellen */
  320.     k++;        /* k entsprechend anpassen */
  321.     j--;
  322.     }
  323.     buf =  (unsigned char *)&strstart[0];
  324.  
  325.     morethings[17] = k;
  326.     dumpthings(morethings[0], 18);
  327.  
  328.     dumpthings(buf[0], k);
  329.  
  330.     /* Restore the strstart[] array, it's needed.
  331.      * A better solution: Dump strings at end.
  332.      */
  333.     src = &buf[(maxstrings * sizeof(poolpointer)) - k];
  334.     memcpy(src, &strstart[1], k);
  335.  
  336.     k = strstart[0];
  337.     for(j = 1 ; j < strptr + 1 ; j++ ) {
  338.     l = (integer) *src++;
  339.     if( l == 255 ) {
  340.       l = (integer) ((unsigned)((*src++) << 8));
  341.       l += ((unsigned)*src++);
  342.     }
  343.     k += l;
  344.     strstart[j] = k;
  345.     }
  346.  
  347.     if( strstart[strptr] != poolptr )
  348.     printf("!! Internal Error (String Pool Inconsistent [%d]) !!\n", 1);
  349.   }
  350. #endif
  351.   /* Nur in Vielfachen von 4 dumpen */
  352.   dumpthings( strpool[0], ROUND_FOUR(poolptr) );
  353.  
  354.   dumpthings(xord[0], 256);
  355.   dumpthings(xchr[0], 256);
  356. #ifdef ERW_CODEPAGE
  357.   dumpthings(printable[0], 256);
  358. #endif
  359.  
  360.   println();
  361.   printint( strptr );
  362.   c_print(" strings of total length ");
  363.   printint( poolptr );
  364.  
  365.   /* Dump the dynamic memory 1311 (III) */
  366.   varused = 0 ; 
  367.  
  368.   p = membot;
  369.   q = rover ; 
  370.   x = 0 ; 
  371.   do {
  372. #ifdef TIME
  373. printf("dump dynmem: len=%d, next_gap=%d\n", q+2-p, mem[q].hh.v.LH );
  374. #endif
  375.     dumpthings ( mem[p], q + 2 - p );
  376.     x = x + q + 2 - p;
  377.     varused = varused + q - p;
  378.     p = q + nodesize ( q );
  379.     q = rlink ( q );
  380.   } while ( ! ( q == rover ) );
  381.   varused = varused + lomemmax - p;
  382.   dynused = memend + 1 - himemmin;
  383. #ifdef TIME
  384. printf("dump dynmem: len=%d, last\n", lomemmax+1-p);
  385. #endif
  386.   dumpthings ( mem[p], lomemmax + 1 - p );
  387.   x = x + lomemmax + 1 - p;
  388.  
  389.   dumpthings ( mem[himemmin], memend + 1 - himemmin );
  390.   x = x + memend + 1 - himemmin;
  391.   p = avail;
  392.   while ( p != 0 ) {
  393.     decr ( dynused );
  394.     p = link ( p );
  395.   }
  396.  
  397.   morethings[0] = varused;
  398.   morethings[1] = dynused;
  399.  
  400.   println();
  401.   printint( x );
  402.   c_print(" memory locations dumped; current usage is ");
  403.   printint( varused );  printchar( 38 );  printint( dynused );
  404.  
  405.   /* Dump the font information 1320 (I) */
  406.   morethings[2] = fmemptr;
  407.   morethings[3] = fontptr;
  408.  
  409.   /* Dump the hyphenation table 1324 (I) */
  410.   morethings[4] = hyphcount;
  411.  
  412.   dumpthings(morethings[0], 5);
  413.  
  414.  
  415. /* Fuer ML-TeX ohne Benutzung von \charsubdef sollte man Bereich von
  416.  * char_sub_base ... char_sub_base + 256  aussparen
  417.  */
  418.  
  419.   /* Dump the table of equivalents 1313,1315,1316,1318 (II) */
  420.   k = activebase ;
  421.   do {
  422.     j = k;
  423.  
  424. too_short:
  425.     while( j < intbase - 1 ) {
  426.       if( (equiv(j) == equiv(j+1)) && (eqtype(j) == eqtype(j+1))
  427.      && (eqlevel(j) == eqlevel(j+1)) )
  428.     goto lab41;
  429.       incr ( j );
  430.     } 
  431.     l = intbase;
  432.     goto lab31;
  433.  
  434. lab41:
  435.     incr ( j );
  436.     l = j;
  437.     while( j < intbase - 1 ) {
  438.       if ( (equiv(j) != equiv(j+1)) || (eqtype(j) != eqtype(j+1))
  439.      || (eqlevel(j) != eqlevel(j+1)) )
  440.     goto lab31;
  441.       incr ( j );
  442.     }
  443. lab31:
  444.     /* Falls wir nicht am Ende sind, und m nicht gross genug, nochmal */
  445.     if( l < intbase  &&  (j+1-l) <= EQTB_THRESHOLD ) {
  446. #ifdef TIME
  447. printf("dump eqtb1-4: len=%d, gap_len=%d  not\n", l-k, j+1-l);
  448. #endif
  449.     goto too_short;
  450.     }
  451.     dumpshort ( l - k );
  452. #ifdef TIME
  453. printf("dump eqtb1-4: len=%d, eq_len=%d\n", l-k, j+1-l);
  454. #endif
  455.     dumpthings ( eqtb[k], l - k );
  456.     k = j + 1 ; 
  457.     dumpshort ( k - l );
  458.   } while ( k != intbase );
  459.  
  460.   do {
  461.     j = k;
  462. too_short2:
  463.     while ( j < eqtbsize ) {
  464.       if( eqtb[j].cint == eqtb[j+1].cint ) 
  465.     goto lab42;
  466.       incr ( j );
  467.     } 
  468.     l = eqtbsize + 1 ;
  469.     goto lab32;
  470.  
  471. lab42:
  472.     incr ( j );
  473.     l = j;
  474.     while( j < eqtbsize ) {
  475.       if( eqtb[j].cint != eqtb[j+1].cint )
  476.     goto lab32;
  477.       incr ( j );
  478.     }
  479. lab32:
  480.     /* Falls wir nicht am Ende sind, und m nicht gross genug, nochmal */
  481.     if( l < eqtbsize + 1  &&  (j+1-l) <= EQTB_THRESHOLD ) {
  482. #ifdef TIME
  483. printf("dump eqtb5-6: len=%d, gap_len=%d  not\n", l-k, j+1-l);
  484. #endif
  485.     goto too_short2;
  486.     }
  487.     dumpshort ( l - k );
  488. #ifdef TIME
  489. printf("dump eqtb5-6: len=%d, eq_len=%d\n", l-k, j+1-l);
  490. #endif
  491.     dumpthings ( eqtb[k], l - k );
  492.     k = j + 1;
  493.     dumpshort ( k - l );
  494.   } while ( k <= eqtbsize );
  495.  
  496.   /* Dump the hash table 1318 (II) */
  497.   { long anzahl = 0;
  498.     for( p = hashbase ; p <= hashused ; p++ ) {
  499.       if ( ztext ( p ) != 0 ) {
  500.     incr(anzahl);
  501.         dumpshort ( p );
  502.       }
  503.     }
  504.     if( hash_low_count != anzahl )
  505.     printf("!! Internal error (Hash Table Inconsistent) !!\n");
  506.     anzahl = 0;
  507.     for( p = hashbase ;  p <= hashused ; p++ ) {
  508.       if ( ztext ( p ) != 0 ) {
  509.     incr(anzahl);
  510. #ifdef BIG
  511.     (void) fwrite( (char *)&hash[p], sizeof(hash[p]), 1, dump_file );
  512. #else
  513.         dumphh ( hash[p] );
  514. #endif
  515.       }
  516.     }
  517.     if( hash_low_count != anzahl )
  518.     printf("!! Internal error (Hash Table Inconsistent) !!\n");
  519.   }
  520.             /* v-- LC BUG */
  521.   dumpthings ( hash[(hashused + 1)], undefinedcontrolsequence - 1 - hashused );
  522.   println();
  523.   printint( cscount );
  524.   c_print(" multiletter control sequences");
  525.  
  526. #ifdef FONTPTR
  527.   /* ...base[] are C pointers in fontinfo[]; dump only "difference" */
  528.   for( p = nullfont ; p <= fontptr ; p++ ) {
  529.     charbase(p)    = (SMALLmemoryword *) (charbase(p)   - &fontinfo[0]);
  530.     widthbase(p)   = (SMALLmemoryword *) (widthbase(p)  - &fontinfo[0]);
  531.     heightbase(p)  = (SMALLmemoryword *) (heightbase(p) - &fontinfo[0]);
  532.     depthbase(p)   = (SMALLmemoryword *) (depthbase(p)  - &fontinfo[0]);
  533.     italicbase(p)  = (SMALLmemoryword *) (italicbase(p) - &fontinfo[0]);
  534.     ligkernbase(p) = (SMALLmemoryword *) (ligkernbase(p) - &fontinfo[0]);
  535.     kernbase(p)    = (SMALLmemoryword *) (kernbase(p)   - &fontinfo[0]);
  536.   }
  537. #endif
  538.  
  539.   /* Dump the font information 1320,1322 (II) */
  540.   {
  541.     dumpthings ( fontinfo [ nullfont ] , fmemptr ) ; 
  542.     dumpthings ( fontsize(nullfont), fontptr + 1 - nullfont ) ; 
  543.     dumpthings ( fontdsize(nullfont), fontptr + 1 - nullfont ) ; 
  544.     dumpthings ( fontname(nullfont), fontptr + 1 - nullfont ) ; 
  545.     dumpthings ( fontarea(nullfont), fontptr + 1 - nullfont ) ;
  546.  
  547. #ifdef FONTSTRUCT
  548.     dumpthings(fontdesc[nullfont], fontptr + 1 - nullfont);
  549. #else
  550.     dumpthings ( fontcheck(nullfont), fontptr + 1 - nullfont ) ; 
  551.     dumpthings ( fontparams(nullfont), fontptr + 1 - nullfont ) ; 
  552.     dumpthings ( hyphenchar(nullfont), fontptr + 1 - nullfont ) ; 
  553.     dumpthings ( skewchar(nullfont), fontptr + 1 - nullfont ) ; 
  554. #ifdef FONTPTR
  555.     dumpthings ( font_bcec[nullfont], fontptr + 1 - nullfont );
  556. #else
  557.     dumpthings ( fontbc[nullfont], fontptr + 1 - nullfont );
  558.     dumpthings ( fontec[nullfont], fontptr + 1 - nullfont ); 
  559. #endif
  560.     dumpthings ( charbase(nullfont), fontptr + 1 - nullfont ) ; 
  561.     dumpthings ( widthbase(nullfont), fontptr + 1 - nullfont ) ; 
  562.     dumpthings ( heightbase(nullfont), fontptr + 1 - nullfont ) ; 
  563.     dumpthings ( depthbase(nullfont), fontptr + 1 - nullfont ) ; 
  564.     dumpthings ( italicbase(nullfont), fontptr + 1 - nullfont ) ; 
  565.     dumpthings ( ligkernbase(nullfont), fontptr + 1 - nullfont ) ; 
  566.     dumpthings ( kernbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  567.     dumpthings ( extenbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  568.     dumpthings ( parambase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  569.     dumpthings ( fontglue [ nullfont ] , fontptr + 1 - nullfont ) ; 
  570.     dumpthings ( bcharlabel [ nullfont ] , fontptr + 1 - nullfont ) ; 
  571.     dumpthings ( fontbchar [ nullfont ] , fontptr + 1 - nullfont ) ; 
  572.     dumpthings ( fontfalsebchar [ nullfont ] , fontptr + 1 - nullfont ) ; 
  573. #endif
  574.     for( k = nullfont ; k <= fontptr ; k++ ) {
  575.     c_printnl("\\font");
  576.     printesc( fontidtext ( k ) );
  577.     printchar( 61 );
  578.     printfilename( fontname(k), fontarea(k), 335 );
  579.     if ( fontsize(k) != fontdsize(k) ) {
  580.       print( STR_AT_ );  printscaled( fontsize(k) );  print( STR_PT );
  581.     } 
  582.     }
  583.   }
  584.   println();
  585.   printint( fmemptr - 7 );
  586.   c_print(" words of font info for ");
  587.   printint( fontptr - 0 );
  588.   c_print(" preloaded font");
  589.   if ( fontptr != 1 )
  590.     printchar( 115 );
  591.  
  592.   /* Dump the hyphenation table 1324 (II) */
  593.   { long anzahl = 0;
  594.     for( k = 0 ; k <= hyphsize ; k++ ) {
  595.       if ( hyphword(k) != 0 ) {
  596.     dumpshort ( k );
  597.     incr(anzahl);
  598.       }
  599.     }
  600.     if( anzahl != hyphcount )
  601.     printf("!! Internal error (HyphException Table Inconsistent) !!\n");
  602.   }
  603.   for( k = 0 ; k <= hyphsize ; k++ ) {
  604.     if ( hyphword(k) != 0 ) {
  605.       dumpshort ( hyphword(k) );
  606.       dumpint ( hyphlist(k) );
  607.     }
  608.   }
  609.   println();
  610.   printint( hyphcount );
  611.   c_print(" hyphenation exception");
  612.   if ( hyphcount != 1 ) 
  613.     printchar( 115 );
  614.   if ( trienotready ) 
  615.     inittrie();
  616.  
  617.   morethings[0] = triemax;
  618.   morethings[1] = trieopptr;
  619.  
  620.   /* Dump a couple of more things 1326 (I) */
  621.   morethings[2] = interaction;  /* mit ERW_INTERACTION nicht mehr notwendig */
  622.   morethings[3] = formatident;
  623.  
  624.   dumpthings(morethings[0], 4);
  625.  
  626.   /* Dump the hyphenation table 1324 (III) */
  627.   dumpthings ( trietrl[0], triemax + 1 );
  628.   dumpthings ( trietro[0], triemax + 1 );
  629.   dumpthings ( trietrc[0], triemax + 1 );
  630.  
  631. #ifdef HYPHSTRUCT
  632.   dumpthings ( hyph_op[1], trieopptr );
  633. #else
  634.   dumpthings ( hyfdistance[1] , trieopptr );
  635.   dumpthings ( hyfnum[1], trieopptr );
  636.   dumpthings ( hyfnext[1], trieopptr );
  637. #endif
  638.   c_printnl("Hyphenation trie of length ");
  639.   printint ( triemax ) ;
  640.   printchar(38);        /* = '&' */
  641.   printint( (integer)trieptr ); /* added "real" triemax for IniTeX (br) */
  642.   c_print(" has ");
  643.   printint ( trieopptr ) ; 
  644.   c_print(" op");
  645.   if ( trieopptr != 1 ) 
  646.     printchar ( 115 ) ; 
  647.   c_print(" out of ");
  648.   printint ( trieopsize ) ;
  649.  
  650.   for( k = 255 ; k >= 0 ; --k ) {
  651.     if ( trieused [ k ] > 0 ) {
  652.       c_printnl("  ");
  653.       printint ( trieused [ k ] ) ; 
  654.       c_print(" for language ");
  655.       printint ( k ) ; 
  656.       dumpchar ( k );
  657.       dumpshort ( trieused [ k ] );
  658.     } 
  659.   }
  660.  
  661.   /* Dump a couple of more things 1326 (II) */
  662.   dumpint ( 69069L );
  663.   tracingstats = 0;
  664.   wclose ( fmtfile ); 
  665. }
  666. #endif /* INITEX */
  667.  
  668.  
  669. boolean loadfmtfile ( void )
  670. { /* 6666 10 */
  671.   loadfmtfile_regmem
  672.   register integer j, k;
  673.   register long_halfword p, q;
  674.   register integer x;
  675.  
  676.   /* (br) UnDumpe moeglichst viel auf einmal, deshalb ... */
  677.   unsigned long morethings[20];
  678.   long hash_low_count;
  679.   /* ein paar feste Strings, die ein paarmal verwendet werden */
  680.   char *Must_Increase = "---! Must increase the %s (>%ld)\n";
  681.   char *This_is = "This is a format file %s.\n";
  682.   long len_of_strpool;
  683.  
  684. #ifdef TIME
  685. #ifdef AMIGA
  686.   unsigned long alt[2], neu[2], sum[2];
  687.   sum[0] = 0; sum[1] = 0;
  688.  
  689.   timer(alt);
  690. #else
  691.   unsigned long alt, neu;
  692.  
  693.   alt = clock();
  694. #endif
  695. #endif
  696.  
  697. #ifndef NEW_STRING    /* For new strstart[] dump: */
  698.   undumpthings(morethings[0], 17);
  699. #else
  700.   undumpthings(morethings[0], 18);
  701. #endif
  702.  
  703.   if( (morethings[0] & FMT_CHECK) != FMT_CHECK ) {
  704.     wakeupterminal ();
  705.     (void) printf(This_is, "written by another TeX implementation");
  706.     goto lab6666;
  707.   }
  708.  
  709. #ifdef BIG
  710.   if( (morethings[0] & CHECK_MASK) != BIGFMT ) {
  711.     wakeupterminal ();
  712.     if( (morethings[0] & CHECK_MASK) == NORMALFMT ) {
  713.     (void) printf(This_is, "for a `normal' TeX");
  714.     } else {
  715.     (void) printf(This_is, "written by an older/newer release");
  716.     }
  717.     goto lab6666;
  718.   }
  719. #else
  720.   if( (morethings[0] & CHECK_MASK) != NORMALFMT ) {
  721.     wakeupterminal ();
  722.     if( (morethings[0] & CHECK_MASK) == BIGFMT ) {
  723.     (void) printf(This_is, "for a `big' TeX");
  724.     } else {
  725.     (void) printf(This_is, "written by an older/newer release");
  726.     }
  727.     goto lab6666;
  728.   }
  729. #endif
  730.  
  731. #if defined(MLTEX) || defined(TEXXET)
  732.   if( (morethings[1] & 0xff000000) != ADDITIONAL ) {
  733.     wakeupterminal ();
  734.     (void) printf(This_is, "of a Standard TeX Version");
  735.     goto lab6666;
  736.   }
  737. # if defined(MLTEX) && defined(TEXXET)
  738.   if( (morethings[1] & (ADD_MLTEX | ADD_TEXXET)) != (ADD_MLTEX | ADD_TEXXET))
  739. # else
  740. #  ifdef MLTEX
  741.   if( (morethings[1] & ADD_MLTEX) != ADD_MLTEX )
  742. #  endif
  743. #  ifdef TEXXET
  744.   if( (morethings[1] & ADD_TEXXET) != ADD_TEXXET )
  745. #  endif
  746. # endif
  747.   {
  748.     wakeupterminal ();
  749.     (void) printf(This_is, "of a TeX with incompatible Patches");
  750.     goto lab6666;
  751.   }
  752.  
  753. # ifdef TEXXET
  754.   if( morethings[1] & TEXXETCHECK ) {
  755.     wakeupterminal ();
  756.     (void) printf("[This is TeX--XeT (1.0)]\n");
  757.     is_TeX_XeT = true;
  758.   } else {
  759.     is_TeX_XeT = false;
  760.   }
  761. # endif
  762.  
  763. # ifdef MLTEX
  764.   if( morethings[1] & MLTEXCHECK ) {
  765.     wakeupterminal ();
  766.     (void) printf("[This is ML-TeX, Version 3]\n");
  767.     is_ML_TeX = true;
  768.   } else {
  769.     is_ML_TeX = false;
  770.   }
  771. # endif
  772.  
  773. #else
  774.   if( morethings[1] != membot ) {
  775.     if( (morethings[1] & 0xff000000) == ADDITIONAL ) {
  776.     wakeupterminal ();
  777.     (void) printf(This_is, "of TeX with additional Patches");
  778.     }
  779.     goto lab6666;
  780.   }
  781. #endif
  782.  
  783.   if( morethings[2] != memtop ) {
  784. #ifdef INITEX
  785.      /* For IniTeX, memtop cannot be changed (or only both of memtop &
  786.       * memmax), so ...
  787.       */
  788.      (void) printf("--- ! Set `mem_top' = %ld (or use virtex) !\n",
  789.         morethings[2]);
  790.      goto lab6666;
  791. #else
  792.      /* If there's enough memory, we set mem_top accordingly and initialize
  793.       * all once more.  (This should work without problems, but it's better
  794.       * to inform the user.)
  795.       */
  796.      if( morethings[2] > memmax ) {
  797.     (void) printf("--- ! Set `mem_max' >= %ld !!\n", morethings[2]);
  798.     goto lab6666;
  799.      }
  800.  
  801. #if 0    /* it seems, that this is ok... */
  802.      (void) printf("--- ! memtop (%ld) != fmt-memtop (%ld), but it's ok for me.\n",
  803.     memtop, morethings[2]);
  804. #endif
  805.      memtop = morethings[2];
  806.  
  807.      /* Don't forget: Set mem[] & other locations for this mem_top value */
  808.      initialize();
  809. #endif
  810.   }
  811.   if( morethings[3] != eqtbsize )
  812.     goto lab6666;
  813.   if( morethings[4] != hashprime )
  814.     goto lab6666;
  815.   if( morethings[5] != hyphsize )
  816.     goto lab6666;
  817.  
  818. #ifdef TIME
  819. #ifdef AMIGA
  820.   timer(neu);
  821.   printf("Undump constants:  %ld, %ld\n", neu[0]-alt[0], neu[1]-alt[1]);
  822.   sum[0] += neu[0]-alt[0];
  823.   sum[1] += neu[1]-alt[1];
  824.   timer(alt);
  825. #else
  826.   neu = clock();
  827.   printf("Undump constants:  %ld\n", neu-alt);
  828.   alt = clock();
  829. #endif
  830. #endif
  831.  
  832.   /* Undump the string pool 1310 */
  833.   x = morethings[6];        /* poolptr */
  834.   if ( x < 0 ) 
  835.     goto lab6666 ; 
  836.   if ( x > poolsize ) {
  837.     wakeupterminal () ; 
  838.     (void) printf(Must_Increase, "string pool size", x);
  839.     goto lab6666 ; 
  840.   }
  841.   poolptr = x ;
  842.  
  843.   x = morethings[7];        /* strptr */
  844.   if ( x < 0 ) 
  845.     goto lab6666 ; 
  846.   if ( x > maxstrings ) {
  847.     wakeupterminal () ; 
  848.     (void) printf(Must_Increase, "max strings", x);
  849.     goto lab6666 ;
  850.   }
  851.   strptr = x ; 
  852.  
  853. #ifndef NEW_STRING
  854.   undumpthings ( strstart[0], strptr + 1 );
  855. #else
  856.   /* see remarks in storefmtfile() */
  857.   { register unsigned char *src;
  858.     unsigned char *buf = (unsigned char *)&strstart[0];
  859.  
  860.     len_of_strpool = morethings[17];
  861.     src = &buf[(maxstrings * sizeof(poolpointer)) - len_of_strpool];
  862.     undumpthings(src[0], len_of_strpool);
  863.   }
  864. #endif
  865.   /* Nur in Vielfachen von 4 undumpen */
  866.   undumpthings( strpool[0], ROUND_FOUR(poolptr) );
  867.  
  868.   initstrptr = strptr ; 
  869.   initpoolptr = poolptr ; 
  870. #ifdef TIME
  871. #ifdef AMIGA
  872.   timer(neu);
  873.   printf("Undump String Pool:  %ld, %ld\n", neu[0]-alt[0], neu[1]-alt[1]);
  874.   sum[0] += neu[0]-alt[0];
  875.   sum[1] += neu[1]-alt[1];
  876.   timer(alt);
  877. #else
  878.   neu = clock();
  879.   printf("Undump String Pool:  %ld\n", neu-alt);
  880.   alt = clock();
  881. #endif
  882. #endif
  883.  
  884.  
  885. #ifdef ERW_CODEPAGE
  886.   if ( codepage_given ) {
  887.     /* ignore the arrays */
  888.     {ASCIIcode foo[256];
  889.      undumpthings(foo[0], 256);
  890.      undumpthings(foo[0], 256);
  891.     }
  892.     {boolean foo[256];
  893.      undumpthings(foo[0], 256);
  894.     }
  895.   } else {
  896. #endif
  897.     undumpthings(xord[0], 256);
  898.     undumpthings(xchr[0], 256);
  899. #ifdef ERW_CODEPAGE
  900.     undumpthings(printable[0], 256);
  901.   }
  902. #endif
  903.  
  904.  
  905.   /* Undump the dynamic memory 1312 */
  906.   x = morethings[8];
  907.   if ( ( x < lomemstatmax + 1000 ) || ( x > himemstatmin - 1 ) )
  908.     goto lab6666;
  909.   lomemmax = x ;
  910.  
  911.   x = morethings[9];
  912.   if ( ( x < lomemstatmax + 1 ) || ( x > lomemmax ) ) 
  913.     goto lab6666;
  914.   rover = x; 
  915.  
  916.   { register long_halfword r_rover = rover;
  917.     register long_halfword r_lomemmax = lomemmax;
  918.  
  919.     p = membot;
  920.     q = r_rover;
  921.     do {
  922.       undumpthings ( mem [ p ] , q + 2 - p );
  923.       p = q + nodesize ( q );
  924.       if (  p > r_lomemmax  || ( q >= rlink(q) && rlink(q) != r_rover ) )
  925.     goto lab6666;
  926.       q = rlink ( q );
  927.     } while ( q != r_rover );
  928.     undumpthings ( mem[p], r_lomemmax + 1 - p );
  929.   }
  930.   if ( memmin < membot - 2 ) {
  931.     p = llink ( rover );
  932.     q = memmin + 1 ; 
  933.     link ( memmin ) = 0 ; 
  934.     info ( memmin ) = 0 ; 
  935.     rlink ( p ) = q ; 
  936.     llink ( rover ) = q ; 
  937.     rlink ( q ) = rover ; 
  938.     llink ( q ) = p ; 
  939.     link ( q ) = emptyflag ;
  940.     nodesize ( q ) = membot - q;
  941.   } 
  942.  
  943.   x = morethings[10];
  944.   if ( ( x < lomemmax + 1 ) || ( x > himemstatmin ) ) 
  945.     goto lab6666 ; 
  946.   himemmin = x ; 
  947.  
  948.   x = morethings[11];
  949.   if ( ( x < 0 ) || ( x > memtop ) ) 
  950.     goto lab6666 ; 
  951.   avail = x ; 
  952.  
  953.   /* Unddump the table of equivalents 1314 */
  954.   x = morethings[12];
  955.   if ( ( x < hashbase ) || ( x > frozencontrolsequence ) ) 
  956.     goto lab6666 ; 
  957.   parloc = x ; 
  958.   partoken = cstokenflag + parloc ; 
  959.  
  960.   x = morethings[13];
  961.   if ( ( x < hashbase ) || ( x > frozencontrolsequence ) ) 
  962.     goto lab6666 ; 
  963.   writeloc = x ; 
  964.  
  965.   x = morethings[14];
  966.   if ( ( x < hashbase ) || ( x > frozencontrolsequence ) )
  967.     goto lab6666 ;
  968.   hashused = x ; 
  969.  
  970.   cscount = morethings[15];
  971.   hash_low_count = morethings[16];
  972.  
  973.   /* Undump the dynamic memory 1312 (II) */
  974.   memend = memtop ; 
  975.   undumpthings ( mem [ himemmin ] , memend + 1 - himemmin ) ;
  976.  
  977.   undumpthings(morethings[0], 5);
  978.  
  979.   varused = morethings[0];
  980.   dynused = morethings[1];
  981.  
  982. #ifdef TIME
  983. #ifdef AMIGA
  984.   timer(neu);
  985.   printf("Undump Dynamic Memory:  %ld, %ld\n", neu[0]-alt[0], neu[1]-alt[1]);
  986.   sum[0] += neu[0]-alt[0];
  987.   sum[1] += neu[1]-alt[1];
  988.   timer(alt);
  989. #else
  990.   neu = clock();
  991.   printf("Undump Dynamic Memory:  %ld\n", neu-alt);
  992.   alt = clock();
  993. #endif
  994. #endif
  995.  
  996. /* Fuer ML-TeX sollte man beim Einlesen eines "normalen" fmt-files
  997.  * der Bereich von char_sub_base ... char_sub_base + 256 ueberlesen werden.
  998.  */
  999.  
  1000.   /* UnDump the table of equivalents 1313,... */
  1001. #if 0
  1002.   k = activebase ;
  1003.   do {
  1004.     undumpshort ( x ) ; 
  1005.     if ( ( x < 1 ) || ( k + x > eqtbsize + 1 ) )
  1006.     goto lab6666 ; 
  1007.     undumpthings ( eqtb [ k ] , x ) ; 
  1008.     k = k + x ; 
  1009.     undumpshort ( x ) ; 
  1010.     if ( ( x < 0 ) || ( k + x > eqtbsize + 1 ) )
  1011.     goto lab6666 ; 
  1012.     for( j = k ; j <= k+x-1 ; j++ ) {
  1013.       eqtb [ j ] = eqtb [ k - 1 ];
  1014.     }
  1015.     k = k + x;
  1016.   } while ( ! ( k > eqtbsize ) );
  1017. #else
  1018.   { register MEDmemoryword *current = &eqtb[activebase];
  1019.     MEDmemoryword *maxcur = &eqtb[eqtbsize+1];
  1020.  
  1021.     do {
  1022.       undumpshort ( x ) ; 
  1023.       if ( x < 1  || ( current + x > maxcur ) )
  1024.     goto lab6666 ; 
  1025.       undumpthings ( *current, x );
  1026.       current += x;
  1027.       undumpshort ( x ) ; 
  1028.       if ( x < 0  || ( current + x > maxcur ) )
  1029.     goto lab6666 ;
  1030.       { register MEDmemoryword *cur = current;
  1031.  
  1032.     --current;
  1033.     for( ; x > 0 ; --x )
  1034.       *cur++ = *current++;
  1035.       }
  1036.       current++;
  1037.     } while ( current < maxcur );
  1038.   }
  1039. #endif
  1040.  
  1041. #ifdef TIME
  1042. #ifdef AMIGA
  1043.   timer(neu);
  1044.   printf("Undump Eqtb:  %ld, %ld\n", neu[0]-alt[0], neu[1]-alt[1]);
  1045.   sum[0] += neu[0]-alt[0];
  1046.   sum[1] += neu[1]-alt[1];
  1047.   timer(alt);
  1048. #else
  1049.   neu = clock();
  1050.   printf("Undump Eqtb:  %ld\n", neu-alt);
  1051.   alt = clock();
  1052. #endif
  1053. #endif
  1054.  
  1055.   /* Undump the hash table 1319 (II) */
  1056.   p = hashbase - 1 ;
  1057.   if( hash_low_count > 0 ) {
  1058.      /* Dies funktioniert nur mit dem GNU C !!!
  1059.       * ausserdem sollte Stack genuegend gross sein... (oder Hash klein)
  1060.       */
  1061. #ifdef __GNUC__
  1062.      short stelle[hash_low_count], *stp = stelle;
  1063. #else
  1064.      short *stelle, *stp;
  1065.  
  1066.      stelle = stp = (short *) xmalloc(sizeof(short) * hash_low_count);
  1067. #endif
  1068.      /* Hole zuerst mal beide Arrays herein ... */
  1069.      undumpthings( stelle[0], hash_low_count);
  1070. #ifdef TIME
  1071. #ifdef AMIGA
  1072.   timer(neu);
  1073.   printf("Undump Hash Table (netto):  %ld, %ld\n", neu[0]-alt[0], neu[1]-alt[1]);
  1074.   sum[0] += neu[0]-alt[0];
  1075.   sum[1] += neu[1]-alt[1];
  1076.   timer(alt);
  1077. #else
  1078.   neu = clock();
  1079.   printf("Undump Hash Table(netto):  %ld\n", neu-alt);
  1080. #endif
  1081. #endif
  1082.  
  1083.      p = hashbase - 1 ;
  1084.      for( j = 0 ; j < hash_low_count ; j++ ) {
  1085.     x = *stp++;
  1086.     if ( ( x < p + 1 ) || ( x > hashused ) )
  1087.       goto lab6666;
  1088.     p = x;
  1089. #ifdef BIG
  1090.     (void) fread( (char *)&hash[p], sizeof(hash[p]), 1, dump_file );
  1091. #else
  1092.     undumphh ( hash [p] );
  1093. #endif
  1094.      }
  1095. #ifndef __GNUC__
  1096.      free(stelle);
  1097. #endif
  1098.   }
  1099.             /* v--LC BUG */
  1100.   undumpthings ( hash[(hashused+1)], undefinedcontrolsequence - 1 - hashused );
  1101. #ifdef TIME
  1102. #ifdef AMIGA
  1103.   timer(neu);
  1104.   printf("Undump Hash Table (gesamt):  %ld, %ld\n", neu[0]-alt[0], neu[1]-alt[1]);
  1105.   sum[0] += neu[0]-alt[0];
  1106.   sum[1] += neu[1]-alt[1];
  1107.   timer(alt);
  1108. #else
  1109.   neu = clock();
  1110.   printf("Undump Hash Table(gesamt):  %ld\n", neu-alt);
  1111.   alt = clock();
  1112. #endif
  1113. #endif
  1114.  
  1115.   /* Undump the font information 1321 */
  1116.   x = morethings[2];
  1117.   if ( x < 7 ) 
  1118.     goto lab6666 ; 
  1119.   if ( x > fontmemsize ) {
  1120.       wakeupterminal ();
  1121.       (void) printf(Must_Increase, "font mem size", x);
  1122.       goto lab6666 ; 
  1123.   }
  1124.   fmemptr = x;
  1125.  
  1126.   x = morethings[3];
  1127.   if ( x < 0 ) 
  1128.     goto lab6666 ; 
  1129.   if ( x > fontmax ) {
  1130.     wakeupterminal () ; 
  1131.     (void) printf(Must_Increase, "font max", x);
  1132.     goto lab6666 ; 
  1133.   }
  1134.   fontptr = x ; 
  1135.  
  1136.   undumpthings ( fontinfo [ 0 ] , fmemptr ) ; 
  1137.  
  1138.   undumpthings ( fontsize(nullfont), fontptr + 1 - nullfont ) ; 
  1139.   undumpthings ( fontdsize(nullfont), fontptr + 1 - nullfont ) ; 
  1140.   undumpthings ( fontname(nullfont), fontptr + 1 - nullfont ) ; 
  1141.   undumpthings ( fontarea(nullfont), fontptr + 1 - nullfont ) ;
  1142.  
  1143. #ifdef FONTSTRUCT
  1144.   undumpthings( fontdesc[nullfont], fontptr + 1 - nullfont);
  1145. #else
  1146.   undumpthings ( fontcheck [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1147.   undumpthings ( fontparams [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1148.   undumpthings ( hyphenchar [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1149.   undumpthings ( skewchar [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1150. #ifdef FONTPTR
  1151.   undumpthings ( font_bcec [ nullfont ] , fontptr + 1 - nullfont );
  1152. #else
  1153.   undumpthings ( fontbc [ nullfont ] , fontptr + 1 - nullfont );
  1154.   undumpthings ( fontec [ nullfont ] , fontptr + 1 - nullfont );
  1155. #endif
  1156.   undumpthings ( charbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1157.   undumpthings ( widthbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1158.   undumpthings ( heightbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1159.   undumpthings ( depthbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1160.   undumpthings ( italicbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1161.   undumpthings ( ligkernbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1162.   undumpthings ( kernbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1163.   undumpthings ( extenbase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1164.   undumpthings ( parambase [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1165.   undumpthings ( fontglue [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1166.   undumpthings ( bcharlabel [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1167.   undumpthings ( fontbchar [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1168.   undumpthings ( fontfalsebchar [ nullfont ] , fontptr + 1 - nullfont ) ; 
  1169. #endif
  1170.  
  1171.   /* Nicht vergessen, evtl. noch Ptr nach fontinfo[] zu berichtigen */
  1172.  
  1173. #ifdef TIME
  1174. #ifdef AMIGA
  1175.   timer(neu);
  1176.   printf("Undump Font Info:  %ld, %ld\n", neu[0]-alt[0], neu[1]-alt[1]);
  1177.   sum[0] += neu[0]-alt[0];
  1178.   sum[1] += neu[1]-alt[1];
  1179.   timer(alt);
  1180. #else
  1181.   neu = clock();
  1182.   printf("Undump Font Info:  %ld\n", neu-alt);
  1183.   alt = clock();
  1184. #endif
  1185. #endif
  1186.  
  1187.   /* Undump the hyphenation table 1325 */
  1188.   x = morethings[4];
  1189.   if ( ( x < 0 ) || ( x > hyphsize ) ) 
  1190.     goto lab6666 ; 
  1191.   hyphcount = x ; 
  1192.  
  1193.   if( hyphcount > 0 ) {
  1194.     /* ... Wie fuer die Hashtabelle ... */
  1195. #ifdef __GNUC__
  1196.     short stelle[hyphcount], *stp = stelle;
  1197. #else
  1198.     short *stelle, *stp;
  1199.  
  1200.     stelle = stp = (short *) xmalloc(sizeof(short) * hyphcount);
  1201. #endif
  1202.     undumpthings(stelle[0], hyphcount);
  1203.  
  1204.     for( k = 0 ; k < hyphcount ; k++ ) {
  1205.     j = *stp++;
  1206.     if ( ( j < 0 ) || ( j > hyphsize ) ) 
  1207.       goto lab6666 ;
  1208.  
  1209.     undumpshort ( x ) ; 
  1210.     if ( ( x < 0 ) || ( x > strptr ) ) 
  1211.       goto lab6666 ; 
  1212.     hyphword(j) = x ; 
  1213.  
  1214.     undumpint ( x ) ; 
  1215.     if ( ( x < 0 ) || ( x > maxhalfword ) )
  1216.       goto lab6666 ; 
  1217.     hyphlist(j) = x ; 
  1218.     }
  1219. #ifndef __GNUC__
  1220.     free(stelle);
  1221. #endif
  1222.   }
  1223.  
  1224.   undumpthings(morethings[0], 4);
  1225.  
  1226.   /* more ... */
  1227.   x = morethings[0];        /* trie_max */
  1228.   if ( x < 0 ) 
  1229.     goto lab6666 ; 
  1230.   if ( x > triesize ) {
  1231.       wakeupterminal () ; 
  1232.       (void) printf(Must_Increase, "trie size", x);
  1233.       goto lab6666 ;
  1234.   }
  1235.   j = x ; 
  1236. #ifdef INITEX
  1237.   triemax = j ; 
  1238. #endif /* INITEX */
  1239.   undumpthings ( trietrl [ 0 ] , j + 1 ) ; 
  1240.   undumpthings ( trietro [ 0 ] , j + 1 ) ; 
  1241.   undumpthings ( trietrc [ 0 ] , j + 1 ) ; 
  1242.  
  1243.   x = morethings[1];        /* trie_op_ptr */
  1244.   if ( x < 0 ) 
  1245.     goto lab6666 ; 
  1246.   if ( x > trieopsize ) {
  1247.       wakeupterminal () ; 
  1248.       (void) printf(Must_Increase, "trie op size", x);
  1249.       goto lab6666 ; 
  1250.   }
  1251.   j = x ; 
  1252. #ifdef INITEX
  1253.   trieopptr = j ; 
  1254. #endif /* INITEX */
  1255. #ifdef HYPHSTRUCT
  1256.   undumpthings ( hyph_op[1], j );
  1257. #else
  1258.   undumpthings ( hyfdistance [ 1 ] , j );
  1259.   undumpthings ( hyfnum [ 1 ] , j );
  1260.   undumpthings ( hyfnext [ 1 ] , j );
  1261. #endif
  1262.  
  1263. #ifdef TIME
  1264. #ifdef AMIGA
  1265.   timer(neu);
  1266.   printf("Undump Hyphenation Table:  %ld, %ld\n", neu[0]-alt[0], neu[1]-alt[1]);
  1267.   sum[0] += neu[0]-alt[0];
  1268.   sum[1] += neu[1]-alt[1];
  1269.   timer(alt);
  1270. #else
  1271.   neu = clock();
  1272.   printf("Undump Hyphenation Table:  %ld\n", neu-alt);
  1273.   alt = clock();
  1274. #endif
  1275. #endif
  1276.  
  1277. #ifdef INITEX
  1278.   for( k = 0 ; k <= 255 ; k++ )
  1279.     trieused [ k ] = 0;
  1280. #endif /* INITEX */
  1281.  
  1282.   k = 256 ; 
  1283.   while ( j > 0 ) {
  1284.     {
  1285.       undumpchar ( x ) ; 
  1286.       if ( ( x < 0 ) || ( x > k - 1 ) ) 
  1287.       goto lab6666 ; 
  1288.       else k = x ; 
  1289.     } 
  1290.     {
  1291.       undumpshort ( x ) ; 
  1292.       if ( ( x < 1 ) || ( x > j ) ) 
  1293.       goto lab6666 ; 
  1294.       else x = x ; 
  1295.     } 
  1296. #ifdef INITEX
  1297.     trieused [ k ] = x ; 
  1298. #endif /* INITEX */
  1299.     j = j - x ; 
  1300.     opstart [ k ] = j ; 
  1301.   } 
  1302. #ifdef INITEX
  1303.   trienotready = false ;
  1304. #endif /* INITEX */
  1305.  
  1306.   /* Undump a couple more things 1327 */
  1307. #ifndef ERW_INTERACTION
  1308.   x = morethings[2];
  1309.   if ( ( x < batchmode ) || ( x > errorstopmode ) ) 
  1310.     goto lab6666 ; 
  1311.   else interaction = x ; 
  1312. #endif
  1313.  
  1314.   x = morethings[3];
  1315.   if ( ( x < 0 ) || ( x > strptr ) ) 
  1316.     goto lab6666 ; 
  1317.   else formatident = x ; 
  1318.  
  1319.   undumpint ( x ) ; 
  1320.   if ( ( x != 69069L ) || feof ( fmtfile ) ) 
  1321.     goto lab6666 ; 
  1322.  
  1323. #ifdef TIME
  1324. #ifdef AMIGA
  1325.   timer(neu);
  1326.   printf("Undump Rest:  %ld, %ld\n", neu[0]-alt[0], neu[1]-alt[1]);
  1327.   sum[0] += neu[0]-alt[0];
  1328.   sum[1] += neu[1]-alt[1];
  1329.   timer(alt);
  1330.   if (sum[1] < 0) {
  1331.     sum[0]--;
  1332.     sum[1] += 1000000;
  1333.   }
  1334.   printf("Undump SUMME: %lu, %lu\n", sum[0], sum[1]);
  1335. #else
  1336.   neu = clock();
  1337.   printf("Undump Rest:  %ld\n", neu-alt);
  1338.   alt = clock();
  1339. #endif
  1340. #endif
  1341.  
  1342. #ifdef NEW_STRING
  1343.   /* Hier werden jetzt noch alle notwendigen Umsortierungen, etc. die
  1344.    * notwendig sind, gemacht...
  1345.    */
  1346.  
  1347.  
  1348.   /* see remarks in storefmtfile() */
  1349.   { register unsigned char *src;
  1350.  
  1351.     { unsigned char *buf = (unsigned char *)&strstart[0];
  1352.  
  1353.       src = &buf[(maxstrings * sizeof(poolpointer)) - len_of_strpool];
  1354.     }
  1355.     /* undumpthings(src[0], len_of_strpool); */
  1356.  
  1357.     k = 0;
  1358.     /* Hole Inhalt von strstart[0] = Startadresse */
  1359.     for( j = sizeof(strstart[0]) ; j > 0 ; --j )
  1360.     k = (k * 256) + ((unsigned)*src++);
  1361.  
  1362.     strstart[0] = k;
  1363.     { poolpointer *pp = &strstart[1];
  1364.  
  1365.       for( j = 1 ; j < strptr + 1 ; j++ ) {
  1366.     x = (integer) (*src++ & 0xff);
  1367.     if( x == 255 ) {
  1368.       x = (integer) ((unsigned)((*src++) << 8));
  1369.       x += ((unsigned)*src++);
  1370.     }
  1371.     k += x;
  1372.     *pp++ = k;    /* strstart[..] = k; */
  1373.       }
  1374.     }
  1375.  
  1376.     if( strstart[strptr] != poolptr )
  1377.     printf("!! Internal Error (String Pool Inconsistent [%d]) !!\n", 2);
  1378.   }
  1379. #endif
  1380.  
  1381. #ifdef FONTPTR
  1382.   /* ...base[] should be C pointers in fontinfo[] */
  1383.   for( p = nullfont ; p <= fontptr ; p++ ) {
  1384.     charbase(p)    = &fontinfo[(long)charbase(p)];
  1385.     widthbase(p)   = &fontinfo[(long)widthbase(p)];
  1386.     heightbase(p)  = &fontinfo[(long)heightbase(p)];
  1387.     depthbase(p)   = &fontinfo[(long)depthbase(p)];
  1388.     italicbase(p)  = &fontinfo[(long)italicbase(p)];
  1389.     ligkernbase(p) = &fontinfo[(long)ligkernbase(p)];
  1390.     kernbase(p)    = &fontinfo[(long)kernbase(p)];
  1391.   }
  1392. #endif
  1393.  
  1394.   return(true);
  1395.  
  1396.  
  1397. lab6666:
  1398.   wakeupterminal ();
  1399.   (void) printf("(Fatal format file error; I'm stymied)\n");
  1400.  
  1401.   return(false);
  1402. }
  1403.  
  1404. /* -- end -- */
  1405.