";
static char div_open_blank[] = "
";
if (xop->xo_flags & XOF_DIV_OPEN)
return;
if (xop->xo_style != XO_STYLE_HTML)
return;
xop->xo_flags |= XOF_DIV_OPEN;
if (flags & XFF_BLANK_LINE)
xo_data_append(xop, div_open_blank, sizeof(div_open_blank) - 1);
else
xo_data_append(xop, div_open, sizeof(div_open) - 1);
if (xop->xo_flags & XOF_PRETTY)
xo_data_append(xop, "\n", 1);
}
static void
xo_line_close (xo_handle_t *xop)
{
static char div_close[] = "
";
switch (xop->xo_style) {
case XO_STYLE_HTML:
if (!(xop->xo_flags & XOF_DIV_OPEN))
xo_line_ensure_open(xop, 0);
xop->xo_flags &= ~XOF_DIV_OPEN;
xo_data_append(xop, div_close, sizeof(div_close) - 1);
if (xop->xo_flags & XOF_PRETTY)
xo_data_append(xop, "\n", 1);
break;
case XO_STYLE_TEXT:
xo_data_append(xop, "\n", 1);
break;
}
}
static int
xo_info_compare (const void *key, const void *data)
{
const char *name = key;
const xo_info_t *xip = data;
return strcmp(name, xip->xi_name);
}
static xo_info_t *
xo_info_find (xo_handle_t *xop, const char *name, int nlen)
{
xo_info_t *xip;
char *cp = alloca(nlen + 1); /* Need local copy for NUL termination */
memcpy(cp, name, nlen);
cp[nlen] = '\0';
xip = bsearch(cp, xop->xo_info, xop->xo_info_count,
sizeof(xop->xo_info[0]), xo_info_compare);
return xip;
}
#define CONVERT(_have, _need) (((_have) << 8) | (_need))
/*
* Check to see that the conversion is safe and sane.
*/
static int
xo_check_conversion (xo_handle_t *xop, int have_enc, int need_enc)
{
switch (CONVERT(have_enc, need_enc)) {
case CONVERT(XF_ENC_UTF8, XF_ENC_UTF8):
case CONVERT(XF_ENC_UTF8, XF_ENC_LOCALE):
case CONVERT(XF_ENC_WIDE, XF_ENC_UTF8):
case CONVERT(XF_ENC_WIDE, XF_ENC_LOCALE):
case CONVERT(XF_ENC_LOCALE, XF_ENC_LOCALE):
case CONVERT(XF_ENC_LOCALE, XF_ENC_UTF8):
return 0;
default:
xo_failure(xop, "invalid conversion (%c:%c)", have_enc, need_enc);
return 1;
}
}
static int
xo_format_string_direct (xo_handle_t *xop, xo_buffer_t *xbp,
xo_xff_flags_t flags,
const wchar_t *wcp, const char *cp, int len, int max,
int need_enc, int have_enc)
{
int cols = 0;
wchar_t wc;
int ilen, olen, width;
int attr = (flags & XFF_ATTR);
const char *sp;
if (len > 0 && !xo_buf_has_room(xbp, len))
return 0;
for (;;) {
if (len == 0)
break;
if (cp) {
if (*cp == '\0')
break;
if ((flags & XFF_UNESCAPE) && (*cp == '\\' || *cp == '%')) {
cp += 1;
len -= 1;
}
}
if (wcp && *wcp == L'\0')
break;
ilen = 0;
switch (have_enc) {
case XF_ENC_WIDE: /* Wide character */
wc = *wcp++;
ilen = 1;
break;
case XF_ENC_UTF8: /* UTF-8 */
ilen = xo_utf8_to_wc_len(cp);
if (ilen < 0) {
xo_failure(xop, "invalid UTF-8 character: %02hhx", *cp);
return -1;
}
if (len > 0 && len < ilen) {
len = 0; /* Break out of the loop */
continue;
}
wc = xo_utf8_char(cp, ilen);
if (wc == (wchar_t) -1) {
xo_failure(xop, "invalid UTF-8 character: %02hhx/%d",
*cp, ilen);
return -1;
}
cp += ilen;
break;
case XF_ENC_LOCALE: /* Native locale */
ilen = (len > 0) ? len : MB_LEN_MAX;
ilen = mbrtowc(&wc, cp, ilen, &xop->xo_mbstate);
if (ilen < 0) { /* Invalid data; skip */
xo_failure(xop, "invalid mbs char: %02hhx", *cp);
continue;
}
if (ilen == 0) { /* Hit a wide NUL character */
len = 0;
continue;
}
cp += ilen;
break;
}
/* Reduce len, but not below zero */
if (len > 0) {
len -= ilen;
if (len < 0)
len = 0;
}
/*
* Find the width-in-columns of this character, which must be done
* in wide characters, since we lack a mbswidth() function. If
* it doesn't fit
*/
width = wcwidth(wc);
if (width < 0)
width = iswcntrl(wc) ? 0 : 1;
if (xop->xo_style == XO_STYLE_TEXT || xop->xo_style == XO_STYLE_HTML) {
if (max > 0 && cols + width > max)
break;
}
switch (need_enc) {
case XF_ENC_UTF8:
/* Output in UTF-8 needs to be escaped, based on the style */
switch (xop->xo_style) {
case XO_STYLE_XML:
case XO_STYLE_HTML:
if (wc == '<')
sp = xo_xml_lt;
else if (wc == '>')
sp = xo_xml_gt;
else if (wc == '&')
sp = xo_xml_amp;
else if (attr && wc == '"')
sp = xo_xml_quot;
else
break;
int slen = strlen(sp);
if (!xo_buf_has_room(xbp, slen - 1))
return -1;
memcpy(xbp->xb_curp, sp, slen);
xbp->xb_curp += slen;
goto done_with_encoding; /* Need multi-level 'break' */
case XO_STYLE_JSON:
if (wc != '\\' && wc != '"')
break;
if (!xo_buf_has_room(xbp, 2))
return -1;
*xbp->xb_curp++ = '\\';
*xbp->xb_curp++ = wc & 0x7f;
goto done_with_encoding;
}
olen = xo_utf8_emit_len(wc);
if (olen < 0) {
xo_failure(xop, "ignoring bad length");
continue;
}
if (!xo_buf_has_room(xbp, olen))
return -1;
xo_utf8_emit_char(xbp->xb_curp, olen, wc);
xbp->xb_curp += olen;
break;
case XF_ENC_LOCALE:
if (!xo_buf_has_room(xbp, MB_LEN_MAX + 1))
return -1;
olen = wcrtomb(xbp->xb_curp, wc, &xop->xo_mbstate);
if (olen <= 0) {
xo_failure(xop, "could not convert wide char: %lx",
(unsigned long) wc);
olen = 1;
width = 1;
*xbp->xb_curp++ = '?';
} else
xbp->xb_curp += olen;
break;
}
done_with_encoding:
cols += width;
}
return cols;
}
static int
xo_format_string (xo_handle_t *xop, xo_buffer_t *xbp, xo_xff_flags_t flags,
xo_format_t *xfp)
{
static char null[] = "(null)";
+
char *cp = NULL;
wchar_t *wcp = NULL;
int len, cols = 0, rc = 0;
int off = xbp->xb_curp - xbp->xb_bufp, off2;
int need_enc = (xop->xo_style == XO_STYLE_TEXT)
? XF_ENC_LOCALE : XF_ENC_UTF8;
if (xo_check_conversion(xop, xfp->xf_enc, need_enc))
return 0;
+ len = xfp->xf_width[XF_WIDTH_SIZE];
+
if (xfp->xf_enc == XF_ENC_WIDE) {
wcp = va_arg(xop->xo_vap, wchar_t *);
if (xfp->xf_skip)
return 0;
+ /*
+ * Dont' deref NULL; use the traditional "(null)" instead
+ * of the more accurate "who's been a naughty boy, then?".
+ */
+ if (wcp == NULL) {
+ cp = null;
+ len = sizeof(null) - 1;
+ }
+
} else {
cp = va_arg(xop->xo_vap, char *); /* UTF-8 or native */
if (xfp->xf_skip)
return 0;
+ /* Echo "Dont' deref NULL" logic */
+ if (cp == NULL) {
+ cp = null;
+ len = sizeof(null) - 1;
+ }
+
/*
* Optimize the most common case, which is "%s". We just
* need to copy the complete string to the output buffer.
*/
if (xfp->xf_enc == need_enc
&& xfp->xf_width[XF_WIDTH_MIN] < 0
&& xfp->xf_width[XF_WIDTH_SIZE] < 0
&& xfp->xf_width[XF_WIDTH_MAX] < 0
&& !(xop->xo_flags & (XOF_ANCHOR | XOF_COLUMNS))) {
len = strlen(cp);
xo_buf_escape(xop, xbp, cp, len, flags);
/*
* Our caller expects xb_curp left untouched, so we have
* to reset it and return the number of bytes written to
* the buffer.
*/
off2 = xbp->xb_curp - xbp->xb_bufp;
rc = off2 - off;
xbp->xb_curp = xbp->xb_bufp + off;
return rc;
}
}
- len = xfp->xf_width[XF_WIDTH_SIZE];
-
- /*
- * Dont' deref NULL; use the traditional "(null)" instead
- * of the more accurate "who's been a naughty boy, then?".
- */
- if (cp == NULL && wcp == NULL) {
- cp = null;
- len = sizeof(null) - 1;
- }
-
cols = xo_format_string_direct(xop, xbp, flags, wcp, cp, len,
xfp->xf_width[XF_WIDTH_MAX],
need_enc, xfp->xf_enc);
if (cols < 0)
goto bail;
/*
* xo_buf_append* will move xb_curp, so we save/restore it.
*/
off2 = xbp->xb_curp - xbp->xb_bufp;
rc = off2 - off;
xbp->xb_curp = xbp->xb_bufp + off;
if (cols < xfp->xf_width[XF_WIDTH_MIN]) {
/*
* Find the number of columns needed to display the string.
* If we have the original wide string, we just call wcswidth,
* but if we did the work ourselves, then we need to do it.
*/
int delta = xfp->xf_width[XF_WIDTH_MIN] - cols;
if (!xo_buf_has_room(xbp, delta))
goto bail;
/*
* If seen_minus, then pad on the right; otherwise move it so
* we can pad on the left.
*/
if (xfp->xf_seen_minus) {
cp = xbp->xb_curp + rc;
} else {
cp = xbp->xb_curp;
memmove(xbp->xb_curp + delta, xbp->xb_curp, rc);
}
/* Set the padding */
memset(cp, (xfp->xf_leading_zero > 0) ? '0' : ' ', delta);
rc += delta;
cols += delta;
}
if (xop->xo_flags & XOF_COLUMNS)
xop->xo_columns += cols;
if (xop->xo_flags & XOF_ANCHOR)
xop->xo_anchor_columns += cols;
return rc;
bail:
xbp->xb_curp = xbp->xb_bufp + off;
return 0;
}
static void
xo_data_append_content (xo_handle_t *xop, const char *str, int len)
{
int cols;
int need_enc = (xop->xo_style == XO_STYLE_TEXT)
? XF_ENC_LOCALE : XF_ENC_UTF8;
cols = xo_format_string_direct(xop, &xop->xo_data, XFF_UNESCAPE,
NULL, str, len, -1,
need_enc, XF_ENC_UTF8);
if (xop->xo_flags & XOF_COLUMNS)
xop->xo_columns += cols;
if (xop->xo_flags & XOF_ANCHOR)
xop->xo_anchor_columns += cols;
}
static void
xo_bump_width (xo_format_t *xfp, int digit)
{
int *ip = &xfp->xf_width[xfp->xf_dots];
*ip = ((*ip > 0) ? *ip : 0) * 10 + digit;
}
static int
xo_trim_ws (xo_buffer_t *xbp, int len)
{
char *cp, *sp, *ep;
int delta;
/* First trim leading space */
for (cp = sp = xbp->xb_curp, ep = cp + len; cp < ep; cp++) {
if (*cp != ' ')
break;
}
delta = cp - sp;
if (delta) {
len -= delta;
memmove(sp, cp, len);
}
/* Then trim off the end */
for (cp = xbp->xb_curp, sp = ep = cp + len; cp < ep; ep--) {
if (ep[-1] != ' ')
break;
}
delta = sp - ep;
if (delta) {
len -= delta;
cp[len] = '\0';
}
return len;
}
static int
xo_format_data (xo_handle_t *xop, xo_buffer_t *xbp,
const char *fmt, int flen, xo_xff_flags_t flags)
{
xo_format_t xf;
const char *cp, *ep, *sp, *xp = NULL;
int rc, cols;
int style = (flags & XFF_XML) ? XO_STYLE_XML : xop->xo_style;
unsigned make_output = !(flags & XFF_NO_OUTPUT);
int need_enc = (xop->xo_style == XO_STYLE_TEXT)
? XF_ENC_LOCALE : XF_ENC_UTF8;
if (xbp == NULL)
xbp = &xop->xo_data;
for (cp = fmt, ep = fmt + flen; cp < ep; cp++) {
if (*cp != '%') {
add_one:
if (xp == NULL)
xp = cp;
if (*cp == '\\' && cp[1] != '\0')
cp += 1;
continue;
} if (cp + 1 < ep && cp[1] == '%') {
cp += 1;
goto add_one;
}
if (xp) {
if (make_output) {
cols = xo_format_string_direct(xop, xbp, flags | XFF_UNESCAPE,
NULL, xp, cp - xp, -1,
need_enc, XF_ENC_UTF8);
if (xop->xo_flags & XOF_COLUMNS)
xop->xo_columns += cols;
if (xop->xo_flags & XOF_ANCHOR)
xop->xo_anchor_columns += cols;
}
xp = NULL;
}
bzero(&xf, sizeof(xf));
xf.xf_leading_zero = -1;
xf.xf_width[0] = xf.xf_width[1] = xf.xf_width[2] = -1;
/*
* "%@" starts an XO-specific set of flags:
* @X@ - XML-only field; ignored if style isn't XML
*/
if (cp[1] == '@') {
for (cp += 2; cp < ep; cp++) {
if (*cp == '@') {
break;
}
if (*cp == '*') {
/*
* '*' means there's a "%*.*s" value in vap that
* we want to ignore
*/
if (!(xop->xo_flags & XOF_NO_VA_ARG))
va_arg(xop->xo_vap, int);
}
}
}
/* Hidden fields are only visible to JSON and XML */
if (xop->xo_flags & XFF_ENCODE_ONLY) {
if (style != XO_STYLE_XML
&& xop->xo_style != XO_STYLE_JSON)
xf.xf_skip = 1;
} else if (xop->xo_flags & XFF_DISPLAY_ONLY) {
if (style != XO_STYLE_TEXT
&& xop->xo_style != XO_STYLE_HTML)
xf.xf_skip = 1;
}
if (!make_output)
xf.xf_skip = 1;
/*
* Looking at one piece of a format; find the end and
* call snprintf. Then advance xo_vap on our own.
*
* Note that 'n', 'v', and '$' are not supported.
*/
sp = cp; /* Save start pointer */
for (cp += 1; cp < ep; cp++) {
if (*cp == 'l')
xf.xf_lflag += 1;
else if (*cp == 'h')
xf.xf_hflag += 1;
else if (*cp == 'j')
xf.xf_jflag += 1;
else if (*cp == 't')
xf.xf_tflag += 1;
else if (*cp == 'z')
xf.xf_zflag += 1;
else if (*cp == 'q')
xf.xf_qflag += 1;
else if (*cp == '.') {
if (++xf.xf_dots >= XF_WIDTH_NUM) {
xo_failure(xop, "Too many dots in format: '%s'", fmt);
return -1;
}
} else if (*cp == '-')
xf.xf_seen_minus = 1;
else if (isdigit((int) *cp)) {
if (xf.xf_leading_zero < 0)
xf.xf_leading_zero = (*cp == '0');
xo_bump_width(&xf, *cp - '0');
} else if (*cp == '*') {
xf.xf_stars += 1;
xf.xf_star[xf.xf_dots] = 1;
} else if (strchr("diouxXDOUeEfFgGaAcCsSp", *cp) != NULL)
break;
else if (*cp == 'n' || *cp == 'v') {
xo_failure(xop, "unsupported format: '%s'", fmt);
return -1;
}
}
if (cp == ep)
xo_failure(xop, "field format missing format character: %s",
fmt);
xf.xf_fc = *cp;
if (!(xop->xo_flags & XOF_NO_VA_ARG)) {
if (*cp == 's' || *cp == 'S') {
/* Handle "%*.*.*s" */
int s;
for (s = 0; s < XF_WIDTH_NUM; s++) {
if (xf.xf_star[s]) {
xf.xf_width[s] = va_arg(xop->xo_vap, int);
/* Normalize a negative width value */
if (xf.xf_width[s] < 0) {
if (s == 0) {
xf.xf_width[0] = -xf.xf_width[0];
xf.xf_seen_minus = 1;
} else
xf.xf_width[s] = -1; /* Ignore negative values */
}
}
}
}
}
/* If no max is given, it defaults to size */
if (xf.xf_width[XF_WIDTH_MAX] < 0 && xf.xf_width[XF_WIDTH_SIZE] >= 0)
xf.xf_width[XF_WIDTH_MAX] = xf.xf_width[XF_WIDTH_SIZE];
if (xf.xf_fc == 'D' || xf.xf_fc == 'O' || xf.xf_fc == 'U')
xf.xf_lflag = 1;
if (!xf.xf_skip) {
xo_buffer_t *fbp = &xop->xo_fmt;
int len = cp - sp + 1;
if (!xo_buf_has_room(fbp, len + 1))
return -1;
char *newfmt = fbp->xb_curp;
memcpy(newfmt, sp, len);
newfmt[0] = '%'; /* If we skipped over a "%@...@s" format */
newfmt[len] = '\0';
/*
* Bad news: our strings are UTF-8, but the stock printf
* functions won't handle field widths for wide characters
* correctly. So we have to handle this ourselves.
*/
if (xop->xo_formatter == NULL
&& (xf.xf_fc == 's' || xf.xf_fc == 'S')) {
xf.xf_enc = (xf.xf_lflag || (xf.xf_fc == 'S'))
? XF_ENC_WIDE : xf.xf_hflag ? XF_ENC_LOCALE : XF_ENC_UTF8;
rc = xo_format_string(xop, xbp, flags, &xf);
if ((flags & XFF_TRIM_WS)
&& (xop->xo_style == XO_STYLE_XML
|| xop->xo_style == XO_STYLE_JSON))
rc = xo_trim_ws(xbp, rc);
} else {
int columns = rc = xo_vsnprintf(xop, xbp, newfmt, xop->xo_vap);
/*
* For XML and HTML, we need "&<>" processing; for JSON,
* it's quotes. Text gets nothing.
*/
switch (style) {
case XO_STYLE_XML:
if (flags & XFF_TRIM_WS)
columns = rc = xo_trim_ws(xbp, rc);
/* fall thru */
case XO_STYLE_HTML:
rc = xo_escape_xml(xbp, rc, (flags & XFF_ATTR));
break;
case XO_STYLE_JSON:
if (flags & XFF_TRIM_WS)
columns = rc = xo_trim_ws(xbp, rc);
rc = xo_escape_json(xbp, rc);
break;
}
/*
* We can assume all the data we've added is ASCII, so
* the columns and bytes are the same. xo_format_string
* handles all the fancy string conversions and updates
* xo_anchor_columns accordingly.
*/
if (xop->xo_flags & XOF_COLUMNS)
xop->xo_columns += columns;
if (xop->xo_flags & XOF_ANCHOR)
xop->xo_anchor_columns += columns;
}
xbp->xb_curp += rc;
}
/*
* Now for the tricky part: we need to move the argument pointer
* along by the amount needed.
*/
if (!(xop->xo_flags & XOF_NO_VA_ARG)) {
if (xf.xf_fc == 's' ||xf.xf_fc == 'S') {
/*
* The 'S' and 's' formats are normally handled in
* xo_format_string, but if we skipped it, then we
* need to pop it.
*/
if (xf.xf_skip)
va_arg(xop->xo_vap, char *);
} else {
int s;
for (s = 0; s < XF_WIDTH_NUM; s++) {
if (xf.xf_star[s])
va_arg(xop->xo_vap, int);
}
if (strchr("diouxXDOU", xf.xf_fc) != NULL) {
if (xf.xf_hflag > 1) {
va_arg(xop->xo_vap, int);
} else if (xf.xf_hflag > 0) {
va_arg(xop->xo_vap, int);
} else if (xf.xf_lflag > 1) {
va_arg(xop->xo_vap, unsigned long long);
} else if (xf.xf_lflag > 0) {
va_arg(xop->xo_vap, unsigned long);
} else if (xf.xf_jflag > 0) {
va_arg(xop->xo_vap, intmax_t);
} else if (xf.xf_tflag > 0) {
va_arg(xop->xo_vap, ptrdiff_t);
} else if (xf.xf_zflag > 0) {
va_arg(xop->xo_vap, size_t);
} else if (xf.xf_qflag > 0) {
va_arg(xop->xo_vap, quad_t);
} else {
va_arg(xop->xo_vap, int);
}
} else if (strchr("eEfFgGaA", xf.xf_fc) != NULL)
if (xf.xf_lflag)
va_arg(xop->xo_vap, long double);
else
va_arg(xop->xo_vap, double);
else if (xf.xf_fc == 'C' || (xf.xf_fc == 'c' && xf.xf_lflag))
va_arg(xop->xo_vap, wint_t);
else if (xf.xf_fc == 'c')
va_arg(xop->xo_vap, int);
else if (xf.xf_fc == 'p')
va_arg(xop->xo_vap, void *);
}
}
}
if (xp) {
if (make_output) {
cols = xo_format_string_direct(xop, xbp, flags | XFF_UNESCAPE,
NULL, xp, cp - xp, -1,
need_enc, XF_ENC_UTF8);
if (xop->xo_flags & XOF_COLUMNS)
xop->xo_columns += cols;
if (xop->xo_flags & XOF_ANCHOR)
xop->xo_anchor_columns += cols;
}
xp = NULL;
}
return 0;
}
static char *
xo_fix_encoding (xo_handle_t *xop UNUSED, char *encoding)
{
char *cp = encoding;
if (cp[0] != '%' || !isdigit((int) cp[1]))
return encoding;
for (cp += 2; *cp; cp++) {
if (!isdigit((int) *cp))
break;
}
cp -= 1;
*cp = '%';
return cp;
}
static void
xo_buf_append_div (xo_handle_t *xop, const char *class, xo_xff_flags_t flags,
const char *name, int nlen,
const char *value, int vlen,
const char *encoding, int elen)
{
static char div_start[] = "
";
static char div_close[] = "
";
/*
* To build our XPath predicate, we need to save the va_list before
* we format our data, and then restore it before we format the
* xpath expression.
* Display-only keys implies that we've got an encode-only key
* elsewhere, so we don't use them from making predicates.
*/
int need_predidate =
(name && (flags & XFF_KEY) && !(flags & XFF_DISPLAY_ONLY)
&& (xop->xo_flags & XOF_XPATH));
if (need_predidate) {
va_list va_local;
va_copy(va_local, xop->xo_vap);
if (xop->xo_checkpointer)
xop->xo_checkpointer(xop, xop->xo_vap, 0);
/*
* Build an XPath predicate expression to match this key.
* We use the format buffer.
*/
xo_buffer_t *pbp = &xop->xo_predicate;
pbp->xb_curp = pbp->xb_bufp; /* Restart buffer */
xo_buf_append(pbp, "[", 1);
xo_buf_escape(xop, pbp, name, nlen, 0);
if (xop->xo_flags & XOF_PRETTY)
xo_buf_append(pbp, " = '", 4);
else
xo_buf_append(pbp, "='", 2);
/* The encoding format defaults to the normal format */
if (encoding == NULL) {
char *enc = alloca(vlen + 1);
memcpy(enc, value, vlen);
enc[vlen] = '\0';
encoding = xo_fix_encoding(xop, enc);
elen = strlen(encoding);
}
xo_format_data(xop, pbp, encoding, elen, XFF_XML | XFF_ATTR);
xo_buf_append(pbp, "']", 2);
/* Now we record this predicate expression in the stack */
xo_stack_t *xsp = &xop->xo_stack[xop->xo_depth];
int olen = xsp->xs_keys ? strlen(xsp->xs_keys) : 0;
int dlen = pbp->xb_curp - pbp->xb_bufp;
char *cp = xo_realloc(xsp->xs_keys, olen + dlen + 1);
if (cp) {
memcpy(cp + olen, pbp->xb_bufp, dlen);
cp[olen + dlen] = '\0';
xsp->xs_keys = cp;
}
/* Now we reset the xo_vap as if we were never here */
va_end(xop->xo_vap);
va_copy(xop->xo_vap, va_local);
va_end(va_local);
if (xop->xo_checkpointer)
xop->xo_checkpointer(xop, xop->xo_vap, 1);
}
if (flags & XFF_ENCODE_ONLY) {
/*
* Even if this is encode-only, we need to go thru the
* work of formatting it to make sure the args are cleared
* from xo_vap.
*/
xo_format_data(xop, &xop->xo_data, encoding, elen,
flags | XFF_NO_OUTPUT);
return;
}
xo_line_ensure_open(xop, 0);
if (xop->xo_flags & XOF_PRETTY)
xo_buf_indent(xop, xop->xo_indent_by);
xo_data_append(xop, div_start, sizeof(div_start) - 1);
xo_data_append(xop, class, strlen(class));
if (name) {
xo_data_append(xop, div_tag, sizeof(div_tag) - 1);
xo_data_escape(xop, name, nlen);
/*
* Save the offset at which we'd place units. See xo_format_units.
*/
if (xop->xo_flags & XOF_UNITS) {
xop->xo_flags |= XOF_UNITS_PENDING;
/*
* Note: We need the '+1' here because we know we've not
* added the closing quote. We add one, knowing the quote
* will be added shortly.
*/
xop->xo_units_offset =
xop->xo_data.xb_curp -xop->xo_data.xb_bufp + 1;
}
}
if (name) {
if (xop->xo_flags & XOF_XPATH) {
int i;
xo_stack_t *xsp;
xo_data_append(xop, div_xpath, sizeof(div_xpath) - 1);
if (xop->xo_leading_xpath)
xo_data_append(xop, xop->xo_leading_xpath,
strlen(xop->xo_leading_xpath));
for (i = 0; i <= xop->xo_depth; i++) {
xsp = &xop->xo_stack[i];
if (xsp->xs_name == NULL)
continue;
xo_data_append(xop, "/", 1);
xo_data_escape(xop, xsp->xs_name, strlen(xsp->xs_name));
if (xsp->xs_keys) {
/* Don't show keys for the key field */
if (i != xop->xo_depth || !(flags & XFF_KEY))
xo_data_append(xop, xsp->xs_keys, strlen(xsp->xs_keys));
}
}
xo_data_append(xop, "/", 1);
xo_data_escape(xop, name, nlen);
}
if ((xop->xo_flags & XOF_INFO) && xop->xo_info) {
static char in_type[] = "\" data-type=\"";
static char in_help[] = "\" data-help=\"";
xo_info_t *xip = xo_info_find(xop, name, nlen);
if (xip) {
if (xip->xi_type) {
xo_data_append(xop, in_type, sizeof(in_type) - 1);
xo_data_escape(xop, xip->xi_type, strlen(xip->xi_type));
}
if (xip->xi_help) {
xo_data_append(xop, in_help, sizeof(in_help) - 1);
xo_data_escape(xop, xip->xi_help, strlen(xip->xi_help));
}
}
}
if ((flags & XFF_KEY) && (xop->xo_flags & XOF_KEYS))
xo_data_append(xop, div_key, sizeof(div_key) - 1);
}
xo_data_append(xop, div_end, sizeof(div_end) - 1);
xo_format_data(xop, NULL, value, vlen, 0);
xo_data_append(xop, div_close, sizeof(div_close) - 1);
if (xop->xo_flags & XOF_PRETTY)
xo_data_append(xop, "\n", 1);
}
static void
xo_format_text (xo_handle_t *xop, const char *str, int len)
{
switch (xop->xo_style) {
case XO_STYLE_TEXT:
xo_buf_append_locale(xop, &xop->xo_data, str, len);
break;
case XO_STYLE_HTML:
xo_buf_append_div(xop, "text", 0, NULL, 0, str, len, NULL, 0);
break;
}
}
static void
xo_format_title (xo_handle_t *xop, const char *str, int len,
const char *fmt, int flen)
{
static char div_open[] = "
";
static char div_close[] = "
";
switch (xop->xo_style) {
case XO_STYLE_XML:
case XO_STYLE_JSON:
/*
* Even though we don't care about text, we need to do
* enough parsing work to skip over the right bits of xo_vap.
*/
if (len == 0)
xo_format_data(xop, NULL, fmt, flen, XFF_NO_OUTPUT);
return;
}
xo_buffer_t *xbp = &xop->xo_data;
int start = xbp->xb_curp - xbp->xb_bufp;
int left = xbp->xb_size - start;
int rc;
int need_enc = XF_ENC_LOCALE;
if (xop->xo_style == XO_STYLE_HTML) {
need_enc = XF_ENC_UTF8;
xo_line_ensure_open(xop, 0);
if (xop->xo_flags & XOF_PRETTY)
xo_buf_indent(xop, xop->xo_indent_by);
xo_buf_append(&xop->xo_data, div_open, sizeof(div_open) - 1);
}
start = xbp->xb_curp - xbp->xb_bufp; /* Reset start */
if (len) {
char *newfmt = alloca(flen + 1);
memcpy(newfmt, fmt, flen);
newfmt[flen] = '\0';
/* If len is non-zero, the format string apply to the name */
char *newstr = alloca(len + 1);
memcpy(newstr, str, len);
newstr[len] = '\0';
if (newstr[len - 1] == 's') {
int cols;
char *bp;
rc = snprintf(NULL, 0, newfmt, newstr);
if (rc > 0) {
/*
* We have to do this the hard way, since we might need
* the columns.
*/
bp = alloca(rc + 1);
rc = snprintf(bp, rc + 1, newfmt, newstr);
cols = xo_format_string_direct(xop, xbp, 0, NULL, bp, rc, -1,
need_enc, XF_ENC_UTF8);
if (cols > 0) {
if (xop->xo_flags & XOF_COLUMNS)
xop->xo_columns += cols;
if (xop->xo_flags & XOF_ANCHOR)
xop->xo_anchor_columns += cols;
}
}
goto move_along;
} else {
rc = snprintf(xbp->xb_curp, left, newfmt, newstr);
if (rc > left) {
if (!xo_buf_has_room(xbp, rc))
return;
left = xbp->xb_size - (xbp->xb_curp - xbp->xb_bufp);
rc = snprintf(xbp->xb_curp, left, newfmt, newstr);
}
if (rc > 0) {
if (xop->xo_flags & XOF_COLUMNS)
xop->xo_columns += rc;
if (xop->xo_flags & XOF_ANCHOR)
xop->xo_anchor_columns += rc;
}
}
} else {
xo_format_data(xop, NULL, fmt, flen, 0);
/* xo_format_data moved curp, so we need to reset it */
rc = xbp->xb_curp - (xbp->xb_bufp + start);
xbp->xb_curp = xbp->xb_bufp + start;
}
/* If we're styling HTML, then we need to escape it */
if (xop->xo_style == XO_STYLE_HTML) {
rc = xo_escape_xml(xbp, rc, 0);
}
if (rc > 0)
xbp->xb_curp += rc;
move_along:
if (xop->xo_style == XO_STYLE_HTML) {
xo_data_append(xop, div_close, sizeof(div_close) - 1);
if (xop->xo_flags & XOF_PRETTY)
xo_data_append(xop, "\n", 1);
}
}
static void
xo_format_prep (xo_handle_t *xop, xo_xff_flags_t flags)
{
if (xop->xo_stack[xop->xo_depth].xs_flags & XSF_NOT_FIRST) {
xo_data_append(xop, ",", 1);
if (!(flags & XFF_LEAF_LIST) && (xop->xo_flags & XOF_PRETTY))
xo_data_append(xop, "\n", 1);
} else
xop->xo_stack[xop->xo_depth].xs_flags |= XSF_NOT_FIRST;
}
#if 0
/* Useful debugging function */
void
xo_arg (xo_handle_t *xop);
void
xo_arg (xo_handle_t *xop)
{
xop = xo_default(xop);
fprintf(stderr, "0x%x", va_arg(xop->xo_vap, unsigned));
}
#endif /* 0 */
static void
xo_format_value (xo_handle_t *xop, const char *name, int nlen,
const char *format, int flen,
const char *encoding, int elen, xo_xff_flags_t flags)
{
int pretty = (xop->xo_flags & XOF_PRETTY);
int quote;
xo_buffer_t *xbp;
switch (xop->xo_style) {
case XO_STYLE_TEXT:
if (flags & XFF_ENCODE_ONLY)
flags |= XFF_NO_OUTPUT;
xo_format_data(xop, NULL, format, flen, flags);
break;
case XO_STYLE_HTML:
if (flags & XFF_ENCODE_ONLY)
flags |= XFF_NO_OUTPUT;
xo_buf_append_div(xop, "data", flags, name, nlen,
format, flen, encoding, elen);
break;
case XO_STYLE_XML:
/*
* Even though we're not making output, we still need to
* let the formatting code handle the va_arg popping.
*/
if (flags & XFF_DISPLAY_ONLY) {
flags |= XFF_NO_OUTPUT;
xo_format_data(xop, NULL, format, flen, flags);
break;
}
if (encoding) {
format = encoding;
flen = elen;
} else {
char *enc = alloca(flen + 1);
memcpy(enc, format, flen);
enc[flen] = '\0';
format = xo_fix_encoding(xop, enc);
flen = strlen(format);
}
if (nlen == 0) {
static char missing[] = "missing-field-name";
xo_failure(xop, "missing field name: %s", format);
name = missing;
nlen = sizeof(missing) - 1;
}
if (pretty)
xo_buf_indent(xop, -1);
xo_data_append(xop, "<", 1);
xo_data_escape(xop, name, nlen);
if (xop->xo_attrs.xb_curp != xop->xo_attrs.xb_bufp) {
xo_data_append(xop, xop->xo_attrs.xb_bufp,
xop->xo_attrs.xb_curp - xop->xo_attrs.xb_bufp);
xop->xo_attrs.xb_curp = xop->xo_attrs.xb_bufp;
}
/*
* We indicate 'key' fields using the 'key' attribute. While
* this is really committing the crime of mixing meta-data with
* data, it's often useful. Especially when format meta-data is
* difficult to come by.
*/
if ((flags & XFF_KEY) && (xop->xo_flags & XOF_KEYS)) {
static char attr[] = " key=\"key\"";
xo_data_append(xop, attr, sizeof(attr) - 1);
}
/*
* Save the offset at which we'd place units. See xo_format_units.
*/
if (xop->xo_flags & XOF_UNITS) {
xop->xo_flags |= XOF_UNITS_PENDING;
xop->xo_units_offset = xop->xo_data.xb_curp -xop->xo_data.xb_bufp;
}
xo_data_append(xop, ">", 1);
xo_format_data(xop, NULL, format, flen, flags);
xo_data_append(xop, "", 1);
if (pretty)
xo_data_append(xop, "\n", 1);
break;
case XO_STYLE_JSON:
if (flags & XFF_DISPLAY_ONLY) {
flags |= XFF_NO_OUTPUT;
xo_format_data(xop, NULL, format, flen, flags);
break;
}
if (encoding) {
format = encoding;
flen = elen;
} else {
char *enc = alloca(flen + 1);
memcpy(enc, format, flen);
enc[flen] = '\0';
format = xo_fix_encoding(xop, enc);
flen = strlen(format);
}
int first = !(xop->xo_stack[xop->xo_depth].xs_flags & XSF_NOT_FIRST);
xo_format_prep(xop, flags);
if (flags & XFF_QUOTE)
quote = 1;
else if (flags & XFF_NOQUOTE)
quote = 0;
else if (flen == 0) {
quote = 0;
format = "true"; /* JSON encodes empty tags as a boolean true */
flen = 4;
} else if (strchr("diouxXDOUeEfFgGaAcCp", format[flen - 1]) == NULL)
quote = 1;
else
quote = 0;
if (nlen == 0) {
static char missing[] = "missing-field-name";
xo_failure(xop, "missing field name: %s", format);
name = missing;
nlen = sizeof(missing) - 1;
}
if (flags & XFF_LEAF_LIST) {
if (first && pretty)
xo_buf_indent(xop, -1);
} else {
if (pretty)
xo_buf_indent(xop, -1);
xo_data_append(xop, "\"", 1);
xbp = &xop->xo_data;
int off = xbp->xb_curp - xbp->xb_bufp;
xo_data_escape(xop, name, nlen);
if (xop->xo_flags & XOF_UNDERSCORES) {
int now = xbp->xb_curp - xbp->xb_bufp;
for ( ; off < now; off++)
if (xbp->xb_bufp[off] == '-')
xbp->xb_bufp[off] = '_';
}
xo_data_append(xop, "\":", 2);
}
if (pretty)
xo_data_append(xop, " ", 1);
if (quote)
xo_data_append(xop, "\"", 1);
xo_format_data(xop, NULL, format, flen, flags);
if (quote)
xo_data_append(xop, "\"", 1);
break;
}
}
static void
xo_format_content (xo_handle_t *xop, const char *class_name,
const char *xml_tag, int display_only,
const char *str, int len, const char *fmt, int flen)
{
switch (xop->xo_style) {
case XO_STYLE_TEXT:
if (len) {
xo_data_append_content(xop, str, len);
} else
xo_format_data(xop, NULL, fmt, flen, 0);
break;
case XO_STYLE_HTML:
if (len == 0) {
str = fmt;
len = flen;
}
xo_buf_append_div(xop, class_name, 0, NULL, 0, str, len, NULL, 0);
break;
case XO_STYLE_XML:
if (xml_tag) {
if (len == 0) {
str = fmt;
len = flen;
}
xo_open_container_h(xop, xml_tag);
xo_format_value(xop, "message", 7, str, len, NULL, 0, 0);
xo_close_container_h(xop, xml_tag);
} else {
/*
* Even though we don't care about labels, we need to do
* enough parsing work to skip over the right bits of xo_vap.
*/
if (len == 0)
xo_format_data(xop, NULL, fmt, flen, XFF_NO_OUTPUT);
}
break;
case XO_STYLE_JSON:
/*
* Even though we don't care about labels, we need to do
* enough parsing work to skip over the right bits of xo_vap.
*/
if (display_only) {
if (len == 0)
xo_format_data(xop, NULL, fmt, flen, XFF_NO_OUTPUT);
break;
}
/* XXX need schem for representing errors in JSON */
break;
}
}
static void
xo_format_units (xo_handle_t *xop, const char *str, int len,
const char *fmt, int flen)
{
static char units_start_xml[] = " units=\"";
static char units_start_html[] = " data-units=\"";
if (!(xop->xo_flags & XOF_UNITS_PENDING)) {
xo_format_content(xop, "units", NULL, 1, str, len, fmt, flen);
return;
}
xo_buffer_t *xbp = &xop->xo_data;
int start = xop->xo_units_offset;
int stop = xbp->xb_curp - xbp->xb_bufp;
if (xop->xo_style == XO_STYLE_XML)
xo_buf_append(xbp, units_start_xml, sizeof(units_start_xml) - 1);
else if (xop->xo_style == XO_STYLE_HTML)
xo_buf_append(xbp, units_start_html, sizeof(units_start_html) - 1);
else
return;
if (len)
xo_data_append(xop, str, len);
else
xo_format_data(xop, NULL, fmt, flen, 0);
xo_buf_append(xbp, "\"", 1);
int now = xbp->xb_curp - xbp->xb_bufp;
int delta = now - stop;
if (delta < 0) { /* Strange; no output to move */
xbp->xb_curp = xbp->xb_bufp + stop; /* Reset buffer to prior state */
return;
}
/*
* Now we're in it alright. We've need to insert the unit value
* we just created into the right spot. We make a local copy,
* move it and then insert our copy. We know there's room in the
* buffer, since we're just moving this around.
*/
char *buf = alloca(delta);
memcpy(buf, xbp->xb_bufp + stop, delta);
memmove(xbp->xb_bufp + start + delta, xbp->xb_bufp + start, stop - start);
memmove(xbp->xb_bufp + start, buf, delta);
}
static int
xo_find_width (xo_handle_t *xop, const char *str, int len,
const char *fmt, int flen)
{
long width = 0;
char *bp;
char *cp;
if (len) {
bp = alloca(len + 1); /* Make local NUL-terminated copy of str */
memcpy(bp, str, len);
bp[len] = '\0';
width = strtol(bp, &cp, 0);
if (width == LONG_MIN || width == LONG_MAX
|| bp == cp || *cp != '\0' ) {
width = 0;
xo_failure(xop, "invalid width for anchor: '%s'", bp);
}
} else if (flen) {
if (flen != 2 || strncmp("%d", fmt, flen) != 0)
xo_failure(xop, "invalid width format: '%*.*s'", flen, flen, fmt);
if (!(xop->xo_flags & XOF_NO_VA_ARG))
width = va_arg(xop->xo_vap, int);
}
return width;
}
static void
xo_anchor_clear (xo_handle_t *xop)
{
xop->xo_flags &= ~XOF_ANCHOR;
xop->xo_anchor_offset = 0;
xop->xo_anchor_columns = 0;
xop->xo_anchor_min_width = 0;
}
/*
* An anchor is a marker used to delay field width implications.
* Imagine the format string "{[:10}{min:%d}/{cur:%d}/{max:%d}{:]}".
* We are looking for output like " 1/4/5"
*
* To make this work, we record the anchor and then return to
* format it when the end anchor tag is seen.
*/
static void
xo_anchor_start (xo_handle_t *xop, const char *str, int len,
const char *fmt, int flen)
{
if (xop->xo_style != XO_STYLE_TEXT && xop->xo_style != XO_STYLE_HTML)
return;
if (xop->xo_flags & XOF_ANCHOR)
xo_failure(xop, "the anchor already recording is discarded");
xop->xo_flags |= XOF_ANCHOR;
xo_buffer_t *xbp = &xop->xo_data;
xop->xo_anchor_offset = xbp->xb_curp - xbp->xb_bufp;
xop->xo_anchor_columns = 0;
/*
* Now we find the width, if possible. If it's not there,
* we'll get it on the end anchor.
*/
xop->xo_anchor_min_width = xo_find_width(xop, str, len, fmt, flen);
}
static void
xo_anchor_stop (xo_handle_t *xop, const char *str, int len,
const char *fmt, int flen)
{
if (xop->xo_style != XO_STYLE_TEXT && xop->xo_style != XO_STYLE_HTML)
return;
if (!(xop->xo_flags & XOF_ANCHOR)) {
xo_failure(xop, "no start anchor");
return;
}
xop->xo_flags &= ~XOF_UNITS_PENDING;
int width = xo_find_width(xop, str, len, fmt, flen);
if (width == 0)
width = xop->xo_anchor_min_width;
if (width == 0) /* No width given; nothing to do */
goto done;
xo_buffer_t *xbp = &xop->xo_data;
int start = xop->xo_anchor_offset;
int stop = xbp->xb_curp - xbp->xb_bufp;
int abswidth = (width > 0) ? width : -width;
int blen = abswidth - xop->xo_anchor_columns;
if (blen <= 0) /* Already over width */
goto done;
if (abswidth > XO_MAX_ANCHOR_WIDTH) {
xo_failure(xop, "width over %u are not supported",
XO_MAX_ANCHOR_WIDTH);
goto done;
}
/* Make a suitable padding field and emit it */
char *buf = alloca(blen);
memset(buf, ' ', blen);
xo_format_content(xop, "padding", NULL, 1, buf, blen, NULL, 0);
if (width < 0) /* Already left justified */
goto done;
int now = xbp->xb_curp - xbp->xb_bufp;
int delta = now - stop;
if (delta < 0) /* Strange; no output to move */
goto done;
/*
* Now we're in it alright. We've need to insert the padding data
* we just created (which might be an HTML
or text) before
* the formatted data. We make a local copy, move it and then
* insert our copy. We know there's room in the buffer, since
* we're just moving this around.
*/
if (delta > blen)
buf = alloca(delta); /* Expand buffer if needed */
memcpy(buf, xbp->xb_bufp + stop, delta);
memmove(xbp->xb_bufp + start + delta, xbp->xb_bufp + start, stop - start);
memmove(xbp->xb_bufp + start, buf, delta);
done:
xo_anchor_clear(xop);
}
static int
xo_do_emit (xo_handle_t *xop, const char *fmt)
{
int rc = 0;
const char *cp, *sp, *ep, *basep;
char *newp = NULL;
int flush = (xop->xo_flags & XOF_FLUSH) ? 1 : 0;
xop->xo_columns = 0; /* Always reset it */
for (cp = fmt; *cp; ) {
if (*cp == '\n') {
xo_line_close(xop);
xo_flush_h(xop);
cp += 1;
continue;
} else if (*cp == '{') {
if (cp[1] == '{') { /* Start of {{escaped braces}} */
cp += 2; /* Skip over _both_ characters */
for (sp = cp; *sp; sp++) {
if (*sp == '}' && sp[1] == '}')
break;
}
if (*sp == '\0') {
xo_failure(xop, "missing closing '}}': %s", fmt);
return -1;
}
xo_format_text(xop, cp, sp - cp);
/* Move along the string, but don't run off the end */
if (*sp == '}' && sp[1] == '}')
sp += 2;
cp = *sp ? sp + 1 : sp;
continue;
}
/* Else fall thru to the code below */
} else {
/* Normal text */
for (sp = cp; *sp; sp++) {
if (*sp == '{' || *sp == '\n')
break;
}
xo_format_text(xop, cp, sp - cp);
cp = sp;
continue;
}
basep = cp + 1;
/*
* We are looking at the start of a field definition. The format is:
* '{' modifiers ':' content [ '/' print-fmt [ '/' encode-fmt ]] '}'
* Modifiers are optional and include the following field types:
* 'D': decoration; something non-text and non-data (colons, commmas)
* 'E': error message
* 'L': label; text preceding data
* 'N': note; text following data
* 'P': padding; whitespace
* 'T': Title, where 'content' is a column title
* 'U': Units, where 'content' is the unit label
* 'V': value, where 'content' is the name of the field (the default)
* 'W': warning message
* '[': start a section of anchored text
* ']': end a section of anchored text
* The following flags are also supported:
* 'c': flag: emit a colon after the label
* 'd': field is only emitted for display formats (text and html)
* 'e': field is only emitted for encoding formats (xml and json)
* 'k': this field is a key, suitable for XPath predicates
* 'l': a leaf-list, a simple list of values
* 'n': no quotes around this field
* 'q': add quotes around this field
* 't': trim whitespace around the value
* 'w': emit a blank after the label
* The print-fmt and encode-fmt strings is the printf-style formating
* for this data. JSON and XML will use the encoding-fmt, if present.
* If the encode-fmt is not provided, it defaults to the print-fmt.
* If the print-fmt is not provided, it defaults to 's'.
*/
unsigned ftype = 0, flags = 0;
const char *content = NULL, *format = NULL, *encoding = NULL;
int clen = 0, flen = 0, elen = 0;
for (sp = basep; sp; sp++) {
if (*sp == ':' || *sp == '/' || *sp == '}')
break;
if (*sp == '\\') {
if (sp[1] == '\0') {
xo_failure(xop, "backslash at the end of string");
return -1;
}
sp += 1;
continue;
}
switch (*sp) {
case 'D':
case 'E':
case 'L':
case 'N':
case 'P':
case 'T':
case 'U':
case 'V':
case 'W':
case '[':
case ']':
if (ftype != 0) {
xo_failure(xop, "field descriptor uses multiple types: %s",
fmt);
return -1;
}
ftype = *sp;
break;
case 'c':
flags |= XFF_COLON;
break;
case 'd':
flags |= XFF_DISPLAY_ONLY;
break;
case 'e':
flags |= XFF_ENCODE_ONLY;
break;
case 'k':
flags |= XFF_KEY;
break;
case 'l':
flags |= XFF_LEAF_LIST;
break;
case 'n':
flags |= XFF_NOQUOTE;
break;
case 'q':
flags |= XFF_QUOTE;
break;
case 't':
flags |= XFF_TRIM_WS;
break;
case 'w':
flags |= XFF_WS;
break;
default:
xo_failure(xop, "field descriptor uses unknown modifier: %s",
fmt);
/*
* No good answer here; a bad format will likely
* mean a core file. We just return and hope
* the caller notices there's no output, and while
* that seems, well, bad. There's nothing better.
*/
return -1;
}
}
if (*sp == ':') {
for (ep = ++sp; *sp; sp++) {
if (*sp == '}' || *sp == '/')
break;
if (*sp == '\\') {
if (sp[1] == '\0') {
xo_failure(xop, "backslash at the end of string");
return -1;
}
sp += 1;
continue;
}
}
if (ep != sp) {
clen = sp - ep;
content = ep;
}
} else {
xo_failure(xop, "missing content (':'): %s", fmt);
return -1;
}
if (*sp == '/') {
for (ep = ++sp; *sp; sp++) {
if (*sp == '}' || *sp == '/')
break;
if (*sp == '\\') {
if (sp[1] == '\0') {
xo_failure(xop, "backslash at the end of string");
return -1;
}
sp += 1;
continue;
}
}
flen = sp - ep;
format = ep;
}
if (*sp == '/') {
for (ep = ++sp; *sp; sp++) {
if (*sp == '}')
break;
}
elen = sp - ep;
encoding = ep;
}
if (*sp == '}') {
sp += 1;
} else {
xo_failure(xop, "missing closing '}': %s", fmt);
return -1;
}
if (format == NULL && ftype != '[' && ftype != ']' ) {
format = "%s";
flen = 2;
}
if (ftype == 0 || ftype == 'V')
xo_format_value(xop, content, clen, format, flen,
encoding, elen, flags);
else if (ftype == 'D')
xo_format_content(xop, "decoration", NULL, 1,
content, clen, format, flen);
else if (ftype == 'E')
xo_format_content(xop, "error", "error", 0,
content, clen, format, flen);
else if (ftype == 'L')
xo_format_content(xop, "label", NULL, 1,
content, clen, format, flen);
else if (ftype == 'N')
xo_format_content(xop, "note", NULL, 1,
content, clen, format, flen);
else if (ftype == 'P')
xo_format_content(xop, "padding", NULL, 1,
content, clen, format, flen);
else if (ftype == 'T')
xo_format_title(xop, content, clen, format, flen);
else if (ftype == 'U') {
if (flags & XFF_WS)
xo_format_content(xop, "padding", NULL, 1, " ", 1, NULL, 0);
xo_format_units(xop, content, clen, format, flen);
} else if (ftype == 'W')
xo_format_content(xop, "warning", "warning", 0,
content, clen, format, flen);
else if (ftype == '[')
xo_anchor_start(xop, content, clen, format, flen);
else if (ftype == ']')
xo_anchor_stop(xop, content, clen, format, flen);
if (flags & XFF_COLON)
xo_format_content(xop, "decoration", NULL, 1, ":", 1, NULL, 0);
if (ftype != 'U' && (flags & XFF_WS))
xo_format_content(xop, "padding", NULL, 1, " ", 1, NULL, 0);
cp += sp - basep + 1;
if (newp) {
xo_free(newp);
newp = NULL;
}
}
/* If we don't have an anchor, write the text out */
if (flush && !(xop->xo_flags & XOF_ANCHOR))
xo_write(xop);
return (rc < 0) ? rc : (int) xop->xo_columns;
}
int
xo_emit_hv (xo_handle_t *xop, const char *fmt, va_list vap)
{
int rc;
xop = xo_default(xop);
va_copy(xop->xo_vap, vap);
rc = xo_do_emit(xop, fmt);
va_end(xop->xo_vap);
bzero(&xop->xo_vap, sizeof(xop->xo_vap));
return rc;
}
int
xo_emit_h (xo_handle_t *xop, const char *fmt, ...)
{
int rc;
xop = xo_default(xop);
va_start(xop->xo_vap, fmt);
rc = xo_do_emit(xop, fmt);
va_end(xop->xo_vap);
bzero(&xop->xo_vap, sizeof(xop->xo_vap));
return rc;
}
int
xo_emit (const char *fmt, ...)
{
xo_handle_t *xop = xo_default(NULL);
int rc;
va_start(xop->xo_vap, fmt);
rc = xo_do_emit(xop, fmt);
va_end(xop->xo_vap);
bzero(&xop->xo_vap, sizeof(xop->xo_vap));
return rc;
}
int
xo_attr_hv (xo_handle_t *xop, const char *name, const char *fmt, va_list vap)
{
const int extra = 5; /* space, equals, quote, quote, and nul */
xop = xo_default(xop);
if (xop->xo_style != XO_STYLE_XML)
return 0;
int nlen = strlen(name);
xo_buffer_t *xbp = &xop->xo_attrs;
if (!xo_buf_has_room(xbp, nlen + extra))
return -1;
*xbp->xb_curp++ = ' ';
memcpy(xbp->xb_curp, name, nlen);
xbp->xb_curp += nlen;
*xbp->xb_curp++ = '=';
*xbp->xb_curp++ = '"';
int rc = xo_vsnprintf(xop, xbp, fmt, vap);
if (rc > 0) {
rc = xo_escape_xml(xbp, rc, 1);
xbp->xb_curp += rc;
}
if (!xo_buf_has_room(xbp, 2))
return -1;
*xbp->xb_curp++ = '"';
*xbp->xb_curp = '\0';
return rc + nlen + extra;
}
int
xo_attr_h (xo_handle_t *xop, const char *name, const char *fmt, ...)
{
int rc;
va_list vap;
va_start(vap, fmt);
rc = xo_attr_hv(xop, name, fmt, vap);
va_end(vap);
return rc;
}
int
xo_attr (const char *name, const char *fmt, ...)
{
int rc;
va_list vap;
va_start(vap, fmt);
rc = xo_attr_hv(NULL, name, fmt, vap);
va_end(vap);
return rc;
}
static void
xo_stack_set_flags (xo_handle_t *xop)
{
if (xop->xo_flags & XOF_NOT_FIRST) {
xo_stack_t *xsp = &xop->xo_stack[xop->xo_depth];
xsp->xs_flags |= XSF_NOT_FIRST;
xop->xo_flags &= ~XOF_NOT_FIRST;
}
}
static void
xo_depth_change (xo_handle_t *xop, const char *name,
int delta, int indent, xo_xsf_flags_t flags)
{
if (xop->xo_flags & XOF_DTRT)
flags |= XSF_DTRT;
if (delta >= 0) { /* Push operation */
if (xo_depth_check(xop, xop->xo_depth + delta))
return;
xo_stack_t *xsp = &xop->xo_stack[xop->xo_depth + delta];
xsp->xs_flags = flags;
xo_stack_set_flags(xop);
unsigned save = (xop->xo_flags & (XOF_XPATH | XOF_WARN | XOF_DTRT));
save |= (flags & XSF_DTRT);
if (name && save) {
int len = strlen(name) + 1;
char *cp = xo_realloc(NULL, len);
if (cp) {
memcpy(cp, name, len);
xsp->xs_name = cp;
}
}
} else { /* Pop operation */
if (xop->xo_depth == 0) {
if (!(xop->xo_flags & XOF_IGNORE_CLOSE))
xo_failure(xop, "close with empty stack: '%s'", name);
return;
}
xo_stack_t *xsp = &xop->xo_stack[xop->xo_depth];
if (xop->xo_flags & XOF_WARN) {
const char *top = xsp->xs_name;
if (top && strcmp(name, top) != 0) {
xo_failure(xop, "incorrect close: '%s' .vs. '%s'",
name, top);
return;
}
if ((xsp->xs_flags & XSF_LIST) != (flags & XSF_LIST)) {
xo_failure(xop, "list close on list confict: '%s'",
name);
return;
}
if ((xsp->xs_flags & XSF_INSTANCE) != (flags & XSF_INSTANCE)) {
xo_failure(xop, "list close on instance confict: '%s'",
name);
return;
}
}
if (xsp->xs_name) {
xo_free(xsp->xs_name);
xsp->xs_name = NULL;
}
if (xsp->xs_keys) {
xo_free(xsp->xs_keys);
xsp->xs_keys = NULL;
}
}
xop->xo_depth += delta; /* Record new depth */
xop->xo_indent += indent;
}
void
xo_set_depth (xo_handle_t *xop, int depth)
{
xop = xo_default(xop);
if (xo_depth_check(xop, depth))
return;
xop->xo_depth += depth;
xop->xo_indent += depth;
}
static xo_xsf_flags_t
xo_stack_flags (unsigned xflags)
{
if (xflags & XOF_DTRT)
return XSF_DTRT;
return 0;
}
static int
xo_open_container_hf (xo_handle_t *xop, xo_xof_flags_t flags, const char *name)
{
xop = xo_default(xop);
int rc = 0;
const char *ppn = (xop->xo_flags & XOF_PRETTY) ? "\n" : "";
const char *pre_nl = "";
if (name == NULL) {
xo_failure(xop, "NULL passed for container name");
name = XO_FAILURE_NAME;
}
flags |= xop->xo_flags; /* Pick up handle flags */
switch (xop->xo_style) {
case XO_STYLE_XML:
rc = xo_printf(xop, "%*s<%s>%s", xo_indent(xop), "",
name, ppn);
xo_depth_change(xop, name, 1, 1, xo_stack_flags(flags));
break;
case XO_STYLE_JSON:
xo_stack_set_flags(xop);
if (!(xop->xo_flags & XOF_NO_TOP)) {
if (!(xop->xo_flags & XOF_TOP_EMITTED)) {
xo_printf(xop, "%*s{%s", xo_indent(xop), "", ppn);
xop->xo_flags |= XOF_TOP_EMITTED;
}
}
if (xop->xo_stack[xop->xo_depth].xs_flags & XSF_NOT_FIRST)
pre_nl = (xop->xo_flags & XOF_PRETTY) ? ",\n" : ", ";
xop->xo_stack[xop->xo_depth].xs_flags |= XSF_NOT_FIRST;
rc = xo_printf(xop, "%s%*s\"%s\": {%s",
pre_nl, xo_indent(xop), "", name, ppn);
xo_depth_change(xop, name, 1, 1, xo_stack_flags(flags));
break;
case XO_STYLE_HTML:
case XO_STYLE_TEXT:
xo_depth_change(xop, name, 1, 0, xo_stack_flags(flags));
break;
}
return rc;
}
int
xo_open_container_h (xo_handle_t *xop, const char *name)
{
return xo_open_container_hf(xop, 0, name);
}
int
xo_open_container (const char *name)
{
return xo_open_container_hf(NULL, 0, name);
}
int
xo_open_container_hd (xo_handle_t *xop, const char *name)
{
return xo_open_container_hf(xop, XOF_DTRT, name);
}
int
xo_open_container_d (const char *name)
{
return xo_open_container_hf(NULL, XOF_DTRT, name);
}
int
xo_close_container_h (xo_handle_t *xop, const char *name)
{
xop = xo_default(xop);
int rc = 0;
const char *ppn = (xop->xo_flags & XOF_PRETTY) ? "\n" : "";
const char *pre_nl = "";
if (name == NULL) {
xo_stack_t *xsp = &xop->xo_stack[xop->xo_depth];
if (!(xsp->xs_flags & XSF_DTRT))
xo_failure(xop, "missing name without 'dtrt' mode");
name = xsp->xs_name;
if (name) {
int len = strlen(name) + 1;
/* We need to make a local copy; xo_depth_change will free it */
char *cp = alloca(len);
memcpy(cp, name, len);
name = cp;
} else
name = XO_FAILURE_NAME;
}
switch (xop->xo_style) {
case XO_STYLE_XML:
xo_depth_change(xop, name, -1, -1, 0);
rc = xo_printf(xop, "%*s%s", xo_indent(xop), "", name, ppn);
break;
case XO_STYLE_JSON:
pre_nl = (xop->xo_flags & XOF_PRETTY) ? "\n" : "";
ppn = (xop->xo_depth <= 1) ? "\n" : "";
xo_depth_change(xop, name, -1, -1, 0);
rc = xo_printf(xop, "%s%*s}%s", pre_nl, xo_indent(xop), "", ppn);
xop->xo_stack[xop->xo_depth].xs_flags |= XSF_NOT_FIRST;
break;
case XO_STYLE_HTML:
case XO_STYLE_TEXT:
xo_depth_change(xop, name, -1, 0, 0);
break;
}
return rc;
}
int
xo_close_container (const char *name)
{
return xo_close_container_h(NULL, name);
}
int
xo_close_container_hd (xo_handle_t *xop)
{
return xo_close_container_h(xop, NULL);
}
int
xo_close_container_d (void)
{
return xo_close_container_h(NULL, NULL);
}
static int
xo_open_list_hf (xo_handle_t *xop, xo_xsf_flags_t flags, const char *name)
{
xop = xo_default(xop);
if (xop->xo_style != XO_STYLE_JSON)
return 0;
int rc = 0;
const char *ppn = (xop->xo_flags & XOF_PRETTY) ? "\n" : "";
const char *pre_nl = "";
if (!(xop->xo_flags & XOF_NO_TOP)) {
if (!(xop->xo_flags & XOF_TOP_EMITTED)) {
xo_printf(xop, "%*s{%s", xo_indent(xop), "", ppn);
xop->xo_flags |= XOF_TOP_EMITTED;
}
}
if (name == NULL) {
xo_failure(xop, "NULL passed for list name");
name = XO_FAILURE_NAME;
}
xo_stack_set_flags(xop);
if (xop->xo_stack[xop->xo_depth].xs_flags & XSF_NOT_FIRST)
pre_nl = (xop->xo_flags & XOF_PRETTY) ? ",\n" : ", ";
xop->xo_stack[xop->xo_depth].xs_flags |= XSF_NOT_FIRST;
rc = xo_printf(xop, "%s%*s\"%s\": [%s",
pre_nl, xo_indent(xop), "", name, ppn);
xo_depth_change(xop, name, 1, 1, XSF_LIST | xo_stack_flags(flags));
return rc;
}
int
xo_open_list_h (xo_handle_t *xop, const char *name UNUSED)
{
return xo_open_list_hf(xop, 0, name);
}
int
xo_open_list (const char *name)
{
return xo_open_list_hf(NULL, 0, name);
}
int
xo_open_list_hd (xo_handle_t *xop, const char *name UNUSED)
{
return xo_open_list_hf(xop, XOF_DTRT, name);
}
int
xo_open_list_d (const char *name)
{
return xo_open_list_hf(NULL, XOF_DTRT, name);
}
int
xo_close_list_h (xo_handle_t *xop, const char *name)
{
int rc = 0;
const char *pre_nl = "";
xop = xo_default(xop);
if (xop->xo_style != XO_STYLE_JSON)
return 0;
if (name == NULL) {
xo_stack_t *xsp = &xop->xo_stack[xop->xo_depth];
if (!(xsp->xs_flags & XSF_DTRT))
xo_failure(xop, "missing name without 'dtrt' mode");
name = xsp->xs_name;
if (name) {
int len = strlen(name) + 1;
/* We need to make a local copy; xo_depth_change will free it */
char *cp = alloca(len);
memcpy(cp, name, len);
name = cp;
} else
name = XO_FAILURE_NAME;
}
if (xop->xo_stack[xop->xo_depth].xs_flags & XSF_NOT_FIRST)
pre_nl = (xop->xo_flags & XOF_PRETTY) ? "\n" : "";
xop->xo_stack[xop->xo_depth].xs_flags |= XSF_NOT_FIRST;
xo_depth_change(xop, name, -1, -1, XSF_LIST);
rc = xo_printf(xop, "%s%*s]", pre_nl, xo_indent(xop), "");
xop->xo_stack[xop->xo_depth].xs_flags |= XSF_NOT_FIRST;
- return 0;
+ return rc;
}
int
xo_close_list (const char *name)
{
return xo_close_list_h(NULL, name);
}
int
xo_close_list_hd (xo_handle_t *xop)
{
return xo_close_list_h(xop, NULL);
}
int
xo_close_list_d (void)
{
return xo_close_list_h(NULL, NULL);
}
static int
xo_open_instance_hf (xo_handle_t *xop, xo_xsf_flags_t flags, const char *name)
{
xop = xo_default(xop);
int rc = 0;
const char *ppn = (xop->xo_flags & XOF_PRETTY) ? "\n" : "";
const char *pre_nl = "";
flags |= xop->xo_flags;
if (name == NULL) {
xo_failure(xop, "NULL passed for instance name");
name = XO_FAILURE_NAME;
}
switch (xop->xo_style) {
case XO_STYLE_XML:
rc = xo_printf(xop, "%*s<%s>%s", xo_indent(xop), "", name, ppn);
xo_depth_change(xop, name, 1, 1, xo_stack_flags(flags));
break;
case XO_STYLE_JSON:
xo_stack_set_flags(xop);
if (xop->xo_stack[xop->xo_depth].xs_flags & XSF_NOT_FIRST)
pre_nl = (xop->xo_flags & XOF_PRETTY) ? ",\n" : ", ";
xop->xo_stack[xop->xo_depth].xs_flags |= XSF_NOT_FIRST;
rc = xo_printf(xop, "%s%*s{%s",
pre_nl, xo_indent(xop), "", ppn);
xo_depth_change(xop, name, 1, 1, xo_stack_flags(flags));
break;
case XO_STYLE_HTML:
case XO_STYLE_TEXT:
xo_depth_change(xop, name, 1, 0, xo_stack_flags(flags));
break;
}
return rc;
}
int
xo_open_instance_h (xo_handle_t *xop, const char *name)
{
return xo_open_instance_hf(xop, 0, name);
}
int
xo_open_instance (const char *name)
{
return xo_open_instance_hf(NULL, 0, name);
}
int
xo_open_instance_hd (xo_handle_t *xop, const char *name)
{
return xo_open_instance_hf(xop, XOF_DTRT, name);
}
int
xo_open_instance_d (const char *name)
{
return xo_open_instance_hf(NULL, XOF_DTRT, name);
}
int
xo_close_instance_h (xo_handle_t *xop, const char *name)
{
xop = xo_default(xop);
int rc = 0;
const char *ppn = (xop->xo_flags & XOF_PRETTY) ? "\n" : "";
const char *pre_nl = "";
if (name == NULL) {
xo_stack_t *xsp = &xop->xo_stack[xop->xo_depth];
if (!(xsp->xs_flags & XSF_DTRT))
xo_failure(xop, "missing name without 'dtrt' mode");
name = xsp->xs_name;
if (name) {
int len = strlen(name) + 1;
/* We need to make a local copy; xo_depth_change will free it */
char *cp = alloca(len);
memcpy(cp, name, len);
name = cp;
} else
name = XO_FAILURE_NAME;
}
switch (xop->xo_style) {
case XO_STYLE_XML:
xo_depth_change(xop, name, -1, -1, 0);
rc = xo_printf(xop, "%*s%s", xo_indent(xop), "", name, ppn);
break;
case XO_STYLE_JSON:
pre_nl = (xop->xo_flags & XOF_PRETTY) ? "\n" : "";
xo_depth_change(xop, name, -1, -1, 0);
rc = xo_printf(xop, "%s%*s}", pre_nl, xo_indent(xop), "");
xop->xo_stack[xop->xo_depth].xs_flags |= XSF_NOT_FIRST;
break;
case XO_STYLE_HTML:
case XO_STYLE_TEXT:
xo_depth_change(xop, name, -1, 0, 0);
break;
}
return rc;
}
int
xo_close_instance (const char *name)
{
return xo_close_instance_h(NULL, name);
}
int
xo_close_instance_hd (xo_handle_t *xop)
{
return xo_close_instance_h(xop, NULL);
}
int
xo_close_instance_d (void)
{
return xo_close_instance_h(NULL, NULL);
}
void
xo_set_writer (xo_handle_t *xop, void *opaque, xo_write_func_t write_func,
xo_close_func_t close_func)
{
xop = xo_default(xop);
xop->xo_opaque = opaque;
xop->xo_write = write_func;
xop->xo_close = close_func;
}
void
xo_set_allocator (xo_realloc_func_t realloc_func, xo_free_func_t free_func)
{
xo_realloc = realloc_func;
xo_free = free_func;
}
void
xo_flush_h (xo_handle_t *xop)
{
static char div_close[] = "
";
xop = xo_default(xop);
switch (xop->xo_style) {
case XO_STYLE_HTML:
if (xop->xo_flags & XOF_DIV_OPEN) {
xop->xo_flags &= ~XOF_DIV_OPEN;
xo_data_append(xop, div_close, sizeof(div_close) - 1);
if (xop->xo_flags & XOF_PRETTY)
xo_data_append(xop, "\n", 1);
}
break;
}
xo_write(xop);
}
void
xo_flush (void)
{
xo_flush_h(NULL);
}
void
xo_finish_h (xo_handle_t *xop)
{
const char *cp = "";
xop = xo_default(xop);
switch (xop->xo_style) {
case XO_STYLE_JSON:
if (!(xop->xo_flags & XOF_NO_TOP)) {
if (xop->xo_flags & XOF_TOP_EMITTED)
xop->xo_flags &= ~XOF_TOP_EMITTED; /* Turn off before output */
else
cp = "{ ";
xo_printf(xop, "%*s%s}\n",xo_indent(xop), "", cp);
}
break;
}
xo_flush_h(xop);
}
void
xo_finish (void)
{
xo_finish_h(NULL);
}
/*
* Generate an error message, such as would be displayed on stderr
*/
void
xo_error_hv (xo_handle_t *xop, const char *fmt, va_list vap)
{
xop = xo_default(xop);
/*
* If the format string doesn't end with a newline, we pop
* one on ourselves.
*/
int len = strlen(fmt);
if (len > 0 && fmt[len - 1] != '\n') {
char *newfmt = alloca(len + 2);
memcpy(newfmt, fmt, len);
newfmt[len] = '\n';
newfmt[len] = '\0';
fmt = newfmt;
}
switch (xop->xo_style) {
case XO_STYLE_TEXT:
vfprintf(stderr, fmt, vap);
break;
case XO_STYLE_HTML:
va_copy(xop->xo_vap, vap);
xo_buf_append_div(xop, "error", 0, NULL, 0, fmt, strlen(fmt), NULL, 0);
if (xop->xo_flags & XOF_DIV_OPEN)
xo_line_close(xop);
xo_write(xop);
va_end(xop->xo_vap);
bzero(&xop->xo_vap, sizeof(xop->xo_vap));
break;
case XO_STYLE_XML:
va_copy(xop->xo_vap, vap);
xo_open_container_h(xop, "error");
xo_format_value(xop, "message", 7, fmt, strlen(fmt), NULL, 0, 0);
xo_close_container_h(xop, "error");
va_end(xop->xo_vap);
bzero(&xop->xo_vap, sizeof(xop->xo_vap));
break;
}
}
void
xo_error_h (xo_handle_t *xop, const char *fmt, ...)
{
va_list vap;
va_start(vap, fmt);
xo_error_hv(xop, fmt, vap);
va_end(vap);
}
/*
* Generate an error message, such as would be displayed on stderr
*/
void
xo_error (const char *fmt, ...)
{
va_list vap;
va_start(vap, fmt);
xo_error_hv(NULL, fmt, vap);
va_end(vap);
}
int
xo_parse_args (int argc, char **argv)
{
static char libxo_opt[] = "--libxo";
char *cp;
int i, save;
/* Save our program name for xo_err and friends */
xo_program = argv[0];
cp = strrchr(xo_program, '/');
if (cp)
xo_program = cp + 1;
for (save = i = 1; i < argc; i++) {
if (argv[i] == NULL
|| strncmp(argv[i], libxo_opt, sizeof(libxo_opt) - 1) != 0) {
if (save != i)
argv[save] = argv[i];
save += 1;
continue;
}
cp = argv[i] + sizeof(libxo_opt) - 1;
if (*cp == 0) {
cp = argv[++i];
if (cp == 0) {
xo_warnx("missing libxo option");
return -1;
}
if (xo_set_options(NULL, cp) < 0)
return -1;
} else if (*cp == ':') {
if (xo_set_options(NULL, cp) < 0)
return -1;
} else if (*cp == '=') {
if (xo_set_options(NULL, ++cp) < 0)
return -1;
} else if (*cp == '-') {
cp += 1;
if (strcmp(cp, "check") == 0) {
exit(XO_HAS_LIBXO);
} else {
xo_warnx("unknown libxo option: '%s'", argv[i]);
return -1;
}
} else {
xo_warnx("unknown libxo option: '%s'", argv[i]);
return -1;
}
}
argv[save] = NULL;
return save;
}
#ifdef UNIT_TEST
int
main (int argc, char **argv)
{
static char base_grocery[] = "GRO";
static char base_hardware[] = "HRD";
struct item {
const char *i_title;
int i_sold;
int i_instock;
int i_onorder;
const char *i_sku_base;
int i_sku_num;
};
struct item list[] = {
{ "gum&this&that", 1412, 54, 10, base_grocery, 415 },
{ "
", 85, 4, 2, base_hardware, 212 },
{ "ladder", 0, 2, 1, base_hardware, 517 },
{ "\"bolt\"", 4123, 144, 42, base_hardware, 632 },
{ "water\\blue", 17, 14, 2, base_grocery, 2331 },
{ NULL, 0, 0, 0, NULL, 0 }
};
struct item list2[] = {
{ "fish", 1321, 45, 1, base_grocery, 533 },
{ NULL, 0, 0, 0, NULL, 0 }
};
struct item *ip;
xo_info_t info[] = {
{ "in-stock", "number", "Number of items in stock" },
{ "name", "string", "Name of the item" },
{ "on-order", "number", "Number of items on order" },
{ "sku", "string", "Stock Keeping Unit" },
{ "sold", "number", "Number of items sold" },
{ NULL, NULL, NULL },
};
int info_count = (sizeof(info) / sizeof(info[0])) - 1;
argc = xo_parse_args(argc, argv);
if (argc < 0)
exit(1);
xo_set_info(NULL, info, info_count);
xo_open_container_h(NULL, "top");
xo_open_container("data");
xo_open_list("item");
xo_emit("{T:Item/%-15s}{T:Total Sold/%12s}{T:In Stock/%12s}"
"{T:On Order/%12s}{T:SKU/%5s}\n");
for (ip = list; ip->i_title; ip++) {
xo_open_instance("item");
xo_emit("{k:name/%-15s/%s}{n:sold/%12u/%u}{:in-stock/%12u/%u}"
"{:on-order/%12u/%u} {q:sku/%5s-000-%u/%s-000-%u}\n",
ip->i_title, ip->i_sold, ip->i_instock, ip->i_onorder,
ip->i_sku_base, ip->i_sku_num);
xo_close_instance("item");
}
xo_close_list("item");
xo_close_container("data");
xo_emit("\n\n");
xo_open_container("data");
xo_open_list("item");
for (ip = list; ip->i_title; ip++) {
xo_open_instance("item");
xo_attr("fancy", "%s%d", "item", ip - list);
xo_emit("{L:Item} '{k:name/%s}':\n", ip->i_title);
xo_emit("{P: }{L:Total sold}: {n:sold/%u%s}{e:percent/%u}\n",
ip->i_sold, ip->i_sold ? ".0" : "", 44);
xo_emit("{P: }{Lcw:In stock}{:in-stock/%u}\n", ip->i_instock);
xo_emit("{P: }{Lcw:On order}{:on-order/%u}\n", ip->i_onorder);
xo_emit("{P: }{L:SKU}: {q:sku/%s-000-%u}\n",
ip->i_sku_base, ip->i_sku_num);
xo_close_instance("item");
}
xo_close_list("item");
xo_close_container("data");
xo_open_container("data");
xo_open_list("item");
for (ip = list2; ip->i_title; ip++) {
xo_open_instance("item");
xo_emit("{L:Item} '{k:name/%s}':\n", ip->i_title);
xo_emit("{P: }{L:Total sold}: {n:sold/%u%s}\n",
ip->i_sold, ip->i_sold ? ".0" : "");
xo_emit("{P: }{Lcw:In stock}{:in-stock/%u}\n", ip->i_instock);
xo_emit("{P: }{Lcw:On order}{:on-order/%u}\n", ip->i_onorder);
xo_emit("{P: }{L:SKU}: {q:sku/%s-000-%u}\n",
ip->i_sku_base, ip->i_sku_num);
xo_open_list("month");
const char *months[] = { "Jan", "Feb", "Mar", NULL };
int discounts[] = { 10, 20, 25, 0 };
int i;
for (i = 0; months[i]; i++) {
xo_open_instance("month");
xo_emit("{P: }"
"{Lwc:Month}{k:month}, {Lwc:Special}{:discount/%d}\n",
months[i], discounts[i]);
xo_close_instance("month");
}
xo_close_list("month");
xo_close_instance("item");
}
xo_close_list("item");
xo_close_container("data");
xo_close_container_h(NULL, "top");
xo_finish();
return 0;
}
#endif /* UNIT_TEST */
Index: head/contrib/libxo/libxo/xoconfig.h
===================================================================
--- head/contrib/libxo/libxo/xoconfig.h (revision 274404)
+++ head/contrib/libxo/libxo/xoconfig.h (revision 274405)
@@ -1,199 +1,199 @@
/* libxo/xoconfig.h. Generated from xoconfig.h.in by configure. */
/* libxo/xoconfig.h.in. Generated from configure.ac by autoheader. */
/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
systems. This function is required for `alloca.c' support on those systems.
*/
/* #undef CRAY_STACKSEG_END */
/* Define to 1 if using `alloca.c'. */
/* #undef C_ALLOCA */
/* Define to 1 if you have `alloca', as a function or macro. */
#define HAVE_ALLOCA 1
/* Define to 1 if you have and it should be used (not on Ultrix).
*/
/* #undef HAVE_ALLOCA_H */
/* Define to 1 if you have the `asprintf' function. */
#define HAVE_ASPRINTF 1
/* Define to 1 if you have the `bzero' function. */
#define HAVE_BZERO 1
/* Define to 1 if you have the `ctime' function. */
#define HAVE_CTIME 1
/* Define to 1 if you have the header file. */
#define HAVE_CTYPE_H 1
/* Define to 1 if you have the header file. */
#define HAVE_DLFCN_H 1
/* Define to 1 if you have the `dlfunc' function. */
#define HAVE_DLFUNC 1
/* Define to 1 if you have the header file. */
#define HAVE_ERRNO_H 1
/* Define to 1 if you have the `fdopen' function. */
#define HAVE_FDOPEN 1
/* Define to 1 if you have the `flock' function. */
#define HAVE_FLOCK 1
/* Define to 1 if you have the `getpass' function. */
#define HAVE_GETPASS 1
/* Define to 1 if you have the `getrusage' function. */
#define HAVE_GETRUSAGE 1
/* Define to 1 if you have the `gettimeofday' function. */
#define HAVE_GETTIMEOFDAY 1
/* Define to 1 if you have the header file. */
#define HAVE_INTTYPES_H 1
/* Define to 1 if you have the `crypto' library (-lcrypto). */
#define HAVE_LIBCRYPTO 1
/* Define to 1 if you have the `m' library (-lm). */
#define HAVE_LIBM 1
/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
to 0 otherwise. */
#define HAVE_MALLOC 1
/* Define to 1 if you have the `memmove' function. */
#define HAVE_MEMMOVE 1
/* Define to 1 if you have the header file. */
#define HAVE_MEMORY_H 1
/* Support printflike */
/* #undef HAVE_PRINTFLIKE */
/* Define to 1 if your system has a GNU libc compatible `realloc' function,
and to 0 otherwise. */
#define HAVE_REALLOC 1
/* Define to 1 if you have the `srand' function. */
#define HAVE_SRAND 1
/* Define to 1 if you have the `sranddev' function. */
#define HAVE_SRANDDEV 1
/* Define to 1 if you have the header file. */
#define HAVE_STDINT_H 1
/* Define to 1 if you have the header file. */
#define HAVE_STDIO_H 1
/* Define to 1 if you have the header file. */
#define HAVE_STDLIB_H 1
/* Define to 1 if you have the header file. */
/* #undef HAVE_STDTIME_TZFILE_H */
/* Define to 1 if you have the `strchr' function. */
#define HAVE_STRCHR 1
/* Define to 1 if you have the `strcspn' function. */
#define HAVE_STRCSPN 1
/* Define to 1 if you have the `strerror' function. */
#define HAVE_STRERROR 1
/* Define to 1 if you have the header file. */
#define HAVE_STRINGS_H 1
/* Define to 1 if you have the header file. */
#define HAVE_STRING_H 1
/* Define to 1 if you have the `strlcpy' function. */
#define HAVE_STRLCPY 1
/* Define to 1 if you have the `strspn' function. */
#define HAVE_STRSPN 1
/* Define to 1 if you have the `sysctlbyname' function. */
#define HAVE_SYSCTLBYNAME 1
/* Define to 1 if you have the header file. */
#define HAVE_SYS_PARAM_H 1
/* Define to 1 if you have the header file. */
#define HAVE_SYS_STAT_H 1
/* Define to 1 if you have the header file. */
#define HAVE_SYS_SYSCTL_H 1
/* Define to 1 if you have the header file. */
#define HAVE_SYS_TIME_H 1
/* Define to 1 if you have the header file. */
#define HAVE_SYS_TYPES_H 1
/* Define to 1 if you have the header file. */
/* #undef HAVE_TZFILE_H */
/* Define to 1 if you have the header file. */
#define HAVE_UNISTD_H 1
/* Enable debugging */
/* #undef LIBXO_DEBUG */
/* Define to the sub-directory in which libtool stores uninstalled libraries.
*/
#define LT_OBJDIR ".libs/"
/* Name of package */
#define PACKAGE "libxo"
/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT "phil@juniper.net"
/* Define to the full name of this package. */
#define PACKAGE_NAME "libxo"
/* Define to the full name and version of this package. */
-#define PACKAGE_STRING "libxo 0.1.4"
+#define PACKAGE_STRING "libxo 0.1.5"
/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "libxo"
/* Define to the home page for this package. */
#define PACKAGE_URL ""
/* Define to the version of this package. */
-#define PACKAGE_VERSION "0.1.4"
+#define PACKAGE_VERSION "0.1.5"
/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at runtime.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
/* #undef STACK_DIRECTION */
/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Version number of package */
-#define VERSION "0.1.4"
+#define VERSION "0.1.5"
/* Define to `__inline__' or `__inline' if that's what the C compiler
calls it, or to nothing if 'inline' is not supported under any name. */
#ifndef __cplusplus
/* #undef inline */
#endif
/* Define to rpl_malloc if the replacement function should be used. */
/* #undef malloc */
/* Define to rpl_realloc if the replacement function should be used. */
/* #undef realloc */
/* Define to `unsigned int' if does not define. */
/* #undef size_t */
Index: head/contrib/libxo/libxo/xoversion.h
===================================================================
--- head/contrib/libxo/libxo/xoversion.h (revision 274404)
+++ head/contrib/libxo/libxo/xoversion.h (revision 274405)
@@ -1,38 +1,38 @@
/*
* $Id$
*
* Copyright (c) 2014, Juniper Networks, Inc.
* All rights reserved.
* This SOFTWARE is licensed under the LICENSE provided in the
* ../Copyright file. By downloading, installing, copying, or otherwise
* using the SOFTWARE, you agree to be bound by the terms of that
* LICENSE.
*
* xoversion.h -- compile time constants for libxo
* NOTE: This file is generated from xoversion.h.in.
*/
#ifndef LIBXO_XOVERSION_H
#define LIBXO_XOVERSION_H
/**
* The version string
*/
-#define LIBXO_VERSION "0.1.4"
+#define LIBXO_VERSION "0.1.5"
/**
* The version number
*/
#define LIBXO_VERSION_NUMBER 1004
/**
* The version number as a string
*/
#define LIBXO_VERSION_STRING "1004"
/**
* The version number extra info as a string
*/
#define LIBXO_VERSION_EXTRA ""
#endif /* LIBXO_XOVERSION_H */
Index: head/contrib/libxo/tests/core/Makefile.am
===================================================================
--- head/contrib/libxo/tests/core/Makefile.am (revision 274404)
+++ head/contrib/libxo/tests/core/Makefile.am (revision 274405)
@@ -1,107 +1,107 @@
#
# $Id$
#
# Copyright 2014, Juniper Networks, Inc.
# All rights reserved.
# This SOFTWARE is licensed under the LICENSE provided in the
# ../Copyright file. By downloading, installing, copying, or otherwise
# using the SOFTWARE, you agree to be bound by the terms of that
# LICENSE.
AM_CFLAGS = -I${top_srcdir} -I${top_srcdir}/libxo
# Ick: maintained by hand!
TEST_CASES = \
test_01.c \
test_02.c \
test_03.c \
test_04.c \
test_05.c \
test_06.c \
test_07.c
test_01_test_SOURCES = test_01.c
test_02_test_SOURCES = test_02.c
test_03_test_SOURCES = test_03.c
test_04_test_SOURCES = test_04.c
test_05_test_SOURCES = test_05.c
test_06_test_SOURCES = test_06.c
test_07_test_SOURCES = test_07.c
# TEST_CASES := $(shell cd ${srcdir} ; echo *.c )
-bin_PROGRAMS = ${TEST_CASES:.c=.test}
+noinst_PROGRAMS = ${TEST_CASES:.c=.test}
LDADD = \
${top_builddir}/libxo/libxo.la
EXTRA_DIST = \
${TEST_CASES} \
${addprefix saved/, ${TEST_CASES:.c=.T.err}} \
${addprefix saved/, ${TEST_CASES:.c=.T.out}} \
${addprefix saved/, ${TEST_CASES:.c=.XP.err}} \
${addprefix saved/, ${TEST_CASES:.c=.XP.out}} \
${addprefix saved/, ${TEST_CASES:.c=.JP.err}} \
${addprefix saved/, ${TEST_CASES:.c=.JP.out}} \
${addprefix saved/, ${TEST_CASES:.c=.HP.err}} \
${addprefix saved/, ${TEST_CASES:.c=.HP.out}} \
${addprefix saved/, ${TEST_CASES:.c=.X.err}} \
${addprefix saved/, ${TEST_CASES:.c=.X.out}} \
${addprefix saved/, ${TEST_CASES:.c=.J.err}} \
${addprefix saved/, ${TEST_CASES:.c=.J.out}} \
${addprefix saved/, ${TEST_CASES:.c=.H.err}} \
${addprefix saved/, ${TEST_CASES:.c=.H.out}} \
${addprefix saved/, ${TEST_CASES:.c=.HIPx.err}} \
${addprefix saved/, ${TEST_CASES:.c=.HIPx.out}}
S2O = | ${SED} '1,/@@/d'
all:
valgrind:
@echo '## Running the regression tests under Valgrind'
${MAKE} CHECKER='valgrind -q' tests
#TEST_TRACE = set -x ;
TEST_ONE = \
LIBXO_OPTIONS=:W$$fmt \
- ${CHECKER} $$base.test ${TEST_OPTS} \
+ ${CHECKER} ./$$base.test ${TEST_OPTS} \
> out/$$base.$$fmt.out 2> out/$$base.$$fmt.err ; \
${DIFF} -Nu ${srcdir}/saved/$$base.$$fmt.out out/$$base.$$fmt.out ${S2O} ; \
${DIFF} -Nu ${srcdir}/saved/$$base.$$fmt.err out/$$base.$$fmt.err ${S2O}
TEST_FORMATS = T XP JP HP X J H HIPx
test tests: ${bin_PROGRAMS}
@${MKDIR} -p out
-@ ${TEST_TRACE} (for test in ${TEST_CASES} ; do \
base=`${BASENAME} $$test .c` ; \
(for fmt in ${TEST_FORMATS}; do \
echo "... $$test ... $$fmt ..."; \
${TEST_ONE}; \
true; \
done) \
done)
one:
-@(test=${TEST_CASE}; data=${TEST_DATA}; ${TEST_ONE} ; true)
accept:
-@(for test in ${TEST_CASES} ; do \
base=`${BASENAME} $$test .c` ; \
(for fmt in ${TEST_FORMATS}; do \
echo "... $$test ... $$fmt ..."; \
${CP} out/$$base.$$fmt.out ${srcdir}/saved/$$base.$$fmt.out ; \
${CP} out/$$base.$$fmt.err ${srcdir}/saved/$$base.$$fmt.err ; \
done) \
done)
.c.test:
$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -o $@ $<
CLEANFILES = ${TEST_CASES:.c=.test}
CLEANDIRS = out
clean-local:
rm -rf ${CLEANDIRS}
Index: head/contrib/libxo/tests/core/saved/test_07.J.out
===================================================================
--- head/contrib/libxo/tests/core/saved/test_07.J.out (revision 274404)
+++ head/contrib/libxo/tests/core/saved/test_07.J.out (revision 274405)
@@ -1,2 +1,2 @@
-{"employees": {"v1":"γιγνώσκειν","v2":"ὦ ἄνδρες ᾿Αθηναῖοι","columns":28,"columns":2,"v1":"ახლავე გაიაროთ რეგისტრაცია","v2":"Unicode-ის მეათე საერთაშორისო","columns":55, "employee": ["columns":0, {"first-name":"Jim","nic-name":"\"რეგტ\"","last-name":"გთხოვთ ახ","department":431,"percent-time":90,"columns":23,"benefits":"full"}, {"first-name":"Terry","nic-name":"\"γιγνώσκεινὦ ἄνδρες ᾿Αθηναῖοι282ახლავე გაიაროთ რეგისტრაციაUnicode-ის მეათე საერთაშორისო550Jim"რეგტ"გთხოვთ ახ4319023fullTerry"<one"Οὐχὶ ταὐτὰ παρίσταταί μοι Jones6609047fullLeslie"Les"Patterson3416025fullAshley"Ash"Meter & Smith144040300123456789"0123456789"01234567890123456789014404049ახლა"გაიარო"საერთაშორისო1239029full
\ No newline at end of file
+(null)γιγνώσκεινὦ ἄνδρες ᾿Αθηναῖοι282ახლავე გაიაროთ რეგისტრაციაUnicode-ის მეათე საერთაშორისო550Jim"რეგტ"გთხოვთ ახ4319023fullTerry"<one"Οὐχὶ ταὐτὰ παρίσταταί μοι Jones6609047fullLeslie"Les"Patterson3416025fullAshley"Ash"Meter & Smith144040300123456789"0123456789"01234567890123456789014404049ახლა"გაიარო"საერთაშორისო1239029full
\ No newline at end of file
Index: head/contrib/libxo/tests/core/saved/test_07.XP.out
===================================================================
--- head/contrib/libxo/tests/core/saved/test_07.XP.out (revision 274404)
+++ head/contrib/libxo/tests/core/saved/test_07.XP.out (revision 274405)
@@ -1,62 +1,65 @@
+
+ (null)
+
γιγνώσκειν
ὦ ἄνδρες ᾿Αθηναῖοι
28
2
ახლავე გაიაროთ რეგისტრაცია
Unicode-ის მეათე საერთაშორისო
55
0
Jim
"რეგტ"
გთხოვთ ახ
431
90
23
full
Terry
"<one"
Οὐχὶ ταὐτὰ παρίσταταί μοι Jones
660
90
47
full
Leslie
"Les"
Patterson
341
60
25
full
Ashley
"Ash"
Meter & Smith
1440
40
30
0123456789
"0123456789"
012345678901234567890
1440
40
49
ახლა
"გაიარო"
საერთაშორისო
123
90
29
full
Index: head/contrib/libxo/tests/core/test_07.c
===================================================================
--- head/contrib/libxo/tests/core/test_07.c (revision 274404)
+++ head/contrib/libxo/tests/core/test_07.c (revision 274405)
@@ -1,90 +1,96 @@
/*
* Copyright (c) 2014, Juniper Networks, Inc.
* All rights reserved.
* This SOFTWARE is licensed under the LICENSE provided in the
* ../Copyright file. By downloading, installing, copying, or otherwise
* using the SOFTWARE, you agree to be bound by the terms of that
* LICENSE.
* Phil Shafer, July 2014
*/
#include
#include
#include
#include "xo.h"
xo_info_t info[] = {
{ "employee", "object", "Employee data" },
{ "first-name", "string", "First name of employee" },
{ "last-name", "string", "Last name of employee" },
{ "department", "number", "Department number" },
{ "percent-time", "number", "Percentage of full & part time (%)" },
};
int info_count = (sizeof(info) / sizeof(info[0]));
int
main (int argc, char **argv)
{
struct employee {
const char *e_first;
const char *e_nic;
const char *e_last;
unsigned e_dept;
unsigned e_percent;
} employees[] = {
{ "Jim", "რეგტ", "გთხოვთ ახ", 431, 90 },
{ "Terry", "e_first; ep++) {
xo_open_instance("employee");
rc = xo_emit("{[:-25}{:first-name/%s} ({:nic-name/\"%s\"}){]:}"
"{:last-name/%-14..14s/%s}"
"{:department/%8u/%u}{:percent-time/%8u/%u}\n",
ep->e_first, ep->e_nic, ep->e_last, ep->e_dept, ep->e_percent);
xo_emit("{:columns/%d}\n", rc);
if (ep->e_percent > 50) {
xo_attr("full-time", "%s", "honest & for true");
xo_emit("{e:benefits/%s}", "full");
}
xo_close_instance("employee");
}
xo_close_list("employee");
xo_close_container("employees");
xo_finish();
return 0;
}