home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d5xx / d583 / aroff.lha / ARoff / Sources / cmd.c < prev    next >
C/C++ Source or Header  |  1992-01-04  |  16KB  |  732 lines
  1. /*
  2.  * Commandes nroff
  3.  * (c)1991 par Denis GOUNELLE
  4.  */
  5.  
  6. #include "aroff.h"
  7. #include "pile.h"
  8.  
  9. extern unsigned char *TestString(), *TestNum() ;
  10. extern unsigned char Arg[], OutputBuf[], TabChar, *GetArg(), TitleSeq[] ;
  11. extern long ArgLen, OutputLen, AdjustMode, PageNumber, InputMode, LineLen,
  12.         Indent, TitleLen, Flg, TmpIndent, PageOffset, PageLen, LineSpacing,
  13.         TabLen, TmpCenter, LineNumber, NumInterv, NumSpace, NumIndent,
  14.         TmpNoNum, OldInputMode, OutputLine, EmptyToWrite, FindTrp(),
  15.         NewPageNumber, CtrlLen ;
  16. extern struct InputFile *CurrentInputFile, *NewFile() ;
  17. extern struct Macro *CurrentMacro ;
  18. extern struct TeteListe TMac ;
  19. extern struct Node *FindVar() ;
  20.  
  21. static unsigned char tmp[LGMAXSTR+1], TrTab[LGMAXSTR+1] = "" ;
  22.  
  23. static char *TableEsc[] =
  24. {
  25.   "\033[22m" ,  /* b0 */
  26.   "\033[1m"  ,  /* b1 */
  27.   "\033[23m" ,  /* i0 */
  28.   "\033[3m"  ,  /* i1 */
  29.   "\033[24m" ,  /* u0 */
  30.   "\033[4m"  ,  /* u1 */
  31.   "\033[0m"     /* n  */
  32. } ;
  33.  
  34. /***********************************************************************/
  35.  
  36. void do_br()
  37. {
  38.   if ( Flg & F_NOBRK ) return ;
  39.  
  40.   if ( OutputLen )
  41.   {
  42.     if ( AdjustMode != AM_BOTH ) AdjustLine() ;
  43.     WriteLine() ;
  44.   }
  45. }
  46.  
  47. /***********************************************************************/
  48.  
  49. void do_tm()
  50. {
  51.   if ( ArgLen > 0 )
  52.   {
  53.     write( 2 , Arg , ArgLen ) ;
  54.     write( 2 , "\n" , 1 ) ;
  55.   }
  56. }
  57.  
  58. /***********************************************************************/
  59.  
  60. void do_ab()
  61. {
  62.   do_tm() ;
  63.   Abort( 1 ) ;
  64. }
  65.  
  66. /***********************************************************************/
  67.  
  68. void do_ad()
  69. {
  70.   long oldmode ;
  71.   unsigned char c ;
  72.  
  73.   c = Arg[0] ;
  74.   oldmode = AdjustMode ;
  75.  
  76.   switch ( c )
  77.   {
  78.     case 'c'  : AdjustMode = AM_CENTER ; break ;
  79.     case 'l'  : AdjustMode = AM_LEFT   ; break ;
  80.     case 'r'  : AdjustMode = AM_RIGHT  ; break ;
  81.     case 'b'  : AdjustMode = AM_BOTH   ; break ;
  82.     case '\0' : AdjustMode = Pop( TE_ADJMOD , 0 ) ;
  83.         if ( AdjustMode == -1 ) AdjustMode = AM_BOTH ;
  84.         break ;
  85.     default   : Fatal( ERR_SYNTAX ) ;
  86.   }
  87.  
  88.   Push( TE_ADJMOD , oldmode ) ;
  89. }
  90.  
  91. /***********************************************************************/
  92.  
  93. void do_am()
  94. {
  95.   struct Macro *m ;
  96.  
  97.   if ( InputMode & IM_EXMACRO ) Fatal( ERR_SYNTAX ) ;
  98.  
  99.   if ( ! ArgLen ) return ;
  100.   m = (struct Macro *)FindVar( &TMac , Arg ) ;
  101.   if ( ! m )
  102.   {
  103.     SetMac( Arg ) ;
  104.     m = CurrentMacro ;
  105.   }
  106.  
  107.   m->m_NextL = NULL ;
  108.   CurrentMacro = m ;
  109.   OldInputMode = InputMode ;
  110.   BCLR( InputMode , IM_FILLING ) ;
  111.   BSET( InputMode , IM_RDMACRO ) ;
  112. }
  113.  
  114. /***********************************************************************/
  115.  
  116. void do_as()
  117. {
  118.   register long k ;
  119.   register unsigned char *var, *val ;
  120.  
  121.   if ( ! ArgLen ) return ;
  122.  
  123.   /* isole le nom de la chaine */
  124.  
  125.   var = Arg ;
  126.   for ( k = 0 ; (Arg[k] != '\0') && (! isspace( Arg[k] )) ; k++ ) ;
  127.   if ( Arg[k] == '\0' ) return ;
  128.   Arg[k] = '\0' ;
  129.  
  130.   /* recupere la valeur */
  131.  
  132.   for ( k++ ; isspace( Arg[k] ) ; k++ ) ;
  133.   if ( Arg[k] == '\0' ) return ;
  134.   if ( Arg[k] == '"' ) k++ ;
  135.   val = &Arg[k] ;
  136.   if ( *val == '\0' ) return ;
  137.  
  138.   /* fabrique la nouvelle valeur */
  139.  
  140.   GetStr( var , tmp ) ;
  141.   strcat( tmp , val ) ;
  142.   SetStr( var , tmp ) ;
  143. }
  144.  
  145. /***********************************************************************/
  146.  
  147. void do_bp()
  148. {
  149.   do_br() ;
  150.  
  151.   if ( OutputLine > 1 ) EmptyToWrite += PageLen - OutputLine + 1 ;
  152.   if ( isdigit( Arg[0] ) ) NewPageNumber = atoi( Arg ) ;
  153.   if (! (Flg & F_SORTIE)) ChangePageNumber( NewPageNumber ) ;
  154. }
  155.  
  156. /***********************************************************************/
  157.  
  158. void do_ce()
  159. {
  160.   do_br() ;
  161.   TmpCenter = ( isdigit( Arg[0] ) ) ? atoi( Arg ) : 1 ;
  162. }
  163.  
  164. /***********************************************************************/
  165.  
  166. void do_de()
  167. {
  168.   if ( InputMode & IM_EXMACRO ) Fatal( ERR_SYNTAX ) ;
  169.  
  170.   if ( ! ArgLen ) return ;
  171.   SetMac( Arg ) ;
  172.   OldInputMode = InputMode ;
  173.   BCLR( InputMode , IM_FILLING ) ;
  174.   BSET( InputMode , IM_RDMACRO ) ;
  175. }
  176.  
  177. /***********************************************************************/
  178.  
  179. void do_ds()
  180. {
  181.   register long k ;
  182.   register unsigned char *var, *val ;
  183.  
  184.   if ( ! ArgLen ) return ;
  185.  
  186.   /* isole le nom de la chaine */
  187.  
  188.   var = Arg ;
  189.   for ( k = 0 ; (Arg[k] != '\0') && (! isspace( Arg[k] )) ; k++ ) ;
  190.   if ( Arg[k] == '\0' ) return ;
  191.   Arg[k] = '\0' ;
  192.  
  193.   /* recupere la valeur */
  194.  
  195.   for ( k++ ; isspace( Arg[k] ) ; k++ ) ;
  196.   if ( Arg[k] == '\0' ) return ;
  197.   if ( Arg[k] == '"' ) k++ ;
  198.   val = &Arg[k] ;
  199.   if ( *val == '\0' ) return ;
  200.  
  201.   SetStr( var , val ) ;
  202. }
  203.  
  204. /***********************************************************************/
  205.  
  206. void do_el()
  207. {
  208.   if (! (Flg & F_WASIF)) Fatal( ERR_IFELSE ) ;
  209.   if (! ArgLen) Fatal( ERR_SYNTAX ) ;
  210.   if ( Flg & F_WASFALSE )
  211.   {
  212.     sprintf( tmp , "%s\n" , Arg ) ;
  213.     NewString( tmp ) ;
  214.   }
  215. }
  216.  
  217. /***********************************************************************/
  218.  
  219. void do_ex()
  220. {
  221.   Abort( 1 ) ;
  222. }
  223.  
  224. /***********************************************************************/
  225.  
  226. void do_fi()
  227. {
  228.   do_br() ;
  229.   BSET( InputMode , IM_FILLING ) ;
  230. }
  231.  
  232. /***********************************************************************/
  233.  
  234. void do_fl( str )
  235. unsigned char *str ;
  236. {
  237.   register long k,l ;
  238.   register unsigned char *p, *q ;
  239.  
  240.   k = strlen( str ) ;
  241.   if ( k < 1 ) Fatal( ERR_WRITE ) ;
  242.  
  243.   for ( q = str ; *q ; q++ )
  244.   {
  245.     if ( *q == SC_FIXSPC ) *q = ' ' ;
  246.     for ( l = 0 ; TrTab[l] ; l += 2 ) /* do translation */
  247.       if ( *q == TrTab[l] )
  248.       {
  249.     *q = TrTab[l+1] ;
  250.     break ;
  251.       }
  252.   }
  253.  
  254.   write( 1 , str , k ) ;
  255. }
  256.  
  257. /***********************************************************************/
  258.  
  259. void do_fs()
  260. {
  261.   register long k ;
  262.   register unsigned char *p, *q ;
  263.  
  264.   if ( ! ArgLen ) return ;
  265.  
  266.   for ( p = Arg ; *p ; p++ )
  267.   {
  268.     switch ( *p )
  269.     {
  270.       case 'b' : k = 0 ; break ;
  271.       case 'i' : k = 2 ; break ;
  272.       case 'u' : k = 4 ; break ;
  273.       case 'n' : k = 6 ; break ;
  274.       default  : Fatal( ERR_SYNTAX ) ; break ;
  275.     }
  276.  
  277.     if ( k != 6 )
  278.     {
  279.       p++ ;
  280.       if ( *p == '1' ) k++ ;
  281.       else if ( *p != '0' ) Fatal( ERR_SYNTAX ) ;
  282.     }
  283.  
  284.     for ( q = TableEsc[k] ; *q ; q++ )
  285.     {
  286.       CtrlLen++ ;
  287.       PutChar( *q ) ;
  288.     }
  289.   }
  290.  
  291.   BSET( Flg , F_CONTINUE ) ;
  292. }
  293.  
  294. /***********************************************************************/
  295.  
  296. void do_if()
  297. {
  298.   register unsigned char *p ;
  299.  
  300.   if (! ArgLen) Fatal( ERR_SYNTAX ) ;
  301.  
  302.   p = Arg ;
  303.   BSET( Flg , F_WASIF ) ;
  304.   BCLR( Flg , (F_IFNOT|F_WASFALSE) ) ;
  305.  
  306.   if ( *p == '!' )
  307.   {
  308.     BSET( Flg , F_IFNOT ) ;
  309.     p++ ;
  310.     while ( isspace(*p) ) p++ ;
  311.   }
  312.  
  313.   switch ( *p )
  314.   {
  315.     case 'e'  : if ( PageNumber & 1 ) BSET( Flg , F_WASFALSE ) ; p++ ; break ; 
  316.     case 'o'  : if (! (PageNumber & 1)) BSET( Flg , F_WASFALSE ) ; p++ ; break ;
  317.     case 'n'  : p++ ; break ;
  318.     case 't'  : BSET( Flg , F_WASFALSE ) ; p++ ; break ;
  319.     case '\'' : p = TestString( p ) ; break ;
  320.     default   : if (! isdigit(*p)) Fatal( ERR_SYNTAX ) ;
  321.                 p = TestNum( p ) ; break ;
  322.                 break ;
  323.   }
  324.  
  325.   if ( Flg & F_IFNOT ) 
  326.     if ( Flg & F_WASFALSE )
  327.       BCLR( Flg , F_WASFALSE ) ;
  328.     else
  329.       BSET( Flg , F_WASFALSE ) ;
  330.  
  331.   while ( isspace(*p) ) p++ ;
  332.   if (! *p) Fatal( ERR_SYNTAX ) ;
  333.   sprintf( tmp , "%s\n\\\n" , p ) ;
  334.   if (! (Flg & F_WASFALSE)) NewString( tmp ) ;
  335. }
  336.  
  337. /***********************************************************************/
  338.  
  339. void do_in()
  340. {
  341.   long oldval ;
  342.  
  343.   do_br() ;
  344.   oldval = Indent ;
  345.   if (! ChangeValue( &Indent )) Indent = Pop( TE_INDENT , 0 ) ;
  346.   if ( Indent < 0 ) Indent = DEF_INDENT ;
  347.   Push( TE_INDENT , oldval ) ;
  348. }
  349.  
  350. /***********************************************************************/
  351.  
  352. void do_ll()
  353. {
  354.   long oldval ;
  355.  
  356.   oldval = LineLen ;
  357.   if (! ChangeValue( &LineLen )) LineLen = Pop( TE_LINLEN , 0 ) ;
  358.   if ( LineLen < 0 ) LineLen = DEF_LINLEN ;
  359.   Push( TE_LINLEN , oldval ) ;
  360. }
  361.  
  362. /***********************************************************************/
  363.  
  364. void do_ls()
  365. {
  366.   long oldval ;
  367.  
  368.   oldval = LineSpacing ;
  369.   if (! (LineSpacing = atoi( Arg ))) LineSpacing = Pop( TE_LINSPC , 0 ) ;
  370.   if ( LineSpacing < 1 ) LineSpacing = DEF_LINSPC ;
  371.   Push( TE_LINSPC , oldval ) ;
  372. }
  373.  
  374. /***********************************************************************/
  375.  
  376. void do_lt()
  377. {
  378.   long oldval ;
  379.  
  380.   oldval = TitleLen ;
  381.   if (! ChangeValue( &TitleLen )) TitleLen = Pop( TE_TITLEN , 0 ) ;
  382.   if ( TitleLen < 0 ) TitleLen = DEF_TITLEN ;
  383.   Push( TE_TITLEN , oldval ) ;
  384. }
  385.  
  386. /***********************************************************************/
  387.  
  388. void do_na()
  389. {
  390.   Push( TE_ADJMOD , AdjustMode ) ;
  391.   AdjustMode = AM_LEFT ;
  392. }
  393.  
  394. /***********************************************************************/
  395.  
  396. void do_ne()
  397. {
  398.   register long k, l ;
  399.  
  400.   if ( ! ArgLen ) return ;
  401.   k = OutputLine + (( isdigit( Arg[0] ) ) ? atoi( Arg ) : 1) - 1 ;
  402.  
  403.   if ( k > PageLen )
  404.   {
  405. _do_it:
  406.     *Arg = '\0' ;
  407.     ArgLen = 0 ;
  408.     do_bp() ;
  409.     return ;
  410.   }
  411.  
  412.   for ( l = OutputLine ; l <= k ; l++ )
  413.     if ( FindTrp( l ) ) goto _do_it ;
  414. }
  415.  
  416. /***********************************************************************/
  417.  
  418. void do_nf()
  419. {
  420.   do_br() ;
  421.   BCLR( InputMode , IM_FILLING ) ;
  422. }
  423.  
  424. /***********************************************************************/
  425.  
  426. void do_nm()
  427. {
  428.   unsigned char *p ;
  429.  
  430.   if (! ArgLen)
  431.   {
  432.     BCLR( Flg , F_NUMBER ) ;
  433.     return ;
  434.   }
  435.  
  436.   BSET( Flg , F_NUMBER ) ;
  437.   ChangeValue( &LineNumber ) ;
  438.   for ( p = Arg ; (*p != '\0') && (! isspace( *p )) ; p++ ) ;
  439.   p = GetArg( p , &NumInterv ) ;
  440.   if (! NumInterv) Fatal( ERR_SYNTAX ) ;
  441.   p = GetArg( p , &NumSpace ) ;
  442.   GetArg( p , &NumIndent ) ;
  443. }
  444.  
  445. /***********************************************************************/
  446.  
  447. void do_nn()
  448. {
  449.   TmpNoNum = ( isdigit( Arg[0] ) ) ? atoi( Arg ) : 1 ;
  450. }
  451.  
  452. /***********************************************************************/
  453.  
  454. void do_nr()
  455. {
  456.   register long k, val, inc ;
  457.   register unsigned char *var ;
  458.  
  459.   if ( ! ArgLen ) return ;
  460.  
  461.   /* isole le nom du registre */
  462.  
  463.   var = Arg ;
  464.   for ( k = 0 ; (Arg[k] != '\0') && (! isspace( Arg[k] )) ; k++ ) ;
  465.   if ( Arg[k] == '\0' ) return ;
  466.   Arg[k] = '\0' ;
  467.  
  468.   /* recupere la valeur initiale */
  469.  
  470.   for ( k++ ; isspace( Arg[k] ) ; k++ ) ;
  471.   val = atoi( &Arg[k] ) ;
  472.  
  473.   /* recupere l'increment */
  474.   while ( isdigit( Arg[k] ) ) k++ ;
  475.   while ( isspace( Arg[k] ) ) k++ ;
  476.   inc = atoi( &Arg[k] ) ;
  477.  
  478.   SetReg( var , val , inc ) ;
  479. }
  480.  
  481. /***********************************************************************/
  482.  
  483. void do_pl()
  484. {
  485.   if (! ChangeValue( &PageLen )) PageLen = DEF_PAGLEN ;
  486.   UpdateTrp() ;
  487. }
  488.  
  489. /***********************************************************************/
  490.  
  491. void do_pm()
  492. {
  493.   register struct Macro *m ;
  494.   register struct MLine *l ;
  495.  
  496.   m = (struct Macro *) (( ArgLen ) ? FindVar( &TMac , Arg ) : NULL) ;
  497.  
  498.   if ( m )
  499.     for ( l = (struct MLine *)m->m_Def.tl_Premier ;
  500.       l ;
  501.       l = (struct MLine *)l->ml_Node.el_Suivant )
  502.     {
  503.       write( 1 , l->ml_Text , l->ml_Len ) ;
  504.       write( 1 , "\n" , 1 ) ;
  505.     }
  506.   else for ( m = (struct Macro *)TMac.tl_Premier ;
  507.          m ;
  508.          m = (struct Macro *)m->m_Node.el_Suivant )
  509.   {
  510.     printf( "Macro %s : \n" , m->m_Name ) ;
  511.     fflush( stdout ) ;
  512.     for ( l = (struct MLine *)m->m_Def.tl_Premier ;
  513.       l ;
  514.       l = (struct MLine *)l->ml_Node.el_Suivant )
  515.     {
  516.       write( 1 , l->ml_Text , l->ml_Len ) ;
  517.       write( 1 , "\n" , 1 ) ;
  518.     }
  519.   }
  520. }
  521.  
  522. /***********************************************************************/
  523.  
  524. void do_pn()
  525. {
  526.   long oldval ;
  527.  
  528.   oldval = PageNumber ;
  529.   if (! ChangeValue( &oldval )) return ;
  530.   if ( oldval > 1 ) NewPageNumber = oldval ;
  531. }
  532.  
  533. /***********************************************************************/
  534.  
  535. void do_po()
  536. {
  537.   long oldval ;
  538.  
  539.   oldval = PageOffset ;
  540.   if (! ChangeValue( &PageOffset )) PageOffset = Pop( TE_PAGOFS , 0 ) ;
  541.   if ( PageOffset < 0 ) PageOffset = DEF_PAGOFS ;
  542.   Push( TE_PAGOFS , oldval ) ;
  543. }
  544.  
  545. /***********************************************************************/
  546.  
  547. void do_rm()
  548. {
  549.   if ( ArgLen ) RemMac( Arg ) ;
  550. }
  551.  
  552. /***********************************************************************/
  553.  
  554. void do_rr()
  555. {
  556.   if ( ArgLen ) RemReg( Arg ) ;
  557. }
  558.  
  559. /***********************************************************************/
  560.  
  561. void do_rs()
  562. {
  563.   if ( ArgLen ) RemStr( Arg ) ;
  564. }
  565.  
  566. /***********************************************************************/
  567.  
  568. void do_rt()
  569. {
  570.   long lig, k ;
  571.  
  572.   if (! ArgLen) return ;
  573.   lig = 0 ;
  574.   if (! ChangeValue( &lig )) return ;
  575.  
  576.   RemTrp( lig ) ;
  577. }
  578.  
  579. /***********************************************************************/
  580.  
  581. void do_so()
  582. {
  583.   if ( ! ArgLen ) Fatal( ERR_SYNTAX ) ;
  584.   Push( TE_INFILE , CurrentInputFile ) ;
  585.  
  586.   CurrentInputFile = NewFile( Arg ) ;
  587.   if ( CurrentInputFile ) SetStr( "fn" , CurrentInputFile->if_Name ) ;
  588. }
  589.  
  590. /***********************************************************************/
  591.  
  592. void do_sp()
  593. {
  594.   do_br() ;
  595.   EmptyToWrite += ( isdigit( Arg[0] ) ) ? atoi( Arg ) : 1 ;
  596. }
  597.  
  598. /***********************************************************************/
  599.  
  600. void do_ta()
  601. {
  602.   long oldval ;
  603.  
  604.   oldval = TabLen ;
  605.   if (! ChangeValue( &TabLen )) TabLen = oldval ;
  606. }
  607.  
  608. /***********************************************************************/
  609.  
  610. void do_tc()
  611. {
  612.   TabChar = ( Arg[0] == '\0' ) ? DEF_TABCHR : Arg[0] ;
  613. }
  614.  
  615. /***********************************************************************/
  616.  
  617. void do_ti()
  618. {
  619.   do_br() ;
  620.   TmpIndent = myatoi() ;
  621.   BCLR( Flg , F_NOTI ) ;
  622. }
  623.  
  624. /***********************************************************************/
  625.  
  626. void do_tl()
  627. {
  628.   long i ;
  629.   register long k, l ;
  630.   unsigned char *centre, *droit ;
  631.   register unsigned char delim, *gauche, *p ;
  632.  
  633.   if ( ! ArgLen ) return ;
  634.  
  635.   /* recupere les trois morceaux */
  636.  
  637.   delim = Arg[0] ;
  638.  
  639.   gauche = &Arg[1] ;
  640.   while ( (*gauche != delim) && (*gauche != '\0') ) gauche++ ;
  641.   if ( *gauche == '\0' ) Fatal( ERR_SYNTAX ) ;
  642.   *gauche = '\0' ;
  643.   gauche++ ;
  644.  
  645.   centre = gauche ;
  646.   while ( (*gauche != delim) && (*gauche != '\0') ) gauche++ ;
  647.   if ( *gauche == '\0' ) Fatal( ERR_SYNTAX ) ;
  648.   *gauche = '\0' ;
  649.   gauche++ ;
  650.  
  651.   droit = gauche ;
  652.   while ( (*gauche != delim) && (*gauche != '\0') ) gauche++ ;
  653.   if ( *gauche == '\0' ) Fatal( ERR_SYNTAX ) ;
  654.   *gauche = '\0' ;
  655.  
  656.   gauche = &Arg[1] ;
  657.  
  658.   /* calcule l'intervalle et pond le resultat */
  659.  
  660.   p = tmp ;
  661.   i = TitleLen - strlen( centre ) ;
  662.   k = i >> 1 ;
  663.   for ( l = 0 ; l < PageOffset ; l++ , p++ ) *p = ' ' ;
  664.   if ( k > 0 )
  665.   {
  666.     strcpy( p , TableEsc[6] ) ; /* repasse en normal */
  667.     while ( *p ) p++ ;
  668.     for ( l = 0 ; TitleSeq[l] ; l++ )
  669.     {
  670.       switch( TitleSeq[l] )
  671.       {
  672.     case 'b' : strcpy( p , TableEsc[1] ) ; break ;
  673.     case 'i' : strcpy( p , TableEsc[3] ) ; break ;
  674.     case 'u' : strcpy( p , TableEsc[5] ) ; break ;
  675.     default  : Fatal( ERR_SYNTAX ) ;
  676.       }
  677.       while ( *p ) p++ ;
  678.     }
  679.     strcpy( p , gauche ) ;
  680.     l = strlen( gauche ) ;
  681.     p += l ;
  682.     if ( i & 1 ) l-- ;
  683.     for ( l = k - l ; l > 0 ; l-- , p++ ) *p = ' ' ;
  684.     strcpy( p , centre ) ;
  685.     p += strlen( centre ) ;
  686.     for ( l = k - strlen( droit ) ; l > 0 ; l-- , p++ ) *p = ' ' ;
  687.     strcpy( p , droit ) ;
  688.     p += strlen( droit ) ;
  689.   }
  690.  
  691.   strcpy( p , TableEsc[6] ) ; /* repasse en normal */
  692.   strcat( p , "\n" ) ;
  693.   EmptyToWrite += LineSpacing - 1 ;
  694.   LigneSuiv( tmp ) ;
  695. }
  696.  
  697. /***********************************************************************/
  698.  
  699. void do_tr()
  700. {
  701.   if (! ArgLen) return ;
  702.   strcpy( TrTab , Arg ) ;
  703.   if ( ArgLen & 1 ) strcat( TrTab , " " ) ;
  704. }
  705.  
  706. /***********************************************************************/
  707.  
  708. void do_ts()
  709. {
  710.   if ( ! ArgLen ) return ;
  711.   strcpy( TitleSeq , Arg ) ;
  712. }
  713.  
  714. /***********************************************************************/
  715.  
  716. void do_wh()
  717. {
  718.   long lig, k ;
  719.   unsigned char *p ;
  720.  
  721.   if (! ArgLen) return ;
  722.   lig = 0 ;
  723.   if (! ChangeValue( &lig )) return ;
  724.  
  725.   for ( p = Arg ; (*p) && (! isspace( *p )) ; p++ ) ;
  726.   while ( isspace( *p ) ) p++ ;
  727.   k = strlen( p ) ;
  728.   if ( (k != 1) && (k != 2) ) Fatal( ERR_SYNTAX ) ;
  729.   SetTrp( lig , p ) ;
  730. }
  731.  
  732.