home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / mainctrl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-14  |  24.0 KB  |  1,122 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4.  
  5. static void appspace ( void )
  6. { appspace_regmem 
  7.   register halfword q;
  8.  
  9.   register liststaterecord * curlistp = &curlist;
  10. #define curlist (*curlistp)
  11.  
  12.   if ( ( curlist .auxfield .hh .v.LH >= 2000 ) && ( xspaceskip != zeroglue ) ) 
  13.     q = newparamglue ( xspaceskipcode );
  14.   else {
  15.     register halfword mainp;
  16.     register internalfontnumber mainf = curfont;    /* (br) */
  17.  
  18.     if ( spaceskip != zeroglue ) 
  19.       mainp = spaceskip;
  20.     else {
  21.       mainp = fontglue(mainf); 
  22.       if ( mainp == 0 ) {
  23.     register SMALLmemoryword *gluep;    /* halfword maink; */
  24.  
  25.     mainp = newspec ( zeroglue ) ;
  26.     gluep = &fontinfo[ parambase(mainf) + spacecode ];    /* maink=...*/
  27.     width ( mainp )   = gluep++->cint;    /* fontinfo[maink].cint; */
  28.     stretch ( mainp ) = gluep++->cint;    /* fontinfo[maink+1].cint; */
  29.     shrink ( mainp )  = gluep->cint;    /* fontinfo[maink+2].cint; */
  30.     fontglue(mainf) = mainp;
  31.       }
  32.     }
  33.     mainp = newspec ( mainp ) ; 
  34.     if ( curlist .auxfield .hh .v.LH >= 2000 ) 
  35.       width ( mainp ) += extraspace ( mainf ) ;
  36.     stretch(mainp) = xnoverd(stretch(mainp), curlist.auxfield.hh.v.LH, 1000);
  37.     shrink(mainp)  = xnoverd(shrink(mainp), 1000, curlist.auxfield.hh.v.LH);
  38.     q = newglue ( mainp );
  39.     gluerefcount ( mainp ) = 0;
  40.   }
  41.   link ( curlist .tailfield ) = q ;
  42.   curlist .tailfield = q ;
  43.  
  44. #undef curlist
  45. }
  46.  
  47.  
  48. void maincontrol ( void )
  49. {  maincontrol_regmem 
  50.  
  51.   /* Try to force the Compiler to free all registers for this
  52.    * function.  (This function is only leaved at the end of the job.)
  53.    */
  54.   /* register */ integer t;
  55.   register internalfontnumber mainf;
  56.   /* register */ fourquarters maini, mainj;
  57.   register fontindex maink;
  58.   /* register halfword mainp; */
  59. #ifdef BIG
  60.   register integer mains;
  61. #else
  62.   register signed short mains;
  63. #endif
  64.   register SMALLmemoryword *ligp;    /* (br) ptr in lig program */
  65.   register long_halfword ligstack;
  66.   register halfword curl, curr, curq;
  67.   register /* eightbits */ long_halfword r_curcmd;
  68.  
  69.   register liststaterecord * curlistp = &curlist;
  70. #define curlist (*curlistp)
  71.  
  72.   boolean insdisc = false;
  73. halfword bchar = nonchar;
  74. halfword falsebchar = nonchar;
  75. boolean cancelboundary = false;
  76.  
  77.   if ( everyjob != 0 )
  78.     begintokenlist ( everyjob , everyjobtext );
  79.  
  80. lab60:        /* big_switch */
  81.   r_curcmd = getxtoken ();
  82.  
  83. lab21:        /* reswitch */
  84.   if ( interrupt != 0 && OKtointerrupt ) {
  85.     backinput ();
  86.     if ( interrupt != 0 )
  87.       pauseforinstructions ();
  88.     goto lab60;
  89.   }
  90.  
  91. #ifdef DEBUG
  92.   if ( panicking )
  93.     checkmem ( false );
  94. #endif /* DEBUG */
  95.  
  96.   if ( tracingcommands > 0 )
  97.     showcurcmdchr ();
  98.  
  99.   mains = curlist.modefield;
  100.   if( mains < 0 ) mains = -mains;
  101.  
  102. #if 0
  103.   switch ( mains + r_curcmd )
  104. #else
  105.   switch ( r_curcmd )
  106. #endif
  107.   {                        /* switch begin */
  108.   case charnum :
  109.     if( mains == hmode ) {
  110. #if 0
  111.       curchr = scancharnum ();  /* curchr = curval; */
  112. #else
  113.       r_curcmd = scancharnum ();
  114.       curchr = r_curcmd;
  115. #endif
  116.       goto lab70;
  117.     } else if( mains == vmode ) {
  118.       backinput();  newgraf(true);
  119.     } else {
  120.       curchr = scancharnum ();  /* curchr = curval; */
  121.       setmathchar ( mathcode ( curchr ) ) ; 
  122.     }
  123.     break;
  124.  
  125.   case letter :
  126.   case otherchar :
  127.   case chargiven :
  128.     if( mains == hmode ) {
  129.       goto lab701 /*lab70*/;
  130.     } else if( mains == vmode ) {
  131.       backinput () ; newgraf ( true ) ; 
  132.     } else {
  133.       setmathchar ( mathcode ( curchr ) ) ; 
  134.     }
  135.     break;
  136.  
  137.   case noboundary :
  138.     if( mains == hmode ) {
  139.       r_curcmd = getxtoken ();
  140.       if ( (eightbits)r_curcmd == letter || (eightbits)r_curcmd == otherchar
  141.     || (eightbits)r_curcmd == chargiven || (eightbits)r_curcmd == charnum )
  142.         cancelboundary = true;
  143.       goto lab21;
  144.     } else if( mains == vmode ) {
  145.       backinput () ; newgraf ( true ) ; 
  146.     } else {
  147.       /* nothing */
  148.     }
  149.     break;
  150.  
  151.   case spacer:
  152.     if( mains == hmode ) {
  153.       if ( curlist .auxfield .hh .v.LH != 1000 ) {    /* space_factor */
  154.     appspace ();
  155.     break;
  156.       } else {
  157.     goto lab120;
  158.       }
  159.     } else {
  160.       /* nothing */
  161.     }
  162.     break;
  163.  
  164.   case exspace :
  165.     if( mains == vmode ) {
  166.       backinput () ;  newgraf ( true ) ; 
  167.     } else {
  168.       long_halfword tempptr;
  169. lab120:
  170.  
  171.       if ( spaceskip == zeroglue ) {
  172.     register internalfontnumber tmp_cf = curfont;
  173.     register long_halfword mainp;
  174.  
  175.     mainp = fontglue(tmp_cf); 
  176.     if ( mainp == 0 ) {
  177.       register SMALLmemoryword *gluep;
  178.  
  179.       mainp = newspec ( zeroglue ) ; 
  180.       gluep = &fontinfo[ parambase(tmp_cf) + spacecode ];    /* maink=... */
  181.       width ( mainp )   = gluep++->cint;    /* fontinfo[maink].cint; */
  182.       stretch ( mainp ) = gluep++->cint;    /* fontinfo[maink+1].cint; */
  183.       shrink ( mainp )  = gluep->cint;    /* fontinfo[maink+2].cint; */
  184.       fontglue(tmp_cf) = mainp;
  185.     }
  186.     tempptr = newglue ( mainp );
  187.       } else
  188.     tempptr = newparamglue ( spaceskipcode ) ; 
  189.       link ( curlist .tailfield ) = tempptr ; 
  190.       curlist .tailfield = tempptr ; 
  191.       goto lab60;
  192.     }
  193.     break;
  194.  
  195.     /* cases of main_control that are not part of the inner loop */
  196.   case relax :
  197.     break;
  198.  
  199.   case ignorespaces :
  200.     r_curcmd = getxnbtoken(0);
  201.     goto lab21;
  202.     break;
  203.  
  204.   case stop :
  205.     if( mains == hmode ) {
  206.       headforvmode () ;
  207.     } else if( mains == vmode ) {
  208.       if ( itsallover () )
  209.     return ;
  210.     } else {
  211.       insertdollarsign () ;
  212.     }
  213.     break;
  214.  
  215.   case vmove :
  216.     if( mains == vmode ) {
  217.       reportillegalcase () ;
  218.     } else {
  219.       /* register integer t; */
  220.       register integer r_curval;
  221.  
  222.       t = curchr;
  223.       r_curval = scandimen ( false , false , false ); 
  224.       if ( t == 0 )
  225.         scanbox ( r_curval );
  226.       else
  227.     scanbox ( - (integer) r_curval );
  228.     }
  229.     break;
  230.  
  231.   case hmove :
  232.     if( mains != vmode ) {
  233.       reportillegalcase () ;
  234.     } else {
  235.       /* register integer t; */
  236.       register integer r_curval;
  237.  
  238.       t = curchr;
  239.       r_curval = scandimen ( false , false , false );
  240.       if ( t == 0 )
  241.         scanbox ( r_curval );
  242.       else
  243.     scanbox ( - (integer) r_curval );
  244.     }
  245.     break;
  246.  
  247.   case last_item :
  248.     reportillegalcase () ; 
  249.     break ; 
  250.  
  251.   case vadjust :
  252.     if( mains == vmode ) {
  253.       reportillegalcase () ;
  254.     } else {
  255.       begininsertoradjust () ;
  256.     }
  257.     break;
  258.  
  259.   case ital_corr :
  260.     if( mains == hmode ) {
  261.       appenditaliccorrection () ;
  262.     } else if( mains == vmode ) {
  263.       reportillegalcase () ;
  264.     } else {
  265.       tailappend ( newkern ( 0 ) ) ;
  266.     }
  267.     break;
  268.  
  269.   case eq_no :
  270.     if( mains != mmode ) {
  271.       reportillegalcase () ;
  272.     } else {
  273.       if ( privileged () )
  274.     if ( curgroup == mathshiftgroup )
  275.       starteqno () ;
  276.     else
  277.       offsave () ;
  278.       break;
  279.     }
  280.     break;
  281.  
  282.   case mac_param :
  283.     reportillegalcase () ;
  284.     break ;
  285.  
  286.   case sup_mark :
  287.   case sub_mark :
  288.     if( mains != mmode ) {
  289.       insertdollarsign () ;
  290.     } else {
  291.       subsup () ;
  292.     }
  293.     break;
  294.  
  295.   case math_char_num :
  296.     if( mains != mmode ) {
  297.       insertdollarsign () ;
  298.     } else {
  299.       setmathchar( scanfifteenbitint () );
  300.       /*setmathchar ( curval ) ;*/
  301.     }
  302.     break;
  303.  
  304.   case math_given :
  305.     if( mains != mmode ) {
  306.       insertdollarsign () ;
  307.     } else {
  308.       setmathchar ( curchr ) ;
  309.     }
  310.     break;
  311.  
  312.   case math_comp :
  313.     if( mains != mmode ) {
  314.       insertdollarsign () ;
  315.     } else {
  316.       tailappend ( newnoad () ) ;
  317.       ztype ( curlist .tailfield ) = curchr ;
  318.       scanmath ( nucleus ( curlist .tailfield ) ) ;
  319.     }
  320.     break;
  321.  
  322.   case delim_num :
  323.     if( mains != mmode ) {
  324.       insertdollarsign () ;
  325.     } else {
  326.       setmathchar( scantwentysevenbitint() / 4096 );
  327.       /*setmathchar ( curval / 4096 );*/
  328.     }
  329.     break;
  330.  
  331.   case left_right :
  332.     if( mains != mmode ) {
  333.       insertdollarsign () ;
  334.     } else {
  335.       mathleftright () ;
  336.     }
  337.     break;
  338.  
  339.   case above :
  340.     if( mains != mmode ) {
  341.       insertdollarsign () ;
  342.     } else {
  343.       mathfraction () ;
  344.     }
  345.     break;
  346.  
  347.   case radical :
  348.     if( mains != mmode ) {
  349.       insertdollarsign () ;
  350.     } else {
  351.       mathradical () ;
  352.     }
  353.     break;
  354.  
  355.   case math_style :
  356.     if( mains != mmode ) {
  357.       insertdollarsign () ;
  358.     } else {
  359.       tailappend ( newstyle ( curchr ) ) ;
  360.     }
  361.     break;
  362.  
  363.   case math_choice :
  364.     if( mains != mmode ) {
  365.       insertdollarsign () ;
  366.     } else {
  367.       appendchoices () ;
  368.     }
  369.     break;
  370.  
  371.   case vcenter :
  372.     if( mains != mmode ) {
  373.       insertdollarsign () ;
  374.     } else {
  375.       scanspec ( vcentergroup , false ) ;
  376.       normalparagraph () ;
  377.       pushnest () ;
  378.       curlist .modefield = -vmode ;
  379.       curlist .auxfield .cint = ignoredepth ;
  380.       if ( everyvbox != 0 )
  381.     begintokenlist ( everyvbox , everyvboxtext ) ;
  382.     }
  383.     break;
  384.  
  385.   case non_script :
  386.     if( mains != mmode ) {
  387.       insertdollarsign () ;
  388.     } else {
  389.       tailappend ( newglue ( zeroglue ) ) ;
  390.       subtype ( curlist .tailfield ) = condmathglue ;
  391.     }
  392.     break;
  393.  
  394.   case mkern :
  395.     if( mains != mmode ) {
  396.       insertdollarsign () ;
  397.     } else {
  398.       appendkern () ;
  399.     }
  400.     break;
  401.  
  402.   case limit_switch :
  403.     if( mains != mmode ) {
  404.       insertdollarsign () ;
  405.     } else {
  406.       mathlimitswitch () ;
  407.     }
  408.     break;
  409.  
  410.   case mskip :
  411.     if( mains != mmode ) {
  412.       insertdollarsign () ;
  413.     } else {
  414.       appendglue () ;
  415.     }
  416.     break;
  417.  
  418.   case math_accent :
  419.     if( mains != mmode ) {
  420.       insertdollarsign () ;
  421.     } else {
  422.       mathac () ;
  423.     }
  424.     break;
  425.  
  426.   case endv :
  427.     if( mains != mmode ) {
  428.       doendv () ;
  429.     } else {
  430.       insertdollarsign () ;
  431.     }
  432.     break;
  433.  
  434.   case par_end :
  435.     if( mains == hmode ) {
  436.       if ( alignstate < 0 )
  437.     offsave () ;
  438.       endgraf () ;
  439.       if ( curlist .modefield == vmode )
  440.     buildpage () ;
  441.     } else if( mains == vmode ) {
  442.       normalparagraph () ;
  443.       if ( curlist .modefield > 0 )
  444.     buildpage () ;
  445.     } else {
  446.       insertdollarsign () ;
  447.     }
  448.     break;
  449.  
  450.   case vskip :
  451.     if( mains == hmode ) {
  452.       headforvmode () ;
  453.     } else if( mains == vmode ) {
  454.       appendglue () ;
  455.     } else {
  456.       insertdollarsign () ;
  457.     }
  458.     break;
  459.  
  460.   case un_vbox :
  461.     if( mains == hmode ) {
  462.       headforvmode () ;
  463.     } else if( mains == vmode ) {
  464.       unpackage () ;
  465.     } else {
  466.       insertdollarsign () ;
  467.     }
  468.     break;
  469.  
  470.   case valign :
  471.     if( mains == hmode ) {
  472. #ifdef TEXXET
  473.       if( curchr > 0 )
  474.     tailappend(newmath(0, curchr));
  475.       else
  476.     initalign () ;
  477. #else
  478.       initalign () ;
  479. #endif
  480.     } else if( mains == vmode ) {
  481.       backinput () ;
  482.       newgraf ( true ) ;
  483.     } else {
  484.       insertdollarsign () ;
  485.     }
  486.     break;
  487.  
  488.   case hrule :
  489.     if( mains == hmode ) {
  490.       headforvmode () ;
  491.     } else if( mains == vmode ) {
  492.       tailappend ( scanrulespec () );
  493.       if ( abs ( curlist .modefield ) == vmode )
  494.     curlist .auxfield .cint = ignoredepth ; 
  495.       else if ( abs ( curlist .modefield ) == hmode )
  496.     curlist .auxfield .hh .v.LH = 1000 ; 
  497.     } else {
  498.       insertdollarsign () ;
  499.     }
  500.     break;
  501.  
  502.   case vrule :
  503.     if( mains == vmode ) {
  504.       backinput () ; 
  505.       newgraf ( true ) ; 
  506.     } else {
  507.       tailappend ( scanrulespec () );
  508.       if ( abs ( curlist .modefield ) == vmode ) 
  509.     curlist .auxfield .cint = ignoredepth ; 
  510.       else if ( abs ( curlist .modefield ) == hmode ) 
  511.     curlist .auxfield .hh .v.LH = 1000 ; 
  512.     }
  513.     break;
  514.  
  515.   case hskip :
  516.     if( mains == vmode ) {
  517.       backinput () ;
  518.       newgraf ( true ) ;
  519.     } else {
  520.       appendglue () ;
  521.     }
  522.     break;
  523.  
  524.   case kern :
  525.     appendkern () ;
  526.     break;
  527.  
  528.   case left_brace :
  529.     if( mains != mmode ) {
  530.       newsavelevel ( simplegroup ) ;
  531.     } else {
  532.       tailappend ( newnoad () ) ;
  533.       backinput () ;
  534.       scanmath ( nucleus ( curlist .tailfield ) );
  535.     }
  536.     break;
  537.  
  538.   case begin_group :
  539.     newsavelevel ( semisimplegroup ) ; 
  540.     break ; 
  541.  
  542.   case end_group :
  543.     if ( curgroup == semisimplegroup )
  544.       unsave () ; 
  545.     else
  546.       offsave () ;
  547.     break ;
  548.  
  549.   case right_brace :
  550.     handlerightbrace () ; 
  551.     break ; 
  552.  
  553.   case leader_ship :
  554.     scanbox ( 1073742337L - aleaders + curchr );
  555.     break ;
  556.  
  557.   case make_box :
  558.     beginbox ( 0 ) ; 
  559.     break ;
  560.  
  561.   case start_par :
  562.     if( mains == vmode ) {
  563.       newgraf( curchr > 0 );
  564.     } else {
  565.       indentinhmode( curchr > 0 );
  566.     }
  567.     break;
  568.  
  569.   case math_shift :
  570.     if( mains == hmode ) {
  571.       initmath () ;
  572.     } else if( mains == vmode ) {
  573.       backinput () ; 
  574.       newgraf ( true ) ; 
  575.     } else {
  576.       if ( curgroup == mathshiftgroup ) 
  577.     aftermath () ; 
  578.       else
  579.     offsave () ; 
  580.     }
  581.     break;
  582.  
  583.   case un_hbox :
  584.     if( mains == vmode ) {
  585.       backinput () ; 
  586.       newgraf ( true ) ; 
  587.     } else {
  588.       unpackage () ;
  589.     }
  590.     break;
  591.  
  592.   case accent :
  593.     if( mains == hmode ) {
  594.       makeaccent () ;
  595.     } else if( mains == vmode ) {
  596.       backinput () ; 
  597.       newgraf ( true ) ; 
  598.     } else {
  599.       mathac () ;
  600.     }
  601.     break;
  602.  
  603.   case discretionary :
  604.     if( mains == vmode ) {
  605.       backinput () ; 
  606.       newgraf ( true ) ; 
  607.     } else {
  608.       appenddiscretionary () ;
  609.     }
  610.     break;
  611.  
  612.   case halign :
  613.     if( mains == vmode ) {
  614.       initalign () ;
  615.     } else if( mains == hmode ) {
  616.       headforvmode () ;
  617.     } else {
  618.       if ( privileged () ) 
  619.     if ( curgroup == mathshiftgroup ) 
  620.       initalign () ; 
  621.     else
  622.       offsave () ; 
  623.     }
  624.     break;
  625.  
  626.   case insert :
  627.     begininsertoradjust () ; 
  628.     break ; 
  629.  
  630.   case mark :
  631.     makemark () ; 
  632.     break ; 
  633.  
  634.   case break_penalty :
  635.     appendpenalty () ; 
  636.     break ; 
  637.  
  638.   case remove_item :
  639.     deletelast () ; 
  640.     break ; 
  641.  
  642.   case tab_mark :
  643.   case car_ret :
  644.     alignerror () ; 
  645.     break ; 
  646.  
  647.   case no_align :
  648.     noalignerror () ; 
  649.     break ; 
  650.  
  651.   case omit :
  652.     omiterror () ; 
  653.     break ;
  654.  
  655.   case end_cs_name :
  656.     cserror () ; 
  657.     break ; 
  658.  
  659.   case toks_register :
  660.   case assign_toks :
  661.   case assign_int :
  662.   case assign_dimen :
  663.   case assign_glue :
  664.   case assign_mu_glue :
  665.   case assign_font_dimen :
  666.   case assign_font_int :
  667.   case set_aux :
  668.   case set_prev_graf :
  669.   case set_page_dimen :
  670.   case set_page_int :
  671.   case set_box_dimen :
  672.   case set_shape :
  673.   case def_code :
  674.   case def_family :
  675.   case set_font :
  676.   case def_font :
  677.   case register_cmd :
  678.   case advance :
  679.   case multiply :
  680.   case divide :
  681.   case prefix :
  682.   case let :
  683.   case shorthand_def :
  684.   case read_to_cs :
  685.   case def :
  686.   case set_box :
  687.   case hyph_data :
  688. #ifdef MLTEX
  689.   case char_sub_def :
  690. #endif
  691.   case set_interaction :
  692.     prefixedcommand () ; 
  693.     break ; 
  694.  
  695.   case afterassignment :
  696.     gettoken () ; 
  697.     aftertoken = curtok ; 
  698.     break ; 
  699.  
  700.   case aftergroup :
  701.     gettoken () ; 
  702.     saveforafter ( curtok ) ; 
  703.     break ; 
  704.  
  705.   case instream :
  706.     openorclosein () ; 
  707.     break ; 
  708.  
  709.   case message :
  710.     issuemessage () ; 
  711.     break ; 
  712.  
  713.   case caseshift :
  714.     shiftcase () ; 
  715.     break ; 
  716.  
  717.   case xray :
  718.     showwhatever () ; 
  719.     break ;
  720.  
  721.   case extension :
  722.     doextension () ; 
  723.     break ; 
  724.  
  725.   default:
  726.     fprintf(stderr, "Internal error: can't happen (mainctrl) !\n");
  727.   }    /* switch 1 */
  728.   goto lab60;        /* goto big_switch ---^ */
  729.  
  730.  
  731. /* main_loop:  when hmode + letter/other_char/char_given/char_num */
  732. lab701:
  733.   r_curcmd = curchr;  /* added */
  734. lab70:
  735. #ifdef ERW_SHIFTCASE
  736.   if( uccode(0) > 0 && uccode(0) < 3 ) {
  737.     if( r_curcmd /*curchr*/ > 0 ) {  /* nicht \char0, da \uccode falsch ! */
  738.       if( uccode(0) == 1 ) {    /* lowercase */
  739.     if( lccode(r_curcmd) > 0 ) {
  740.       r_curcmd = lccode(r_curcmd);
  741.       curchr = r_curcmd;
  742.     }
  743.       } else {            /* uppercase */
  744.     if( uccode(r_curcmd) > 0 ) {
  745.       r_curcmd = uccode(r_curcmd);
  746.       curchr = r_curcmd;
  747.         }
  748.       }
  749.     }
  750.   }
  751. #endif
  752.   /* adjust space_factor */
  753.   mains = sfcode ( r_curcmd /*curchr*/ );
  754.   if ( mains == 1000 )
  755.     curlist .auxfield .hh .v.LH = 1000;
  756.   else if ( mains <= 1000 ) {  /* was:  if ( mains < 1000 ) */
  757.     if ( mains > 0 )
  758.       curlist .auxfield .hh .v.LH = mains;
  759.   } else if ( curlist .auxfield .hh .v.LH < 1000 )
  760.     curlist .auxfield .hh .v.LH = 1000;
  761.   else
  762.     curlist .auxfield .hh .v.LH = mains;
  763.  
  764. #ifdef ERW_CONSTITUTE
  765.  
  766.   if (
  767. #ifndef ERW_LANGUAGE
  768.        curlist .modefield > 0 &&
  769. #endif
  770.                                  language != curlist.auxfield.hh.v.RH )
  771.       fixlanguage () ; 
  772.   fastgetavail (ligstack);
  773.   character(ligstack) = curchr;
  774.   font(ligstack) = curfont;
  775.   tailappend(ligstack);
  776.   goto lab60;
  777.  
  778. #else
  779.  
  780.   mainf = curfont;
  781.   bchar = fontbchar(mainf);
  782.   falsebchar = fontfalsebchar(mainf);
  783.   if (
  784. #ifndef ERW_LANGUAGE
  785.        curlist .modefield > 0 &&
  786. #endif
  787.                                  language != curlist.auxfield.hh.v.RH )
  788.       fixlanguage () ; 
  789.   fastgetavail ( ligstack ) ; 
  790.   curl = curchr ; 
  791.   font ( ligstack ) = mainf ; 
  792.   character ( ligstack ) = curl ; 
  793.   curq = curlist .tailfield ; 
  794.   if ( cancelboundary ) {
  795.     cancelboundary = false ;
  796. #if 0    /* not needed with the following jump */
  797.     maink = nonaddress; 
  798. #endif
  799.     goto lab92;        /* (br) added this ... see below */
  800.   } else
  801.     maink = bcharlabel(mainf);
  802.   if ( maink == nonaddress ) 
  803.     goto lab92;        /* goto main_loop_move_2 */
  804.  
  805.   curr = curl ;
  806.   curl = nonchar;
  807.   ligp = &fontinfo[ maink ];    /* (br) init ligp/maink for bcharlabel[] */
  808.   goto lab111;        /* goto main_lig_loop_1 */
  809.  
  810. /* main_loop_wrapup: wird nur von "unten" angesprungen */
  811. lab80:
  812.   if ( curl < nonchar ) {
  813.     if ( character ( curlist .tailfield ) == hyphenchar(mainf) ) 
  814.       if ( link ( curq ) > 0 ) 
  815.         insdisc = true ; 
  816.     if ( ligaturepresent ) {
  817.       register long_halfword mainp;
  818.  
  819.       mainp = newligature ( mainf , curl , link ( curq ) ) ; 
  820.       if ( lfthit ) {
  821.     subtype ( mainp ) = 2 ; 
  822.     lfthit = false ; 
  823.       }
  824.       if ( rthit ) 
  825.         if ( ligstack == 0 ) {
  826.       incr ( subtype ( mainp ) );
  827.       rthit = false ; 
  828.         }
  829.       link ( curq ) = mainp ; 
  830.       curlist .tailfield = mainp ; 
  831.       ligaturepresent = false ; 
  832.     }
  833.     if ( insdisc ) {
  834.       insdisc = false ; 
  835.       if ( curlist .modefield > 0 ) 
  836.     tailappend ( newdisc () ) ; 
  837.     }
  838.   }
  839.  
  840. /* main_loop_move: */
  841. lab90:
  842.   if ( ligstack == 0 ) {
  843.     r_curcmd = curcmd;
  844.     goto lab21;
  845.   }
  846.   curq = curlist .tailfield;
  847.   curl = character ( ligstack );   /* curr; TeX 3.141 */
  848.  
  849. lab91:        /* main_loop_move_1 */
  850.   if ( ! ischarnode ( ligstack ) ) {
  851.     /* statt goto lab95; wurde Teil hierher verschoben */
  852.     register long_halfword mainp;
  853.  
  854.     mainp = ligptr ( ligstack );
  855.     if ( mainp > 0 )
  856.       tailappend ( mainp ) ;
  857.     {long_halfword tempptr;
  858.      tempptr = ligstack ;
  859.      ligstack = link ( tempptr ) ;
  860.      freenode ( tempptr , smallnodesize ) ;
  861.     }
  862.     maini = zcharinfo ( mainf ,  curl ) ;
  863.     ligaturepresent = true ;
  864.     if ( ligstack == 0 )
  865.       if ( mainp > 0 )
  866.         goto lab100 ;
  867.       else
  868.         curr = bchar ;
  869.     else
  870.       curr = character ( ligstack ) ;
  871.     goto lab110 ;
  872.   }
  873.  
  874. lab92:        /* main_loop_move_2 */
  875.   if ( curchr < fontbc(mainf) || effective_char(curchr) > fontec(mainf) ) {
  876.     charwarning ( mainf , curchr );
  877.     freeavail ( ligstack );
  878.     goto lab60;        /* goto big_switch */
  879.   }
  880.   maini = zcharinfo ( mainf ,  curl );
  881.  
  882.   if ( ! charexists ( maini ) ) {
  883.     charwarning ( mainf , curchr ) ; 
  884.     freeavail ( ligstack ) ; 
  885.     goto lab60 ; 
  886.   } 
  887.   tailappend ( ligstack ) ; 
  888. lab100:
  889.   r_curcmd = getnext () ; 
  890.   if ( (eightbits)r_curcmd == letter || (eightbits)r_curcmd == otherchar
  891.     || (eightbits)r_curcmd == chargiven )
  892.       goto lab101;
  893.  
  894.   r_curcmd = xtoken () ;
  895.   if ( (eightbits)r_curcmd == letter || (eightbits)r_curcmd == otherchar
  896.     || (eightbits)r_curcmd == chargiven )
  897.       goto lab101;
  898.   if ( (eightbits)r_curcmd == charnum ) {
  899.       curchr = scancharnum ();    /* curchr = curval; */
  900.       goto lab101 ; 
  901.   }
  902.   if ( (eightbits)r_curcmd == noboundary )
  903.       bchar = nonchar;
  904.  
  905.   curr = bchar ; 
  906.   ligstack = 0 ; 
  907.   goto lab110 ;
  908.  
  909. lab101:        /* wird nur ab lab100 bis hier angesprungen */
  910. #ifdef ERW_SHIFTCASE
  911.   if( uccode(0) > 0 && uccode(0) < 3 ) {
  912.     if( curchr > 0 ) {  /* nicht \char0, da \uccode falsch ! */
  913.       if( uccode(0) == 1 ) {    /* lowercase */
  914.     if( lccode(curchr) > 0 )
  915.       curchr = lccode(curchr);
  916.       } else {            /* uppercase */
  917.     if( uccode(curchr) > 0 )
  918.       curchr = uccode(curchr);
  919.       }
  920.     }
  921.   }
  922. #endif
  923.  
  924.   /* adjust_space_factor */
  925.   mains = sfcode ( curchr ) ; 
  926.   if ( mains == 1000 ) 
  927.     curlist .auxfield .hh .v.LH = 1000 ; 
  928.   else if ( mains <= 1000 ) {
  929.     if ( mains > 0 ) 
  930.       curlist .auxfield .hh .v.LH = mains ; 
  931.   } else if ( curlist .auxfield .hh .v.LH < 1000 ) 
  932.     curlist .auxfield .hh .v.LH = 1000 ; 
  933.   else
  934.     curlist .auxfield .hh .v.LH = mains ; 
  935.  
  936.   fastgetavail ( ligstack ) ; 
  937.   font ( ligstack ) = mainf ; 
  938.   curr = curchr ; 
  939.   character ( ligstack ) = curr ; 
  940.   if ( curr == falsebchar ) 
  941.     curr = nonchar ;
  942.  
  943. lab110:
  944. #if 1
  945.   if ( mychartag ( maini ) != (ligtag << 8) )    /* (br) */
  946. #else
  947.   if ( chartag ( maini ) != ligtag )
  948. #endif
  949.     goto lab80;
  950.  
  951.   /* maink = zligkernstart ( mainf ,  maini ) ; */
  952.   /* mainj = fontinfo [ maink ] .qqqq ; */
  953. #ifdef FONTPTR
  954.   ligp = zligkernstart ( mainf, maini );
  955. #else
  956.   ligp = &fontinfo[ zligkernstart ( mainf, maini ) ];
  957. #endif
  958.   mainj = ligp->qqqq;
  959.  
  960.   if ( skipbyte ( mainj ) <= stopflag )
  961.     goto lab112 ; 
  962.  
  963.   /* maink = zligkernrestart ( mainf ,  mainj ) ; */
  964. #ifdef FONTPTR
  965.   ligp = zligkernrestart ( mainf ,  mainj );
  966. #else
  967.   ligp = &fontinfo[ zligkernrestart ( mainf ,  mainj ) ];
  968. #endif
  969.  
  970. lab111:
  971.   mainj = ligp->qqqq;    /* mainj = fontinfo [ maink ] .qqqq ; */
  972.  
  973. lab112:
  974.   if ( nextchar ( mainj ) == curr ) {
  975.    if ( skipbyte ( mainj ) <= stopflag ) {
  976.     if ( opbyte ( mainj ) >= kernflag ) {
  977.       if ( curl < nonchar ) {
  978.     if ( character ( curlist .tailfield ) == hyphenchar(mainf) ) 
  979.     if ( link ( curq ) > 0 ) 
  980.     insdisc = true ; 
  981.     if ( ligaturepresent ) {
  982.       register long_halfword mainp;
  983.  
  984.       mainp = newligature ( mainf , curl , link ( curq ) ) ; 
  985.       if ( lfthit ) {
  986.         subtype ( mainp ) = 2 ; 
  987.         lfthit = false ; 
  988.       } 
  989.       if ( rthit ) 
  990.       if ( ligstack == 0 ) {
  991.         incr ( subtype ( mainp ) ) ; 
  992.         rthit = false ; 
  993.       } 
  994.       link ( curq ) = mainp ; 
  995.       curlist .tailfield = mainp ; 
  996.       ligaturepresent = false ; 
  997.     }
  998.     if ( insdisc ) {
  999.       insdisc = false ; 
  1000.       if ( curlist .modefield > 0 ) 
  1001.       tailappend ( newdisc () ) ; 
  1002.     } 
  1003.       } 
  1004.       tailappend ( newkern ( zcharkern ( mainf ,  mainj ) ) ) ; 
  1005.       goto lab90 ; 
  1006.     } 
  1007.     if ( curl == nonchar ) 
  1008.       lfthit = true ; 
  1009.     else if ( ligstack == 0 ) 
  1010.       rthit = true ; 
  1011.     {
  1012.       if ( interrupt != 0 ) 
  1013.       pauseforinstructions () ; 
  1014.     } 
  1015.     switch ( opbyte ( mainj ) ) {
  1016.     case 1 : 
  1017.     case 5 : 
  1018.       {
  1019.     curl = rembyte ( mainj ) ; 
  1020.     maini = zcharinfo ( mainf ,  curl ) ; 
  1021.     ligaturepresent = true ; 
  1022.       } 
  1023.       break ; 
  1024.     case 2 : 
  1025.     case 6 : 
  1026.       {
  1027.     curr = rembyte ( mainj ) ; 
  1028.     if ( ligstack == 0 ) {
  1029.       ligstack = newligitem ( curr ) ; 
  1030.       bchar = nonchar ; 
  1031.     } else if ( ischarnode ( ligstack ) ) {
  1032.       register halfword mainp;
  1033.  
  1034.       mainp = ligstack ; 
  1035.       ligstack = newligitem ( curr ) ; 
  1036.       ligptr ( ligstack ) = mainp ; 
  1037.     } else
  1038.       character ( ligstack ) = curr ; 
  1039.       } 
  1040.       break ; 
  1041.     case 3 : 
  1042.       { register halfword mainp;
  1043.  
  1044.     curr = rembyte ( mainj ) ; 
  1045.     mainp = ligstack ; 
  1046.     ligstack = newligitem ( curr ) ; 
  1047.     link ( ligstack ) = mainp ; 
  1048.       } 
  1049.       break ; 
  1050.     case 7 : 
  1051.     case 11 : 
  1052.       {
  1053.     if ( curl < nonchar ) {
  1054.       if ( character ( curlist .tailfield ) == hyphenchar(mainf) ) 
  1055.         if ( link ( curq ) > 0 ) 
  1056.           insdisc = true ; 
  1057.       if ( ligaturepresent ) {
  1058.         register long_halfword mainp;
  1059.  
  1060.         mainp = newligature ( mainf , curl , link ( curq ) ) ; 
  1061.         if ( lfthit ) {
  1062.           subtype ( mainp ) = 2 ; 
  1063.           lfthit = false ; 
  1064.         } 
  1065.         if ( false )
  1066.         if ( ligstack == 0 ) {
  1067.           incr ( subtype ( mainp ) ) ; 
  1068.           rthit = false ; 
  1069.         } 
  1070.         link ( curq ) = mainp ; 
  1071.         curlist .tailfield = mainp ; 
  1072.         ligaturepresent = false ; 
  1073.       }
  1074.       if ( insdisc ) {
  1075.         insdisc = false ; 
  1076.         if ( curlist .modefield > 0 ) 
  1077.         tailappend ( newdisc () ) ; 
  1078.       } 
  1079.     } 
  1080.     curq = curlist .tailfield ; 
  1081.     curl = rembyte ( mainj ) ; 
  1082.     maini = zcharinfo ( mainf ,  curl ) ; 
  1083.     ligaturepresent = true ; 
  1084.       } 
  1085.       break ;
  1086.     case 0 : /* (br) added to avoid "subql #1" */
  1087.     default:
  1088.       {
  1089.     curl = rembyte ( mainj ) ;
  1090.     ligaturepresent = true ;
  1091.     if ( ligstack == 0 )
  1092.       goto lab80 ;
  1093.     else
  1094.       goto lab91 ;
  1095.       }
  1096.       break ;
  1097.     } 
  1098.     if ( opbyte ( mainj ) > 4 && opbyte ( mainj ) != 7 )
  1099.       goto lab80 ;
  1100.     if ( curl < nonchar )
  1101.       goto lab110 ;
  1102.  
  1103.     ligp = &fontinfo[ bcharlabel(mainf) ];   /* maink = bcharlabel[mainf]; */
  1104.     goto lab111 ;
  1105.    }
  1106.   }    /* if (nextchar(mainj) == curr) */
  1107.  
  1108.   if ( skipbyte ( mainj ) == 0 ) {
  1109.     incr (ligp);    /* incr ( maink ); */
  1110.   } else {
  1111.     if ( skipbyte ( mainj ) >= stopflag )
  1112.       goto lab80;
  1113.     /* maink = maink + skipbyte ( mainj ) + 1 ; */
  1114.     ligp = ligp + skipbyte(mainj) + 1;
  1115.   }
  1116.   goto lab111 ;
  1117.  
  1118. #endif  /* ERW_CONSTITUTE */
  1119. }
  1120.  
  1121. /* -- end -- */
  1122.