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

Diff for /docbook2mdoc/parse.c between version 1.23 and 1.24

version 1.23, 2019/04/08 14:37:31 version 1.24, 2019/04/08 22:47:34
Line 17 
Line 17 
  */   */
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
   #include <errno.h>
   #include <fcntl.h>
   #include <libgen.h>
 #include <stdarg.h>  #include <stdarg.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
Line 273  static const struct entity entities[] = {
Line 276  static const struct entity entities[] = {
   
 static size_t    parse_string(struct parse *, char *, size_t,  static size_t    parse_string(struct parse *, char *, size_t,
                          enum pstate *, int);                           enum pstate *, int);
   static void      parse_fd(struct parse *, int);
   
   
 static void  static void
Line 957  parse_string(struct parse *p, char *b, size_t rlen,
Line 961  parse_string(struct parse *p, char *b, size_t rlen,
         return poff;          return poff;
 }  }
   
 struct ptree *  
 parse_file(struct parse *p, int fd, const char *fname)  /*
    * The read loop.
    * If the previous token was incomplete and asked for more input,
    * we have to enter the read loop once more even on EOF.
    * Once rsz is 0, incomplete tokens will no longer ask for more input
    * but instead use whatever there is, and then exit the read loop.
    * The minus one on the size limit for read(2) is needed such that
    * advance() can set b[rlen] to NUL when needed.
    */
   static void
   parse_fd(struct parse *p, int fd)
 {  {
         char             b[4096];          char             b[4096];
         ssize_t          rsz;   /* Return value from read(2). */          ssize_t          rsz;   /* Return value from read(2). */
Line 966  parse_file(struct parse *p, int fd, const char *fname)
Line 980  parse_file(struct parse *p, int fd, const char *fname)
         size_t           poff;  /* Parse offset in b[]. */          size_t           poff;  /* Parse offset in b[]. */
         enum pstate      pstate;          enum pstate      pstate;
   
         p->fname = fname;  
         p->nline = 1;  
         p->ncol = 1;  
         pstate = PARSE_ELEM;  
         rlen = 0;          rlen = 0;
           pstate = PARSE_ELEM;
         /*  
          * Read loop.  
          *  
          * If the previous token was incomplete and asked for more  
          * input, we have to enter the read loop once more even on EOF.  
          * Once rsz is 0, incomplete tokens will no longer ask  
          * for more input but instead use whatever there is,  
          * and then exit the read loop.  
          * The minus one on the size limit for read(2) is needed  
          * such that advance() can set b[rlen] to NUL when needed.  
          */  
   
         while ((rsz = read(fd, b + rlen, sizeof(b) - rlen - 1)) >= 0 &&          while ((rsz = read(fd, b + rlen, sizeof(b) - rlen - 1)) >= 0 &&
             (rlen += rsz) > 0) {              (rlen += rsz) > 0) {
                 poff = parse_string(p, b, rlen, &pstate, rsz > 0);                  poff = parse_string(p, b, rlen, &pstate, rsz > 0);
Line 992  parse_file(struct parse *p, int fd, const char *fname)
Line 990  parse_file(struct parse *p, int fd, const char *fname)
                 rlen -= poff;                  rlen -= poff;
                 memmove(b, b + poff, rlen);                  memmove(b, b + poff, rlen);
         }          }
         if (rsz < 0) {          if (rsz < 0)
                 perror(fname);                  error_msg(p, "read: %s", strerror(errno));
                 p->tree->flags |= TREE_FAIL;  }
   
   /*
    * Open and parse a file.
    */
   struct ptree *
   parse_file(struct parse *p, int fd, const char *fname)
   {
           const char      *save_fname;
           int              save_line, save_col;
   
           /* Save and initialize reporting data. */
   
           save_fname = p->fname;
           save_line = p->nline;
           save_col = p->ncol;
           p->fname = fname;
           p->line = 0;
           p->col = 0;
   
           /* Open the file, unless it is already open. */
   
           if (fd == -1 && (fd = open(fname, O_RDONLY, 0)) == -1) {
                   error_msg(p, "open: %s", strerror(errno));
                   p->fname = save_fname;
                   return p->tree;
         }          }
         pnode_closetext(p);  
         if ((p->tree->flags & TREE_CLOSED) == 0)          /*
                 warn_msg(p, "document not closed");           * After opening the starting file, change to the directory it
         pnode_unlink(p->doctype);           * is located in, in case it wants to include any further files,
            * which are typically given with relative paths in DocBook.
            * Do this on a best-effort basis; don't complain about failure.
            */
   
           if (save_fname == NULL && (fname = dirname(fname)) != NULL &&
               strcmp(fname, ".") != 0)
                   (void)chdir(fname);
   
           /* Run the read loop. */
   
           p->nline = 1;
           p->ncol = 1;
           parse_fd(p, fd);
   
           /* On the top level, finalize the parse tree. */
   
           if (save_fname == NULL) {
                   pnode_closetext(p);
                   if (p->tree->root == NULL)
                           error_msg(p, "empty document");
                   else if ((p->tree->flags & TREE_CLOSED) == 0)
                           warn_msg(p, "document not closed");
                   pnode_unlink(p->doctype);
           }
   
           /* Clean up. */
   
           if (fd != STDIN_FILENO)
                   close(fd);
           p->fname = save_fname;
           p->nline = save_line;
           p->ncol = save_col;
         return p->tree;          return p->tree;
 }  }
Legend:
Removed from v.1.23  
changed lines
  Added in v.1.24
CVSweb