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

Annotation of mandoc/xml.c, Revision 1.22

1.22    ! kristaps    1: /* $Id: xml.c,v 1.21 2008/12/09 17:09:12 kristaps Exp $ */
1.1       kristaps    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:  */
1.16      kristaps   19: #include <assert.h>
1.1       kristaps   20: #include <stdlib.h>
                     21: #include <string.h>
                     22:
                     23: #include "private.h"
1.10      kristaps   24: #include "ml.h"
1.9       kristaps   25:
1.6       kristaps   26:
1.16      kristaps   27: static int             xml_alloc(void **);
                     28: static void            xml_free(void *);
1.15      kristaps   29: static ssize_t         xml_endtag(struct md_mbuf *, void *,
1.10      kristaps   30:                                const struct md_args *,
                     31:                                enum md_ns, int);
1.15      kristaps   32: static ssize_t         xml_begintag(struct md_mbuf *, void *,
1.10      kristaps   33:                                const struct md_args *,
                     34:                                enum md_ns, int,
                     35:                                const int *, const char **);
1.18      kristaps   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);
1.13      kristaps   42: static int             xml_begin(struct md_mbuf *,
                     43:                                const struct md_args *,
                     44:                                const struct tm *,
                     45:                                const char *, const char *,
1.20      kristaps   46:                                enum roffmsec, const char *);
1.11      kristaps   47: static int             xml_end(struct md_mbuf *,
                     48:                                const struct md_args *);
1.16      kristaps   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 **);
1.11      kristaps   53:
                     54:
1.16      kristaps   55: static ssize_t
                     56: xml_printtagargs(struct md_mbuf *mbuf, const int *argc,
                     57:                const char **argv)
1.11      kristaps   58: {
1.16      kristaps   59:        int              i, c;
1.11      kristaps   60:        size_t           res;
                     61:
1.16      kristaps   62:        if (NULL == argc || NULL == argv)
1.11      kristaps   63:                return(0);
1.16      kristaps   64:        assert(argc && argv);
1.11      kristaps   65:
1.17      kristaps   66:        /* LINTED */
1.16      kristaps   67:        for (res = 0, i = 0; ROFF_ARGMAX != (c = argc[i]); i++) {
                     68:                if ( ! ml_nputs(mbuf, " ", 1, &res))
                     69:                        return(-1);
1.11      kristaps   70:
1.22    ! kristaps   71:                /* FIXME: should puke on some, no? */
        !            72:
1.16      kristaps   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:        }
1.11      kristaps   85:
1.16      kristaps   86:        return((ssize_t)res);
1.11      kristaps   87: }
                     88:
1.10      kristaps   89:
                     90: static ssize_t
1.16      kristaps   91: xml_printtagname(struct md_mbuf *mbuf, enum md_ns ns, int tok)
1.8       kristaps   92: {
1.10      kristaps   93:        size_t           res;
1.8       kristaps   94:
1.10      kristaps   95:        res = 0;
1.6       kristaps   96:        switch (ns) {
1.9       kristaps   97:        case (MD_NS_BLOCK):
1.10      kristaps   98:                if ( ! ml_nputs(mbuf, "block:", 6, &res))
                     99:                        return(-1);
1.9       kristaps  100:                break;
1.16      kristaps  101:        case (MD_NS_INLINE):
                    102:                if ( ! ml_nputs(mbuf, "inline:", 7, &res))
                    103:                        return(-1);
                    104:                break;
1.11      kristaps  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;
1.9       kristaps  113:        default:
1.11      kristaps  114:                break;
1.6       kristaps  115:        }
                    116:
1.12      kristaps  117:        if ( ! ml_puts(mbuf, toknames[tok], &res))
1.10      kristaps  118:                return(-1);
1.16      kristaps  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,
1.20      kristaps  127:                const char *title, enum roffmsec section,
1.16      kristaps  128:                const char *vol)
                    129: {
1.6       kristaps  130:
1.16      kristaps  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\" "
1.19      kristaps  135:                                "xmlns:body=\"body\" "
                    136:                                "xmlns:head=\"head\" "
1.16      kristaps  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
1.18      kristaps  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
1.16      kristaps  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);
1.6       kristaps  185: }
                    186:
                    187:
1.12      kristaps  188: /* ARGSUSED */
1.10      kristaps  189: static ssize_t
1.15      kristaps  190: xml_endtag(struct md_mbuf *mbuf, void *data,
                    191:                const struct md_args *args, enum md_ns ns, int tok)
1.6       kristaps  192: {
                    193:
1.16      kristaps  194:        return(xml_printtagname(mbuf, ns, tok));
                    195: }
                    196:
                    197:
                    198: /* ARGSUSED */
                    199: int
                    200: xml_alloc(void **p)
                    201: {
                    202:
1.20      kristaps  203:        *p = NULL;
1.16      kristaps  204:        return(1);
                    205: }
1.10      kristaps  206:
1.6       kristaps  207:
1.16      kristaps  208: /* ARGSUSED */
                    209: void
                    210: xml_free(void *p)
                    211: {
1.1       kristaps  212:
1.16      kristaps  213:        /* Do nothing. */
1.1       kristaps  214: }
                    215:
                    216:
                    217: int
1.10      kristaps  218: md_line_xml(void *data, char *buf)
1.1       kristaps  219: {
                    220:
1.10      kristaps  221:        return(mlg_line((struct md_mlg *)data, buf));
1.1       kristaps  222: }
                    223:
                    224:
                    225: int
                    226: md_exit_xml(void *data, int flush)
                    227: {
                    228:
1.10      kristaps  229:        return(mlg_exit((struct md_mlg *)data, flush));
1.1       kristaps  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: {
1.16      kristaps  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;
1.18      kristaps  245:        cbs.ml_beginstring = xml_beginstring;
                    246:        cbs.ml_endstring = xml_endstring;
1.9       kristaps  247:
1.16      kristaps  248:        return(mlg_alloc(args, rbuf, mbuf, &cbs));
1.9       kristaps  249: }
                    250:

CVSweb