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

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

数据库系统

开发平台：

Unix_Linux

scan.l：源码内容
  1. %{
  2. /*-------------------------------------------------------------------------
  3.  *
  4.  * scan.l
  5.  *   lexical scanner for POSTGRES
  6.  *
  7.  * Copyright (c) 1994, Regents of the University of California
  8.  *
  9.  *
  10.  * IDENTIFICATION
  11.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/parser/scan.l,v 1.50 1999/07/08 00:00:43 momjian Exp $
  12.  *
  13.  *-------------------------------------------------------------------------
  14.  */
  15. #include <ctype.h>
  16. #include <unistd.h>
  17. #ifndef __linux__
  18. #include <math.h>
  19. #else
  20. #include <stdlib.h>
  21. #endif /* __linux__ */
  22. #include <string.h>
  23. #include <errno.h>
  25. #include "postgres.h"
  26. #include "miscadmin.h"
  27. #include "nodes/pg_list.h"
  28. #include "nodes/parsenodes.h"
  29. #include "parser/gramparse.h"
  30. #include "parser/keywords.h"
  31. #include "parser/scansup.h"
  32. #include "parse.h"
  33. #include "utils/builtins.h"
  35. #ifdef  YY_READ_BUF_SIZE
  36. #undef  YY_READ_BUF_SIZE
  37. #endif
  38. #define YY_READ_BUF_SIZE MAX_PARSE_BUFFER
  40. #ifdef  YY_READ_BUF_SIZE
  41. #undef  YY_READ_BUF_SIZE
  42. #endif
  43. #define YY_READ_BUF_SIZE MAX_PARSE_BUFFER
  45. extern char *parseString;
  46. static char *parseCh;
  48. /* some versions of lex define this as a macro */
  49. #if defined(yywrap)
  50. #undef yywrap
  51. #endif /* yywrap */
  53. #if defined(FLEX_SCANNER)
  54. /* MAX_PARSE_BUFFER is defined in miscadmin.h */
  55. #define YYLMAX MAX_PARSE_BUFFER
  56. #define YY_NO_UNPUT
  57. static int myinput(char* buf, int max);
  58. #undef YY_INPUT
  59. #define YY_INPUT(buf,result,max) {result = myinput(buf,max);}
  60. #else
  61. #undef input
  62. int input();
  63. #undef unput
  64. void unput(char);
  65. #endif /* FLEX_SCANNER */
  67. extern YYSTYPE yylval;
  69. int llen;
  70. char literal[MAX_PARSE_BUFFER];
  72. %}
  73. /* OK, here is a short description of lex/flex rules behavior.
  74.  * The longest pattern which matches an input string is always chosen.
  75.  * For equal-length patterns, the first occurring in the rules list is chosen.
  76.  * INITIAL is the starting condition, to which all non-conditional rules apply.
  77.  * When in an exclusive condition, only those rules defined for that condition apply.
  78.  *
  79.  * Exclusive states change parsing rules while the state is active.
  80.  * There are exclusive states for quoted strings, extended comments,
  81.  *  and to eliminate parsing troubles for numeric strings.
  82.  * Exclusive states:
  83.  *  <xb> binary numeric string - thomas 1997-11-16
  84.  *  <xc> extended C-style comments - tgl 1997-07-12
  85.  *  <xd> delimited identifiers (double-quoted identifiers) - tgl 1997-10-27
  86.  *  <xh> hexadecimal numeric string - thomas 1997-11-16
  87.  *  <xm> numeric strings with embedded minus sign - tgl 1997-09-05
  88.  *  <xq> quoted strings - tgl 1997-07-30
  89.  *
  90.  * The "extended comment" syntax closely resembles allowable operator syntax.
  91.  * So, when in condition <xc>, only strings which would terminate the
  92.  *  "extended comment" trigger any action other than "ignore".
  93.  * Be sure to match _any_ candidate comment, including those with appended
  94.  * operator-like symbols. - thomas 1997-07-14
  95.  */
  97. %x xb
  98. %x xc
  99. %x xd
  100. %x xh
  101. %x xm
  102. %x xq
  104. /* Binary number
  105.  */
  106. xbstart [bB]{quote}
  107. xbstop {quote}
  108. xbinside [^']*
  109. xbcat {quote}{space}*n{space}*{quote}
  111. /* Hexadecimal number
  112.  */
  113. xhstart [xX]{quote}
  114. xhstop {quote}
  115. xhinside [^']*
  116. xhcat {quote}{space}*n{space}*{quote}
  118. /* Extended quote
  119.  * xqdouble implements SQL92 embedded quote
  120.  * xqcat allows strings to cross input lines
  121.  * Note: reduction of '' and  sequences to output text is done in scanstr(),
  122.  * not by rules here.
  123.  */
  124. quote '
  125. xqstart {quote}
  126. xqstop {quote}
  127. xqdouble {quote}{quote}
  128. xqinside [^\']*
  129. xqliteral [\](.|n)
  130. xqcat {quote}{space}*n{space}*{quote}
  132. /* Delimited quote
  133.  * Allows embedded spaces and other special characters into identifiers.
  134.  */
  135. dquote "
  136. xdstart {dquote}
  137. xdstop {dquote}
  138. xdinside [^"]*
  140. /* Comments
  141.  * Ignored by the scanner and parser.
  142.  */
  143. xcline [/][*].*[*][/]{space}*n*
  144. xcstart [/][*]{op_and_self}*
  145. xcstop {op_and_self}*[*][/]({space}*|n)
  146. xcinside [^*]*
  147. xcstar [^/]
  149. digit [0-9]
  150. number [-+.0-9Ee]
  151. letter [200-377_A-Za-z]
  152. letter_or_digit [200-377_A-Za-z0-9]
  154. identifier {letter}{letter_or_digit}*
  156. typecast "::"
  158. self [,()[].;$:+-*/%^<>=|]
  159. op_and_self [~!@#^&|`?$:+-*/%<>=]
  160. operator {op_and_self}+
  162. xmstop -
  164. integer [-]?{digit}+
  165. decimal [-]?(({digit}*.{digit}+)|({digit}+.{digit}*))
  166. real [-]?((({digit}*.{digit}+)|({digit}+.{digit}*)|({digit}+))([Ee][-+]?{digit}+))
  167. /*
  168. real [-]?(((({digit}*.{digit}+)|({digit}+.{digit}*))([Ee][-+]?{digit}+)?)|({digit}+[Ee][-+]?{digit}+))
  169. */
  171. param ${integer}
  173. comment ("--"|"//").*n
  175. space [ tnf]
  176. other .
  178. /* DO NOT PUT ANY COMMENTS IN THE FOLLOWING SECTION.
  179.  * AT&T lex does not properly handle C-style comments in this second lex block.
  180.  * So, put comments here. tgl - 1997-09-08
  181.  *
  182.  * Quoted strings must allow some special characters such as single-quote
  183.  *  and newline.
  184.  * Embedded single-quotes are implemented both in the SQL/92-standard
  185.  *  style of two adjacent single quotes "''" and in the Postgres/Java style
  186.  *  of escaped-quote "'".
  187.  * Other embedded escaped characters are matched explicitly and the leading
  188.  *  backslash is dropped from the string. - thomas 1997-09-24
  189.  */
  191. %%
  192. {comment} { /* ignore */ }
  194. {xcline} { /* ignore */ }
  196. <xc>{xcstar} |
  197. {xcstart} { BEGIN(xc); }
  199. <xc>{xcstop} { BEGIN(INITIAL); }
  201. <xc>{xcinside} { /* ignore */ }
  203. {xbstart} {
  204. BEGIN(xb);
  205. llen = 0;
  206. *literal = '';
  207. }
  208. <xb>{xbstop} {
  209. char* endptr;
  211. BEGIN(INITIAL);
  212. errno = 0;
  213. yylval.ival = strtol((char *)literal,&endptr,2);
  214. if (*endptr != '' || errno == ERANGE)
  215. elog(ERROR,"Bad binary integer input '%s'",literal);
  216. return ICONST;
  217. }
  218. <xh>{xhinside} |
  219. <xb>{xbinside} {
  220. if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
  221. elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
  222. memcpy(literal+llen, yytext, yyleng+1);
  223. llen += yyleng;
  224. }
  225. <xh>{xhcat} |
  226. <xb>{xbcat} {
  227. }
  229. {xhstart} {
  230. BEGIN(xh);
  231. llen = 0;
  232. *literal = '';
  233. }
  234. <xh>{xhstop} {
  235. char* endptr;
  237. BEGIN(INITIAL);
  238. errno = 0;
  239. yylval.ival = strtol((char *)literal,&endptr,16);
  240. if (*endptr != '' || errno == ERANGE)
  241. elog(ERROR,"Bad hexadecimal integer input '%s'",literal);
  242. return ICONST;
  243. }
  245. {xqstart} {
  246. BEGIN(xq);
  247. llen = 0;
  248. *literal = '';
  249. }
  250. <xq>{xqstop} {
  251. BEGIN(INITIAL);
  252. yylval.str = pstrdup(scanstr(literal));
  253. return SCONST;
  254. }
  255. <xq>{xqdouble} |
  256. <xq>{xqinside} |
  257. <xq>{xqliteral} {
  258. if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
  259. elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
  260. memcpy(literal+llen, yytext, yyleng+1);
  261. llen += yyleng;
  262. }
  263. <xq>{xqcat} {
  264. }
  267. {xdstart} {
  268. BEGIN(xd);
  269. llen = 0;
  270. *literal = '';
  271. }
  272. <xd>{xdstop} {
  273. BEGIN(INITIAL);
  274. yylval.str = pstrdup(literal);
  275. return IDENT;
  276. }
  277. <xd>{xdinside} {
  278. if ((llen+yyleng) > (MAX_PARSE_BUFFER - 1))
  279. elog(ERROR,"quoted string parse buffer of %d chars exceeded",MAX_PARSE_BUFFER);
  280. memcpy(literal+llen, yytext, yyleng+1);
  281. llen += yyleng;
  282. }
  285. <xm>{space}* { /* ignore */ }
  286. <xm>{xmstop} {
  287. BEGIN(INITIAL);
  288. return yytext[0];
  289. }
  292. {typecast} { return TYPECAST; }
  294. {self}/{space}*-[.0-9] {
  295. BEGIN(xm);
  296. return yytext[0];
  297. }
  298. {self} {  return yytext[0]; }
  299. {self} {  return yytext[0]; }
  300. {operator}/-[.0-9] {
  301. yylval.str = pstrdup((char*)yytext);
  302. return Op;
  303. }
  304. {operator} {
  305. if (strcmp((char*)yytext,"!=") == 0)
  306. yylval.str = pstrdup("<>"); /* compatability */
  307. else
  308. yylval.str = pstrdup((char*)yytext);
  309. return Op;
  310. }
  311. {param} {
  312. yylval.ival = atoi((char*)&yytext[1]);
  313. return PARAM;
  314. }
  317. {identifier}/{space}*-{number} {
  318. int i;
  319. ScanKeyword *keyword;
  321. BEGIN(xm);
  322. for(i = 0; yytext[i]; i++)
  323. if (isascii((unsigned char)yytext[i]) &&
  324. isupper(yytext[i]))
  325. yytext[i] = tolower(yytext[i]);
  326. if (i >= NAMEDATALEN)
  327. yytext[NAMEDATALEN-1] = '';
  329. keyword = ScanKeywordLookup((char*)yytext);
  330. if (keyword != NULL) {
  331. return keyword->value;
  332. }
  333. else
  334. {
  335. yylval.str = pstrdup((char*)yytext);
  336. return IDENT;
  337. }
  338. }
  339. {integer}/{space}*-{number} {
  340. char* endptr;
  342. BEGIN(xm);
  343. errno = 0;
  344. yylval.ival = strtol((char *)yytext,&endptr,10);
  345. if (*endptr != '' || errno == ERANGE)
  346. {
  347. errno = 0;
  348. #if 0
  349. yylval.dval = strtod(((char *)yytext),&endptr);
  350. if (*endptr != '' || errno == ERANGE)
  351. elog(ERROR,"Bad integer input '%s'",yytext);
  352. CheckFloat8Val(yylval.dval);
  353. elog(NOTICE,"Integer input '%s' is out of range; promoted to float", yytext);
  354. return FCONST;
  355. #endif
  356. yylval.str = pstrdup((char*)yytext);
  357. return SCONST;
  358. }
  359. return ICONST;
  360. }
  361. {decimal}/{space}*-{number} {
  362. char* endptr;
  364. BEGIN(xm);
  365. if (strlen((char *)yytext) <= 17)
  366. {
  367. errno = 0;
  368. yylval.dval = strtod(((char *)yytext),&endptr);
  369. if (*endptr != '' || errno == ERANGE)
  370. elog(ERROR,"Bad float8 input '%s'",yytext);
  371. CheckFloat8Val(yylval.dval);
  372. return FCONST;
  373. }
  374. yylval.str = pstrdup((char*)yytext);
  375. return SCONST;
  376. }
  377. {real}/{space}*-{number} {
  378. char* endptr;
  380. BEGIN(xm);
  381. errno = 0;
  382. yylval.dval = strtod(((char *)yytext),&endptr);
  383. if (*endptr != '' || errno == ERANGE)
  384. elog(ERROR,"Bad float8 input '%s'",yytext);
  385. CheckFloat8Val(yylval.dval);
  386. return FCONST;
  387. }
  388. {integer} {
  389. char* endptr;
  391. errno = 0;
  392. yylval.ival = strtol((char *)yytext,&endptr,10);
  393. if (*endptr != '' || errno == ERANGE)
  394. {
  395. errno = 0;
  396. #if 0
  397. yylval.dval = strtod(((char *)yytext),&endptr);
  398. if (*endptr != '' || errno == ERANGE)
  399. elog(ERROR,"Bad integer input '%s'",yytext);
  400. CheckFloat8Val(yylval.dval);
  401. elog(NOTICE,"Integer input '%s' is out of range; promoted to float", yytext);
  402. return FCONST;
  403. #endif
  404. yylval.str = pstrdup((char*)yytext);
  405. return SCONST;
  406. }
  407. return ICONST;
  408. }
  409. {decimal} {
  410. char* endptr;
  412. if (strlen((char *)yytext) <= 17)
  413. {
  414. errno = 0;
  415. yylval.dval = strtod((char *)yytext,&endptr);
  416. if (*endptr != '' || errno == ERANGE)
  417. elog(ERROR,"Bad float input '%s'",yytext);
  418. CheckFloat8Val(yylval.dval);
  419. return FCONST;
  420. }
  421. yylval.str = pstrdup((char*)yytext);
  422. return SCONST;
  423. }
  424. {real} {
  425. char* endptr;
  427. errno = 0;
  428. yylval.dval = strtod((char *)yytext,&endptr);
  429. if (*endptr != '' || errno == ERANGE)
  430. elog(ERROR,"Bad float input '%s'",yytext);
  431. CheckFloat8Val(yylval.dval);
  432. return FCONST;
  433. }
  436. {identifier} {
  437. int i;
  438. ScanKeyword *keyword;
  440. for(i = 0; yytext[i]; i++)
  441. if (isascii((unsigned char)yytext[i]) &&
  442. isupper(yytext[i]))
  443. yytext[i] = tolower(yytext[i]);
  444. if (i >= NAMEDATALEN)
  445. yytext[NAMEDATALEN-1] = '';
  447. keyword = ScanKeywordLookup((char*)yytext);
  448. if (keyword != NULL) {
  449. return keyword->value;
  450. }
  451. else
  452. {
  453. yylval.str = pstrdup((char*)yytext);
  454. return IDENT;
  455. }
  456. }
  457. {space} { /* ignore */ }
  459. {other} { return yytext[0]; }
  461. %%
  463. void yyerror(char message[])
  464. {
  465. elog(ERROR, "parser: %s at or near "%s"", message, yytext);
  466. }
  468. int yywrap()
  469. {
  470. return(1);
  471. }
  473. /*
  474.  init_io:
  475. called by postgres before any actual parsing is done
  476. */
  477. void
  478. init_io()
  479. {
  480. /* it's important to set this to NULL
  481.    because input()/myinput() checks the non-nullness of parseCh
  482.    to know when to pass the string to lex/flex */
  483. parseCh = NULL;
  484. #if defined(FLEX_SCANNER)
  485. if (YY_CURRENT_BUFFER)
  486. yy_flush_buffer(YY_CURRENT_BUFFER);
  487. #endif /* FLEX_SCANNER */
  488. BEGIN INITIAL;
  489. }
  491. #if !defined(FLEX_SCANNER)
  492. /* get lex input from a string instead of from stdin */
  493. int
  494. input()
  495. {
  496. if (parseCh == NULL)
  497. {
  498. parseCh = parseString;
  499. return(*parseCh++);
  500. }
  501. else if (*parseCh == '')
  502. return(0);
  503. else
  504. return(*parseCh++);
  505. }
  507. /* undo lex input from a string instead of from stdin */
  508. void
  509. unput(char c)
  510. {
  511. if (parseCh == NULL)
  512. elog(FATAL, "Unput() failed.n");
  513. else if (c != 0)
  514. *--parseCh = c;
  515. }
  516. #endif /* !defined(FLEX_SCANNER) */
  518. #ifdef FLEX_SCANNER
  519. /* input routine for flex to read input from a string instead of a file */
  520. static int
  521. myinput(char* buf, int max)
  522. {
  523. int len, copylen;
  525. if (parseCh == NULL)
  526. {
  527. len = strlen(parseString);
  528. if (len >= max)
  529. copylen = max - 1;
  530. else
  531. copylen = len;
  532. if (copylen > 0)
  533. memcpy(buf, parseString, copylen);
  534. buf[copylen] = '';
  535. parseCh = parseString;
  536. return copylen;
  537. }
  538. else
  539. return 0; /* end of string */
  540. }
  541. #endif /* FLEX_SCANNER */