home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / texipf21.zip / texi2ipf / items.c < prev    next >
C/C++ Source or Header  |  1997-01-15  |  6KB  |  207 lines
  1. /*
  2.  * items.c - handles itemized list commands (formerly part of translate.c)
  3.  *           and @set / @clear tag lists
  4.  *
  5.  * texi2roff history:
  6.  *             Release 2.0     January 1990
  7.  *
  8.  * Copyright 1988, 1989, 1990  Beverly A.Erlebacher
  9.  * erlebach@cs.toronto.edu    ...uunet!utai!erlebach
  10.  *
  11.  * texi2ipf history:
  12.  *             Release 1.0     February 1993
  13.  *
  14.  * Modified by Marcus Gröber, Fido 2:2402/61.1
  15.  *
  16.  * Modified by Martin "Herbert" Dietze, Email herbert@wiloyee.shnet.org
  17.  *
  18.  */
  19.  
  20. /*
  21.  * History:
  22.  *
  23.  * $Log: items.c,v $
  24.  * Revision 1.3  1997/01/15 12:18:18  herbert
  25.  * - Fixed a bug in eat_first_word() that made the program crash sometimes.
  26.  * - "@ignore" environments will now be handled like real comments.
  27.  *
  28.  * Revision 1.2  1996/12/17 15:14:21  herbert
  29.  * Only some cosmetic changes. The code looks still rather ugly to me :-)
  30.  *
  31.  * Revision 1.1.1.1  1996/12/02 12:10:01  herbert
  32.  * Texi2IPF 1.0
  33.  *
  34.  */
  35.  
  36. #include "texi2ipf.h"
  37. #include <stdio.h>
  38. #include <stdlib.h>
  39. #include <string.h>
  40.  
  41. static char * id =
  42. "@(#)$Id: items.c,v 1.3 1997/01/15 12:18:18 herbert Exp $";
  43.  
  44. int  icount[MAXILEVEL];
  45. int  what[MAXILEVEL];
  46. char item[MAXILEVEL][MAXLINELEN];
  47.  
  48. struct {
  49.     char name[MAXTAGSIZE];
  50.     char *value;
  51. } tags[MAXTAG];                /* list of currently set tags */
  52. int tagnum=0;                  /* number ob tags set */
  53.  
  54. extern int  ilevel;
  55. char * gettoken( char *, char *);
  56. char * eatwhitespace( char *);
  57. void errormsg( char *, char *);
  58. struct tablerecd * lookup( char *);
  59.  
  60. /*
  61.  * itemize - handle the itemizing start commands @enumerate, @itemize
  62.  *     and @table
  63.  */
  64.  
  65. char * itemize( char*s, char *token)
  66. {
  67.     char *tag;
  68.  
  69.     tag = item[ilevel];
  70.     if ( STREQ( token, "@itemize") ) {
  71.         what[ilevel] = ITEMIZE;
  72.         s = gettoken( eatwhitespace( s), tag);
  73.         if ( *tag == '\n' ) { /* this is an error in the input */
  74.             --s;
  75.             *tag = '-';
  76.             errormsg( "missing itemizing argument ", "");
  77.         } else {
  78.             if ( *tag =='@' ) {
  79.                 if ( (lookup(tag)==NULL) && (lookup(strcat(tag,"{"))==NULL) )
  80.                     errormsg( "unrecognized itemizing argument ", tag);
  81.                 else
  82.                     if ( *(tag + strlen(tag) - 1) == '{' )
  83.                         (void) strcat( tag, "}");
  84.             }/* if */
  85.         }/* if */
  86.         (void) strcat( tag, " ");
  87.     } else if ( STREQ(token, "@enumerate") ) {
  88.         what[ilevel] = ENUMERATE;
  89.         icount[ilevel] = 1;
  90.     } else if ( STREQ( token, "@table") ) {
  91.         what[ilevel] = TABLE;
  92.         s = gettoken( eatwhitespace( s), tag);
  93.         if ( *tag == '\n' ) {
  94.             *tag = '\0';  /* do nothing special */
  95.             --s;
  96.         } else {
  97.             if ( *tag =='@' ) {
  98.                 if ( (lookup( tag) == NULL) 
  99.                      && (lookup( strcat( tag, "{")) == NULL) )
  100.                     errormsg( "unrecognized itemizing argument ", tag);
  101.                 else {
  102.                     what[ilevel] = APPLY;
  103.                     if ( *(tag + strlen(tag) - 1) != '{' )
  104.                         (void) strcat( tag, "{");
  105.                 }/* if */
  106.             }/* if */
  107.         }/* if */
  108.     }/* if */
  109.     while ( *s != '\n' && *s != '\0' )
  110.         ++s;  /* flush rest of line */
  111.     /* endwhile */
  112.     return s;
  113. }/* itemize() */
  114.  
  115. /*
  116.  * doitem - handle @item and @itemx
  117.  */
  118.  
  119. char * doitem( char *s, char *tag, int itemx)
  120. {
  121.     switch ( what[ilevel] ) {
  122.     case ITEMIZE:
  123.     case ENUMERATE:
  124.         *tag=0;
  125.         break;
  126.     case TABLE:
  127.         (void) strcpy( tag, (itemx ? "@br\n" : "@_tag{pt}"));
  128.         tag+=strlen( tag);
  129.         s = eatwhitespace( s);
  130.         if ( *s == '\n' ) {
  131.             *tag++ = '-';
  132.             errormsg( "missing table item tag", "");
  133.         } else
  134.             while( *s != '\n' )
  135.                 *tag++ = *s++;
  136.         *tag = '\0';
  137.         break;
  138.     case APPLY:
  139.         (void) strcpy( tag, (itemx ? "@br\n" : "@_tag{pt}"));
  140.         (void) strcat( tag, item[ilevel]);
  141.         tag += strlen( tag);
  142.         s = eatwhitespace( s);
  143.         while( *s != '\n' )
  144.             *tag++ = *s++;
  145.         *tag++ = '}';
  146.         *tag = '\0';
  147.         break;
  148.     }/* switch */
  149.     return s;
  150. }/* doitem() */
  151.  
  152. /*
  153.  * findtag - returns -1 if the tag has not been set,
  154.  *           or the index of the tag in the tag list.
  155.  */
  156. int findtag( char *str)
  157. {
  158.     int i;
  159.  
  160.     for( i = 0; i<tagnum; i++ )
  161.     if ( !strncmp( str, tags[i].name, strlen( tags[i].name)) )
  162.             return i;
  163.         /* endif */
  164.     /* endfor */
  165.     return -1;
  166. }/* findtag */
  167.  
  168. char * value ( char *str)
  169. {
  170.     int i;
  171.  
  172.     if ( (i = findtag( str)) == -1 ) {
  173.         return NULL;
  174.     } else {
  175.         return tags[i].value;
  176.     } /* endif */
  177. }/* value */
  178.  
  179. /*
  180.  * setclear - sets (value!="") or clears (value=="") a tag
  181.  */
  182. int setclear( char *str, char *val)
  183. {
  184.     int i;
  185.     if( *val ) {                    /* SET tag */
  186.         if ( (i=findtag( str)) == -1 && tagnum < MAXTAG )  
  187.             i=tagnum++;              /* Tag not found? Add tag */
  188.         else
  189.             free( tags[i].value);      /* Replace old tag value */
  190.         /* endif */
  191.         tags[i].value = malloc( strlen( val)+1);
  192.         if ( tags[i].value == NULL )
  193.         return -1;
  194.       /* endif */
  195.         strncpy( tags[i].name, str, MAXTAGSIZE);
  196.         strcpy( tags[i].value, val);
  197.     } else {
  198.                                       /* CLEAR tag */
  199.         i=findtag( str);              /* tag set? */
  200.         if( i!=-1 ) {                 /* yes, remove */
  201.             free( tags[tagnum-1].value);
  202.             memcpy( &tags[i], &tags[--tagnum], sizeof(*tags));
  203.         }/* if */
  204.     }/* if */
  205.     return 0;
  206. }/* setclear() */
  207.