Source/cmCommandArgumentLexer.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmCommandArgumentLexer.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008-12-18 14:58:06 $
   7   Version:   $Revision: 1.18 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #include "cmStandardIncludes.h"
  18
  19 #line 2 "cmCommandArgumentLexer.cxx"
  20
  21 #line 4 "cmCommandArgumentLexer.cxx"
  22
  23 #define  YY_INT_ALIGNED short int
  24
  25 /* A lexical scanner generated by flex */
  26
  27 #define FLEX_SCANNER
  28 #define YY_FLEX_MAJOR_VERSION 2
  29 #define YY_FLEX_MINOR_VERSION 5
  30 #define YY_FLEX_SUBMINOR_VERSION 35
  31 #if YY_FLEX_SUBMINOR_VERSION > 0
  32 #define FLEX_BETA
  33 #endif
  34
  35 /* First, we deal with  platform-specific or compiler-specific issues. */
  36
  37 /* begin standard C headers. */
  38 #include <stdio.h>
  39 #include <string.h>
  40 #include <errno.h>
  41 #include <stdlib.h>
  42
  43 /* end standard C headers. */
  44
  45 /* flex integer type definitions */
  46
  47 #ifndef FLEXINT_H
  48 #define FLEXINT_H
  49
  50 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
  51
  52 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
  53
  54 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
  55  * if you want the limit (max/min) macros for int types.
  56  */
  57 #ifndef __STDC_LIMIT_MACROS
  58 #define __STDC_LIMIT_MACROS 1
  59 #endif
  60
  61 #include <inttypes.h>
  62 typedef int8_t flex_int8_t;
  63 typedef uint8_t flex_uint8_t;
  64 typedef int16_t flex_int16_t;
  65 typedef uint16_t flex_uint16_t;
  66 typedef int32_t flex_int32_t;
  67 typedef uint32_t flex_uint32_t;
  68 #else
  69 typedef signed char flex_int8_t;
  70 typedef short int flex_int16_t;
  71 typedef int flex_int32_t;
  72 typedef unsigned char flex_uint8_t;
  73 typedef unsigned short int flex_uint16_t;
  74 typedef unsigned int flex_uint32_t;
  75
  76 /* Limits of integral types. */
  77 #ifndef INT8_MIN
  78 #define INT8_MIN               (-128)
  79 #endif
  80 #ifndef INT16_MIN
  81 #define INT16_MIN              (-32767-1)
  82 #endif
  83 #ifndef INT32_MIN
  84 #define INT32_MIN              (-2147483647-1)
  85 #endif
  86 #ifndef INT8_MAX
  87 #define INT8_MAX               (127)
  88 #endif
  89 #ifndef INT16_MAX
  90 #define INT16_MAX              (32767)
  91 #endif
  92 #ifndef INT32_MAX
  93 #define INT32_MAX              (2147483647)
  94 #endif
  95 #ifndef UINT8_MAX
  96 #define UINT8_MAX              (255U)
  97 #endif
  98 #ifndef UINT16_MAX
  99 #define UINT16_MAX             (65535U)
 100 #endif
 101 #ifndef UINT32_MAX
 102 #define UINT32_MAX             (4294967295U)
 103 #endif
 104
 105 #endif /* ! C99 */
 106
 107 #endif /* ! FLEXINT_H */
 108
 109 #ifdef __cplusplus
 110
 111 /* The "const" storage-class-modifier is valid. */
 112 #define YY_USE_CONST
 113
 114 #else   /* ! __cplusplus */
 115
 116 /* C99 requires __STDC__ to be defined as 1. */
 117 #if defined (__STDC__)
 118
 119 #define YY_USE_CONST
 120
 121 #endif  /* defined (__STDC__) */
 122 #endif  /* ! __cplusplus */
 123
 124 #ifdef YY_USE_CONST
 125 #define yyconst const
 126 #else
 127 #define yyconst
 128 #endif
 129
 130 /* Returned upon end-of-file. */
 131 #define YY_NULL 0
 132
 133 /* Promotes a possibly negative, possibly signed char to an unsigned
 134  * integer for use as an array index.  If the signed char is negative,
 135  * we want to instead treat it as an 8-bit unsigned char, hence the
 136  * double cast.
 137  */
 138 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 139
 140 /* An opaque pointer. */
 141 #ifndef YY_TYPEDEF_YY_SCANNER_T
 142 #define YY_TYPEDEF_YY_SCANNER_T
 143 typedef void* yyscan_t;
 144 #endif
 145
 146 /* For convenience, these vars (plus the bison vars far below)
 147    are macros in the reentrant scanner. */
 148 #define yyin yyg->yyin_r
 149 #define yyout yyg->yyout_r
 150 #define yyextra yyg->yyextra_r
 151 #define yyleng yyg->yyleng_r
 152 #define yytext yyg->yytext_r
 153 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
 154 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
 155 #define yy_flex_debug yyg->yy_flex_debug_r
 156
 157 /* Enter a start condition.  This macro really ought to take a parameter,
 158  * but we do it the disgusting crufty way forced on us by the ()-less
 159  * definition of BEGIN.
 160  */
 161 #define BEGIN yyg->yy_start = 1 + 2 *
 162
 163 /* Translate the current start state into a value that can be later handed
 164  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 165  * compatibility.
 166  */
 167 #define YY_START ((yyg->yy_start - 1) / 2)
 168 #define YYSTATE YY_START
 169
 170 /* Action number for EOF rule of a given start state. */
 171 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 172
 173 /* Special action meaning "start processing a new file". */
 174 #define YY_NEW_FILE cmCommandArgument_yyrestart(yyin ,yyscanner )
 175
 176 #define YY_END_OF_BUFFER_CHAR 0
 177
 178 /* Size of default input buffer. */
 179 #ifndef YY_BUF_SIZE
 180 #define YY_BUF_SIZE 16384
 181 #endif
 182
 183 /* The state buf must be large enough to hold one state per character in the main buffer.
 184  */
 185 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
 186
 187 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
 188 #define YY_TYPEDEF_YY_BUFFER_STATE
 189 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 190 #endif
 191
 192 #define EOB_ACT_CONTINUE_SCAN 0
 193 #define EOB_ACT_END_OF_FILE 1
 194 #define EOB_ACT_LAST_MATCH 2
 195
 196     #define YY_LESS_LINENO(n)
 197
 198 /* Return all but the first "n" matched characters back to the input stream. */
 199 #define yyless(n) \
 200         do \
 201                 { \
 202                 /* Undo effects of setting up yytext. */ \
 203         int yyless_macro_arg = (n); \
 204         YY_LESS_LINENO(yyless_macro_arg);\
 205                 *yy_cp = yyg->yy_hold_char; \
 206                 YY_RESTORE_YY_MORE_OFFSET \
 207                 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
 208                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 209                 } \
 210         while ( 0 )
 211
 212 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
 213
 214 #ifndef YY_TYPEDEF_YY_SIZE_T
 215 #define YY_TYPEDEF_YY_SIZE_T
 216 typedef size_t yy_size_t;
 217 #endif
 218
 219 #ifndef YY_STRUCT_YY_BUFFER_STATE
 220 #define YY_STRUCT_YY_BUFFER_STATE
 221 struct yy_buffer_state
 222         {
 223         FILE *yy_input_file;
 224
 225         char *yy_ch_buf;                /* input buffer */
 226         char *yy_buf_pos;               /* current position in input buffer */
 227
 228         /* Size of input buffer in bytes, not including room for EOB
 229          * characters.
 230          */
 231         yy_size_t yy_buf_size;
 232
 233         /* Number of characters read into yy_ch_buf, not including EOB
 234          * characters.
 235          */
 236         int yy_n_chars;
 237
 238         /* Whether we "own" the buffer - i.e., we know we created it,
 239          * and can realloc() it to grow it, and should free() it to
 240          * delete it.
 241          */
 242         int yy_is_our_buffer;
 243
 244         /* Whether this is an "interactive" input source; if so, and
 245          * if we're using stdio for input, then we want to use getc()
 246          * instead of fread(), to make sure we stop fetching input after
 247          * each newline.
 248          */
 249         int yy_is_interactive;
 250
 251         /* Whether we're considered to be at the beginning of a line.
 252          * If so, '^' rules will be active on the next match, otherwise
 253          * not.
 254          */
 255         int yy_at_bol;
 256
 257     int yy_bs_lineno; /**< The line count. */
 258     int yy_bs_column; /**< The column count. */
 259
 260         /* Whether to try to fill the input buffer when we reach the
 261          * end of it.
 262          */
 263         int yy_fill_buffer;
 264
 265         int yy_buffer_status;
 266
 267 #define YY_BUFFER_NEW 0
 268 #define YY_BUFFER_NORMAL 1
 269         /* When an EOF's been seen but there's still some text to process
 270          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 271          * shouldn't try reading from the input source any more.  We might
 272          * still have a bunch of tokens to match, though, because of
 273          * possible backing-up.
 274          *
 275          * When we actually see the EOF, we change the status to "new"
 276          * (via cmCommandArgument_yyrestart()), so that the user can continue scanning by
 277          * just pointing yyin at a new input file.
 278          */
 279 #define YY_BUFFER_EOF_PENDING 2
 280
 281         };
 282 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
 283
 284 /* We provide macros for accessing buffer states in case in the
 285  * future we want to put the buffer states in a more general
 286  * "scanner state".
 287  *
 288  * Returns the top of the stack, or NULL.
 289  */
 290 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
 291                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
 292                           : NULL)
 293
 294 /* Same as previous macro, but useful when we know that the buffer stack is not
 295  * NULL or when we need an lvalue. For internal use only.
 296  */
 297 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
 298
 299 void cmCommandArgument_yyrestart (FILE *input_file ,yyscan_t yyscanner );
 300 void cmCommandArgument_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 301 YY_BUFFER_STATE cmCommandArgument_yy_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
 302 void cmCommandArgument_yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 303 void cmCommandArgument_yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
 304 void cmCommandArgument_yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
 305 void cmCommandArgument_yypop_buffer_state (yyscan_t yyscanner );
 306
 307 static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner );
 308 static void cmCommandArgument_yy_load_buffer_state (yyscan_t yyscanner );
 309 static void cmCommandArgument_yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
 310
 311 #define YY_FLUSH_BUFFER cmCommandArgument_yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
 312
 313 YY_BUFFER_STATE cmCommandArgument_yy_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
 314 YY_BUFFER_STATE cmCommandArgument_yy_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
 315 YY_BUFFER_STATE cmCommandArgument_yy_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
 316
 317 void *cmCommandArgument_yyalloc (yy_size_t ,yyscan_t yyscanner );
 318 void *cmCommandArgument_yyrealloc (void *,yy_size_t ,yyscan_t yyscanner );
 319 void cmCommandArgument_yyfree (void * ,yyscan_t yyscanner );
 320
 321 #define yy_new_buffer cmCommandArgument_yy_create_buffer
 322
 323 #define yy_set_interactive(is_interactive) \
 324         { \
 325         if ( ! YY_CURRENT_BUFFER ){ \
 326         cmCommandArgument_yyensure_buffer_stack (yyscanner); \
 327                 YY_CURRENT_BUFFER_LVALUE =    \
 328             cmCommandArgument_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 329         } \
 330         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
 331         }
 332
 333 #define yy_set_bol(at_bol) \
 334         { \
 335         if ( ! YY_CURRENT_BUFFER ){\
 336         cmCommandArgument_yyensure_buffer_stack (yyscanner); \
 337                 YY_CURRENT_BUFFER_LVALUE =    \
 338             cmCommandArgument_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
 339         } \
 340         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
 341         }
 342
 343 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
 344
 345 /* Begin user sect3 */
 346
 347 #define cmCommandArgument_yywrap(n) 1
 348 #define YY_SKIP_YYWRAP
 349
 350 typedef unsigned char YY_CHAR;
 351
 352 typedef int yy_state_type;
 353
 354 #define yytext_ptr yytext_r
 355
 356 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
 357 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
 358 static int yy_get_next_buffer (yyscan_t yyscanner );
 359 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
 360
 361 /* Done after the current pattern has been matched and before the
 362  * corresponding action - sets up yytext.
 363  */
 364 #define YY_DO_BEFORE_ACTION \
 365         yyg->yytext_ptr = yy_bp; \
 366         yyleng = (size_t) (yy_cp - yy_bp); \
 367         yyg->yy_hold_char = *yy_cp; \
 368         *yy_cp = '\0'; \
 369         yyg->yy_c_buf_p = yy_cp;
 370
 371 #define YY_NUM_RULES 14
 372 #define YY_END_OF_BUFFER 15
 373 /* This struct is not used in this scanner,
 374    but its presence is necessary. */
 375 struct yy_trans_info
 376         {
 377         flex_int32_t yy_verify;
 378         flex_int32_t yy_nxt;
 379         };
 380 static yyconst flex_int16_t yy_accept[30] =
 381     {   0,
 382         0,    0,    0,    0,    0,    0,   15,    9,   10,    7,
 383         6,   14,   11,    5,   12,   13,    9,    0,    0,    4,
 384         7,    0,    8,    2,    0,    3,    0,    1,    0
 385     } ;
 386
 387 static yyconst flex_int32_t yy_ec[256] =
 388     {   0,
 389         1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
 390         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 391         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 392         1,    1,    1,    1,    1,    3,    1,    1,    1,    1,
 393         1,    1,    4,    1,    4,    4,    4,    4,    4,    4,
 394         4,    4,    4,    4,    4,    4,    4,    1,    1,    1,
 395         1,    1,    1,    5,    4,    4,    4,    4,    6,    4,
 396         4,    4,    4,    4,    4,    4,    4,    7,    4,    4,
 397         4,    4,    4,    4,    4,    8,    4,    4,    4,    4,
 398         1,    9,    1,    1,    4,    1,    4,    4,    4,    4,
 399
 400         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
 401         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
 402         4,    4,   10,    1,   11,    1,    1,    1,    1,    1,
 403         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 405         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 408         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 409         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 410
 411         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 412         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 413         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 414         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 415         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 416         1,    1,    1,    1,    1
 417     } ;
 418
 419 static yyconst flex_int32_t yy_meta[12] =
 420     {   0,
 421         1,    2,    3,    4,    3,    4,    4,    4,    3,    5,
 422         3
 423     } ;
 424
 425 static yyconst flex_int16_t yy_base[35] =
 426     {   0,
 427         0,    0,   31,   30,   29,   28,   36,    0,    6,   16,
 428         0,   41,   41,   41,    0,   41,    0,   22,   22,   41,
 429        18,   18,   41,   41,    7,   41,    4,   41,   41,   20,
 430        21,   26,    9,   30
 431     } ;
 432
 433 static yyconst flex_int16_t yy_def[35] =
 434     {   0,
 435        29,    1,    1,    1,    1,    1,   29,   30,   31,   32,
 436        33,   29,   29,   29,   34,   29,   30,   31,   18,   29,
 437        32,   33,   29,   29,   18,   29,   18,   29,    0,   29,
 438        29,   29,   29,   29
 439     } ;
 440
 441 static yyconst flex_int16_t yy_nxt[53] =
 442     {   0,
 443         8,    8,    9,   10,   11,   10,   10,   10,   12,   13,
 444        14,   19,   22,   28,   27,   20,   17,   17,   17,   17,
 445        17,   17,   26,   17,   18,   18,   21,   21,   25,   21,
 446        23,   24,   23,   23,   23,   29,   16,   16,   15,   15,
 447         7,   29,   29,   29,   29,   29,   29,   29,   29,   29,
 448        29,   29
 449     } ;
 450
 451 static yyconst flex_int16_t yy_chk[53] =
 452     {   0,
 453         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 454         1,    9,   33,   27,   25,    9,   10,   10,   21,   21,
 455        30,   30,   22,   30,   31,   31,   32,   32,   19,   32,
 456        34,   18,   34,   34,   34,    7,    6,    5,    4,    3,
 457        29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
 458        29,   29
 459     } ;
 460
 461 /* The intent behind this definition is that it'll catch
 462  * any uses of REJECT which flex missed.
 463  */
 464 #define REJECT reject_used_but_not_detected
 465 #define yymore() yymore_used_but_not_detected
 466 #define YY_MORE_ADJ 0
 467 #define YY_RESTORE_YY_MORE_OFFSET
 468 #line 1 "cmCommandArgumentLexer.in.l"
 469 #line 2 "cmCommandArgumentLexer.in.l"
 470 /*=========================================================================
 471
 472   Program:   CMake - Cross-Platform Makefile Generator
 473   Module:    $RCSfile: cmCommandArgumentLexer.cxx,v $
 474   Language:  C++
 475   Date:      $Date: 2008-12-18 14:58:06 $
 476   Version:   $Revision: 1.18 $
 477
 478   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
 479   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
 480
 481      This software is distributed WITHOUT ANY WARRANTY; without even
 482      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 483      PURPOSE.  See the above copyright notices for more information.
 484
 485 =========================================================================*/
 486 /*
 487
 488 This file must be translated to C and modified to build everywhere.
 489
 490 Run flex like this:
 491
 492   flex --prefix=cmCommandArgument_yy --header-file=cmCommandArgumentLexer.h -ocmCommandArgumentLexer.cxx cmCommandArgumentLexer.in.l
 493
 494 Modify cmCommandArgumentLexer.cxx:
 495   - add #include "cmStandardIncludes.h" to top of file
 496   - put header block at top of file
 497   - remove TABs
 498   - remove "yyscanner" argument from these methods:
 499       yy_fatal_error, cmCommandArgument_yyalloc, cmCommandArgument_yyrealloc, cmCommandArgument_yyfree
 500   - remove all YY_BREAK lines occurring right after return statements
 501   - change while ( 1 ) to for(;;)
 502   - add "return 0;" to end of cmCommandArgument_yylex
 503
 504 Modify cmCommandArgumentLexer.h:
 505   - remove TABs
 506   - remove the yy_init_globals function
 507   - remove the block that includes unistd.h
 508   - remove #line directives (avoids bogus warning on old Sun)
 509
 510 */
 511
 512 #include "cmStandardLexer.h"
 513
 514 #include "cmCommandArgumentParserHelper.h"
 515
 516 /* Replace the lexer input function.  */
 517 #undef YY_INPUT
 518 #define YY_INPUT(buf, result, max_size) \
 519   { result = yyextra->LexInput(buf, max_size); }
 520
 521 /* Include the set of tokens from the parser.  */
 522 #include "cmCommandArgumentParserTokens.h"
 523
 524 /*--------------------------------------------------------------------------*/
 525
 526
 527 #line 508 "cmCommandArgumentLexer.cxx"
 528
 529 #define INITIAL 0
 530 #define ESCAPES 1
 531 #define NOESCAPES 2
 532
 533 #ifndef YY_NO_UNISTD_H
 534 /* Special case for "unistd.h", since it is non-ANSI. We include it way
 535  * down here because we want the user's section 1 to have been scanned first.
 536  * The user has a chance to override it with an option.
 537  */
 538 #include <unistd.h>
 539 #endif
 540
 541 #ifndef YY_EXTRA_TYPE
 542 #define YY_EXTRA_TYPE void *
 543 #endif
 544
 545 /* Holds the entire state of the reentrant scanner. */
 546 struct yyguts_t
 547     {
 548
 549     /* User-defined. Not touched by flex. */
 550     YY_EXTRA_TYPE yyextra_r;
 551
 552     /* The rest are the same as the globals declared in the non-reentrant scanner. */
 553     FILE *yyin_r, *yyout_r;
 554     size_t yy_buffer_stack_top; /**< index of top of stack. */
 555     size_t yy_buffer_stack_max; /**< capacity of stack. */
 556     YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
 557     char yy_hold_char;
 558     int yy_n_chars;
 559     int yyleng_r;
 560     char *yy_c_buf_p;
 561     int yy_init;
 562     int yy_start;
 563     int yy_did_buffer_switch_on_eof;
 564     int yy_start_stack_ptr;
 565     int yy_start_stack_depth;
 566     int *yy_start_stack;
 567     yy_state_type yy_last_accepting_state;
 568     char* yy_last_accepting_cpos;
 569
 570     int yylineno_r;
 571     int yy_flex_debug_r;
 572
 573     char *yytext_r;
 574     int yy_more_flag;
 575     int yy_more_len;
 576
 577     }; /* end struct yyguts_t */
 578
 579 static int yy_init_globals (yyscan_t yyscanner );
 580
 581 int cmCommandArgument_yylex_init (yyscan_t* scanner);
 582
 583 int cmCommandArgument_yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
 584
 585 /* Accessor methods to globals.
 586    These are made visible to non-reentrant scanners for convenience. */
 587
 588 int cmCommandArgument_yylex_destroy (yyscan_t yyscanner );
 589
 590 int cmCommandArgument_yyget_debug (yyscan_t yyscanner );
 591
 592 void cmCommandArgument_yyset_debug (int debug_flag ,yyscan_t yyscanner );
 593
 594 YY_EXTRA_TYPE cmCommandArgument_yyget_extra (yyscan_t yyscanner );
 595
 596 void cmCommandArgument_yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
 597
 598 FILE *cmCommandArgument_yyget_in (yyscan_t yyscanner );
 599
 600 void cmCommandArgument_yyset_in  (FILE * in_str ,yyscan_t yyscanner );
 601
 602 FILE *cmCommandArgument_yyget_out (yyscan_t yyscanner );
 603
 604 void cmCommandArgument_yyset_out  (FILE * out_str ,yyscan_t yyscanner );
 605
 606 int cmCommandArgument_yyget_leng (yyscan_t yyscanner );
 607
 608 char *cmCommandArgument_yyget_text (yyscan_t yyscanner );
 609
 610 int cmCommandArgument_yyget_lineno (yyscan_t yyscanner );
 611
 612 void cmCommandArgument_yyset_lineno (int line_number ,yyscan_t yyscanner );
 613
 614 /* Macros after this point can all be overridden by user definitions in
 615  * section 1.
 616  */
 617
 618 #ifndef YY_SKIP_YYWRAP
 619 #ifdef __cplusplus
 620 extern "C" int cmCommandArgument_yywrap (yyscan_t yyscanner );
 621 #else
 622 extern int cmCommandArgument_yywrap (yyscan_t yyscanner );
 623 #endif
 624 #endif
 625
 626 #ifndef yytext_ptr
 627 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
 628 #endif
 629
 630 #ifdef YY_NEED_STRLEN
 631 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 632 #endif
 633
 634 #ifndef YY_NO_INPUT
 635
 636 #ifdef __cplusplus
 637 static int yyinput (yyscan_t yyscanner );
 638 #else
 639 static int input (yyscan_t yyscanner );
 640 #endif
 641
 642 #endif
 643
 644 /* Amount of stuff to slurp up with each read. */
 645 #ifndef YY_READ_BUF_SIZE
 646 #define YY_READ_BUF_SIZE 8192
 647 #endif
 648
 649 /* Copy whatever the last rule matched to the standard output. */
 650 #ifndef ECHO
 651 /* This used to be an fputs(), but since the string might contain NUL's,
 652  * we now use fwrite().
 653  */
 654 #define ECHO fwrite( yytext, yyleng, 1, yyout )
 655 #endif
 656
 657 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 658  * is returned in "result".
 659  */
 660 #ifndef YY_INPUT
 661 #define YY_INPUT(buf,result,max_size) \
 662         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
 663                 { \
 664                 int c = '*'; \
 665                 size_t n; \
 666                 for ( n = 0; n < max_size && \
 667                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 668                         buf[n] = (char) c; \
 669                 if ( c == '\n' ) \
 670                         buf[n++] = (char) c; \
 671                 if ( c == EOF && ferror( yyin ) ) \
 672                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 673                 result = n; \
 674                 } \
 675         else \
 676                 { \
 677                 errno=0; \
 678                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
 679                         { \
 680                         if( errno != EINTR) \
 681                                 { \
 682                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
 683                                 break; \
 684                                 } \
 685                         errno=0; \
 686                         clearerr(yyin); \
 687                         } \
 688                 }\
 689 \
 690
 691 #endif
 692
 693 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 694  * we don't want an extra ';' after the "return" because that will cause
 695  * some compilers to complain about unreachable statements.
 696  */
 697 #ifndef yyterminate
 698 #define yyterminate() return YY_NULL
 699 #endif
 700
 701 /* Number of entries by which start-condition stack grows. */
 702 #ifndef YY_START_STACK_INCR
 703 #define YY_START_STACK_INCR 25
 704 #endif
 705
 706 /* Report a fatal error. */
 707 #ifndef YY_FATAL_ERROR
 708 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
 709 #endif
 710
 711 /* end tables serialization structures and prototypes */
 712
 713 /* Default declaration of generated scanner - a define so the user can
 714  * easily add parameters.
 715  */
 716 #ifndef YY_DECL
 717 #define YY_DECL_IS_OURS 1
 718
 719 extern int cmCommandArgument_yylex (yyscan_t yyscanner);
 720
 721 #define YY_DECL int cmCommandArgument_yylex (yyscan_t yyscanner)
 722 #endif /* !YY_DECL */
 723
 724 /* Code executed at the beginning of each rule, after yytext and yyleng
 725  * have been set up.
 726  */
 727 #ifndef YY_USER_ACTION
 728 #define YY_USER_ACTION
 729 #endif
 730
 731 /* Code executed at the end of each rule. */
 732 #ifndef YY_BREAK
 733 #define YY_BREAK break;
 734 #endif
 735
 736 #define YY_RULE_SETUP \
 737         YY_USER_ACTION
 738
 739 /** The main scanner function which does all the work.
 740  */
 741 YY_DECL
 742 {
 743         register yy_state_type yy_current_state;
 744         register char *yy_cp, *yy_bp;
 745         register int yy_act;
 746     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 747
 748 #line 64 "cmCommandArgumentLexer.in.l"
 749
 750
 751 #line 732 "cmCommandArgumentLexer.cxx"
 752
 753         if ( !yyg->yy_init )
 754                 {
 755                 yyg->yy_init = 1;
 756
 757 #ifdef YY_USER_INIT
 758                 YY_USER_INIT;
 759 #endif
 760
 761                 if ( ! yyg->yy_start )
 762                         yyg->yy_start = 1;      /* first start state */
 763
 764                 if ( ! yyin )
 765                         yyin = stdin;
 766
 767                 if ( ! yyout )
 768                         yyout = stdout;
 769
 770                 if ( ! YY_CURRENT_BUFFER ) {
 771                         cmCommandArgument_yyensure_buffer_stack (yyscanner);
 772                         YY_CURRENT_BUFFER_LVALUE =
 773                                 cmCommandArgument_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
 774                 }
 775
 776                 cmCommandArgument_yy_load_buffer_state(yyscanner );
 777                 }
 778
 779         for(;;)             /* loops until end-of-file is reached */
 780                 {
 781                 yy_cp = yyg->yy_c_buf_p;
 782
 783                 /* Support of yytext. */
 784                 *yy_cp = yyg->yy_hold_char;
 785
 786                 /* yy_bp points to the position in yy_ch_buf of the start of
 787                  * the current run.
 788                  */
 789                 yy_bp = yy_cp;
 790
 791                 yy_current_state = yyg->yy_start;
 792 yy_match:
 793                 do
 794                         {
 795                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 796                         if ( yy_accept[yy_current_state] )
 797                                 {
 798                                 yyg->yy_last_accepting_state = yy_current_state;
 799                                 yyg->yy_last_accepting_cpos = yy_cp;
 800                                 }
 801                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 802                                 {
 803                                 yy_current_state = (int) yy_def[yy_current_state];
 804                                 if ( yy_current_state >= 30 )
 805                                         yy_c = yy_meta[(unsigned int) yy_c];
 806                                 }
 807                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 808                         ++yy_cp;
 809                         }
 810                 while ( yy_base[yy_current_state] != 41 );
 811
 812 yy_find_action:
 813                 yy_act = yy_accept[yy_current_state];
 814                 if ( yy_act == 0 )
 815                         { /* have to back up */
 816                         yy_cp = yyg->yy_last_accepting_cpos;
 817                         yy_current_state = yyg->yy_last_accepting_state;
 818                         yy_act = yy_accept[yy_current_state];
 819                         }
 820
 821                 YY_DO_BEFORE_ACTION;
 822
 823 do_action:      /* This label is used only to access EOF actions. */
 824
 825                 switch ( yy_act )
 826         { /* beginning of action switch */
 827                         case 0: /* must back up */
 828                         /* undo the effects of YY_DO_BEFORE_ACTION */
 829                         *yy_cp = yyg->yy_hold_char;
 830                         yy_cp = yyg->yy_last_accepting_cpos;
 831                         yy_current_state = yyg->yy_last_accepting_state;
 832                         goto yy_find_action;
 833
 834 case 1:
 835 YY_RULE_SETUP
 836 #line 66 "cmCommandArgumentLexer.in.l"
 837 {
 838   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
 839   yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
 840   return cal_ENVCURLY;
 841 }
 842 case 2:
 843 YY_RULE_SETUP
 844 #line 72 "cmCommandArgumentLexer.in.l"
 845 {
 846   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
 847   yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
 848   return cal_NCURLY;
 849 }
 850 case 3:
 851 YY_RULE_SETUP
 852 #line 78 "cmCommandArgumentLexer.in.l"
 853 {
 854   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
 855   yyextra->AllocateParserType(yylvalp, yytext+1, strlen(yytext)-2);
 856   return cal_ATNAME;
 857 }
 858 case 4:
 859 YY_RULE_SETUP
 860 #line 84 "cmCommandArgumentLexer.in.l"
 861 {
 862   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
 863   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
 864   yylvalp->str = yyextra->DCURLYVariable;
 865   return cal_DCURLY;
 866 }
 867 case 5:
 868 YY_RULE_SETUP
 869 #line 91 "cmCommandArgumentLexer.in.l"
 870 {
 871   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
 872   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
 873   yylvalp->str = yyextra->RCURLYVariable;
 874   return cal_RCURLY;
 875 }
 876 case 6:
 877 YY_RULE_SETUP
 878 #line 98 "cmCommandArgumentLexer.in.l"
 879 {
 880   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
 881   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
 882   yylvalp->str = yyextra->ATVariable;
 883   return cal_AT;
 884 }
 885 case 7:
 886 YY_RULE_SETUP
 887 #line 105 "cmCommandArgumentLexer.in.l"
 888 {
 889   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
 890   yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
 891   return cal_NAME;
 892 }
 893 case 8:
 894 YY_RULE_SETUP
 895 #line 111 "cmCommandArgumentLexer.in.l"
 896 {
 897   if ( !yyextra->HandleEscapeSymbol(yylvalp, *(yytext+1)) )
 898     {
 899     return cal_ERROR;
 900     }
 901   return cal_SYMBOL;
 902 }
 903 case 9:
 904 /* rule 9 can match eol */
 905 YY_RULE_SETUP
 906 #line 119 "cmCommandArgumentLexer.in.l"
 907 {
 908   //std::cerr << __LINE__ << " here: [" << yytext << "]" << std::endl;
 909   yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
 910   return cal_SYMBOL;
 911 }
 912 case 10:
 913 YY_RULE_SETUP
 914 #line 125 "cmCommandArgumentLexer.in.l"
 915 {
 916   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
 917   yylvalp->str = yyextra->DOLLARVariable;
 918   return cal_DOLLAR;
 919 }
 920 case 11:
 921 YY_RULE_SETUP
 922 #line 131 "cmCommandArgumentLexer.in.l"
 923 {
 924   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
 925   yylvalp->str = yyextra->LCURLYVariable;
 926   return cal_LCURLY;
 927 }
 928 case 12:
 929 YY_RULE_SETUP
 930 #line 137 "cmCommandArgumentLexer.in.l"
 931 {
 932   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
 933   yylvalp->str = yyextra->BSLASHVariable;
 934   return cal_BSLASH;
 935 }
 936 case 13:
 937 YY_RULE_SETUP
 938 #line 143 "cmCommandArgumentLexer.in.l"
 939 {
 940   //yyextra->AllocateParserType(yylvalp, yytext, strlen(yytext));
 941   yylvalp->str = yyextra->BSLASHVariable;
 942   return cal_SYMBOL;
 943 }
 944 case 14:
 945 YY_RULE_SETUP
 946 #line 149 "cmCommandArgumentLexer.in.l"
 947 ECHO;
 948         YY_BREAK
 949 #line 943 "cmCommandArgumentLexer.cxx"
 950 case YY_STATE_EOF(INITIAL):
 951 case YY_STATE_EOF(ESCAPES):
 952 case YY_STATE_EOF(NOESCAPES):
 953         yyterminate();
 954
 955         case YY_END_OF_BUFFER:
 956                 {
 957                 /* Amount of text matched not including the EOB char. */
 958                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
 959
 960                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
 961                 *yy_cp = yyg->yy_hold_char;
 962                 YY_RESTORE_YY_MORE_OFFSET
 963
 964                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
 965                         {
 966                         /* We're scanning a new file or input source.  It's
 967                          * possible that this happened because the user
 968                          * just pointed yyin at a new source and called
 969                          * cmCommandArgument_yylex().  If so, then we have to assure
 970                          * consistency between YY_CURRENT_BUFFER and our
 971                          * globals.  Here is the right place to do so, because
 972                          * this is the first action (other than possibly a
 973                          * back-up) that will match for the new input source.
 974                          */
 975                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
 976                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
 977                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
 978                         }
 979
 980                 /* Note that here we test for yy_c_buf_p "<=" to the position
 981                  * of the first EOB in the buffer, since yy_c_buf_p will
 982                  * already have been incremented past the NUL character
 983                  * (since all states make transitions on EOB to the
 984                  * end-of-buffer state).  Contrast this with the test
 985                  * in input().
 986                  */
 987                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
 988                         { /* This was really a NUL. */
 989                         yy_state_type yy_next_state;
 990
 991                         yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
 992
 993                         yy_current_state = yy_get_previous_state( yyscanner );
 994
 995                         /* Okay, we're now positioned to make the NUL
 996                          * transition.  We couldn't have
 997                          * yy_get_previous_state() go ahead and do it
 998                          * for us because it doesn't know how to deal
 999                          * with the possibility of jamming (and we don't
1000                          * want to build jamming into it because then it
1001                          * will run more slowly).
1002                          */
1003
1004                         yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1005
1006                         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1007
1008                         if ( yy_next_state )
1009                                 {
1010                                 /* Consume the NUL. */
1011                                 yy_cp = ++yyg->yy_c_buf_p;
1012                                 yy_current_state = yy_next_state;
1013                                 goto yy_match;
1014                                 }
1015
1016                         else
1017                                 {
1018                                 yy_cp = yyg->yy_c_buf_p;
1019                                 goto yy_find_action;
1020                                 }
1021                         }
1022
1023                 else switch ( yy_get_next_buffer( yyscanner ) )
1024                         {
1025                         case EOB_ACT_END_OF_FILE:
1026                                 {
1027                                 yyg->yy_did_buffer_switch_on_eof = 0;
1028
1029                                 if ( cmCommandArgument_yywrap(yyscanner ) )
1030                                         {
1031                                         /* Note: because we've taken care in
1032                                          * yy_get_next_buffer() to have set up
1033                                          * yytext, we can now set up
1034                                          * yy_c_buf_p so that if some total
1035                                          * hoser (like flex itself) wants to
1036                                          * call the scanner after we return the
1037                                          * YY_NULL, it'll still work - another
1038                                          * YY_NULL will get returned.
1039                                          */
1040                                         yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1041
1042                                         yy_act = YY_STATE_EOF(YY_START);
1043                                         goto do_action;
1044                                         }
1045
1046                                 else
1047                                         {
1048                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
1049                                                 YY_NEW_FILE;
1050                                         }
1051                                 break;
1052                                 }
1053
1054                         case EOB_ACT_CONTINUE_SCAN:
1055                                 yyg->yy_c_buf_p =
1056                                         yyg->yytext_ptr + yy_amount_of_matched_text;
1057
1058                                 yy_current_state = yy_get_previous_state( yyscanner );
1059
1060                                 yy_cp = yyg->yy_c_buf_p;
1061                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1062                                 goto yy_match;
1063
1064                         case EOB_ACT_LAST_MATCH:
1065                                 yyg->yy_c_buf_p =
1066                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1067
1068                                 yy_current_state = yy_get_previous_state( yyscanner );
1069
1070                                 yy_cp = yyg->yy_c_buf_p;
1071                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1072                                 goto yy_find_action;
1073                         }
1074                 break;
1075                 }
1076
1077         default:
1078                 YY_FATAL_ERROR(
1079                         "fatal flex scanner internal error--no action found" );
1080         } /* end of action switch */
1081                 } /* end of scanning one token */
1082 return 0; /* this should not happend but it should silence a warning */
1083 } /* end of cmCommandArgument_yylex */
1084
1085 /* yy_get_next_buffer - try to read in a new buffer
1086  *
1087  * Returns a code representing an action:
1088  *      EOB_ACT_LAST_MATCH -
1089  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1090  *      EOB_ACT_END_OF_FILE - end of file
1091  */
1092 static int yy_get_next_buffer (yyscan_t yyscanner)
1093 {
1094     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1095         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1096         register char *source = yyg->yytext_ptr;
1097         register int number_to_move, i;
1098         int ret_val;
1099
1100         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1101                 YY_FATAL_ERROR(
1102                 "fatal flex scanner internal error--end of buffer missed" );
1103
1104         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1105                 { /* Don't try to fill the buffer, so this is an EOF. */
1106                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1107                         {
1108                         /* We matched a single character, the EOB, so
1109                          * treat this as a final EOF.
1110                          */
1111                         return EOB_ACT_END_OF_FILE;
1112                         }
1113
1114                 else
1115                         {
1116                         /* We matched some text prior to the EOB, first
1117                          * process it.
1118                          */
1119                         return EOB_ACT_LAST_MATCH;
1120                         }
1121                 }
1122
1123         /* Try to read more data. */
1124
1125         /* First move last chars to start of buffer. */
1126         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1127
1128         for ( i = 0; i < number_to_move; ++i )
1129                 *(dest++) = *(source++);
1130
1131         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1132                 /* don't do the read, it's not guaranteed to return an EOF,
1133                  * just force an EOF
1134                  */
1135                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1136
1137         else
1138                 {
1139                         int num_to_read =
1140                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1141
1142                 while ( num_to_read <= 0 )
1143                         { /* Not enough room in the buffer - grow it. */
1144
1145                         /* just a shorter name for the current buffer */
1146                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1147
1148                         int yy_c_buf_p_offset =
1149                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1150
1151                         if ( b->yy_is_our_buffer )
1152                                 {
1153                                 int new_size = b->yy_buf_size * 2;
1154
1155                                 if ( new_size <= 0 )
1156                                         b->yy_buf_size += b->yy_buf_size / 8;
1157                                 else
1158                                         b->yy_buf_size *= 2;
1159
1160                                 b->yy_ch_buf = (char *)
1161                                         /* Include room in for 2 EOB chars. */
1162                                         cmCommandArgument_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1163                                 }
1164                         else
1165                                 /* Can't grow it, we don't own it. */
1166                                 b->yy_ch_buf = 0;
1167
1168                         if ( ! b->yy_ch_buf )
1169                                 YY_FATAL_ERROR(
1170                                 "fatal error - scanner input buffer overflow" );
1171
1172                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1173
1174                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1175                                                 number_to_move - 1;
1176
1177                         }
1178
1179                 if ( num_to_read > YY_READ_BUF_SIZE )
1180                         num_to_read = YY_READ_BUF_SIZE;
1181
1182                 /* Read in more data. */
1183                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1184                         yyg->yy_n_chars, (size_t) num_to_read );
1185
1186                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1187                 }
1188
1189         if ( yyg->yy_n_chars == 0 )
1190                 {
1191                 if ( number_to_move == YY_MORE_ADJ )
1192                         {
1193                         ret_val = EOB_ACT_END_OF_FILE;
1194                         cmCommandArgument_yyrestart(yyin  ,yyscanner);
1195                         }
1196
1197                 else
1198                         {
1199                         ret_val = EOB_ACT_LAST_MATCH;
1200                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1201                                 YY_BUFFER_EOF_PENDING;
1202                         }
1203                 }
1204
1205         else
1206                 ret_val = EOB_ACT_CONTINUE_SCAN;
1207
1208         if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1209                 /* Extend the array by 50%, plus the number we really need. */
1210                 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1211                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) cmCommandArgument_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1212                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1213                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1214         }
1215
1216         yyg->yy_n_chars += number_to_move;
1217         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1218         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1219
1220         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1221
1222         return ret_val;
1223 }
1224
1225 /* yy_get_previous_state - get the state just before the EOB char was reached */
1226
1227     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1228 {
1229         register yy_state_type yy_current_state;
1230         register char *yy_cp;
1231     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1232
1233         yy_current_state = yyg->yy_start;
1234
1235         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1236                 {
1237                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1238                 if ( yy_accept[yy_current_state] )
1239                         {
1240                         yyg->yy_last_accepting_state = yy_current_state;
1241                         yyg->yy_last_accepting_cpos = yy_cp;
1242                         }
1243                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1244                         {
1245                         yy_current_state = (int) yy_def[yy_current_state];
1246                         if ( yy_current_state >= 30 )
1247                                 yy_c = yy_meta[(unsigned int) yy_c];
1248                         }
1249                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1250                 }
1251
1252         return yy_current_state;
1253 }
1254
1255 /* yy_try_NUL_trans - try to make a transition on the NUL character
1256  *
1257  * synopsis
1258  *      next_state = yy_try_NUL_trans( current_state );
1259  */
1260     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
1261 {
1262         register int yy_is_jam;
1263     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
1264         register char *yy_cp = yyg->yy_c_buf_p;
1265
1266         register YY_CHAR yy_c = 1;
1267         if ( yy_accept[yy_current_state] )
1268                 {
1269                 yyg->yy_last_accepting_state = yy_current_state;
1270                 yyg->yy_last_accepting_cpos = yy_cp;
1271                 }
1272         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1273                 {
1274                 yy_current_state = (int) yy_def[yy_current_state];
1275                 if ( yy_current_state >= 30 )
1276                         yy_c = yy_meta[(unsigned int) yy_c];
1277                 }
1278         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1279         yy_is_jam = (yy_current_state == 29);
1280
1281         return yy_is_jam ? 0 : yy_current_state;
1282 }
1283
1284 #ifndef YY_NO_INPUT
1285 #ifdef __cplusplus
1286     static int yyinput (yyscan_t yyscanner)
1287 #else
1288     static int input  (yyscan_t yyscanner)
1289 #endif
1290
1291 {
1292         int c;
1293     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1294
1295         *yyg->yy_c_buf_p = yyg->yy_hold_char;
1296
1297         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1298                 {
1299                 /* yy_c_buf_p now points to the character we want to return.
1300                  * If this occurs *before* the EOB characters, then it's a
1301                  * valid NUL; if not, then we've hit the end of the buffer.
1302                  */
1303                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1304                         /* This was really a NUL. */
1305                         *yyg->yy_c_buf_p = '\0';
1306
1307                 else
1308                         { /* need more input */
1309                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1310                         ++yyg->yy_c_buf_p;
1311
1312                         switch ( yy_get_next_buffer( yyscanner ) )
1313                                 {
1314                                 case EOB_ACT_LAST_MATCH:
1315                                         /* This happens because yy_g_n_b()
1316                                          * sees that we've accumulated a
1317                                          * token and flags that we need to
1318                                          * try matching the token before
1319                                          * proceeding.  But for input(),
1320                                          * there's no matching to consider.
1321                                          * So convert the EOB_ACT_LAST_MATCH
1322                                          * to EOB_ACT_END_OF_FILE.
1323                                          */
1324
1325                                         /* Reset buffer status. */
1326                                         cmCommandArgument_yyrestart(yyin ,yyscanner);
1327
1328                                         /*FALLTHROUGH*/
1329
1330                                 case EOB_ACT_END_OF_FILE:
1331                                         {
1332                                         if ( cmCommandArgument_yywrap(yyscanner ) )
1333                                                 return EOF;
1334
1335                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
1336                                                 YY_NEW_FILE;
1337 #ifdef __cplusplus
1338                                         return yyinput(yyscanner);
1339 #else
1340                                         return input(yyscanner);
1341 #endif
1342                                         }
1343
1344                                 case EOB_ACT_CONTINUE_SCAN:
1345                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1346                                         break;
1347                                 }
1348                         }
1349                 }
1350
1351         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
1352         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
1353         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1354
1355         return c;
1356 }
1357 #endif  /* ifndef YY_NO_INPUT */
1358
1359 /** Immediately switch to a different input stream.
1360  * @param input_file A readable stream.
1361  * @param yyscanner The scanner object.
1362  * @note This function does not reset the start condition to @c INITIAL .
1363  */
1364     void cmCommandArgument_yyrestart  (FILE * input_file , yyscan_t yyscanner)
1365 {
1366     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1367
1368         if ( ! YY_CURRENT_BUFFER ){
1369         cmCommandArgument_yyensure_buffer_stack (yyscanner);
1370                 YY_CURRENT_BUFFER_LVALUE =
1371             cmCommandArgument_yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1372         }
1373
1374         cmCommandArgument_yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1375         cmCommandArgument_yy_load_buffer_state(yyscanner );
1376 }
1377
1378 /** Switch to a different input buffer.
1379  * @param new_buffer The new input buffer.
1380  * @param yyscanner The scanner object.
1381  */
1382     void cmCommandArgument_yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
1383 {
1384     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1385
1386         /* TODO. We should be able to replace this entire function body
1387          * with
1388          *              cmCommandArgument_yypop_buffer_state();
1389          *              cmCommandArgument_yypush_buffer_state(new_buffer);
1390      */
1391         cmCommandArgument_yyensure_buffer_stack (yyscanner);
1392         if ( YY_CURRENT_BUFFER == new_buffer )
1393                 return;
1394
1395         if ( YY_CURRENT_BUFFER )
1396                 {
1397                 /* Flush out information for old buffer. */
1398                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1399                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1400                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1401                 }
1402
1403         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1404         cmCommandArgument_yy_load_buffer_state(yyscanner );
1405
1406         /* We don't actually know whether we did this switch during
1407          * EOF (cmCommandArgument_yywrap()) processing, but the only time this flag
1408          * is looked at is after cmCommandArgument_yywrap() is called, so it's safe
1409          * to go ahead and always set it.
1410          */
1411         yyg->yy_did_buffer_switch_on_eof = 1;
1412 }
1413
1414 static void cmCommandArgument_yy_load_buffer_state  (yyscan_t yyscanner)
1415 {
1416     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1417         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1418         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1419         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1420         yyg->yy_hold_char = *yyg->yy_c_buf_p;
1421 }
1422
1423 /** Allocate and initialize an input buffer state.
1424  * @param file A readable stream.
1425  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1426  * @param yyscanner The scanner object.
1427  * @return the allocated buffer state.
1428  */
1429     YY_BUFFER_STATE cmCommandArgument_yy_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
1430 {
1431         YY_BUFFER_STATE b;
1432
1433         b = (YY_BUFFER_STATE) cmCommandArgument_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1434         if ( ! b )
1435                 YY_FATAL_ERROR( "out of dynamic memory in cmCommandArgument_yy_create_buffer()" );
1436
1437         b->yy_buf_size = size;
1438
1439         /* yy_ch_buf has to be 2 characters longer than the size given because
1440          * we need to put in 2 end-of-buffer characters.
1441          */
1442         b->yy_ch_buf = (char *) cmCommandArgument_yyalloc(b->yy_buf_size + 2 ,yyscanner );
1443         if ( ! b->yy_ch_buf )
1444                 YY_FATAL_ERROR( "out of dynamic memory in cmCommandArgument_yy_create_buffer()" );
1445
1446         b->yy_is_our_buffer = 1;
1447
1448         cmCommandArgument_yy_init_buffer(b,file ,yyscanner);
1449
1450         return b;
1451 }
1452
1453 /** Destroy the buffer.
1454  * @param b a buffer created with cmCommandArgument_yy_create_buffer()
1455  * @param yyscanner The scanner object.
1456  */
1457     void cmCommandArgument_yy_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1458 {
1459     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1460
1461         if ( ! b )
1462                 return;
1463
1464         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1465                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1466
1467         if ( b->yy_is_our_buffer )
1468                 cmCommandArgument_yyfree((void *) b->yy_ch_buf ,yyscanner );
1469
1470         cmCommandArgument_yyfree((void *) b ,yyscanner );
1471 }
1472
1473 #ifndef __cplusplus
1474 extern int isatty (int );
1475 #endif /* __cplusplus */
1476
1477 /* Initializes or reinitializes a buffer.
1478  * This function is sometimes called more than once on the same buffer,
1479  * such as during a cmCommandArgument_yyrestart() or at EOF.
1480  */
1481     static void cmCommandArgument_yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
1482
1483 {
1484         int oerrno = errno;
1485     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1486
1487         cmCommandArgument_yy_flush_buffer(b ,yyscanner);
1488
1489         b->yy_input_file = file;
1490         b->yy_fill_buffer = 1;
1491
1492     /* If b is the current buffer, then cmCommandArgument_yy_init_buffer was _probably_
1493      * called from cmCommandArgument_yyrestart() or through yy_get_next_buffer.
1494      * In that case, we don't want to reset the lineno or column.
1495      */
1496     if (b != YY_CURRENT_BUFFER){
1497         b->yy_bs_lineno = 1;
1498         b->yy_bs_column = 0;
1499     }
1500
1501         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1502
1503         errno = oerrno;
1504 }
1505
1506 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1507  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1508  * @param yyscanner The scanner object.
1509  */
1510     void cmCommandArgument_yy_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
1511 {
1512     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1513         if ( ! b )
1514                 return;
1515
1516         b->yy_n_chars = 0;
1517
1518         /* We always need two end-of-buffer characters.  The first causes
1519          * a transition to the end-of-buffer state.  The second causes
1520          * a jam in that state.
1521          */
1522         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1523         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1524
1525         b->yy_buf_pos = &b->yy_ch_buf[0];
1526
1527         b->yy_at_bol = 1;
1528         b->yy_buffer_status = YY_BUFFER_NEW;
1529
1530         if ( b == YY_CURRENT_BUFFER )
1531                 cmCommandArgument_yy_load_buffer_state(yyscanner );
1532 }
1533
1534 /** Pushes the new state onto the stack. The new state becomes
1535  *  the current state. This function will allocate the stack
1536  *  if necessary.
1537  *  @param new_buffer The new state.
1538  *  @param yyscanner The scanner object.
1539  */
1540 void cmCommandArgument_yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1541 {
1542     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1543         if (new_buffer == NULL)
1544                 return;
1545
1546         cmCommandArgument_yyensure_buffer_stack(yyscanner);
1547
1548         /* This block is copied from cmCommandArgument_yy_switch_to_buffer. */
1549         if ( YY_CURRENT_BUFFER )
1550                 {
1551                 /* Flush out information for old buffer. */
1552                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1553                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1554                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1555                 }
1556
1557         /* Only push if top exists. Otherwise, replace top. */
1558         if (YY_CURRENT_BUFFER)
1559                 yyg->yy_buffer_stack_top++;
1560         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1561
1562         /* copied from cmCommandArgument_yy_switch_to_buffer. */
1563         cmCommandArgument_yy_load_buffer_state(yyscanner );
1564         yyg->yy_did_buffer_switch_on_eof = 1;
1565 }
1566
1567 /** Removes and deletes the top of the stack, if present.
1568  *  The next element becomes the new top.
1569  *  @param yyscanner The scanner object.
1570  */
1571 void cmCommandArgument_yypop_buffer_state (yyscan_t yyscanner)
1572 {
1573     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1574         if (!YY_CURRENT_BUFFER)
1575                 return;
1576
1577         cmCommandArgument_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1578         YY_CURRENT_BUFFER_LVALUE = NULL;
1579         if (yyg->yy_buffer_stack_top > 0)
1580                 --yyg->yy_buffer_stack_top;
1581
1582         if (YY_CURRENT_BUFFER) {
1583                 cmCommandArgument_yy_load_buffer_state(yyscanner );
1584                 yyg->yy_did_buffer_switch_on_eof = 1;
1585         }
1586 }
1587
1588 /* Allocates the stack if it does not exist.
1589  *  Guarantees space for at least one push.
1590  */
1591 static void cmCommandArgument_yyensure_buffer_stack (yyscan_t yyscanner)
1592 {
1593         int num_to_alloc;
1594     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1595
1596         if (!yyg->yy_buffer_stack) {
1597
1598                 /* First allocation is just for 2 elements, since we don't know if this
1599                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1600                  * immediate realloc on the next call.
1601          */
1602                 num_to_alloc = 1;
1603                 yyg->yy_buffer_stack = (struct yy_buffer_state**)cmCommandArgument_yyalloc
1604                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1605                                                                 , yyscanner);
1606                 if ( ! yyg->yy_buffer_stack )
1607                         YY_FATAL_ERROR( "out of dynamic memory in cmCommandArgument_yyensure_buffer_stack()" );
1608
1609                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1610
1611                 yyg->yy_buffer_stack_max = num_to_alloc;
1612                 yyg->yy_buffer_stack_top = 0;
1613                 return;
1614         }
1615
1616         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
1617
1618                 /* Increase the buffer to prepare for a possible push. */
1619                 int grow_size = 8 /* arbitrary grow size */;
1620
1621                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
1622                 yyg->yy_buffer_stack = (struct yy_buffer_state**)cmCommandArgument_yyrealloc
1623                                                                 (yyg->yy_buffer_stack,
1624                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1625                                                                 , yyscanner);
1626                 if ( ! yyg->yy_buffer_stack )
1627                         YY_FATAL_ERROR( "out of dynamic memory in cmCommandArgument_yyensure_buffer_stack()" );
1628
1629                 /* zero only the new slots.*/
1630                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
1631                 yyg->yy_buffer_stack_max = num_to_alloc;
1632         }
1633 }
1634
1635 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1636  * @param base the character buffer
1637  * @param size the size in bytes of the character buffer
1638  * @param yyscanner The scanner object.
1639  * @return the newly allocated buffer state object.
1640  */
1641 YY_BUFFER_STATE cmCommandArgument_yy_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
1642 {
1643         YY_BUFFER_STATE b;
1644
1645         if ( size < 2 ||
1646              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1647              base[size-1] != YY_END_OF_BUFFER_CHAR )
1648                 /* They forgot to leave room for the EOB's. */
1649                 return 0;
1650
1651         b = (YY_BUFFER_STATE) cmCommandArgument_yyalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
1652         if ( ! b )
1653                 YY_FATAL_ERROR( "out of dynamic memory in cmCommandArgument_yy_scan_buffer()" );
1654
1655         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1656         b->yy_buf_pos = b->yy_ch_buf = base;
1657         b->yy_is_our_buffer = 0;
1658         b->yy_input_file = 0;
1659         b->yy_n_chars = b->yy_buf_size;
1660         b->yy_is_interactive = 0;
1661         b->yy_at_bol = 1;
1662         b->yy_fill_buffer = 0;
1663         b->yy_buffer_status = YY_BUFFER_NEW;
1664
1665         cmCommandArgument_yy_switch_to_buffer(b ,yyscanner );
1666
1667         return b;
1668 }
1669
1670 /** Setup the input buffer state to scan a string. The next call to cmCommandArgument_yylex() will
1671  * scan from a @e copy of @a str.
1672  * @param yystr a NUL-terminated string to scan
1673  * @param yyscanner The scanner object.
1674  * @return the newly allocated buffer state object.
1675  * @note If you want to scan bytes that may contain NUL values, then use
1676  *       cmCommandArgument_yy_scan_bytes() instead.
1677  */
1678 YY_BUFFER_STATE cmCommandArgument_yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
1679 {
1680
1681         return cmCommandArgument_yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
1682 }
1683
1684 /** Setup the input buffer state to scan the given bytes. The next call to cmCommandArgument_yylex() will
1685  * scan from a @e copy of @a bytes.
1686  * @param bytes the byte buffer to scan
1687  * @param len the number of bytes in the buffer pointed to by @a bytes.
1688  * @param yyscanner The scanner object.
1689  * @return the newly allocated buffer state object.
1690  */
1691 YY_BUFFER_STATE cmCommandArgument_yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
1692 {
1693         YY_BUFFER_STATE b;
1694         char *buf;
1695         yy_size_t n;
1696         int i;
1697
1698         /* Get memory for full buffer, including space for trailing EOB's. */
1699         n = _yybytes_len + 2;
1700         buf = (char *) cmCommandArgument_yyalloc(n ,yyscanner );
1701         if ( ! buf )
1702                 YY_FATAL_ERROR( "out of dynamic memory in cmCommandArgument_yy_scan_bytes()" );
1703
1704         for ( i = 0; i < _yybytes_len; ++i )
1705                 buf[i] = yybytes[i];
1706
1707         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1708
1709         b = cmCommandArgument_yy_scan_buffer(buf,n ,yyscanner);
1710         if ( ! b )
1711                 YY_FATAL_ERROR( "bad buffer in cmCommandArgument_yy_scan_bytes()" );
1712
1713         /* It's okay to grow etc. this buffer, and we should throw it
1714          * away when we're done.
1715          */
1716         b->yy_is_our_buffer = 1;
1717
1718         return b;
1719 }
1720
1721 #ifndef YY_EXIT_FAILURE
1722 #define YY_EXIT_FAILURE 2
1723 #endif
1724
1725 static void yy_fatal_error (yyconst char* msg , yyscan_t)
1726 {
1727         (void) fprintf( stderr, "%s\n", msg );
1728         exit( YY_EXIT_FAILURE );
1729 }
1730
1731 /* Redefine yyless() so it works in section 3 code. */
1732
1733 #undef yyless
1734 #define yyless(n) \
1735         do \
1736                 { \
1737                 /* Undo effects of setting up yytext. */ \
1738         int yyless_macro_arg = (n); \
1739         YY_LESS_LINENO(yyless_macro_arg);\
1740                 yytext[yyleng] = yyg->yy_hold_char; \
1741                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1742                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1743                 *yyg->yy_c_buf_p = '\0'; \
1744                 yyleng = yyless_macro_arg; \
1745                 } \
1746         while ( 0 )
1747
1748 /* Accessor  methods (get/set functions) to struct members. */
1749
1750 /** Get the user-defined data for this scanner.
1751  * @param yyscanner The scanner object.
1752  */
1753 YY_EXTRA_TYPE cmCommandArgument_yyget_extra  (yyscan_t yyscanner)
1754 {
1755     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1756     return yyextra;
1757 }
1758
1759 /** Get the current line number.
1760  * @param yyscanner The scanner object.
1761  */
1762 int cmCommandArgument_yyget_lineno  (yyscan_t yyscanner)
1763 {
1764     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1765
1766         if (! YY_CURRENT_BUFFER)
1767             return 0;
1768
1769     return yylineno;
1770 }
1771
1772 /** Get the current column number.
1773  * @param yyscanner The scanner object.
1774  */
1775 int cmCommandArgument_yyget_column  (yyscan_t yyscanner)
1776 {
1777     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1778
1779         if (! YY_CURRENT_BUFFER)
1780             return 0;
1781
1782     return yycolumn;
1783 }
1784
1785 /** Get the input stream.
1786  * @param yyscanner The scanner object.
1787  */
1788 FILE *cmCommandArgument_yyget_in  (yyscan_t yyscanner)
1789 {
1790     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1791     return yyin;
1792 }
1793
1794 /** Get the output stream.
1795  * @param yyscanner The scanner object.
1796  */
1797 FILE *cmCommandArgument_yyget_out  (yyscan_t yyscanner)
1798 {
1799     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1800     return yyout;
1801 }
1802
1803 /** Get the length of the current token.
1804  * @param yyscanner The scanner object.
1805  */
1806 int cmCommandArgument_yyget_leng  (yyscan_t yyscanner)
1807 {
1808     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1809     return yyleng;
1810 }
1811
1812 /** Get the current token.
1813  * @param yyscanner The scanner object.
1814  */
1815
1816 char *cmCommandArgument_yyget_text  (yyscan_t yyscanner)
1817 {
1818     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1819     return yytext;
1820 }
1821
1822 /** Set the user-defined data. This data is never touched by the scanner.
1823  * @param user_defined The data to be associated with this scanner.
1824  * @param yyscanner The scanner object.
1825  */
1826 void cmCommandArgument_yyset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
1827 {
1828     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1829     yyextra = user_defined ;
1830 }
1831
1832 /** Set the current line number.
1833  * @param line_number
1834  * @param yyscanner The scanner object.
1835  */
1836 void cmCommandArgument_yyset_lineno (int  line_number , yyscan_t yyscanner)
1837 {
1838     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1839
1840         /* lineno is only valid if an input buffer exists. */
1841         if (! YY_CURRENT_BUFFER )
1842            yy_fatal_error( "cmCommandArgument_yyset_lineno called with no buffer" , yyscanner);
1843
1844     yylineno = line_number;
1845 }
1846
1847 /** Set the current column.
1848  * @param line_number
1849  * @param yyscanner The scanner object.
1850  */
1851 void cmCommandArgument_yyset_column (int  column_no , yyscan_t yyscanner)
1852 {
1853     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1854
1855         /* column is only valid if an input buffer exists. */
1856         if (! YY_CURRENT_BUFFER )
1857            yy_fatal_error( "cmCommandArgument_yyset_column called with no buffer" , yyscanner);
1858
1859     yycolumn = column_no;
1860 }
1861
1862 /** Set the input stream. This does not discard the current
1863  * input buffer.
1864  * @param in_str A readable stream.
1865  * @param yyscanner The scanner object.
1866  * @see cmCommandArgument_yy_switch_to_buffer
1867  */
1868 void cmCommandArgument_yyset_in (FILE *  in_str , yyscan_t yyscanner)
1869 {
1870     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1871     yyin = in_str ;
1872 }
1873
1874 void cmCommandArgument_yyset_out (FILE *  out_str , yyscan_t yyscanner)
1875 {
1876     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1877     yyout = out_str ;
1878 }
1879
1880 int cmCommandArgument_yyget_debug  (yyscan_t yyscanner)
1881 {
1882     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1883     return yy_flex_debug;
1884 }
1885
1886 void cmCommandArgument_yyset_debug (int  bdebug , yyscan_t yyscanner)
1887 {
1888     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1889     yy_flex_debug = bdebug ;
1890 }
1891
1892 /* Accessor methods for yylval and yylloc */
1893
1894 /* User-visible API */
1895
1896 /* cmCommandArgument_yylex_init is special because it creates the scanner itself, so it is
1897  * the ONLY reentrant function that doesn't take the scanner as the last argument.
1898  * That's why we explicitly handle the declaration, instead of using our macros.
1899  */
1900
1901 int cmCommandArgument_yylex_init(yyscan_t* ptr_yy_globals)
1902
1903 {
1904     if (ptr_yy_globals == NULL){
1905         errno = EINVAL;
1906         return 1;
1907     }
1908
1909     *ptr_yy_globals = (yyscan_t) cmCommandArgument_yyalloc ( sizeof( struct yyguts_t ), NULL );
1910
1911     if (*ptr_yy_globals == NULL){
1912         errno = ENOMEM;
1913         return 1;
1914     }
1915
1916     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
1917     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
1918
1919     return yy_init_globals ( *ptr_yy_globals );
1920 }
1921
1922 /* cmCommandArgument_yylex_init_extra has the same functionality as cmCommandArgument_yylex_init, but follows the
1923  * convention of taking the scanner as the last argument. Note however, that
1924  * this is a *pointer* to a scanner, as it will be allocated by this call (and
1925  * is the reason, too, why this function also must handle its own declaration).
1926  * The user defined value in the first argument will be available to cmCommandArgument_yyalloc in
1927  * the yyextra field.
1928  */
1929
1930 int cmCommandArgument_yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
1931
1932 {
1933     struct yyguts_t dummy_yyguts;
1934
1935     cmCommandArgument_yyset_extra (yy_user_defined, &dummy_yyguts);
1936
1937     if (ptr_yy_globals == NULL){
1938         errno = EINVAL;
1939         return 1;
1940     }
1941
1942     *ptr_yy_globals = (yyscan_t) cmCommandArgument_yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
1943
1944     if (*ptr_yy_globals == NULL){
1945         errno = ENOMEM;
1946         return 1;
1947     }
1948
1949     /* By setting to 0xAA, we expose bugs in
1950     yy_init_globals. Leave at 0x00 for releases. */
1951     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
1952
1953     cmCommandArgument_yyset_extra (yy_user_defined, *ptr_yy_globals);
1954
1955     return yy_init_globals ( *ptr_yy_globals );
1956 }
1957
1958 static int yy_init_globals (yyscan_t yyscanner)
1959 {
1960     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1961     /* Initialization is the same as for the non-reentrant scanner.
1962      * This function is called from cmCommandArgument_yylex_destroy(), so don't allocate here.
1963      */
1964
1965     yyg->yy_buffer_stack = 0;
1966     yyg->yy_buffer_stack_top = 0;
1967     yyg->yy_buffer_stack_max = 0;
1968     yyg->yy_c_buf_p = (char *) 0;
1969     yyg->yy_init = 0;
1970     yyg->yy_start = 0;
1971
1972     yyg->yy_start_stack_ptr = 0;
1973     yyg->yy_start_stack_depth = 0;
1974     yyg->yy_start_stack =  NULL;
1975
1976 /* Defined in main.c */
1977 #ifdef YY_STDINIT
1978     yyin = stdin;
1979     yyout = stdout;
1980 #else
1981     yyin = (FILE *) 0;
1982     yyout = (FILE *) 0;
1983 #endif
1984
1985     /* For future reference: Set errno on error, since we are called by
1986      * cmCommandArgument_yylex_init()
1987      */
1988     return 0;
1989 }
1990
1991 /* cmCommandArgument_yylex_destroy is for both reentrant and non-reentrant scanners. */
1992 int cmCommandArgument_yylex_destroy  (yyscan_t yyscanner)
1993 {
1994     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1995
1996     /* Pop the buffer stack, destroying each element. */
1997         while(YY_CURRENT_BUFFER){
1998                 cmCommandArgument_yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
1999                 YY_CURRENT_BUFFER_LVALUE = NULL;
2000                 cmCommandArgument_yypop_buffer_state(yyscanner);
2001         }
2002
2003         /* Destroy the stack itself. */
2004         cmCommandArgument_yyfree(yyg->yy_buffer_stack ,yyscanner);
2005         yyg->yy_buffer_stack = NULL;
2006
2007     /* Destroy the start condition stack. */
2008         cmCommandArgument_yyfree(yyg->yy_start_stack ,yyscanner );
2009         yyg->yy_start_stack = NULL;
2010
2011     /* Reset the globals. This is important in a non-reentrant scanner so the next time
2012      * cmCommandArgument_yylex() is called, initialization will occur. */
2013     yy_init_globals( yyscanner);
2014
2015     /* Destroy the main struct (reentrant only). */
2016     cmCommandArgument_yyfree ( yyscanner , yyscanner );
2017     yyscanner = NULL;
2018     return 0;
2019 }
2020
2021 /*
2022  * Internal utility routines.
2023  */
2024
2025 #ifndef yytext_ptr
2026 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2027 {
2028         register int i;
2029         for ( i = 0; i < n; ++i )
2030                 s1[i] = s2[i];
2031 }
2032 #endif
2033
2034 #ifdef YY_NEED_STRLEN
2035 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
2036 {
2037         register int n;
2038         for ( n = 0; s[n]; ++n )
2039                 ;
2040
2041         return n;
2042 }
2043 #endif
2044
2045 void *cmCommandArgument_yyalloc (yy_size_t  size , yyscan_t)
2046 {
2047         return (void *) malloc( size );
2048 }
2049
2050 void *cmCommandArgument_yyrealloc  (void * ptr, yy_size_t  size , yyscan_t)
2051 {
2052         /* The cast to (char *) in the following accommodates both
2053          * implementations that use char* generic pointers, and those
2054          * that use void* generic pointers.  It works with the latter
2055          * because both ANSI C and C++ allow castless assignment from
2056          * any pointer type to void*, and deal with argument conversions
2057          * as though doing an assignment.
2058          */
2059         return (void *) realloc( (char *) ptr, size );
2060 }
2061
2062 void cmCommandArgument_yyfree (void * ptr , yyscan_t)
2063 {
2064         free( (char *) ptr );   /* see cmCommandArgument_yyrealloc() for (char *) cast */
2065 }
2066
2067 #define YYTABLES_NAME "yytables"
2068
2069 #line 149 "cmCommandArgumentLexer.in.l"
2070
2071
2072
2073 /*--------------------------------------------------------------------------*/
2074 void cmCommandArgument_SetupEscapes(yyscan_t yyscanner, bool noEscapes)
2075 {
2076   /* Hack into the internal flex-generated scanner to set the state.  */
2077   struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2078   if(noEscapes)
2079     {
2080     BEGIN(NOESCAPES);
2081     }
2082   else
2083     {
2084     BEGIN(ESCAPES);
2085     }
2086 }
2087