gscanner.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * GScanner: Flexible lexical scanner for general purpose.
   5  * Copyright (C) 1997, 1998 Tim Janik
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22 #define         __gscanner_c__
  23
  24 #include        <stdlib.h>
  25 #include        <stdarg.h>
  26 #include        <string.h>
  27 #include        <stdio.h>
  28 #include        <unistd.h>
  29 #include        <errno.h>
  30 #include        <sys/types.h>   /* needed for sys/stat.h */
  31 #include        <sys/stat.h>
  32 #include        "glib.h"
  33
  34
  35
  36 /* --- defines --- */
  37 #define to_lower(c)                             ( \
  38         (guchar) (                                                      \
  39           ( (((guchar)(c))>='A' && ((guchar)(c))<='Z') * ('a'-'A') ) |  \
  40           ( (((guchar)(c))>=192 && ((guchar)(c))<=214) * (224-192) ) |  \
  41           ( (((guchar)(c))>=216 && ((guchar)(c))<=222) * (248-216) ) |  \
  42           ((guchar)(c))                                                 \
  43         )                                                               \
  44 )
  45
  46
  47 /* --- typedefs --- */
  48 typedef struct  _GScannerHashVal        GScannerHashVal;
  49
  50 struct  _GScannerHashVal
  51 {
  52   gchar         *key;
  53   gpointer      value;
  54 };
  55
  56
  57
  58 /* --- variables --- */
  59 static  GScannerConfig  g_scanner_config_template =
  60 {
  61   (
  62    " \t\n"
  63    )                    /* cset_skip_characters */,
  64   (
  65    G_CSET_a_2_z
  66    "_"
  67    G_CSET_A_2_Z
  68    )                    /* cset_identifier_first */,
  69   (
  70    G_CSET_a_2_z
  71    "_0123456789"
  72    G_CSET_A_2_Z
  73    G_CSET_LATINS
  74    G_CSET_LATINC
  75    )                    /* cset_identifier_nth */,
  76   ( "#\n" )             /* cpair_comment_single */,
  77
  78   FALSE                 /* case_sensitive */,
  79
  80   TRUE                  /* skip_comment_multi */,
  81   TRUE                  /* skip_comment_single */,
  82   TRUE                  /* scan_comment_multi */,
  83   TRUE                  /* scan_identifier */,
  84   FALSE                 /* scan_identifier_1char */,
  85   FALSE                 /* scan_identifier_NULL */,
  86   TRUE                  /* scan_symbols */,
  87   FALSE                 /* scan_binary */,
  88   TRUE                  /* scan_octal */,
  89   TRUE                  /* scan_float */,
  90   TRUE                  /* scan_hex */,
  91   FALSE                 /* scan_hex_dollar */,
  92   TRUE                  /* scan_string_sq */,
  93   TRUE                  /* scan_string_dq */,
  94   TRUE                  /* numbers_2_int */,
  95   FALSE                 /* int_2_float */,
  96   FALSE                 /* identifier_2_string */,
  97   TRUE                  /* char_2_token */,
  98   FALSE                 /* symbol_2_token */,
  99 };
 100
 101
 102 /* --- prototypes --- */
 103 extern char* g_vsprintf (gchar *fmt, va_list *args, va_list *args2);
 104 static  GScannerHashVal* g_scanner_lookup_internal (GScanner    *scanner,
 105                                                     const gchar *symbol);
 106 static  void    g_scanner_get_token_ll  (GScanner       *scanner,
 107                                          GTokenType     *token_p,
 108                                          GValue         *value_p,
 109                                          guint          *line_p,
 110                                          guint          *position_p);
 111 static  void    g_scanner_get_token_i   (GScanner       *scanner,
 112                                          GTokenType     *token_p,
 113                                          GValue         *value_p,
 114                                          guint          *line_p,
 115                                          guint          *position_p);
 116 static  void    g_scanner_free_value    (GTokenType     *token_p,
 117                                          GValue         *value_p);
 118
 119 static  inline
 120 gint            g_scanner_char_2_num    (guchar         c,
 121                                          guchar         base);
 122 static  guchar  g_scanner_peek_next_char(GScanner       *scanner);
 123 static  guchar  g_scanner_get_char      (GScanner       *scanner,
 124                                          guint          *line_p,
 125                                          guint          *position_p);
 126 static  void    g_scanner_msg_handler   (GScanner       *scanner,
 127                                          gchar          *message,
 128                                          gint            is_error);
 129
 130
 131 /* --- functions --- */
 132 static gint
 133 g_scanner_char_2_num (guchar    c,
 134                       guchar    base)
 135 {
 136   if (c >= '0' && c <= '9')
 137     c -= '0';
 138   else if (c >= 'A' && c <= 'Z')
 139     c -= 'A' - 10;
 140   else if (c >= 'a' && c <= 'z')
 141     c -= 'a' - 10;
 142   else
 143     return -1;
 144
 145   if (c < base)
 146     return c;
 147
 148   return -1;
 149 }
 150
 151 GScanner*
 152 g_scanner_new (GScannerConfig   *config_templ)
 153 {
 154   register GScanner     *scanner;
 155
 156   if (!config_templ)
 157     config_templ = &g_scanner_config_template;
 158
 159   scanner = g_new0 (GScanner, 1);
 160
 161   scanner->user_data = NULL;
 162   scanner->max_parse_errors = 0;
 163   scanner->parse_errors = 0;
 164   scanner->input_name = NULL;
 165   scanner->derived_data = NULL;
 166
 167   scanner->config = g_new0 (GScannerConfig, 1);
 168
 169   scanner->config->case_sensitive       = config_templ->case_sensitive;
 170   scanner->config->cset_skip_characters = config_templ->cset_skip_characters;
 171   scanner->config->cset_identifier_first= config_templ->cset_identifier_first;
 172   scanner->config->cset_identifier_nth  = config_templ->cset_identifier_nth;
 173   scanner->config->cpair_comment_single = config_templ->cpair_comment_single;
 174   scanner->config->skip_comment_multi   = config_templ->skip_comment_multi;
 175   scanner->config->skip_comment_single  = config_templ->skip_comment_single;
 176   scanner->config->scan_comment_multi   = config_templ->scan_comment_multi;
 177   scanner->config->scan_identifier      = config_templ->scan_identifier;
 178   scanner->config->scan_identifier_1char= config_templ->scan_identifier_1char;
 179   scanner->config->scan_identifier_NULL = config_templ->scan_identifier_NULL;
 180   scanner->config->scan_symbols         = config_templ->scan_symbols;
 181   scanner->config->scan_binary          = config_templ->scan_binary;
 182   scanner->config->scan_octal           = config_templ->scan_octal;
 183   scanner->config->scan_float           = config_templ->scan_float;
 184   scanner->config->scan_hex             = config_templ->scan_hex;
 185   scanner->config->scan_hex_dollar      = config_templ->scan_hex_dollar;
 186   scanner->config->scan_string_sq       = config_templ->scan_string_sq;
 187   scanner->config->scan_string_dq       = config_templ->scan_string_dq;
 188   scanner->config->numbers_2_int        = config_templ->numbers_2_int;
 189   scanner->config->int_2_float          = config_templ->int_2_float;
 190   scanner->config->identifier_2_string  = config_templ->identifier_2_string;
 191   scanner->config->char_2_token         = config_templ->char_2_token;
 192   scanner->config->symbol_2_token       = config_templ->symbol_2_token;
 193
 194   scanner->token = G_TOKEN_NONE;
 195   scanner->value.v_int = 0;
 196   scanner->line = 1;
 197   scanner->position = 0;
 198
 199   scanner->next_token = G_TOKEN_NONE;
 200   scanner->next_value.v_int = 0;
 201   scanner->next_line = 1;
 202   scanner->next_position = 0;
 203
 204   scanner->symbol_table = g_hash_table_new (g_str_hash, g_str_equal);
 205   scanner->text = NULL;
 206   scanner->text_len = 0;
 207   scanner->input_fd = -1;
 208   scanner->peeked_char = -1;
 209
 210   scanner->msg_handler = g_scanner_msg_handler;
 211
 212   return scanner;
 213 }
 214
 215 static void
 216 g_scanner_destroy_symbol_table_entry (gpointer key,
 217                                       gpointer value,
 218                                       gpointer user_data)
 219 {
 220   g_free (key);
 221   g_free (value);
 222 }
 223
 224 void
 225 g_scanner_destroy (GScanner     *scanner)
 226 {
 227   g_return_if_fail (scanner != NULL);
 228
 229   g_hash_table_foreach (scanner->symbol_table,
 230                         g_scanner_destroy_symbol_table_entry, NULL);
 231   g_hash_table_destroy (scanner->symbol_table);
 232   g_scanner_free_value (&scanner->token, &scanner->value);
 233   g_scanner_free_value (&scanner->next_token, &scanner->next_value);
 234   g_free (scanner->config);
 235   g_free (scanner);
 236 }
 237
 238 static void
 239 g_scanner_msg_handler (GScanner         *scanner,
 240                        gchar            *message,
 241                        gint              is_error)
 242 {
 243   g_return_if_fail (scanner != NULL);
 244
 245   fprintf (stdout, "%s:%d: ", scanner->input_name, scanner->line);
 246   if (is_error)
 247     fprintf (stdout, "error: ");
 248   fprintf (stdout, "%s\n", message);
 249 }
 250
 251 void
 252 g_scanner_error (GScanner       *scanner,
 253                  const gchar    *format,
 254                  ...)
 255 {
 256   g_return_if_fail (scanner != NULL);
 257   g_return_if_fail (format != NULL);
 258
 259   scanner->parse_errors++;
 260
 261   if (scanner->msg_handler)
 262     {
 263       va_list args, args2;
 264       gchar *string;
 265
 266       va_start (args, format);
 267       va_start (args2, format);
 268       string = g_vsprintf ((gchar*) format, &args, &args2);
 269       va_end (args);
 270       va_end (args2);
 271
 272       string = g_strdup (string);
 273
 274       scanner->msg_handler (scanner, string, TRUE);
 275
 276       g_free (string);
 277     }
 278 }
 279
 280 void
 281 g_scanner_warn (GScanner       *scanner,
 282                 const gchar    *format,
 283                 ...)
 284 {
 285   g_return_if_fail (scanner != NULL);
 286   g_return_if_fail (format != NULL);
 287
 288   if (scanner->msg_handler)
 289     {
 290       va_list args, args2;
 291       gchar *string;
 292
 293       va_start (args, format);
 294       va_start (args2, format);
 295       string = g_vsprintf ((gchar*) format, &args, &args2);
 296       va_end (args);
 297       va_end (args2);
 298
 299       string = g_strdup (string);
 300
 301       scanner->msg_handler (scanner, string, FALSE);
 302
 303       g_free (string);
 304     }
 305 }
 306
 307 void
 308 g_scanner_input_file (GScanner  *scanner,
 309                       gint      input_fd)
 310 {
 311   g_return_if_fail (input_fd >= 0);
 312
 313   scanner->token = G_TOKEN_NONE;
 314   scanner->value.v_int = 0;
 315   scanner->line = 1;
 316   scanner->position = 0;
 317   scanner->next_token = G_TOKEN_NONE;
 318
 319   scanner->text = NULL;
 320   scanner->text_len = 0;
 321   scanner->input_fd = input_fd;
 322   scanner->peeked_char = -1;
 323 }
 324
 325 void
 326 g_scanner_input_text (GScanner       *scanner,
 327                       const  gchar   *text,
 328                       guint           text_len)
 329 {
 330   g_return_if_fail (text != NULL);
 331
 332   scanner->token = G_TOKEN_NONE;
 333   scanner->value.v_int = 0;
 334   scanner->line = 1;
 335   scanner->position = 0;
 336   scanner->next_token = G_TOKEN_NONE;
 337
 338   scanner->text = text;
 339   scanner->text_len = text_len;
 340   scanner->input_fd = -1;
 341   scanner->peeked_char = -1;
 342 }
 343
 344 void
 345 g_scanner_add_symbol (GScanner          *scanner,
 346                       const gchar       *symbol,
 347                       gpointer          value)
 348 {
 349   register GScannerHashVal      *hash_val;
 350
 351   g_return_if_fail (scanner != NULL);
 352   g_return_if_fail (symbol != NULL);
 353
 354   hash_val = g_scanner_lookup_internal (scanner, symbol);
 355
 356   if (!hash_val)
 357     {
 358       hash_val = g_new (GScannerHashVal, 1);
 359       hash_val->key = g_strdup (symbol);
 360       hash_val->value = value;
 361       if (!scanner->config->case_sensitive)
 362         {
 363           register guint        i, l;
 364
 365           l = strlen (hash_val->key);
 366           for (i = 0; i < l; i++)
 367             hash_val->key[i] = to_lower (hash_val->key[i]);
 368         }
 369       g_hash_table_insert (scanner->symbol_table, hash_val->key, hash_val);
 370     }
 371   else
 372     hash_val->value = value;
 373 }
 374
 375 gpointer
 376 g_scanner_lookup_symbol (GScanner       *scanner,
 377                          const gchar    *symbol)
 378 {
 379   register GScannerHashVal      *hash_val;
 380
 381   g_return_val_if_fail (scanner != NULL, NULL);
 382
 383   if (!symbol)
 384     return NULL;
 385
 386   hash_val = g_scanner_lookup_internal (scanner, symbol);
 387
 388   if (hash_val)
 389     return hash_val->value;
 390   else
 391     return NULL;
 392 }
 393
 394 static void
 395 g_scanner_foreach_internal (gpointer  key,
 396                             gpointer  value,
 397                             gpointer  user_data)
 398 {
 399   register GScannerHashVal *hash_val;
 400   register GHFunc func;
 401   register gpointer func_data;
 402   register gpointer *d;
 403
 404   d = user_data;
 405   func = (GHFunc)d[0];
 406   func_data = d[1];
 407   hash_val = value;
 408
 409   func (key, hash_val->value, func_data);
 410 }
 411
 412 void
 413 g_scanner_foreach_symbol (GScanner       *scanner,
 414                           GHFunc          func,
 415                           gpointer        func_data)
 416 {
 417   gpointer d[2];
 418
 419   g_return_if_fail (scanner != NULL);
 420
 421   d[0] = (gpointer)func;
 422   d[1] = func_data;
 423
 424   g_hash_table_foreach (scanner->symbol_table, g_scanner_foreach_internal, d);
 425 }
 426
 427 void
 428 g_scanner_remove_symbol (GScanner       *scanner,
 429                          const gchar    *symbol)
 430 {
 431   register GScannerHashVal      *hash_val;
 432
 433   g_return_if_fail (scanner != NULL);
 434
 435   hash_val = g_scanner_lookup_internal (scanner, symbol);
 436
 437   if (hash_val)
 438     {
 439       g_hash_table_remove (scanner->symbol_table, hash_val->key);
 440       g_free (hash_val->key);
 441       g_free (hash_val);
 442     }
 443 }
 444
 445 void
 446 g_scanner_freeze_symbol_table (GScanner *scanner)
 447 {
 448   g_return_if_fail (scanner != NULL);
 449
 450   g_hash_table_freeze (scanner->symbol_table);
 451 }
 452
 453 void
 454 g_scanner_thaw_symbol_table (GScanner *scanner)
 455 {
 456   g_return_if_fail (scanner != NULL);
 457
 458   g_hash_table_thaw (scanner->symbol_table);
 459 }
 460
 461 GTokenType
 462 g_scanner_peek_next_token (GScanner     *scanner)
 463 {
 464   g_return_val_if_fail (scanner != NULL, G_TOKEN_EOF);
 465
 466   if (scanner->next_token == G_TOKEN_NONE)
 467     {
 468       scanner->next_line = scanner->line;
 469       scanner->next_position = scanner->position;
 470       g_scanner_get_token_i (scanner,
 471                              &scanner->next_token,
 472                              &scanner->next_value,
 473                              &scanner->next_line,
 474                              &scanner->next_position);
 475     }
 476
 477   return scanner->next_token;
 478 }
 479
 480 GTokenType
 481 g_scanner_get_next_token (GScanner      *scanner)
 482 {
 483   g_return_val_if_fail (scanner != NULL, G_TOKEN_EOF);
 484
 485   if (scanner->next_token != G_TOKEN_NONE)
 486     {
 487       g_scanner_free_value (&scanner->token, &scanner->value);
 488
 489       scanner->token = scanner->next_token;
 490       scanner->value = scanner->next_value;
 491       scanner->line = scanner->next_line;
 492       scanner->position = scanner->next_position;
 493       scanner->next_token = G_TOKEN_NONE;
 494     }
 495   else
 496     g_scanner_get_token_i (scanner,
 497                            &scanner->token,
 498                            &scanner->value,
 499                            &scanner->line,
 500                            &scanner->position);
 501
 502   return scanner->token;
 503 }
 504
 505 GTokenType
 506 g_scanner_cur_token (GScanner *scanner)
 507 {
 508   g_return_val_if_fail (scanner != NULL, G_TOKEN_EOF);
 509
 510   return scanner->token;
 511 }
 512
 513 GValue
 514 g_scanner_cur_value (GScanner *scanner)
 515 {
 516   register GValue v;
 517
 518   v.v_int = 0;
 519   g_return_val_if_fail (scanner != NULL, v);
 520
 521   return scanner->value;
 522 }
 523
 524 guint
 525 g_scanner_cur_line (GScanner *scanner)
 526 {
 527   g_return_val_if_fail (scanner != NULL, 0);
 528
 529   return scanner->line;
 530 }
 531
 532 guint
 533 g_scanner_cur_position (GScanner *scanner)
 534 {
 535   g_return_val_if_fail (scanner != NULL, 0);
 536
 537   return scanner->position;
 538 }
 539
 540 gboolean
 541 g_scanner_eof (GScanner *scanner)
 542 {
 543   g_return_val_if_fail (scanner != NULL, TRUE);
 544
 545   return scanner->token == G_TOKEN_EOF;
 546 }
 547
 548 static GScannerHashVal*
 549 g_scanner_lookup_internal (GScanner     *scanner,
 550                            const gchar  *symbol)
 551 {
 552   register GScannerHashVal      *hash_val;
 553
 554   if (!scanner->config->case_sensitive)
 555     {
 556       register gchar *buffer;
 557       register guint i, l;
 558
 559       l = strlen (symbol);
 560       buffer = g_new (gchar, l + 1);
 561       for (i = 0; i < l; i++)
 562         buffer[i] = to_lower (symbol[i]);
 563       buffer[i] = 0;
 564       hash_val = g_hash_table_lookup (scanner->symbol_table, buffer);
 565       g_free (buffer);
 566     }
 567   else
 568     hash_val = g_hash_table_lookup (scanner->symbol_table, (gchar*) symbol);
 569
 570   return hash_val;
 571 }
 572
 573 static guchar
 574 g_scanner_peek_next_char (GScanner *scanner)
 575 {
 576   guchar fchar;
 577
 578   if (scanner->text_len)
 579     {
 580       fchar = scanner->text[0];
 581     }
 582   else if (scanner->input_fd >= 0)
 583     {
 584       if (scanner->peeked_char < 0)
 585         {
 586           register gint count;
 587
 588           do
 589             {
 590               count = read (scanner->input_fd, &fchar, 1);
 591             }
 592           while (count == -1 &&
 593                  (errno == EINTR ||
 594                   errno == EAGAIN));
 595
 596           if (count != 1)
 597             fchar = 0;
 598
 599           scanner->peeked_char = fchar;
 600         }
 601       else
 602         fchar = scanner->peeked_char;
 603     }
 604   else
 605     fchar = 0;
 606
 607   return fchar;
 608 }
 609
 610 static guchar
 611 g_scanner_get_char (GScanner    *scanner,
 612                     guint       *line_p,
 613                     guint       *position_p)
 614 {
 615   guchar fchar;
 616
 617   if (scanner->text_len)
 618     {
 619       fchar = *(scanner->text++);
 620       scanner->text_len--;
 621     }
 622   else if (scanner->input_fd >= 0)
 623     {
 624       if (scanner->peeked_char < 0)
 625         {
 626           register gint count;
 627
 628           do
 629             {
 630               count = read (scanner->input_fd, &fchar, 1);
 631             }
 632           while (count == -1 &&
 633                  (errno == EINTR ||
 634                   errno == EAGAIN));
 635           if (count != 1 || fchar == 0)
 636             {
 637               fchar = 0;
 638               scanner->peeked_char = 0;
 639             }
 640         }
 641       else
 642         {
 643           fchar = scanner->peeked_char;
 644           if (fchar)
 645             scanner->peeked_char = -1;
 646         }
 647     }
 648   else
 649     fchar = 0;
 650
 651   if (fchar == '\n')
 652     {
 653       (*position_p) = 0;
 654       (*line_p)++;
 655     }
 656   else if (fchar)
 657     {
 658       (*position_p)++;
 659     }
 660
 661   return fchar;
 662 }
 663
 664 void
 665 g_scanner_unexp_token (GScanner         *scanner,
 666                        GTokenType        expected_token,
 667                        const gchar      *identifier_spec,
 668                        const gchar      *symbol_spec,
 669                        const gchar      *symbol_name,
 670                        const gchar      *message,
 671                        gint              is_error)
 672 {
 673   register gchar        *token_string;
 674   register guint        token_string_len;
 675   register gchar        *expected_string;
 676   register guint        expected_string_len;
 677   register gchar        *message_prefix;
 678   register gboolean     print_unexp;
 679   void (*msg_handler)   (GScanner*, const gchar*, ...);
 680
 681   g_return_if_fail (scanner != NULL);
 682
 683   if (is_error)
 684     msg_handler = g_scanner_error;
 685   else
 686     msg_handler = g_scanner_warn;
 687
 688   if (!identifier_spec)
 689     identifier_spec = "identifier";
 690   if (!symbol_spec)
 691     symbol_spec = "symbol";
 692
 693   token_string_len = 56;
 694   token_string = g_new (gchar, token_string_len + 1);
 695   expected_string_len = 64;
 696   expected_string = g_new (gchar, expected_string_len + 1);
 697   print_unexp = TRUE;
 698
 699   switch (scanner->token)
 700     {
 701
 702     case  G_TOKEN_EOF:
 703       g_snprintf (token_string, token_string_len, "end of file");
 704       break;
 705
 706     default:  /* 1 ... 255 */
 707       if (scanner->token >= 1 && scanner->token <= 255)
 708         {
 709           if ((scanner->token >= ' ' && scanner->token <= '~') ||
 710               strchr (scanner->config->cset_identifier_first, scanner->token) ||
 711               strchr (scanner->config->cset_identifier_nth, scanner->token))
 712             g_snprintf (token_string, expected_string_len, "character `%c'", scanner->token);
 713           else
 714             g_snprintf (token_string, expected_string_len, "character `\\%o'", scanner->token);
 715         }
 716       else
 717         g_snprintf (token_string, token_string_len, "(unknown) token <%d>", scanner->token);
 718       break;
 719
 720     case  G_TOKEN_ERROR:
 721       print_unexp = FALSE;
 722       expected_token = G_TOKEN_NONE;
 723       switch (scanner->value.v_error)
 724         {
 725         case  G_ERR_UNEXP_EOF:
 726           g_snprintf (token_string, token_string_len, "scanner: unexpected end of file");
 727           break;
 728
 729         case  G_ERR_UNEXP_EOF_IN_STRING:
 730           g_snprintf (token_string, token_string_len, "scanner: unterminated string constant");
 731           break;
 732
 733         case  G_ERR_UNEXP_EOF_IN_COMMENT:
 734           g_snprintf (token_string, token_string_len, "scanner: unterminated comment");
 735           break;
 736
 737         case  G_ERR_NON_DIGIT_IN_CONST:
 738           g_snprintf (token_string, token_string_len, "scanner: non digit in constant");
 739           break;
 740
 741         case  G_ERR_FLOAT_RADIX:
 742           g_snprintf (token_string, token_string_len, "scanner: invalid radix for floating constant");
 743           break;
 744
 745         case  G_ERR_FLOAT_MALFORMED:
 746           g_snprintf (token_string, token_string_len, "scanner: malformed floating constant");
 747           break;
 748
 749         case  G_ERR_DIGIT_RADIX:
 750           g_snprintf (token_string, token_string_len, "scanner: digit is beyond radix");
 751           break;
 752
 753         case  G_ERR_UNKNOWN:
 754         default:
 755           g_snprintf (token_string, token_string_len, "scanner: unknown error");
 756           break;
 757         }
 758       break;
 759
 760     case  G_TOKEN_CHAR:
 761       g_snprintf (token_string, token_string_len, "character `%c'", scanner->value.v_char);
 762       break;
 763
 764     case  G_TOKEN_SYMBOL:
 765       if (expected_token == G_TOKEN_SYMBOL)
 766         print_unexp = FALSE;
 767       if (symbol_name)
 768         g_snprintf (token_string,
 769                   token_string_len,
 770                   "%s%s `%s'",
 771                   print_unexp ? "" : "invalid ",
 772                   symbol_spec,
 773                   symbol_name);
 774       else
 775         g_snprintf (token_string,
 776                   token_string_len,
 777                   "%s%s",
 778                   print_unexp ? "" : "invalid ",
 779                   symbol_spec);
 780       break;
 781
 782     case  G_TOKEN_IDENTIFIER:
 783       if (expected_token == G_TOKEN_IDENTIFIER)
 784         print_unexp = FALSE;
 785       g_snprintf (token_string,
 786                 token_string_len,
 787                 "%s%s `%s'",
 788                 print_unexp ? "" : "invalid ",
 789                 identifier_spec,
 790                 scanner->value.v_string);
 791       break;
 792
 793     case  G_TOKEN_BINARY:
 794     case  G_TOKEN_OCTAL:
 795     case  G_TOKEN_INT:
 796     case  G_TOKEN_HEX:
 797       g_snprintf (token_string, token_string_len, "number `%ld'", scanner->value.v_int);
 798       break;
 799
 800     case  G_TOKEN_FLOAT:
 801       g_snprintf (token_string, token_string_len, "number `%.3f'", scanner->value.v_float);
 802       break;
 803
 804     case  G_TOKEN_STRING:
 805       g_snprintf (token_string,
 806                 token_string_len,
 807                 "%sstring constant \"%s\"",
 808                 scanner->value.v_string[0] == 0 ? "empty " : "",
 809                 scanner->value.v_string);
 810       token_string[token_string_len - 2] = '"';
 811       token_string[token_string_len - 1] = 0;
 812       break;
 813
 814     case  G_TOKEN_COMMENT_SINGLE:
 815     case  G_TOKEN_COMMENT_MULTI:
 816       g_snprintf (token_string, token_string_len, "comment");
 817       break;
 818
 819     case  G_TOKEN_NONE:
 820       g_assert_not_reached ();
 821       break;
 822     }
 823
 824
 825   switch (expected_token)
 826     {
 827     default: /* 1 ... 255 */
 828       if (expected_token >= 1 && expected_token <= 255)
 829         {
 830           if ((expected_token >= ' ' && expected_token <= '~') ||
 831               strchr (scanner->config->cset_identifier_first, expected_token) ||
 832               strchr (scanner->config->cset_identifier_nth, expected_token))
 833             g_snprintf (expected_string, expected_string_len, "character `%c'", expected_token);
 834           else
 835             g_snprintf (expected_string, expected_string_len, "character `\\%o'", expected_token);
 836         }
 837       else
 838         g_snprintf (expected_string, expected_string_len, "(unknown) token <%d>", expected_token);
 839       break;
 840
 841     case  G_TOKEN_INT:
 842       g_snprintf (expected_string, expected_string_len, "number (integer)");
 843       break;
 844
 845     case  G_TOKEN_FLOAT:
 846       g_snprintf (expected_string, expected_string_len, "number (float)");
 847       break;
 848
 849     case  G_TOKEN_STRING:
 850       g_snprintf (expected_string, expected_string_len, "string constant");
 851       break;
 852
 853     case  G_TOKEN_SYMBOL:
 854       g_snprintf (expected_string,
 855                 expected_string_len,
 856                 "%s%s",
 857                 scanner->token == G_TOKEN_SYMBOL ? "valid " : "",
 858                 symbol_spec);
 859       break;
 860
 861     case  G_TOKEN_IDENTIFIER:
 862       g_snprintf (expected_string,
 863                 expected_string_len,
 864                 "%s%s",
 865                 scanner->token == G_TOKEN_IDENTIFIER ? "valid " : "",
 866                 identifier_spec);
 867       break;
 868
 869     case  G_TOKEN_NONE:
 870       break;
 871     }
 872
 873   if (message && message[0] != 0)
 874     message_prefix = " - ";
 875   else
 876     {
 877       message_prefix = "";
 878       message = "";
 879     }
 880
 881   if (expected_token != G_TOKEN_NONE)
 882     {
 883       if (print_unexp)
 884         msg_handler (scanner,
 885                      "unexpected %s, expected %s%s%s",
 886                      token_string,
 887                      expected_string,
 888                      message_prefix,
 889                      message);
 890       else
 891         msg_handler (scanner,
 892                      "%s, expected %s%s%s",
 893                      token_string,
 894                      expected_string,
 895                      message_prefix,
 896                      message);
 897     }
 898   else
 899     {
 900       if (print_unexp)
 901         msg_handler (scanner,
 902                      "unexpected %s%s%s",
 903                      token_string,
 904                      message_prefix,
 905                      message);
 906       else
 907         msg_handler (scanner,
 908                      "%s%s%s",
 909                      token_string,
 910                      message_prefix,
 911                      message);
 912     }
 913
 914   g_free (token_string);
 915   g_free (expected_string);
 916 }
 917
 918 gint
 919 g_scanner_stat_mode (const gchar *filename)
 920 {
 921   struct stat  *stat_buf;
 922   gint          st_mode;
 923
 924   stat_buf = g_new0 (struct stat, 1);
 925
 926   lstat (filename, stat_buf);
 927
 928   st_mode = stat_buf->st_mode;
 929
 930   g_free (stat_buf);
 931
 932   return st_mode;
 933 }
 934
 935 static void
 936 g_scanner_free_value (GTokenType     *token_p,
 937                       GValue         *value_p)
 938 {
 939   switch (*token_p)
 940     {
 941     case  G_TOKEN_STRING:
 942     case  G_TOKEN_IDENTIFIER:
 943     case  G_TOKEN_IDENTIFIER_NULL:
 944     case  G_TOKEN_COMMENT_SINGLE:
 945     case  G_TOKEN_COMMENT_MULTI:
 946       g_free (value_p->v_string);
 947       break;
 948
 949     default:
 950       break;
 951     }
 952
 953   *token_p = G_TOKEN_NONE;
 954 }
 955
 956 static void
 957 g_scanner_get_token_i (GScanner *scanner,
 958                        GTokenType       *token_p,
 959                        GValue           *value_p,
 960                        guint            *line_p,
 961                        guint            *position_p)
 962 {
 963   do
 964     {
 965       g_scanner_free_value (token_p, value_p);
 966       g_scanner_get_token_ll (scanner, token_p, value_p, line_p, position_p);
 967     }
 968   while (((*token_p > 0 && *token_p < 256) &&
 969           strchr (scanner->config->cset_skip_characters, *token_p)) ||
 970          (*token_p == G_TOKEN_CHAR &&
 971           strchr (scanner->config->cset_skip_characters, value_p->v_char)) ||
 972          (*token_p == G_TOKEN_COMMENT_MULTI &&
 973           scanner->config->skip_comment_multi) ||
 974          (*token_p == G_TOKEN_COMMENT_SINGLE &&
 975           scanner->config->skip_comment_single));
 976
 977   switch (*token_p)
 978     {
 979     case        G_TOKEN_IDENTIFIER:
 980       if (scanner->config->identifier_2_string)
 981         *token_p = G_TOKEN_STRING;
 982       break;
 983
 984     case        G_TOKEN_SYMBOL:
 985       if (scanner->config->symbol_2_token)
 986         *token_p = (GTokenType) value_p->v_symbol;
 987       break;
 988
 989     case        G_TOKEN_BINARY:
 990     case        G_TOKEN_OCTAL:
 991     case        G_TOKEN_HEX:
 992       if (scanner->config->numbers_2_int)
 993         *token_p = G_TOKEN_INT;
 994       break;
 995
 996     default:
 997       break;
 998     }
 999
1000   if (*token_p == G_TOKEN_INT &&
1001       scanner->config->int_2_float)
1002     {
1003       *token_p = G_TOKEN_FLOAT;
1004       value_p->v_float = value_p->v_int;
1005     }
1006
1007   errno = 0;
1008 }
1009
1010 static void
1011 g_scanner_get_token_ll  (GScanner       *scanner,
1012                          GTokenType     *token_p,
1013                          GValue         *value_p,
1014                          guint          *line_p,
1015                          guint          *position_p)
1016 {
1017   register GScannerConfig       *config;
1018   register gboolean             in_comment_multi;
1019   register gboolean             in_comment_single;
1020   register gboolean             in_string_sq;
1021   register gboolean             in_string_dq;
1022   static   guchar               ch;
1023   register GTokenType           token;
1024   register GValue               value;
1025   register GString              *gstring;
1026
1027   config = scanner->config;
1028   (*value_p).v_int = 0;
1029
1030   if (scanner->token == G_TOKEN_EOF ||
1031       (!scanner->text_len &&
1032        (scanner->input_fd < 0 ||
1033         scanner->peeked_char == 0)))
1034     {
1035       *token_p = G_TOKEN_EOF;
1036       return;
1037     }
1038
1039   in_comment_multi = FALSE;
1040   in_comment_single = FALSE;
1041   in_string_sq = FALSE;
1042   in_string_dq = FALSE;
1043   gstring = NULL;
1044
1045   do
1046     {
1047       register gboolean         dotted_float = FALSE;
1048
1049       ch = g_scanner_get_char (scanner, line_p, position_p);
1050
1051       value.v_int = 0;
1052       token = G_TOKEN_NONE;
1053
1054       /* this is *evil*, but needed ;(
1055        * we first check for identifier first character, because  it
1056        * might interfere with other key chars like slashes or numbers
1057        */
1058       if (config->scan_identifier &&
1059           ch && strchr (config->cset_identifier_first, ch))
1060         goto identifier_precedence;
1061
1062       switch (ch)
1063         {
1064           register gboolean     in_number;
1065           static         gchar          *endptr;
1066
1067         case  0:
1068           token = G_TOKEN_EOF;
1069           (*position_p)++;
1070           ch = 0;
1071           break;
1072
1073         case  '/':
1074           if (!config->scan_comment_multi ||
1075               g_scanner_peek_next_char (scanner) != '*')
1076             goto default_case;
1077           g_scanner_get_char (scanner, line_p, position_p);
1078           token = G_TOKEN_COMMENT_MULTI;
1079           in_comment_multi = TRUE;
1080           gstring = g_string_new ("");
1081           while ((ch = g_scanner_get_char (scanner, line_p, position_p)) != 0)
1082             {
1083               if (ch == '*' && g_scanner_peek_next_char (scanner) == '/')
1084                 {
1085                   g_scanner_get_char (scanner, line_p, position_p);
1086                   in_comment_multi = FALSE;
1087                   break;
1088                 }
1089               else
1090                 gstring = g_string_append_c (gstring, ch);
1091             }
1092           ch = 0;
1093           break;
1094
1095         case  '\'':
1096           if (!config->scan_string_sq)
1097             goto default_case;
1098           token = G_TOKEN_STRING;
1099           in_string_sq = TRUE;
1100           gstring = g_string_new ("");
1101           while ((ch = g_scanner_get_char (scanner, line_p, position_p)) != 0)
1102             {
1103               if (ch == '\'')
1104                 {
1105                   in_string_sq = FALSE;
1106                   break;
1107                 }
1108               else
1109                 gstring = g_string_append_c (gstring, ch);
1110             }
1111           ch = 0;
1112           break;
1113
1114         case  '"':
1115           if (!config->scan_string_dq)
1116             goto default_case;
1117           token = G_TOKEN_STRING;
1118           in_string_dq = TRUE;
1119           gstring = g_string_new ("");
1120           while ((ch = g_scanner_get_char (scanner, line_p, position_p)) != 0)
1121             {
1122               if (ch == '"')
1123                 {
1124                   in_string_dq = FALSE;
1125                   break;
1126                 }
1127               else
1128                 {
1129                   if (ch == '\\')
1130                     {
1131                       ch = g_scanner_get_char (scanner, line_p, position_p);
1132                       switch (ch)
1133                         {
1134                           register guint        i;
1135                           register guint        fchar;
1136
1137                         case  0:
1138                           break;
1139
1140                         case  '\\':
1141                           gstring = g_string_append_c (gstring, '\\');
1142                           break;
1143
1144                         case  'n':
1145                           gstring = g_string_append_c (gstring, '\n');
1146                           break;
1147
1148                         case  't':
1149                           gstring = g_string_append_c (gstring, '\t');
1150                           break;
1151
1152                         case  'r':
1153                           gstring = g_string_append_c (gstring, '\r');
1154                           break;
1155
1156                         case  'b':
1157                           gstring = g_string_append_c (gstring, '\b');
1158                           break;
1159
1160                         case  'f':
1161                           gstring = g_string_append_c (gstring, '\f');
1162                           break;
1163
1164                         case  '0':
1165                         case  '1':
1166                         case  '2':
1167                         case  '3':
1168                         case  '4':
1169                         case  '5':
1170                         case  '6':
1171                         case  '7':
1172                           i = ch - '0';
1173                           fchar = g_scanner_peek_next_char (scanner);
1174                           if (fchar >= '0' && fchar <= '7')
1175                             {
1176                               ch = g_scanner_get_char (scanner, line_p, position_p);
1177                               i= i * 8 + ch - '0';
1178                               fchar = g_scanner_peek_next_char (scanner);
1179                               if (fchar >= '0' && fchar <= '7')
1180                                 {
1181                                   ch = g_scanner_get_char (scanner, line_p, position_p);
1182                                   i = i * 8 + ch - '0';
1183                                 }
1184                             }
1185                           gstring = g_string_append_c (gstring, i);
1186                           break;
1187
1188                         default:
1189                           gstring = g_string_append_c (gstring, ch);
1190                           break;
1191                         }
1192                     }
1193                   else
1194                     gstring = g_string_append_c (gstring, ch);
1195                 }
1196             }
1197           ch = 0;
1198           break;
1199
1200         case  '.':
1201           if (!config->scan_float)
1202             goto default_case;
1203           token = G_TOKEN_FLOAT;
1204           dotted_float = TRUE;
1205           ch = g_scanner_get_char (scanner, line_p, position_p);
1206           goto number_parsing;
1207
1208         case  '$':
1209           if (!config->scan_hex_dollar)
1210             goto default_case;
1211           token = G_TOKEN_HEX;
1212           ch = g_scanner_get_char (scanner, line_p, position_p);
1213           goto number_parsing;
1214
1215         case  '0':
1216           if (config->scan_octal)
1217             token = G_TOKEN_OCTAL;
1218           else
1219             token = G_TOKEN_INT;
1220           ch = g_scanner_peek_next_char (scanner);
1221           if (config->scan_hex && (ch == 'x' || ch == 'X'))
1222             {
1223               token = G_TOKEN_HEX;
1224               g_scanner_get_char (scanner, line_p, position_p);
1225               ch = g_scanner_get_char (scanner, line_p, position_p);
1226               if (ch == 0)
1227                 {
1228                   token = G_TOKEN_ERROR;
1229                   value.v_error = G_ERR_UNEXP_EOF;
1230                   (*position_p)++;
1231                   break;
1232                 }
1233               if (g_scanner_char_2_num (ch, 16) < 0)
1234                 {
1235                   token = G_TOKEN_ERROR;
1236                   value.v_error = G_ERR_DIGIT_RADIX;
1237                   ch = 0;
1238                   break;
1239                 }
1240             }
1241           else if (config->scan_binary && (ch == 'b' || ch == 'B'))
1242             {
1243               token = G_TOKEN_BINARY;
1244               g_scanner_get_char (scanner, line_p, position_p);
1245               ch = g_scanner_get_char (scanner, line_p, position_p);
1246               if (ch == 0)
1247                 {
1248                   token = G_TOKEN_ERROR;
1249                   value.v_error = G_ERR_UNEXP_EOF;
1250                   (*position_p)++;
1251                   break;
1252                 }
1253               if (g_scanner_char_2_num (ch, 10) < 0)
1254                 {
1255                   token = G_TOKEN_ERROR;
1256                   value.v_error = G_ERR_NON_DIGIT_IN_CONST;
1257                   ch = 0;
1258                   break;
1259                 }
1260             }
1261           else
1262             ch = '0';
1263           /* fall through */
1264         case  '1':
1265         case  '2':
1266         case  '3':
1267         case  '4':
1268         case  '5':
1269         case  '6':
1270         case  '7':
1271         case  '8':
1272         case  '9':
1273         number_parsing:
1274         if (token == G_TOKEN_NONE)
1275           token = G_TOKEN_INT;
1276
1277         gstring = g_string_new (dotted_float ? "0." : "");
1278         gstring = g_string_append_c (gstring, ch);
1279         in_number = TRUE;
1280         while (in_number)
1281           {
1282             register gboolean is_E;
1283
1284             is_E = (ch == 'e' || ch == 'E') && token == G_TOKEN_FLOAT;
1285             ch = g_scanner_peek_next_char (scanner);
1286
1287             if (g_scanner_char_2_num (ch, 36) >= 0 ||
1288                 (config->scan_float && ch == '.') ||
1289                 (is_E && ch == '+') ||
1290                 (is_E && ch == '-') )
1291               ch = g_scanner_get_char (scanner, line_p, position_p);
1292             else
1293               in_number = FALSE;
1294
1295             if (in_number)
1296               switch (ch)
1297                 {
1298                 case  '.':
1299                   if (token != G_TOKEN_INT &&
1300                       token != G_TOKEN_OCTAL)
1301                     {
1302                       token = G_TOKEN_ERROR;
1303                       if (token == G_TOKEN_FLOAT)
1304                         value.v_error = G_ERR_FLOAT_MALFORMED;
1305                       else
1306                         value.v_error = G_ERR_FLOAT_RADIX;
1307                       in_number = FALSE;
1308                     }
1309                   else
1310                     {
1311                       token = G_TOKEN_FLOAT;
1312                       gstring = g_string_append_c (gstring, ch);
1313                     }
1314                   break;
1315
1316                 case    '0':
1317                 case  '1':
1318                 case  '2':
1319                 case  '3':
1320                 case  '4':
1321                 case  '5':
1322                 case  '6':
1323                 case  '7':
1324                 case  '8':
1325                 case  '9':
1326                   gstring = g_string_append_c (gstring, ch);
1327                   break;
1328
1329                 case    '-':
1330                 case    '+':
1331                   if (token != G_TOKEN_FLOAT)
1332                     {
1333                       token = G_TOKEN_ERROR;
1334                       value.v_error = G_ERR_NON_DIGIT_IN_CONST;
1335                       in_number = FALSE;
1336                     }
1337                   else
1338                     gstring = g_string_append_c (gstring, ch);
1339                   break;
1340
1341                 case    'e':
1342                 case    'E':
1343                   if ((token != G_TOKEN_HEX && !config->scan_float) ||
1344                       (token != G_TOKEN_HEX &&
1345                        token != G_TOKEN_OCTAL &&
1346                        token != G_TOKEN_FLOAT &&
1347                        token != G_TOKEN_INT))
1348                     {
1349                       token = G_TOKEN_ERROR;
1350                       value.v_error = G_ERR_NON_DIGIT_IN_CONST;
1351                       in_number = FALSE;
1352                     }
1353                   else
1354                     {
1355                       if (token != G_TOKEN_HEX)
1356                         token = G_TOKEN_FLOAT;
1357                       gstring = g_string_append_c (gstring, ch);
1358                     }
1359                   break;
1360
1361                 default:
1362                   if (token != G_TOKEN_HEX)
1363                     {
1364                       token = G_TOKEN_ERROR;
1365                       value.v_error = G_ERR_NON_DIGIT_IN_CONST;
1366                       in_number = FALSE;
1367                     }
1368                   else
1369                     gstring = g_string_append_c (gstring, ch);
1370                   break;
1371                 }
1372           }
1373         endptr = NULL;
1374         switch (token)
1375           {
1376           case  G_TOKEN_BINARY:
1377             value.v_binary = strtol (gstring->str, &endptr, 2);
1378             break;
1379
1380           case  G_TOKEN_OCTAL:
1381             value.v_octal = strtol (gstring->str, &endptr, 8);
1382             break;
1383
1384           case  G_TOKEN_INT:
1385             value.v_int = strtol (gstring->str, &endptr, 10);
1386             break;
1387
1388           case  G_TOKEN_FLOAT:
1389             value.v_float = g_strtod (gstring->str, &endptr);
1390             break;
1391
1392           case  G_TOKEN_HEX:
1393             value.v_hex = strtol (gstring->str, &endptr, 16);
1394             break;
1395
1396           default:
1397             break;
1398           }
1399         if (endptr && *endptr)
1400           {
1401             token = G_TOKEN_ERROR;
1402             if (*endptr == 'e' || *endptr == 'E')
1403               value.v_error = G_ERR_NON_DIGIT_IN_CONST;
1404             else
1405               value.v_error = G_ERR_DIGIT_RADIX;
1406           }
1407         g_string_free (gstring, TRUE);
1408         gstring = NULL;
1409         ch = 0;
1410         break;
1411
1412         default:
1413         default_case:
1414         if (config->cpair_comment_single &&
1415             ch == config->cpair_comment_single[0])
1416           {
1417             token = G_TOKEN_COMMENT_SINGLE;
1418             in_comment_single = TRUE;
1419             gstring = g_string_new ("");
1420             while ((ch = g_scanner_get_char (scanner,
1421                                              line_p,
1422                                              position_p)) != 0)
1423               {
1424                 if (ch == config->cpair_comment_single[1])
1425                   {
1426                     in_comment_single = FALSE;
1427                     ch = 0;
1428                     break;
1429                   }
1430
1431                 gstring = g_string_append_c (gstring, ch);
1432                 ch = 0;
1433               }
1434           }
1435         else if (config->scan_identifier && ch &&
1436                  strchr (config->cset_identifier_first, ch))
1437           {
1438           identifier_precedence:
1439
1440             if (config->cset_identifier_nth && ch &&
1441                 strchr (config->cset_identifier_nth,
1442                         g_scanner_peek_next_char (scanner)))
1443               {
1444                 token = G_TOKEN_IDENTIFIER;
1445                 gstring = g_string_new ("");
1446                 gstring = g_string_append_c (gstring, ch);
1447                 do
1448                   {
1449                     ch = g_scanner_get_char (scanner, line_p, position_p);
1450                     gstring = g_string_append_c (gstring, ch);
1451                     ch = g_scanner_peek_next_char (scanner);
1452                   }
1453                 while (ch && strchr (config->cset_identifier_nth, ch));
1454                 ch = 0;
1455               }
1456             else if (config->scan_identifier_1char)
1457               {
1458                 token = G_TOKEN_IDENTIFIER;
1459                 value.v_identifier = g_new0 (gchar, 2);
1460                 value.v_identifier[0] = ch;
1461                 ch = 0;
1462               }
1463           }
1464         if (ch)
1465           {
1466             if (config->char_2_token)
1467               token = ch;
1468             else
1469               {
1470                 token = G_TOKEN_CHAR;
1471                 value.v_char = ch;
1472               }
1473             ch = 0;
1474           }
1475         break;
1476         }
1477       g_assert (ch == 0 && token != G_TOKEN_NONE);
1478     }
1479   while (ch != 0);
1480
1481   if (in_comment_multi ||
1482       in_comment_single ||
1483       in_string_sq ||
1484       in_string_dq)
1485     {
1486       token = G_TOKEN_ERROR;
1487       if (gstring)
1488         {
1489           g_string_free (gstring, TRUE);
1490           gstring = NULL;
1491         }
1492       (*position_p)++;
1493       if (in_comment_multi || in_comment_single)
1494         value.v_error = G_ERR_UNEXP_EOF_IN_COMMENT;
1495       else if (in_string_sq || in_string_dq)
1496         value.v_error = G_ERR_UNEXP_EOF_IN_STRING;
1497     }
1498
1499   if (gstring)
1500     {
1501       value.v_string = gstring->str;
1502       g_string_free (gstring, FALSE);
1503       gstring = NULL;
1504     }
1505
1506   if (token == G_TOKEN_IDENTIFIER &&
1507       config->scan_symbols)
1508     {
1509       register GScannerHashVal  *hash_val;
1510
1511       hash_val = g_scanner_lookup_internal (scanner, value.v_identifier);
1512
1513       if (hash_val)
1514         {
1515           g_free (value.v_identifier);
1516           token = G_TOKEN_SYMBOL;
1517           value.v_symbol = hash_val->value;
1518         }
1519     }
1520
1521   if (token == G_TOKEN_IDENTIFIER &&
1522       config->scan_identifier_NULL &&
1523       strlen (value.v_identifier) == 4)
1524     {
1525       gchar *null_upper = "NULL";
1526       gchar *null_lower = "null";
1527
1528       if (scanner->config->case_sensitive)
1529         {
1530           if (value.v_identifier[0] == null_upper[0] &&
1531               value.v_identifier[1] == null_upper[1] &&
1532               value.v_identifier[2] == null_upper[2] &&
1533               value.v_identifier[3] == null_upper[3])
1534             token = G_TOKEN_IDENTIFIER_NULL;
1535         }
1536       else
1537         {
1538           if ((value.v_identifier[0] == null_upper[0] ||
1539                value.v_identifier[0] == null_lower[0]) &&
1540               (value.v_identifier[1] == null_upper[1] ||
1541                value.v_identifier[1] == null_lower[1]) &&
1542               (value.v_identifier[2] == null_upper[2] ||
1543                value.v_identifier[2] == null_lower[2]) &&
1544               (value.v_identifier[3] == null_upper[3] ||
1545                value.v_identifier[3] == null_lower[3]))
1546             token = G_TOKEN_IDENTIFIER_NULL;
1547         }
1548     }
1549
1550   *token_p = token;
1551   *value_p = value;
1552 }