home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / scanning.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-18  |  21.3 KB  |  952 lines
  1. /* Part 26: Basic scanning subroutines... */
  2.  
  3. #define EXTERN extern
  4. #include "texd.h"
  5.  
  6. void scanleftbrace ( void )        /* 403. */
  7. { scanleftbrace_regmem
  8.   register eightbits r_curcmd;
  9.  
  10.   r_curcmd = getxnbtoken(1);
  11.  
  12.   if ( r_curcmd != 1 ) {
  13.     p_print_err( STR_H_MISSING_LEFTBRACE );
  14.     zhelp1( STR_H_A_LEFTBRACE_MANDATORY );
  15.     backerror();
  16.     curtok = leftbracetoken + 123 ; 
  17.     curcmd = 1 ; 
  18.     curchr = 123 ; 
  19.     incr ( alignstate ) ; 
  20.   }
  21. }
  22.  
  23. void scanoptionalequals ( void )    /* 405. */
  24. { scanoptionalequals_regmem
  25.  
  26.   (void) getxnbtoken(0);
  27.   if ( curtok != othertoken + 61 )
  28.     backinput ();
  29. }
  30.  
  31. boolean scankeyword ( strnumber s )    /* 407. */
  32. { scankeyword_regmem 
  33.   register long_halfword p ;
  34.   register packedASCIIcode *pp, *endp;
  35.  
  36.   p = backuphead;
  37.   link ( p ) = 0;
  38.  
  39.   pp   = &strpool[strstart[s]];        /* k = strstart[s]; */
  40.   endp = &strpool[strstart[s+1]];
  41.   while ( pp < endp ) {            /* (k < strstart[s+1]) */
  42.     register eightbits r_curcmd;
  43.  
  44.     r_curcmd = getxtoken ();        /* *pp: strpool[k] */
  45.     if ( curcs == 0
  46.     && ( (packedASCIIcode)curchr == *pp
  47.       || (packedASCIIcode)curchr == *pp - 32 ) ) {
  48.       storenewtoken ( curtok );
  49.       pp++;
  50.     } else if ( r_curcmd != 10 || (halfword)p != backuphead ) {
  51.       backinput ();
  52.       if ( (halfword)p != backuphead )
  53.     begintokenlist ( link ( backuphead ) , backedup );
  54.       return(false);
  55.     }
  56.   }
  57.   flushlist ( link ( backuphead ) );
  58.   return(true);
  59. }
  60.  
  61. void muerror ( void )        /* 408. */
  62. { muerror_regmem 
  63.  
  64.   print_err ("Incompatible glue units");
  65.   zhelp1( STR_H_IM_GOING_MU_PT );
  66.   error () ; 
  67. } 
  68.  
  69.  
  70. integer scaneightbitint ( void )    /* 433. */
  71. { scaneightbitint_regmem 
  72.   register integer r_curval;
  73.  
  74.   r_curval = scanint (); 
  75.   if ( r_curval < 0 || r_curval > 255 ) {
  76.     print_err("Bad register code");
  77.     zhelp2( STR_H_REGISTERNUMBER_BETWEEN, STR_H_I_CHANGED_TO_ZERO );
  78.     interror ( curval );
  79.     curval = 0L;
  80.     return 0L;
  81.   }
  82.   return r_curval;
  83. }
  84.  
  85. integer scancharnum ( void )
  86. { scancharnum_regmem 
  87.   register integer r_curval;
  88.   
  89.   r_curval = scanint();
  90.   if ( r_curval < 0 || r_curval > 255 ) {
  91.     print_err("Bad character code");
  92.     zhelp2( STR_H_CHARNUMBER_BETWEEN, STR_H_I_CHANGED_TO_ZERO );
  93.     interror ( curval );
  94.     curval = 0L;
  95.     return 0L;
  96.   }
  97.   return r_curval;
  98. }
  99.  
  100. integer scanfourbitint ( void )
  101. { scanfourbitint_regmem 
  102.   register integer r_curval;
  103.  
  104.   r_curval = scanint();
  105.   if ( r_curval < 0 || r_curval > 15 ) {
  106.     print_err("Bad number");
  107.     zhelp2( STR_H_SINCE_I_EXPECT_BETWEEN, STR_H_I_CHANGED_TO_ZERO );
  108.     interror ( curval );
  109.     curval = 0L; 
  110.     return 0L;
  111.   }
  112.   return r_curval;
  113. }
  114.  
  115. integer scanfifteenbitint ( void )
  116. { scanfifteenbitint_regmem
  117.   register integer r_curval;
  118.  
  119.   r_curval = scanint();
  120.   if ( r_curval < 0 || r_curval > 32767 ) {
  121. #if 0  /* TeX 3.141 */
  122.     print_err("Bad math code");
  123. #else
  124.     print_err("Bad mathchar");
  125. #endif
  126.     zhelp2( STR_H_NUMERICMATH_BETWEEN, STR_H_I_CHANGED_TO_ZERO );
  127.     interror ( curval );
  128.     curval = 0L;
  129.     return 0L;
  130.   }
  131.   return r_curval;
  132. }
  133.  
  134. integer scantwentysevenbitint ( void )
  135. { scantwentysevenbitint_regmem 
  136.   register integer r_curval;
  137.  
  138.   r_curval = scanint();
  139.   if ( r_curval < 0 || r_curval > 134217727L ) {
  140.     print_err("Bad delimiter code");
  141.     zhelp2( STR_H_NUMERICDEL_BETWEEN, STR_H_I_CHANGED_TO_ZERO );
  142.     interror ( curval );
  143.     curval = 0L;
  144.     return 0L;
  145.   }
  146.   return r_curval;
  147. }
  148.  
  149. integer scanfontident ( void )        /* 577. */
  150. { scanfontident_regmem
  151.   register internalfontnumber f;
  152.   register eightbits r_curcmd;
  153.  
  154.   r_curcmd = getxnbtoken(0);
  155.  
  156.   if ( r_curcmd == def_font )
  157.     f = curfont;
  158.   else if ( r_curcmd == set_font )
  159.     f = curchr;
  160.   else if ( r_curcmd == def_family ) {
  161.     register halfword m;
  162.     m = curchr;
  163.     f = equiv( m + scanfourbitint() );
  164.   } else {
  165.     print_err("Missing font identifier");
  166.     zhelp1( STR_H_I_LOOKING_FOR_CS );
  167.     backerror();
  168.     f = nullfont;
  169.   }
  170.   curval = f;
  171.   return (integer)f;
  172. }
  173.  
  174.  
  175. integer findfontdimen ( boolean writing )    /* 578. */
  176. { findfontdimen_regmem
  177.   register internalfontnumber f;
  178.   register integer n;
  179.   register integer r_curval;
  180.  
  181.   n = scanint ();
  182.   f = scanfontident();
  183.   if ( n <= 0 )
  184.     r_curval = fmemptr;
  185.   else {
  186.     if ( writing && ( n <= spaceshrinkcode )
  187.     && ( n >= spacecode ) && ( fontglue(f) != 0 ) )
  188.     {
  189.       deleteglueref ( fontglue(f) );
  190.       fontglue(f) = 0;
  191.     }
  192.     if ( n > fontparams(f) ) {
  193.       if ( f < fontptr ) {
  194.     r_curval = fmemptr ; 
  195.       } else {
  196.     do {
  197.       if ( fmemptr == fontmemsize ) 
  198.         overflow(11, fontmemsize);
  199.       fontinfo [ fmemptr ] .cint = 0 ; 
  200.       incr ( fmemptr ) ; 
  201.       incr ( fontparams(f) ) ; 
  202.         } while ( n != fontparams(f) );
  203.         r_curval = fmemptr - 1;
  204.       }
  205.     } else {
  206.       r_curval = n + parambase(f);
  207.     }
  208.   }
  209.  
  210.   curval = r_curval;
  211.  
  212.   if ( r_curval == fmemptr ) {
  213.     print_err("Font ");
  214.     printesc ( fontidtext ( f ) );
  215.     c_print(" has only ");
  216.     printint ( fontparams(f) );
  217.     c_print(" fontdimen parameters");
  218.     zhelp1( STR_H_TO_INCREASE_FNTP );
  219.     error();
  220.     return curval;
  221.   } else {
  222.     return r_curval;
  223.   }
  224. }
  225.  
  226.  
  227.   static void
  228. missing_number_error(void)
  229. {
  230.   print_err("Missing number, treated as zero");
  231.   zhelp1( STR_H_ANUMBER_SHOULD_HERE );
  232.   backerror();
  233. }
  234.  
  235.  
  236.   integer
  237. scansomethinginternal ( smallnumber level, boolean negative ) /* 413. */
  238. { scansomethinginternal_regmem 
  239.   register halfword m;
  240.   register integer r_curval;
  241.   register schar r_curvallevel;
  242.  
  243.   m = curchr;
  244.   switch ( curcmd ) {
  245.   case def_code:
  246.       r_curval = scancharnum () ; 
  247.       if ( m == mathcodebase ) {
  248.     r_curval = mathcode ( r_curval );
  249.     r_curvallevel = intval;
  250.       } else if ( m < mathcodebase ) {
  251.     r_curval = equiv ( m + r_curval ) ; 
  252.     r_curvallevel = intval ; 
  253.       } else {
  254.     r_curval = eqtb [ m + r_curval ] .cint ; 
  255.     r_curvallevel = intval ; 
  256.       }
  257.       break;
  258.   case toks_register:
  259.   case assign_toks:
  260.   case def_family:
  261.   case set_font:
  262.   case def_font:
  263.     if ( level != tokval ) {
  264.       missing_number_error();
  265.       r_curval = 0 ; 
  266.       r_curvallevel = dimenval ; 
  267.     } else if ( curcmd <= assign_toks ) {
  268.       if ( curcmd < assign_toks ) {
  269.     r_curval = scaneightbitint () ;
  270.     m = toksbase + r_curval ;
  271.       }
  272.       r_curval = equiv(m);
  273.       r_curvallevel = tokval;
  274.     } else {
  275.       backinput ();
  276.       r_curval = scanfontident ();
  277.       r_curval = fontidbase + r_curval ; 
  278.       r_curvallevel = identval ; 
  279.     }
  280.     break;
  281.   case assign_int:
  282.     r_curval = eqtb[m].cint;
  283.     r_curvallevel = intval;
  284.     break ; 
  285.   case assign_dimen:
  286.     r_curval = eqtb [ m ] .cint;
  287.     r_curvallevel = dimenval;
  288.     break;
  289.   case assign_glue:
  290.     r_curval = equiv ( m );
  291.     r_curvallevel = glueval;
  292.     break;
  293.   case assign_mu_glue:
  294.     r_curval = equiv ( m );
  295.     r_curvallevel = muval;
  296.     break;
  297.   case set_aux:
  298.     if ( abs ( curlist.modefield ) != m ) {
  299.       p_print_err( STR_H_IMPROPER );
  300.       printcmdchr( set_aux, m );
  301.       zhelp2( STR_H_YOU_REFER_SPACEFACTOR, STR_H_IM_FORGETTING_ZERO );
  302.       error ();
  303.       r_curval = 0;
  304.       if ( level != tokval ) {
  305.     r_curvallevel = dimenval;
  306.       } else {
  307.     r_curvallevel = intval;
  308.       }
  309.     } else if ( m == vmode ) {
  310.       r_curval = curlist .auxfield .cint;
  311.       r_curvallevel = dimenval;
  312.     } else {
  313.       r_curval = curlist .auxfield .hh .v.LH;
  314.       r_curvallevel = intval;
  315.     }
  316.     break;
  317.   case set_prev_graf: 
  318.     if ( curlist .modefield == 0 ) {
  319.       r_curval = 0;
  320.       r_curvallevel = intval;
  321.     } else {    
  322.       register integer p;
  323.  
  324.       nest [ nestptr ] = curlist;
  325.       p = nestptr;
  326.       while ( abs ( nest [ p ] .modefield ) != vmode )
  327.     decr ( p );
  328.       r_curval = nest [ p ] .pgfield;
  329.       r_curvallevel = intval;
  330.     }
  331.     break ;
  332.   case set_page_int:
  333.     if ( m == 0 ) 
  334.     r_curval = deadcycles ; 
  335.     else
  336.     r_curval = insertpenalties ; 
  337.     r_curvallevel = intval ; 
  338.     break ; 
  339.   case set_page_dimen:
  340.     if ( pagecontents == 0 && !outputactive )
  341.       if ( m == 0 )
  342.     r_curval = maxdimen;
  343.       else
  344.     r_curval = 0;
  345.     else
  346.       r_curval = pagesofar [ m ];
  347.     r_curvallevel = dimenval;
  348.     break ; 
  349.   case set_shape:
  350.     if ( parshapeptr == 0 ) 
  351.     r_curval = 0;
  352.     else
  353.     r_curval = info ( parshapeptr );
  354.     r_curvallevel = intval ; 
  355.     break ; 
  356.   case set_box_dimen:
  357.     r_curval = scaneightbitint ();
  358.     if ( box ( r_curval ) == 0 )
  359.     r_curval = 0;
  360.     else
  361.     r_curval = mem [ box ( r_curval ) + m ] .cint;
  362.     r_curvallevel = dimenval ; 
  363.     break ; 
  364.   case chargiven:
  365.   case math_given:
  366.     r_curval = curchr;
  367.     r_curvallevel = intval;
  368.     break ; 
  369.   case assign_font_dimen:
  370.     r_curval = findfontdimen ( false );
  371.     fontinfo[fmemptr].cint = 0;
  372.     r_curval = fontinfo [ r_curval ] .cint;
  373.     r_curvallevel = dimenval;
  374.     break;
  375.   case assign_font_int:
  376.     r_curval = scanfontident ();
  377.     if ( m == 0 ) {
  378.     r_curval = hyphenchar(r_curval);
  379.     } else {      
  380.     r_curval = skewchar(r_curval);
  381.     }
  382.     r_curvallevel = intval ; 
  383.     break ; 
  384.   case register_cmd:
  385.     {
  386.       r_curval = scaneightbitint ();
  387.       switch ( m ) {
  388.       case intval :
  389.     r_curval = count ( r_curval );
  390.     break ; 
  391.       case dimenval : 
  392.     r_curval = dimen ( r_curval ) ;
  393.     break ;
  394.       case glueval : 
  395.     r_curval = skip ( r_curval ) ;
  396.     break ; 
  397.       case muval : 
  398.     r_curval = muskip ( r_curval ) ;
  399.     break ; 
  400.       }
  401.       r_curvallevel = m ; 
  402.     }
  403.     break ; 
  404.   case last_item:
  405.     if ( curchr > glueval ) {
  406.       if ( curchr == inputlinenocode ) 
  407.     r_curval = line ; 
  408.       else
  409.     r_curval = lastbadness ; 
  410.       r_curvallevel = intval ; 
  411.     } else {    
  412.       if ( curchr == glueval )
  413.     r_curval = zeroglue ; 
  414.       else
  415.     r_curval = 0 ; 
  416.       r_curvallevel = curchr;
  417.       if ( ! ischarnode ( curlist.tailfield ) && ( curlist.modefield != 0 ) ) {
  418.     switch ( curchr ) {
  419.     case intval : 
  420.       if ( ztype ( curlist .tailfield ) == penaltynode )
  421.         r_curval = mem [ curlist .tailfield + 1 ] .cint ; 
  422.       break ; 
  423.     case dimenval : 
  424.       if ( ztype ( curlist .tailfield ) == kernnode ) 
  425.         r_curval = width ( curlist .tailfield ) ; 
  426.       break ; 
  427.     case glueval : 
  428.       if ( ztype ( curlist .tailfield ) == gluenode ) {
  429.         r_curval = glueptr ( curlist .tailfield ) ; 
  430.         if ( subtype ( curlist .tailfield ) == muglue ) 
  431.           r_curvallevel = muval ; 
  432.       }
  433.       break;
  434.     }
  435.       } else if ( curlist .modefield == vmode
  436.            && curlist.tailfield == curlist.headfield ) {
  437.     switch ( curchr ) {
  438.     case intval : 
  439.       r_curval = lastpenalty ; 
  440.       break ; 
  441.     case dimenval : 
  442.       r_curval = lastkern ; 
  443.       break ; 
  444.     case glueval : 
  445.       if ( lastglue != maxhalfword ) 
  446.         r_curval = lastglue ; 
  447.       break;
  448.     }
  449.       }
  450.     }
  451.     break;
  452.   default: 
  453.     {
  454.       p_print_err( STR_H_YOUCANTUSE );
  455.       printcmdchr( curcmd, curchr );
  456.       print( STR_H_AFTER );
  457.       printesc( STR_THE );
  458.       zhelp1( STR_H_IM_FORGETTING_ZERO );
  459.       error () ; 
  460.       r_curval = 0;
  461.       if ( level != tokval ) {
  462.     r_curvallevel = dimenval;
  463.       } else {
  464.     r_curvallevel = intval;
  465.       }
  466.     }
  467.     break;
  468.   }
  469.  
  470.   while ( r_curvallevel > level ) {      
  471.     if ( r_curvallevel == glueval )
  472.       r_curval = width ( r_curval ) ; 
  473.     else if ( r_curvallevel == muval ) {
  474.       muerror ();
  475.       /* Possible insertions in error()... reload registers */
  476.       r_curval = curval; r_curvallevel = curvallevel;
  477.     }
  478.     decr ( r_curvallevel );
  479.   }
  480.   if ( negative ) {
  481.     if ( r_curvallevel >= glueval ) {
  482.       curval = r_curval = newspec ( r_curval );
  483.       width ( r_curval ) = - (integer) width ( r_curval );
  484.       stretch ( r_curval ) = - (integer) stretch ( r_curval );
  485.       shrink ( r_curval ) = - (integer) shrink ( r_curval );
  486.     } else {
  487.       r_curval = - (integer) r_curval;
  488.     }
  489.   } else if ( r_curvallevel >= glueval && r_curvallevel <= muval ) {
  490.     addglueref ( r_curval );
  491.   }
  492.  
  493.   /* Update global values... */
  494.   curvallevel = r_curvallevel;
  495.   curval = r_curval;
  496.  
  497.   return r_curval;
  498. }
  499.  
  500.  
  501.   integer
  502. scanint ( void )        /* 440. */
  503. { scanint_regmem
  504.   boolean negative;
  505.   register eightbits r_curcmd;
  506.  
  507.   radix = 0;
  508.   negative = false;
  509.   do {
  510.     r_curcmd = getxnbtoken(0);
  511.     if ( curtok == othertoken + 45 ) {
  512.       negative = ! negative ; 
  513.       curtok = othertoken + 43 ;
  514.     }
  515.   } while ( curtok == othertoken + 43 );
  516.  
  517.   if ( curtok == alphatoken ) {
  518.     r_curcmd = gettoken();
  519.     if ( curtok < cstokenflag ) {
  520.       curval = curchr ;
  521.       if ( r_curcmd <= 2 ) 
  522.     if ( r_curcmd == 2 ) 
  523.       incr ( alignstate ) ; 
  524.     else
  525.       decr ( alignstate );
  526.     } else if ( curtok < cstokenflag + singlebase )
  527.       curval = curtok - cstokenflag - activebase;
  528.     else
  529.       curval = curtok - cstokenflag - singlebase;
  530.  
  531.     if ( curval > 255 ) {
  532.       print_err("Improper alphabetic constant");
  533.       zhelp1( STR_H_ONECHAR_CS_BELONGS );
  534.       curval = 48;
  535.       backerror ();
  536.     } else {
  537.       if ( (eightbits)getxtoken() != 10 )
  538.         backinput();
  539.     }
  540.  
  541.   } else if ( r_curcmd >= min_internal && r_curcmd <= max_internal )
  542.  
  543.     scansomethinginternal ( intval , false ) ; 
  544.  
  545.   else {
  546.       
  547.     register integer m;
  548.     boolean vacuous;
  549.     boolean OKsofar;
  550.  
  551.     radix = 10 ; 
  552.     m = 214748364L ; 
  553.     if ( curtok == octaltoken ) {
  554.       radix = 8 ; 
  555.       m = 268435456L ; 
  556.       getxtoken () ; 
  557.     } else if ( curtok == hextoken ) {
  558.       radix = 16 ; 
  559.       m = 134217728L ; 
  560.       getxtoken () ; 
  561.     } 
  562.     OKsofar = true;
  563.     vacuous = true;
  564.     curval = 0;
  565.  
  566.     while ( true ) {
  567.       register smallnumber d;
  568.  
  569.       if ( ( curtok < zerotoken + radix ) && ( curtok >= zerotoken )
  570.         && ( curtok <= zerotoken + 9 ) )
  571.     d = curtok - zerotoken ; 
  572.       else if ( radix == 16 ) 
  573.     if ( ( curtok <= Atoken + 5 ) && ( curtok >= Atoken ) ) 
  574.       d = curtok - Atoken + 10 ; 
  575.      else if ( ( curtok <= otherAtoken + 5 ) && ( curtok >= otherAtoken ) ) 
  576.       d = curtok - otherAtoken + 10;
  577.     else goto lab30;
  578.       else
  579.     goto lab30;
  580.       vacuous = false;
  581.       if ( curval >= m && ( curval > m || d > 7 || ( radix != 10 ) ) ) {
  582.     if ( OKsofar ) {
  583.       print_err("Number too big");
  584.       zhelp1( STR_H_ICAN_ONLY_GOUPTO );
  585.       error();
  586.       curval = infinity;
  587.       OKsofar = false;
  588.     }
  589.       } else
  590.     curval = curval * radix + d;
  591.       getxtoken();
  592.     }
  593.  
  594. lab30:
  595.     if ( vacuous ) {
  596.       missing_number_error();
  597.     } else if ( curcmd != 10 ) 
  598.       backinput () ;
  599.   }
  600.   if ( negative )
  601.     curval = - (integer) curval;
  602.  
  603.   return curval;
  604. }
  605.  
  606. static char *Illegal_Unit_of_Measure = "Illegal unit of measure (";
  607.  
  608.   integer
  609. scandimen ( boolean mu, boolean inf, boolean shortcut )        /* 448. */
  610. { scandimen_regmem
  611.   boolean negative;
  612.   register integer f;
  613.   register integer r_curval;
  614.  
  615.   f = 0 ; 
  616.   aritherror = false ; 
  617.   curorder = normal ; 
  618.   negative = false ; 
  619.   if ( ! shortcut ) {
  620.     negative = false ; 
  621.     do {
  622.       (void) getxnbtoken(0);
  623.       if ( curtok == othertoken + 45 ) {
  624.     negative = ! negative ;
  625.     curtok = othertoken + 43 ;
  626.       }
  627.     } while ( curtok == othertoken + 43 );
  628.  
  629.     if ( curcmd >= min_internal && curcmd <= max_internal ) {
  630.       if ( mu ) {
  631.     r_curval = scansomethinginternal ( muval , false ) ; 
  632.     if ( curvallevel >= glueval ) {
  633.       register scaled v;
  634.  
  635.       v = width ( r_curval ) ; 
  636.       deleteglueref ( r_curval ) ; 
  637.       curval = r_curval = v ; 
  638.     }
  639.     if ( curvallevel == muval ) 
  640.       goto lab89 ; 
  641.     if ( curvallevel != intval ) 
  642.       muerror ();
  643.       } else {
  644.     r_curval = scansomethinginternal ( dimenval , false ) ; 
  645.     if ( curvallevel == dimenval ) 
  646.       goto lab89 ; 
  647.       }
  648.     } else {        /* not internal.. */
  649.       backinput ();
  650.       if ( curtok == continentalpointtoken ) 
  651.     curtok = pointtoken ; 
  652.       if ( curtok != pointtoken ) 
  653.     scanint ();
  654.       else {
  655.     radix = 10;
  656.     curval = 0;
  657.       }
  658.       if ( curtok == continentalpointtoken ) 
  659.     curtok = pointtoken ;
  660.  
  661.       if ( radix == 10 && curtok == pointtoken ) {
  662.     register long_halfword p;
  663.     register smallnumber k; 
  664.  
  665.     k = 0; p = 0;
  666.     gettoken();
  667.  
  668.     while ( true ) {
  669.       getxtoken () ; 
  670.       if ( ( curtok > zerotoken + 9 ) || ( curtok < zerotoken ) ) 
  671.         goto lab31 ; 
  672.       if ( k < 17 ) {
  673.         register long_halfword q;
  674.  
  675.         q = getavail () ; 
  676.         link ( q ) = p ; 
  677.         info ( q ) = curtok - zerotoken ; 
  678.         p = q ; 
  679.         incr ( k ) ; 
  680.       }
  681.     }
  682.  
  683. lab31:
  684.     { short kk;
  685. #if 0
  686.     for( kk = k ; kk >= 1 ; --kk ) {
  687.       register long_halfword q;
  688.  
  689.       dig [ kk - 1 ] = info ( p ) ; 
  690.       q = p ; p = link ( p ) ; freeavail ( q ) ; 
  691.     }
  692.     f = rounddecimals ( k ) ; 
  693. #else
  694.     f = 0;
  695.     kk = k;
  696.     while ( kk > 0 ) {
  697.       register long_halfword q;
  698.  
  699.       decr ( kk ) ; 
  700.       f = ( f + ((schar) info(p)) * two ) / 10; 
  701.       q = p; p = link(p); freeavail(q);
  702.     }
  703.     f = (f + 1) / 2;
  704. #endif
  705.     }
  706.     if ( curcmd != 10 ) 
  707.       backinput () ;
  708.       }    /* end... scan decimal fraction */
  709.     }    /* end... not internal quantity */
  710.   }    /* end... !shortcut */
  711.  
  712.   if ( curval < 0 ) {
  713.     negative = ! negative;
  714.     curval = - (integer) curval;
  715.   }
  716.  
  717.   if ( inf ) {
  718.     if ( scankeyword( STR_FIL ) ) {    /* "fil" */
  719.       curorder = fil;
  720.       while ( scankeyword( 108 ) ) {    /* "l" */
  721.     if ( curorder == filll ) {
  722.       print_err(Illegal_Unit_of_Measure);
  723.       c_print("replaced by filll)");
  724.       zhelp1( STR_H_I_DDDONT_GO );
  725.       error ();
  726.     } else
  727.       incr ( curorder );
  728.       }
  729.       goto lab88;
  730.     }
  731.   }
  732.  
  733.  
  734.   /* 455. Scan for units that are internal dimensions.. */
  735.   { integer savecurval;
  736.     halfword r_curcmd;
  737.     scaled v;
  738.  
  739.   savecurval = curval ; 
  740.   r_curcmd = getxnbtoken(0);
  741.   if ( r_curcmd < min_internal || r_curcmd > max_internal )
  742.     backinput ();
  743.   else {
  744.     if ( mu ) {
  745.       scansomethinginternal ( muval , false );
  746.       if ( curvallevel >= glueval ) {
  747.     v = width ( curval ) ; 
  748.     deleteglueref ( curval );
  749.     curval = v;
  750.       }
  751.       if ( curvallevel != muval ) 
  752.     muerror () ; 
  753.     } else
  754.       scansomethinginternal ( dimenval , false ) ; 
  755.     v = curval;
  756.     goto lab40 ; 
  757.   }
  758.  
  759.   if ( mu )
  760.     goto lab45;
  761.  
  762.   if ( scankeyword( STR_EM ) )
  763.     v = quad ( curfont );
  764.   else if ( scankeyword( STR_EX ) )
  765.     v = xheight ( curfont );
  766.   else
  767.     goto lab45;
  768.   {
  769.     if ( (eightbits)getxtoken() != 10 )
  770.       backinput ();
  771.   }
  772. lab40:
  773.   r_curval = multandadd (savecurval, v, xnoverd (v, f, 65536L), 1073741823L);
  774.   goto lab89;
  775.  }
  776.  
  777.  
  778. lab45:
  779.   if ( mu ) {
  780.     if ( scankeyword( STR_MU ) ) {    /* "mu" */
  781.       goto lab88;
  782.     } else {
  783.       print_err(Illegal_Unit_of_Measure);
  784.       c_print("mu inserted)");
  785.       zhelp2( STR_H_UNIT_IN_MATHGLUE, STR_H_TO_RECOVER_GRACEF );
  786.       error ();
  787.       goto lab88;
  788.     }
  789.   }
  790.  
  791.   if ( scankeyword( STR_TRUE ) ) {        /* "true" */
  792.     preparemag ();
  793.     if ( mag != 1000 ) {
  794.       curval = xnoverd ( curval , 1000 , mag );
  795.       f = ( 1000 * f + 65536L * remainder ) / mag;
  796.       curval = curval + ( f / 65536L );
  797.       f = f % 65536L;
  798.     }
  799.   }
  800.  
  801.   if ( scankeyword( STR_PT ) )        /* "pt" */
  802.     goto lab88;
  803.  
  804.  { register integer num, denom;
  805.  
  806.   if ( scankeyword( STR_IN ) ) {
  807.     num = 7227;    denom = 100;
  808.   } else if ( scankeyword( STR_PC ) ) {
  809.     num = 12;    denom = 1;
  810.   } else if ( scankeyword( STR_CM ) ) {
  811.     num = 7227;    denom = 254;
  812.   } else if ( scankeyword( STR_MM ) ) {
  813.     num = 7227;    denom = 2540;
  814.   } else if ( scankeyword( STR_BP ) ) {
  815.     num = 7227;    denom = 7200;
  816.   } else if ( scankeyword( STR_DD ) ) {
  817.     num = 1238;    denom = 1157;
  818.   } else if ( scankeyword( STR_CC ) ) {
  819.     num = 14856; denom = 1157;
  820.   } else if ( scankeyword( STR_SP ) )
  821.     goto lab30;
  822.   else {
  823.     print_err(Illegal_Unit_of_Measure);
  824.     c_print("pt inserted)");
  825.     zhelp2( STR_H_DIMENSIONS_EMEX, STR_H_TO_RECOVER_GRACEF );
  826.     error () ; 
  827.     goto lab32 ; 
  828.   } 
  829.   curval = xnoverd ( curval , num , denom ) ; 
  830.   f = ( num * f + 65536L * remainder ) / denom ; 
  831.   curval = curval + ( f / 65536L ) ; 
  832.   f = f % 65536L ;
  833. lab32: ;
  834.  }
  835.  
  836. lab88:
  837.   if ( curval >= 16384 ) 
  838.     aritherror = true;
  839.   else
  840.     curval = curval * unity + f;
  841.  
  842. lab30: ; 
  843.   {
  844.     if ( (eightbits)getxtoken() != 10 )
  845.       backinput();
  846.   } 
  847.   r_curval = curval;
  848.  
  849. lab89:
  850.   if ( aritherror || ( abs ( r_curval ) >= 1073741824L ) ) {
  851.     print_err("Dimension too large");
  852.     zhelp1( STR_H_ICANT_WORK_BIGGER );
  853.     error();
  854.     r_curval = maxdimen;
  855.     aritherror = false;
  856.   }
  857.   if ( negative )
  858.     r_curval = - (integer) r_curval;
  859.  
  860.   curval = r_curval;
  861.   return r_curval;
  862. }
  863.  
  864.  
  865.   long_halfword
  866. scanglue ( smallnumber level )        /* 461. */
  867. { scanglue_regmem
  868.   boolean negative;
  869.   register long_halfword q;
  870.   boolean mu;
  871.   register eightbits r_curcmd;
  872.   register integer r_curval;
  873.  
  874.   negative = false ; 
  875.   do {
  876.     r_curcmd = getxnbtoken(0);
  877.     if ( curtok == othertoken + 45 ) {
  878.       negative = ! negative ; 
  879.       curtok = othertoken + 43 ; 
  880.     }
  881.   } while ( curtok == othertoken + 43 ) ; 
  882.  
  883.   mu = ( level == muval );
  884.   if ( r_curcmd >= min_internal && r_curcmd <= max_internal ) {
  885.     r_curval = scansomethinginternal ( level , negative );
  886.     if ( curvallevel >= glueval ) {
  887.       if ( curvallevel != level ) {
  888.     muerror ();
  889.     r_curval = curval;
  890.       }
  891.       return r_curval; 
  892.     }
  893.     if ( curvallevel == intval ) 
  894.       r_curval = scandimen ( mu , false , true );
  895.     else if ( level == muval ) {
  896.       muerror ();
  897.       r_curval = curval;
  898.     }
  899.   } else {
  900.     backinput () ; 
  901.     r_curval = scandimen ( mu, false, false );
  902.     if ( negative )
  903.       r_curval = - (integer) r_curval;
  904.   }
  905.  
  906.   q = newspec ( zeroglue );
  907.   width ( q ) = r_curval;
  908.  
  909.   if ( scankeyword( STR_PLUS ) ) {        /* "plus" */
  910.     stretch ( q ) = scandimen ( mu , true , false );
  911.     stretchorder ( q ) = curorder;
  912.   }
  913.   if ( scankeyword( STR_MINUS ) ) {        /* "minus" */
  914.     shrink ( q ) = scandimen ( mu , true , false );
  915.     shrinkorder ( q ) = curorder ; 
  916.   }
  917.  
  918.   curval = q;
  919.   return q;
  920. }
  921.  
  922. long_halfword scanrulespec ( void )
  923. { scanrulespec_regmem 
  924.   register long_halfword q;
  925.  
  926.   q = newrule ();
  927.   if ( curcmd == 35 )
  928.     width ( q ) = defaultrule;
  929.   else {
  930.     height ( q ) = defaultrule;
  931.     depth ( q ) = 0;
  932.   }
  933.  
  934. lab21:
  935.   if ( scankeyword( STR_WIDTH ) ) {
  936.     width(q) = scandimen ( false , false , false );
  937.     goto lab21;
  938.   }
  939.   if ( scankeyword( STR_HEIGHT ) ) {
  940.     height(q) = scandimen ( false , false , false );
  941.     goto lab21;
  942.   }
  943.   if ( scankeyword( STR_DEPTH ) ) {
  944.     depth(q) = scandimen ( false , false , false );
  945.     goto lab21 ; 
  946.   }
  947.  
  948.   return(q);
  949. }
  950.  
  951. /* -- end -- */
  952.