Annotation of embedaddon/libpdel/tmpl/tmpl_parse.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include "tmpl_internal.h"
! 42: #ifdef __FreeBSD__
! 43: #include <machine/param.h>
! 44: #endif
! 45:
! 46: #ifndef __FreeBSD__
! 47: #define __printflike(x,y)
! 48: #endif
! 49:
! 50: #define isidchar(c) (isalnum(c) || (c) == '_')
! 51:
! 52: /* Parsing */
! 53: static int parse_function(struct tmpl *tmpl, FILE *input,
! 54: struct func_call *call, int special_ok);
! 55: static int parse_argument(struct tmpl *tmpl, FILE *input,
! 56: struct func_arg *arg);
! 57: static int set_text(struct tmpl *tmpl, FILE *input, int nl_white,
! 58: struct tmpl_elem *elem, off_t start, off_t end);
! 59: static int add_elem(struct tmpl *tmpl);
! 60:
! 61: /* Semantic analysis */
! 62: static int scan_elements(struct tmpl *tmpl,
! 63: int start, int in_loop, int *num_errors);
! 64: static int set_error(struct tmpl *tmpl, struct func_call *call,
! 65: const char *fmt, ...) __printflike(3, 4);
! 66:
! 67: /* Memory management */
! 68: static void _tmpl_compact_func(const char *mtype,
! 69: struct func_call *call, char *mem, size_t *bsize);
! 70: static void _tmpl_compact_arg(const char *mtype,
! 71: struct func_arg *arg, char *mem, size_t *bsize);
! 72:
! 73: /* Built-in function handlers */
! 74: static tmpl_handler_t add_func;
! 75: static tmpl_handler_t and_func;
! 76: static tmpl_handler_t atsign_func;
! 77: static tmpl_handler_t cat_func;
! 78: static tmpl_handler_t div_func;
! 79: static tmpl_handler_t equal_func;
! 80: static tmpl_handler_t error_func;
! 81: static tmpl_handler_t eval_func;
! 82: static tmpl_handler_t flush_func;
! 83: static tmpl_handler_t ge_func;
! 84: static tmpl_handler_t get_func;
! 85: static tmpl_handler_t gt_func;
! 86: static tmpl_handler_t htmlencode_func;
! 87: static tmpl_handler_t invoke_func;
! 88: static tmpl_handler_t le_func;
! 89: static tmpl_handler_t loopindex_func;
! 90: static tmpl_handler_t lt_func;
! 91: static tmpl_handler_t mod_func;
! 92: static tmpl_handler_t mul_func;
! 93: static tmpl_handler_t not_func;
! 94: static tmpl_handler_t or_func;
! 95: static tmpl_handler_t output_func;
! 96: static tmpl_handler_t set_func;
! 97: static tmpl_handler_t sub_func;
! 98: static tmpl_handler_t urlencode_func;
! 99:
! 100: #if TMPL_DEBUG
! 101: /* Debugging */
! 102: static char *funcstr(const char *mtype, const struct func_call *call);
! 103: static char *argstr(const char *mtype, const struct func_arg *arg);
! 104: static const char *typestr(const struct tmpl_elem *elem);
! 105: #endif /* TMPL_DEBUG */
! 106:
! 107: /*
! 108: * Built-in functions
! 109: */
! 110: struct builtin_info {
! 111: const char *name;
! 112: enum func_type type;
! 113: tmpl_handler_t *handler;
! 114: int min_args;
! 115: int max_args;
! 116: };
! 117:
! 118: static const char tmpl_function_string[] = { TMPL_FUNCTION_CHARACTER, '\0' };
! 119:
! 120: static const struct builtin_info builtin_funcs[] = {
! 121: { "loop", TY_LOOP, NULL, 1, 1 },
! 122: { "endloop", TY_ENDLOOP, NULL, 0, 0 },
! 123: { "while", TY_WHILE, NULL, 1, 1 },
! 124: { "endwhile", TY_ENDWHILE, NULL, 0, 0 },
! 125: { "if", TY_IF, NULL, 1, 1 },
! 126: { "elif", TY_ELIF, NULL, 1, 1 },
! 127: { "else", TY_ELSE, NULL, 0, 0 },
! 128: { "endif", TY_ENDIF, NULL, 0, 0 },
! 129: { "define", TY_DEFINE, NULL, 1, 1 },
! 130: { "enddef", TY_ENDDEF, NULL, 0, 0 },
! 131: { "continue", TY_CONTINUE, NULL, 0, 0 },
! 132: { "break", TY_BREAK, NULL, 0, 0 },
! 133: { "return", TY_RETURN, NULL, 0, 1 },
! 134: { "equal", TY_NORMAL, equal_func, 2, 2 },
! 135: { "not", TY_NORMAL, not_func, 1, 1 },
! 136: { "and", TY_NORMAL, and_func, 1, INT_MAX },
! 137: { "or", TY_NORMAL, or_func, 1, INT_MAX },
! 138: { "add", TY_NORMAL, add_func, 1, INT_MAX },
! 139: { "sub", TY_NORMAL, sub_func, 1, INT_MAX },
! 140: { "mul", TY_NORMAL, mul_func, 2, INT_MAX },
! 141: { "div", TY_NORMAL, div_func, 2, 2 },
! 142: { "mod", TY_NORMAL, mod_func, 2, 2 },
! 143: { "lt", TY_NORMAL, lt_func, 2, 2 },
! 144: { "gt", TY_NORMAL, gt_func, 2, 2 },
! 145: { "le", TY_NORMAL, le_func, 2, 2 },
! 146: { "ge", TY_NORMAL, ge_func, 2, 2 },
! 147: { "eval", TY_NORMAL, eval_func, 1, 1 },
! 148: { "invoke", TY_NORMAL, invoke_func, 0, 0 },
! 149: { "cat", TY_NORMAL, cat_func, 0, INT_MAX },
! 150: { "error", TY_NORMAL, error_func, 1, 1 },
! 151: { "loopindex", TY_NORMAL, loopindex_func, 0, 1 },
! 152: { "get", TY_NORMAL, get_func, 1, 1 },
! 153: { "set", TY_NORMAL, set_func, 2, 2 },
! 154: { "urlencode", TY_NORMAL, urlencode_func, 1, 1 },
! 155: { "htmlencode", TY_NORMAL, htmlencode_func, 1, 1 },
! 156: { "flush", TY_NORMAL, flush_func, 0, 0 },
! 157: { "output", TY_NORMAL, output_func, 1, 1 },
! 158: { tmpl_function_string,
! 159: TY_NORMAL, atsign_func, 0, 0 },
! 160: { NULL, 0, NULL, 0, 0 }
! 161: };
! 162:
! 163: /************************************************************************
! 164: * PARSING *
! 165: ************************************************************************/
! 166:
! 167: /* Cleanup info */
! 168: struct tmpl_parse_info {
! 169: struct tmpl *tmpl;
! 170: struct func_call call;
! 171: };
! 172:
! 173: /* Internal functions */
! 174: static void tmpl_parse_cleanup(void *arg);
! 175:
! 176: /*
! 177: * Parse an input stream.
! 178: */
! 179: int
! 180: _tmpl_parse(struct tmpl *tmpl, FILE *input, int *num_errors)
! 181: {
! 182: struct tmpl_parse_info info;
! 183: struct tmpl_elem *elem = NULL;
! 184: int nl_white = 0;
! 185: off_t start = 0;
! 186: int rtn = -1;
! 187: size_t bsize;
! 188: off_t pos;
! 189: int ch;
! 190: #if TMPL_DEBUG
! 191: int i;
! 192: #endif
! 193:
! 194: /* Set up cleanup in case of thread cancellation */
! 195: info.tmpl = tmpl;
! 196: memset(&info.call, 0, sizeof(info.call));
! 197: pthread_cleanup_push(tmpl_parse_cleanup, &info);
! 198:
! 199: /* Save starting position */
! 200: if ((pos = ftello(input)) == -1)
! 201: goto fail;
! 202:
! 203: /* Read lines and parse input into elements */
! 204: *num_errors = 0;
! 205: while ((ch = getc(input)) != EOF) {
! 206: off_t end_func;
! 207:
! 208: /* Create a new element if necessary */
! 209: if (elem == NULL) {
! 210: if (add_elem(tmpl) == -1)
! 211: goto fail;
! 212: elem = &tmpl->elems[tmpl->num_elems - 1];
! 213: start = pos;
! 214: nl_white = 1;
! 215: }
! 216:
! 217: /* Look for the initial character of a function invocation */
! 218: if (ch != TMPL_FUNCTION_CHARACTER) {
! 219: if (nl_white && (!isspace(ch)
! 220: || (pos == start && ch != '\n')))
! 221: nl_white = 0;
! 222: pos++; /* more normal text */
! 223: continue;
! 224: }
! 225:
! 226: /* Try to parse a function */
! 227: if (parse_function(tmpl, input, &info.call, 1) == -1) {
! 228: if (errno == EINVAL) {
! 229: (*num_errors)++;
! 230: nl_white = 0;
! 231: pos++;
! 232: continue; /* ignore parse error */
! 233: }
! 234: goto fail;
! 235: }
! 236:
! 237: /* Remember input position just past the end of the function */
! 238: if ((end_func = ftello(input)) == -1) {
! 239: _tmpl_free_call(tmpl->mtype, &info.call);
! 240: goto fail;
! 241: }
! 242:
! 243: /*
! 244: * We parsed a function. Terminate the previous text
! 245: * element (if not empty) and add the function element.
! 246: */
! 247: if (start != pos) {
! 248: if (set_text(tmpl, input,
! 249: nl_white, elem, start, pos) == -1) {
! 250: _tmpl_free_call(tmpl->mtype, &info.call);
! 251: goto fail;
! 252: }
! 253: if (add_elem(tmpl) == -1) {
! 254: _tmpl_free_call(tmpl->mtype, &info.call);
! 255: goto fail;
! 256: }
! 257: elem = &tmpl->elems[tmpl->num_elems - 1];
! 258: nl_white = 1;
! 259: }
! 260: elem->call = info.call;
! 261: memset(&info.call, 0, sizeof(info.call));
! 262:
! 263: /* Reset input position just past the end of the function */
! 264: pos = end_func;
! 265: if (fseeko(input, pos, SEEK_SET) == -1)
! 266: goto fail;
! 267:
! 268: /* Force a new text element to start */
! 269: elem = NULL;
! 270: }
! 271:
! 272: /* Terminate last text element, if any */
! 273: if (elem != NULL
! 274: && set_text(tmpl, input, nl_white, elem, start, pos) == -1)
! 275: goto fail;
! 276:
! 277: #if TMPL_DEBUG
! 278: DBG("Initial parse results: %d elements\n", tmpl->num_elems);
! 279: for (i = 0; i < tmpl->num_elems; i++)
! 280: DBG("%4d: %s\n", i, _tmpl_elemstr(&tmpl->elems[i], i));
! 281: #endif
! 282:
! 283: /* Fill in semantic data */
! 284: if (scan_elements(tmpl, -1, 0, num_errors) == -1)
! 285: goto fail;
! 286:
! 287: #if TMPL_DEBUG
! 288: DBG("After semantic check:\n");
! 289: for (i = 0; i < tmpl->num_elems; i++)
! 290: DBG("%4d: %s\n", i, _tmpl_elemstr(&tmpl->elems[i], i));
! 291: #endif
! 292:
! 293: /* Compress all static information into a single memory block */
! 294: bsize = tmpl->num_elems * sizeof(*tmpl->elems);
! 295: _tmpl_compact_elems(tmpl->mtype,
! 296: tmpl->elems, tmpl->num_elems, NULL, &bsize);
! 297: if ((tmpl->eblock = MALLOC(tmpl->mtype, bsize)) == NULL)
! 298: goto fail;
! 299: bsize = 0;
! 300: _tmpl_compact(tmpl->mtype, tmpl->eblock, &tmpl->elems,
! 301: tmpl->num_elems * sizeof(*tmpl->elems), &bsize);
! 302: _tmpl_compact_elems(tmpl->mtype, tmpl->elems,
! 303: tmpl->num_elems, tmpl->eblock, &bsize);
! 304:
! 305: /* Success */
! 306: rtn = 0;
! 307:
! 308: fail:;
! 309: /* Done */
! 310: pthread_cleanup_pop(0);
! 311: return (rtn);
! 312: }
! 313:
! 314: /*
! 315: * Cleanup for _tmpl_parse()
! 316: */
! 317: static void
! 318: tmpl_parse_cleanup(void *arg)
! 319: {
! 320: struct tmpl_parse_info *const info = arg;
! 321:
! 322: _tmpl_free_call(info->tmpl->mtype, &info->call);
! 323: }
! 324:
! 325: /*
! 326: * Traverse parsed elements and size/move all allocated memory.
! 327: */
! 328: void
! 329: _tmpl_compact_elems(const char *mtype, struct tmpl_elem *elems,
! 330: int num_elems, char *mem, size_t *bsize)
! 331: {
! 332: int i;
! 333:
! 334: for (i = 0; i < num_elems; i++) {
! 335: struct tmpl_elem *const elem = &elems[i];
! 336:
! 337: if (elem->text != NULL) {
! 338: if ((elem->flags & TMPL_ELEM_MMAP_TEXT) == 0) {
! 339: _tmpl_compact(mtype, mem,
! 340: &elem->text, elem->len, bsize);
! 341: }
! 342: } else {
! 343: *bsize = ALIGN(*bsize);
! 344: _tmpl_compact_func(mtype, &elem->call, mem, bsize);
! 345: }
! 346: }
! 347: }
! 348:
! 349: /*
! 350: * Traverse function call and size/move all allocated memory.
! 351: */
! 352: static void
! 353: _tmpl_compact_func(const char *mtype,
! 354: struct func_call *call, char *mem, size_t *bsize)
! 355: {
! 356: int i;
! 357:
! 358: /* Do call function name */
! 359: _tmpl_compact(mtype, mem,
! 360: &call->funcname, strlen(call->funcname) + 1, bsize);
! 361:
! 362: /* Do call arguments array */
! 363: *bsize = ALIGN(*bsize);
! 364: _tmpl_compact(mtype, mem, &call->args,
! 365: call->nargs * sizeof(*call->args), bsize);
! 366:
! 367: /* Do call arguments */
! 368: for (i = 0; i < call->nargs; i++)
! 369: _tmpl_compact_arg(mtype, &call->args[i], mem, bsize);
! 370: }
! 371:
! 372: /*
! 373: * Traverse function call argument and size/move all allocated memory.
! 374: */
! 375: static void
! 376: _tmpl_compact_arg(const char *mtype,
! 377: struct func_arg *arg, char *mem, size_t *bsize)
! 378: {
! 379: if (arg->is_literal) {
! 380: _tmpl_compact(mtype, mem, &arg->u.literal,
! 381: strlen(arg->u.literal) + 1, bsize);
! 382: } else
! 383: _tmpl_compact_func(mtype, &arg->u.call, mem, bsize);
! 384: }
! 385:
! 386: /*
! 387: * Compact a region of memory
! 388: */
! 389: void
! 390: _tmpl_compact(const char *mtype, char *mem,
! 391: void *ptrp, size_t len, size_t *bsize)
! 392: {
! 393: void **const pp = ptrp;
! 394:
! 395: if (mem != NULL) {
! 396: memcpy(mem + *bsize, *pp, len);
! 397: FREE(mtype, *pp);
! 398: *pp = mem + *bsize;
! 399: }
! 400: *bsize += len;
! 401: }
! 402:
! 403: /*
! 404: * Finalize a text parse element.
! 405: */
! 406: static int
! 407: set_text(struct tmpl *tmpl, FILE *input, int nl_white,
! 408: struct tmpl_elem *elem, off_t start, off_t end)
! 409: {
! 410: const u_int len = end - start;
! 411: int ch;
! 412: int i;
! 413:
! 414: assert(elem->flags == 0);
! 415: if (tmpl->mmap_addr != NULL) {
! 416: elem->text = (char *)tmpl->mmap_addr + start;
! 417: elem->flags |= TMPL_ELEM_MMAP_TEXT;
! 418: } else {
! 419: if ((elem->text = MALLOC(tmpl->mtype, len)) == NULL)
! 420: return (-1);
! 421: if (fseeko(input, start, SEEK_SET) == -1)
! 422: return (-1);
! 423: for (i = 0; i < len; i++) {
! 424: if ((ch = getc(input)) == EOF) {
! 425: if (!ferror(input))
! 426: errno = EIO;
! 427: return (-1);
! 428: }
! 429: elem->text[i] = (char)ch;
! 430: }
! 431: }
! 432: if (nl_white)
! 433: elem->flags |= TMPL_ELEM_NL_WHITE;
! 434: elem->len = len;
! 435: return (0);
! 436: }
! 437:
! 438: /*
! 439: * Grow an array of elements by one. Secretly we allocate in
! 440: * chunks of size 'chunk'.
! 441: */
! 442: static int
! 443: add_elem(struct tmpl *tmpl)
! 444: {
! 445: static const int chunk = 128;
! 446: void *new_array;
! 447:
! 448: if (tmpl->num_elems % chunk != 0) {
! 449: tmpl->num_elems++;
! 450: return (0);
! 451: }
! 452: if ((new_array = REALLOC(tmpl->mtype, tmpl->elems,
! 453: (tmpl->num_elems + chunk) * sizeof(*tmpl->elems))) == NULL)
! 454: return (-1);
! 455: tmpl->elems = new_array;
! 456: memset(&tmpl->elems[tmpl->num_elems], 0, chunk * sizeof(*tmpl->elems));
! 457: tmpl->num_elems++;
! 458: return (0);
! 459: }
! 460:
! 461: /*
! 462: * Parse a function call. The input stream is assumed to be pointing
! 463: * just past the '@'. Upon return it will be pointing to the character
! 464: * after the function call if successful, otherwise it will be reset
! 465: * to where it started from.
! 466: *
! 467: * If errno is EINVAL upon return, then there was a parse error.
! 468: */
! 469: static int
! 470: parse_function(struct tmpl *tmpl, FILE *input,
! 471: struct func_call *call, int special_ok)
! 472: {
! 473: const struct builtin_info *builtin;
! 474: off_t start_pos;
! 475: int errno_save;
! 476: int noargs = 0;
! 477: void *mem;
! 478: int len;
! 479: int ch;
! 480:
! 481: /* Save starting position */
! 482: memset(call, 0, sizeof(*call));
! 483: if ((start_pos = ftello(input)) == -1)
! 484: return (-1);
! 485:
! 486: /* Get function name; special case for "@@" */
! 487: if ((ch = getc(input)) == TMPL_FUNCTION_CHARACTER)
! 488: len = 1;
! 489: else {
! 490: for (len = 0; ch != EOF && isidchar(ch); len++)
! 491: ch = getc(input);
! 492: if (len == 0)
! 493: goto parse_err;
! 494: }
! 495:
! 496: /* Re-scan function name into malloc'd buffer */
! 497: if ((call->funcname = MALLOC(tmpl->mtype, len + 1)) == NULL)
! 498: goto parse_err;
! 499: if (fseeko(input, start_pos, SEEK_SET) == -1)
! 500: goto sys_err;
! 501: if (fread(call->funcname, 1, len, input) != len) {
! 502: if (!ferror(input))
! 503: goto parse_err;
! 504: goto sys_err;
! 505: }
! 506: call->funcname[len] = '\0';
! 507:
! 508: /* Check for built-in function; some do not take arguments */
! 509: for (builtin = builtin_funcs; builtin->name != NULL; builtin++) {
! 510: if (strcmp(call->funcname, builtin->name) == 0) {
! 511: if (builtin->min_args == 0)
! 512: noargs = 1;
! 513: break;
! 514: }
! 515: }
! 516: ch = getc(input);
! 517: if (noargs && ch != '(') {
! 518: if (ch != EOF)
! 519: ungetc(ch, input);
! 520: goto got_args;
! 521: }
! 522:
! 523: /* Find opening parenthesis */
! 524: while (isspace(ch))
! 525: ch = getc(input);
! 526: if (ch != '(')
! 527: goto parse_err;
! 528:
! 529: /* Parse function call arguments */
! 530: while (1) {
! 531: ch = getc(input);
! 532: while (isspace(ch)) /* skip white space */
! 533: ch = getc(input);
! 534: if (ch == ')') /* no more arguments */
! 535: break;
! 536: if (call->nargs > 0) {
! 537: if (ch != ',') /* eat comma */
! 538: goto parse_err;
! 539: ch = getc(input);
! 540: while (isspace(ch)) /* skip white space */
! 541: ch = getc(input);
! 542: }
! 543: ungetc(ch, input);
! 544: if ((mem = REALLOC(tmpl->mtype, call->args,
! 545: (call->nargs + 1) * sizeof(*call->args))) == NULL)
! 546: goto sys_err;
! 547: call->args = mem;
! 548: if (parse_argument(tmpl, input, &call->args[call->nargs]) == -1)
! 549: goto sys_err;
! 550: call->nargs++;
! 551: }
! 552:
! 553: got_args:
! 554: /* Set up function call for this function */
! 555: if (builtin->name != NULL) {
! 556: if (call->nargs < builtin->min_args) {
! 557: if (set_error(tmpl, call,
! 558: "at %s %d argument%s %s for \"%c%s\"",
! 559: "least", builtin->min_args,
! 560: builtin->min_args == 1 ? "" : "s",
! 561: "required", TMPL_FUNCTION_CHARACTER,
! 562: builtin->name) == -1)
! 563: goto sys_err;
! 564: return (0);
! 565: }
! 566: if (call->nargs > builtin->max_args) {
! 567: if (set_error(tmpl, call,
! 568: "at %s %d argument%s %s for \"%c%s\"",
! 569: "most", builtin->max_args,
! 570: builtin->max_args == 1 ? "" : "s",
! 571: "allowed", TMPL_FUNCTION_CHARACTER,
! 572: builtin->name) == -1)
! 573: goto sys_err;
! 574: return (0);
! 575: }
! 576: if (!special_ok && builtin->handler == NULL) {
! 577: if (set_error(tmpl, call, "illegal nested \"%c%s\"",
! 578: TMPL_FUNCTION_CHARACTER, builtin->name) == -1)
! 579: goto sys_err;
! 580: return (0);
! 581: }
! 582: call->type = builtin->type;
! 583: call->handler = builtin->handler;
! 584: } else {
! 585: call->type = TY_NORMAL;
! 586: call->handler = NULL;
! 587: }
! 588: return (0);
! 589:
! 590: /* Error */
! 591: parse_err:
! 592: errno = EINVAL;
! 593: sys_err:
! 594: _tmpl_free_call(tmpl->mtype, call);
! 595: errno_save = errno;
! 596: if (fseeko(input, start_pos, SEEK_SET) == -1)
! 597: return (-1);
! 598: errno = errno_save;
! 599: return (-1);
! 600: }
! 601:
! 602: /*
! 603: * Parse a function argument. The input stream is assumed to be pointing
! 604: * at the first non-white space character. Upon return it will be
! 605: * pointing to the character after the argument if successful,
! 606: * otherwise it will be reset to where it started.
! 607: *
! 608: * If errno is EINVAL upon return, then there was a parse error.
! 609: */
! 610: static int
! 611: parse_argument(struct tmpl *tmpl, FILE *input, struct func_arg *arg)
! 612: {
! 613: off_t start_pos;
! 614:
! 615: /* Save starting position */
! 616: memset(arg, 0, sizeof(*arg));
! 617: if ((start_pos = ftello(input)) == -1)
! 618: return (-1);
! 619:
! 620: /* Parse argument */
! 621: switch (getc(input)) {
! 622: case '"':
! 623: arg->is_literal = 1;
! 624: if ((arg->u.literal = string_dequote(input,
! 625: tmpl->mtype)) == NULL)
! 626: return (-1);
! 627: break;
! 628: case TMPL_FUNCTION_CHARACTER:
! 629: arg->is_literal = 0;
! 630: if (parse_function(tmpl, input, &arg->u.call, 0) == -1)
! 631: return (-1);
! 632: break;
! 633: default:
! 634: if (fseeko(input, start_pos, SEEK_SET) != -1)
! 635: errno = EINVAL;
! 636: return (-1);
! 637: }
! 638: return (0);
! 639: }
! 640:
! 641: /************************************************************************
! 642: * SEMANTIC ANALYSIS *
! 643: ************************************************************************/
! 644:
! 645: /*
! 646: * Scan an element list. Returns -1 if error.
! 647: */
! 648: static int
! 649: scan_elements(struct tmpl *tmpl, int start, int in_loop, int *num_errors)
! 650: {
! 651: struct tmpl_elem *const elem = start == -1 ? NULL : &tmpl->elems[start];
! 652: int ret = 0;
! 653: int i;
! 654:
! 655: assert (elem == NULL || elem->call.type != TY_NORMAL);
! 656: for (i = start + 1; i < tmpl->num_elems; i++) {
! 657: struct tmpl_elem *const elem2 = &tmpl->elems[i];
! 658:
! 659: if (elem2->text != NULL)
! 660: continue;
! 661: switch (elem2->call.type) {
! 662: case TY_NORMAL:
! 663: break;
! 664: case TY_LOOP:
! 665: if ((i = scan_elements(tmpl, i, 1, num_errors)) == -1)
! 666: return (-1);
! 667: break;
! 668: case TY_WHILE:
! 669: if ((i = scan_elements(tmpl, i, 1, num_errors)) == -1)
! 670: return (-1);
! 671: break;
! 672: case TY_IF:
! 673: elem2->u.u_if.elsie = -1;
! 674: if ((i = scan_elements(tmpl,
! 675: i, in_loop, num_errors)) == -1)
! 676: return (-1);
! 677: break;
! 678: case TY_DEFINE:
! 679: if ((i = scan_elements(tmpl, i, 0, num_errors)) == -1)
! 680: return (-1);
! 681: break;
! 682: case TY_ENDLOOP:
! 683: if (!elem || elem->call.type != TY_LOOP)
! 684: goto unexpected;
! 685: elem->u.u_loop.endloop = i - start;
! 686: return (i);
! 687: case TY_ENDWHILE:
! 688: if (!elem || elem->call.type != TY_WHILE)
! 689: goto unexpected;
! 690: elem->u.u_while.endwhile = i - start;
! 691: return (i);
! 692: case TY_ELSE:
! 693: case TY_ELIF:
! 694: if (!elem
! 695: || (elem->call.type != TY_IF
! 696: && elem->call.type != TY_ELIF))
! 697: goto unexpected;
! 698: if (elem->u.u_if.elsie != -1)
! 699: goto unexpected;
! 700: elem->u.u_if.elsie = i - start;
! 701: if (elem2->call.type == TY_ELIF) {
! 702: elem2->u.u_if.elsie = -1;
! 703: if ((i = scan_elements(tmpl,
! 704: i, in_loop, num_errors)) == -1)
! 705: return (-1);
! 706: if (tmpl->elems[i].call.type == TY_ENDIF) {
! 707: elem->u.u_if.endif = i - start;
! 708: return (i);
! 709: }
! 710: }
! 711: break;
! 712: case TY_ENDIF:
! 713: if (!elem
! 714: || (elem->call.type != TY_IF
! 715: && elem->call.type != TY_ELIF
! 716: && elem->call.type != TY_ELSE))
! 717: goto unexpected;
! 718: elem->u.u_if.endif = i - start;
! 719: return (i);
! 720: case TY_ENDDEF:
! 721: if (!elem || elem->call.type != TY_DEFINE)
! 722: goto unexpected;
! 723: elem->u.u_define.enddef = i - start;
! 724: return (i);
! 725: case TY_BREAK:
! 726: case TY_CONTINUE:
! 727: if (!in_loop)
! 728: goto unexpected;
! 729: break;
! 730: case TY_RETURN:
! 731: break;
! 732: default:
! 733: assert(0);
! 734: }
! 735: continue;
! 736: unexpected:
! 737: {
! 738: char *fname;
! 739:
! 740: (*num_errors)++;
! 741: if ((fname = STRDUP(tmpl->mtype,
! 742: elem2->call.funcname)) == NULL)
! 743: return (-1);
! 744: if (set_error(tmpl, &elem2->call, "unexpected %c%s",
! 745: TMPL_FUNCTION_CHARACTER, fname) == -1) {
! 746: FREE(tmpl->mtype, fname);
! 747: return (-1);
! 748: }
! 749: FREE(tmpl->mtype, fname);
! 750: }
! 751: }
! 752:
! 753: /* We ran out of elements */
! 754: if (elem == NULL)
! 755: return (0);
! 756: (*num_errors)++;
! 757: switch (elem->call.type) {
! 758: case TY_LOOP:
! 759: ret = set_error(tmpl, &elem->call, "%cloop without %cendloop",
! 760: TMPL_FUNCTION_CHARACTER, TMPL_FUNCTION_CHARACTER);
! 761: break;
! 762: case TY_WHILE:
! 763: ret = set_error(tmpl, &elem->call, "%cwhile without %cendwhile",
! 764: TMPL_FUNCTION_CHARACTER, TMPL_FUNCTION_CHARACTER);
! 765: break;
! 766: case TY_IF:
! 767: case TY_ELSE:
! 768: case TY_ELIF:
! 769: ret = set_error(tmpl, &elem->call, "%cif without %cendif",
! 770: TMPL_FUNCTION_CHARACTER, TMPL_FUNCTION_CHARACTER);
! 771: break;
! 772: case TY_DEFINE:
! 773: ret = set_error(tmpl, &elem->call, "%cdefine without %cenddef",
! 774: TMPL_FUNCTION_CHARACTER, TMPL_FUNCTION_CHARACTER);
! 775: break;
! 776: case TY_NORMAL: /* set_error() already called */
! 777: break;
! 778: default:
! 779: assert(0);
! 780: }
! 781: return (ret);
! 782: }
! 783:
! 784: /************************************************************************
! 785: * ERROR HANDLING *
! 786: ************************************************************************/
! 787:
! 788: /*
! 789: * Set up a function call that prints an error.
! 790: * Replaces the previuous call.
! 791: */
! 792: static int
! 793: set_error(struct tmpl *tmpl, struct func_call *call, const char *fmt, ...)
! 794: {
! 795: char *string;
! 796: va_list args;
! 797: int slen;
! 798:
! 799: _tmpl_free_call(tmpl->mtype, call);
! 800: if ((call->funcname = STRDUP(tmpl->mtype, "error")) == NULL)
! 801: return (-1);
! 802: if ((call->args = MALLOC(tmpl->mtype, sizeof(*call->args))) == NULL) {
! 803: _tmpl_free_call(tmpl->mtype, call);
! 804: return (-1);
! 805: }
! 806: va_start(args, fmt);
! 807: slen = vsnprintf(NULL, 0, fmt, args); /* just get length */
! 808: if ((string = MALLOC(tmpl->mtype, slen + 1)) != NULL)
! 809: vsnprintf(string, slen + 1, fmt, args);
! 810: va_end(args);
! 811: if (string == NULL) {
! 812: _tmpl_free_call(tmpl->mtype, call);
! 813: return (-1);
! 814: }
! 815: call->nargs = 1;
! 816: call->args[0].is_literal = 1;
! 817: call->args[0].u.literal = string;
! 818: call->handler = error_func;
! 819: call->type = TY_NORMAL;
! 820: return (0);
! 821: }
! 822:
! 823: /************************************************************************
! 824: * BUILT-IN FUNCTIONS *
! 825: ************************************************************************/
! 826:
! 827: /*
! 828: * @error()
! 829: */
! 830: static char *
! 831: error_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 832: {
! 833: *errmsgp = STRDUP(ctx->mtype, av[1]);
! 834: return (NULL);
! 835: }
! 836:
! 837: /*
! 838: * @equal()
! 839: */
! 840: static char *
! 841: equal_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 842: {
! 843: return (STRDUP(ctx->mtype, strcmp(av[1], av[2]) == 0 ? "1" : "0"));
! 844: }
! 845:
! 846: /*
! 847: * @not()
! 848: */
! 849: static char *
! 850: not_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 851: {
! 852: return (STRDUP(ctx->mtype, _tmpl_true(av[1]) ? "0" : "1"));
! 853: }
! 854:
! 855: /*
! 856: * @and()
! 857: */
! 858: static char *
! 859: and_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 860: {
! 861: int is_true = 1;
! 862: int i;
! 863:
! 864: for (i = 1; i < ac; i++)
! 865: is_true &= _tmpl_true(av[i]);
! 866: return (STRDUP(ctx->mtype, is_true ? "1" : "0"));
! 867: }
! 868:
! 869: /*
! 870: * @or()
! 871: */
! 872: static char *
! 873: or_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 874: {
! 875: int is_true = 0;
! 876: int i;
! 877:
! 878: for (i = 1; i < ac; i++)
! 879: is_true |= _tmpl_true(av[i]);
! 880: return (STRDUP(ctx->mtype, is_true ? "1" : "0"));
! 881: }
! 882:
! 883: /*
! 884: * @add()
! 885: */
! 886: static char *
! 887: add_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 888: {
! 889: long long sum = 0;
! 890: char buf[32];
! 891: int i;
! 892:
! 893: for (i = 1; i < ac; i++)
! 894: sum += strtoll(av[i], NULL, 0);
! 895: snprintf(buf, sizeof(buf), "%lld", sum);
! 896: return (STRDUP(ctx->mtype, buf));
! 897: }
! 898:
! 899: /*
! 900: * @sub()
! 901: */
! 902: static char *
! 903: sub_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 904: {
! 905: long long result;
! 906: char buf[32];
! 907: int i;
! 908:
! 909: result = strtoll(av[1], NULL, 0);
! 910: for (i = 2; i < ac; i++)
! 911: result -= strtoll(av[i], NULL, 0);
! 912: snprintf(buf, sizeof(buf), "%lld", result);
! 913: return (STRDUP(ctx->mtype, buf));
! 914: }
! 915:
! 916: /*
! 917: * @mul()
! 918: */
! 919: static char *
! 920: mul_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 921: {
! 922: long long product = 1;
! 923: char buf[32];
! 924: int i;
! 925:
! 926: for (i = 1; i < ac; i++)
! 927: product *= strtoll(av[i], NULL, 0);
! 928: snprintf(buf, sizeof(buf), "%lld", product);
! 929: return (STRDUP(ctx->mtype, buf));
! 930: }
! 931:
! 932: /*
! 933: * @div()
! 934: */
! 935: static char *
! 936: div_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 937: {
! 938: long long x, y;
! 939: char buf[32];
! 940:
! 941: x = strtoll(av[1], NULL, 0);
! 942: y = strtoll(av[2], NULL, 0);
! 943: if (y == 0)
! 944: return (STRDUP(ctx->mtype, "divide by zero"));
! 945: snprintf(buf, sizeof(buf), "%lld", x / y);
! 946: return (STRDUP(ctx->mtype, buf));
! 947: }
! 948:
! 949: /*
! 950: * @mod()
! 951: */
! 952: static char *
! 953: mod_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 954: {
! 955: long long x, y;
! 956: char buf[32];
! 957:
! 958: x = strtoll(av[1], NULL, 0);
! 959: y = strtoll(av[2], NULL, 0);
! 960: if (y == 0)
! 961: return (STRDUP(ctx->mtype, "divide by zero"));
! 962: snprintf(buf, sizeof(buf), "%lld", x % y);
! 963: return (STRDUP(ctx->mtype, buf));
! 964: }
! 965:
! 966: /*
! 967: * @lt()
! 968: */
! 969: static char *
! 970: lt_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 971: {
! 972: char buf[32];
! 973:
! 974: snprintf(buf, sizeof(buf), "%d",
! 975: strtoll(av[1], NULL, 0) < strtoll(av[2], NULL, 0));
! 976: return (STRDUP(ctx->mtype, buf));
! 977: }
! 978:
! 979: /*
! 980: * @gt()
! 981: */
! 982: static char *
! 983: gt_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 984: {
! 985: char buf[32];
! 986:
! 987: snprintf(buf, sizeof(buf), "%d",
! 988: strtoll(av[1], NULL, 0) > strtoll(av[2], NULL, 0));
! 989: return (STRDUP(ctx->mtype, buf));
! 990: }
! 991:
! 992: /*
! 993: * @le()
! 994: */
! 995: static char *
! 996: le_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 997: {
! 998: char buf[32];
! 999:
! 1000: snprintf(buf, sizeof(buf), "%d",
! 1001: strtoll(av[1], NULL, 0) <= strtoll(av[2], NULL, 0));
! 1002: return (STRDUP(ctx->mtype, buf));
! 1003: }
! 1004:
! 1005: /*
! 1006: * @ge()
! 1007: */
! 1008: static char *
! 1009: ge_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1010: {
! 1011: char buf[32];
! 1012:
! 1013: snprintf(buf, sizeof(buf), "%d",
! 1014: strtoll(av[1], NULL, 0) >= strtoll(av[2], NULL, 0));
! 1015: return (STRDUP(ctx->mtype, buf));
! 1016: }
! 1017:
! 1018: /*
! 1019: * @eval()
! 1020: */
! 1021: static char *
! 1022: eval_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1023: {
! 1024: FILE *const output_save = ctx->output;
! 1025: struct tmpl *tmpl = NULL;
! 1026: char *rtn = NULL;
! 1027: FILE *input = NULL;
! 1028: int esave;
! 1029:
! 1030: /* Create string output buffer to capture output */
! 1031: if ((ctx->output = string_buf_output(ctx->mtype)) == NULL)
! 1032: goto fail;
! 1033:
! 1034: /* Create new template using string argument as input */
! 1035: if ((input = string_buf_input(av[1], strlen(av[1]), 0)) == NULL)
! 1036: goto fail;
! 1037: if ((tmpl = tmpl_create(input, NULL, ctx->mtype)) == NULL)
! 1038: goto fail;
! 1039:
! 1040: /* Execute parsed template using existing context */
! 1041: _tmpl_execute_elems(ctx, tmpl->elems, 0, tmpl->num_elems);
! 1042:
! 1043: /* Get the resulting output as a string */
! 1044: rtn = string_buf_content(ctx->output, 1);
! 1045:
! 1046: fail:
! 1047: /* Clean up and return */
! 1048: esave = errno;
! 1049: if (input != NULL)
! 1050: fclose(input);
! 1051: tmpl_destroy(&tmpl);
! 1052: if (ctx->output != NULL)
! 1053: fclose(ctx->output);
! 1054: ctx->output = output_save;
! 1055: errno = esave;
! 1056: return (rtn);
! 1057: }
! 1058:
! 1059: /*
! 1060: * @invoke()
! 1061: */
! 1062: static char *
! 1063: invoke_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1064: {
! 1065: struct func_call call;
! 1066: char *rtn;
! 1067: int i;
! 1068:
! 1069: /* Initialize function call structure */
! 1070: memset(&call, 0, sizeof(call));
! 1071: call.type = TY_NORMAL;
! 1072:
! 1073: /* Get argument count */
! 1074: if ((i = _tmpl_find_var(ctx, "argc")) == -1
! 1075: || (call.nargs = strtol(ctx->vars[i].value, NULL, 0)) <= 0) {
! 1076: ASPRINTF(ctx->mtype, errmsgp,
! 1077: "%cinvoke(): \"argc\" must be greater than zero",
! 1078: TMPL_FUNCTION_CHARACTER);
! 1079: return (NULL);
! 1080: }
! 1081: call.nargs--;
! 1082:
! 1083: /* Get function and arguments */
! 1084: if ((call.args = MALLOC(ctx->mtype,
! 1085: call.nargs * sizeof(*call.args))) == NULL)
! 1086: return (NULL);
! 1087: for (i = 0; i <= call.nargs; i++) {
! 1088: const char *value;
! 1089: char name[16];
! 1090: int j;
! 1091:
! 1092: /* Get argN */
! 1093: snprintf(name, sizeof(name), "arg%d", i);
! 1094: value = ((j = _tmpl_find_var(ctx, name)) != -1) ?
! 1095: ctx->vars[j].value : "";
! 1096:
! 1097: /* Set argN */
! 1098: if (i == 0)
! 1099: call.funcname = (char *)value;
! 1100: else {
! 1101: call.args[i - 1].is_literal = 1;
! 1102: call.args[i - 1].u.literal = (char *)value;
! 1103: }
! 1104: }
! 1105:
! 1106: /* Invoke function */
! 1107: rtn = _tmpl_invoke(ctx, errmsgp, &call);
! 1108:
! 1109: /* Done */
! 1110: FREE(ctx->mtype, call.args);
! 1111: return (rtn);
! 1112: }
! 1113:
! 1114: /*
! 1115: * @cat()
! 1116: */
! 1117: static char *
! 1118: cat_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1119: {
! 1120: int len, slen;
! 1121: char *cat;
! 1122: int i;
! 1123:
! 1124: for (len = 0, i = 1; i < ac; i++)
! 1125: len += strlen(av[i]);
! 1126: if ((cat = MALLOC(ctx->mtype, len + 1)) == NULL)
! 1127: return (NULL);
! 1128: for (len = 0, i = 1; i < ac; i++) {
! 1129: slen = strlen(av[i]);
! 1130: memcpy(cat + len, av[i], slen);
! 1131: len += slen;
! 1132: }
! 1133: cat[len] = '\0';
! 1134: return (cat);
! 1135: }
! 1136:
! 1137: /*
! 1138: * @get()
! 1139: */
! 1140: static char *
! 1141: get_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1142: {
! 1143: int i;
! 1144:
! 1145: if ((i = _tmpl_find_var(ctx, av[1])) == -1)
! 1146: return (STRDUP(ctx->mtype, ""));
! 1147: return (STRDUP(ctx->mtype, ctx->vars[i].value));
! 1148: }
! 1149:
! 1150: /*
! 1151: * @set()
! 1152: */
! 1153: static char *
! 1154: set_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1155: {
! 1156: if (tmpl_ctx_set_var(ctx, av[1], av[2]) == -1)
! 1157: return (NULL);
! 1158: return (STRDUP(ctx->mtype, ""));
! 1159: }
! 1160:
! 1161: /*
! 1162: * @urlencode()
! 1163: */
! 1164: static char *
! 1165: urlencode_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1166: {
! 1167: char *s = av[1];
! 1168: char *enc;
! 1169: char *t;
! 1170:
! 1171: if ((enc = MALLOC(ctx->mtype, (strlen(s) * 3) + 1)) == NULL)
! 1172: return (NULL);
! 1173: for (t = enc; *s != '\0'; s++) {
! 1174: if (!isalnum(*s) && strchr("$-_.+!*'(),:@&=~", *s) == NULL)
! 1175: t += sprintf(t, "%%%02x", (u_char)*s);
! 1176: else
! 1177: *t++ = *s;
! 1178: }
! 1179: *t = '\0';
! 1180: return (enc);
! 1181: }
! 1182:
! 1183: /*
! 1184: * @htmlencode()
! 1185: */
! 1186: static char *
! 1187: htmlencode_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1188: {
! 1189: char *s = av[1];
! 1190: char *esc;
! 1191: char *t;
! 1192:
! 1193: if ((esc = MALLOC(ctx->mtype, (strlen(s) * 6) + 1)) == NULL)
! 1194: return (NULL);
! 1195: for (t = esc; *s != '\0'; s++) {
! 1196: switch (*s) {
! 1197: case '<':
! 1198: t += sprintf(t, "<");
! 1199: break;
! 1200: case '>':
! 1201: t += sprintf(t, ">");
! 1202: break;
! 1203: case '"':
! 1204: t += sprintf(t, """);
! 1205: break;
! 1206: case '&':
! 1207: t += sprintf(t, "&");
! 1208: break;
! 1209: default:
! 1210: if ((u_char)*s >= 0x7e)
! 1211: t += sprintf(t, "&#%d;", (u_char)*s);
! 1212: else
! 1213: *t++ = *s;
! 1214: break;
! 1215: }
! 1216: }
! 1217: *t = '\0';
! 1218: return (esc);
! 1219: }
! 1220:
! 1221: /*
! 1222: * @flush()
! 1223: */
! 1224: static char *
! 1225: flush_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1226: {
! 1227: fflush(ctx->output);
! 1228: if (ctx->orig_output != ctx->output)
! 1229: fflush(ctx->orig_output);
! 1230: return (STRDUP(ctx->mtype, ""));
! 1231: }
! 1232:
! 1233: /*
! 1234: * @output()
! 1235: */
! 1236: static char *
! 1237: output_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1238: {
! 1239: fputs(av[1], ctx->orig_output);
! 1240: return (STRDUP(ctx->mtype, ""));
! 1241: }
! 1242:
! 1243: /*
! 1244: * @loopindex()
! 1245: */
! 1246: static char *
! 1247: loopindex_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1248: {
! 1249: struct loop_ctx *loop;
! 1250: long level;
! 1251: char buf[64];
! 1252: char *eptr;
! 1253: int i;
! 1254:
! 1255: if (ac == 1)
! 1256: level = 0;
! 1257: else {
! 1258: level = strtol(av[1], &eptr, 0);
! 1259: if (*av[1] == '\0' || *eptr != '\0'
! 1260: || level < 0 || level == LONG_MAX)
! 1261: return (STRDUP(ctx->mtype, "-1"));
! 1262: }
! 1263: for (i = 0, loop = ctx->loop;
! 1264: i < level && loop != NULL;
! 1265: i++, loop = loop->outer);
! 1266: if (loop == NULL) {
! 1267: snprintf(buf, sizeof(buf), "%c%s called not within any loop",
! 1268: TMPL_FUNCTION_CHARACTER, av[0]);
! 1269: *errmsgp = STRDUP(ctx->mtype, buf);
! 1270: return (NULL);
! 1271: }
! 1272: snprintf(buf, sizeof(buf), "%d", loop->index);
! 1273: return (STRDUP(ctx->mtype, buf));
! 1274: }
! 1275:
! 1276: /*
! 1277: * @@
! 1278: */
! 1279: static char *
! 1280: atsign_func(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1281: {
! 1282: return (STRDUP(ctx->mtype, tmpl_function_string));
! 1283: }
! 1284:
! 1285: /************************************************************************
! 1286: * DEBUGGING *
! 1287: ************************************************************************/
! 1288:
! 1289: #if TMPL_DEBUG
! 1290:
! 1291: #define BUFSIZE 128
! 1292:
! 1293: /*
! 1294: * Return a text version of a template element.
! 1295: */
! 1296: const char *
! 1297: _tmpl_elemstr(const struct tmpl_elem *elem, int index)
! 1298: {
! 1299: static char buf[BUFSIZE];
! 1300: char *s;
! 1301:
! 1302: snprintf(buf, sizeof(buf), "at 0x%04lx-0x%04lx type=%s",
! 1303: (u_long)elem->start, (u_long)elem->start + elem->len,
! 1304: typestr(elem));
! 1305: if (elem->text != NULL) {
! 1306: int i;
! 1307:
! 1308: strlcat(buf, " text=\"", sizeof(buf));
! 1309: for (i = 0; i < elem->len; i++) {
! 1310: switch (elem->text[i]) {
! 1311: case '\n':
! 1312: strlcat(buf, "\\n", sizeof(buf));
! 1313: break;
! 1314: case '\r':
! 1315: strlcat(buf, "\\r", sizeof(buf));
! 1316: break;
! 1317: case '\t':
! 1318: strlcat(buf, "\\t", sizeof(buf));
! 1319: break;
! 1320: default:
! 1321: if (isprint(elem->text[i])) {
! 1322: snprintf(buf + strlen(buf),
! 1323: sizeof(buf) - strlen(buf),
! 1324: "%c", elem->text[i]);
! 1325: } else {
! 1326: snprintf(buf + strlen(buf),
! 1327: sizeof(buf) - strlen(buf),
! 1328: "\\x%02x", (u_char)elem->text[i]);
! 1329: }
! 1330: }
! 1331: }
! 1332: strlcat(buf, "\"", sizeof(buf));
! 1333: return (buf);
! 1334: }
! 1335: s = funcstr(TYPED_MEM_TEMP, &elem->call);
! 1336: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " %s", s);
! 1337: FREE(TYPED_MEM_TEMP, s);
! 1338: switch (elem->call.type) {
! 1339: case TY_LOOP:
! 1340: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
! 1341: " end=%d", index + elem->u.u_loop.endloop);
! 1342: break;
! 1343: case TY_IF:
! 1344: case TY_ELIF:
! 1345: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
! 1346: " else=%d endif=%d",
! 1347: index + elem->u.u_if.elsie, index + elem->u.u_if.endif);
! 1348: break;
! 1349: case TY_WHILE:
! 1350: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
! 1351: " end=%d", index + elem->u.u_while.endwhile);
! 1352: break;
! 1353: case TY_DEFINE:
! 1354: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
! 1355: " end=%d", index + elem->u.u_define.enddef);
! 1356: break;
! 1357: default:
! 1358: break;
! 1359: }
! 1360: return (buf);
! 1361: }
! 1362:
! 1363: /*
! 1364: * Returns a malloc'd string
! 1365: */
! 1366: static char *
! 1367: funcstr(const char *mtype, const struct func_call *call)
! 1368: {
! 1369: char buf[BUFSIZE];
! 1370: char *s;
! 1371: int i;
! 1372:
! 1373: snprintf(buf, sizeof(buf), "%c%s(",
! 1374: TMPL_FUNCTION_CHARACTER, call->funcname);
! 1375: for (i = 0; i < call->nargs; i++) {
! 1376: s = argstr(mtype, &call->args[i]);
! 1377: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
! 1378: "%s%s", s, (i < call->nargs - 1) ? ", " : "");
! 1379: FREE(mtype, s);
! 1380: }
! 1381: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ")");
! 1382: return (STRDUP(mtype, buf));
! 1383: }
! 1384:
! 1385: /*
! 1386: * Returns a malloc'd string
! 1387: */
! 1388: static char *
! 1389: argstr(const char *mtype, const struct func_arg *arg)
! 1390: {
! 1391: char buf[BUFSIZE];
! 1392:
! 1393: if (arg->is_literal) {
! 1394: snprintf(buf, sizeof(buf), "\"%s\"", arg->u.literal);
! 1395: return (STRDUP(mtype, buf));
! 1396: } else
! 1397: return (funcstr(mtype, &arg->u.call));
! 1398: }
! 1399:
! 1400: static const char *
! 1401: typestr(const struct tmpl_elem *elem)
! 1402: {
! 1403: if (elem->text != NULL)
! 1404: return ("TEXT");
! 1405: switch (elem->call.type) {
! 1406: case TY_NORMAL:
! 1407: return (elem->call.handler != NULL ? "BUILTIN" : "USER");
! 1408: case TY_LOOP: return ("LOOP");
! 1409: case TY_ENDLOOP: return ("ENDLOOP");
! 1410: case TY_WHILE: return ("WHILE");
! 1411: case TY_ENDWHILE: return ("ENDWHILE");
! 1412: case TY_IF: return ("IF");
! 1413: case TY_ELSE: return ("ELSE");
! 1414: case TY_ELIF: return ("ELIF");
! 1415: case TY_ENDIF: return ("ENDIF");
! 1416: case TY_DEFINE: return ("DEFINE");
! 1417: case TY_ENDDEF: return ("ENDDEF");
! 1418: case TY_BREAK: return ("BREAK");
! 1419: case TY_CONTINUE: return ("CONTINUE");
! 1420: case TY_RETURN: return ("RETURN");
! 1421: }
! 1422: return ("???");
! 1423: }
! 1424: #endif /* TMPL_DEBUG */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tmpl_parse.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / tmpl