diff options
Diffstat (limited to 'pkg/pcsc/patch')
| -rw-r--r-- | pkg/pcsc/patch/0001-Add-tokenparser.c-from-pcsc-1.8.17-distribution.patch | 2058 |
1 files changed, 2058 insertions, 0 deletions
diff --git a/pkg/pcsc/patch/0001-Add-tokenparser.c-from-pcsc-1.8.17-distribution.patch b/pkg/pcsc/patch/0001-Add-tokenparser.c-from-pcsc-1.8.17-distribution.patch new file mode 100644 index 00000000..9c99d360 --- /dev/null +++ b/pkg/pcsc/patch/0001-Add-tokenparser.c-from-pcsc-1.8.17-distribution.patch @@ -0,0 +1,2058 @@ +From 13f8dbbd6cd2de7ac0c0567df53b72e82bc21d2d Mon Sep 17 00:00:00 2001 +From: Michael Forney <mforney@mforney.org> +Date: Tue, 5 Jul 2016 23:13:48 -0700 +Subject: [PATCH] Add tokenparser.c from pcsc 1.8.17 distribution + +--- + src/tokenparser.c | 2039 +++++++++++++++++++++++++++++++++++++++++++++++++++++ + 1 file changed, 2039 insertions(+) + create mode 100644 src/tokenparser.c + +diff --git a/src/tokenparser.c b/src/tokenparser.c +new file mode 100644 +index 0000000..94cee67 +--- /dev/null ++++ b/src/tokenparser.c +@@ -0,0 +1,2039 @@ ++ ++#line 3 "tokenparser.c" ++ ++#define YY_INT_ALIGNED short int ++ ++/* A lexical scanner generated by flex */ ++ ++#define yy_create_buffer tp_create_buffer ++#define yy_delete_buffer tp_delete_buffer ++#define yy_flex_debug tp_flex_debug ++#define yy_init_buffer tp_init_buffer ++#define yy_flush_buffer tp_flush_buffer ++#define yy_load_buffer_state tp_load_buffer_state ++#define yy_switch_to_buffer tp_switch_to_buffer ++#define yyin tpin ++#define yyleng tpleng ++#define yylex tplex ++#define yylineno tplineno ++#define yyout tpout ++#define yyrestart tprestart ++#define yytext tptext ++#define yywrap tpwrap ++#define yyalloc tpalloc ++#define yyrealloc tprealloc ++#define yyfree tpfree ++ ++#define FLEX_SCANNER ++#define YY_FLEX_MAJOR_VERSION 2 ++#define YY_FLEX_MINOR_VERSION 5 ++#define YY_FLEX_SUBMINOR_VERSION 39 ++#if YY_FLEX_SUBMINOR_VERSION > 0 ++#define FLEX_BETA ++#endif ++ ++/* First, we deal with platform-specific or compiler-specific issues. */ ++ ++/* begin standard C headers. */ ++#include <stdio.h> ++#include <string.h> ++#include <errno.h> ++#include <stdlib.h> ++ ++/* end standard C headers. */ ++ ++/* flex integer type definitions */ ++ ++#ifndef FLEXINT_H ++#define FLEXINT_H ++ ++/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ ++ ++#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L ++ ++/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, ++ * if you want the limit (max/min) macros for int types. ++ */ ++#ifndef __STDC_LIMIT_MACROS ++#define __STDC_LIMIT_MACROS 1 ++#endif ++ ++#include <inttypes.h> ++typedef int8_t flex_int8_t; ++typedef uint8_t flex_uint8_t; ++typedef int16_t flex_int16_t; ++typedef uint16_t flex_uint16_t; ++typedef int32_t flex_int32_t; ++typedef uint32_t flex_uint32_t; ++#else ++typedef signed char flex_int8_t; ++typedef short int flex_int16_t; ++typedef int flex_int32_t; ++typedef unsigned char flex_uint8_t; ++typedef unsigned short int flex_uint16_t; ++typedef unsigned int flex_uint32_t; ++ ++/* Limits of integral types. */ ++#ifndef INT8_MIN ++#define INT8_MIN (-128) ++#endif ++#ifndef INT16_MIN ++#define INT16_MIN (-32767-1) ++#endif ++#ifndef INT32_MIN ++#define INT32_MIN (-2147483647-1) ++#endif ++#ifndef INT8_MAX ++#define INT8_MAX (127) ++#endif ++#ifndef INT16_MAX ++#define INT16_MAX (32767) ++#endif ++#ifndef INT32_MAX ++#define INT32_MAX (2147483647) ++#endif ++#ifndef UINT8_MAX ++#define UINT8_MAX (255U) ++#endif ++#ifndef UINT16_MAX ++#define UINT16_MAX (65535U) ++#endif ++#ifndef UINT32_MAX ++#define UINT32_MAX (4294967295U) ++#endif ++ ++#endif /* ! C99 */ ++ ++#endif /* ! FLEXINT_H */ ++ ++#ifdef __cplusplus ++ ++/* The "const" storage-class-modifier is valid. */ ++#define YY_USE_CONST ++ ++#else /* ! __cplusplus */ ++ ++/* C99 requires __STDC__ to be defined as 1. */ ++#if defined (__STDC__) ++ ++#define YY_USE_CONST ++ ++#endif /* defined (__STDC__) */ ++#endif /* ! __cplusplus */ ++ ++#ifdef YY_USE_CONST ++#define yyconst const ++#else ++#define yyconst ++#endif ++ ++/* Returned upon end-of-file. */ ++#define YY_NULL 0 ++ ++/* Promotes a possibly negative, possibly signed char to an unsigned ++ * integer for use as an array index. If the signed char is negative, ++ * we want to instead treat it as an 8-bit unsigned char, hence the ++ * double cast. ++ */ ++#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) ++ ++/* Enter a start condition. This macro really ought to take a parameter, ++ * but we do it the disgusting crufty way forced on us by the ()-less ++ * definition of BEGIN. ++ */ ++#define BEGIN (yy_start) = 1 + 2 * ++ ++/* Translate the current start state into a value that can be later handed ++ * to BEGIN to return to the state. The YYSTATE alias is for lex ++ * compatibility. ++ */ ++#define YY_START (((yy_start) - 1) / 2) ++#define YYSTATE YY_START ++ ++/* Action number for EOF rule of a given start state. */ ++#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) ++ ++/* Special action meaning "start processing a new file". */ ++#define YY_NEW_FILE tprestart(tpin ) ++ ++#define YY_END_OF_BUFFER_CHAR 0 ++ ++/* Size of default input buffer. */ ++#ifndef YY_BUF_SIZE ++#ifdef __ia64__ ++/* On IA-64, the buffer size is 16k, not 8k. ++ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. ++ * Ditto for the __ia64__ case accordingly. ++ */ ++#define YY_BUF_SIZE 32768 ++#else ++#define YY_BUF_SIZE 16384 ++#endif /* __ia64__ */ ++#endif ++ ++/* The state buf must be large enough to hold one state per character in the main buffer. ++ */ ++#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) ++ ++#ifndef YY_TYPEDEF_YY_BUFFER_STATE ++#define YY_TYPEDEF_YY_BUFFER_STATE ++typedef struct yy_buffer_state *YY_BUFFER_STATE; ++#endif ++ ++#ifndef YY_TYPEDEF_YY_SIZE_T ++#define YY_TYPEDEF_YY_SIZE_T ++typedef size_t yy_size_t; ++#endif ++ ++extern yy_size_t tpleng; ++ ++extern FILE *tpin, *tpout; ++ ++#define EOB_ACT_CONTINUE_SCAN 0 ++#define EOB_ACT_END_OF_FILE 1 ++#define EOB_ACT_LAST_MATCH 2 ++ ++ #define YY_LESS_LINENO(n) ++ #define YY_LINENO_REWIND_TO(ptr) ++ ++/* Return all but the first "n" matched characters back to the input stream. */ ++#define yyless(n) \ ++ do \ ++ { \ ++ /* Undo effects of setting up tptext. */ \ ++ int yyless_macro_arg = (n); \ ++ YY_LESS_LINENO(yyless_macro_arg);\ ++ *yy_cp = (yy_hold_char); \ ++ YY_RESTORE_YY_MORE_OFFSET \ ++ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ ++ YY_DO_BEFORE_ACTION; /* set up tptext again */ \ ++ } \ ++ while ( 0 ) ++ ++#define unput(c) yyunput( c, (yytext_ptr) ) ++ ++#ifndef YY_STRUCT_YY_BUFFER_STATE ++#define YY_STRUCT_YY_BUFFER_STATE ++struct yy_buffer_state ++ { ++ FILE *yy_input_file; ++ ++ char *yy_ch_buf; /* input buffer */ ++ char *yy_buf_pos; /* current position in input buffer */ ++ ++ /* Size of input buffer in bytes, not including room for EOB ++ * characters. ++ */ ++ yy_size_t yy_buf_size; ++ ++ /* Number of characters read into yy_ch_buf, not including EOB ++ * characters. ++ */ ++ yy_size_t yy_n_chars; ++ ++ /* Whether we "own" the buffer - i.e., we know we created it, ++ * and can realloc() it to grow it, and should free() it to ++ * delete it. ++ */ ++ int yy_is_our_buffer; ++ ++ /* Whether this is an "interactive" input source; if so, and ++ * if we're using stdio for input, then we want to use getc() ++ * instead of fread(), to make sure we stop fetching input after ++ * each newline. ++ */ ++ int yy_is_interactive; ++ ++ /* Whether we're considered to be at the beginning of a line. ++ * If so, '^' rules will be active on the next match, otherwise ++ * not. ++ */ ++ int yy_at_bol; ++ ++ int yy_bs_lineno; /**< The line count. */ ++ int yy_bs_column; /**< The column count. */ ++ ++ /* Whether to try to fill the input buffer when we reach the ++ * end of it. ++ */ ++ int yy_fill_buffer; ++ ++ int yy_buffer_status; ++ ++#define YY_BUFFER_NEW 0 ++#define YY_BUFFER_NORMAL 1 ++ /* When an EOF's been seen but there's still some text to process ++ * then we mark the buffer as YY_EOF_PENDING, to indicate that we ++ * shouldn't try reading from the input source any more. We might ++ * still have a bunch of tokens to match, though, because of ++ * possible backing-up. ++ * ++ * When we actually see the EOF, we change the status to "new" ++ * (via tprestart()), so that the user can continue scanning by ++ * just pointing tpin at a new input file. ++ */ ++#define YY_BUFFER_EOF_PENDING 2 ++ ++ }; ++#endif /* !YY_STRUCT_YY_BUFFER_STATE */ ++ ++/* Stack of input buffers. */ ++static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ ++static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ ++static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ ++ ++/* We provide macros for accessing buffer states in case in the ++ * future we want to put the buffer states in a more general ++ * "scanner state". ++ * ++ * Returns the top of the stack, or NULL. ++ */ ++#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ++ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ ++ : NULL) ++ ++/* Same as previous macro, but useful when we know that the buffer stack is not ++ * NULL or when we need an lvalue. For internal use only. ++ */ ++#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] ++ ++/* yy_hold_char holds the character lost when tptext is formed. */ ++static char yy_hold_char; ++static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ ++yy_size_t tpleng; ++ ++/* Points to current character in buffer. */ ++static char *yy_c_buf_p = (char *) 0; ++static int yy_init = 0; /* whether we need to initialize */ ++static int yy_start = 0; /* start state number */ ++ ++/* Flag which is used to allow tpwrap()'s to do buffer switches ++ * instead of setting up a fresh tpin. A bit of a hack ... ++ */ ++static int yy_did_buffer_switch_on_eof; ++ ++void tprestart (FILE *input_file ); ++void tp_switch_to_buffer (YY_BUFFER_STATE new_buffer ); ++YY_BUFFER_STATE tp_create_buffer (FILE *file,int size ); ++void tp_delete_buffer (YY_BUFFER_STATE b ); ++void tp_flush_buffer (YY_BUFFER_STATE b ); ++void tppush_buffer_state (YY_BUFFER_STATE new_buffer ); ++void tppop_buffer_state (void ); ++ ++static void tpensure_buffer_stack (void ); ++static void tp_load_buffer_state (void ); ++static void tp_init_buffer (YY_BUFFER_STATE b,FILE *file ); ++ ++#define YY_FLUSH_BUFFER tp_flush_buffer(YY_CURRENT_BUFFER ) ++ ++YY_BUFFER_STATE tp_scan_buffer (char *base,yy_size_t size ); ++YY_BUFFER_STATE tp_scan_string (yyconst char *yy_str ); ++YY_BUFFER_STATE tp_scan_bytes (yyconst char *bytes,yy_size_t len ); ++ ++void *tpalloc (yy_size_t ); ++void *tprealloc (void *,yy_size_t ); ++void tpfree (void * ); ++ ++#define yy_new_buffer tp_create_buffer ++ ++#define yy_set_interactive(is_interactive) \ ++ { \ ++ if ( ! YY_CURRENT_BUFFER ){ \ ++ tpensure_buffer_stack (); \ ++ YY_CURRENT_BUFFER_LVALUE = \ ++ tp_create_buffer(tpin,YY_BUF_SIZE ); \ ++ } \ ++ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ ++ } ++ ++#define yy_set_bol(at_bol) \ ++ { \ ++ if ( ! YY_CURRENT_BUFFER ){\ ++ tpensure_buffer_stack (); \ ++ YY_CURRENT_BUFFER_LVALUE = \ ++ tp_create_buffer(tpin,YY_BUF_SIZE ); \ ++ } \ ++ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ ++ } ++ ++#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) ++ ++/* Begin user sect3 */ ++ ++#define tpwrap() 1 ++#define YY_SKIP_YYWRAP ++ ++typedef unsigned char YY_CHAR; ++ ++FILE *tpin = (FILE *) 0, *tpout = (FILE *) 0; ++ ++typedef int yy_state_type; ++ ++extern int tplineno; ++ ++int tplineno = 1; ++ ++extern char *tptext; ++#define yytext_ptr tptext ++ ++static yy_state_type yy_get_previous_state (void ); ++static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); ++static int yy_get_next_buffer (void ); ++static void yy_fatal_error (yyconst char msg[] ); ++ ++/* Done after the current pattern has been matched and before the ++ * corresponding action - sets up tptext. ++ */ ++#define YY_DO_BEFORE_ACTION \ ++ (yytext_ptr) = yy_bp; \ ++ tpleng = (size_t) (yy_cp - yy_bp); \ ++ (yy_hold_char) = *yy_cp; \ ++ *yy_cp = '\0'; \ ++ (yy_c_buf_p) = yy_cp; ++ ++#define YY_NUM_RULES 7 ++#define YY_END_OF_BUFFER 8 ++/* This struct is not used in this scanner, ++ but its presence is necessary. */ ++struct yy_trans_info ++ { ++ flex_int32_t yy_verify; ++ flex_int32_t yy_nxt; ++ }; ++static yyconst flex_int16_t yy_accept[39] = ++ { 0, ++ 0, 0, 8, 6, 4, 2, 1, 6, 1, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, ++ 0, 0, 0, 0, 0, 0, 5, 0 ++ } ; ++ ++static yyconst flex_int32_t yy_ec[256] = ++ { 0, ++ 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 2, 4, 4, 5, 4, 4, 4, 4, 4, ++ 4, 4, 4, 4, 4, 4, 6, 7, 7, 7, ++ 7, 7, 7, 7, 7, 7, 7, 4, 4, 8, ++ 4, 9, 4, 4, 10, 10, 10, 10, 10, 10, ++ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, ++ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, ++ 4, 1, 4, 4, 4, 1, 11, 11, 11, 11, ++ ++ 12, 11, 13, 11, 14, 11, 15, 11, 11, 16, ++ 11, 11, 11, 17, 18, 19, 11, 11, 11, 11, ++ 20, 11, 1, 1, 1, 4, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1 ++ } ; ++ ++static yyconst flex_int32_t yy_meta[21] = ++ { 0, ++ 1, 2, 3, 4, 4, 4, 2, 1, 1, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ++ } ; ++ ++static yyconst flex_int16_t yy_base[43] = ++ { 0, ++ 0, 7, 49, 50, 50, 50, 0, 1, 0, 36, ++ 28, 26, 28, 35, 29, 0, 26, 33, 27, 33, ++ 29, 22, 0, 24, 27, 14, 27, 23, 13, 50, ++ 10, 9, 4, 1, 0, 2, 50, 50, 19, 23, ++ 2, 26 ++ } ; ++ ++static yyconst flex_int16_t yy_def[43] = ++ { 0, ++ 39, 39, 38, 38, 38, 38, 40, 38, 40, 38, ++ 38, 38, 38, 38, 38, 41, 38, 41, 38, 38, ++ 38, 38, 42, 38, 42, 38, 38, 38, 38, 38, ++ 38, 38, 38, 38, 38, 38, 38, 0, 38, 38, ++ 38, 38 ++ } ; ++ ++static yyconst flex_int16_t yy_nxt[71] = ++ { 0, ++ 38, 5, 6, 18, 7, 38, 38, 8, 5, 6, ++ 37, 7, 36, 38, 8, 10, 35, 34, 11, 4, ++ 4, 4, 4, 9, 9, 33, 9, 25, 32, 25, ++ 31, 30, 29, 28, 27, 26, 24, 23, 22, 21, ++ 20, 19, 17, 16, 15, 14, 13, 12, 38, 3, ++ 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, ++ 38, 38, 38, 38, 38, 38, 38, 38, 38, 38 ++ } ; ++ ++static yyconst flex_int16_t yy_chk[71] = ++ { 0, ++ 0, 1, 1, 41, 1, 0, 0, 1, 2, 2, ++ 36, 2, 35, 0, 2, 8, 34, 33, 8, 39, ++ 39, 39, 39, 40, 40, 32, 40, 42, 31, 42, ++ 29, 28, 27, 26, 25, 24, 22, 21, 20, 19, ++ 18, 17, 15, 14, 13, 12, 11, 10, 3, 38, ++ 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, ++ 38, 38, 38, 38, 38, 38, 38, 38, 38, 38 ++ } ; ++ ++static yy_state_type yy_last_accepting_state; ++static char *yy_last_accepting_cpos; ++ ++extern int tp_flex_debug; ++int tp_flex_debug = 0; ++ ++/* The intent behind this definition is that it'll catch ++ * any uses of REJECT which flex missed. ++ */ ++#define REJECT reject_used_but_not_detected ++#define yymore() yymore_used_but_not_detected ++#define YY_MORE_ADJ 0 ++#define YY_RESTORE_YY_MORE_OFFSET ++char *tptext; ++#line 1 "tokenparser.l" ++/* ++ * Reads lexical config files and updates database. ++ * ++ * MUSCLE SmartCard Development ( http://pcsclite.alioth.debian.org/pcsclite.html ) ++ * ++ * Copyright (C) 2001-2003 ++ * David Corcoran <corcoran@musclecard.com> ++ * Copyright (C) 2003-2010 ++ * Ludovic Rousseau <ludovic.rousseau@free.fr> ++ * ++Redistribution and use in source and binary forms, with or without ++modification, are permitted provided that the following conditions ++are met: ++ ++1. Redistributions of source code must retain the above copyright ++ notice, this list of conditions and the following disclaimer. ++2. Redistributions in binary form must reproduce the above copyright ++ notice, this list of conditions and the following disclaimer in the ++ documentation and/or other materials provided with the distribution. ++3. The name of the author may not be used to endorse or promote products ++ derived from this software without specific prior written permission. ++ ++THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR ++IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES ++OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ++IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, ++INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF ++THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ */ ++/** ++ * @file ++ * @brief provides parsing functions for Info.plist files ++ * platforms ++ */ ++#line 42 "tokenparser.l" ++ ++#include "config.h" ++#include <stdio.h> ++#include <string.h> ++#include <errno.h> ++#define NDEBUG ++#include <assert.h> ++ ++#include "simclist.h" ++#include "debuglog.h" ++#include "parser.h" ++ ++static void eval_key(char *pcToken, list_t *list_key); ++static void eval_value(char *pcToken, list_t *list_values); ++void tperrorCheck (char *pcToken_error); ++ ++static list_t *ListKeys; ++static list_t *ListValues; ++ ++#define YY_NO_INPUT 1 ++#line 564 "tokenparser.c" ++ ++#define INITIAL 0 ++ ++#ifndef YY_NO_UNISTD_H ++/* Special case for "unistd.h", since it is non-ANSI. We include it way ++ * down here because we want the user's section 1 to have been scanned first. ++ * The user has a chance to override it with an option. ++ */ ++#include <unistd.h> ++#endif ++ ++#ifndef YY_EXTRA_TYPE ++#define YY_EXTRA_TYPE void * ++#endif ++ ++static int yy_init_globals (void ); ++ ++/* Accessor methods to globals. ++ These are made visible to non-reentrant scanners for convenience. */ ++ ++int tplex_destroy (void ); ++ ++int tpget_debug (void ); ++ ++void tpset_debug (int debug_flag ); ++ ++YY_EXTRA_TYPE tpget_extra (void ); ++ ++void tpset_extra (YY_EXTRA_TYPE user_defined ); ++ ++FILE *tpget_in (void ); ++ ++void tpset_in (FILE * in_str ); ++ ++FILE *tpget_out (void ); ++ ++void tpset_out (FILE * out_str ); ++ ++yy_size_t tpget_leng (void ); ++ ++char *tpget_text (void ); ++ ++int tpget_lineno (void ); ++ ++void tpset_lineno (int line_number ); ++ ++/* Macros after this point can all be overridden by user definitions in ++ * section 1. ++ */ ++ ++#ifndef YY_SKIP_YYWRAP ++#ifdef __cplusplus ++extern "C" int tpwrap (void ); ++#else ++extern int tpwrap (void ); ++#endif ++#endif ++ ++#ifndef yytext_ptr ++static void yy_flex_strncpy (char *,yyconst char *,int ); ++#endif ++ ++#ifdef YY_NEED_STRLEN ++static int yy_flex_strlen (yyconst char * ); ++#endif ++ ++#ifndef YY_NO_INPUT ++ ++#ifdef __cplusplus ++static int yyinput (void ); ++#else ++static int input (void ); ++#endif ++ ++#endif ++ ++/* Amount of stuff to slurp up with each read. */ ++#ifndef YY_READ_BUF_SIZE ++#ifdef __ia64__ ++/* On IA-64, the buffer size is 16k, not 8k */ ++#define YY_READ_BUF_SIZE 16384 ++#else ++#define YY_READ_BUF_SIZE 8192 ++#endif /* __ia64__ */ ++#endif ++ ++/* Copy whatever the last rule matched to the standard output. */ ++#ifndef ECHO ++/* This used to be an fputs(), but since the string might contain NUL's, ++ * we now use fwrite(). ++ */ ++#define ECHO do { if (fwrite( tptext, tpleng, 1, tpout )) {} } while (0) ++#endif ++ ++/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, ++ * is returned in "result". ++ */ ++#ifndef YY_INPUT ++#define YY_INPUT(buf,result,max_size) \ ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ ++ { \ ++ int c = '*'; \ ++ size_t n; \ ++ for ( n = 0; n < max_size && \ ++ (c = getc( tpin )) != EOF && c != '\n'; ++n ) \ ++ buf[n] = (char) c; \ ++ if ( c == '\n' ) \ ++ buf[n++] = (char) c; \ ++ if ( c == EOF && ferror( tpin ) ) \ ++ YY_FATAL_ERROR( "input in flex scanner failed" ); \ ++ result = n; \ ++ } \ ++ else \ ++ { \ ++ errno=0; \ ++ while ( (result = fread(buf, 1, max_size, tpin))==0 && ferror(tpin)) \ ++ { \ ++ if( errno != EINTR) \ ++ { \ ++ YY_FATAL_ERROR( "input in flex scanner failed" ); \ ++ break; \ ++ } \ ++ errno=0; \ ++ clearerr(tpin); \ ++ } \ ++ }\ ++\ ++ ++#endif ++ ++/* No semi-colon after return; correct usage is to write "yyterminate();" - ++ * we don't want an extra ';' after the "return" because that will cause ++ * some compilers to complain about unreachable statements. ++ */ ++#ifndef yyterminate ++#define yyterminate() return YY_NULL ++#endif ++ ++/* Number of entries by which start-condition stack grows. */ ++#ifndef YY_START_STACK_INCR ++#define YY_START_STACK_INCR 25 ++#endif ++ ++/* Report a fatal error. */ ++#ifndef YY_FATAL_ERROR ++#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) ++#endif ++ ++/* end tables serialization structures and prototypes */ ++ ++/* Default declaration of generated scanner - a define so the user can ++ * easily add parameters. ++ */ ++#ifndef YY_DECL ++#define YY_DECL_IS_OURS 1 ++ ++extern int tplex (void); ++ ++#define YY_DECL int tplex (void) ++#endif /* !YY_DECL */ ++ ++/* Code executed at the beginning of each rule, after tptext and tpleng ++ * have been set up. ++ */ ++#ifndef YY_USER_ACTION ++#define YY_USER_ACTION ++#endif ++ ++/* Code executed at the end of each rule. */ ++#ifndef YY_BREAK ++#define YY_BREAK break; ++#endif ++ ++#define YY_RULE_SETUP \ ++ YY_USER_ACTION ++ ++/** The main scanner function which does all the work. ++ */ ++YY_DECL ++{ ++ register yy_state_type yy_current_state; ++ register char *yy_cp, *yy_bp; ++ register int yy_act; ++ ++ if ( !(yy_init) ) ++ { ++ (yy_init) = 1; ++ ++#ifdef YY_USER_INIT ++ YY_USER_INIT; ++#endif ++ ++ if ( ! (yy_start) ) ++ (yy_start) = 1; /* first start state */ ++ ++ if ( ! tpin ) ++ tpin = stdin; ++ ++ if ( ! tpout ) ++ tpout = stdout; ++ ++ if ( ! YY_CURRENT_BUFFER ) { ++ tpensure_buffer_stack (); ++ YY_CURRENT_BUFFER_LVALUE = ++ tp_create_buffer(tpin,YY_BUF_SIZE ); ++ } ++ ++ tp_load_buffer_state( ); ++ } ++ ++ { ++#line 67 "tokenparser.l" ++ ++ ++#line 779 "tokenparser.c" ++ ++ while ( 1 ) /* loops until end-of-file is reached */ ++ { ++ yy_cp = (yy_c_buf_p); ++ ++ /* Support of tptext. */ ++ *yy_cp = (yy_hold_char); ++ ++ /* yy_bp points to the position in yy_ch_buf of the start of ++ * the current run. ++ */ ++ yy_bp = yy_cp; ++ ++ yy_current_state = (yy_start); ++yy_match: ++ do ++ { ++ register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; ++ if ( yy_accept[yy_current_state] ) ++ { ++ (yy_last_accepting_state) = yy_current_state; ++ (yy_last_accepting_cpos) = yy_cp; ++ } ++ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ++ { ++ yy_current_state = (int) yy_def[yy_current_state]; ++ if ( yy_current_state >= 39 ) ++ yy_c = yy_meta[(unsigned int) yy_c]; ++ } ++ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++ ++yy_cp; ++ } ++ while ( yy_base[yy_current_state] != 50 ); ++ ++yy_find_action: ++ yy_act = yy_accept[yy_current_state]; ++ if ( yy_act == 0 ) ++ { /* have to back up */ ++ yy_cp = (yy_last_accepting_cpos); ++ yy_current_state = (yy_last_accepting_state); ++ yy_act = yy_accept[yy_current_state]; ++ } ++ ++ YY_DO_BEFORE_ACTION; ++ ++do_action: /* This label is used only to access EOF actions. */ ++ ++ switch ( yy_act ) ++ { /* beginning of action switch */ ++ case 0: /* must back up */ ++ /* undo the effects of YY_DO_BEFORE_ACTION */ ++ *yy_cp = (yy_hold_char); ++ yy_cp = (yy_last_accepting_cpos); ++ yy_current_state = (yy_last_accepting_state); ++ goto yy_find_action; ++ ++case 1: ++YY_RULE_SETUP ++#line 69 "tokenparser.l" ++{} ++ YY_BREAK ++case 2: ++/* rule 2 can match eol */ ++YY_RULE_SETUP ++#line 70 "tokenparser.l" ++{} ++ YY_BREAK ++case 3: ++YY_RULE_SETUP ++#line 71 "tokenparser.l" ++{ eval_key(tptext, ListKeys); } ++ YY_BREAK ++case 4: ++YY_RULE_SETUP ++#line 72 "tokenparser.l" ++{} ++ YY_BREAK ++case 5: ++YY_RULE_SETUP ++#line 73 "tokenparser.l" ++{ eval_value(tptext, ListValues); } ++ YY_BREAK ++case 6: ++YY_RULE_SETUP ++#line 74 "tokenparser.l" ++{ tperrorCheck(tptext); } ++ YY_BREAK ++case 7: ++YY_RULE_SETUP ++#line 75 "tokenparser.l" ++ECHO; ++ YY_BREAK ++#line 872 "tokenparser.c" ++case YY_STATE_EOF(INITIAL): ++ yyterminate(); ++ ++ case YY_END_OF_BUFFER: ++ { ++ /* Amount of text matched not including the EOB char. */ ++ int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; ++ ++ /* Undo the effects of YY_DO_BEFORE_ACTION. */ ++ *yy_cp = (yy_hold_char); ++ YY_RESTORE_YY_MORE_OFFSET ++ ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) ++ { ++ /* We're scanning a new file or input source. It's ++ * possible that this happened because the user ++ * just pointed tpin at a new source and called ++ * tplex(). If so, then we have to assure ++ * consistency between YY_CURRENT_BUFFER and our ++ * globals. Here is the right place to do so, because ++ * this is the first action (other than possibly a ++ * back-up) that will match for the new input source. ++ */ ++ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ++ YY_CURRENT_BUFFER_LVALUE->yy_input_file = tpin; ++ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; ++ } ++ ++ /* Note that here we test for yy_c_buf_p "<=" to the position ++ * of the first EOB in the buffer, since yy_c_buf_p will ++ * already have been incremented past the NUL character ++ * (since all states make transitions on EOB to the ++ * end-of-buffer state). Contrast this with the test ++ * in input(). ++ */ ++ if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) ++ { /* This was really a NUL. */ ++ yy_state_type yy_next_state; ++ ++ (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; ++ ++ yy_current_state = yy_get_previous_state( ); ++ ++ /* Okay, we're now positioned to make the NUL ++ * transition. We couldn't have ++ * yy_get_previous_state() go ahead and do it ++ * for us because it doesn't know how to deal ++ * with the possibility of jamming (and we don't ++ * want to build jamming into it because then it ++ * will run more slowly). ++ */ ++ ++ yy_next_state = yy_try_NUL_trans( yy_current_state ); ++ ++ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ++ ++ if ( yy_next_state ) ++ { ++ /* Consume the NUL. */ ++ yy_cp = ++(yy_c_buf_p); ++ yy_current_state = yy_next_state; ++ goto yy_match; ++ } ++ ++ else ++ { ++ yy_cp = (yy_c_buf_p); ++ goto yy_find_action; ++ } ++ } ++ ++ else switch ( yy_get_next_buffer( ) ) ++ { ++ case EOB_ACT_END_OF_FILE: ++ { ++ (yy_did_buffer_switch_on_eof) = 0; ++ ++ if ( tpwrap( ) ) ++ { ++ /* Note: because we've taken care in ++ * yy_get_next_buffer() to have set up ++ * tptext, we can now set up ++ * yy_c_buf_p so that if some total ++ * hoser (like flex itself) wants to ++ * call the scanner after we return the ++ * YY_NULL, it'll still work - another ++ * YY_NULL will get returned. ++ */ ++ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; ++ ++ yy_act = YY_STATE_EOF(YY_START); ++ goto do_action; ++ } ++ ++ else ++ { ++ if ( ! (yy_did_buffer_switch_on_eof) ) ++ YY_NEW_FILE; ++ } ++ break; ++ } ++ ++ case EOB_ACT_CONTINUE_SCAN: ++ (yy_c_buf_p) = ++ (yytext_ptr) + yy_amount_of_matched_text; ++ ++ yy_current_state = yy_get_previous_state( ); ++ ++ yy_cp = (yy_c_buf_p); ++ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ++ goto yy_match; ++ ++ case EOB_ACT_LAST_MATCH: ++ (yy_c_buf_p) = ++ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; ++ ++ yy_current_state = yy_get_previous_state( ); ++ ++ yy_cp = (yy_c_buf_p); ++ yy_bp = (yytext_ptr) + YY_MORE_ADJ; ++ goto yy_find_action; ++ } ++ break; ++ } ++ ++ default: ++ YY_FATAL_ERROR( ++ "fatal flex scanner internal error--no action found" ); ++ } /* end of action switch */ ++ } /* end of scanning one token */ ++ } /* end of user's declarations */ ++} /* end of tplex */ ++ ++/* yy_get_next_buffer - try to read in a new buffer ++ * ++ * Returns a code representing an action: ++ * EOB_ACT_LAST_MATCH - ++ * EOB_ACT_CONTINUE_SCAN - continue scanning from current position ++ * EOB_ACT_END_OF_FILE - end of file ++ */ ++static int yy_get_next_buffer (void) ++{ ++ register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; ++ register char *source = (yytext_ptr); ++ register int number_to_move, i; ++ int ret_val; ++ ++ if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) ++ YY_FATAL_ERROR( ++ "fatal flex scanner internal error--end of buffer missed" ); ++ ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) ++ { /* Don't try to fill the buffer, so this is an EOF. */ ++ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) ++ { ++ /* We matched a single character, the EOB, so ++ * treat this as a final EOF. ++ */ ++ return EOB_ACT_END_OF_FILE; ++ } ++ ++ else ++ { ++ /* We matched some text prior to the EOB, first ++ * process it. ++ */ ++ return EOB_ACT_LAST_MATCH; ++ } ++ } ++ ++ /* Try to read more data. */ ++ ++ /* First move last chars to start of buffer. */ ++ number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; ++ ++ for ( i = 0; i < number_to_move; ++i ) ++ *(dest++) = *(source++); ++ ++ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) ++ /* don't do the read, it's not guaranteed to return an EOF, ++ * just force an EOF ++ */ ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; ++ ++ else ++ { ++ yy_size_t num_to_read = ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; ++ ++ while ( num_to_read <= 0 ) ++ { /* Not enough room in the buffer - grow it. */ ++ ++ /* just a shorter name for the current buffer */ ++ YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; ++ ++ int yy_c_buf_p_offset = ++ (int) ((yy_c_buf_p) - b->yy_ch_buf); ++ ++ if ( b->yy_is_our_buffer ) ++ { ++ yy_size_t new_size = b->yy_buf_size * 2; ++ ++ if ( new_size <= 0 ) ++ b->yy_buf_size += b->yy_buf_size / 8; ++ else ++ b->yy_buf_size *= 2; ++ ++ b->yy_ch_buf = (char *) ++ /* Include room in for 2 EOB chars. */ ++ tprealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); ++ } ++ else ++ /* Can't grow it, we don't own it. */ ++ b->yy_ch_buf = 0; ++ ++ if ( ! b->yy_ch_buf ) ++ YY_FATAL_ERROR( ++ "fatal error - scanner input buffer overflow" ); ++ ++ (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; ++ ++ num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - ++ number_to_move - 1; ++ ++ } ++ ++ if ( num_to_read > YY_READ_BUF_SIZE ) ++ num_to_read = YY_READ_BUF_SIZE; ++ ++ /* Read in more data. */ ++ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), ++ (yy_n_chars), num_to_read ); ++ ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ++ } ++ ++ if ( (yy_n_chars) == 0 ) ++ { ++ if ( number_to_move == YY_MORE_ADJ ) ++ { ++ ret_val = EOB_ACT_END_OF_FILE; ++ tprestart(tpin ); ++ } ++ ++ else ++ { ++ ret_val = EOB_ACT_LAST_MATCH; ++ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = ++ YY_BUFFER_EOF_PENDING; ++ } ++ } ++ ++ else ++ ret_val = EOB_ACT_CONTINUE_SCAN; ++ ++ if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { ++ /* Extend the array by 50%, plus the number we really need. */ ++ yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) tprealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); ++ if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) ++ YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); ++ } ++ ++ (yy_n_chars) += number_to_move; ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; ++ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; ++ ++ (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; ++ ++ return ret_val; ++} ++ ++/* yy_get_previous_state - get the state just before the EOB char was reached */ ++ ++ static yy_state_type yy_get_previous_state (void) ++{ ++ register yy_state_type yy_current_state; ++ register char *yy_cp; ++ ++ yy_current_state = (yy_start); ++ ++ for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) ++ { ++ register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); ++ if ( yy_accept[yy_current_state] ) ++ { ++ (yy_last_accepting_state) = yy_current_state; ++ (yy_last_accepting_cpos) = yy_cp; ++ } ++ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ++ { ++ yy_current_state = (int) yy_def[yy_current_state]; ++ if ( yy_current_state >= 39 ) ++ yy_c = yy_meta[(unsigned int) yy_c]; ++ } ++ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++ } ++ ++ return yy_current_state; ++} ++ ++/* yy_try_NUL_trans - try to make a transition on the NUL character ++ * ++ * synopsis ++ * next_state = yy_try_NUL_trans( current_state ); ++ */ ++ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) ++{ ++ register int yy_is_jam; ++ register char *yy_cp = (yy_c_buf_p); ++ ++ register YY_CHAR yy_c = 1; ++ if ( yy_accept[yy_current_state] ) ++ { ++ (yy_last_accepting_state) = yy_current_state; ++ (yy_last_accepting_cpos) = yy_cp; ++ } ++ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) ++ { ++ yy_current_state = (int) yy_def[yy_current_state]; ++ if ( yy_current_state >= 39 ) ++ yy_c = yy_meta[(unsigned int) yy_c]; ++ } ++ yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++ yy_is_jam = (yy_current_state == 38); ++ ++ return yy_is_jam ? 0 : yy_current_state; ++} ++ ++#ifndef YY_NO_INPUT ++#ifdef __cplusplus ++ static int yyinput (void) ++#else ++ static int input (void) ++#endif ++ ++{ ++ int c; ++ ++ *(yy_c_buf_p) = (yy_hold_char); ++ ++ if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) ++ { ++ /* yy_c_buf_p now points to the character we want to return. ++ * If this occurs *before* the EOB characters, then it's a ++ * valid NUL; if not, then we've hit the end of the buffer. ++ */ ++ if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) ++ /* This was really a NUL. */ ++ *(yy_c_buf_p) = '\0'; ++ ++ else ++ { /* need more input */ ++ yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); ++ ++(yy_c_buf_p); ++ ++ switch ( yy_get_next_buffer( ) ) ++ { ++ case EOB_ACT_LAST_MATCH: ++ /* This happens because yy_g_n_b() ++ * sees that we've accumulated a ++ * token and flags that we need to ++ * try matching the token before ++ * proceeding. But for input(), ++ * there's no matching to consider. ++ * So convert the EOB_ACT_LAST_MATCH ++ * to EOB_ACT_END_OF_FILE. ++ */ ++ ++ /* Reset buffer status. */ ++ tprestart(tpin ); ++ ++ /*FALLTHROUGH*/ ++ ++ case EOB_ACT_END_OF_FILE: ++ { ++ if ( tpwrap( ) ) ++ return EOF; ++ ++ if ( ! (yy_did_buffer_switch_on_eof) ) ++ YY_NEW_FILE; ++#ifdef __cplusplus ++ return yyinput(); ++#else ++ return input(); ++#endif ++ } ++ ++ case EOB_ACT_CONTINUE_SCAN: ++ (yy_c_buf_p) = (yytext_ptr) + offset; ++ break; ++ } ++ } ++ } ++ ++ c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ ++ *(yy_c_buf_p) = '\0'; /* preserve tptext */ ++ (yy_hold_char) = *++(yy_c_buf_p); ++ ++ return c; ++} ++#endif /* ifndef YY_NO_INPUT */ ++ ++/** Immediately switch to a different input stream. ++ * @param input_file A readable stream. ++ * ++ * @note This function does not reset the start condition to @c INITIAL . ++ */ ++ void tprestart (FILE * input_file ) ++{ ++ ++ if ( ! YY_CURRENT_BUFFER ){ ++ tpensure_buffer_stack (); ++ YY_CURRENT_BUFFER_LVALUE = ++ tp_create_buffer(tpin,YY_BUF_SIZE ); ++ } ++ ++ tp_init_buffer(YY_CURRENT_BUFFER,input_file ); ++ tp_load_buffer_state( ); ++} ++ ++/** Switch to a different input buffer. ++ * @param new_buffer The new input buffer. ++ * ++ */ ++ void tp_switch_to_buffer (YY_BUFFER_STATE new_buffer ) ++{ ++ ++ /* TODO. We should be able to replace this entire function body ++ * with ++ * tppop_buffer_state(); ++ * tppush_buffer_state(new_buffer); ++ */ ++ tpensure_buffer_stack (); ++ if ( YY_CURRENT_BUFFER == new_buffer ) ++ return; ++ ++ if ( YY_CURRENT_BUFFER ) ++ { ++ /* Flush out information for old buffer. */ ++ *(yy_c_buf_p) = (yy_hold_char); ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ++ } ++ ++ YY_CURRENT_BUFFER_LVALUE = new_buffer; ++ tp_load_buffer_state( ); ++ ++ /* We don't actually know whether we did this switch during ++ * EOF (tpwrap()) processing, but the only time this flag ++ * is looked at is after tpwrap() is called, so it's safe ++ * to go ahead and always set it. ++ */ ++ (yy_did_buffer_switch_on_eof) = 1; ++} ++ ++static void tp_load_buffer_state (void) ++{ ++ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; ++ (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; ++ tpin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; ++ (yy_hold_char) = *(yy_c_buf_p); ++} ++ ++/** Allocate and initialize an input buffer state. ++ * @param file A readable stream. ++ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. ++ * ++ * @return the allocated buffer state. ++ */ ++ YY_BUFFER_STATE tp_create_buffer (FILE * file, int size ) ++{ ++ YY_BUFFER_STATE b; ++ ++ b = (YY_BUFFER_STATE) tpalloc(sizeof( struct yy_buffer_state ) ); ++ if ( ! b ) ++ YY_FATAL_ERROR( "out of dynamic memory in tp_create_buffer()" ); ++ ++ b->yy_buf_size = size; ++ ++ /* yy_ch_buf has to be 2 characters longer than the size given because ++ * we need to put in 2 end-of-buffer characters. ++ */ ++ b->yy_ch_buf = (char *) tpalloc(b->yy_buf_size + 2 ); ++ if ( ! b->yy_ch_buf ) ++ YY_FATAL_ERROR( "out of dynamic memory in tp_create_buffer()" ); ++ ++ b->yy_is_our_buffer = 1; ++ ++ tp_init_buffer(b,file ); ++ ++ return b; ++} ++ ++/** Destroy the buffer. ++ * @param b a buffer created with tp_create_buffer() ++ * ++ */ ++ void tp_delete_buffer (YY_BUFFER_STATE b ) ++{ ++ ++ if ( ! b ) ++ return; ++ ++ if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ ++ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; ++ ++ if ( b->yy_is_our_buffer ) ++ tpfree((void *) b->yy_ch_buf ); ++ ++ tpfree((void *) b ); ++} ++ ++/* Initializes or reinitializes a buffer. ++ * This function is sometimes called more than once on the same buffer, ++ * such as during a tprestart() or at EOF. ++ */ ++ static void tp_init_buffer (YY_BUFFER_STATE b, FILE * file ) ++ ++{ ++ int oerrno = errno; ++ ++ tp_flush_buffer(b ); ++ ++ b->yy_input_file = file; ++ b->yy_fill_buffer = 1; ++ ++ /* If b is the current buffer, then tp_init_buffer was _probably_ ++ * called from tprestart() or through yy_get_next_buffer. ++ * In that case, we don't want to reset the lineno or column. ++ */ ++ if (b != YY_CURRENT_BUFFER){ ++ b->yy_bs_lineno = 1; ++ b->yy_bs_column = 0; ++ } ++ ++ b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; ++ ++ errno = oerrno; ++} ++ ++/** Discard all buffered characters. On the next scan, YY_INPUT will be called. ++ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. ++ * ++ */ ++ void tp_flush_buffer (YY_BUFFER_STATE b ) ++{ ++ if ( ! b ) ++ return; ++ ++ b->yy_n_chars = 0; ++ ++ /* We always need two end-of-buffer characters. The first causes ++ * a transition to the end-of-buffer state. The second causes ++ * a jam in that state. ++ */ ++ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; ++ b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; ++ ++ b->yy_buf_pos = &b->yy_ch_buf[0]; ++ ++ b->yy_at_bol = 1; ++ b->yy_buffer_status = YY_BUFFER_NEW; ++ ++ if ( b == YY_CURRENT_BUFFER ) ++ tp_load_buffer_state( ); ++} ++ ++/** Pushes the new state onto the stack. The new state becomes ++ * the current state. This function will allocate the stack ++ * if necessary. ++ * @param new_buffer The new state. ++ * ++ */ ++void tppush_buffer_state (YY_BUFFER_STATE new_buffer ) ++{ ++ if (new_buffer == NULL) ++ return; ++ ++ tpensure_buffer_stack(); ++ ++ /* This block is copied from tp_switch_to_buffer. */ ++ if ( YY_CURRENT_BUFFER ) ++ { ++ /* Flush out information for old buffer. */ ++ *(yy_c_buf_p) = (yy_hold_char); ++ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); ++ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); ++ } ++ ++ /* Only push if top exists. Otherwise, replace top. */ ++ if (YY_CURRENT_BUFFER) ++ (yy_buffer_stack_top)++; ++ YY_CURRENT_BUFFER_LVALUE = new_buffer; ++ ++ /* copied from tp_switch_to_buffer. */ ++ tp_load_buffer_state( ); ++ (yy_did_buffer_switch_on_eof) = 1; ++} ++ ++/** Removes and deletes the top of the stack, if present. ++ * The next element becomes the new top. ++ * ++ */ ++void tppop_buffer_state (void) ++{ ++ if (!YY_CURRENT_BUFFER) ++ return; ++ ++ tp_delete_buffer(YY_CURRENT_BUFFER ); ++ YY_CURRENT_BUFFER_LVALUE = NULL; ++ if ((yy_buffer_stack_top) > 0) ++ --(yy_buffer_stack_top); ++ ++ if (YY_CURRENT_BUFFER) { ++ tp_load_buffer_state( ); ++ (yy_did_buffer_switch_on_eof) = 1; ++ } ++} ++ ++/* Allocates the stack if it does not exist. ++ * Guarantees space for at least one push. ++ */ ++static void tpensure_buffer_stack (void) ++{ ++ yy_size_t num_to_alloc; ++ ++ if (!(yy_buffer_stack)) { ++ ++ /* First allocation is just for 2 elements, since we don't know if this ++ * scanner will even need a stack. We use 2 instead of 1 to avoid an ++ * immediate realloc on the next call. ++ */ ++ num_to_alloc = 1; ++ (yy_buffer_stack) = (struct yy_buffer_state**)tpalloc ++ (num_to_alloc * sizeof(struct yy_buffer_state*) ++ ); ++ if ( ! (yy_buffer_stack) ) ++ YY_FATAL_ERROR( "out of dynamic memory in tpensure_buffer_stack()" ); ++ ++ memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); ++ ++ (yy_buffer_stack_max) = num_to_alloc; ++ (yy_buffer_stack_top) = 0; ++ return; ++ } ++ ++ if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ ++ ++ /* Increase the buffer to prepare for a possible push. */ ++ int grow_size = 8 /* arbitrary grow size */; ++ ++ num_to_alloc = (yy_buffer_stack_max) + grow_size; ++ (yy_buffer_stack) = (struct yy_buffer_state**)tprealloc ++ ((yy_buffer_stack), ++ num_to_alloc * sizeof(struct yy_buffer_state*) ++ ); ++ if ( ! (yy_buffer_stack) ) ++ YY_FATAL_ERROR( "out of dynamic memory in tpensure_buffer_stack()" ); ++ ++ /* zero only the new slots.*/ ++ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); ++ (yy_buffer_stack_max) = num_to_alloc; ++ } ++} ++ ++/** Setup the input buffer state to scan directly from a user-specified character buffer. ++ * @param base the character buffer ++ * @param size the size in bytes of the character buffer ++ * ++ * @return the newly allocated buffer state object. ++ */ ++YY_BUFFER_STATE tp_scan_buffer (char * base, yy_size_t size ) ++{ ++ YY_BUFFER_STATE b; ++ ++ if ( size < 2 || ++ base[size-2] != YY_END_OF_BUFFER_CHAR || ++ base[size-1] != YY_END_OF_BUFFER_CHAR ) ++ /* They forgot to leave room for the EOB's. */ ++ return 0; ++ ++ b = (YY_BUFFER_STATE) tpalloc(sizeof( struct yy_buffer_state ) ); ++ if ( ! b ) ++ YY_FATAL_ERROR( "out of dynamic memory in tp_scan_buffer()" ); ++ ++ b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ ++ b->yy_buf_pos = b->yy_ch_buf = base; ++ b->yy_is_our_buffer = 0; ++ b->yy_input_file = 0; ++ b->yy_n_chars = b->yy_buf_size; ++ b->yy_is_interactive = 0; ++ b->yy_at_bol = 1; ++ b->yy_fill_buffer = 0; ++ b->yy_buffer_status = YY_BUFFER_NEW; ++ ++ tp_switch_to_buffer(b ); ++ ++ return b; ++} ++ ++/** Setup the input buffer state to scan a string. The next call to tplex() will ++ * scan from a @e copy of @a str. ++ * @param yystr a NUL-terminated string to scan ++ * ++ * @return the newly allocated buffer state object. ++ * @note If you want to scan bytes that may contain NUL values, then use ++ * tp_scan_bytes() instead. ++ */ ++YY_BUFFER_STATE tp_scan_string (yyconst char * yystr ) ++{ ++ ++ return tp_scan_bytes(yystr,strlen(yystr) ); ++} ++ ++/** Setup the input buffer state to scan the given bytes. The next call to tplex() will ++ * scan from a @e copy of @a bytes. ++ * @param yybytes the byte buffer to scan ++ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. ++ * ++ * @return the newly allocated buffer state object. ++ */ ++YY_BUFFER_STATE tp_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len ) ++{ ++ YY_BUFFER_STATE b; ++ char *buf; ++ yy_size_t n; ++ yy_size_t i; ++ ++ /* Get memory for full buffer, including space for trailing EOB's. */ ++ n = _yybytes_len + 2; ++ buf = (char *) tpalloc(n ); ++ if ( ! buf ) ++ YY_FATAL_ERROR( "out of dynamic memory in tp_scan_bytes()" ); ++ ++ for ( i = 0; i < _yybytes_len; ++i ) ++ buf[i] = yybytes[i]; ++ ++ buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; ++ ++ b = tp_scan_buffer(buf,n ); ++ if ( ! b ) ++ YY_FATAL_ERROR( "bad buffer in tp_scan_bytes()" ); ++ ++ /* It's okay to grow etc. this buffer, and we should throw it ++ * away when we're done. ++ */ ++ b->yy_is_our_buffer = 1; ++ ++ return b; ++} ++ ++#ifndef YY_EXIT_FAILURE ++#define YY_EXIT_FAILURE 2 ++#endif ++ ++static void yy_fatal_error (yyconst char* msg ) ++{ ++ (void) fprintf( stderr, "%s\n", msg ); ++ exit( YY_EXIT_FAILURE ); ++} ++ ++/* Redefine yyless() so it works in section 3 code. */ ++ ++#undef yyless ++#define yyless(n) \ ++ do \ ++ { \ ++ /* Undo effects of setting up tptext. */ \ ++ int yyless_macro_arg = (n); \ ++ YY_LESS_LINENO(yyless_macro_arg);\ ++ tptext[tpleng] = (yy_hold_char); \ ++ (yy_c_buf_p) = tptext + yyless_macro_arg; \ ++ (yy_hold_char) = *(yy_c_buf_p); \ ++ *(yy_c_buf_p) = '\0'; \ ++ tpleng = yyless_macro_arg; \ ++ } \ ++ while ( 0 ) ++ ++/* Accessor methods (get/set functions) to struct members. */ ++ ++/** Get the current line number. ++ * ++ */ ++int tpget_lineno (void) ++{ ++ ++ return tplineno; ++} ++ ++/** Get the input stream. ++ * ++ */ ++FILE *tpget_in (void) ++{ ++ return tpin; ++} ++ ++/** Get the output stream. ++ * ++ */ ++FILE *tpget_out (void) ++{ ++ return tpout; ++} ++ ++/** Get the length of the current token. ++ * ++ */ ++yy_size_t tpget_leng (void) ++{ ++ return tpleng; ++} ++ ++/** Get the current token. ++ * ++ */ ++ ++char *tpget_text (void) ++{ ++ return tptext; ++} ++ ++/** Set the current line number. ++ * @param line_number ++ * ++ */ ++void tpset_lineno (int line_number ) ++{ ++ ++ tplineno = line_number; ++} ++ ++/** Set the input stream. This does not discard the current ++ * input buffer. ++ * @param in_str A readable stream. ++ * ++ * @see tp_switch_to_buffer ++ */ ++void tpset_in (FILE * in_str ) ++{ ++ tpin = in_str ; ++} ++ ++void tpset_out (FILE * out_str ) ++{ ++ tpout = out_str ; ++} ++ ++int tpget_debug (void) ++{ ++ return tp_flex_debug; ++} ++ ++void tpset_debug (int bdebug ) ++{ ++ tp_flex_debug = bdebug ; ++} ++ ++static int yy_init_globals (void) ++{ ++ /* Initialization is the same as for the non-reentrant scanner. ++ * This function is called from tplex_destroy(), so don't allocate here. ++ */ ++ ++ (yy_buffer_stack) = 0; ++ (yy_buffer_stack_top) = 0; ++ (yy_buffer_stack_max) = 0; ++ (yy_c_buf_p) = (char *) 0; ++ (yy_init) = 0; ++ (yy_start) = 0; ++ ++/* Defined in main.c */ ++#ifdef YY_STDINIT ++ tpin = stdin; ++ tpout = stdout; ++#else ++ tpin = (FILE *) 0; ++ tpout = (FILE *) 0; ++#endif ++ ++ /* For future reference: Set errno on error, since we are called by ++ * tplex_init() ++ */ ++ return 0; ++} ++ ++/* tplex_destroy is for both reentrant and non-reentrant scanners. */ ++int tplex_destroy (void) ++{ ++ ++ /* Pop the buffer stack, destroying each element. */ ++ while(YY_CURRENT_BUFFER){ ++ tp_delete_buffer(YY_CURRENT_BUFFER ); ++ YY_CURRENT_BUFFER_LVALUE = NULL; ++ tppop_buffer_state(); ++ } ++ ++ /* Destroy the stack itself. */ ++ tpfree((yy_buffer_stack) ); ++ (yy_buffer_stack) = NULL; ++ ++ /* Reset the globals. This is important in a non-reentrant scanner so the next time ++ * tplex() is called, initialization will occur. */ ++ yy_init_globals( ); ++ ++ return 0; ++} ++ ++/* ++ * Internal utility routines. ++ */ ++ ++#ifndef yytext_ptr ++static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) ++{ ++ register int i; ++ for ( i = 0; i < n; ++i ) ++ s1[i] = s2[i]; ++} ++#endif ++ ++#ifdef YY_NEED_STRLEN ++static int yy_flex_strlen (yyconst char * s ) ++{ ++ register int n; ++ for ( n = 0; s[n]; ++n ) ++ ; ++ ++ return n; ++} ++#endif ++ ++void *tpalloc (yy_size_t size ) ++{ ++ return (void *) malloc( size ); ++} ++ ++void *tprealloc (void * ptr, yy_size_t size ) ++{ ++ /* The cast to (char *) in the following accommodates both ++ * implementations that use char* generic pointers, and those ++ * that use void* generic pointers. It works with the latter ++ * because both ANSI C and C++ allow castless assignment from ++ * any pointer type to void*, and deal with argument conversions ++ * as though doing an assignment. ++ */ ++ return (void *) realloc( (char *) ptr, size ); ++} ++ ++void tpfree (void * ptr ) ++{ ++ free( (char *) ptr ); /* see tprealloc() for (char *) cast */ ++} ++ ++#define YYTABLES_NAME "yytables" ++ ++#line 74 "tokenparser.l" ++ ++ ++ ++ ++static void eval_key(char *pcToken, list_t *list_key) ++{ ++ struct bundleElt *elt; ++ int r; ++ size_t len; ++ ++ /* create a new list element */ ++ elt = malloc(sizeof(*elt)); ++ assert(elt); ++ ++ /* <key>foobar</key> ++ * 012345 : 5 is the first key character index */ ++ ++ /* calculate the argument length */ ++ for (len=0; pcToken[len+5] != '<'; len++) ++ ; ++ len++; /* final NULL byte */ ++ ++ elt->key = malloc(len); ++ memcpy(elt->key, &pcToken[5], len-1); ++ elt->key[len-1] = '\0'; ++ ++ r = list_init(&elt->values); ++ assert(r >= 0); ++ (void)r; ++ ++ /* add the key/values */ ++ list_append(list_key, elt); ++ ++ /* set the list to store the values */ ++ ListValues = &elt->values; ++} ++ ++static void eval_value(char *pcToken, list_t *list_values) ++{ ++ int r; ++ size_t len; ++ char *value; ++ char *amp; ++ ++ /* <string>foobar</string> ++ * 012345678 : 8 is the first string character index */ ++ ++ /* calculate the argument length */ ++ for (len=0; pcToken[len+8] != '<'; len++) ++ ; ++ len++; /* final NULL byte */ ++ ++ value = malloc(len); ++ assert(value); ++ ++ memcpy(value, &pcToken[8], len-1); ++ value[len-1] = '\0'; ++ ++ /* for all & in the string */ ++ amp = value; ++ while ((amp = strstr(amp, "&")) != NULL) ++ { ++ char *p; ++ ++ /* just skip "amp;" substring (4 letters) */ ++ for (p = amp+1; *(p+4); p++) ++ { ++ *p = *(p+4); ++ } ++ /* terminate the now shorter string */ ++ *p = '\0'; ++ ++ /* skip the & and continue */ ++ amp++; ++ } ++ ++ r = list_append(list_values, value); ++ assert(r >= 0); ++ (void)r; ++} ++ ++void tperrorCheck (char *token_error) ++{ ++ (void)token_error; ++} ++ ++/** ++ * Find an optional key in a configuration file ++ * No error is logged if the key is not found ++ * ++ * @param l list generated by bundleParse() ++ * @param key searched key ++ * @param[out] values list of token value (if key found) ++ * @retval 0 OK ++ * @retval 1 key not found ++ */ ++int LTPBundleFindValueWithKey(list_t *l, const char *key, list_t **values) ++{ ++ unsigned int i; ++ int ret = 1; ++ ++ for (i=0; i < list_size(l); i++) ++ { ++ struct bundleElt *elt; ++ ++ elt = list_get_at(l, i); ++ assert(elt); ++ ++ if (0 == strcmp(elt->key, key)) ++ { ++ *values = &elt->values; ++ ret = 0; ++ } ++ } ++ ++ return ret; ++} ++ ++ ++/** ++ * Parse a Info.plist file and file a list ++ * ++ * @param fileName file name ++ * @param l list containing the results ++ * @retval -1 configuration file not found ++ * @retval 0 OK ++ */ ++int bundleParse(const char *fileName, list_t *l) ++{ ++ FILE *file = NULL; ++ int r; ++#ifndef NDEBUG ++ int i; ++#endif ++ ++ file = fopen(fileName, "r"); ++ if (!file) ++ { ++ Log3(PCSC_LOG_CRITICAL, "Could not open bundle file %s: %s", ++ fileName, strerror(errno)); ++ return 1; ++ } ++ ++ r = list_init(l); ++ assert(r >= 0); ++ (void)r; ++ ++ ListKeys = l; ++ tpin = file; ++ ++ do ++ { ++ (void)tplex(); ++ } while (!feof(file)); ++ tplex_destroy(); ++ ++ (void)fclose(file); ++ ++#ifndef NDEBUG ++ printf("size: %d\n", list_size(l)); ++ for (i=0; i < list_size(l); i++) ++ { ++ struct bundleElt *elt; ++ unsigned int j; ++ ++ elt = list_get_at(l, i); ++ assert(elt); ++ printf("Key: %s\n", elt->key); ++ ++ for (j=0; j<list_size(&elt->values); j++) ++ { ++ char *v = list_get_at(&elt->values, j); ++ printf(" value: %s\n", v); ++ } ++ } ++#endif ++ ++ return 0; ++} ++ ++/** ++ * Free the list created by bundleParse() ++ * ++ * @param l list containing the results ++ */ ++void bundleRelease(list_t *l) ++{ ++ unsigned int i; ++ ++ for (i=0; i < list_size(l); i++) ++ { ++ struct bundleElt *elt; ++ unsigned int j; ++ ++ elt = list_get_at(l, i); ++ assert(elt); ++ ++ /* free all the values */ ++ for (j=0; j<list_size(&elt->values); j++) ++ free(list_get_at(&elt->values, j)); ++ list_destroy(&elt->values); ++ ++ /* free the key */ ++ free(elt->key); ++ free(elt); ++ } ++ ++ list_destroy(l); ++} ++ +-- +2.9.0 + |