contrib/bind-9.5.2/lib/isc/lex.c

   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 }