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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
scan.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：59k
源码类别：

数据库系统

开发平台：

Unix_Linux

scan.c：源码内容
  1. /* A lexical scanner generated by flex */
  3. /* Scanner skeleton version:
  4.  * $FreeBSD: src/usr.bin/lex/skel.c,v 1.2.2.1 1999/08/29 15:29:33 peter Exp $
  5.  */
  7. #define FLEX_SCANNER
  8. #define YY_FLEX_MAJOR_VERSION 2
  9. #define YY_FLEX_MINOR_VERSION 5
  11. #include <stdio.h>
  14. /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  15. #ifdef c_plusplus
  16. #ifndef __cplusplus
  17. #define __cplusplus
  18. #endif
  19. #endif
  22. #ifdef __cplusplus
  24. #include <stdlib.h>
  25. #include <unistd.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 65536
  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)
  265. #define YY_USES_REJECT
  266. typedef unsigned char YY_CHAR;
  267. FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
  268. typedef int yy_state_type;
  269. extern char *yytext;
  270. #define yytext_ptr yytext
  272. static yy_state_type yy_get_previous_state YY_PROTO(( void ));
  273. static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
  274. static int yy_get_next_buffer YY_PROTO(( void ));
  275. static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
  277. /* Done after the current pattern has been matched and before the
  278.  * corresponding action - sets up yytext.
  279.  */
  280. #define YY_DO_BEFORE_ACTION 
  281. yytext_ptr = yy_bp; 
  282. yyleng = (int) (yy_cp - yy_bp); 
  283. yy_hold_char = *yy_cp; 
  284. *yy_cp = ''; 
  285. yy_c_buf_p = yy_cp;
  287. #define YY_NUM_RULES 43
  288. #define YY_END_OF_BUFFER 44
  289. static yyconst short int yy_acclist[181] =
  290.     {   0,
  291.        10,   10,    6,    6,   23,   23,    9,    9,   24,   24,
  292.        18,   18,   44,   42,   43,   41,   42,   43,   41,   43,
  293.        31,   42,   43,   21,   42,   43,   28,   29,   31,   42,
  294.        43,   28,   29,   31,   42,   43,   15,   42,   43,   28,
  295.        29,   42,   43,   28,   29,   31,   42,   43,   28,   29,
  296.        42,   43,   28,   29,   31,   42,   43,   37,   42,   43,
  297.     16418,   28,   29,   31,   42,   43,   40,   42,   43,16417,
  298.        40,   42,   43,16417,   40,   42,   43,16417,   10,   43,
  299.         8,   43,    3,    6,   43,    3,    6,   43,    3,   43,
  300.         6,   43,   23,   43,   22,   43,    9,   43,   14,   43,
  302.        43,   24,   43,   25,   43,   18,   43,   16,   43,   43,
  303.        31,   31,   31,   32,   31,   31,   37,16418,   38,16419,
  304.         4,   31,   31,   38,16419,   26,   31,   40,16417,    7,
  305.        13,   10,    6,    6,    5,   23,    9,   24,   18,   17,
  306.        19,   30,   27,   30,   27,   30,   32,   27,    1,   31,
  307.        31,   27,   30,    4,   31,    4,   31,    4,   31, 8226,
  308.        38,16419,   39,16420, 8225,   12,    5,   11,   20,   30,
  309.      8227,    2,    4,   31,   30,    2,    2,    2, 8228,    2
  310.     } ;
  312. static yyconst short int yy_accept[134] =
  313.     {   0,
  314.         1,    1,    1,    2,    3,    4,    5,    6,    7,    8,
  315.         9,   10,   11,   12,   13,   14,   16,   19,   21,   24,
  316.        27,   32,   37,   40,   44,   49,   53,   58,   62,   67,
  317.        71,   75,   79,   81,   83,   86,   89,   91,   93,   95,
  318.        97,   99,  101,  102,  104,  106,  108,  110,  111,  112,
  319.       113,  113,  114,  115,  116,  116,  117,  117,  119,  121,
  320.       123,  124,  124,  124,  126,  126,  128,  128,  128,  130,
  321.       131,  132,  133,  133,  133,  134,  135,  135,  135,  136,
  322.       137,  138,  138,  138,  139,  140,  140,  140,  141,  142,
  323.       143,  145,  148,  149,  149,  150,  151,  152,  154,  154,
  325.       154,  154,  156,  158,  160,  161,  163,  163,  165,  166,
  326.       166,  166,  167,  168,  168,  168,  169,  169,  169,  170,
  327.       171,  172,  172,  175,  176,  176,  176,  177,  178,  179,
  328.       180,  181,  181
  329.     } ;
  331. static yyconst int yy_ec[256] =
  332.     {   0,
  333.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  334.         1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
  335.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  336.         1,    2,    4,    5,    4,    6,    7,    4,    8,    9,
  337.         9,   10,   11,    9,   12,   13,   14,   15,   15,   15,
  338.        15,   15,   15,   15,   15,   15,   15,   16,    9,    7,
  339.         7,    7,    4,    4,   17,   18,   17,   17,   19,   17,
  340.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  341.        17,   17,   17,   17,   17,   17,   17,   20,   17,   17,
  342.         9,   21,    9,    7,   17,    4,   17,   18,   17,   17,
  344.        19,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  345.        17,   17,   17,   17,   17,   17,   17,   17,   17,   20,
  346.        17,   17,    1,    7,    1,    4,    1,   17,   17,   17,
  347.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  348.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  349.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  350.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  351.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  352.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  353.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  355.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  356.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  357.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  358.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  359.        17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
  360.        17,   17,   17,   17,   17
  361.     } ;
  363. static yyconst int yy_meta[22] =
  364.     {   0,
  365.         1,    2,    3,    4,    5,    4,    4,    6,    1,    7,
  366.         8,    9,   10,    4,   11,    4,    2,    2,   11,    2,
  367.        12
  368.     } ;
  370. static yyconst short int yy_base[153] =
  371.     {   0,
  372.         0,    0,  261,  260,   18,   31,  261,  248,  243,  234,
  373.        24,   37,   23,   25,  239,  466,  466,  466,  225,  466,
  374.        48,   40,  466,   54,   46,   65,   55,   79,  218,   71,
  375.        97,  220,    0,   51,    0,  106,   61,    0,    0,  466,
  376.         0,   76,  466,   82,  466,    0,   85,    0,  214,   89,
  377.        94,   49,  203,  190,   57,  122,  180,    0,  142,  158,
  378.       106,  144,    0,  177,   96,  170,  146,    0,  142,  466,
  379.       466,    0,   87,  173,    0,    0,  141,   93,  150,    0,
  380.         0,  112,  175,  164,    0,  177,  182,  466,  466,  466,
  381.       466,   80,  466,  187,  466,  200,  158,    0,  184,    0,
  383.        76,  213,   62,  200,  466,    0,   33,  228,  466,  230,
  384.       233,  466,  186,  242,  244,  466,  246,  253,  466,    0,
  385.       466,  149,  206,   13,  255,    0,  260,  262,  219,  466,
  386.       257,  466,  272,  284,  296,  308,  320,  332,  341,  349,
  387.       360,  372,  381,  390,  402,  414,  425,  437,  442,  446,
  388.       450,  454
  389.     } ;
  391. static yyconst short int yy_def[153] =
  392.     {   0,
  393.       132,    1,  133,  133,  134,  134,  135,  135,  136,  136,
  394.       137,  137,  138,  138,  132,  132,  132,  132,  139,  132,
  395.       139,   21,  132,  132,   21,  132,   22,  132,   22,  140,
  396.       140,   31,  141,  132,  142,  142,  143,   36,  144,  132,
  397.       145,  132,  132,  132,  132,  146,  132,  147,  139,  139,
  398.       132,   50,  132,   52,  132,  132,  132,   28,  132,  148,
  399.        56,  132,  149,   59,  132,  139,  132,  150,   31,  132,
  400.       132,  141,  132,  132,  142,   36,  143,  143,  143,  144,
  401.       145,  132,  132,  132,  146,  132,  132,  132,  132,  132,
  402.       132,  132,  132,   56,  132,   94,   96,   94,  132,  151,
  404.       148,  148,  102,  102,  132,   64,  132,  132,  132,  132,
  405.       132,  132,  132,  132,  132,  132,  132,  132,  132,   94,
  406.       132,  148,  102,  148,  132,  152,  148,  148,  132,  132,
  407.       132,    0,  132,  132,  132,  132,  132,  132,  132,  132,
  408.       132,  132,  132,  132,  132,  132,  132,  132,  132,  132,
  409.       132,  132
  410.     } ;
  412. static yyconst short int yy_nxt[488] =
  413.     {   0,
  414.        16,   17,   18,   19,   20,   21,   22,   23,   24,   22,
  415.        22,   25,   26,   27,   28,   29,   30,   31,   30,   32,
  416.        16,   36,  122,   36,   36,   44,   44,   37,   36,   36,
  417.        47,   38,   47,   36,   36,   45,   36,   36,   44,   44,
  418.        37,   36,   36,   48,   38,   48,   36,  108,   45,   51,
  419.        51,   54,   73,   74,  132,   51,   51,   56,   57,   52,
  420.        58,   91,   53,   92,   60,   55,   51,   51,   61,   93,
  421.        77,   93,   67,   67,   79,  123,   55,   82,   83,   59,
  422.        62,   62,   68,   84,   84,  122,   86,   87,   73,   74,
  423.        63,   64,   88,   58,   53,   51,   51,   65,   67,   67,
  425.        50,   90,   77,   90,   70,   55,  107,  107,   68,   76,
  426.       108,   76,   76,   82,   83,   77,   76,   76,   94,   76,
  427.        94,   76,   94,   94,   95,   96,   94,   96,   96,   94,
  428.        94,   96,   96,   97,   98,   96,   98,   96,   94,   94,
  429.        94,   94,   94,   99,   99,   62,   62,   67,   67,  132,
  430.        77,  113,  113,  100,   79,   63,   59,   68,  122,   77,
  431.        65,  102,  127,  102,  102,   84,   84,  103,  102,  104,
  432.       120,  102,  120,  102,  110,  111,  114,  115,   86,   87,
  433.       112,   50,  116,  117,  118,   99,   99,  113,  113,  119,
  434.        94,  106,   94,   94,   59,  100,   94,   94,   94,   94,
  436.        94,   94,   94,   96,   91,   96,   96,  128,  129,   96,
  437.        96,   97,  124,   96,  124,   96,  102,   53,  102,  102,
  438.       131,  129,  103,  102,  104,   50,  102,   71,  102,  125,
  439.       125,  110,  111,   66,  110,  111,   50,  112,  132,  126,
  440.       112,   42,  108,  114,  115,  114,  115,  117,  118,  116,
  441.        42,  116,   40,  119,  117,  118,  125,  125,  131,  129,
  442.       119,  128,  129,  128,  129,   40,  126,   34,   34,  122,
  443.       132,  122,   33,   33,   33,   33,   33,   33,   33,   33,
  444.        33,   33,   33,   33,   35,   35,   35,   35,   35,   35,
  445.        35,   35,   35,   35,   35,   35,   39,   39,   39,   39,
  447.        39,   39,   39,   39,   39,   39,   39,   39,   41,   41,
  448.        41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
  449.        43,   43,   43,   43,   43,   43,   43,   43,   43,   43,
  450.        43,   43,   46,   46,   46,   46,   46,   46,   46,   46,
  451.        46,   46,   46,   46,   49,  132,  132,   49,   49,   49,
  452.        69,   69,  132,  132,  132,  132,  132,   69,  132,   69,
  453.        72,   72,   72,   72,   72,  132,   72,   72,   72,   72,
  454.        72,   72,   75,   75,   75,   75,   75,   75,  132,   75,
  455.        75,   75,   75,   75,   78,  132,  132,   78,   78,   78,
  456.        80,   80,   80,   80,  132,   80,   80,   80,   80,   80,
  458.        80,   80,   81,   81,   81,   81,   81,  132,   81,   81,
  459.        81,   81,   81,   81,   85,   85,   85,   85,   85,  132,
  460.        85,   85,   85,   85,   85,   89,   89,   89,   89,   89,
  461.        89,   89,   89,   89,   89,   89,   89,  101,  101,  132,
  462.       101,  101,  101,  101,  101,  101,  101,  101,  101,  105,
  463.       105,  105,  105,  109,  109,  109,  109,  121,  121,  121,
  464.       121,  130,  130,  130,  130,   15,  132,  132,  132,  132,
  465.       132,  132,  132,  132,  132,  132,  132,  132,  132,  132,
  466.       132,  132,  132,  132,  132,  132,  132
  467.     } ;
  469. static yyconst short int yy_chk[488] =
  470.     {   0,
  471.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  472.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  473.         1,    5,  124,    5,    5,   11,   11,    5,    5,    5,
  474.        13,    5,   14,    5,    6,   11,    6,    6,   12,   12,
  475.         6,    6,    6,   13,    6,   14,    6,  107,   12,   21,
  476.        21,   22,   34,   34,   22,   24,   24,   25,   25,   21,
  477.        25,   52,   21,   52,   27,   24,   26,   26,   27,   55,
  478.        37,   55,   30,   30,   37,  103,   26,   42,   42,   26,
  479.        28,   28,   30,   44,   44,  101,   47,   47,   73,   73,
  480.        28,   28,   47,   28,   92,   51,   51,   28,   31,   31,
  482.        50,   50,   78,   50,   31,   51,   65,   65,   31,   36,
  483.        65,   36,   36,   82,   82,   36,   36,   36,   61,   36,
  484.        61,   36,   56,   56,   56,   56,   56,   56,   56,   56,
  485.        56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
  486.        56,   56,   56,   59,   59,   62,   62,   67,   67,   69,
  487.        77,   79,   79,   59,   77,   62,   59,   67,  122,   79,
  488.        59,   60,  122,   60,   60,   84,   84,   60,   60,   60,
  489.        97,   60,   97,   60,   74,   74,   83,   83,   86,   86,
  490.        74,   66,   83,   87,   87,   99,   99,  113,  113,   87,
  491.        94,   64,   94,   94,   57,   99,   94,   94,   94,   94,
  493.        94,   94,   94,   96,   54,   96,   96,  123,  123,   96,
  494.        96,   96,  104,   96,  104,   96,  102,   53,  102,  102,
  495.       129,  129,  102,  102,  102,   49,  102,   32,  102,  108,
  496.       108,  110,  110,   29,  111,  111,   19,  110,   15,  108,
  497.       111,   10,  108,  114,  114,  115,  115,  117,  117,  114,
  498.         9,  115,    8,  117,  118,  118,  125,  125,  131,  131,
  499.       118,  127,  127,  128,  128,    7,  125,    4,    3,  127,
  500.         0,  128,  133,  133,  133,  133,  133,  133,  133,  133,
  501.       133,  133,  133,  133,  134,  134,  134,  134,  134,  134,
  502.       134,  134,  134,  134,  134,  134,  135,  135,  135,  135,
  504.       135,  135,  135,  135,  135,  135,  135,  135,  136,  136,
  505.       136,  136,  136,  136,  136,  136,  136,  136,  136,  136,
  506.       137,  137,  137,  137,  137,  137,  137,  137,  137,  137,
  507.       137,  137,  138,  138,  138,  138,  138,  138,  138,  138,
  508.       138,  138,  138,  138,  139,    0,    0,  139,  139,  139,
  509.       140,  140,    0,    0,    0,    0,    0,  140,    0,  140,
  510.       141,  141,  141,  141,  141,    0,  141,  141,  141,  141,
  511.       141,  141,  142,  142,  142,  142,  142,  142,    0,  142,
  512.       142,  142,  142,  142,  143,    0,    0,  143,  143,  143,
  513.       144,  144,  144,  144,    0,  144,  144,  144,  144,  144,
  515.       144,  144,  145,  145,  145,  145,  145,    0,  145,  145,
  516.       145,  145,  145,  145,  146,  146,  146,  146,  146,    0,
  517.       146,  146,  146,  146,  146,  147,  147,  147,  147,  147,
  518.       147,  147,  147,  147,  147,  147,  147,  148,  148,    0,
  519.       148,  148,  148,  148,  148,  148,  148,  148,  148,  149,
  520.       149,  149,  149,  150,  150,  150,  150,  151,  151,  151,
  521.       151,  152,  152,  152,  152,  132,  132,  132,  132,  132,
  522.       132,  132,  132,  132,  132,  132,  132,  132,  132,  132,
  523.       132,  132,  132,  132,  132,  132,  132
  524.     } ;
  526. static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
  527. static char *yy_full_match;
  528. static int yy_lp;
  529. static int yy_looking_for_trail_begin = 0;
  530. static int yy_full_lp;
  531. static int *yy_full_state;
  532. #define YY_TRAILING_MASK 0x2000
  533. #define YY_TRAILING_HEAD_MASK 0x4000
  534. #define REJECT 
  535. { 
  536. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ 
  537. yy_cp = yy_full_match; /* restore poss. backed-over text */ 
  538. yy_lp = yy_full_lp; /* restore orig. accepting pos. */ 
  539. yy_state_ptr = yy_full_state; /* restore orig. state */ 
  540. yy_current_state = *yy_state_ptr; /* restore curr. state */ 
  541. ++yy_lp; 
  542. goto find_rule; 
  543. }
  544. #define yymore() yymore_used_but_not_detected
  545. #define YY_MORE_ADJ 0
  546. #define YY_RESTORE_YY_MORE_OFFSET
  547. char *yytext;
  548. #line 1 "scan.l"
  549. #define INITIAL 0
  550. #line 2 "scan.l"
  551. /*-------------------------------------------------------------------------
  552.  *
  553.  * scan.l
  554.  *   lexical scanner for POSTGRES
  555.  *
  556.  * Copyright (c) 1994, Regents of the University of California
  557.  *
  558.  *
  559.  * IDENTIFICATION
  560.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/parser/scan.l,v 1.50 1999/07/08 00:00:43 momjian Exp $
  561.  *
  562.  *-------------------------------------------------------------------------
  563.  */
  564. #include <ctype.h>
  565. #include <unistd.h>
  566. #ifndef __linux__
  567. #include <math.h>
  568. #else
  569. #include <stdlib.h>
  570. #endif /* __linux__ */
  571. #include <string.h>
  572. #include <errno.h>
  574. #include "postgres.h"
  575. #include "miscadmin.h"
  576. #include "nodes/pg_list.h"
  577. #include "nodes/parsenodes.h"
  578. #include "parser/gramparse.h"
  579. #include "parser/keywords.h"
  580. #include "parser/scansup.h"
  581. #include "parse.h"
  582. #include "utils/builtins.h"
  584. #ifdef  YY_READ_BUF_SIZE
  585. #undef  YY_READ_BUF_SIZE
  586. #endif
  587. #define YY_READ_BUF_SIZE MAX_PARSE_BUFFER
  589. #ifdef  YY_READ_BUF_SIZE
  590. #undef  YY_READ_BUF_SIZE
  591. #endif
  592. #define YY_READ_BUF_SIZE MAX_PARSE_BUFFER
  594. extern char *parseString;
  595. static char *parseCh;
  597. /* some versions of lex define this as a macro */
  598. #if defined(yywrap)
  599. #undef yywrap
  600. #endif /* yywrap */
  602. #if defined(FLEX_SCANNER)
  603. /* MAX_PARSE_BUFFER is defined in miscadmin.h */
  604. #define YYLMAX MAX_PARSE_BUFFER
  605. #define YY_NO_UNPUT
  606. static int myinput(char* buf, int max);
  607. #undef YY_INPUT
  608. #define YY_INPUT(buf,result,max) {result = myinput(buf,max);}
  609. #else
  610. #undef input
  611. int input();
  612. #undef unput
  613. void unput(char);
  614. #endif /* FLEX_SCANNER */
  616. extern YYSTYPE yylval;
  618. int llen;
  619. char literal[MAX_PARSE_BUFFER];
  621. /* OK, here is a short description of lex/flex rules behavior.
  622.  * The longest pattern which matches an input string is always chosen.
  623.  * For equal-length patterns, the first occurring in the rules list is chosen.
  624.  * INITIAL is the starting condition, to which all non-conditional rules apply.
  625.  * When in an exclusive condition, only those rules defined for that condition apply.
  626.  *
  627.  * Exclusive states change parsing rules while the state is active.
  628.  * There are exclusive states for quoted strings, extended comments,
  629.  *  and to eliminate parsing troubles for numeric strings.
  630.  * Exclusive states:
  631.  *  <xb> binary numeric string - thomas 1997-11-16
  632.  *  <xc> extended C-style comments - tgl 1997-07-12
  633.  *  <xd> delimited identifiers (double-quoted identifiers) - tgl 1997-10-27
  634.  *  <xh> hexadecimal numeric string - thomas 1997-11-16
  635.  *  <xm> numeric strings with embedded minus sign - tgl 1997-09-05
  636.  *  <xq> quoted strings - tgl 1997-07-30
  637.  *
  638.  * The "extended comment" syntax closely resembles allowable operator syntax.
  639.  * So, when in condition <xc>, only strings which would terminate the
  640.  *  "extended comment" trigger any action other than "ignore".
  641.  * Be sure to match _any_ candidate comment, including those with appended
  642.  * operator-like symbols. - thomas 1997-07-14
  643.  */
  644. #define xb 1
  646. #define xc 2
  648. #define xd 3
  650. #define xh 4
  652. #define xm 5
  654. #define xq 6
  656. /* Binary number
  657.  */
  658. /* Hexadecimal number
  659.  */
  660. /* Extended quote
  661.  * xqdouble implements SQL92 embedded quote
  662.  * xqcat allows strings to cross input lines
  663.  * Note: reduction of '' and  sequences to output text is done in scanstr(),
  664.  * not by rules here.
  665.  */
  666. /* Delimited quote
  667.  * Allows embedded spaces and other special characters into identifiers.
  668.  */
  669. /* Comments
  670.  * Ignored by the scanner and parser.
  671.  */
  672. /*
  673. real [-]?(((({digit}*.{digit}+)|({digit}+.{digit}*))([Ee][-+]?{digit}+)?)|({digit}+[Ee][-+]?{digit}+))
  674. */
  675. /* DO NOT PUT ANY COMMENTS IN THE FOLLOWING SECTION.
  676.  * AT&T lex does not properly handle C-style comments in this second lex block.
  677.  * So, put comments here. tgl - 1997-09-08
  678.  *
  679.  * Quoted strings must allow some special characters such as single-quote
  680.  *  and newline.
  681.  * Embedded single-quotes are implemented both in the SQL/92-standard
  682.  *  style of two adjacent single quotes "''" and in the Postgres/Java style
  683.  *  of escaped-quote "'".
  684.  * Other embedded escaped characters are matched explicitly and the leading
  685.  *  backslash is dropped from the string. - thomas 1997-09-24
  686.  */
  687. #line 688 "lex.yy.c"
  689. /* Macros after this point can all be overridden by user definitions in
  690.  * section 1.
  691.  */
  693. #ifndef YY_SKIP_YYWRAP
  694. #ifdef __cplusplus
  695. extern "C" int yywrap YY_PROTO(( void ));
  696. #else
  697. extern int yywrap YY_PROTO(( void ));
  698. #endif
  699. #endif
  701. #ifndef YY_NO_UNPUT
  702. static void yyunput YY_PROTO(( int c, char *buf_ptr ));
  703. #endif
  705. #ifndef yytext_ptr
  706. static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
  707. #endif
  709. #ifdef YY_NEED_STRLEN
  710. static int yy_flex_strlen YY_PROTO(( yyconst char * ));
  711. #endif
  713. #ifndef YY_NO_INPUT
  714. #ifdef __cplusplus
  715. static int yyinput YY_PROTO(( void ));
  716. #else
  717. static int input YY_PROTO(( void ));
  718. #endif
  719. #endif
  721. #if YY_STACK_USED
  722. static int yy_start_stack_ptr = 0;
  723. static int yy_start_stack_depth = 0;
  724. static int *yy_start_stack = 0;
  725. #ifndef YY_NO_PUSH_STATE
  726. static void yy_push_state YY_PROTO(( int new_state ));
  727. #endif
  728. #ifndef YY_NO_POP_STATE
  729. static void yy_pop_state YY_PROTO(( void ));
  730. #endif
  731. #ifndef YY_NO_TOP_STATE
  732. static int yy_top_state YY_PROTO(( void ));
  733. #endif
  735. #else
  736. #define YY_NO_PUSH_STATE 1
  737. #define YY_NO_POP_STATE 1
  738. #define YY_NO_TOP_STATE 1
  739. #endif
  741. #ifdef YY_MALLOC_DECL
  742. YY_MALLOC_DECL
  743. #else
  744. #if __STDC__
  745. #ifndef __cplusplus
  746. #include <stdlib.h>
  747. #endif
  748. #else
  749. /* Just try to get by without declaring the routines.  This will fail
  750.  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
  751.  * or sizeof(void*) != sizeof(int).
  752.  */
  753. #endif
  754. #endif
  756. /* Amount of stuff to slurp up with each read. */
  757. #ifndef YY_READ_BUF_SIZE
  758. #define YY_READ_BUF_SIZE 8192
  759. #endif
  761. /* Copy whatever the last rule matched to the standard output. */
  763. #ifndef ECHO
  764. /* This used to be an fputs(), but since the string might contain NUL's,
  765.  * we now use fwrite().
  766.  */
  767. #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
  768. #endif
  770. /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
  771.  * is returned in "result".
  772.  */
  773. #ifndef YY_INPUT
  774. #define YY_INPUT(buf,result,max_size) 
  775. if ( yy_current_buffer->yy_is_interactive ) 
  776. { 
  777. int c = '*', n; 
  778. for ( n = 0; n < max_size && 
  779.      (c = getc( yyin )) != EOF && c != 'n'; ++n ) 
  780. buf[n] = (char) c; 
  781. if ( c == 'n' ) 
  782. buf[n++] = (char) c; 
  783. if ( c == EOF && ferror( yyin ) ) 
  784. YY_FATAL_ERROR( "input in flex scanner failed" ); 
  785. result = n; 
  786. } 
  787. else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) 
  788.   && ferror( yyin ) ) 
  789. YY_FATAL_ERROR( "input in flex scanner failed" );
  790. #endif
  792. /* No semi-colon after return; correct usage is to write "yyterminate();" -
  793.  * we don't want an extra ';' after the "return" because that will cause
  794.  * some compilers to complain about unreachable statements.
  795.  */
  796. #ifndef yyterminate
  797. #define yyterminate() return YY_NULL
  798. #endif
  800. /* Number of entries by which start-condition stack grows. */
  801. #ifndef YY_START_STACK_INCR
  802. #define YY_START_STACK_INCR 25
  803. #endif
  805. /* Report a fatal error. */
  806. #ifndef YY_FATAL_ERROR
  807. #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
  808. #endif
  810. /* Default declaration of generated scanner - a define so the user can
  811.  * easily add parameters.
  812.  */
  813. #ifndef YY_DECL
  814. #define YY_DECL int yylex YY_PROTO(( void ))
  815. #endif
  817. /* Code executed at the beginning of each rule, after yytext and yyleng
  818.  * have been set up.
  819.  */
  820. #ifndef YY_USER_ACTION
  821. #define YY_USER_ACTION
  822. #endif
  824. /* Code executed at the end of each rule. */
  825. #ifndef YY_BREAK
  826. #define YY_BREAK break;
  827. #endif
  829. #define YY_RULE_SETUP 
  830. YY_USER_ACTION
  832. YY_DECL
  833. {
  834. register yy_state_type yy_current_state;
  835. register char *yy_cp, *yy_bp;
  836. register int yy_act;
  838. #line 191 "scan.l"
  840. #line 841 "lex.yy.c"
  842. if ( yy_init )
  843. {
  844. yy_init = 0;
  846. #ifdef YY_USER_INIT
  847. YY_USER_INIT;
  848. #endif
  850. if ( ! yy_start )
  851. yy_start = 1; /* first start state */
  853. if ( ! yyin )
  854. yyin = stdin;
  856. if ( ! yyout )
  857. yyout = stdout;
  859. if ( ! yy_current_buffer )
  860. yy_current_buffer =
  861. yy_create_buffer( yyin, YY_BUF_SIZE );
  863. yy_load_buffer_state();
  864. }
  866. while ( 1 ) /* loops until end-of-file is reached */
  867. {
  868. yy_cp = yy_c_buf_p;
  870. /* Support of yytext. */
  871. *yy_cp = yy_hold_char;
  873. /* yy_bp points to the position in yy_ch_buf of the start of
  874.  * the current run.
  875.  */
  876. yy_bp = yy_cp;
  878. yy_current_state = yy_start;
  879. yy_state_ptr = yy_state_buf;
  880. *yy_state_ptr++ = yy_current_state;
  881. yy_match:
  882. do
  883. {
  884. register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
  885. while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  886. {
  887. yy_current_state = (int) yy_def[yy_current_state];
  888. if ( yy_current_state >= 133 )
  889. yy_c = yy_meta[(unsigned int) yy_c];
  890. }
  891. yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  892. *yy_state_ptr++ = yy_current_state;
  893. ++yy_cp;
  894. }
  895. while ( yy_base[yy_current_state] != 466 );
  897. yy_find_action:
  898. yy_current_state = *--yy_state_ptr;
  899. yy_lp = yy_accept[yy_current_state];
  900. find_rule: /* we branch to this label when backing up */
  901. for ( ; ; ) /* until we find what rule we matched */
  902. {
  903. if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
  904. {
  905. yy_act = yy_acclist[yy_lp];
  906. if ( yy_act & YY_TRAILING_HEAD_MASK ||
  907.      yy_looking_for_trail_begin )
  908. {
  909. if ( yy_act == yy_looking_for_trail_begin )
  910. {
  911. yy_looking_for_trail_begin = 0;
  912. yy_act &= ~YY_TRAILING_HEAD_MASK;
  913. break;
  914. }
  915. }
  916. else if ( yy_act & YY_TRAILING_MASK )
  917. {
  918. yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
  919. yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
  920. }
  921. else
  922. {
  923. yy_full_match = yy_cp;
  924. yy_full_state = yy_state_ptr;
  925. yy_full_lp = yy_lp;
  926. break;
  927. }
  928. ++yy_lp;
  929. goto find_rule;
  930. }
  931. --yy_cp;
  932. yy_current_state = *--yy_state_ptr;
  933. yy_lp = yy_accept[yy_current_state];
  934. }
  936. YY_DO_BEFORE_ACTION;
  939. do_action: /* This label is used only to access EOF actions. */
  942. switch ( yy_act )
  943. { /* beginning of action switch */
  944. case 1:
  945. YY_RULE_SETUP
  946. #line 192 "scan.l"
  947. { /* ignore */ }
  948. YY_BREAK
  949. case 2:
  950. YY_RULE_SETUP
  951. #line 194 "scan.l"
  952. { /* ignore */ }
  953. YY_BREAK
  954. case 3:
  955. #line 197 "scan.l"
  956. case 4:
  957. YY_RULE_SETUP
  958. #line 197 "scan.l"
  959. { BEGIN(xc); }
  960. YY_BREAK
  961. case 5:
  962. YY_RULE_SETUP
  963. #line 199 "scan.l"
  964. { BEGIN(INITIAL); }
  965. YY_BREAK
  966. case 6:
  967. YY_RULE_SETUP
  968. #line 201 "scan.l"
  969. { /* ignore */ }
  970. YY_BREAK
  971. case 7:
  972. YY_RULE_SETUP
  973. #line 203 "scan.l"
  974. {
  975. BEGIN(xb);
  976. llen = 0;
  977. *literal = '';
  978. }
  979. YY_BREAK
  980. case 8:
  981. YY_RULE_SETUP
  982. #line 208 "scan.l"
  983. {
  984. char* endptr;
  986. BEGIN(INITIAL);
  987. errno = 0;
  988. yylval.ival = strtol((char *)literal,&endptr,2);
  989. if (*endptr != '' || errno == ERANGE)
  990. elog(ERROR,"Bad binary integer input '%s'",literal);
  991. return ICONST;
  992. }
  993. YY_BREAK
  994. case 9:
  995. #line 219 "scan.l"
  996. case 10:
  997. YY_RULE_SETUP
  998. #line 219 "scan.l"
  999. {
  1000. if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
  1001. elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
  1002. memcpy(literal+llen, yytext, yyleng+1);
  1003. llen += yyleng;
  1004. }
  1005. YY_BREAK
  1006. case 11:
  1007. #line 226 "scan.l"
  1008. case 12:
  1009. YY_RULE_SETUP
  1010. #line 226 "scan.l"
  1011. {
  1012. }
  1013. YY_BREAK
  1014. case 13:
  1015. YY_RULE_SETUP
  1016. #line 229 "scan.l"
  1017. {
  1018. BEGIN(xh);
  1019. llen = 0;
  1020. *literal = '';
  1021. }
  1022. YY_BREAK
  1023. case 14:
  1024. YY_RULE_SETUP
  1025. #line 234 "scan.l"
  1026. {
  1027. char* endptr;
  1029. BEGIN(INITIAL);
  1030. errno = 0;
  1031. yylval.ival = strtol((char *)literal,&endptr,16);
  1032. if (*endptr != '' || errno == ERANGE)
  1033. elog(ERROR,"Bad hexadecimal integer input '%s'",literal);
  1034. return ICONST;
  1035. }
  1036. YY_BREAK
  1037. case 15:
  1038. YY_RULE_SETUP
  1039. #line 245 "scan.l"
  1040. {
  1041. BEGIN(xq);
  1042. llen = 0;
  1043. *literal = '';
  1044. }
  1045. YY_BREAK
  1046. case 16:
  1047. YY_RULE_SETUP
  1048. #line 250 "scan.l"
  1049. {
  1050. BEGIN(INITIAL);
  1051. yylval.str = pstrdup(scanstr(literal));
  1052. return SCONST;
  1053. }
  1054. YY_BREAK
  1055. case 17:
  1056. #line 256 "scan.l"
  1057. case 18:
  1058. #line 257 "scan.l"
  1059. case 19:
  1060. YY_RULE_SETUP
  1061. #line 257 "scan.l"
  1062. {
  1063. if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
  1064. elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
  1065. memcpy(literal+llen, yytext, yyleng+1);
  1066. llen += yyleng;
  1067. }
  1068. YY_BREAK
  1069. case 20:
  1070. YY_RULE_SETUP
  1071. #line 263 "scan.l"
  1072. {
  1073. }
  1074. YY_BREAK
  1075. case 21:
  1076. YY_RULE_SETUP
  1077. #line 267 "scan.l"
  1078. {
  1079. BEGIN(xd);
  1080. llen = 0;
  1081. *literal = '';
  1082. }
  1083. YY_BREAK
  1084. case 22:
  1085. YY_RULE_SETUP
  1086. #line 272 "scan.l"
  1087. {
  1088. BEGIN(INITIAL);
  1089. yylval.str = pstrdup(literal);
  1090. return IDENT;
  1091. }
  1092. YY_BREAK
  1093. case 23:
  1094. YY_RULE_SETUP
  1095. #line 277 "scan.l"
  1096. {
  1097. if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
  1098. elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
  1099. memcpy(literal+llen, yytext, yyleng+1);
  1100. llen += yyleng;
  1101. }
  1102. YY_BREAK
  1103. case 24:
  1104. YY_RULE_SETUP
  1105. #line 285 "scan.l"
  1106. { /* ignore */ }
  1107. YY_BREAK
  1108. case 25:
  1109. YY_RULE_SETUP
  1110. #line 286 "scan.l"
  1111. {
  1112. BEGIN(INITIAL);
  1113. return yytext[0];
  1114. }
  1115. YY_BREAK
  1116. case 26:
  1117. YY_RULE_SETUP
  1118. #line 292 "scan.l"
  1119. { return TYPECAST; }
  1120. YY_BREAK
  1121. case 27:
  1122. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  1123. yy_c_buf_p = yy_cp = yy_bp + 1;
  1124. YY_DO_BEFORE_ACTION; /* set up yytext again */
  1125. YY_RULE_SETUP
  1126. #line 294 "scan.l"
  1127. {
  1128. BEGIN(xm);
  1129. return yytext[0];
  1130. }
  1131. YY_BREAK
  1132. case 28:
  1133. YY_RULE_SETUP
  1134. #line 298 "scan.l"
  1135. {  return yytext[0]; }
  1136. YY_BREAK
  1137. case 29:
  1138. YY_RULE_SETUP
  1139. #line 299 "scan.l"
  1140. {  return yytext[0]; }
  1141. YY_BREAK
  1142. case 30:
  1143. *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
  1144. yy_c_buf_p = yy_cp -= 2;
  1145. YY_DO_BEFORE_ACTION; /* set up yytext again */
  1146. YY_RULE_SETUP
  1147. #line 300 "scan.l"
  1148. {
  1149. yylval.str = pstrdup((char*)yytext);
  1150. return Op;
  1151. }
  1152. YY_BREAK
  1153. case 31:
  1154. YY_RULE_SETUP
  1155. #line 304 "scan.l"
  1156. {
  1157. if (strcmp((char*)yytext,"!=") == 0)
  1158. yylval.str = pstrdup("<>"); /* compatability */
  1159. else
  1160. yylval.str = pstrdup((char*)yytext);
  1161. return Op;
  1162. }
  1163. YY_BREAK
  1164. case 32:
  1165. YY_RULE_SETUP
  1166. #line 311 "scan.l"
  1167. {
  1168. yylval.ival = atoi((char*)&yytext[1]);
  1169. return PARAM;
  1170. }
  1171. YY_BREAK
  1172. case 33:
  1173. YY_RULE_SETUP
  1174. #line 317 "scan.l"
  1175. {
  1176. int i;
  1177. ScanKeyword *keyword;
  1179. BEGIN(xm);
  1180. for(i = 0; yytext[i]; i++)
  1181. if (isascii((unsigned char)yytext[i]) &&
  1182. isupper(yytext[i]))
  1183. yytext[i] = tolower(yytext[i]);
  1184. if (i >= NAMEDATALEN)
  1185. yytext[NAMEDATALEN-1] = '';
  1187. keyword = ScanKeywordLookup((char*)yytext);
  1188. if (keyword != NULL) {
  1189. return keyword->value;
  1190. }
  1191. else
  1192. {
  1193. yylval.str = pstrdup((char*)yytext);
  1194. return IDENT;
  1195. }
  1196. }
  1197. YY_BREAK
  1198. case 34:
  1199. YY_RULE_SETUP
  1200. #line 339 "scan.l"
  1201. {
  1202. char* endptr;
  1204. BEGIN(xm);
  1205. errno = 0;
  1206. yylval.ival = strtol((char *)yytext,&endptr,10);
  1207. if (*endptr != '' || errno == ERANGE)
  1208. {
  1209. errno = 0;
  1210. #if 0
  1211. yylval.dval = strtod(((char *)yytext),&endptr);
  1212. if (*endptr != '' || errno == ERANGE)
  1213. elog(ERROR,"Bad integer input '%s'",yytext);
  1214. CheckFloat8Val(yylval.dval);
  1215. elog(NOTICE,"Integer input '%s' is out of range; promoted to float", yytext);
  1216. return FCONST;
  1217. #endif
  1218. yylval.str = pstrdup((char*)yytext);
  1219. return SCONST;
  1220. }
  1221. return ICONST;
  1222. }
  1223. YY_BREAK
  1224. case 35:
  1225. YY_RULE_SETUP
  1226. #line 361 "scan.l"
  1227. {
  1228. char* endptr;
  1230. BEGIN(xm);
  1231. if (strlen((char *)yytext) <= 17)
  1232. {
  1233. errno = 0;
  1234. yylval.dval = strtod(((char *)yytext),&endptr);
  1235. if (*endptr != '' || errno == ERANGE)
  1236. elog(ERROR,"Bad float8 input '%s'",yytext);
  1237. CheckFloat8Val(yylval.dval);
  1238. return FCONST;
  1239. }
  1240. yylval.str = pstrdup((char*)yytext);
  1241. return SCONST;
  1242. }
  1243. YY_BREAK
  1244. case 36:
  1245. YY_RULE_SETUP
  1246. #line 377 "scan.l"
  1247. {
  1248. char* endptr;
  1250. BEGIN(xm);
  1251. errno = 0;
  1252. yylval.dval = strtod(((char *)yytext),&endptr);
  1253. if (*endptr != '' || errno == ERANGE)
  1254. elog(ERROR,"Bad float8 input '%s'",yytext);
  1255. CheckFloat8Val(yylval.dval);
  1256. return FCONST;
  1257. }
  1258. YY_BREAK
  1259. case 37:
  1260. YY_RULE_SETUP
  1261. #line 388 "scan.l"
  1262. {
  1263. char* endptr;
  1265. errno = 0;
  1266. yylval.ival = strtol((char *)yytext,&endptr,10);
  1267. if (*endptr != '' || errno == ERANGE)
  1268. {
  1269. errno = 0;
  1270. #if 0
  1271. yylval.dval = strtod(((char *)yytext),&endptr);
  1272. if (*endptr != '' || errno == ERANGE)
  1273. elog(ERROR,"Bad integer input '%s'",yytext);
  1274. CheckFloat8Val(yylval.dval);
  1275. elog(NOTICE,"Integer input '%s' is out of range; promoted to float", yytext);
  1276. return FCONST;
  1277. #endif
  1278. yylval.str = pstrdup((char*)yytext);
  1279. return SCONST;
  1280. }
  1281. return ICONST;
  1282. }
  1283. YY_BREAK
  1284. case 38:
  1285. YY_RULE_SETUP
  1286. #line 409 "scan.l"
  1287. {
  1288. char* endptr;
  1290. if (strlen((char *)yytext) <= 17)
  1291. {
  1292. errno = 0;
  1293. yylval.dval = strtod((char *)yytext,&endptr);
  1294. if (*endptr != '' || errno == ERANGE)
  1295. elog(ERROR,"Bad float input '%s'",yytext);
  1296. CheckFloat8Val(yylval.dval);
  1297. return FCONST;
  1298. }
  1299. yylval.str = pstrdup((char*)yytext);
  1300. return SCONST;
  1301. }
  1302. YY_BREAK
  1303. case 39:
  1304. YY_RULE_SETUP
  1305. #line 424 "scan.l"
  1306. {
  1307. char* endptr;
  1309. errno = 0;
  1310. yylval.dval = strtod((char *)yytext,&endptr);
  1311. if (*endptr != '' || errno == ERANGE)
  1312. elog(ERROR,"Bad float input '%s'",yytext);
  1313. CheckFloat8Val(yylval.dval);
  1314. return FCONST;
  1315. }
  1316. YY_BREAK
  1317. case 40:
  1318. YY_RULE_SETUP
  1319. #line 436 "scan.l"
  1320. {
  1321. int i;
  1322. ScanKeyword *keyword;
  1324. for(i = 0; yytext[i]; i++)
  1325. if (isascii((unsigned char)yytext[i]) &&
  1326. isupper(yytext[i]))
  1327. yytext[i] = tolower(yytext[i]);
  1328. if (i >= NAMEDATALEN)
  1329. yytext[NAMEDATALEN-1] = '';
  1331. keyword = ScanKeywordLookup((char*)yytext);
  1332. if (keyword != NULL) {
  1333. return keyword->value;
  1334. }
  1335. else
  1336. {
  1337. yylval.str = pstrdup((char*)yytext);
  1338. return IDENT;
  1339. }
  1340. }
  1341. YY_BREAK
  1342. case 41:
  1343. YY_RULE_SETUP
  1344. #line 457 "scan.l"
  1345. { /* ignore */ }
  1346. YY_BREAK
  1347. case 42:
  1348. YY_RULE_SETUP
  1349. #line 459 "scan.l"
  1350. { return yytext[0]; }
  1351. YY_BREAK
  1352. case 43:
  1353. YY_RULE_SETUP
  1354. #line 461 "scan.l"
  1355. ECHO;
  1356. YY_BREAK
  1357. #line 1358 "lex.yy.c"
  1358. case YY_STATE_EOF(INITIAL):
  1359. case YY_STATE_EOF(xb):
  1360. case YY_STATE_EOF(xc):
  1361. case YY_STATE_EOF(xd):
  1362. case YY_STATE_EOF(xh):
  1363. case YY_STATE_EOF(xm):
  1364. case YY_STATE_EOF(xq):
  1365. yyterminate();
  1367. case YY_END_OF_BUFFER:
  1368. {
  1369. /* Amount of text matched not including the EOB char. */
  1370. int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
  1372. /* Undo the effects of YY_DO_BEFORE_ACTION. */
  1373. *yy_cp = yy_hold_char;
  1374. YY_RESTORE_YY_MORE_OFFSET
  1376. if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
  1377. {
  1378. /* We're scanning a new file or input source.  It's
  1379.  * possible that this happened because the user
  1380.  * just pointed yyin at a new source and called
  1381.  * yylex().  If so, then we have to assure
  1382.  * consistency between yy_current_buffer and our
  1383.  * globals.  Here is the right place to do so, because
  1384.  * this is the first action (other than possibly a
  1385.  * back-up) that will match for the new input source.
  1386.  */
  1387. yy_n_chars = yy_current_buffer->yy_n_chars;
  1388. yy_current_buffer->yy_input_file = yyin;
  1389. yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
  1390. }
  1392. /* Note that here we test for yy_c_buf_p "<=" to the position
  1393.  * of the first EOB in the buffer, since yy_c_buf_p will
  1394.  * already have been incremented past the NUL character
  1395.  * (since all states make transitions on EOB to the
  1396.  * end-of-buffer state).  Contrast this with the test
  1397.  * in input().
  1398.  */
  1399. if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1400. { /* This was really a NUL. */
  1401. yy_state_type yy_next_state;
  1403. yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
  1405. yy_current_state = yy_get_previous_state();
  1407. /* Okay, we're now positioned to make the NUL
  1408.  * transition.  We couldn't have
  1409.  * yy_get_previous_state() go ahead and do it
  1410.  * for us because it doesn't know how to deal
  1411.  * with the possibility of jamming (and we don't
  1412.  * want to build jamming into it because then it
  1413.  * will run more slowly).
  1414.  */
  1416. yy_next_state = yy_try_NUL_trans( yy_current_state );
  1418. yy_bp = yytext_ptr + YY_MORE_ADJ;
  1420. if ( yy_next_state )
  1421. {
  1422. /* Consume the NUL. */
  1423. yy_cp = ++yy_c_buf_p;
  1424. yy_current_state = yy_next_state;
  1425. goto yy_match;
  1426. }
  1428. else
  1429. {
  1430. yy_cp = yy_c_buf_p;
  1431. goto yy_find_action;
  1432. }
  1433. }
  1435. else switch ( yy_get_next_buffer() )
  1436. {
  1437. case EOB_ACT_END_OF_FILE:
  1438. {
  1439. yy_did_buffer_switch_on_eof = 0;
  1441. if ( yywrap() )
  1442. {
  1443. /* Note: because we've taken care in
  1444.  * yy_get_next_buffer() to have set up
  1445.  * yytext, we can now set up
  1446.  * yy_c_buf_p so that if some total
  1447.  * hoser (like flex itself) wants to
  1448.  * call the scanner after we return the
  1449.  * YY_NULL, it'll still work - another
  1450.  * YY_NULL will get returned.
  1451.  */
  1452. yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
  1454. yy_act = YY_STATE_EOF(YY_START);
  1455. goto do_action;
  1456. }
  1458. else
  1459. {
  1460. if ( ! yy_did_buffer_switch_on_eof )
  1461. YY_NEW_FILE;
  1462. }
  1463. break;
  1464. }
  1466. case EOB_ACT_CONTINUE_SCAN:
  1467. yy_c_buf_p =
  1468. yytext_ptr + yy_amount_of_matched_text;
  1470. yy_current_state = yy_get_previous_state();
  1472. yy_cp = yy_c_buf_p;
  1473. yy_bp = yytext_ptr + YY_MORE_ADJ;
  1474. goto yy_match;
  1476. case EOB_ACT_LAST_MATCH:
  1477. yy_c_buf_p =
  1478. &yy_current_buffer->yy_ch_buf[yy_n_chars];
  1480. yy_current_state = yy_get_previous_state();
  1482. yy_cp = yy_c_buf_p;
  1483. yy_bp = yytext_ptr + YY_MORE_ADJ;
  1484. goto yy_find_action;
  1485. }
  1486. break;
  1487. }
  1489. default:
  1490. YY_FATAL_ERROR(
  1491. "fatal flex scanner internal error--no action found" );
  1492. } /* end of action switch */
  1493. } /* end of scanning one token */
  1494. } /* end of yylex */
  1497. /* yy_get_next_buffer - try to read in a new buffer
  1498.  *
  1499.  * Returns a code representing an action:
  1500.  * EOB_ACT_LAST_MATCH -
  1501.  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
  1502.  * EOB_ACT_END_OF_FILE - end of file
  1503.  */
  1505. static int yy_get_next_buffer()
  1506. {
  1507. register char *dest = yy_current_buffer->yy_ch_buf;
  1508. register char *source = yytext_ptr;
  1509. register int number_to_move, i;
  1510. int ret_val;
  1512. if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
  1513. YY_FATAL_ERROR(
  1514. "fatal flex scanner internal error--end of buffer missed" );
  1516. if ( yy_current_buffer->yy_fill_buffer == 0 )
  1517. { /* Don't try to fill the buffer, so this is an EOF. */
  1518. if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
  1519. {
  1520. /* We matched a single character, the EOB, so
  1521.  * treat this as a final EOF.
  1522.  */
  1523. return EOB_ACT_END_OF_FILE;
  1524. }
  1526. else
  1527. {
  1528. /* We matched some text prior to the EOB, first
  1529.  * process it.
  1530.  */
  1531. return EOB_ACT_LAST_MATCH;
  1532. }
  1533. }
  1535. /* Try to read more data. */
  1537. /* First move last chars to start of buffer. */
  1538. number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
  1540. for ( i = 0; i < number_to_move; ++i )
  1541. *(dest++) = *(source++);
  1543. if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
  1544. /* don't do the read, it's not guaranteed to return an EOF,
  1545.  * just force an EOF
  1546.  */
  1547. yy_current_buffer->yy_n_chars = yy_n_chars = 0;
  1549. else
  1550. {
  1551. int num_to_read =
  1552. yy_current_buffer->yy_buf_size - number_to_move - 1;
  1554. while ( num_to_read <= 0 )
  1555. { /* Not enough room in the buffer - grow it. */
  1556. #ifdef YY_USES_REJECT
  1557. YY_FATAL_ERROR(
  1558. "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
  1559. #else
  1561. /* just a shorter name for the current buffer */
  1562. YY_BUFFER_STATE b = yy_current_buffer;
  1564. int yy_c_buf_p_offset =
  1565. (int) (yy_c_buf_p - b->yy_ch_buf);
  1567. if ( b->yy_is_our_buffer )
  1568. {
  1569. int new_size = b->yy_buf_size * 2;
  1571. if ( new_size <= 0 )
  1572. b->yy_buf_size += b->yy_buf_size / 8;
  1573. else
  1574. b->yy_buf_size *= 2;
  1576. b->yy_ch_buf = (char *)
  1577. /* Include room in for 2 EOB chars. */
  1578. yy_flex_realloc( (void *) b->yy_ch_buf,
  1579.  b->yy_buf_size + 2 );
  1580. }
  1581. else
  1582. /* Can't grow it, we don't own it. */
  1583. b->yy_ch_buf = 0;
  1585. if ( ! b->yy_ch_buf )
  1586. YY_FATAL_ERROR(
  1587. "fatal error - scanner input buffer overflow" );
  1589. yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
  1591. num_to_read = yy_current_buffer->yy_buf_size -
  1592. number_to_move - 1;
  1593. #endif
  1594. }
  1596. if ( num_to_read > YY_READ_BUF_SIZE )
  1597. num_to_read = YY_READ_BUF_SIZE;
  1599. /* Read in more data. */
  1600. YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
  1601. yy_n_chars, num_to_read );
  1603. yy_current_buffer->yy_n_chars = yy_n_chars;
  1604. }
  1606. if ( yy_n_chars == 0 )
  1607. {
  1608. if ( number_to_move == YY_MORE_ADJ )
  1609. {
  1610. ret_val = EOB_ACT_END_OF_FILE;
  1611. yyrestart( yyin );
  1612. }
  1614. else
  1615. {
  1616. ret_val = EOB_ACT_LAST_MATCH;
  1617. yy_current_buffer->yy_buffer_status =
  1618. YY_BUFFER_EOF_PENDING;
  1619. }
  1620. }
  1622. else
  1623. ret_val = EOB_ACT_CONTINUE_SCAN;
  1625. yy_n_chars += number_to_move;
  1626. yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
  1627. yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
  1629. yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
  1631. return ret_val;
  1632. }
  1635. /* yy_get_previous_state - get the state just before the EOB char was reached */
  1637. static yy_state_type yy_get_previous_state()
  1638. {
  1639. register yy_state_type yy_current_state;
  1640. register char *yy_cp;
  1642. yy_current_state = yy_start;
  1643. yy_state_ptr = yy_state_buf;
  1644. *yy_state_ptr++ = yy_current_state;
  1646. for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
  1647. {
  1648. register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
  1649. while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1650. {
  1651. yy_current_state = (int) yy_def[yy_current_state];
  1652. if ( yy_current_state >= 133 )
  1653. yy_c = yy_meta[(unsigned int) yy_c];
  1654. }
  1655. yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1656. *yy_state_ptr++ = yy_current_state;
  1657. }
  1659. return yy_current_state;
  1660. }
  1663. /* yy_try_NUL_trans - try to make a transition on the NUL character
  1664.  *
  1665.  * synopsis
  1666.  * next_state = yy_try_NUL_trans( current_state );
  1667.  */
  1669. #ifdef YY_USE_PROTOS
  1670. static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
  1671. #else
  1672. static yy_state_type yy_try_NUL_trans( yy_current_state )
  1673. yy_state_type yy_current_state;
  1674. #endif
  1675. {
  1676. register int yy_is_jam;
  1678. register YY_CHAR yy_c = 1;
  1679. while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
  1680. {
  1681. yy_current_state = (int) yy_def[yy_current_state];
  1682. if ( yy_current_state >= 133 )
  1683. yy_c = yy_meta[(unsigned int) yy_c];
  1684. }
  1685. yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  1686. yy_is_jam = (yy_current_state == 132);
  1687. if ( ! yy_is_jam )
  1688. *yy_state_ptr++ = yy_current_state;
  1690. return yy_is_jam ? 0 : yy_current_state;
  1691. }
  1694. #ifndef YY_NO_UNPUT
  1695. #ifdef YY_USE_PROTOS
  1696. static void yyunput( int c, register char *yy_bp )
  1697. #else
  1698. static void yyunput( c, yy_bp )
  1699. int c;
  1700. register char *yy_bp;
  1701. #endif
  1702. {
  1703. register char *yy_cp = yy_c_buf_p;
  1705. /* undo effects of setting up yytext */
  1706. *yy_cp = yy_hold_char;
  1708. if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1709. { /* need to shift things up to make room */
  1710. /* +2 for EOB chars. */
  1711. register int number_to_move = yy_n_chars + 2;
  1712. register char *dest = &yy_current_buffer->yy_ch_buf[
  1713. yy_current_buffer->yy_buf_size + 2];
  1714. register char *source =
  1715. &yy_current_buffer->yy_ch_buf[number_to_move];
  1717. while ( source > yy_current_buffer->yy_ch_buf )
  1718. *--dest = *--source;
  1720. yy_cp += (int) (dest - source);
  1721. yy_bp += (int) (dest - source);
  1722. yy_current_buffer->yy_n_chars =
  1723. yy_n_chars = yy_current_buffer->yy_buf_size;
  1725. if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
  1726. YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1727. }
  1729. *--yy_cp = (char) c;
  1732. yytext_ptr = yy_bp;
  1733. yy_hold_char = *yy_cp;
  1734. yy_c_buf_p = yy_cp;
  1735. }
  1736. #endif /* ifndef YY_NO_UNPUT */
  1739. #ifdef __cplusplus
  1740. static int yyinput()
  1741. #else
  1742. static int input()
  1743. #endif
  1744. {
  1745. int c;
  1747. *yy_c_buf_p = yy_hold_char;
  1749. if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
  1750. {
  1751. /* yy_c_buf_p now points to the character we want to return.
  1752.  * If this occurs *before* the EOB characters, then it's a
  1753.  * valid NUL; if not, then we've hit the end of the buffer.
  1754.  */
  1755. if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
  1756. /* This was really a NUL. */
  1757. *yy_c_buf_p = '';
  1759. else
  1760. { /* need more input */
  1761. int offset = yy_c_buf_p - yytext_ptr;
  1762. ++yy_c_buf_p;
  1764. switch ( yy_get_next_buffer() )
  1765. {
  1766. case EOB_ACT_LAST_MATCH:
  1767. /* This happens because yy_g_n_b()
  1768.  * sees that we've accumulated a
  1769.  * token and flags that we need to
  1770.  * try matching the token before
  1771.  * proceeding.  But for input(),
  1772.  * there's no matching to consider.
  1773.  * So convert the EOB_ACT_LAST_MATCH
  1774.  * to EOB_ACT_END_OF_FILE.
  1775.  */
  1777. /* Reset buffer status. */
  1778. yyrestart( yyin );
  1780. /* fall through */
  1782. case EOB_ACT_END_OF_FILE:
  1783. {
  1784. if ( yywrap() )
  1785. return EOF;
  1787. if ( ! yy_did_buffer_switch_on_eof )
  1788. YY_NEW_FILE;
  1789. #ifdef __cplusplus
  1790. return yyinput();
  1791. #else
  1792. return input();
  1793. #endif
  1794. }
  1796. case EOB_ACT_CONTINUE_SCAN:
  1797. yy_c_buf_p = yytext_ptr + offset;
  1798. break;
  1799. }
  1800. }
  1801. }
  1803. c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
  1804. *yy_c_buf_p = ''; /* preserve yytext */
  1805. yy_hold_char = *++yy_c_buf_p;
  1808. return c;
  1809. }
  1812. #ifdef YY_USE_PROTOS
  1813. void yyrestart( FILE *input_file )
  1814. #else
  1815. void yyrestart( input_file )
  1816. FILE *input_file;
  1817. #endif
  1818. {
  1819. if ( ! yy_current_buffer )
  1820. yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
  1822. yy_init_buffer( yy_current_buffer, input_file );
  1823. yy_load_buffer_state();
  1824. }
  1827. #ifdef YY_USE_PROTOS
  1828. void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
  1829. #else
  1830. void yy_switch_to_buffer( new_buffer )
  1831. YY_BUFFER_STATE new_buffer;
  1832. #endif
  1833. {
  1834. if ( yy_current_buffer == new_buffer )
  1835. return;
  1837. if ( yy_current_buffer )
  1838. {
  1839. /* Flush out information for old buffer. */
  1840. *yy_c_buf_p = yy_hold_char;
  1841. yy_current_buffer->yy_buf_pos = yy_c_buf_p;
  1842. yy_current_buffer->yy_n_chars = yy_n_chars;
  1843. }
  1845. yy_current_buffer = new_buffer;
  1846. yy_load_buffer_state();
  1848. /* We don't actually know whether we did this switch during
  1849.  * EOF (yywrap()) processing, but the only time this flag
  1850.  * is looked at is after yywrap() is called, so it's safe
  1851.  * to go ahead and always set it.
  1852.  */
  1853. yy_did_buffer_switch_on_eof = 1;
  1854. }
  1857. #ifdef YY_USE_PROTOS
  1858. void yy_load_buffer_state( void )
  1859. #else
  1860. void yy_load_buffer_state()
  1861. #endif
  1862. {
  1863. yy_n_chars = yy_current_buffer->yy_n_chars;
  1864. yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
  1865. yyin = yy_current_buffer->yy_input_file;
  1866. yy_hold_char = *yy_c_buf_p;
  1867. }
  1870. #ifdef YY_USE_PROTOS
  1871. YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
  1872. #else
  1873. YY_BUFFER_STATE yy_create_buffer( file, size )
  1874. FILE *file;
  1875. int size;
  1876. #endif
  1877. {
  1878. YY_BUFFER_STATE b;
  1880. b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  1881. if ( ! b )
  1882. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1884. b->yy_buf_size = size;
  1886. /* yy_ch_buf has to be 2 characters longer than the size given because
  1887.  * we need to put in 2 end-of-buffer characters.
  1888.  */
  1889. b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
  1890. if ( ! b->yy_ch_buf )
  1891. YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
  1893. b->yy_is_our_buffer = 1;
  1895. yy_init_buffer( b, file );
  1897. return b;
  1898. }
  1901. #ifdef YY_USE_PROTOS
  1902. void yy_delete_buffer( YY_BUFFER_STATE b )
  1903. #else
  1904. void yy_delete_buffer( b )
  1905. YY_BUFFER_STATE b;
  1906. #endif
  1907. {
  1908. if ( ! b )
  1909. return;
  1911. if ( b == yy_current_buffer )
  1912. yy_current_buffer = (YY_BUFFER_STATE) 0;
  1914. if ( b->yy_is_our_buffer )
  1915. yy_flex_free( (void *) b->yy_ch_buf );
  1917. yy_flex_free( (void *) b );
  1918. }
  1921. #ifndef YY_ALWAYS_INTERACTIVE
  1922. #ifndef YY_NEVER_INTERACTIVE
  1923. extern int isatty YY_PROTO(( int ));
  1924. #endif
  1925. #endif
  1927. #ifdef YY_USE_PROTOS
  1928. void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
  1929. #else
  1930. void yy_init_buffer( b, file )
  1931. YY_BUFFER_STATE b;
  1932. FILE *file;
  1933. #endif
  1936. {
  1937. yy_flush_buffer( b );
  1939. b->yy_input_file = file;
  1940. b->yy_fill_buffer = 1;
  1942. #if YY_ALWAYS_INTERACTIVE
  1943. b->yy_is_interactive = 1;
  1944. #else
  1945. #if YY_NEVER_INTERACTIVE
  1946. b->yy_is_interactive = 0;
  1947. #else
  1948. b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
  1949. #endif
  1950. #endif
  1951. }
  1954. #ifdef YY_USE_PROTOS
  1955. void yy_flush_buffer( YY_BUFFER_STATE b )
  1956. #else
  1957. void yy_flush_buffer( b )
  1958. YY_BUFFER_STATE b;
  1959. #endif
  1961. {
  1962. if ( ! b )
  1963. return;
  1965. b->yy_n_chars = 0;
  1967. /* We always need two end-of-buffer characters.  The first causes
  1968.  * a transition to the end-of-buffer state.  The second causes
  1969.  * a jam in that state.
  1970.  */
  1971. b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  1972. b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
  1974. b->yy_buf_pos = &b->yy_ch_buf[0];
  1976. b->yy_at_bol = 1;
  1977. b->yy_buffer_status = YY_BUFFER_NEW;
  1979. if ( b == yy_current_buffer )
  1980. yy_load_buffer_state();
  1981. }
  1984. #ifndef YY_NO_SCAN_BUFFER
  1985. #ifdef YY_USE_PROTOS
  1986. YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
  1987. #else
  1988. YY_BUFFER_STATE yy_scan_buffer( base, size )
  1989. char *base;
  1990. yy_size_t size;
  1991. #endif
  1992. {
  1993. YY_BUFFER_STATE b;
  1995. if ( size < 2 ||
  1996.      base[size-2] != YY_END_OF_BUFFER_CHAR ||
  1997.      base[size-1] != YY_END_OF_BUFFER_CHAR )
  1998. /* They forgot to leave room for the EOB's. */
  1999. return 0;
  2001. b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
  2002. if ( ! b )
  2003. YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
  2005. b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
  2006. b->yy_buf_pos = b->yy_ch_buf = base;
  2007. b->yy_is_our_buffer = 0;
  2008. b->yy_input_file = 0;
  2009. b->yy_n_chars = b->yy_buf_size;
  2010. b->yy_is_interactive = 0;
  2011. b->yy_at_bol = 1;
  2012. b->yy_fill_buffer = 0;
  2013. b->yy_buffer_status = YY_BUFFER_NEW;
  2015. yy_switch_to_buffer( b );
  2017. return b;
  2018. }
  2019. #endif
  2022. #ifndef YY_NO_SCAN_STRING
  2023. #ifdef YY_USE_PROTOS
  2024. YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
  2025. #else
  2026. YY_BUFFER_STATE yy_scan_string( yy_str )
  2027. yyconst char *yy_str;
  2028. #endif
  2029. {
  2030. int len;
  2031. for ( len = 0; yy_str[len]; ++len )
  2032. ;
  2034. return yy_scan_bytes( yy_str, len );
  2035. }
  2036. #endif
  2039. #ifndef YY_NO_SCAN_BYTES
  2040. #ifdef YY_USE_PROTOS
  2041. YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
  2042. #else
  2043. YY_BUFFER_STATE yy_scan_bytes( bytes, len )
  2044. yyconst char *bytes;
  2045. int len;
  2046. #endif
  2047. {
  2048. YY_BUFFER_STATE b;
  2049. char *buf;
  2050. yy_size_t n;
  2051. int i;
  2053. /* Get memory for full buffer, including space for trailing EOB's. */
  2054. n = len + 2;
  2055. buf = (char *) yy_flex_alloc( n );
  2056. if ( ! buf )
  2057. YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
  2059. for ( i = 0; i < len; ++i )
  2060. buf[i] = bytes[i];
  2062. buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
  2064. b = yy_scan_buffer( buf, n );
  2065. if ( ! b )
  2066. YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
  2068. /* It's okay to grow etc. this buffer, and we should throw it
  2069.  * away when we're done.
  2070.  */
  2071. b->yy_is_our_buffer = 1;
  2073. return b;
  2074. }
  2075. #endif
  2078. #ifndef YY_NO_PUSH_STATE
  2079. #ifdef YY_USE_PROTOS
  2080. static void yy_push_state( int new_state )
  2081. #else
  2082. static void yy_push_state( new_state )
  2083. int new_state;
  2084. #endif
  2085. {
  2086. if ( yy_start_stack_ptr >= yy_start_stack_depth )
  2087. {
  2088. yy_size_t new_size;
  2090. yy_start_stack_depth += YY_START_STACK_INCR;
  2091. new_size = yy_start_stack_depth * sizeof( int );
  2093. if ( ! yy_start_stack )
  2094. yy_start_stack = (int *) yy_flex_alloc( new_size );
  2096. else
  2097. yy_start_stack = (int *) yy_flex_realloc(
  2098. (void *) yy_start_stack, new_size );
  2100. if ( ! yy_start_stack )
  2101. YY_FATAL_ERROR(
  2102. "out of memory expanding start-condition stack" );
  2103. }
  2105. yy_start_stack[yy_start_stack_ptr++] = YY_START;
  2107. BEGIN(new_state);
  2108. }
  2109. #endif
  2112. #ifndef YY_NO_POP_STATE
  2113. static void yy_pop_state()
  2114. {
  2115. if ( --yy_start_stack_ptr < 0 )
  2116. YY_FATAL_ERROR( "start-condition stack underflow" );
  2118. BEGIN(yy_start_stack[yy_start_stack_ptr]);
  2119. }
  2120. #endif
  2123. #ifndef YY_NO_TOP_STATE
  2124. static int yy_top_state()
  2125. {
  2126. return yy_start_stack[yy_start_stack_ptr - 1];
  2127. }
  2128. #endif
  2130. #ifndef YY_EXIT_FAILURE
  2131. #define YY_EXIT_FAILURE 2
  2132. #endif
  2134. #ifdef YY_USE_PROTOS
  2135. static void yy_fatal_error( yyconst char msg[] )
  2136. #else
  2137. static void yy_fatal_error( msg )
  2138. char msg[];
  2139. #endif
  2140. {
  2141. (void) fprintf( stderr, "%sn", msg );
  2142. exit( YY_EXIT_FAILURE );
  2143. }
  2147. /* Redefine yyless() so it works in section 3 code. */
  2149. #undef yyless
  2150. #define yyless(n) 
  2151. do 
  2152. { 
  2153. /* Undo effects of setting up yytext. */ 
  2154. yytext[yyleng] = yy_hold_char; 
  2155. yy_c_buf_p = yytext + n; 
  2156. yy_hold_char = *yy_c_buf_p; 
  2157. *yy_c_buf_p = ''; 
  2158. yyleng = n; 
  2159. } 
  2160. while ( 0 )
  2163. /* Internal utility routines. */
  2165. #ifndef yytext_ptr
  2166. #ifdef YY_USE_PROTOS
  2167. static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
  2168. #else
  2169. static void yy_flex_strncpy( s1, s2, n )
  2170. char *s1;
  2171. yyconst char *s2;
  2172. int n;
  2173. #endif
  2174. {
  2175. register int i;
  2176. for ( i = 0; i < n; ++i )
  2177. s1[i] = s2[i];
  2178. }
  2179. #endif
  2181. #ifdef YY_NEED_STRLEN
  2182. #ifdef YY_USE_PROTOS
  2183. static int yy_flex_strlen( yyconst char *s )
  2184. #else
  2185. static int yy_flex_strlen( s )
  2186. yyconst char *s;
  2187. #endif
  2188. {
  2189. register int n;
  2190. for ( n = 0; s[n]; ++n )
  2191. ;
  2193. return n;
  2194. }
  2195. #endif
  2198. #ifdef YY_USE_PROTOS
  2199. static void *yy_flex_alloc( yy_size_t size )
  2200. #else
  2201. static void *yy_flex_alloc( size )
  2202. yy_size_t size;
  2203. #endif
  2204. {
  2205. return (void *) malloc( size );
  2206. }
  2208. #ifdef YY_USE_PROTOS
  2209. static void *yy_flex_realloc( void *ptr, yy_size_t size )
  2210. #else
  2211. static void *yy_flex_realloc( ptr, size )
  2212. void *ptr;
  2213. yy_size_t size;
  2214. #endif
  2215. {
  2216. /* The cast to (char *) in the following accommodates both
  2217.  * implementations that use char* generic pointers, and those
  2218.  * that use void* generic pointers.  It works with the latter
  2219.  * because both ANSI C and C++ allow castless assignment from
  2220.  * any pointer type to void*, and deal with argument conversions
  2221.  * as though doing an assignment.
  2222.  */
  2223. return (void *) realloc( (char *) ptr, size );
  2224. }
  2226. #ifdef YY_USE_PROTOS
  2227. static void yy_flex_free( void *ptr )
  2228. #else
  2229. static void yy_flex_free( ptr )
  2230. void *ptr;
  2231. #endif
  2232. {
  2233. free( ptr );
  2234. }
  2236. #if YY_MAIN
  2237. int main()
  2238. {
  2239. yylex();
  2240. return 0;
  2241. }
  2242. #endif
  2243. #line 461 "scan.l"
  2246. void yyerror(char message[])
  2247. {
  2248. elog(ERROR, "parser: %s at or near "%s"", message, yytext);
  2249. }
  2251. int yywrap()
  2252. {
  2253. return(1);
  2254. }
  2256. /*
  2257.  init_io:
  2258. called by postgres before any actual parsing is done
  2259. */
  2260. void
  2261. init_io()
  2262. {
  2263. /* it's important to set this to NULL
  2264.    because input()/myinput() checks the non-nullness of parseCh
  2265.    to know when to pass the string to lex/flex */
  2266. parseCh = NULL;
  2267. #if defined(FLEX_SCANNER)
  2268. if (YY_CURRENT_BUFFER)
  2269. yy_flush_buffer(YY_CURRENT_BUFFER);
  2270. #endif /* FLEX_SCANNER */
  2271. BEGIN INITIAL;
  2272. }
  2274. #if !defined(FLEX_SCANNER)
  2275. /* get lex input from a string instead of from stdin */
  2276. int
  2277. input()
  2278. {
  2279. if (parseCh == NULL)
  2280. {
  2281. parseCh = parseString;
  2282. return(*parseCh++);
  2283. }
  2284. else if (*parseCh == '')
  2285. return(0);
  2286. else
  2287. return(*parseCh++);
  2288. }
  2290. /* undo lex input from a string instead of from stdin */
  2291. void
  2292. unput(char c)
  2293. {
  2294. if (parseCh == NULL)
  2295. elog(FATAL, "Unput() failed.n");
  2296. else if (c != 0)
  2297. *--parseCh = c;
  2298. }
  2299. #endif /* !defined(FLEX_SCANNER) */
  2301. #ifdef FLEX_SCANNER
  2302. /* input routine for flex to read input from a string instead of a file */
  2303. static int
  2304. myinput(char* buf, int max)
  2305. {
  2306. int len, copylen;
  2308. if (parseCh == NULL)
  2309. {
  2310. len = strlen(parseString);
  2311. if (len >= max)
  2312. copylen = max - 1;
  2313. else
  2314. copylen = len;
  2315. if (copylen > 0)
  2316. memcpy(buf, parseString, copylen);
  2317. buf[copylen] = '';
  2318. parseCh = parseString;
  2319. return copylen;
  2320. }
  2321. else
  2322. return 0; /* end of string */
  2323. }
  2324. #endif /* FLEX_SCANNER */