home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / filename.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-09  |  20.1 KB  |  793 lines
  1. /* =========  Part 29: File Names =========== */
  2.  
  3. #define EXTERN extern
  4. #include "texd.h"
  5.  
  6.  
  7. /* Diese Routinen sollte man so abaendern, dass sie vielleicht statt dem
  8.  * String Pool feste oder dynamische C-Arrays benutzen.  TeX hat jetzt die
  9.  * unangenehme Eigenschaft, fuer jeden(!) Filenamen, selbst wenn er schon
  10.  * vorhanden ist, einen neuen String zu verwenden.
  11.  */
  12.  
  13.  
  14. /* Als erste einfache Abhilfe werden die letzten FNCACHELEN Stringnummern
  15.  * fuer Files in `fncache[]' eingetragen... und bevor ein neuer String fuer
  16.  * einen Filenamen erzeugt wird, wird dort nachgesehen.
  17.  */
  18. #ifdef FILENAMECACHE
  19.  
  20. static strnumber fn_cache[FNCACHELEN];
  21. static char  fn_cache_sc[FNCACHELEN];  /* Second Chance Zaehler */
  22. static short fn_cache_rover = 0;       /* letzte Position */
  23.  
  24.  
  25. #if 0
  26.  
  27. /* Die Funktion `flushstring' kann nur den zuletzt erzeugten String
  28.  * entfernen.  `deletestring(s)' entfernt den beliebigen String Nummer `s'.
  29.  * Dabei sollte `s' nicht allzuweit vom Ende des Pools entfernt sein, da es
  30.  * sonst etwas langsam vor sich geht.
  31.  * Ausserdem darf keiner der Strings > s schon irgendwo abgespeichert
  32.  * worden sein, d.h. die Stringnummern duerfen nicht im Cache sein oder
  33.  * in einer der Variablen curarea, curname, curext....
  34.  */
  35.  
  36.   static void
  37. delete_string(strnumber s)
  38. { long len;
  39.  
  40. c_printnl("Deleting: "); print(s); println();
  41.  
  42.   if( s >= strptr ) {
  43.     printf("!! Internal Error (Filename Cache [%d]) !!\n", 1);
  44.     return;
  45.   }
  46.  
  47.   len = length(s);
  48.  
  49. c_printnl("Str1: "); printf(
  50. "poolptr: %d  str: %d  str-1: %d  str+1 %d  len: %d strptr: %d",
  51. poolptr, strstart[strptr], strstart[strptr-1], strstart[strptr+1],
  52. len, strptr);
  53. println();
  54. c_printnl("Str1: "); printf(
  55. "s: %d  s: %d  s-1: %d  s+1 %d", s, strstart[s], strstart[s-1], strstart[s+1]);
  56. println();
  57.  
  58.   /* Kopiere den restlichen Stringpool "herunter" */
  59.   /* memcpy( dst, src, size ); */
  60.   memcpy( &strpool[strstart[s]], &strpool[strstart[s+1]],
  61.           poolptr - strstart[s+1] );
  62.  
  63.   /* poolptr und strptr erniedrigen... */
  64.   poolptr -= len;
  65.   --strptr;
  66.  
  67.   /* Passe strstart[] oberhalb des Strings an (nicht strstart[s]!) */
  68.   s++;
  69.   while( s <= strptr ) {
  70.     strstart[s] = strstart[s+1] - len;
  71.     s++;
  72.   }
  73.  
  74. c_printnl("Str2: "); printf(
  75. "poolptr: %d  str: %d  str-1: %d  str+1 %d  len: %d strptr: %d",
  76. poolptr, strstart[strptr], strstart[strptr-1], strstart[strptr+1],
  77. len, strptr);
  78. println();
  79. c_printnl("Str2: "); printf(
  80. "s: %d  s: %d  s-1: %d  s+1 %d", s, strstart[s], strstart[s-1], strstart[s+1]);
  81. println();
  82.  
  83.   if( poolptr != strstart[strptr] )
  84.     printf("!! Internal Error (Filename Cache [%d]) !!\n", 2);
  85. }
  86. #endif
  87.  
  88.  
  89. /* Suchen im Filename-Cache, liefert neue Stringnummer zurueck, alter String
  90.  * wird geloescht (Man huete sich davor lookup_fncache() mit einer String-
  91.  * nummer aufzurufen, die im Cache schon ist und spaeter noch benoetigt wird!)
  92.  */
  93.  
  94.   static int
  95. lookup_fncache(strnumber search)
  96. { short cur_ptr = fn_cache_rover;
  97.  
  98.   /* Verhindere, dass die festen Strings gesucht und evtl. geloescht werden
  99.    * ( makenamestring() liefert z.B. auch 63 zurueck).
  100.    * Und da ist es gleich besser, nur den zuletzt mit makestring() erzeugten
  101.    * String (und den gerade in endname() erzeugten) zuzulassen.
  102.    */
  103.   if( search < (strptr - 1) )
  104.     return( 0 );    /* not found */
  105.  
  106.   while( 1 ) {
  107.  
  108.     /* Stringnummer im Cache ?? */
  109.     if( fn_cache[cur_ptr] != 0 ) {   /* gueltiger Eintrag?? */
  110.  
  111.       /* Der Vergleich
  112.        *     fn_cache[cur_ptr] < strptr
  113.        * ist notwendig, da ab TeX 3.1415 in \S 1260 Code enthalten ist,
  114.        * der den neuen gelesenen Fontnamen von schon vorhandenen Fonts
  115.        * loescht und den alten verwendet.  Dabei koennte dieser Name
  116.        * schon hier eingetragen sein!!
  117.        * Dieser Test alleine bringt's jedoch nicht, deshalb wird vorher
  118.        * schon explizit gegen alle Fontnamen abgeprueft!
  119.        */
  120.       if( fn_cache[cur_ptr] >= strptr ) {  /* wirklich: gueltiger Eintrag?? */
  121.     fn_cache[cur_ptr] = 0;  /* nein: Eintrag loeschen */
  122.       } else {
  123.     if( str_eq_str(search, fn_cache[cur_ptr]) ) {
  124.       fn_cache_rover = cur_ptr;
  125.       /* Second Chance Zaehler auf `belegt' setzen */
  126.           fn_cache_sc[cur_ptr] = 0;
  127.       /* und Stringnummer aus Cache zurueckgeben */
  128.       return( fn_cache[cur_ptr] );
  129.     }
  130.       }
  131.     }
  132.  
  133.     /* Zeiger erhoehen (und am Cache-Ende wieder auf den Anfang setzen) */
  134.     cur_ptr++;  cur_ptr %= FNCACHELEN;
  135.  
  136.     /* schon einmal im Kreis herum und immer noch nicht gefunden...? */
  137.     if( cur_ptr == fn_cache_rover )
  138.     break;
  139.   }
  140.  
  141.   /* Nicht gefunden, jetzt mit ``Second Chance'' verdraengen. */
  142.  
  143.   while( 1 ) {
  144.     /* Zeiger erhoehen (und am Cache-Ende wieder auf den Anfang setzen) */
  145.     cur_ptr++;  cur_ptr %= FNCACHELEN;
  146.  
  147.     /* keine Second Chance mehr ? */
  148.     if( fn_cache_sc[cur_ptr] >= 2 )
  149.     break;
  150.  
  151.     /* Second Chance Zaehler, von `belegt' (0) auf `gealtert' (1)
  152.      * bzw. von `gealtert' auf `frei' (2) setzen.
  153.      */
  154.     fn_cache_sc[cur_ptr] += 1;
  155.   }
  156.  
  157.   fn_cache_rover = cur_ptr;
  158.  
  159.   /* String eintragen und als `belegt' markieren */
  160.   fn_cache[cur_ptr] = search;
  161.   fn_cache_sc[cur_ptr] = 0;
  162.  
  163.   return( 0 );    /* not found */
  164. }
  165.  
  166.  
  167. /* Ersetze einen moeglichen Eintrag des Strings `old' im Cache durch
  168.  * den String `new'.
  169.  * Dies ist immer dann notwendig, wenn ein String durch einen anderen
  170.  * (mit gleichem Inhalt!) ersetzt wird und der alte mit `flushstring()'
  171.  * geloescht wird.
  172.  * Momentan nur in \S 1260 new_font() benoetigt...
  173.  * und dort tritt dies nur auf, wenn ein Fontname gescannt wird, der
  174.  * nicht mehr im Cache ist und deshalb unter der Nummer eingetragen
  175.  * wird.  Anschliessend ersetzt der Original-TeX-Code diesen String
  176.  * durch den in `fontname(f)' gefundenen und dies muss auch im Cache
  177.  * nachvollzogen werden!
  178.  */
  179.  
  180.   static void
  181. update_fncache(strnumber old, strnumber new)
  182. { short cur_ptr;
  183.   char errorflag = 0;
  184.  
  185.   /* fn_cache[] enthaelt 0 als Anzeichen fuer einen leeren Eintrag.
  186.    * `old' sollte nie 0 sein, da die Bedingung in der Schleife
  187.    * eigentlich
  188.    *    if( fn_cache[cur_ptr] != 0 && fn_cache[cur_ptr] == old )
  189.    * lautet.  Stringnummer 0 steht im Grunde fuer "@" und koennte
  190.    * vorkommen, wird aber von `lookup_fncache()' nie zurueckgeliefert
  191.    * und auch nicht in den Cache eingetragen (wieso wohl?!).
  192.    * Vorsichtshalber trotzdem abpruefen...
  193.    */
  194.   if ( old == 0 ) {
  195.     printf("\n!! Internal Error (Filename Cache Update [%d]) !!\n", 1);
  196.     return;
  197.   }
  198.  
  199.   for( cur_ptr = FNCACHELEN - 1 ; cur_ptr >= 0 ; cur_ptr-- ) {
  200.     if( fn_cache[cur_ptr] == old ) {
  201.       fn_cache[cur_ptr] = new;
  202.       /* Der zu ersetzende Eintrag sollte nur einmal drin sein!! */
  203.       if ( errorflag )
  204.         printf("\n!! Internal Error (Filename Cache Update [%d]) !!\n", 2);
  205.       errorflag = 1;
  206.     }
  207.   }
  208. }
  209.  
  210. #endif   /* FILENAMECACHE */
  211.  
  212.  
  213.  
  214. /*
  215.  *  Die naechsten drei Routinen werden nur von scanfilename() und
  216.  *  promptfilename() aufgerufen.
  217.  */
  218.  
  219.   static
  220. void beginname ( void )
  221. { beginname_regmem 
  222.  
  223.   areadelimiter = 0;
  224.   extdelimiter = 0;
  225. } 
  226.  
  227.  
  228.   static
  229. boolean morename ( ASCIIcode c )
  230. { morename_regmem
  231.  
  232.   if ( c == 32 )
  233.     return(false);
  234.  
  235.   strroom( 1 );
  236.   appendchar( c );
  237.   if ( c == 47 ) {        /* / */
  238.     areadelimiter = curlength;
  239.     extdelimiter = 0;
  240.   } else if ( c == 46 )        /* . */
  241.     extdelimiter = curlength;
  242.  
  243.   return(true);
  244. }
  245.  
  246.  
  247.   static
  248. void endname ( void )
  249. { endname_regmem
  250.   strnumber tempstr;
  251.   long i;
  252.  
  253.   if ( strptr + 3 > maxstrings )
  254.     overflow(1, maxstrings - initstrptr);
  255.  
  256.   /* Falls kein Directory angegeben wurde, ist curarea = "",
  257.    * ansonsten wird curarea auf das Directory gesetzt.
  258.    */
  259.   if ( areadelimiter == 0 )
  260.     curarea = 335;
  261.   else {
  262.     curarea = strptr;
  263.     strstart[strptr + 1] = strstart[strptr] + areadelimiter;
  264.     incr ( strptr );
  265. #ifdef FILENAMECACHE
  266.     if( (tempstr = lookup_fncache(curarea)) != 0 ) {
  267.     curarea = tempstr;
  268.     decr(strptr);    /* nicht flushstring, da sonst poolptr falsch */
  269.  
  270.     /* Name + Ext des Filenamens herunterkopieren */
  271.     for( i = strstart[strptr + 1] ; i < poolptr ; i++ )
  272.       strpool[i - areadelimiter] = strpool[i];
  273.     /* Poolpointer korrigieren */
  274.     poolptr -= areadelimiter;
  275.     }
  276. #endif
  277.   }
  278.  
  279.   /* Falls keine Extension angegeben wurde, ist curext = "" und curname
  280.    * der aktuelle String.
  281.    * Ansonsten ist curname der String bis zu curext und curext der restliche
  282.    * aktuelle String.
  283.    */
  284.   if ( extdelimiter == 0 ) {
  285.     curext = 335;
  286. #ifdef FILENAMECACHE
  287.     if( curlength == 0 ) {
  288.       curname = 335;
  289.     } else {
  290.       curname = makestring();
  291.       if( (tempstr = lookup_fncache(curname)) != 0 ) {
  292.     curname = tempstr;
  293.     flushstring;    /* poolptr wird automatisch richtig gesetzt */
  294.       }
  295.     }
  296. #else
  297.     curname = makestring();
  298. #endif
  299.   } else {
  300.     curname = strptr;
  301.     strstart[strptr+1] = strstart[strptr] + extdelimiter - areadelimiter - 1;
  302.     incr ( strptr );
  303. #ifdef FILENAMECACHE
  304.     if( (tempstr = lookup_fncache(curname)) != 0 ) {
  305.     curname = tempstr;
  306.     decr(strptr);    /* nicht flushstring, da sonst poolptr falsch */
  307.  
  308.     /* Extension des Filenamens herunterkopieren */
  309.     for( i = strstart[strptr+1] ; i < poolptr; i++ )
  310.       strpool[i - extdelimiter + areadelimiter + 1] = strpool[i];
  311.     poolptr = poolptr - extdelimiter + areadelimiter + 1;
  312.     }
  313. #endif
  314.  
  315.     curext = makestring();
  316. #ifdef FILENAMECACHE
  317.     /* Zuerst mal auf ".tex" abpruefen.. */
  318.     if( str_eq_str(STR_DOT_TEX, curext) ) {
  319.     curext = STR_DOT_TEX;
  320.     flushstring;
  321.     } else if( (tempstr = lookup_fncache(curext)) != 0 ) {
  322.     curext = tempstr;
  323.     flushstring;
  324.     }
  325. #endif
  326.   }
  327. }
  328.  
  329.  
  330.  
  331. void packfilename( strnumber n, strnumber a, strnumber e )
  332. { packfilename_regmem
  333.   register integer k;
  334.   register ASCIIcode c;
  335.   register poolpointer j;
  336.  
  337.   k = 0;
  338.   { register integer for_end;
  339.     j = strstart[a];  for_end = strstart[a + 1] - 1;
  340.     if ( j <= for_end) do {
  341.       c = strpool[j];
  342.       incr ( k );
  343.       if ( k <= FILENAMESIZE-1 )
  344.     nameoffile [ k ] = xchr [ c ];
  345.     } while ( j++ < for_end ); 
  346.   }
  347.   { register integer for_end;
  348.     j = strstart [ n ] ; for_end = strstart [ n + 1 ] - 1 ;
  349.     if ( j <= for_end) do {
  350.       c = strpool [ j ];
  351.       incr ( k ) ; 
  352.       if ( k <= FILENAMESIZE-1 )
  353.     nameoffile [ k ] = xchr [ c ] ; 
  354.     } while ( j++ < for_end ) ;
  355.   }
  356.   { register integer for_end;
  357.     j = strstart [ e ] ; for_end = strstart [ e + 1 ] - 1 ;
  358.     if ( j <= for_end) do {
  359.       c = strpool [ j ];
  360.       incr ( k );
  361.       if ( k <= FILENAMESIZE-1 ) 
  362.     nameoffile [ k ] = xchr [ c ];
  363.     } while ( j++ < for_end );
  364.   }
  365.  
  366.   if ( k <= FILENAMESIZE-1 )
  367.     namelength = k;
  368.   else
  369.     namelength = FILENAMESIZE-1;
  370.  
  371.   { register integer for_end;
  372.     k = namelength + 1 ; for_end = FILENAMESIZE;
  373.     if ( k <= for_end) do 
  374.       nameoffile [ k ] = ' ';
  375.     while ( k++ < for_end );
  376.   }
  377. }
  378.  
  379.  
  380. void packbufferedname ( smallnumber n, integer a, integer b )
  381. { packbufferedname_regmem 
  382.   register integer k;
  383.   register ASCIIcode c;
  384.   register integer j;
  385.  
  386.   if ( n + b - a + 5 > FILENAMESIZE-1 ) 
  387.     b = a + (FILENAMESIZE-1) - n - 5;
  388.   k = 0;
  389.   { register integer for_end;
  390.     j = 1; for_end = n;
  391.     if ( j <= for_end) do {
  392.       c = xord [ TEXformatdefault[j] ];
  393.       incr ( k );
  394.       if ( k <= FILENAMESIZE-1 )
  395.     nameoffile [ k ] = xchr [ c ];
  396.     } while ( j++ < for_end );
  397.   }
  398.   { register integer for_end;
  399.     j = a; for_end = b;
  400.     if ( j <= for_end) do {
  401.       c = buffer [ j ];
  402.       incr ( k );
  403.       if ( k <= FILENAMESIZE-1 )
  404.     nameoffile [ k ] = xchr [ c ];
  405.     } while ( j++ < for_end );
  406.   }
  407.   { register integer for_end;
  408.     j = formatdefaultlength - 3; for_end = formatdefaultlength;
  409.     if ( j <= for_end) do {
  410.       c = xord [ TEXformatdefault[j] ];
  411.       incr ( k );
  412.       if ( k <= FILENAMESIZE-1 )
  413.     nameoffile [ k ] = xchr [ c ];
  414.     } while ( j++ < for_end );
  415.   }
  416.   if ( k <= FILENAMESIZE-1 )
  417.     namelength = k;
  418.   else
  419.     namelength = FILENAMESIZE-1;
  420.  
  421.   { register integer for_end;
  422.     k = namelength + 1; for_end = FILENAMESIZE;
  423.     if ( k <= for_end) do 
  424.       nameoffile [ k ] = ' ';
  425.     while ( k++ < for_end );
  426.   }
  427. }
  428.  
  429.  
  430. strnumber makenamestring ( void )
  431. { makenamestring_regmem
  432.   register integer k;
  433.  
  434.   if ( ( poolptr + namelength > poolsize ) || ( strptr == maxstrings )
  435.     || ( curlength > 0 ) )
  436.     return( (strnumber)63 );   /* "?" */
  437.  
  438.   { register integer for_end; k = 1 ; for_end = namelength;
  439.     if ( k <= for_end) do 
  440.       appendchar ( xord [ nameoffile [ k ] ] ) ; 
  441.     while ( k++ < for_end );
  442.   }
  443.  
  444.   return( makestring () );
  445. }
  446.  
  447.  
  448. void scanfilename ( void )
  449. { scanfilename_regmem
  450.   register eightbits r_curcmd;
  451.  
  452.   nameinprogress = true;
  453.   beginname();
  454.   r_curcmd = getxnbtoken(0);
  455.  
  456.   while ( true ) {
  457.     if ( r_curcmd > 12 || (curchr > 255) ) {
  458.       backinput ();
  459.       goto lab30;
  460.     }
  461.     if ( ! morename( curchr ) )
  462.       goto lab30;
  463.     r_curcmd = getxtoken();
  464.   }
  465.  
  466. lab30:
  467.   endname();
  468.   nameinprogress = false;
  469. }
  470.  
  471.  
  472. void packjobname ( strnumber s )
  473. { packjobname_regmem
  474.  
  475.   curarea = 335 ;
  476.   curext = s ;
  477.   curname = jobname ;
  478.   packfilename ( curname , curarea , curext );
  479. }
  480.  
  481.  
  482. /* Da wir nach der Adresse des naechsten Strings abfragen (ist schneller
  483.  * als `strcmp()', wird er hier einmalig angelegt.
  484.  */
  485. static char input_file_name[] = "input file name";
  486.  
  487.  
  488. void promptfilename ( char *s, strnumber e )
  489. {/* 30 */ promptfilename_regmem 
  490.   register integer k  ; 
  491.  
  492.   if ( interaction == scrollmode ) 
  493.     wakeupterminal () ; 
  494.   if ( s == input_file_name ) {
  495.     print_err("I can't find file `");
  496.   } else {
  497.     print_err("I can't write on file `");
  498.   } 
  499.   printfilename ( curname , curarea , curext ) ; 
  500.   c_print("'.");
  501.   if ( e == STR_DOT_TEX )
  502.     showcontext();
  503.   c_printnl("Please type another ");
  504.   c_print ( s );
  505.   if ( interaction < scrollmode ) 
  506.     fatalerror( STR_H_FE_JOBAB_FILE );
  507.   clearterminal () ; 
  508.   terminput(": ");
  509.   {
  510.     beginname () ; 
  511.     k = first ; 
  512.     while ( ( buffer [ k ] == 32 ) && ( k < last ) )
  513.       incr ( k );
  514.     while ( true ) {
  515.       if ( k == last ) 
  516.     goto lab30 ; 
  517.       if ( ! morename ( buffer [ k ] ) ) 
  518.     goto lab30 ; 
  519.       incr ( k ) ; 
  520.     }
  521. lab30:
  522.     endname () ; 
  523.   } 
  524.   if ( curext == 335 ) 
  525.     curext = e;
  526.   packfilename ( curname , curarea , curext ) ; 
  527. }
  528.  
  529.  
  530. void openlogfile ( void )
  531. { openlogfile_regmem 
  532.   integer oldsetting;
  533.   register integer k;
  534.   register integer l;
  535.   ccharpointer months;
  536.  
  537.   oldsetting = selector;
  538.  
  539.   if ( jobname == 0 ) 
  540.     jobname = STR_TEXPUT;
  541.   packjobname( STR_DOT_LOG );  
  542.   while ( ! aopenout ( logfile ) ) {
  543.     selector = termonly ; 
  544.     promptfilename("transcript file name", STR_DOT_LOG );
  545.   }
  546.   logname = amakenamestring ( logfile ) ; 
  547.   selector = logonly ; 
  548.   logopened = true ; 
  549.   {
  550. #if 0
  551.     (void) Fputs( logfile ,  "This is TeX, C Version 3.1t2" ) ; 
  552. #else
  553.     (void) Fputs( logfile, banner );
  554. #endif
  555. #ifdef MLTEX
  556.   /* if user has given ML-TeX switch in IniTeX, output a second line */
  557.   if( is_ML_TeX )
  558.     (void) Fputs(logfile, "\nThis is ML-TeX, Version 3");
  559. #endif
  560. #ifdef TEXXET
  561.   if( is_TeX_XeT )
  562.     (void) Fputs(logfile, "\nThis is TeX--XeT (1.0)");
  563. #endif
  564.     slowprint ( formatident );  /* TeX 3.141 */
  565.     c_print("  ");
  566.     printint ( zday ) ; 
  567.     printchar ( 32 ) ; 
  568.     months = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
  569.     {register integer for_end; k = 3 * zmonth - 3 ; for_end = 3 * zmonth - 1
  570.     ; if ( k <= for_end) do 
  571.       (void) putc( months [ k ] ,  logfile );
  572.     while ( k++ < for_end ) ; } 
  573.     printchar ( 32 ) ; 
  574.     printint ( zyear ) ; 
  575.     printchar ( 32 ) ; 
  576.     printtwo ( ztime / 60 ) ; 
  577.     printchar ( 58 ) ; 
  578.     printtwo ( ztime % 60 ) ; 
  579.   }
  580. #ifdef INP_PTR
  581.   /*  Da bei INP_PTR curinput auf oberstes Element von inputstack[] zeigt ..
  582.    *  ist nichts zu tun.
  583.    */
  584. #else
  585.   inputstack [ inputptr ] = curinput; 
  586. #endif
  587.   c_printnl("**");
  588.   l = inputstack [ 0 ] .limitfield ; 
  589.   if ( buffer [ l ] == endlinechar ) 
  590.     decr ( l );
  591.   {register integer for_end; k = 1 ; for_end = l ; if ( k <= for_end) do 
  592.     print ( buffer [ k ] ) ; 
  593.   while ( k++ < for_end ) ; } 
  594.   println () ; 
  595.   selector = oldsetting + 2 ; 
  596. }
  597.  
  598.  
  599. void startinput ( void )
  600. {/* 30 */ startinput_regmem 
  601.  
  602.   scanfilename ();
  603.   if ( curext == 335 ) 
  604.     packfilename ( curname , curarea , STR_DOT_TEX );
  605.   else
  606.     packfilename ( curname , curarea , curext );
  607.  
  608.   while ( true ) {
  609.     beginfilereading () ; 
  610.     if ( aopenin ( inputfile [ curinput.indexfield ] , TEXINPUTPATH ) ) 
  611.       goto lab30 ; 
  612.     if ( curext == 335 ) {
  613.       packfilename ( curname , curarea , curext ) ; 
  614.       if ( aopenin ( inputfile [ curinput.indexfield ] , TEXINPUTPATH ) ) 
  615.       goto lab30 ; 
  616.     } 
  617.     endfilereading () ; 
  618.     promptfilename( input_file_name, STR_DOT_TEX );
  619.   }
  620. lab30:
  621.   curinput.namefield = amakenamestring ( inputfile[curinput.indexfield] );
  622. #ifdef FILENAMECACHE
  623.   { strnumber tempstr;
  624.     if( (tempstr = lookup_fncache( curinput.namefield )) != 0 ) {
  625.     curinput.namefield = tempstr;
  626.     flushstring;
  627.     }
  628.   }
  629. #endif
  630.   if ( jobname == 0 ) {
  631.     jobname = curname;
  632.     openlogfile();
  633.   }
  634.   if ( termoffset + length ( curinput.namefield ) > maxprintline - 3 )
  635.     println();
  636.   else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) )
  637.     printchar ( 32 );
  638.   printchar ( 40 );
  639.   incr ( openparens );
  640. #if 0  /* TeX 3.141 */
  641.   print ( curinput.namefield );
  642. #else
  643.   slowprint ( curinput.namefield );
  644. #endif
  645.   flush ( stdout );
  646.   curinput.statefield = 33;
  647.  
  648.   line = 1;
  649.   if ( inputln ( inputfile[ curinput.indexfield ], false ) )
  650.     ;
  651.  
  652.   curinput.limitfield = last;    /* (br) added */
  653.   if ( pausing > 0 )        /* (br) added */
  654.     firmuptheline () ;
  655.  
  656.   if ( endlinecharinactive () ) 
  657.     decr ( curinput.limitfield );
  658.   else
  659.     buffer [ curinput.limitfield ] = endlinechar;
  660.   first = curinput.limitfield + 1;
  661.   curinput.locfield = curinput.startfield;
  662. }
  663.  
  664.  
  665. /* aus tex7.c: */
  666.  
  667. static char err_illegal_mag[] =
  668.     "Illegal magnification has been changed to 1000"; /* 548 */
  669.  
  670. void preparemag ( void )
  671. { preparemag_regmem 
  672.  
  673.   static long magset = 0L;
  674.  
  675.   if ( ( magset > 0 ) && ( mag != magset ) ) {
  676.     print_err("Incompatible magnification (");
  677.     printint ( mag );
  678.     c_print(");");
  679.     c_printnl(" the previous value will be retained");
  680.     zhelp1( STR_H_ICAN_MAGRATIO );
  681.     interror( magset );
  682.     geqworddefine ( intbase + magcode , magset );
  683.   } 
  684.   if ( ( mag <= 0 ) || ( mag > 32768L ) ) {
  685.     print_err(err_illegal_mag);
  686.     zhelp1( STR_H_THEMAGRATIO );
  687.     interror ( mag ) ; 
  688.     geqworddefine ( intbase + magcode , 1000 ) ; 
  689.   } 
  690.   magset = mag;
  691. }
  692.  
  693.  
  694. void newfont ( smallnumber a )
  695. { newfont_regmem
  696.   register scaled s;
  697.   register internalfontnumber f;
  698.   register halfword u;
  699.   strnumber t;
  700.   strnumber flushablestring;
  701.  
  702.   if ( jobname == 0 )
  703.     openlogfile();
  704.  
  705.   getrtoken();
  706.   u = curcs;
  707.   if ( u >= hashbase )
  708.     t = ztext ( u );
  709.   else if ( u >= singlebase )
  710.     if ( u == nullcs )
  711.       t = STR_FONT_;
  712.     else
  713.       t = u - singlebase;
  714.   else {
  715.     register integer oldsetting;
  716.  
  717.     oldsetting = selector;
  718.     selector = newstring;
  719.     print( STR_FONT_ );
  720.     print( u - activebase );
  721.     selector = oldsetting;
  722.     strroom ( 1 );
  723.     t = makestring();
  724.   }
  725.  
  726.   if ( ( a >= 4 ) )
  727.     geqdefine( u, set_font, nullfont );
  728.   else
  729.     eqdefine( u, set_font, nullfont );
  730.  
  731.   scanoptionalequals ();
  732.   scanfilename ();
  733.   nameinprogress = true;
  734.  
  735.   if ( scankeyword ( STR_AT ) ) {
  736.     s = scandimen ( false , false , false );
  737.     if ( s <= 0 || s >= 134217728L ) {
  738.       print_err("Improper `at' size (");
  739.       printscaled ( s ) ; 
  740.       c_print("pt), replaced by 10pt");
  741.       zhelp1( STR_H_ICANONLYHANDLE );
  742.       error();
  743.       s = 10 * unity;
  744.     } 
  745.   } else if ( scankeyword ( STR_SCALED ) ) {
  746.     s = scanint ();    /* s = - (integer) curval; */
  747.     if ( s <= 0 || s > 32768L ) {
  748.       print_err(err_illegal_mag);
  749.       zhelp1( STR_H_THEMAGRATIO );
  750.       interror ( s );
  751.       s = -1000;
  752.     } else
  753.       s = -s;
  754.   } else
  755.     s = -1000;
  756.  
  757.   nameinprogress = false;
  758.   flushablestring = strptr - 1;  /* TeX 3.141 */
  759.   {register integer for_end; f = 1 ; for_end = fontptr ; if ( f <= for_end) 
  760.   do 
  761. #if 0        /* (br) changed */
  762.     if ( streqstr(fontname(f), curname) && streqstr(fontarea(f), curarea) )
  763. #else
  764.     if( str_eq_str(curname, fontname(f)) && str_eq_str(curarea, fontarea(f)) )
  765. #endif
  766.     {
  767.       if ( curname == flushablestring    /* TeX 3.141 */
  768.         && curname != fontname(f) ) {   /* notwendig mit lookup_fncache()!! */
  769. #ifdef FILENAMECACHE
  770.     update_fncache(curname, fontname(f));
  771. #endif
  772.     flushstring;
  773.     curname = fontname(f);
  774.       }
  775.       if ( s > 0 ) {
  776.     if ( s == fontsize(f) ) 
  777.     goto lab50 ; 
  778.       } else if ( fontsize(f) == xnoverd( fontdsize(f), - (integer) s, 1000 ) )
  779.     goto lab50;
  780.     }
  781.   while ( f++ < for_end ) ; } 
  782.  
  783.   f = readfontinfo ( u , curname , curarea , s ) ;
  784.  
  785. lab50:
  786.   equiv ( u ) = f ; 
  787.   eqtb [ fontidbase + f ] = eqtb [ u ] ; 
  788.   fontidtext ( f ) = t ; 
  789. }
  790.  
  791.  
  792. /* -- end -- */
  793.