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