Annotation of embedaddon/ntp/lib/isc/lex.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2004, 2005, 2007 Internet Systems Consortium, Inc. ("ISC")
! 3: * Copyright (C) 1998-2003 Internet Software Consortium.
! 4: *
! 5: * Permission to use, copy, modify, and/or distribute this software for any
! 6: * purpose with or without fee is hereby granted, provided that the above
! 7: * copyright notice and this permission notice appear in all copies.
! 8: *
! 9: * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
! 10: * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
! 11: * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
! 12: * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
! 13: * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
! 14: * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
! 15: * PERFORMANCE OF THIS SOFTWARE.
! 16: */
! 17:
! 18: /* $Id: lex.c,v 1.86 2007/09/17 09:56:29 shane Exp $ */
! 19:
! 20: /*! \file */
! 21:
! 22: #include <config.h>
! 23:
! 24: #include <ctype.h>
! 25: #include <errno.h>
! 26: #include <stdlib.h>
! 27:
! 28: #include <isc/buffer.h>
! 29: #include <isc/file.h>
! 30: #include <isc/lex.h>
! 31: #include <isc/mem.h>
! 32: #include <isc/msgs.h>
! 33: #include <isc/parseint.h>
! 34: #include <isc/print.h>
! 35: #include <isc/stdio.h>
! 36: #include <isc/string.h>
! 37: #include <isc/util.h>
! 38:
! 39: typedef struct inputsource {
! 40: isc_result_t result;
! 41: isc_boolean_t is_file;
! 42: isc_boolean_t need_close;
! 43: isc_boolean_t at_eof;
! 44: isc_buffer_t * pushback;
! 45: unsigned int ignored;
! 46: void * input;
! 47: char * name;
! 48: unsigned long line;
! 49: unsigned long saved_line;
! 50: ISC_LINK(struct inputsource) link;
! 51: } inputsource;
! 52:
! 53: #define LEX_MAGIC ISC_MAGIC('L', 'e', 'x', '!')
! 54: #define VALID_LEX(l) ISC_MAGIC_VALID(l, LEX_MAGIC)
! 55:
! 56: struct isc_lex {
! 57: /* Unlocked. */
! 58: unsigned int magic;
! 59: isc_mem_t * mctx;
! 60: size_t max_token;
! 61: char * data;
! 62: unsigned int comments;
! 63: isc_boolean_t comment_ok;
! 64: isc_boolean_t last_was_eol;
! 65: unsigned int paren_count;
! 66: unsigned int saved_paren_count;
! 67: isc_lexspecials_t specials;
! 68: LIST(struct inputsource) sources;
! 69: };
! 70:
! 71: static inline isc_result_t
! 72: grow_data(isc_lex_t *lex, size_t *remainingp, char **currp, char **prevp) {
! 73: char *new;
! 74:
! 75: new = isc_mem_get(lex->mctx, lex->max_token * 2 + 1);
! 76: if (new == NULL)
! 77: return (ISC_R_NOMEMORY);
! 78: memcpy(new, lex->data, lex->max_token + 1);
! 79: *currp = new + (*currp - lex->data);
! 80: if (*prevp != NULL)
! 81: *prevp = new + (*prevp - lex->data);
! 82: isc_mem_put(lex->mctx, lex->data, lex->max_token + 1);
! 83: lex->data = new;
! 84: *remainingp += lex->max_token;
! 85: lex->max_token *= 2;
! 86: return (ISC_R_SUCCESS);
! 87: }
! 88:
! 89: isc_result_t
! 90: isc_lex_create(isc_mem_t *mctx, size_t max_token, isc_lex_t **lexp) {
! 91: isc_lex_t *lex;
! 92:
! 93: /*
! 94: * Create a lexer.
! 95: */
! 96:
! 97: REQUIRE(lexp != NULL && *lexp == NULL);
! 98: REQUIRE(max_token > 0U);
! 99:
! 100: lex = isc_mem_get(mctx, sizeof(*lex));
! 101: if (lex == NULL)
! 102: return (ISC_R_NOMEMORY);
! 103: lex->data = isc_mem_get(mctx, max_token + 1);
! 104: if (lex->data == NULL) {
! 105: isc_mem_put(mctx, lex, sizeof(*lex));
! 106: return (ISC_R_NOMEMORY);
! 107: }
! 108: lex->mctx = mctx;
! 109: lex->max_token = max_token;
! 110: lex->comments = 0;
! 111: lex->comment_ok = ISC_TRUE;
! 112: lex->last_was_eol = ISC_TRUE;
! 113: lex->paren_count = 0;
! 114: lex->saved_paren_count = 0;
! 115: memset(lex->specials, 0, 256);
! 116: INIT_LIST(lex->sources);
! 117: lex->magic = LEX_MAGIC;
! 118:
! 119: *lexp = lex;
! 120:
! 121: return (ISC_R_SUCCESS);
! 122: }
! 123:
! 124: void
! 125: isc_lex_destroy(isc_lex_t **lexp) {
! 126: isc_lex_t *lex;
! 127:
! 128: /*
! 129: * Destroy the lexer.
! 130: */
! 131:
! 132: REQUIRE(lexp != NULL);
! 133: lex = *lexp;
! 134: REQUIRE(VALID_LEX(lex));
! 135:
! 136: while (!EMPTY(lex->sources))
! 137: RUNTIME_CHECK(isc_lex_close(lex) == ISC_R_SUCCESS);
! 138: if (lex->data != NULL)
! 139: isc_mem_put(lex->mctx, lex->data, lex->max_token + 1);
! 140: lex->magic = 0;
! 141: isc_mem_put(lex->mctx, lex, sizeof(*lex));
! 142:
! 143: *lexp = NULL;
! 144: }
! 145:
! 146: unsigned int
! 147: isc_lex_getcomments(isc_lex_t *lex) {
! 148: /*
! 149: * Return the current lexer commenting styles.
! 150: */
! 151:
! 152: REQUIRE(VALID_LEX(lex));
! 153:
! 154: return (lex->comments);
! 155: }
! 156:
! 157: void
! 158: isc_lex_setcomments(isc_lex_t *lex, unsigned int comments) {
! 159: /*
! 160: * Set allowed lexer commenting styles.
! 161: */
! 162:
! 163: REQUIRE(VALID_LEX(lex));
! 164:
! 165: lex->comments = comments;
! 166: }
! 167:
! 168: void
! 169: isc_lex_getspecials(isc_lex_t *lex, isc_lexspecials_t specials) {
! 170: /*
! 171: * Put the current list of specials into 'specials'.
! 172: */
! 173:
! 174: REQUIRE(VALID_LEX(lex));
! 175:
! 176: memcpy(specials, lex->specials, 256);
! 177: }
! 178:
! 179: void
! 180: isc_lex_setspecials(isc_lex_t *lex, isc_lexspecials_t specials) {
! 181: /*
! 182: * The characters in 'specials' are returned as tokens. Along with
! 183: * whitespace, they delimit strings and numbers.
! 184: */
! 185:
! 186: REQUIRE(VALID_LEX(lex));
! 187:
! 188: memcpy(lex->specials, specials, 256);
! 189: }
! 190:
! 191: static inline isc_result_t
! 192: new_source(isc_lex_t *lex, isc_boolean_t is_file, isc_boolean_t need_close,
! 193: void *input, const char *name)
! 194: {
! 195: inputsource *source;
! 196: isc_result_t result;
! 197:
! 198: source = isc_mem_get(lex->mctx, sizeof(*source));
! 199: if (source == NULL)
! 200: return (ISC_R_NOMEMORY);
! 201: source->result = ISC_R_SUCCESS;
! 202: source->is_file = is_file;
! 203: source->need_close = need_close;
! 204: source->at_eof = ISC_FALSE;
! 205: source->input = input;
! 206: source->name = isc_mem_strdup(lex->mctx, name);
! 207: if (source->name == NULL) {
! 208: isc_mem_put(lex->mctx, source, sizeof(*source));
! 209: return (ISC_R_NOMEMORY);
! 210: }
! 211: source->pushback = NULL;
! 212: result = isc_buffer_allocate(lex->mctx, &source->pushback,
! 213: lex->max_token);
! 214: if (result != ISC_R_SUCCESS) {
! 215: isc_mem_free(lex->mctx, source->name);
! 216: isc_mem_put(lex->mctx, source, sizeof(*source));
! 217: return (result);
! 218: }
! 219: source->ignored = 0;
! 220: source->line = 1;
! 221: ISC_LIST_INITANDPREPEND(lex->sources, source, link);
! 222:
! 223: return (ISC_R_SUCCESS);
! 224: }
! 225:
! 226: isc_result_t
! 227: isc_lex_openfile(isc_lex_t *lex, const char *filename) {
! 228: isc_result_t result;
! 229: FILE *stream = NULL;
! 230:
! 231: /*
! 232: * Open 'filename' and make it the current input source for 'lex'.
! 233: */
! 234:
! 235: REQUIRE(VALID_LEX(lex));
! 236:
! 237: result = isc_stdio_open(filename, "r", &stream);
! 238: if (result != ISC_R_SUCCESS)
! 239: return (result);
! 240:
! 241: result = new_source(lex, ISC_TRUE, ISC_TRUE, stream, filename);
! 242: if (result != ISC_R_SUCCESS)
! 243: (void)fclose(stream);
! 244: return (result);
! 245: }
! 246:
! 247: isc_result_t
! 248: isc_lex_openstream(isc_lex_t *lex, FILE *stream) {
! 249: char name[128];
! 250:
! 251: /*
! 252: * Make 'stream' the current input source for 'lex'.
! 253: */
! 254:
! 255: REQUIRE(VALID_LEX(lex));
! 256:
! 257: snprintf(name, sizeof(name), "stream-%p", stream);
! 258:
! 259: return (new_source(lex, ISC_TRUE, ISC_FALSE, stream, name));
! 260: }
! 261:
! 262: isc_result_t
! 263: isc_lex_openbuffer(isc_lex_t *lex, isc_buffer_t *buffer) {
! 264: char name[128];
! 265:
! 266: /*
! 267: * Make 'buffer' the current input source for 'lex'.
! 268: */
! 269:
! 270: REQUIRE(VALID_LEX(lex));
! 271:
! 272: snprintf(name, sizeof(name), "buffer-%p", buffer);
! 273:
! 274: return (new_source(lex, ISC_FALSE, ISC_FALSE, buffer, name));
! 275: }
! 276:
! 277: isc_result_t
! 278: isc_lex_close(isc_lex_t *lex) {
! 279: inputsource *source;
! 280:
! 281: /*
! 282: * Close the most recently opened object (i.e. file or buffer).
! 283: */
! 284:
! 285: REQUIRE(VALID_LEX(lex));
! 286:
! 287: source = HEAD(lex->sources);
! 288: if (source == NULL)
! 289: return (ISC_R_NOMORE);
! 290:
! 291: ISC_LIST_UNLINK(lex->sources, source, link);
! 292: if (source->is_file) {
! 293: if (source->need_close)
! 294: (void)fclose((FILE *)(source->input));
! 295: }
! 296: isc_mem_free(lex->mctx, source->name);
! 297: isc_buffer_free(&source->pushback);
! 298: isc_mem_put(lex->mctx, source, sizeof(*source));
! 299:
! 300: return (ISC_R_SUCCESS);
! 301: }
! 302:
! 303: typedef enum {
! 304: lexstate_start,
! 305: lexstate_crlf,
! 306: lexstate_string,
! 307: lexstate_number,
! 308: lexstate_maybecomment,
! 309: lexstate_ccomment,
! 310: lexstate_ccommentend,
! 311: lexstate_eatline,
! 312: lexstate_qstring
! 313: } lexstate;
! 314:
! 315: #define IWSEOL (ISC_LEXOPT_INITIALWS | ISC_LEXOPT_EOL)
! 316:
! 317: static void
! 318: pushback(inputsource *source, int c) {
! 319: REQUIRE(source->pushback->current > 0);
! 320: if (c == EOF) {
! 321: source->at_eof = ISC_FALSE;
! 322: return;
! 323: }
! 324: source->pushback->current--;
! 325: if (c == '\n')
! 326: source->line--;
! 327: }
! 328:
! 329: static isc_result_t
! 330: pushandgrow(isc_lex_t *lex, inputsource *source, int c) {
! 331: if (isc_buffer_availablelength(source->pushback) == 0) {
! 332: isc_buffer_t *tbuf = NULL;
! 333: unsigned int oldlen;
! 334: isc_region_t used;
! 335: isc_result_t result;
! 336:
! 337: oldlen = isc_buffer_length(source->pushback);
! 338: result = isc_buffer_allocate(lex->mctx, &tbuf, oldlen * 2);
! 339: if (result != ISC_R_SUCCESS)
! 340: return (result);
! 341: isc_buffer_usedregion(source->pushback, &used);
! 342: result = isc_buffer_copyregion(tbuf, &used);
! 343: INSIST(result == ISC_R_SUCCESS);
! 344: tbuf->current = source->pushback->current;
! 345: isc_buffer_free(&source->pushback);
! 346: source->pushback = tbuf;
! 347: }
! 348: isc_buffer_putuint8(source->pushback, (isc_uint8_t)c);
! 349: return (ISC_R_SUCCESS);
! 350: }
! 351:
! 352: isc_result_t
! 353: isc_lex_gettoken(isc_lex_t *lex, unsigned int options, isc_token_t *tokenp) {
! 354: inputsource *source;
! 355: int c;
! 356: isc_boolean_t done = ISC_FALSE;
! 357: isc_boolean_t no_comments = ISC_FALSE;
! 358: isc_boolean_t escaped = ISC_FALSE;
! 359: lexstate state = lexstate_start;
! 360: lexstate saved_state = lexstate_start;
! 361: isc_buffer_t *buffer;
! 362: FILE *stream;
! 363: char *curr, *prev;
! 364: size_t remaining;
! 365: isc_uint32_t as_ulong;
! 366: unsigned int saved_options;
! 367: isc_result_t result;
! 368:
! 369: /*
! 370: * Get the next token.
! 371: */
! 372:
! 373: REQUIRE(VALID_LEX(lex));
! 374: source = HEAD(lex->sources);
! 375: REQUIRE(tokenp != NULL);
! 376:
! 377: if (source == NULL) {
! 378: if ((options & ISC_LEXOPT_NOMORE) != 0) {
! 379: tokenp->type = isc_tokentype_nomore;
! 380: return (ISC_R_SUCCESS);
! 381: }
! 382: return (ISC_R_NOMORE);
! 383: }
! 384:
! 385: if (source->result != ISC_R_SUCCESS)
! 386: return (source->result);
! 387:
! 388: lex->saved_paren_count = lex->paren_count;
! 389: source->saved_line = source->line;
! 390:
! 391: if (isc_buffer_remaininglength(source->pushback) == 0 &&
! 392: source->at_eof)
! 393: {
! 394: if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 &&
! 395: lex->paren_count != 0) {
! 396: lex->paren_count = 0;
! 397: return (ISC_R_UNBALANCED);
! 398: }
! 399: if ((options & ISC_LEXOPT_EOF) != 0) {
! 400: tokenp->type = isc_tokentype_eof;
! 401: return (ISC_R_SUCCESS);
! 402: }
! 403: return (ISC_R_EOF);
! 404: }
! 405:
! 406: isc_buffer_compact(source->pushback);
! 407:
! 408: saved_options = options;
! 409: if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 && lex->paren_count > 0)
! 410: options &= ~IWSEOL;
! 411:
! 412: curr = lex->data;
! 413: *curr = '\0';
! 414:
! 415: prev = NULL;
! 416: remaining = lex->max_token;
! 417:
! 418: #ifdef HAVE_FLOCKFILE
! 419: if (source->is_file)
! 420: flockfile(source->input);
! 421: #endif
! 422:
! 423: do {
! 424: if (isc_buffer_remaininglength(source->pushback) == 0) {
! 425: if (source->is_file) {
! 426: stream = source->input;
! 427:
! 428: #if defined(HAVE_FLOCKFILE) && defined(HAVE_GETCUNLOCKED)
! 429: c = getc_unlocked(stream);
! 430: #else
! 431: c = getc(stream);
! 432: #endif
! 433: if (c == EOF) {
! 434: if (ferror(stream)) {
! 435: source->result = ISC_R_IOERROR;
! 436: result = source->result;
! 437: goto done;
! 438: }
! 439: source->at_eof = ISC_TRUE;
! 440: }
! 441: } else {
! 442: buffer = source->input;
! 443:
! 444: if (buffer->current == buffer->used) {
! 445: c = EOF;
! 446: source->at_eof = ISC_TRUE;
! 447: } else {
! 448: c = *((char *)buffer->base +
! 449: buffer->current);
! 450: buffer->current++;
! 451: }
! 452: }
! 453: if (c != EOF) {
! 454: source->result = pushandgrow(lex, source, c);
! 455: if (source->result != ISC_R_SUCCESS) {
! 456: result = source->result;
! 457: goto done;
! 458: }
! 459: }
! 460: }
! 461:
! 462: if (!source->at_eof) {
! 463: if (state == lexstate_start)
! 464: /* Token has not started yet. */
! 465: source->ignored =
! 466: isc_buffer_consumedlength(source->pushback);
! 467: c = isc_buffer_getuint8(source->pushback);
! 468: } else {
! 469: c = EOF;
! 470: }
! 471:
! 472: if (c == '\n')
! 473: source->line++;
! 474:
! 475: if (lex->comment_ok && !no_comments) {
! 476: if (!escaped && c == ';' &&
! 477: ((lex->comments & ISC_LEXCOMMENT_DNSMASTERFILE)
! 478: != 0)) {
! 479: saved_state = state;
! 480: state = lexstate_eatline;
! 481: no_comments = ISC_TRUE;
! 482: continue;
! 483: } else if (c == '/' &&
! 484: (lex->comments &
! 485: (ISC_LEXCOMMENT_C|
! 486: ISC_LEXCOMMENT_CPLUSPLUS)) != 0) {
! 487: saved_state = state;
! 488: state = lexstate_maybecomment;
! 489: no_comments = ISC_TRUE;
! 490: continue;
! 491: } else if (c == '#' &&
! 492: ((lex->comments & ISC_LEXCOMMENT_SHELL)
! 493: != 0)) {
! 494: saved_state = state;
! 495: state = lexstate_eatline;
! 496: no_comments = ISC_TRUE;
! 497: continue;
! 498: }
! 499: }
! 500:
! 501: no_read:
! 502: /* INSIST(c == EOF || (c >= 0 && c <= 255)); */
! 503: switch (state) {
! 504: case lexstate_start:
! 505: if (c == EOF) {
! 506: lex->last_was_eol = ISC_FALSE;
! 507: if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 &&
! 508: lex->paren_count != 0) {
! 509: lex->paren_count = 0;
! 510: result = ISC_R_UNBALANCED;
! 511: goto done;
! 512: }
! 513: if ((options & ISC_LEXOPT_EOF) == 0) {
! 514: result = ISC_R_EOF;
! 515: goto done;
! 516: }
! 517: tokenp->type = isc_tokentype_eof;
! 518: done = ISC_TRUE;
! 519: } else if (c == ' ' || c == '\t') {
! 520: if (lex->last_was_eol &&
! 521: (options & ISC_LEXOPT_INITIALWS)
! 522: != 0) {
! 523: lex->last_was_eol = ISC_FALSE;
! 524: tokenp->type = isc_tokentype_initialws;
! 525: tokenp->value.as_char = c;
! 526: done = ISC_TRUE;
! 527: }
! 528: } else if (c == '\n') {
! 529: if ((options & ISC_LEXOPT_EOL) != 0) {
! 530: tokenp->type = isc_tokentype_eol;
! 531: done = ISC_TRUE;
! 532: }
! 533: lex->last_was_eol = ISC_TRUE;
! 534: } else if (c == '\r') {
! 535: if ((options & ISC_LEXOPT_EOL) != 0)
! 536: state = lexstate_crlf;
! 537: } else if (c == '"' &&
! 538: (options & ISC_LEXOPT_QSTRING) != 0) {
! 539: lex->last_was_eol = ISC_FALSE;
! 540: no_comments = ISC_TRUE;
! 541: state = lexstate_qstring;
! 542: } else if (lex->specials[c]) {
! 543: lex->last_was_eol = ISC_FALSE;
! 544: if ((c == '(' || c == ')') &&
! 545: (options & ISC_LEXOPT_DNSMULTILINE) != 0) {
! 546: if (c == '(') {
! 547: if (lex->paren_count == 0)
! 548: options &= ~IWSEOL;
! 549: lex->paren_count++;
! 550: } else {
! 551: if (lex->paren_count == 0) {
! 552: result = ISC_R_UNBALANCED;
! 553: goto done;
! 554: }
! 555: lex->paren_count--;
! 556: if (lex->paren_count == 0)
! 557: options =
! 558: saved_options;
! 559: }
! 560: continue;
! 561: }
! 562: tokenp->type = isc_tokentype_special;
! 563: tokenp->value.as_char = c;
! 564: done = ISC_TRUE;
! 565: } else if (isdigit((unsigned char)c) &&
! 566: (options & ISC_LEXOPT_NUMBER) != 0) {
! 567: lex->last_was_eol = ISC_FALSE;
! 568: if ((options & ISC_LEXOPT_OCTAL) != 0 &&
! 569: (c == '8' || c == '9'))
! 570: state = lexstate_string;
! 571: else
! 572: state = lexstate_number;
! 573: goto no_read;
! 574: } else {
! 575: lex->last_was_eol = ISC_FALSE;
! 576: state = lexstate_string;
! 577: goto no_read;
! 578: }
! 579: break;
! 580: case lexstate_crlf:
! 581: if (c != '\n')
! 582: pushback(source, c);
! 583: tokenp->type = isc_tokentype_eol;
! 584: done = ISC_TRUE;
! 585: lex->last_was_eol = ISC_TRUE;
! 586: break;
! 587: case lexstate_number:
! 588: if (c == EOF || !isdigit((unsigned char)c)) {
! 589: if (c == ' ' || c == '\t' || c == '\r' ||
! 590: c == '\n' || c == EOF ||
! 591: lex->specials[c]) {
! 592: int base;
! 593: if ((options & ISC_LEXOPT_OCTAL) != 0)
! 594: base = 8;
! 595: else if ((options & ISC_LEXOPT_CNUMBER) != 0)
! 596: base = 0;
! 597: else
! 598: base = 10;
! 599: pushback(source, c);
! 600:
! 601: result = isc_parse_uint32(&as_ulong,
! 602: lex->data,
! 603: base);
! 604: if (result == ISC_R_SUCCESS) {
! 605: tokenp->type =
! 606: isc_tokentype_number;
! 607: tokenp->value.as_ulong =
! 608: as_ulong;
! 609: } else if (result == ISC_R_BADNUMBER) {
! 610: isc_tokenvalue_t *v;
! 611:
! 612: tokenp->type =
! 613: isc_tokentype_string;
! 614: v = &(tokenp->value);
! 615: v->as_textregion.base =
! 616: lex->data;
! 617: v->as_textregion.length =
! 618: lex->max_token -
! 619: remaining;
! 620: } else
! 621: goto done;
! 622: done = ISC_TRUE;
! 623: continue;
! 624: } else if (!(options & ISC_LEXOPT_CNUMBER) ||
! 625: ((c != 'x' && c != 'X') ||
! 626: (curr != &lex->data[1]) ||
! 627: (lex->data[0] != '0'))) {
! 628: /* Above test supports hex numbers */
! 629: state = lexstate_string;
! 630: }
! 631: } else if ((options & ISC_LEXOPT_OCTAL) != 0 &&
! 632: (c == '8' || c == '9')) {
! 633: state = lexstate_string;
! 634: }
! 635: if (remaining == 0U) {
! 636: result = grow_data(lex, &remaining,
! 637: &curr, &prev);
! 638: if (result != ISC_R_SUCCESS)
! 639: goto done;
! 640: }
! 641: INSIST(remaining > 0U);
! 642: *curr++ = c;
! 643: *curr = '\0';
! 644: remaining--;
! 645: break;
! 646: case lexstate_string:
! 647: /*
! 648: * EOF needs to be checked before lex->specials[c]
! 649: * as lex->specials[EOF] is not a good idea.
! 650: */
! 651: if (c == '\r' || c == '\n' || c == EOF ||
! 652: (!escaped &&
! 653: (c == ' ' || c == '\t' || lex->specials[c]))) {
! 654: pushback(source, c);
! 655: if (source->result != ISC_R_SUCCESS) {
! 656: result = source->result;
! 657: goto done;
! 658: }
! 659: tokenp->type = isc_tokentype_string;
! 660: tokenp->value.as_textregion.base = lex->data;
! 661: tokenp->value.as_textregion.length =
! 662: lex->max_token - remaining;
! 663: done = ISC_TRUE;
! 664: continue;
! 665: }
! 666: if ((options & ISC_LEXOPT_ESCAPE) != 0)
! 667: escaped = (!escaped && c == '\\') ?
! 668: ISC_TRUE : ISC_FALSE;
! 669: if (remaining == 0U) {
! 670: result = grow_data(lex, &remaining,
! 671: &curr, &prev);
! 672: if (result != ISC_R_SUCCESS)
! 673: goto done;
! 674: }
! 675: INSIST(remaining > 0U);
! 676: *curr++ = c;
! 677: *curr = '\0';
! 678: remaining--;
! 679: break;
! 680: case lexstate_maybecomment:
! 681: if (c == '*' &&
! 682: (lex->comments & ISC_LEXCOMMENT_C) != 0) {
! 683: state = lexstate_ccomment;
! 684: continue;
! 685: } else if (c == '/' &&
! 686: (lex->comments & ISC_LEXCOMMENT_CPLUSPLUS) != 0) {
! 687: state = lexstate_eatline;
! 688: continue;
! 689: }
! 690: pushback(source, c);
! 691: c = '/';
! 692: no_comments = ISC_FALSE;
! 693: state = saved_state;
! 694: goto no_read;
! 695: case lexstate_ccomment:
! 696: if (c == EOF) {
! 697: result = ISC_R_UNEXPECTEDEND;
! 698: goto done;
! 699: }
! 700: if (c == '*')
! 701: state = lexstate_ccommentend;
! 702: break;
! 703: case lexstate_ccommentend:
! 704: if (c == EOF) {
! 705: result = ISC_R_UNEXPECTEDEND;
! 706: goto done;
! 707: }
! 708: if (c == '/') {
! 709: /*
! 710: * C-style comments become a single space.
! 711: * We do this to ensure that a comment will
! 712: * act as a delimiter for strings and
! 713: * numbers.
! 714: */
! 715: c = ' ';
! 716: no_comments = ISC_FALSE;
! 717: state = saved_state;
! 718: goto no_read;
! 719: } else if (c != '*')
! 720: state = lexstate_ccomment;
! 721: break;
! 722: case lexstate_eatline:
! 723: if ((c == '\n') || (c == EOF)) {
! 724: no_comments = ISC_FALSE;
! 725: state = saved_state;
! 726: goto no_read;
! 727: }
! 728: break;
! 729: case lexstate_qstring:
! 730: if (c == EOF) {
! 731: result = ISC_R_UNEXPECTEDEND;
! 732: goto done;
! 733: }
! 734: if (c == '"') {
! 735: if (escaped) {
! 736: escaped = ISC_FALSE;
! 737: /*
! 738: * Overwrite the preceding backslash.
! 739: */
! 740: INSIST(prev != NULL);
! 741: *prev = '"';
! 742: } else {
! 743: tokenp->type = isc_tokentype_qstring;
! 744: tokenp->value.as_textregion.base =
! 745: lex->data;
! 746: tokenp->value.as_textregion.length =
! 747: lex->max_token - remaining;
! 748: no_comments = ISC_FALSE;
! 749: done = ISC_TRUE;
! 750: }
! 751: } else {
! 752: if (c == '\n' && !escaped &&
! 753: (options & ISC_LEXOPT_QSTRINGMULTILINE) == 0) {
! 754: pushback(source, c);
! 755: result = ISC_R_UNBALANCEDQUOTES;
! 756: goto done;
! 757: }
! 758: if (c == '\\' && !escaped)
! 759: escaped = ISC_TRUE;
! 760: else
! 761: escaped = ISC_FALSE;
! 762: if (remaining == 0U) {
! 763: result = grow_data(lex, &remaining,
! 764: &curr, &prev);
! 765: if (result != ISC_R_SUCCESS)
! 766: goto done;
! 767: }
! 768: INSIST(remaining > 0U);
! 769: prev = curr;
! 770: *curr++ = c;
! 771: *curr = '\0';
! 772: remaining--;
! 773: }
! 774: break;
! 775: default:
! 776: FATAL_ERROR(__FILE__, __LINE__,
! 777: isc_msgcat_get(isc_msgcat, ISC_MSGSET_LEX,
! 778: ISC_MSG_UNEXPECTEDSTATE,
! 779: "Unexpected state %d"),
! 780: state);
! 781: /* Does not return. */
! 782: }
! 783:
! 784: } while (!done);
! 785:
! 786: result = ISC_R_SUCCESS;
! 787: done:
! 788: #ifdef HAVE_FLOCKFILE
! 789: if (source->is_file)
! 790: funlockfile(source->input);
! 791: #endif
! 792: return (result);
! 793: }
! 794:
! 795: isc_result_t
! 796: isc_lex_getmastertoken(isc_lex_t *lex, isc_token_t *token,
! 797: isc_tokentype_t expect, isc_boolean_t eol)
! 798: {
! 799: unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF |
! 800: ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE;
! 801: isc_result_t result;
! 802:
! 803: if (expect == isc_tokentype_qstring)
! 804: options |= ISC_LEXOPT_QSTRING;
! 805: else if (expect == isc_tokentype_number)
! 806: options |= ISC_LEXOPT_NUMBER;
! 807: result = isc_lex_gettoken(lex, options, token);
! 808: if (result == ISC_R_RANGE)
! 809: isc_lex_ungettoken(lex, token);
! 810: if (result != ISC_R_SUCCESS)
! 811: return (result);
! 812:
! 813: if (eol && ((token->type == isc_tokentype_eol) ||
! 814: (token->type == isc_tokentype_eof)))
! 815: return (ISC_R_SUCCESS);
! 816: if (token->type == isc_tokentype_string &&
! 817: expect == isc_tokentype_qstring)
! 818: return (ISC_R_SUCCESS);
! 819: if (token->type != expect) {
! 820: isc_lex_ungettoken(lex, token);
! 821: if (token->type == isc_tokentype_eol ||
! 822: token->type == isc_tokentype_eof)
! 823: return (ISC_R_UNEXPECTEDEND);
! 824: if (expect == isc_tokentype_number)
! 825: return (ISC_R_BADNUMBER);
! 826: return (ISC_R_UNEXPECTEDTOKEN);
! 827: }
! 828: return (ISC_R_SUCCESS);
! 829: }
! 830:
! 831: isc_result_t
! 832: isc_lex_getoctaltoken(isc_lex_t *lex, isc_token_t *token, isc_boolean_t eol)
! 833: {
! 834: unsigned int options = ISC_LEXOPT_EOL | ISC_LEXOPT_EOF |
! 835: ISC_LEXOPT_DNSMULTILINE | ISC_LEXOPT_ESCAPE|
! 836: ISC_LEXOPT_NUMBER | ISC_LEXOPT_OCTAL;
! 837: isc_result_t result;
! 838:
! 839: result = isc_lex_gettoken(lex, options, token);
! 840: if (result == ISC_R_RANGE)
! 841: isc_lex_ungettoken(lex, token);
! 842: if (result != ISC_R_SUCCESS)
! 843: return (result);
! 844:
! 845: if (eol && ((token->type == isc_tokentype_eol) ||
! 846: (token->type == isc_tokentype_eof)))
! 847: return (ISC_R_SUCCESS);
! 848: if (token->type != isc_tokentype_number) {
! 849: isc_lex_ungettoken(lex, token);
! 850: if (token->type == isc_tokentype_eol ||
! 851: token->type == isc_tokentype_eof)
! 852: return (ISC_R_UNEXPECTEDEND);
! 853: return (ISC_R_BADNUMBER);
! 854: }
! 855: return (ISC_R_SUCCESS);
! 856: }
! 857:
! 858: void
! 859: isc_lex_ungettoken(isc_lex_t *lex, isc_token_t *tokenp) {
! 860: inputsource *source;
! 861: /*
! 862: * Unget the current token.
! 863: */
! 864:
! 865: REQUIRE(VALID_LEX(lex));
! 866: source = HEAD(lex->sources);
! 867: REQUIRE(source != NULL);
! 868: REQUIRE(tokenp != NULL);
! 869: REQUIRE(isc_buffer_consumedlength(source->pushback) != 0 ||
! 870: tokenp->type == isc_tokentype_eof);
! 871:
! 872: UNUSED(tokenp);
! 873:
! 874: isc_buffer_first(source->pushback);
! 875: lex->paren_count = lex->saved_paren_count;
! 876: source->line = source->saved_line;
! 877: source->at_eof = ISC_FALSE;
! 878: }
! 879:
! 880: void
! 881: isc_lex_getlasttokentext(isc_lex_t *lex, isc_token_t *tokenp, isc_region_t *r)
! 882: {
! 883: inputsource *source;
! 884:
! 885: REQUIRE(VALID_LEX(lex));
! 886: source = HEAD(lex->sources);
! 887: REQUIRE(source != NULL);
! 888: REQUIRE(tokenp != NULL);
! 889: REQUIRE(isc_buffer_consumedlength(source->pushback) != 0 ||
! 890: tokenp->type == isc_tokentype_eof);
! 891:
! 892: UNUSED(tokenp);
! 893:
! 894: INSIST(source->ignored <= isc_buffer_consumedlength(source->pushback));
! 895: r->base = (unsigned char *)isc_buffer_base(source->pushback) +
! 896: source->ignored;
! 897: r->length = isc_buffer_consumedlength(source->pushback) -
! 898: source->ignored;
! 899: }
! 900:
! 901:
! 902: char *
! 903: isc_lex_getsourcename(isc_lex_t *lex) {
! 904: inputsource *source;
! 905:
! 906: REQUIRE(VALID_LEX(lex));
! 907: source = HEAD(lex->sources);
! 908:
! 909: if (source == NULL)
! 910: return (NULL);
! 911:
! 912: return (source->name);
! 913: }
! 914:
! 915: unsigned long
! 916: isc_lex_getsourceline(isc_lex_t *lex) {
! 917: inputsource *source;
! 918:
! 919: REQUIRE(VALID_LEX(lex));
! 920: source = HEAD(lex->sources);
! 921:
! 922: if (source == NULL)
! 923: return (0);
! 924:
! 925: return (source->line);
! 926: }
! 927:
! 928:
! 929: isc_result_t
! 930: isc_lex_setsourcename(isc_lex_t *lex, const char *name) {
! 931: inputsource *source;
! 932: char *newname;
! 933:
! 934: REQUIRE(VALID_LEX(lex));
! 935: source = HEAD(lex->sources);
! 936:
! 937: if (source == NULL)
! 938: return(ISC_R_NOTFOUND);
! 939: newname = isc_mem_strdup(lex->mctx, name);
! 940: if (newname == NULL)
! 941: return (ISC_R_NOMEMORY);
! 942: isc_mem_free(lex->mctx, source->name);
! 943: source->name = newname;
! 944: return (ISC_R_SUCCESS);
! 945: }
! 946:
! 947: isc_boolean_t
! 948: isc_lex_isfile(isc_lex_t *lex) {
! 949: inputsource *source;
! 950:
! 951: REQUIRE(VALID_LEX(lex));
! 952:
! 953: source = HEAD(lex->sources);
! 954:
! 955: if (source == NULL)
! 956: return (ISC_FALSE);
! 957:
! 958: return (source->is_file);
! 959: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lex.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc