xml.c

   1 /* $Id: xml.c,v 1.22 2008/12/10 00:53:40 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the
   7  * above copyright notice and this permission notice appear in all
   8  * copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  13  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  14  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  15  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  16  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19 #include <assert.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "private.h"
  24 #include "ml.h"
  25
  26
  27 static  int             xml_alloc(void **);
  28 static  void            xml_free(void *);
  29 static  ssize_t         xml_endtag(struct md_mbuf *, void *,
  30                                 const struct md_args *,
  31                                 enum md_ns, int);
  32 static  ssize_t         xml_begintag(struct md_mbuf *, void *,
  33                                 const struct md_args *,
  34                                 enum md_ns, int,
  35                                 const int *, const char **);
  36 static  ssize_t         xml_beginstring(struct md_mbuf *,
  37                                 const struct md_args *,
  38                                 const char *, size_t);
  39 static  ssize_t         xml_endstring(struct md_mbuf *,
  40                                 const struct md_args *,
  41                                 const char *, size_t);
  42 static  int             xml_begin(struct md_mbuf *,
  43                                 const struct md_args *,
  44                                 const struct tm *,
  45                                 const char *, const char *,
  46                                 enum roffmsec, const char *);
  47 static  int             xml_end(struct md_mbuf *,
  48                                 const struct md_args *);
  49 static  ssize_t         xml_printtagname(struct md_mbuf *,
  50                                 enum md_ns, int);
  51 static  ssize_t         xml_printtagargs(struct md_mbuf *,
  52                                 const int *, const char **);
  53
  54
  55 static ssize_t
  56 xml_printtagargs(struct md_mbuf *mbuf, const int *argc,
  57                 const char **argv)
  58 {
  59         int              i, c;
  60         size_t           res;
  61
  62         if (NULL == argc || NULL == argv)
  63                 return(0);
  64         assert(argc && argv);
  65
  66         /* LINTED */
  67         for (res = 0, i = 0; ROFF_ARGMAX != (c = argc[i]); i++) {
  68                 if ( ! ml_nputs(mbuf, " ", 1, &res))
  69                         return(-1);
  70
  71                 /* FIXME: should puke on some, no? */
  72
  73                 if ( ! ml_puts(mbuf, tokargnames[c], &res))
  74                         return(-1);
  75                 if ( ! ml_nputs(mbuf, "=\"", 2, &res))
  76                         return(-1);
  77                 if (argv[i]) {
  78                         if ( ! ml_putstring(mbuf, argv[i], &res))
  79                                 return(-1);
  80                 } else if ( ! ml_nputs(mbuf, "true", 4, &res))
  81                         return(-1);
  82                 if ( ! ml_nputs(mbuf, "\"", 1, &res))
  83                         return(-1);
  84         }
  85
  86         return((ssize_t)res);
  87 }
  88
  89
  90 static ssize_t
  91 xml_printtagname(struct md_mbuf *mbuf, enum md_ns ns, int tok)
  92 {
  93         size_t           res;
  94
  95         res = 0;
  96         switch (ns) {
  97         case (MD_NS_BLOCK):
  98                 if ( ! ml_nputs(mbuf, "block:", 6, &res))
  99                         return(-1);
 100                 break;
 101         case (MD_NS_INLINE):
 102                 if ( ! ml_nputs(mbuf, "inline:", 7, &res))
 103                         return(-1);
 104                 break;
 105         case (MD_NS_BODY):
 106                 if ( ! ml_nputs(mbuf, "body:", 5, &res))
 107                         return(-1);
 108                 break;
 109         case (MD_NS_HEAD):
 110                 if ( ! ml_nputs(mbuf, "head:", 5, &res))
 111                         return(-1);
 112                 break;
 113         default:
 114                 break;
 115         }
 116
 117         if ( ! ml_puts(mbuf, toknames[tok], &res))
 118                 return(-1);
 119         return((ssize_t)res);
 120 }
 121
 122
 123 /* ARGSUSED */
 124 static int
 125 xml_begin(struct md_mbuf *mbuf, const struct md_args *args,
 126                 const struct tm *tm, const char *os,
 127                 const char *title, enum roffmsec section,
 128                 const char *vol)
 129 {
 130
 131         if ( ! ml_puts(mbuf, "<?xml version=\"1.0\" "
 132                                 "encoding=\"UTF-8\"?>\n", NULL))
 133                 return(0);
 134         return(ml_puts(mbuf, "<mdoc xmlns:block=\"block\" "
 135                                 "xmlns:body=\"body\" "
 136                                 "xmlns:head=\"head\" "
 137                                 "xmlns:inline=\"inline\">", NULL));
 138 }
 139
 140
 141 /* ARGSUSED */
 142 static int
 143 xml_end(struct md_mbuf *mbuf, const struct md_args *args)
 144 {
 145
 146         return(ml_puts(mbuf, "</mdoc>", NULL));
 147 }
 148
 149
 150 /* ARGSUSED */
 151 static ssize_t
 152 xml_beginstring(struct md_mbuf *mbuf,
 153                 const struct md_args *args,
 154                 const char *buf, size_t sz)
 155 {
 156
 157         return(0);
 158 }
 159
 160
 161 /* ARGSUSED */
 162 static ssize_t
 163 xml_endstring(struct md_mbuf *mbuf,
 164                 const struct md_args *args,
 165                 const char *buf, size_t sz)
 166 {
 167
 168         return(0);
 169 }
 170
 171
 172 /* ARGSUSED */
 173 static ssize_t
 174 xml_begintag(struct md_mbuf *mbuf, void *data,
 175                 const struct md_args *args, enum md_ns ns,
 176                 int tok, const int *argc, const char **argv)
 177 {
 178         ssize_t          res, sz;
 179
 180         if (-1 == (res = xml_printtagname(mbuf, ns, tok)))
 181                 return(-1);
 182         if (-1 == (sz = xml_printtagargs(mbuf, argc, argv)))
 183                 return(-1);
 184         return(res + sz);
 185 }
 186
 187
 188 /* ARGSUSED */
 189 static ssize_t
 190 xml_endtag(struct md_mbuf *mbuf, void *data,
 191                 const struct md_args *args, enum md_ns ns, int tok)
 192 {
 193
 194         return(xml_printtagname(mbuf, ns, tok));
 195 }
 196
 197
 198 /* ARGSUSED */
 199 int
 200 xml_alloc(void **p)
 201 {
 202
 203         *p = NULL;
 204         return(1);
 205 }
 206
 207
 208 /* ARGSUSED */
 209 void
 210 xml_free(void *p)
 211 {
 212
 213         /* Do nothing. */
 214 }
 215
 216
 217 int
 218 md_line_xml(void *data, char *buf)
 219 {
 220
 221         return(mlg_line((struct md_mlg *)data, buf));
 222 }
 223
 224
 225 int
 226 md_exit_xml(void *data, int flush)
 227 {
 228
 229         return(mlg_exit((struct md_mlg *)data, flush));
 230 }
 231
 232
 233 void *
 234 md_init_xml(const struct md_args *args,
 235                 struct md_mbuf *mbuf, const struct md_rbuf *rbuf)
 236 {
 237         struct ml_cbs    cbs;
 238
 239         cbs.ml_alloc = xml_alloc;
 240         cbs.ml_free = xml_free;
 241         cbs.ml_begintag = xml_begintag;
 242         cbs.ml_endtag = xml_endtag;
 243         cbs.ml_begin = xml_begin;
 244         cbs.ml_end = xml_end;
 245         cbs.ml_beginstring = xml_beginstring;
 246         cbs.ml_endstring = xml_endstring;
 247
 248         return(mlg_alloc(args, rbuf, mbuf, &cbs));
 249 }
 250