[BACK]Return to dummy.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/Attic/dummy.c between version 1.1 and 1.8

version 1.1, 2008/11/23 16:53:18 version 1.8, 2008/11/27 14:02:41
Line 17 
Line 17 
  * PERFORMANCE OF THIS SOFTWARE.   * PERFORMANCE OF THIS SOFTWARE.
  */   */
 #include <assert.h>  #include <assert.h>
   #include <err.h>
   #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
   #include <string.h>
   
 #include "libmdocml.h"  #include "libmdocml.h"
 #include "private.h"  #include "private.h"
   
   #ifdef  __linux__
   #define strlcat         strncat
   #endif
   
   static  int             md_dummy_blk_in(int);
   static  int             md_dummy_blk_out(int);
   static  int             md_dummy_text_in(int, int *, char **);
   static  int             md_dummy_text_out(int);
   static  int             md_dummy_special(int);
   static  int             md_dummy_head(void);
   static  int             md_dummy_tail(void);
   
   static  void            dbg_prologue(const char *);
   static  void            dbg_epilogue(void);
   
   static  int             dbg_lvl = 0;
   static  char            dbg_line[72];
   
   struct  md_dummy {
           struct rofftree *tree;
           struct roffcb    cb;
   };
   
   
 int  int
 md_line_dummy(const struct md_args *args,  md_line_dummy(void *arg, char *buf, size_t sz)
                 struct md_mbuf *out, const struct md_rbuf *in,  
                 const char *buf, size_t sz, void *data)  
 {  {
           struct md_dummy *p;
   
         assert(buf);          p = (struct md_dummy *)arg;
         assert(out);          return(roff_engine(p->tree, buf, sz));
         assert(in);  }
         assert(args);  
         assert(NULL == data);  
   
         if ( ! md_buf_puts(out, buf, sz))  
                 return(0);  int
         if ( ! md_buf_putchar(out, '\n'))  md_exit_dummy(void *data, int flush)
                 return(0);  {
           int              c;
           struct md_dummy *p;
   
           p = (struct md_dummy *)data;
           c = roff_free(p->tree, flush);
           free(p);
   
           return(c);
   }
   
   
   void *
   md_init_dummy(const struct md_args *args,
                   struct md_mbuf *mbuf, const struct md_rbuf *rbuf)
   {
           struct md_dummy *p;
   
           if (NULL == (p = malloc(sizeof(struct md_dummy)))) {
                   warn("malloc");
                   return(NULL);
           }
   
           p->cb.roffhead = md_dummy_head;
           p->cb.rofftail = md_dummy_tail;
           p->cb.roffin = md_dummy_text_in;
           p->cb.roffout = md_dummy_text_out;
           p->cb.roffblkin = md_dummy_blk_in;
           p->cb.roffblkout = md_dummy_blk_out;
           p->cb.roffspecial = md_dummy_special;
   
           p->tree = roff_alloc(args, mbuf, rbuf, &p->cb);
   
           if (NULL == p->tree) {
                   free(p);
                   return(NULL);
           }
   
           return(p);
   }
   
   
   static void
   dbg_prologue(const char *p)
   {
           int              i;
   
           (void)snprintf(dbg_line, sizeof(dbg_line) - 1, "%6s", p);
           (void)strlcat(dbg_line, ": ", sizeof(dbg_line) - 1);
           /* LINTED */
           for (i = 0; i < dbg_lvl; i++)
                   (void)strlcat(dbg_line, "    ", sizeof(dbg_line) - 1);
   }
   
   
   static void
   dbg_epilogue(void)
   {
   
           assert(0 != dbg_line[0]);
           (void)printf("%s\n", dbg_line);
   }
   
   
   static int
   md_dummy_head(void)
   {
   
           return(1);
   }
   
   
   static int
   md_dummy_tail(void)
   {
   
           return(1);
   }
   
   
   static int
   md_dummy_special(int tok)
   {
   
           dbg_prologue("noop");
           (void)strlcat(dbg_line, toknames[tok], sizeof(dbg_line) - 1);
           dbg_epilogue();
   
           return(1);
   }
   
   
   static int
   md_dummy_blk_in(int tok)
   {
   
           dbg_prologue("blk");
           (void)strlcat(dbg_line, toknames[tok], sizeof(dbg_line) - 1);
           dbg_epilogue();
   
           dbg_lvl++;
           return(1);
   }
   
   
   static int
   md_dummy_blk_out(int tok)
   {
   
           dbg_lvl--;
           return(1);
   }
   
   
   /* ARGSUSED */
   static int
   md_dummy_text_in(int tok, int *argcp, char **argvp)
   {
   
           dbg_prologue("text");
           (void)strlcat(dbg_line, toknames[tok], sizeof(dbg_line) - 1);
           (void)strlcat(dbg_line, " ", sizeof(dbg_line) - 1);
           while (ROFF_ARGMAX != *argcp) {
                   (void)strlcat(dbg_line, "[", sizeof(dbg_line) - 1);
                   (void)strlcat(dbg_line, tokargnames[*argcp],
                                   sizeof(dbg_line) - 1);
                   if (*argvp) {
                           (void)strlcat(dbg_line, " [",
                                           sizeof(dbg_line) - 1);
                           (void)strlcat(dbg_line, *argvp,
                                           sizeof(dbg_line) - 1);
                           (void)strlcat(dbg_line, "]",
                                           sizeof(dbg_line) - 1);
                   }
                   (void)strlcat(dbg_line, "]", sizeof(dbg_line) - 1);
                   argcp++;
                   argvp++;
           }
           dbg_epilogue();
           return(1);
   }
   
   
   static int
   md_dummy_text_out(int tok)
   {
   
         return(1);          return(1);
 }  }
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.8
CVSweb