开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 视频捕捉/采集 > 查看源码
CascadeFileScanner.c
资源名称：handvu-beta3.tar.gz　[点击查看]
上传用户：lijia5631
上传日期：2008-11-10
资源大小：1214k
文件大小：52k
源码类别：

视频捕捉/采集

开发平台：

MultiPlatform

CascadeFileScanner.c：源码内容
  1. /* A lexical scanner generated by flex */
  3. /* Scanner skeleton version:
  4.  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
  5.  */
  7. #define FLEX_SCANNER
  8. #define YY_FLEX_MAJOR_VERSION 2
  9. #define YY_FLEX_MINOR_VERSION 5
  11. #include <stdio.h>
  12. #include <unistd.h>
  15. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  16. #ifdef c_plusplus
  17. #ifndef __cplusplus
  18. #define __cplusplus
  19. #endif
  20. #endif
  23. #ifdef __cplusplus
  25. #include <stdlib.h>
  27. /* Use prototypes in function declarations. */
  28. #define YY_USE_PROTOS
  30. /* The "const" storage-class-modifier is valid. */
  31. #define YY_USE_CONST
  33. #else /* ! __cplusplus */
  35. #if __STDC__
  37. #define YY_USE_PROTOS
  38. #define YY_USE_CONST
  40. #endif /* __STDC__ */
  41. #endif /* ! __cplusplus */
  43. #ifdef __TURBOC__
  44.  #pragma warn -rch
  45.  #pragma warn -use
  46. #include <io.h>
  47. #include <stdlib.h>
  48. #define YY_USE_CONST
  49. #define YY_USE_PROTOS
  50. #endif
  52. #ifdef YY_USE_CONST
  53. #define yyconst const
  54. #else
  55. #define yyconst
  56. #endif
  59. #ifdef YY_USE_PROTOS
  60. #define YY_PROTO(proto) proto
  61. #else
  62. #define YY_PROTO(proto) ()
  63. #endif
  65. /* Returned upon end-of-file. */
  66. #define YY_NULL 0
  68. /* Promotes a possibly negative, possibly signed char to an unsigned
  69.  * integer for use as an array index.  If the signed char is negative,
  70.  * we want to instead treat it as an 8-bit unsigned char, hence the
  71.  * double cast.
  72.  */
  73. #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  75. /* Enter a start condition.  This macro really ought to take a parameter,
  76.  * but we do it the disgusting crufty way forced on us by the ()-less
  77.  * definition of BEGIN.
  78.  */
  79. #define BEGIN yy_start = 1 + 2 *
  81. /* Translate the current start state into a value that can be later handed
  82.  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  83.  * compatibility.
  84.  */
  85. #define YY_START ((yy_start - 1) / 2)
  86. #define YYSTATE YY_START
  88. /* Action number for EOF rule of a given start state. */
  89. #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
  91. /* Special action meaning "start processing a new file". */
  92. #define YY_NEW_FILE yyrestart( yyin )
  94. #define YY_END_OF_BUFFER_CHAR 0
  96. /* Size of default input buffer. */
  97. #define YY_BUF_SIZE 16384
  99. typedef struct yy_buffer_state *YY_BUFFER_STATE;
  101. extern int yyleng;
  102. extern FILE *yyin, *yyout;
  104. #define EOB_ACT_CONTINUE_SCAN 0
  105. #define EOB_ACT_END_OF_FILE 1
  106. #define EOB_ACT_LAST_MATCH 2
  108. /* The funky do-while in the following #define is used to turn the definition
  109.  * int a single C statement (which needs a semi-colon terminator).  This
  110.  * avoids problems with code like:
  111.  *
  112.  *  if ( condition_holds )
  113.  * yyless( 5 );
  114.  * else
  115.  * do_something_else();
  116.  *
  117.  * Prior to using the do-while the compiler would get upset at the
  118.  * "else" because it interpreted the "if" statement as being all
  119.  * done when it reached the ';' after the yyless() call.
  120.  */
  122. /* Return all but the first 'n' matched characters back to the input stream. */
  124. #define yyless(n) 
  125. do 
  126. { 
  127. /* Undo effects of setting up yytext. */ 
  128. *yy_cp = yy_hold_char; 
  129. YY_RESTORE_YY_MORE_OFFSET 
  130. yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; 
  131. YY_DO_BEFORE_ACTION; /* set up yytext again */ 
  132. } 
  133. while ( 0 )
  135. #define unput(c) yyunput( c, yytext_ptr )
  137. /* The following is because we cannot portably get our hands on size_t
  138.  * (without autoconf's help, which isn't available because we want
  139.  * flex-generated scanners to compile on their own).
  140.  */
  141. typedef unsigned int yy_size_t;
  144. struct yy_buffer_state
  145. {
  146. FILE *yy_input_file;
  148. char *yy_ch_buf; /* input buffer */
  149. char *yy_buf_pos; /* current position in input buffer */
  151. /* Size of input buffer in bytes, not including room for EOB
  152.  * characters.
  153.  */
  154. yy_size_t yy_buf_size;
  156. /* Number of characters read into yy_ch_buf, not including EOB
  157.  * characters.
  158.  */
  159. int yy_n_chars;
  161. /* Whether we "own" the buffer - i.e., we know we created it,
  162.  * and can realloc() it to grow it, and should free() it to
  163.  * delete it.
  164.  */
  165. int yy_is_our_buffer;
  167. /* Whether this is an "interactive" input source; if so, and
  168.  * if we're using stdio for input, then we want to use getc()
  169.  * instead of fread(), to make sure we stop fetching input after
  170.  * each newline.
  171.  */
  172. int yy_is_interactive;
  174. /* Whether we're considered to be at the beginning of a line.
  175.  * If so, '^' rules will be active on the next match, otherwise
  176.  * not.
  177.  */
  178. int yy_at_bol;
  180. /* Whether to try to fill the input buffer when we reach the
  181.  * end of it.
  182.  */
  183. int yy_fill_buffer;
  185. int yy_buffer_status;
  186. #define YY_BUFFER_NEW 0
  187. #define YY_BUFFER_NORMAL 1
  188. /* When an EOF's been seen but there's still some text to process
  189.  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
  190.  * shouldn't try reading from the input source any more.  We might
  191.  * still have a bunch of tokens to match, though, because of
  192.  * possible backing-up.
  193.  *
  194.  * When we actually see the EOF, we change the status to "new"
  195.  * (via yyrestart()), so that the user can continue scanning by
  196.  * just pointing yyin at a new input file.
  197.  */
  198. #define YY_BUFFER_EOF_PENDING 2
  199. };
  201. static YY_BUFFER_STATE yy_current_buffer = 0;
  203. /* We provide macros for accessing buffer states in case in the
  204.  * future we want to put the buffer states in a more general
  205.  * "scanner state".
  206.  */
  207. #define YY_CURRENT_BUFFER yy_current_buffer
  210. /* yy_hold_char holds the character lost when yytext is formed. */
  211. static char yy_hold_char;
  213. static int yy_n_chars; /* number of characters read into yy_ch_buf */
  216. int yyleng;
  218. /* Points to current character in buffer. */
  219. static char *yy_c_buf_p = (char *) 0;
  220. static int yy_init = 1; /* whether we need to initialize */
  221. static int yy_start = 0; /* start state number */
  223. /* Flag which is used to allow yywrap()'s to do buffer switches
  224.  * instead of setting up a fresh yyin.  A bit of a hack ...
  225.  */
  226. static int yy_did_buffer_switch_on_eof;
  228. void yyrestart YY_PROTO(( FILE *input_file ));
  230. void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
  231. void yy_load_buffer_state YY_PROTO(( void ));
  232. YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
  233. void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  234. void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
  235. void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
  236. #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
  238. YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
  239. YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
  240. YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
  242. static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
  243. static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
  244. static void yy_flex_free YY_PROTO(( void * ));
  246. #define yy_new_buffer yy_create_buffer
  248. #define yy_set_interactive(is_interactive) 
  249. { 
  250. if ( ! yy_current_buffer ) 
  251. yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 
  252. yy_current_buffer->yy_is_interactive = is_interactive; 
  253. }
  255. #define yy_set_bol(at_bol) 
  256. { 
  257. if ( ! yy_current_buffer ) 
  258. yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 
  259. yy_current_buffer->yy_at_bol = at_bol; 
  260. }
  262. #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
  264. typedef unsigned char YY_CHAR;
  265. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  266. typedef int yy_state_type;
  267. extern char *yytext;
  268. #define yytext_ptr yytext
  270. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  271. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  272. static int yy_get_next_buffer YY_PROTO(( void ));
  273. static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
  275. /* Done after the current pattern has been matched and before the
  276.  * corresponding action - sets up yytext.
  277.  */
  278. #define YY_DO_BEFORE_ACTION 
  279. yytext_ptr = yy_bp; 
  280. yyleng = (int) (yy_cp - yy_bp); 
  281. yy_hold_char = *yy_cp; 
  282. *yy_cp = ''; 
  283. yy_c_buf_p = yy_cp;
  285. #define YY_NUM_RULES 58
  286. #define YY_END_OF_BUFFER 59
  287. static yyconst short int yy_accept[250] =
  288.     {   0,
  289.         0,    0,   59,   57,   52,   54,   57,   51,   34,   57,
  290.        38,   39,   42,   57,   35,   50,   49,   45,   47,   37,
  291.        43,   57,   48,   48,   48,   48,   48,   48,   48,   48,
  292.        48,   40,   41,   48,   48,   48,   48,   48,   48,   48,
  293.        48,   48,   36,   53,    0,   56,    0,    0,    0,   47,
  294.        46,   46,   44,   48,   48,   48,   48,   48,   48,   48,
  295.        48,   48,   48,   48,   48,   48,    7,   48,   48,   48,
  296.        48,   48,   48,   48,   48,   48,   48,   48,   55,    0,
  297.        46,   48,   48,   48,   48,   48,   48,   48,   48,   48,
  298.        48,   48,   48,   48,    3,    6,   48,   48,   48,   48,
  300.        48,   48,   48,   48,    0,   46,   48,   48,   48,   21,
  301.        48,   48,   16,   48,   48,   48,   48,   48,   48,   48,
  302.        48,   48,   48,   48,    4,   14,   48,   48,   48,   48,
  303.        48,   48,   48,   48,   48,   48,   48,   48,   48,    5,
  304.        48,   48,   48,   48,   33,   32,   48,   48,   48,   48,
  305.        48,   48,   13,   48,   18,   48,   48,   48,   48,   10,
  306.        48,   48,   48,   48,   48,   48,   48,   48,   48,   48,
  307.        48,   48,   48,   48,   48,   48,   48,   27,   48,   48,
  308.        48,   48,   48,   48,   31,   48,   48,   48,   48,   48,
  309.        48,   48,   29,   48,   17,   48,   48,   48,    9,   48,
  311.        48,   15,   48,   48,   48,   48,   48,   48,   23,   12,
  312.         2,    8,   48,   28,   48,   48,   48,   48,   11,   48,
  313.        48,   48,   48,   20,   48,   30,   48,   22,   48,   48,
  314.        48,   48,   48,   48,   19,   48,   48,   48,   48,   25,
  315.        48,    1,   48,   48,   48,   48,   24,   26,    0
  316.     } ;
  318. static yyconst int yy_ec[256] =
  319.     {   0,
  320.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  321.         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
  322.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  323.         1,    5,    1,    6,    7,    1,    1,    1,    1,    8,
  324.         9,   10,   11,   12,   13,   14,   15,   16,   16,   16,
  325.        16,   16,   16,   16,   16,   16,   16,   17,    1,   18,
  326.        19,   20,    1,    1,   21,   22,   23,   24,   25,   26,
  327.        27,   28,   29,   29,   29,   30,   31,   32,   33,   29,
  328.        29,   34,   35,   36,   37,   29,   29,   38,   29,   29,
  329.        39,    1,   40,    1,   29,    1,   41,   42,   43,   44,
  331.        45,   46,   47,   48,   49,   29,   50,   51,   52,   53,
  332.        54,   55,   56,   57,   58,   59,   60,   61,   62,   63,
  333.        29,   29,    1,   11,    1,    1,    1,    1,    1,    1,
  334.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  335.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  336.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  337.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  338.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  339.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  340.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  342.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  343.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  344.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  345.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  346.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  347.         1,    1,    1,    1,    1
  348.     } ;
  350. static yyconst int yy_meta[64] =
  351.     {   0,
  352.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  353.         1,    1,    1,    1,    1,    2,    1,    1,    1,    1,
  354.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  355.         3,    3,    3,    3,    3,    3,    3,    3,    1,    1,
  356.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  357.         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
  358.         3,    3,    3
  359.     } ;
  361. static yyconst short int yy_base[254] =
  362.     {   0,
  363.         0,    0,  291,  292,  292,  292,  287,  292,  292,   61,
  364.       292,  292,  292,   52,  292,   53,  273,  292,   56,  292,
  365.       292,  269,    0,  253,   38,  237,  231,  239,  246,   37,
  366.       227,  292,  292,  224,  229,  222,  215,   33,  236,   31,
  367.        27,  231,    0,  292,   74,  292,   76,  259,   67,   71,
  368.        70,  258,  292,    0,  252,  241,  230,  229,  209,  222,
  369.       237,  232,  204,  240,  222,  221,    0,  213,  207,  202,
  370.       199,  201,  199,  212,  197,  208,  211,    0,  292,   81,
  371.        77,  219,  219,  191,  201,  190,  187,  215,  211,  198,
  372.       188,  188,  182,  198,    0,    0,  189,  177,  182,  192,
  374.       189,  188,  182,    0,  215,  214,  206,  195,  169,  191,
  375.       203,   73,    0,  192,  170,  160,  178,  162,  159,  164,
  376.       172,  163,  170,  156,    0,    0,  185,  180,  162,   57,
  377.       156,  164,  159,  180,  183,  152,  156,  154,  144,    0,
  378.       148,  153,  141,  150,    0,    0,  151,  144,  143,  131,
  379.       140,  145,    0,  137,  155,  144,  142,  128,  127,    0,
  380.       127,  130,  134,  137,  132,  135,  120,  130,  126,  135,
  381.       117,  125,  128,  123,  125,  119,  124,    0,  117,  109,
  382.       121,  106,  104,  111,    0,  117,  117,  119,   99,  114,
  383.       100,  115,  120,   97,  118,  100,  106,   93,    0,   98,
  385.        97,    0,  124,   89,  104,  110,  102,   89,    0,   83,
  386.         0,    0,   99,    0,   87,   89,   85,   78,    0,   77,
  387.        89,   86,   87,   96,   87,    0,   73,    0,   59,   79,
  388.        60,   66,   65,   72,   79,   68,   63,   66,   69,    0,
  389.        58,    0,   53,   63,   58,   44,    0,    0,  292,  122,
  390.       124,   96,  126
  391.     } ;
  393. static yyconst short int yy_def[254] =
  394.     {   0,
  395.       249,    1,  249,  249,  249,  249,  249,  249,  249,  250,
  396.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  397.       249,  249,  251,  251,  251,  251,  251,  251,  251,  251,
  398.       251,  249,  249,  251,  251,  251,  251,  251,  251,  251,
  399.       251,  251,  252,  249,  250,  249,  250,  249,  249,  249,
  400.       249,  249,  249,  251,  251,  251,  251,  251,  251,  251,
  401.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  402.       251,  251,  251,  251,  251,  251,  251,  253,  249,  249,
  403.       249,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  404.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  406.       251,  251,  251,  253,  249,  249,  251,  251,  251,  251,
  407.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  408.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  409.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  410.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  411.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  412.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  413.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  414.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  415.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  417.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  418.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  419.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  420.       251,  251,  251,  251,  251,  251,  251,  251,  251,  251,
  421.       251,  251,  251,  251,  251,  251,  251,  251,    0,  249,
  422.       249,  249,  249
  423.     } ;
  425. static yyconst short int yy_nxt[356] =
  426.     {   0,
  427.         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
  428.        14,   15,   16,   17,   18,   19,   20,   21,    4,   22,
  429.        23,   24,   25,   26,   23,   27,   23,   23,   23,   28,
  430.        23,   29,   23,   23,   30,   23,   31,    4,   32,   33,
  431.        23,   34,   35,   36,   37,   38,   23,   23,   23,   23,
  432.        23,   23,   23,   23,   23,   23,   39,   40,   41,   23,
  433.        23,   42,   43,   46,   47,   48,   48,   49,   50,   52,
  434.        56,   50,   62,   69,   75,   72,   46,   47,   79,   47,
  435.        52,   63,   49,   76,   52,   51,   50,   70,   57,   73,
  436.        74,  105,   81,  105,   80,  132,  106,  148,   78,  232,
  438.       248,   80,  247,  246,  245,  149,  133,  233,  244,  243,
  439.       242,  241,  240,  239,   80,  238,  237,  236,  235,  234,
  440.       231,   80,   45,   45,   45,   54,   54,  104,  104,  230,
  441.       229,  228,  227,  226,  225,  224,  223,  222,  221,  220,
  442.       219,  218,  217,  216,  215,  214,  213,  212,  211,  210,
  443.       209,  208,  207,  206,  205,  204,  203,  202,  201,  200,
  444.       199,  198,  197,  196,  195,  194,  193,  192,  191,  190,
  445.       189,  188,  187,  186,  185,  184,  183,  182,  181,  180,
  446.       179,  178,  177,  176,  175,  174,  173,  172,  171,  170,
  447.       169,  168,  167,  166,  165,  164,  163,  162,  161,  160,
  449.       159,  158,  157,  156,  155,  154,  153,  152,  151,  150,
  450.       147,  146,  145,  144,  143,  142,  141,  140,  139,  138,
  451.       137,  136,  135,  134,  131,  130,  129,  128,  127,  106,
  452.       106,  126,  125,  124,  123,  122,  121,  120,  119,  118,
  453.       117,  116,  115,  114,  113,  112,  111,  110,  109,  108,
  454.       107,  103,  102,  101,  100,   99,   98,   97,   96,   95,
  455.        94,   93,   92,   91,   90,   89,   88,   87,   86,   85,
  456.        84,   83,   82,   81,   51,   77,   71,   68,   67,   66,
  457.        65,   64,   61,   60,   59,   58,   55,   53,   51,   44,
  458.       249,    3,  249,  249,  249,  249,  249,  249,  249,  249,
  460.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  461.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  462.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  463.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  464.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  465.       249,  249,  249,  249,  249
  466.     } ;
  468. static yyconst short int yy_chk[356] =
  469.     {   0,
  470.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  471.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  472.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  473.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  474.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  475.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  476.         1,    1,    1,   10,   10,   14,   16,   14,   16,   19,
  477.        25,   19,   30,   38,   41,   40,   45,   45,   47,   47,
  478.        49,   30,   49,   41,   50,   51,   50,   38,   25,   40,
  479.        40,   80,   81,   80,   51,  112,   80,  130,  252,  229,
  481.       246,   81,  245,  244,  243,  130,  112,  229,  241,  239,
  482.       238,  237,  236,  235,   51,  234,  233,  232,  231,  230,
  483.       227,   81,  250,  250,  250,  251,  251,  253,  253,  225,
  484.       224,  223,  222,  221,  220,  218,  217,  216,  215,  213,
  485.       210,  208,  207,  206,  205,  204,  203,  201,  200,  198,
  486.       197,  196,  195,  194,  193,  192,  191,  190,  189,  188,
  487.       187,  186,  184,  183,  182,  181,  180,  179,  177,  176,
  488.       175,  174,  173,  172,  171,  170,  169,  168,  167,  166,
  489.       165,  164,  163,  162,  161,  159,  158,  157,  156,  155,
  490.       154,  152,  151,  150,  149,  148,  147,  144,  143,  142,
  492.       141,  139,  138,  137,  136,  135,  134,  133,  132,  131,
  493.       129,  128,  127,  124,  123,  122,  121,  120,  119,  118,
  494.       117,  116,  115,  114,  111,  110,  109,  108,  107,  106,
  495.       105,  103,  102,  101,  100,   99,   98,   97,   94,   93,
  496.        92,   91,   90,   89,   88,   87,   86,   85,   84,   83,
  497.        82,   77,   76,   75,   74,   73,   72,   71,   70,   69,
  498.        68,   66,   65,   64,   63,   62,   61,   60,   59,   58,
  499.        57,   56,   55,   52,   48,   42,   39,   37,   36,   35,
  500.        34,   31,   29,   28,   27,   26,   24,   22,   17,    7,
  501.         3,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  503.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  504.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  505.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  506.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  507.       249,  249,  249,  249,  249,  249,  249,  249,  249,  249,
  508.       249,  249,  249,  249,  249
  509.     } ;
  511. static yy_state_type yy_last_accepting_state;
  512. static char *yy_last_accepting_cpos;
  514. /* The intent behind this definition is that it'll catch
  515.  * any uses of REJECT which flex missed.
  516.  */
  517. #define REJECT reject_used_but_not_detected
  518. #define yymore() yymore_used_but_not_detected
  519. #define YY_MORE_ADJ 0
  520. #define YY_RESTORE_YY_MORE_OFFSET
  521. char *yytext;
  522. #line 1 "CascadeFileScanner.l"
  523. #define INITIAL 0
  524. /**
  525.   * cubicles
  526.   *
  527.   * This is an implementation of the Viola-Jones object detection 
  528.   * method and some extensions.  The code is mostly platform-
  529.   * independent and uses only standard C and C++ libraries.  It
  530.   * can make use of MPI for parallel training and a few Windows
  531.   * MFC functions for classifier display.
  532.   *
  533.   * Mathias Kolsch, matz@cs.ucsb.edu
  534.   *
  535.   * $Id: CascadeFileScanner.l,v 1.7 2004/10/22 03:26:00 matz Exp $
  536. **
  538. // CascadeFileScanner takes care of scanning integral features,
  539. // weak classifiers, strong classifiers, and classifier cascades
  540. // from file input.  Compile with flex.
  541. //
  543. ////////////////////////////////////////////////////////////////////
  544. //
  545. // By downloading, copying, installing or using the software you 
  546. // agree to this license.  If you do not agree to this license, 
  547. // do not download, install, copy or use the software.
  548. //
  549. // Copyright (C) 2004, Mathias Kolsch, all rights reserved.
  550. // Third party copyrights are property of their respective owners.
  551. //
  552. // Redistribution and use in binary form, with or without 
  553. // modification, is permitted for non-commercial purposes only.
  554. // Redistribution in source, with or without modification, is 
  555. // prohibited without prior written permission.
  556. // If granted in writing in another document, personal use and 
  557. // modification are permitted provided that the following two
  558. // conditions are met:
  559. //
  560. // 1.Any modification of source code must retain the above 
  561. //   copyright notice, this list of conditions and the following 
  562. //   disclaimer.
  563. //
  564. // 2.Redistribution's in binary form must reproduce the above 
  565. //   copyright notice, this list of conditions and the following 
  566. //   disclaimer in the documentation and/or other materials provided
  567. //   with the distribution.
  568. //
  569. // This software is provided by the copyright holders and 
  570. // contributors "as is" and any express or implied warranties, 
  571. // including, but not limited to, the implied warranties of 
  572. // merchantability and fitness for a particular purpose are 
  573. // disclaimed.  In no event shall the copyright holder or 
  574. // contributors be liable for any direct, indirect, incidental, 
  575. // special, exemplary, or consequential damages (including, but not 
  576. // limited to, procurement of substitute goods or services; loss of 
  577. // use, data, or profits; or business interruption) however caused
  578. // and on any theory of liability, whether in contract, strict 
  579. // liability, or tort (including negligence or otherwise) arising 
  580. // in any way out of the use of this software, even if advised of 
  581. // the possibility of such damage.
  582. //
  583. ////////////////////////////////////////////////////////////////////
  584. */
  585. #line 64 "CascadeFileScanner.l"
  586. #include "cubicles.hpp"
  587. #include "IntegralFeatures.h"
  588. #include "Classifiers.h"
  589. #include "Cascade.h"
  590. #include "CascadeFileParser.h"
  592. void yyerror(const char *str);
  593. //void yyerror(YYLTYPE *llocp, const char *str);
  595. extern "C" int mywrap(void)
  596. {
  597.   /*
  598.   FILE* fp = fopen("c:\tmp\dump3.txt", "a+");
  599.   fprintf(fp, "wrap calledn");
  600.   fflush(fp);
  601.   fclose(fp);
  602.   */
  603.   return 1;
  604. }
  606. extern string yyIDstring;
  607.  
  608. void nextline(void);
  609.  
  610. #define yywrap mywrap
  612. #define YY_NEVER_INTERACTIVE 1
  613. #define YYERROR_VERBOSE 1
  615. /* definitions */
  616. #line 617 "CascadeFileScanner.c"
  618. /* Macros after this point can all be overridden by user definitions in
  619.  * section 1.
  620.  */
  622. #ifndef YY_SKIP_YYWRAP
  623. #ifdef __cplusplus
  624. extern "C" int yywrap YY_PROTO(( void ));
  625. #else
  626. extern int yywrap YY_PROTO(( void ));
  627. #endif
  628. #endif
  630. #ifndef YY_NO_UNPUT
  631. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  632. #endif
  634. #ifndef yytext_ptr
  635. static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
  636. #endif
  638. #ifdef YY_NEED_STRLEN
  639. static int yy_flex_strlen YY_PROTO(( yyconst char * ));
  640. #endif
  642. #ifndef YY_NO_INPUT
  643. #ifdef __cplusplus
  644. static int yyinput YY_PROTO(( void ));
  645. #else
  646. static int input YY_PROTO(( void ));
  647. #endif
  648. #endif
  650. #if YY_STACK_USED
  651. static int yy_start_stack_ptr = 0;
  652. static int yy_start_stack_depth = 0;
  653. static int *yy_start_stack = 0;
  654. #ifndef YY_NO_PUSH_STATE
  655. static void yy_push_state YY_PROTO(( int new_state ));
  656. #endif
  657. #ifndef YY_NO_POP_STATE
  658. static void yy_pop_state YY_PROTO(( void ));
  659. #endif
  660. #ifndef YY_NO_TOP_STATE
  661. static int yy_top_state YY_PROTO(( void ));
  662. #endif
  664. #else
  665. #define YY_NO_PUSH_STATE 1
  666. #define YY_NO_POP_STATE 1
  667. #define YY_NO_TOP_STATE 1
  668. #endif
  670. #ifdef YY_MALLOC_DECL
  671. YY_MALLOC_DECL
  672. #else
  673. #if __STDC__
  674. #ifndef __cplusplus
  675. #include <stdlib.h>
  676. #endif
  677. #else
  678. /* Just try to get by without declaring the routines.  This will fail
  679.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  680.  * or sizeof(void*) != sizeof(int).
  681.  */
  682. #endif
  683. #endif
  685. /* Amount of stuff to slurp up with each read. */
  686. #ifndef YY_READ_BUF_SIZE
  687. #define YY_READ_BUF_SIZE 8192
  688. #endif
  690. /* Copy whatever the last rule matched to the standard output. */
  692. #ifndef ECHO
  693. /* This used to be an fputs(), but since the string might contain NUL's,
  694.  * we now use fwrite().
  695.  */
  696. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  697. #endif
  699. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  700.  * is returned in "result".
  701.  */
  702. #ifndef YY_INPUT
  703. #define YY_INPUT(buf,result,max_size) 
  704. if ( yy_current_buffer->yy_is_interactive ) 
  705. { 
  706. int c = '*', n; 
  707. for ( n = 0; n < max_size && 
  708.      (c = getc( yyin )) != EOF && c != 'n'; ++n ) 
  709. buf[n] = (char) c; 
  710. if ( c == 'n' ) 
  711. buf[n++] = (char) c; 
  712. if ( c == EOF && ferror( yyin ) ) 
  713. YY_FATAL_ERROR( "input in flex scanner failed" ); 
  714. result = n; 
  715. } 
  716. else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) 
  717.   && ferror( yyin ) ) 
  718. YY_FATAL_ERROR( "input in flex scanner failed" );
  719. #endif
  721. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  722.  * we don't want an extra ';' after the "return" because that will cause
  723.  * some compilers to complain about unreachable statements.
  724.  */
  725. #ifndef yyterminate
  726. #define yyterminate() return YY_NULL
  727. #endif
  729. /* Number of entries by which start-condition stack grows. */
  730. #ifndef YY_START_STACK_INCR
  731. #define YY_START_STACK_INCR 25
  732. #endif
  734. /* Report a fatal error. */
  735. #ifndef YY_FATAL_ERROR
  736. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  737. #endif
  739. /* Default declaration of generated scanner - a define so the user can
  740.  * easily add parameters.
  741.  */
  742. #ifndef YY_DECL
  743. #define YY_DECL int yylex YY_PROTO(( void ))
  744. #endif
  746. /* Code executed at the beginning of each rule, after yytext and yyleng
  747.  * have been set up.
  748.  */
  749. #ifndef YY_USER_ACTION
  750. #define YY_USER_ACTION
  751. #endif
  753. /* Code executed at the end of each rule. */
  754. #ifndef YY_BREAK
  755. #define YY_BREAK break;
  756. #endif
  758. #define YY_RULE_SETUP 
  759. YY_USER_ACTION
  761. YY_DECL
  762. {
  763. register yy_state_type yy_current_state;
  764. register char *yy_cp = NULL, *yy_bp = NULL;
  765. register int yy_act;
  767. #line 103 "CascadeFileScanner.l"
  770. #line 771 "CascadeFileScanner.c"
  772. if ( yy_init )
  773. {
  774. yy_init = 0;
  776. #ifdef YY_USER_INIT
  777. YY_USER_INIT;
  778. #endif
  780. if ( ! yy_start )
  781. yy_start = 1; /* first start state */
  783. if ( ! yyin )
  784. yyin = stdin;
  786. if ( ! yyout )
  787. yyout = stdout;
  789. if ( ! yy_current_buffer )
  790. yy_current_buffer =
  791. yy_create_buffer( yyin, YY_BUF_SIZE );
  793. yy_load_buffer_state();
  794. }
  796. while ( 1 ) /* loops until end-of-file is reached */
  797. {
  798. yy_cp = yy_c_buf_p;
  800. /* Support of yytext. */
  801. *yy_cp = yy_hold_char;
  803. /* yy_bp points to the position in yy_ch_buf of the start of
  804.  * the current run.
  805.  */
  806. yy_bp = yy_cp;
  808. yy_current_state = yy_start;
  809. yy_match:
  810. do
  811. {
  812. register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  813. if ( yy_accept[yy_current_state] )
  814. {
  815. yy_last_accepting_state = yy_current_state;
  816. yy_last_accepting_cpos = yy_cp;
  817. }
  818. while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  819. {
  820. yy_current_state = (int) yy_def[yy_current_state];
  821. if ( yy_current_state >= 250 )
  822. yy_c = yy_meta[(unsigned int) yy_c];
  823. }
  824. yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  825. ++yy_cp;
  826. }
  827. while ( yy_base[yy_current_state] != 292 );
  829. yy_find_action:
  830. yy_act = yy_accept[yy_current_state];
  831. if ( yy_act == 0 )
  832. { /* have to back up */
  833. yy_cp = yy_last_accepting_cpos;
  834. yy_current_state = yy_last_accepting_state;
  835. yy_act = yy_accept[yy_current_state];
  836. }
  838. YY_DO_BEFORE_ACTION;
  841. do_action: /* This label is used only to access EOF actions. */
  844. switch ( yy_act )
  845. { /* beginning of action switch */
  846. case 0: /* must back up */
  847. /* undo the effects of YY_DO_BEFORE_ACTION */
  848. *yy_cp = yy_hold_char;
  849. yy_cp = yy_last_accepting_cpos;
  850. yy_current_state = yy_last_accepting_state;
  851. goto yy_find_action;
  853. case 1:
  854. YY_RULE_SETUP
  855. #line 105 "CascadeFileScanner.l"
  856. { return CLASSIFIER_CASCADE; }
  857. YY_BREAK
  858. case 2:
  859. YY_RULE_SETUP
  860. #line 106 "CascadeFileScanner.l"
  861. { return TYPE_SEQUENTIAL; }
  862. YY_BREAK
  863. case 3:
  864. YY_RULE_SETUP
  865. #line 107 "CascadeFileScanner.l"
  866. { return TYPE_FAN; }
  867. YY_BREAK
  868. case 4:
  869. YY_RULE_SETUP
  870. #line 108 "CascadeFileScanner.l"
  871. { return TYPE_TREE; }
  872. YY_BREAK
  873. case 5:
  874. YY_RULE_SETUP
  875. #line 109 "CascadeFileScanner.l"
  876. { return RATIO; }
  877. YY_BREAK
  878. case 6:
  879. YY_RULE_SETUP
  880. #line 110 "CascadeFileScanner.l"
  881. { return FPR; }
  882. YY_BREAK
  883. case 7:
  884. YY_RULE_SETUP
  885. #line 111 "CascadeFileScanner.l"
  886. { return DR; }
  887. YY_BREAK
  888. case 8:
  889. YY_RULE_SETUP
  890. #line 112 "CascadeFileScanner.l"
  891. { return SUCCESSFUL; }
  892. YY_BREAK
  893. case 9:
  894. YY_RULE_SETUP
  895. #line 113 "CascadeFileScanner.l"
  896. { return EXHAUSTED; }
  897. YY_BREAK
  898. case 10:
  899. YY_RULE_SETUP
  900. #line 114 "CascadeFileScanner.l"
  901. { return STRONG; }
  902. YY_BREAK
  903. case 11:
  904. YY_RULE_SETUP
  905. #line 115 "CascadeFileScanner.l"
  906. { return CLASSIFIERS; }
  907. YY_BREAK
  908. case 12:
  909. YY_RULE_SETUP
  910. #line 116 "CascadeFileScanner.l"
  911. { return CLASSIFIER; }
  912. YY_BREAK
  913. case 13:
  914. YY_RULE_SETUP
  915. #line 117 "CascadeFileScanner.l"
  916. { return UPCASE_STRONG; }
  917. YY_BREAK
  918. case 14:
  919. YY_RULE_SETUP
  920. #line 118 "CascadeFileScanner.l"
  921. { return WEAK; }
  922. YY_BREAK
  923. case 15:
  924. YY_RULE_SETUP
  925. #line 119 "CascadeFileScanner.l"
  926. { return THRESHOLD; }
  927. YY_BREAK
  928. case 16:
  929. YY_RULE_SETUP
  930. #line 120 "CascadeFileScanner.l"
  931. { return NULL_ID; }
  932. YY_BREAK
  933. case 17:
  934. YY_RULE_SETUP
  935. #line 121 "CascadeFileScanner.l"
  936. { return LEFT_RIGHT; }
  937. YY_BREAK
  938. case 18:
  939. YY_RULE_SETUP
  940. #line 122 "CascadeFileScanner.l"
  941. { return UP_DOWN; }
  942. YY_BREAK
  943. case 19:
  944. YY_RULE_SETUP
  945. #line 123 "CascadeFileScanner.l"
  946. { return LEFT_CENTER_RIGHT; }
  947. YY_BREAK
  948. case 20:
  949. YY_RULE_SETUP
  950. #line 124 "CascadeFileScanner.l"
  951. { return SEVEN_COLUMNS; }
  952. YY_BREAK
  953. case 21:
  954. YY_RULE_SETUP
  955. #line 125 "CascadeFileScanner.l"
  956. { return DIAG; }
  957. YY_BREAK
  958. case 22:
  959. YY_RULE_SETUP
  960. #line 126 "CascadeFileScanner.l"
  961. { return LEFT_RIGHT_SAME; }
  962. YY_BREAK
  963. case 23:
  964. YY_RULE_SETUP
  965. #line 127 "CascadeFileScanner.l"
  966. { return UP_DOWN_SAME; }
  967. YY_BREAK
  968. case 24:
  969. YY_RULE_SETUP
  970. #line 128 "CascadeFileScanner.l"
  971. { return LEFT_CENTER_RIGHT_SAME; }
  972. YY_BREAK
  973. case 25:
  974. YY_RULE_SETUP
  975. #line 129 "CascadeFileScanner.l"
  976. { return SEVEN_COLUMNS_SAME; }
  977. YY_BREAK
  978. case 26:
  979. YY_RULE_SETUP
  980. #line 130 "CascadeFileScanner.l"
  981. { return SEVEN_COLUMNS_SIMILAR; }
  982. YY_BREAK
  983. case 27:
  984. YY_RULE_SETUP
  985. #line 131 "CascadeFileScanner.l"
  986. { return DIAG_SAME; }
  987. YY_BREAK
  988. case 28:
  989. YY_RULE_SETUP
  990. #line 132 "CascadeFileScanner.l"
  991. { return DIAG_SIMILAR; }
  992. YY_BREAK
  993. case 29:
  994. YY_RULE_SETUP
  995. #line 133 "CascadeFileScanner.l"
  996. { return FOUR_BOXES; }
  997. YY_BREAK
  998. case 30:
  999. YY_RULE_SETUP
  1000. #line 134 "CascadeFileScanner.l"
  1001. { return FOUR_BOXES_SAME; }
  1002. YY_BREAK
  1003. case 31:
  1004. YY_RULE_SETUP
  1005. #line 135 "CascadeFileScanner.l"
  1006. { return BRANCHES; }
  1007. YY_BREAK
  1008. case 32:
  1009. YY_RULE_SETUP
  1010. #line 136 "CascadeFileScanner.l"
  1011. { return COMMON; }
  1012. YY_BREAK
  1013. case 33:
  1014. YY_RULE_SETUP
  1015. #line 137 "CascadeFileScanner.l"
  1016. { return BRANCH; }
  1017. YY_BREAK
  1018. case 34:
  1019. YY_RULE_SETUP
  1020. #line 140 "CascadeFileScanner.l"
  1021. { return DOUBLEQUOTE; }
  1022. YY_BREAK
  1023. case 35:
  1024. YY_RULE_SETUP
  1025. #line 141 "CascadeFileScanner.l"
  1026. { return COMMA; }
  1027. YY_BREAK
  1028. case 36:
  1029. YY_RULE_SETUP
  1030. #line 142 "CascadeFileScanner.l"
  1031. { return X_BY; }
  1032. YY_BREAK
  1033. case 37:
  1034. YY_RULE_SETUP
  1035. #line 143 "CascadeFileScanner.l"
  1036. { return COLON; }
  1037. YY_BREAK
  1038. case 38:
  1039. YY_RULE_SETUP
  1040. #line 144 "CascadeFileScanner.l"
  1041. { return OPEN_PAREN; }
  1042. YY_BREAK
  1043. case 39:
  1044. YY_RULE_SETUP
  1045. #line 145 "CascadeFileScanner.l"
  1046. { return CLOSE_PAREN; }
  1047. YY_BREAK
  1048. case 40:
  1049. YY_RULE_SETUP
  1050. #line 146 "CascadeFileScanner.l"
  1051. { return OPEN_BRACKET; }
  1052. YY_BREAK
  1053. case 41:
  1054. YY_RULE_SETUP
  1055. #line 147 "CascadeFileScanner.l"
  1056. { return CLOSE_BRACKET; }
  1057. YY_BREAK
  1058. case 42:
  1059. YY_RULE_SETUP
  1060. #line 148 "CascadeFileScanner.l"
  1061. { return ASTERIX; }
  1062. YY_BREAK
  1063. case 43:
  1064. YY_RULE_SETUP
  1065. #line 149 "CascadeFileScanner.l"
  1066. { return LT; }
  1067. YY_BREAK
  1068. case 44:
  1069. YY_RULE_SETUP
  1070. #line 150 "CascadeFileScanner.l"
  1071. { return GTEQ; }
  1072. YY_BREAK
  1073. case 45:
  1074. YY_RULE_SETUP
  1075. #line 151 "CascadeFileScanner.l"
  1076. { return SLASH; }
  1077. YY_BREAK
  1078. case 46:
  1079. YY_RULE_SETUP
  1080. #line 153 "CascadeFileScanner.l"
  1081. { yylval.fval = atof(yytext); return FP_NUMBER; }
  1082. YY_BREAK
  1083. case 47:
  1084. YY_RULE_SETUP
  1085. #line 154 "CascadeFileScanner.l"
  1086. { yylval.ival = atoi(yytext); return INT_NUMBER; }
  1087. YY_BREAK
  1088. case 48:
  1089. YY_RULE_SETUP
  1090. #line 155 "CascadeFileScanner.l"
  1091. { yyIDstring = string(yytext); yylval.sval = yytext; return NAME; }
  1092. YY_BREAK
  1093. case 49:
  1094. YY_RULE_SETUP
  1095. #line 157 "CascadeFileScanner.l"
  1096. { return DOT; }
  1097. YY_BREAK
  1098. case 50:
  1099. YY_RULE_SETUP
  1100. #line 158 "CascadeFileScanner.l"
  1101. { return MINUS; }
  1102. YY_BREAK
  1103. case 51:
  1104. YY_RULE_SETUP
  1105. #line 160 "CascadeFileScanner.l"
  1106. { ; }
  1107. YY_BREAK
  1108. case 52:
  1109. YY_RULE_SETUP
  1110. #line 161 "CascadeFileScanner.l"
  1111. { ; }
  1112. YY_BREAK
  1113. case 53:
  1114. YY_RULE_SETUP
  1115. #line 162 "CascadeFileScanner.l"
  1116. { nextline(); }
  1117. YY_BREAK
  1118. case 54:
  1119. YY_RULE_SETUP
  1120. #line 163 "CascadeFileScanner.l"
  1121. { nextline(); }
  1122. YY_BREAK
  1123. case 55:
  1124. YY_RULE_SETUP
  1125. #line 165 "CascadeFileScanner.l"
  1126. { nextline(); } /*comment*/
  1127. YY_BREAK
  1128. case 56:
  1129. YY_RULE_SETUP
  1130. #line 166 "CascadeFileScanner.l"
  1131. { nextline(); } /*comment*/
  1132. YY_BREAK
  1133. case 57:
  1134. YY_RULE_SETUP
  1135. #line 167 "CascadeFileScanner.l"
  1136. { char buf[32]; sprintf(buf, "illegal token: ' '"); buf[16]=yytext[0]; yyerror(buf); }
  1137. YY_BREAK
  1138. case 58:
  1139. YY_RULE_SETUP
  1140. #line 169 "CascadeFileScanner.l"
  1141. ECHO;
  1142. YY_BREAK
  1143. #line 1144 "CascadeFileScanner.c"
  1144. case YY_STATE_EOF(INITIAL):
  1145. yyterminate();
  1147. case YY_END_OF_BUFFER:
  1148. {
  1149. /* Amount of text matched not including the EOB char. */
  1150. int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
  1152. /* Undo the effects of YY_DO_BEFORE_ACTION. */
  1153. *yy_cp = yy_hold_char;
  1154. YY_RESTORE_YY_MORE_OFFSET
  1156. if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  1157. {
  1158. /* We're scanning a new file or input source.  It's
  1159.  * possible that this happened because the user
  1160.  * just pointed yyin at a new source and called
  1161.  * yylex().  If so, then we have to assure
  1162.  * consistency between yy_current_buffer and our
  1163.  * globals.  Here is the right place to do so, because
  1164.  * this is the first action (other than possibly a
  1165.  * back-up) that will match for the new input source.
  1166.  */
  1167. yy_n_chars = yy_current_buffer->yy_n_chars;
  1168. yy_current_buffer->yy_input_file = yyin;
  1169. yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  1170. }
  1172. /* Note that here we test for yy_c_buf_p "<=" to the position
  1173.  * of the first EOB in the buffer, since yy_c_buf_p will
  1174.  * already have been incremented past the NUL character
  1175.  * (since all states make transitions on EOB to the
  1176.  * end-of-buffer state).  Contrast this with the test
  1177.  * in input().
  1178.  */
  1179. if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1180. { /* This was really a NUL. */
  1181. yy_state_type yy_next_state;
  1183. yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  1185. yy_current_state = yy_get_previous_state();
  1187. /* Okay, we're now positioned to make the NUL
  1188.  * transition.  We couldn't have
  1189.  * yy_get_previous_state() go ahead and do it
  1190.  * for us because it doesn't know how to deal
  1191.  * with the possibility of jamming (and we don't
  1192.  * want to build jamming into it because then it
  1193.  * will run more slowly).
  1194.  */
  1196. yy_next_state = yy_try_NUL_trans( yy_current_state );
  1198. yy_bp = yytext_ptr + YY_MORE_ADJ;
  1200. if ( yy_next_state )
  1201. {
  1202. /* Consume the NUL. */
  1203. yy_cp = ++yy_c_buf_p;
  1204. yy_current_state = yy_next_state;
  1205. goto yy_match;
  1206. }
  1208. else
  1209. {
  1210. yy_cp = yy_c_buf_p;
  1211. goto yy_find_action;
  1212. }
  1213. }
  1215. else switch ( yy_get_next_buffer() )
  1216. {
  1217. case EOB_ACT_END_OF_FILE:
  1218. {
  1219. yy_did_buffer_switch_on_eof = 0;
  1221. if ( yywrap() )
  1222. {
  1223. /* Note: because we've taken care in
  1224.  * yy_get_next_buffer() to have set up
  1225.  * yytext, we can now set up
  1226.  * yy_c_buf_p so that if some total
  1227.  * hoser (like flex itself) wants to
  1228.  * call the scanner after we return the
  1229.  * YY_NULL, it'll still work - another
  1230.  * YY_NULL will get returned.
  1231.  */
  1232. yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1234. yy_act = YY_STATE_EOF(YY_START);
  1235. goto do_action;
  1236. }
  1238. else
  1239. {
  1240. if ( ! yy_did_buffer_switch_on_eof )
  1241. YY_NEW_FILE;
  1242. }
  1243. break;
  1244. }
  1246. case EOB_ACT_CONTINUE_SCAN:
  1247. yy_c_buf_p =
  1248. yytext_ptr + yy_amount_of_matched_text;
  1250. yy_current_state = yy_get_previous_state();
  1252. yy_cp = yy_c_buf_p;
  1253. yy_bp = yytext_ptr + YY_MORE_ADJ;
  1254. goto yy_match;
  1256. case EOB_ACT_LAST_MATCH:
  1257. yy_c_buf_p =
  1258. &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1260. yy_current_state = yy_get_previous_state();
  1262. yy_cp = yy_c_buf_p;
  1263. yy_bp = yytext_ptr + YY_MORE_ADJ;
  1264. goto yy_find_action;
  1265. }
  1266. break;
  1267. }
  1269. default:
  1270. YY_FATAL_ERROR(
  1271. "fatal flex scanner internal error--no action found" );
  1272. } /* end of action switch */
  1273. } /* end of scanning one token */
  1274. } /* end of yylex */
  1277. /* yy_get_next_buffer - try to read in a new buffer
  1278.  *
  1279.  * Returns a code representing an action:
  1280.  * EOB_ACT_LAST_MATCH -
  1281.  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1282.  * EOB_ACT_END_OF_FILE - end of file
  1283.  */
  1285. static int yy_get_next_buffer()
  1286. {
  1287. register char *dest = yy_current_buffer->yy_ch_buf;
  1288. register char *source = yytext_ptr;
  1289. register int number_to_move, i;
  1290. int ret_val;
  1292. if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1293. YY_FATAL_ERROR(
  1294. "fatal flex scanner internal error--end of buffer missed" );
  1296. if ( yy_current_buffer->yy_fill_buffer == 0 )
  1297. { /* Don't try to fill the buffer, so this is an EOF. */
  1298. if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  1299. {
  1300. /* We matched a single character, the EOB, so
  1301.  * treat this as a final EOF.
  1302.  */
  1303. return EOB_ACT_END_OF_FILE;
  1304. }
  1306. else
  1307. {
  1308. /* We matched some text prior to the EOB, first
  1309.  * process it.
  1310.  */
  1311. return EOB_ACT_LAST_MATCH;
  1312. }
  1313. }
  1315. /* Try to read more data. */
  1317. /* First move last chars to start of buffer. */
  1318. number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
  1320. for ( i = 0; i < number_to_move; ++i )
  1321. *(dest++) = *(source++);
  1323. if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  1324. /* don't do the read, it's not guaranteed to return an EOF,
  1325.  * just force an EOF
  1326.  */
  1327. yy_current_buffer->yy_n_chars = yy_n_chars = 0;
  1329. else
  1330. {
  1331. int num_to_read =
  1332. yy_current_buffer->yy_buf_size - number_to_move - 1;
  1334. while ( num_to_read <= 0 )
  1335. { /* Not enough room in the buffer - grow it. */
  1336. #ifdef YY_USES_REJECT
  1337. YY_FATAL_ERROR(
  1338. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  1339. #else
  1341. /* just a shorter name for the current buffer */
  1342. YY_BUFFER_STATE b = yy_current_buffer;
  1344. int yy_c_buf_p_offset =
  1345. (int) (yy_c_buf_p - b->yy_ch_buf);
  1347. if ( b->yy_is_our_buffer )
  1348. {
  1349. int new_size = b->yy_buf_size * 2;
  1351. if ( new_size <= 0 )
  1352. b->yy_buf_size += b->yy_buf_size / 8;
  1353. else
  1354. b->yy_buf_size *= 2;
  1356. b->yy_ch_buf = (char *)
  1357. /* Include room in for 2 EOB chars. */
  1358. yy_flex_realloc( (void *) b->yy_ch_buf,
  1359.  b->yy_buf_size + 2 );
  1360. }
  1361. else
  1362. /* Can't grow it, we don't own it. */
  1363. b->yy_ch_buf = 0;
  1365. if ( ! b->yy_ch_buf )
  1366. YY_FATAL_ERROR(
  1367. "fatal error - scanner input buffer overflow" );
  1369. yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  1371. num_to_read = yy_current_buffer->yy_buf_size -
  1372. number_to_move - 1;
  1373. #endif
  1374. }
  1376. if ( num_to_read > YY_READ_BUF_SIZE )
  1377. num_to_read = YY_READ_BUF_SIZE;
  1379. /* Read in more data. */
  1380. YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1381. yy_n_chars, num_to_read );
  1383. yy_current_buffer->yy_n_chars = yy_n_chars;
  1384. }
  1386. if ( yy_n_chars == 0 )
  1387. {
  1388. if ( number_to_move == YY_MORE_ADJ )
  1389. {
  1390. ret_val = EOB_ACT_END_OF_FILE;
  1391. yyrestart( yyin );
  1392. }
  1394. else
  1395. {
  1396. ret_val = EOB_ACT_LAST_MATCH;
  1397. yy_current_buffer->yy_buffer_status =
  1398. YY_BUFFER_EOF_PENDING;
  1399. }
  1400. }
  1402. else
  1403. ret_val = EOB_ACT_CONTINUE_SCAN;
  1405. yy_n_chars += number_to_move;
  1406. yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1407. yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1409. yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
  1411. return ret_val;
  1412. }
  1415. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1417. static yy_state_type yy_get_previous_state()
  1418. {
  1419. register yy_state_type yy_current_state;
  1420. register char *yy_cp;
  1422. yy_current_state = yy_start;
  1424. for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1425. {
  1426. register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  1427. if ( yy_accept[yy_current_state] )
  1428. {
  1429. yy_last_accepting_state = yy_current_state;
  1430. yy_last_accepting_cpos = yy_cp;
  1431. }
  1432. while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1433. {
  1434. yy_current_state = (int) yy_def[yy_current_state];
  1435. if ( yy_current_state >= 250 )
  1436. yy_c = yy_meta[(unsigned int) yy_c];
  1437. }
  1438. yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1439. }
  1441. return yy_current_state;
  1442. }
  1445. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1446.  *
  1447.  * synopsis
  1448.  * next_state = yy_try_NUL_trans( current_state );
  1449.  */
  1451. #ifdef YY_USE_PROTOS
  1452. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  1453. #else
  1454. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1455. yy_state_type yy_current_state;
  1456. #endif
  1457. {
  1458. register int yy_is_jam;
  1459. register char *yy_cp = yy_c_buf_p;
  1461. register YY_CHAR yy_c = 1;
  1462. if ( yy_accept[yy_current_state] )
  1463. {
  1464. yy_last_accepting_state = yy_current_state;
  1465. yy_last_accepting_cpos = yy_cp;
  1466. }
  1467. while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1468. {
  1469. yy_current_state = (int) yy_def[yy_current_state];
  1470. if ( yy_current_state >= 250 )
  1471. yy_c = yy_meta[(unsigned int) yy_c];
  1472. }
  1473. yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1474. yy_is_jam = (yy_current_state == 249);
  1476. return yy_is_jam ? 0 : yy_current_state;
  1477. }
  1480. #ifndef YY_NO_UNPUT
  1481. #ifdef YY_USE_PROTOS
  1482. static void yyunput( int c, register char *yy_bp )
  1483. #else
  1484. static void yyunput( c, yy_bp )
  1485. int c;
  1486. register char *yy_bp;
  1487. #endif
  1488. {
  1489. register char *yy_cp = yy_c_buf_p;
  1491. /* undo effects of setting up yytext */
  1492. *yy_cp = yy_hold_char;
  1494. if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1495. { /* need to shift things up to make room */
  1496. /* +2 for EOB chars. */
  1497. register int number_to_move = yy_n_chars + 2;
  1498. register char *dest = &yy_current_buffer->yy_ch_buf[
  1499. yy_current_buffer->yy_buf_size + 2];
  1500. register char *source =
  1501. &yy_current_buffer->yy_ch_buf[number_to_move];
  1503. while ( source > yy_current_buffer->yy_ch_buf )
  1504. *--dest = *--source;
  1506. yy_cp += (int) (dest - source);
  1507. yy_bp += (int) (dest - source);
  1508. yy_current_buffer->yy_n_chars =
  1509. yy_n_chars = yy_current_buffer->yy_buf_size;
  1511. if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1512. YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1513. }
  1515. *--yy_cp = (char) c;
  1518. yytext_ptr = yy_bp;
  1519. yy_hold_char = *yy_cp;
  1520. yy_c_buf_p = yy_cp;
  1521. }
  1522. #endif /* ifndef YY_NO_UNPUT */
  1525. #ifndef YY_NO_INPUT
  1526. #ifdef __cplusplus
  1527. static int yyinput()
  1528. #else
  1529. static int input()
  1530. #endif
  1531. {
  1532. int c;
  1534. *yy_c_buf_p = yy_hold_char;
  1536. if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1537. {
  1538. /* yy_c_buf_p now points to the character we want to return.
  1539.  * If this occurs *before* the EOB characters, then it's a
  1540.  * valid NUL; if not, then we've hit the end of the buffer.
  1541.  */
  1542. if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1543. /* This was really a NUL. */
  1544. *yy_c_buf_p = '';
  1546. else
  1547. { /* need more input */
  1548. int offset = yy_c_buf_p - yytext_ptr;
  1549. ++yy_c_buf_p;
  1551. switch ( yy_get_next_buffer() )
  1552. {
  1553. case EOB_ACT_LAST_MATCH:
  1554. /* This happens because yy_g_n_b()
  1555.  * sees that we've accumulated a
  1556.  * token and flags that we need to
  1557.  * try matching the token before
  1558.  * proceeding.  But for input(),
  1559.  * there's no matching to consider.
  1560.  * So convert the EOB_ACT_LAST_MATCH
  1561.  * to EOB_ACT_END_OF_FILE.
  1562.  */
  1564. /* Reset buffer status. */
  1565. yyrestart( yyin );
  1567. /* fall through */
  1569. case EOB_ACT_END_OF_FILE:
  1570. {
  1571. if ( yywrap() )
  1572. return EOF;
  1574. if ( ! yy_did_buffer_switch_on_eof )
  1575. YY_NEW_FILE;
  1576. #ifdef __cplusplus
  1577. return yyinput();
  1578. #else
  1579. return input();
  1580. #endif
  1581. }
  1583. case EOB_ACT_CONTINUE_SCAN:
  1584. yy_c_buf_p = yytext_ptr + offset;
  1585. break;
  1586. }
  1587. }
  1588. }
  1590. c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
  1591. *yy_c_buf_p = ''; /* preserve yytext */
  1592. yy_hold_char = *++yy_c_buf_p;
  1595. return c;
  1596. }
  1597. #endif /* YY_NO_INPUT */
  1599. #ifdef YY_USE_PROTOS
  1600. void yyrestart( FILE *input_file )
  1601. #else
  1602. void yyrestart( input_file )
  1603. FILE *input_file;
  1604. #endif
  1605. {
  1606. if ( ! yy_current_buffer )
  1607. yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1609. yy_init_buffer( yy_current_buffer, input_file );
  1610. yy_load_buffer_state();
  1611. }
  1614. #ifdef YY_USE_PROTOS
  1615. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1616. #else
  1617. void yy_switch_to_buffer( new_buffer )
  1618. YY_BUFFER_STATE new_buffer;
  1619. #endif
  1620. {
  1621. if ( yy_current_buffer == new_buffer )
  1622. return;
  1624. if ( yy_current_buffer )
  1625. {
  1626. /* Flush out information for old buffer. */
  1627. *yy_c_buf_p = yy_hold_char;
  1628. yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1629. yy_current_buffer->yy_n_chars = yy_n_chars;
  1630. }
  1632. yy_current_buffer = new_buffer;
  1633. yy_load_buffer_state();
  1635. /* We don't actually know whether we did this switch during
  1636.  * EOF (yywrap()) processing, but the only time this flag
  1637.  * is looked at is after yywrap() is called, so it's safe
  1638.  * to go ahead and always set it.
  1639.  */
  1640. yy_did_buffer_switch_on_eof = 1;
  1641. }
  1644. #ifdef YY_USE_PROTOS
  1645. void yy_load_buffer_state( void )
  1646. #else
  1647. void yy_load_buffer_state()
  1648. #endif
  1649. {
  1650. yy_n_chars = yy_current_buffer->yy_n_chars;
  1651. yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1652. yyin = yy_current_buffer->yy_input_file;
  1653. yy_hold_char = *yy_c_buf_p;
  1654. }
  1657. #ifdef YY_USE_PROTOS
  1658. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1659. #else
  1660. YY_BUFFER_STATE yy_create_buffer( file, size )
  1661. FILE *file;
  1662. int size;
  1663. #endif
  1664. {
  1665. YY_BUFFER_STATE b;
  1667. b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1668. if ( ! b )
  1669. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1671. b->yy_buf_size = size;
  1673. /* yy_ch_buf has to be 2 characters longer than the size given because
  1674.  * we need to put in 2 end-of-buffer characters.
  1675.  */
  1676. b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1677. if ( ! b->yy_ch_buf )
  1678. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1680. b->yy_is_our_buffer = 1;
  1682. yy_init_buffer( b, file );
  1684. return b;
  1685. }
  1688. #ifdef YY_USE_PROTOS
  1689. void yy_delete_buffer( YY_BUFFER_STATE b )
  1690. #else
  1691. void yy_delete_buffer( b )
  1692. YY_BUFFER_STATE b;
  1693. #endif
  1694. {
  1695. if ( ! b )
  1696. return;
  1698. if ( b == yy_current_buffer )
  1699. yy_current_buffer = (YY_BUFFER_STATE) 0;
  1701. if ( b->yy_is_our_buffer )
  1702. yy_flex_free( (void *) b->yy_ch_buf );
  1704. yy_flex_free( (void *) b );
  1705. }
  1709. #ifdef YY_USE_PROTOS
  1710. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1711. #else
  1712. void yy_init_buffer( b, file )
  1713. YY_BUFFER_STATE b;
  1714. FILE *file;
  1715. #endif
  1718. {
  1719. yy_flush_buffer( b );
  1721. b->yy_input_file = file;
  1722. b->yy_fill_buffer = 1;
  1724. #if YY_ALWAYS_INTERACTIVE
  1725. b->yy_is_interactive = 1;
  1726. #else
  1727. #if YY_NEVER_INTERACTIVE
  1728. b->yy_is_interactive = 0;
  1729. #else
  1730. b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
  1731. #endif
  1732. #endif
  1733. }
  1736. #ifdef YY_USE_PROTOS
  1737. void yy_flush_buffer( YY_BUFFER_STATE b )
  1738. #else
  1739. void yy_flush_buffer( b )
  1740. YY_BUFFER_STATE b;
  1741. #endif
  1743. {
  1744. if ( ! b )
  1745. return;
  1747. b->yy_n_chars = 0;
  1749. /* We always need two end-of-buffer characters.  The first causes
  1750.  * a transition to the end-of-buffer state.  The second causes
  1751.  * a jam in that state.
  1752.  */
  1753. b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1754. b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1756. b->yy_buf_pos = &b->yy_ch_buf[0];
  1758. b->yy_at_bol = 1;
  1759. b->yy_buffer_status = YY_BUFFER_NEW;
  1761. if ( b == yy_current_buffer )
  1762. yy_load_buffer_state();
  1763. }
  1766. #ifndef YY_NO_SCAN_BUFFER
  1767. #ifdef YY_USE_PROTOS
  1768. YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  1769. #else
  1770. YY_BUFFER_STATE yy_scan_buffer( base, size )
  1771. char *base;
  1772. yy_size_t size;
  1773. #endif
  1774. {
  1775. YY_BUFFER_STATE b;
  1777. if ( size < 2 ||
  1778.      base[size-2] != YY_END_OF_BUFFER_CHAR ||
  1779.      base[size-1] != YY_END_OF_BUFFER_CHAR )
  1780. /* They forgot to leave room for the EOB's. */
  1781. return 0;
  1783. b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1784. if ( ! b )
  1785. YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
  1787. b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
  1788. b->yy_buf_pos = b->yy_ch_buf = base;
  1789. b->yy_is_our_buffer = 0;
  1790. b->yy_input_file = 0;
  1791. b->yy_n_chars = b->yy_buf_size;
  1792. b->yy_is_interactive = 0;
  1793. b->yy_at_bol = 1;
  1794. b->yy_fill_buffer = 0;
  1795. b->yy_buffer_status = YY_BUFFER_NEW;
  1797. yy_switch_to_buffer( b );
  1799. return b;
  1800. }
  1801. #endif
  1804. #ifndef YY_NO_SCAN_STRING
  1805. #ifdef YY_USE_PROTOS
  1806. YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
  1807. #else
  1808. YY_BUFFER_STATE yy_scan_string( yy_str )
  1809. yyconst char *yy_str;
  1810. #endif
  1811. {
  1812. int len;
  1813. for ( len = 0; yy_str[len]; ++len )
  1814. ;
  1816. return yy_scan_bytes( yy_str, len );
  1817. }
  1818. #endif
  1821. #ifndef YY_NO_SCAN_BYTES
  1822. #ifdef YY_USE_PROTOS
  1823. YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
  1824. #else
  1825. YY_BUFFER_STATE yy_scan_bytes( bytes, len )
  1826. yyconst char *bytes;
  1827. int len;
  1828. #endif
  1829. {
  1830. YY_BUFFER_STATE b;
  1831. char *buf;
  1832. yy_size_t n;
  1833. int i;
  1835. /* Get memory for full buffer, including space for trailing EOB's. */
  1836. n = len + 2;
  1837. buf = (char *) yy_flex_alloc( n );
  1838. if ( ! buf )
  1839. YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
  1841. for ( i = 0; i < len; ++i )
  1842. buf[i] = bytes[i];
  1844. buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
  1846. b = yy_scan_buffer( buf, n );
  1847. if ( ! b )
  1848. YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
  1850. /* It's okay to grow etc. this buffer, and we should throw it
  1851.  * away when we're done.
  1852.  */
  1853. b->yy_is_our_buffer = 1;
  1855. return b;
  1856. }
  1857. #endif
  1860. #ifndef YY_NO_PUSH_STATE
  1861. #ifdef YY_USE_PROTOS
  1862. static void yy_push_state( int new_state )
  1863. #else
  1864. static void yy_push_state( new_state )
  1865. int new_state;
  1866. #endif
  1867. {
  1868. if ( yy_start_stack_ptr >= yy_start_stack_depth )
  1869. {
  1870. yy_size_t new_size;
  1872. yy_start_stack_depth += YY_START_STACK_INCR;
  1873. new_size = yy_start_stack_depth * sizeof( int );
  1875. if ( ! yy_start_stack )
  1876. yy_start_stack = (int *) yy_flex_alloc( new_size );
  1878. else
  1879. yy_start_stack = (int *) yy_flex_realloc(
  1880. (void *) yy_start_stack, new_size );
  1882. if ( ! yy_start_stack )
  1883. YY_FATAL_ERROR(
  1884. "out of memory expanding start-condition stack" );
  1885. }
  1887. yy_start_stack[yy_start_stack_ptr++] = YY_START;
  1889. BEGIN(new_state);
  1890. }
  1891. #endif
  1894. #ifndef YY_NO_POP_STATE
  1895. static void yy_pop_state()
  1896. {
  1897. if ( --yy_start_stack_ptr < 0 )
  1898. YY_FATAL_ERROR( "start-condition stack underflow" );
  1900. BEGIN(yy_start_stack[yy_start_stack_ptr]);
  1901. }
  1902. #endif
  1905. #ifndef YY_NO_TOP_STATE
  1906. static int yy_top_state()
  1907. {
  1908. return yy_start_stack[yy_start_stack_ptr - 1];
  1909. }
  1910. #endif
  1912. #ifndef YY_EXIT_FAILURE
  1913. #define YY_EXIT_FAILURE 2
  1914. #endif
  1916. #ifdef YY_USE_PROTOS
  1917. static void yy_fatal_error( yyconst char msg[] )
  1918. #else
  1919. static void yy_fatal_error( msg )
  1920. char msg[];
  1921. #endif
  1922. {
  1923. (void) fprintf( stderr, "%sn", msg );
  1924. exit( YY_EXIT_FAILURE );
  1925. }
  1929. /* Redefine yyless() so it works in section 3 code. */
  1931. #undef yyless
  1932. #define yyless(n) 
  1933. do 
  1934. { 
  1935. /* Undo effects of setting up yytext. */ 
  1936. yytext[yyleng] = yy_hold_char; 
  1937. yy_c_buf_p = yytext + n; 
  1938. yy_hold_char = *yy_c_buf_p; 
  1939. *yy_c_buf_p = ''; 
  1940. yyleng = n; 
  1941. } 
  1942. while ( 0 )
  1945. /* Internal utility routines. */
  1947. #ifndef yytext_ptr
  1948. #ifdef YY_USE_PROTOS
  1949. static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
  1950. #else
  1951. static void yy_flex_strncpy( s1, s2, n )
  1952. char *s1;
  1953. yyconst char *s2;
  1954. int n;
  1955. #endif
  1956. {
  1957. register int i;
  1958. for ( i = 0; i < n; ++i )
  1959. s1[i] = s2[i];
  1960. }
  1961. #endif
  1963. #ifdef YY_NEED_STRLEN
  1964. #ifdef YY_USE_PROTOS
  1965. static int yy_flex_strlen( yyconst char *s )
  1966. #else
  1967. static int yy_flex_strlen( s )
  1968. yyconst char *s;
  1969. #endif
  1970. {
  1971. register int n;
  1972. for ( n = 0; s[n]; ++n )
  1973. ;
  1975. return n;
  1976. }
  1977. #endif
  1980. #ifdef YY_USE_PROTOS
  1981. static void *yy_flex_alloc( yy_size_t size )
  1982. #else
  1983. static void *yy_flex_alloc( size )
  1984. yy_size_t size;
  1985. #endif
  1986. {
  1987. return (void *) malloc( size );
  1988. }
  1990. #ifdef YY_USE_PROTOS
  1991. static void *yy_flex_realloc( void *ptr, yy_size_t size )
  1992. #else
  1993. static void *yy_flex_realloc( ptr, size )
  1994. void *ptr;
  1995. yy_size_t size;
  1996. #endif
  1997. {
  1998. /* The cast to (char *) in the following accommodates both
  1999.  * implementations that use char* generic pointers, and those
  2000.  * that use void* generic pointers.  It works with the latter
  2001.  * because both ANSI C and C++ allow castless assignment from
  2002.  * any pointer type to void*, and deal with argument conversions
  2003.  * as though doing an assignment.
  2004.  */
  2005. return (void *) realloc( (char *) ptr, size );
  2006. }
  2008. #ifdef YY_USE_PROTOS
  2009. static void yy_flex_free( void *ptr )
  2010. #else
  2011. static void yy_flex_free( ptr )
  2012. void *ptr;
  2013. #endif
  2014. {
  2015. free( ptr );
  2016. }
  2018. #if YY_MAIN
  2019. int main()
  2020. {
  2021. yylex();
  2022. return 0;
  2023. }
  2024. #endif
  2025. #line 169 "CascadeFileScanner.l"