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

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

数据库系统

开发平台：

Unix_Linux

gram.y：源码内容
  1. %{
  2. /**********************************************************************
  3.  * gram.y - Parser for the PL/pgSQL
  4.  *   procedural language
  5.  *
  6.  * IDENTIFICATION
  7.  *    $Header: /usr/local/cvsroot/pgsql/src/pl/plpgsql/src/gram.y,v 1.4.2.1 1999/08/16 19:55:46 momjian Exp $
  8.  *
  9.  *    This software is copyrighted by Jan Wieck - Hamburg.
  10.  *
  11.  *    The author hereby grants permission  to  use,  copy,  modify,
  12.  *    distribute,  and  license this software and its documentation
  13.  *    for any purpose, provided that existing copyright notices are
  14.  *    retained  in  all  copies  and  that  this notice is included
  15.  *    verbatim in any distributions. No written agreement, license,
  16.  *    or  royalty  fee  is required for any of the authorized uses.
  17.  *    Modifications to this software may be  copyrighted  by  their
  18.  *    author  and  need  not  follow  the licensing terms described
  19.  *    here, provided that the new terms are  clearly  indicated  on
  20.  *    the first page of each file where they apply.
  21.  *
  22.  *    IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY
  23.  *    PARTY  FOR  DIRECT,   INDIRECT,   SPECIAL,   INCIDENTAL,   OR
  24.  *    CONSEQUENTIAL   DAMAGES  ARISING  OUT  OF  THE  USE  OF  THIS
  25.  *    SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF, EVEN
  26.  *    IF  THE  AUTHOR  HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
  27.  *    DAMAGE.
  28.  *
  29.  *    THE  AUTHOR  AND  DISTRIBUTORS  SPECIFICALLY   DISCLAIM   ANY
  30.  *    WARRANTIES,  INCLUDING,  BUT  NOT  LIMITED  TO,  THE  IMPLIED
  31.  *    WARRANTIES  OF  MERCHANTABILITY,  FITNESS  FOR  A  PARTICULAR
  32.  *    PURPOSE,  AND NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON
  33.  *    AN "AS IS" BASIS, AND THE AUTHOR  AND  DISTRIBUTORS  HAVE  NO
  34.  *    OBLIGATION   TO   PROVIDE   MAINTENANCE,   SUPPORT,  UPDATES,
  35.  *    ENHANCEMENTS, OR MODIFICATIONS.
  36.  *
  37.  **********************************************************************/
  39. #include "stdio.h"
  40. #include "string.h"
  41. #include "plpgsql.h"
  43. #ifdef YYBISON
  44. #include "pl_scan.c" /* GNU bison wants it here */
  45. #endif
  47. static PLpgSQL_expr *read_sqlstmt(int until, char *s, char *sqlstart);
  48. static PLpgSQL_stmt *make_select_stmt(void);
  49. static PLpgSQL_expr *make_tupret_expr(PLpgSQL_row *row);
  51. %}
  53. %union {
  54. int32 ival;
  55. char *str;
  56. struct {
  57.     char *name;
  58.     int  lineno;
  59. } varname;
  60. struct {
  61.     int  nalloc;
  62.     int  nused;
  63.     int  *dtnums;
  64. } dtlist;
  65. struct {
  66.     int  reverse;
  67.     PLpgSQL_expr *expr;
  68. } forilow;
  69. struct {
  70.     char *label;
  71.     int  n_initvars;
  72.     int  *initvarnos;
  73. } declhdr;
  74. PLpgSQL_type *dtype;
  75. PLpgSQL_var *var;
  76. PLpgSQL_row *row;
  77. PLpgSQL_rec *rec;
  78. PLpgSQL_recfield *recfield;
  79. PLpgSQL_trigarg *trigarg;
  80. PLpgSQL_expr *expr;
  81. PLpgSQL_stmt *stmt;
  82. PLpgSQL_stmts *stmts;
  83. PLpgSQL_stmt_block *program;
  84. PLpgSQL_nsitem *nsitem;
  85. }
  87. %type <declhdr> decl_sect
  88. %type <varname> decl_varname
  89. %type <str> decl_renname
  90. %type <ival> decl_const, decl_notnull, decl_atttypmod, decl_atttypmodval
  91. %type <expr> decl_defval
  92. %type <dtype> decl_datatype, decl_dtypename
  93. %type <row> decl_rowtype
  94. %type <nsitem> decl_aliasitem
  95. %type <str> decl_stmts, decl_stmt
  97. %type <expr> expr_until_semi, expr_until_then, expr_until_loop
  98. %type <expr> opt_exitcond
  100. %type <ival> assign_var
  101. %type <var> fori_var
  102. %type <varname> fori_varname
  103. %type <forilow> fori_lower
  104. %type <rec> fors_target
  106. %type <str> opt_lblname, opt_label
  107. %type <str> opt_exitlabel
  108. %type <str> execsql_start
  110. %type <stmts> proc_sect, proc_stmts, stmt_else, loop_body
  111. %type <stmt> proc_stmt, pl_block
  112. %type <stmt> stmt_assign, stmt_if, stmt_loop, stmt_while, stmt_exit
  113. %type <stmt> stmt_return, stmt_raise, stmt_execsql, stmt_fori
  114. %type <stmt> stmt_fors, stmt_select, stmt_perform
  116. %type <dtlist> raise_params
  117. %type <ival> raise_level, raise_param
  118. %type <str> raise_msg
  120. %type <ival> lno
  122. /*
  123.  * Keyword tokens
  124.  */
  125. %token K_ALIAS
  126. %token K_ASSIGN
  127. %token K_BEGIN
  128. %token K_CONSTANT
  129. %token K_DEBUG
  130. %token K_DECLARE
  131. %token K_DEFAULT
  132. %token K_DOTDOT
  133. %token K_ELSE
  134. %token K_END
  135. %token K_EXCEPTION
  136. %token K_EXIT
  137. %token K_FOR
  138. %token K_FROM
  139. %token K_IF
  140. %token K_IN
  141. %token K_INTO
  142. %token K_LOOP
  143. %token K_NOT
  144. %token K_NOTICE
  145. %token K_NULL
  146. %token K_PERFORM
  147. %token K_RAISE
  148. %token K_RECORD
  149. %token K_RENAME
  150. %token K_RETURN
  151. %token K_REVERSE
  152. %token K_SELECT
  153. %token K_THEN
  154. %token K_TO
  155. %token K_TYPE
  156. %token K_WHEN
  157. %token K_WHILE
  159. /*
  160.  * Other tokens
  161.  */
  162. %token T_FUNCTION
  163. %token T_TRIGGER
  164. %token T_CHAR
  165. %token T_BPCHAR
  166. %token T_VARCHAR
  167. %token T_LABEL
  168. %token T_STRING
  169. %token T_VARIABLE
  170. %token T_ROW
  171. %token T_ROWTYPE
  172. %token T_RECORD
  173. %token T_RECFIELD
  174. %token T_TGARGV
  175. %token T_DTYPE
  176. %token T_WORD
  177. %token T_NUMBER
  178. %token T_ERROR
  180. %token O_OPTION
  181. %token O_DUMP
  183. %%
  185. pl_function : T_FUNCTION comp_optsect pl_block
  186.     {
  187. yylval.program = (PLpgSQL_stmt_block *)$3;
  188.     }
  189. | T_TRIGGER comp_optsect pl_block
  190.     {
  191. yylval.program = (PLpgSQL_stmt_block *)$3;
  192.     }
  193. ;
  195. comp_optsect :
  196. | comp_options
  197. ;
  199. comp_options : comp_options comp_option
  200. | comp_option
  201. ;
  203. comp_option : O_OPTION O_DUMP
  204.     {
  205.         plpgsql_DumpExecTree = 1;
  206.     }
  207. ;
  209. pl_block : decl_sect K_BEGIN lno proc_sect K_END ';'
  210.     {
  211.         PLpgSQL_stmt_block *new;
  213. new = malloc(sizeof(PLpgSQL_stmt_block));
  214. memset(new, 0, sizeof(PLpgSQL_stmt_block));
  216. new->cmd_type   = PLPGSQL_STMT_BLOCK;
  217. new->lineno     = $3;
  218. new->label      = $1.label;
  219. new->n_initvars = $1.n_initvars;
  220. new->initvarnos = $1.initvarnos;
  221. new->body       = $4;
  223. plpgsql_ns_pop();
  225. $$ = (PLpgSQL_stmt *)new;
  226.     }
  227. ;
  230. decl_sect : opt_label
  231.     {
  232.         plpgsql_ns_setlocal(false);
  233. $$.label      = $1;
  234. $$.n_initvars = 0;
  235. $$.initvarnos = NULL;
  236. plpgsql_add_initdatums(NULL);
  237.     }
  238. | opt_label decl_start
  239.     {
  240.         plpgsql_ns_setlocal(false);
  241. $$.label      = $1;
  242. $$.n_initvars = 0;
  243. $$.initvarnos = NULL;
  244. plpgsql_add_initdatums(NULL);
  245.     }
  246. | opt_label decl_start decl_stmts
  247.     {
  248.         plpgsql_ns_setlocal(false);
  249. if ($3 != NULL) {
  250.     $$.label = $3;
  251. } else {
  252.     $$.label = $1;
  253. }
  254. $$.n_initvars = plpgsql_add_initdatums(&($$.initvarnos));
  255.     }
  256. ;
  258. decl_start : K_DECLARE
  259.     {
  260.         plpgsql_ns_setlocal(true);
  261.     }
  262. ;
  264. decl_stmts : decl_stmts decl_stmt
  265.     {
  266.         $$ = $2;
  267.     }
  268. | decl_stmt
  269.     {
  270.         $$ = $1;
  271.     }
  272. ;
  274. decl_stmt : '<' '<' opt_lblname '>' '>'
  275.     {
  276. $$ = $3;
  277.     }
  278. | K_DECLARE
  279.     {
  280.         $$ = NULL;
  281.     }
  282. | decl_statement
  283.     {
  284.         $$ = NULL;
  285.     }
  286. ;
  288. decl_statement : decl_varname decl_const decl_datatype decl_notnull decl_defval
  289.     {
  290.         PLpgSQL_var *new;
  292. new = malloc(sizeof(PLpgSQL_var));
  294. new->dtype = PLPGSQL_DTYPE_VAR;
  295. new->refname = $1.name;
  296. new->lineno = $1.lineno;
  298. new->datatype = $3;
  299. new->isconst = $2;
  300. new->notnull = $4;
  301. new->default_val = $5;
  303. plpgsql_adddatum((PLpgSQL_datum *)new);
  304. plpgsql_ns_additem(PLPGSQL_NSTYPE_VAR, new->varno,
  305. $1.name);
  306.     }
  307. | decl_varname K_RECORD ';'
  308.     {
  309.         PLpgSQL_rec *new;
  311. new = malloc(sizeof(PLpgSQL_var));
  313. new->dtype = PLPGSQL_DTYPE_REC;
  314. new->refname = $1.name;
  315. new->lineno = $1.lineno;
  317. plpgsql_adddatum((PLpgSQL_datum *)new);
  318. plpgsql_ns_additem(PLPGSQL_NSTYPE_REC, new->recno,
  319. $1.name);
  320.     }
  321. | decl_varname decl_rowtype ';'
  322.     {
  323. $2->dtype = PLPGSQL_DTYPE_ROW;
  324. $2->refname = $1.name;
  325. $2->lineno = $1.lineno;
  327. plpgsql_adddatum((PLpgSQL_datum *)$2);
  328. plpgsql_ns_additem(PLPGSQL_NSTYPE_ROW, $2->rowno,
  329. $1.name);
  330.     }
  331. | decl_varname K_ALIAS K_FOR decl_aliasitem ';'
  332.     {
  333.         plpgsql_ns_additem($4->itemtype,
  334. $4->itemno, $1.name);
  335.     }
  336. | K_RENAME decl_renname K_TO decl_renname ';'
  337.     {
  338.         plpgsql_ns_rename($2, $4);
  339.     }
  340. ;
  342. decl_aliasitem : T_WORD
  343.     {
  344.         PLpgSQL_nsitem *nsi;
  345. char *name;
  347. plpgsql_ns_setlocal(false);
  348. name = plpgsql_tolower(yytext);
  349. if (name[0] != '$') {
  350.     elog(ERROR, "can only alias positional parameters");
  351. }
  352. nsi = plpgsql_ns_lookup(name, NULL);
  353. if (nsi == NULL) {
  354.     elog(ERROR, "function has no parameter %s", name);
  355. }
  357. plpgsql_ns_setlocal(true);
  359. $$ = nsi;
  360.     }
  361. ;
  363. decl_rowtype : T_ROW
  364.     {
  365.         $$ = yylval.row;
  366.     }
  367. ;
  369. decl_varname : T_WORD
  370.     {
  371.         $$.name = strdup(yytext);
  372. $$.lineno  = yylineno;
  373.     }
  374. ;
  376. decl_renname : T_WORD
  377.     {
  378.         $$ = plpgsql_tolower(yytext);
  379.     }
  380. ;
  382. decl_const :
  383.     { $$ = 0; }
  384. | K_CONSTANT
  385.     { $$ = 1; }
  386. ;
  388. decl_datatype : decl_dtypename
  389.     {
  390.         $$ = $1;
  391.     }
  392. ;
  394. decl_dtypename : T_DTYPE
  395.     {
  396. $$ = yylval.dtype;
  397.     }
  398. | T_CHAR decl_atttypmod
  399.     {
  400.         if ($2 < 0) {
  401.     plpgsql_parse_word("char");
  402.     $$ = yylval.dtype;
  403. } else {
  404.     plpgsql_parse_word("bpchar");
  405.     $$ = yylval.dtype;
  406.     $$->atttypmod = $2;
  407. }
  408.     }
  409. | T_VARCHAR decl_atttypmod
  410.     {
  411.         plpgsql_parse_word("varchar");
  412. $$ = yylval.dtype;
  413. $$->atttypmod = $2;
  414.     }
  415. | T_BPCHAR '(' decl_atttypmodval ')'
  416.     {
  417.         plpgsql_parse_word("bpchar");
  418. $$ = yylval.dtype;
  419. $$->atttypmod = $3;
  420.     }
  421. ;
  423. decl_atttypmod :
  424.     {
  425.         $$ = -1;
  426.     }
  427. | '(' decl_atttypmodval ')'
  428.     {
  429.         $$ = $2;
  430.     }
  431. ;
  433. decl_atttypmodval : T_NUMBER
  434.     {
  435.         $$ = int2in(yytext) + VARHDRSZ;
  436.     }
  437. ;
  439. decl_notnull :
  440.     { $$ = 0; }
  441. | K_NOT K_NULL
  442.     { $$ = 1; }
  443. ;
  445. decl_defval : ';'
  446.     { $$ = NULL; }
  447. | decl_defkey
  448.     {
  449. int tok;
  450. int lno;
  451.         PLpgSQL_dstring ds;
  452. PLpgSQL_expr *expr;
  454. lno = yylineno;
  455. expr = malloc(sizeof(PLpgSQL_expr));
  456. plpgsql_dstring_init(&ds);
  457. plpgsql_dstring_append(&ds, "SELECT ");
  459. expr->dtype   = PLPGSQL_DTYPE_EXPR;
  460. expr->plan    = NULL;
  461. expr->nparams = 0;
  463. tok = yylex();
  464. switch (tok) {
  465.     case 0:
  466. plpgsql_error_lineno = lno;
  467. plpgsql_comperrinfo();
  468.      elog(ERROR, "unexpected end of file");
  469.     case K_NULL:
  470.         if (yylex() != ';') {
  471.     plpgsql_error_lineno = lno;
  472.     plpgsql_comperrinfo();
  473.     elog(ERROR, "expectec ; after NULL");
  474. }
  475. free(expr);
  476. plpgsql_dstring_free(&ds);
  478. $$ = NULL;
  479. break;
  481.     default:
  482. plpgsql_dstring_append(&ds, yytext);
  483. while ((tok = yylex()) != ';') {
  484.     if (tok == 0) {
  485. plpgsql_error_lineno = lno;
  486. plpgsql_comperrinfo();
  487. elog(ERROR, "unterminated default value");
  488.     }
  489.     if (plpgsql_SpaceScanned) {
  490. plpgsql_dstring_append(&ds, " ");
  491.     }
  492.     plpgsql_dstring_append(&ds, yytext);
  493. }
  494. expr->query = strdup(plpgsql_dstring_get(&ds));
  495. plpgsql_dstring_free(&ds);
  497. $$ = expr;
  498. break;
  499. }
  500.     }
  501. ;
  503. decl_defkey : K_ASSIGN
  504. | K_DEFAULT
  506. proc_sect :
  507. {
  508. PLpgSQL_stmts *new;
  510. new = malloc(sizeof(PLpgSQL_stmts));
  511. memset(new, 0, sizeof(PLpgSQL_stmts));
  512. $$ = new;
  513. }
  514. | proc_stmts
  515. {
  516. $$ = $1;
  517. }
  518. ;
  520. proc_stmts : proc_stmts proc_stmt
  521. {
  522. if ($1->stmts_used == $1->stmts_alloc) {
  523.     $1->stmts_alloc *= 2;
  524.     $1->stmts = realloc($1->stmts, sizeof(PLpgSQL_stmt *) * $1->stmts_alloc);
  525. }
  526. $1->stmts[$1->stmts_used++] = (struct PLpgSQL_stmt *)$2;
  528. $$ = $1;
  529. }
  530. | proc_stmt
  531. {
  532. PLpgSQL_stmts *new;
  534. new = malloc(sizeof(PLpgSQL_stmts));
  535. memset(new, 0, sizeof(PLpgSQL_stmts));
  537. new->stmts_alloc = 64;
  538. new->stmts_used  = 1;
  539. new->stmts = malloc(sizeof(PLpgSQL_stmt *) * new->stmts_alloc);
  540. new->stmts[0] = (struct PLpgSQL_stmt *)$1;
  542. $$ = new;
  543. }
  544. ;
  546. proc_stmt : pl_block
  547. { $$ = $1; }
  548. | stmt_assign
  549. { $$ = $1; }
  550. | stmt_if
  551. { $$ = $1; }
  552. | stmt_loop
  553. { $$ = $1; }
  554. | stmt_while
  555. { $$ = $1; }
  556. | stmt_fori
  557. { $$ = $1; }
  558. | stmt_fors
  559. { $$ = $1; }
  560. | stmt_select
  561. { $$ = $1; }
  562. | stmt_exit
  563. { $$ = $1; }
  564. | stmt_return
  565. { $$ = $1; }
  566. | stmt_raise
  567. { $$ = $1; }
  568. | stmt_execsql
  569. { $$ = $1; }
  570. | stmt_perform
  571. { $$ = $1; }
  572. ;
  574. stmt_perform : K_PERFORM lno expr_until_semi
  575.     {
  576.      PLpgSQL_stmt_assign *new;
  578. new = malloc(sizeof(PLpgSQL_stmt_assign));
  579. memset(new, 0, sizeof(PLpgSQL_stmt_assign));
  581. new->cmd_type = PLPGSQL_STMT_ASSIGN;
  582. new->lineno   = $2;
  583. new->varno = -1;
  584. new->expr  = $3;
  586. $$ = (PLpgSQL_stmt *)new;
  587.     }
  588. ;
  590. stmt_assign : assign_var lno K_ASSIGN expr_until_semi
  591.     {
  592. PLpgSQL_stmt_assign *new;
  594. new = malloc(sizeof(PLpgSQL_stmt_assign));
  595. memset(new, 0, sizeof(PLpgSQL_stmt_assign));
  597. new->cmd_type = PLPGSQL_STMT_ASSIGN;
  598. new->lineno   = $2;
  599. new->varno = $1;
  600. new->expr  = $4;
  602. $$ = (PLpgSQL_stmt *)new;
  603.     }
  604. ;
  606. assign_var : T_VARIABLE
  607.     {
  608. if (yylval.var->isconst) {
  609.     plpgsql_comperrinfo();
  610.     elog(ERROR, "%s is declared CONSTANT", yylval.var->refname);
  611. }
  612.         $$ = yylval.var->varno;
  613.     }
  614. | T_RECFIELD
  615.     {
  616.         $$ = yylval.recfield->rfno;
  617.     }
  618. ;
  620. stmt_if : K_IF lno expr_until_then proc_sect stmt_else K_END K_IF ';'
  621.     {
  622. PLpgSQL_stmt_if *new;
  624. new = malloc(sizeof(PLpgSQL_stmt_if));
  625. memset(new, 0, sizeof(PLpgSQL_stmt_if));
  627. new->cmd_type   = PLPGSQL_STMT_IF;
  628. new->lineno     = $2;
  629. new->cond       = $3;
  630. new->true_body  = $4;
  631. new->false_body = $5;
  633. $$ = (PLpgSQL_stmt *)new;
  634.     }
  635. ;
  637. stmt_else :
  638. {
  639. PLpgSQL_stmts *new;
  641. new = malloc(sizeof(PLpgSQL_stmts));
  642. memset(new, 0, sizeof(PLpgSQL_stmts));
  643. $$ = new;
  644. }
  645. | K_ELSE proc_sect
  646. { $$ = $2; }
  647. ;
  649. stmt_loop : opt_label K_LOOP lno loop_body
  650.     {
  651. PLpgSQL_stmt_loop *new;
  653. new = malloc(sizeof(PLpgSQL_stmt_loop));
  654. memset(new, 0, sizeof(PLpgSQL_stmt_loop));
  656. new->cmd_type = PLPGSQL_STMT_LOOP;
  657. new->lineno   = $3;
  658. new->label    = $1;
  659. new->body     = $4;
  661. plpgsql_ns_pop();
  663. $$ = (PLpgSQL_stmt *)new;
  664.     }
  665. ;
  667. stmt_while : opt_label K_WHILE lno expr_until_loop loop_body
  668.     {
  669. PLpgSQL_stmt_while *new;
  671. new = malloc(sizeof(PLpgSQL_stmt_while));
  672. memset(new, 0, sizeof(PLpgSQL_stmt_while));
  674. new->cmd_type = PLPGSQL_STMT_WHILE;
  675. new->lineno   = $3;
  676. new->label    = $1;
  677. new->cond     = $4;
  678. new->body     = $5;
  680. plpgsql_ns_pop();
  682. $$ = (PLpgSQL_stmt *)new;
  683.     }
  684. ;
  686. stmt_fori : opt_label K_FOR lno fori_var K_IN fori_lower expr_until_loop loop_body
  687.     {
  688. PLpgSQL_stmt_fori *new;
  690. new = malloc(sizeof(PLpgSQL_stmt_fori));
  691. memset(new, 0, sizeof(PLpgSQL_stmt_fori));
  693. new->cmd_type = PLPGSQL_STMT_FORI;
  694. new->lineno   = $3;
  695. new->label    = $1;
  696. new->var      = $4;
  697. new->reverse  = $6.reverse;
  698. new->lower    = $6.expr;
  699. new->upper    = $7;
  700. new->body     = $8;
  702. plpgsql_ns_pop();
  704. $$ = (PLpgSQL_stmt *)new;
  705.     }
  706. ;
  708. fori_var : fori_varname
  709.     {
  710.         PLpgSQL_var *new;
  712. new = malloc(sizeof(PLpgSQL_var));
  714. new->dtype = PLPGSQL_DTYPE_VAR;
  715. new->refname = $1.name;
  716. new->lineno = $1.lineno;
  718. plpgsql_parse_word("integer");
  720. new->datatype = yylval.dtype;
  721. new->isconst = false;
  722. new->notnull = false;
  723. new->default_val = NULL;
  725. plpgsql_adddatum((PLpgSQL_datum *)new);
  726. plpgsql_ns_additem(PLPGSQL_NSTYPE_VAR, new->varno,
  727. $1.name);
  729. plpgsql_add_initdatums(NULL);
  731.         $$ = new;
  732.     }
  733. ;
  735. fori_varname : T_VARIABLE
  736.     {
  737.         $$.name = strdup(yytext);
  738. $$.lineno = yylineno;
  739.     }
  740. | T_WORD
  741.     {
  742.         $$.name = strdup(yytext);
  743. $$.lineno = yylineno;
  744.     }
  745. ;
  747. fori_lower :
  748.     {
  749. int tok;
  750. int lno;
  751. PLpgSQL_dstring ds;
  752. int nparams = 0;
  753. int params[1024];
  754. char buf[32];
  755. PLpgSQL_expr *expr;
  756. int firsttok = 1;
  758. lno = yylineno;
  759. plpgsql_dstring_init(&ds);
  760. plpgsql_dstring_append(&ds, "SELECT ");
  762. $$.reverse = 0;
  763. while((tok = yylex()) != K_DOTDOT) {
  764.     if (firsttok) {
  765. firsttok = 0;
  766. if (tok == K_REVERSE) {
  767.     $$.reverse = 1;
  768.     continue;
  769. }
  770.     }
  771.     if (tok == ';') break;
  772.     if (plpgsql_SpaceScanned) {
  773. plpgsql_dstring_append(&ds, " ");
  774.     }
  775.     switch (tok) {
  776. case T_VARIABLE:
  777.     params[nparams] = yylval.var->varno;
  778.     sprintf(buf, "$%d", ++nparams);
  779.     plpgsql_dstring_append(&ds, buf);
  780.     break;
  781.     
  782. case T_RECFIELD:
  783.     params[nparams] = yylval.recfield->rfno;
  784.     sprintf(buf, "$%d", ++nparams);
  785.     plpgsql_dstring_append(&ds, buf);
  786.     break;
  787.     
  788. case T_TGARGV:
  789.     params[nparams] = yylval.trigarg->dno;
  790.     sprintf(buf, "$%d", ++nparams);
  791.     plpgsql_dstring_append(&ds, buf);
  792.     break;
  793.     
  794. default:
  795.     if (tok == 0) {
  796. plpgsql_error_lineno = lno;
  797. plpgsql_comperrinfo();
  798. elog(ERROR, "missing .. to terminate lower bound of for loop");
  799.     }
  800.     plpgsql_dstring_append(&ds, yytext);
  801.     break;
  802.     }
  803. }
  805. expr = malloc(sizeof(PLpgSQL_expr) + sizeof(int) * nparams - 1);
  806. expr->dtype = PLPGSQL_DTYPE_EXPR;
  807. expr->query = strdup(plpgsql_dstring_get(&ds));
  808. expr->plan = NULL;
  809. expr->nparams = nparams;
  810. while(nparams-- > 0) {
  811.     expr->params[nparams] = params[nparams];
  812. }
  813. plpgsql_dstring_free(&ds);
  814. $$.expr = expr;
  815.     }
  817. stmt_fors : opt_label K_FOR lno fors_target K_IN K_SELECT expr_until_loop loop_body
  818.     {
  819. PLpgSQL_stmt_fors *new;
  821. new = malloc(sizeof(PLpgSQL_stmt_fors));
  822. memset(new, 0, sizeof(PLpgSQL_stmt_fors));
  824. new->cmd_type = PLPGSQL_STMT_FORS;
  825. new->lineno   = $3;
  826. new->label    = $1;
  827. switch ($4->dtype) {
  828.     case PLPGSQL_DTYPE_REC:
  829.         new->rec = $4;
  830. break;
  831.     case PLPGSQL_DTYPE_ROW:
  832.         new->row = (PLpgSQL_row *)$4;
  833. break;
  834.     default:
  835. plpgsql_comperrinfo();
  836.         elog(ERROR, "unknown dtype %d in stmt_fors", $4->dtype);
  837. }
  838. new->query = $7;
  839. new->body  = $8;
  841. plpgsql_ns_pop();
  843. $$ = (PLpgSQL_stmt *)new;
  844.     }
  846. fors_target : T_RECORD
  847.     {
  848.         $$ = yylval.rec;
  849.     }
  850. | T_ROW
  851.     {
  852.      $$ = (PLpgSQL_rec *)(yylval.row);
  853.     }
  854. ;
  856. stmt_select : K_SELECT lno
  857.     {
  858.      $$ = make_select_stmt();
  859. $$->lineno = $2;
  860.     }
  861. ;
  863. stmt_exit : K_EXIT lno opt_exitlabel opt_exitcond
  864.     {
  865. PLpgSQL_stmt_exit *new;
  867. new = malloc(sizeof(PLpgSQL_stmt_exit));
  868. memset(new, 0, sizeof(PLpgSQL_stmt_exit));
  870. new->cmd_type = PLPGSQL_STMT_EXIT;
  871. new->lineno   = $2;
  872. new->label    = $3;
  873. new->cond     = $4;
  875. $$ = (PLpgSQL_stmt *)new;
  876.     }
  877. ;
  879. stmt_return : K_RETURN lno
  880.     {
  881. PLpgSQL_stmt_return *new;
  882. PLpgSQL_expr *expr = NULL;
  883. int tok;
  885. new = malloc(sizeof(PLpgSQL_stmt_return));
  886. memset(new, 0, sizeof(PLpgSQL_stmt_return));
  888. if (plpgsql_curr_compile->fn_retistuple) {
  889.     new->retistuple = true;
  890.     new->retrecno   = -1;
  891.     switch (tok = yylex()) {
  892.         case K_NULL:
  893.     expr = NULL;
  894.     break;
  896.         case T_ROW:
  897.     expr = make_tupret_expr(yylval.row);
  898.     break;
  900. case T_RECORD:
  901.     new->retrecno = yylval.rec->recno;
  902.     expr = NULL;
  903.     break;
  905. default:
  906.     yyerror("return type mismatch in function returning table row");
  907.     break;
  908.     }
  909.     if (yylex() != ';') {
  910.         yyerror("expected ';'");
  911.     }
  912. } else {
  913.     new->retistuple = false;
  914.     expr = plpgsql_read_expression(';', ";");
  915. }
  917. new->cmd_type = PLPGSQL_STMT_RETURN;
  918. new->lineno   = $2;
  919. new->expr     = expr;
  921. $$ = (PLpgSQL_stmt *)new;
  922.     }
  923. ;
  925. stmt_raise : K_RAISE lno raise_level raise_msg raise_params ';'
  926.     {
  927.         PLpgSQL_stmt_raise *new;
  929. new = malloc(sizeof(PLpgSQL_stmt_raise));
  931. new->cmd_type = PLPGSQL_STMT_RAISE;
  932. new->lineno     = $2;
  933. new->elog_level = $3;
  934. new->message = $4;
  935. new->nparams = $5.nused;
  936. new->params = malloc(sizeof(int) * $5.nused);
  937. memcpy(new->params, $5.dtnums, sizeof(int) * $5.nused);
  939. $$ = (PLpgSQL_stmt *)new;
  940.     }
  941. | K_RAISE lno raise_level raise_msg ';'
  942.     {
  943.         PLpgSQL_stmt_raise *new;
  945. new = malloc(sizeof(PLpgSQL_stmt_raise));
  947. new->cmd_type = PLPGSQL_STMT_RAISE;
  948. new->lineno     = $2;
  949. new->elog_level = $3;
  950. new->message = $4;
  951. new->nparams = 0;
  952. new->params = NULL;
  954. $$ = (PLpgSQL_stmt *)new;
  955.     }
  956. ;
  958. raise_msg : T_STRING
  959.     {
  960.         $$ = strdup(yytext);
  961.     }
  962. ;
  964. raise_level : K_EXCEPTION
  965.     {
  966.         $$ = ERROR;
  967.     }
  968. | K_NOTICE
  969.     {
  970.         $$ = NOTICE;
  971.     }
  972. | K_DEBUG
  973.     {
  974.         $$ = DEBUG;
  975.     }
  976. ;
  978. raise_params : raise_params raise_param
  979.     {
  980.         if ($1.nused == $1.nalloc) {
  981.     $1.nalloc *= 2;
  982.     $1.dtnums = repalloc($1.dtnums, sizeof(int) * $1.nalloc);
  983. }
  984. $1.dtnums[$1.nused++] = $2;
  986. $$.nalloc = $1.nalloc;
  987. $$.nused  = $1.nused;
  988. $$.dtnums = $1.dtnums;
  989.     }
  990. | raise_param
  991.     {
  992.         $$.nalloc = 1;
  993. $$.nused  = 1;
  994. $$.dtnums = palloc(sizeof(int) * $$.nalloc);
  995. $$.dtnums[0] = $1;
  996.     }
  997. ;
  999. raise_param : ',' T_VARIABLE
  1000.     {
  1001.         $$ = yylval.var->varno;
  1002.     }
  1003. | ',' T_RECFIELD
  1004.     {
  1005.         $$ = yylval.recfield->rfno;
  1006.     }
  1007. | ',' T_TGARGV
  1008.     {
  1009.         $$ = yylval.trigarg->dno;
  1010.     }
  1011. ;
  1013. loop_body : proc_sect K_END K_LOOP ';'
  1014.     { $$ = $1; }
  1015. ;
  1017. stmt_execsql : execsql_start lno
  1018.     {
  1019.         PLpgSQL_stmt_execsql *new;
  1021. new = malloc(sizeof(PLpgSQL_stmt_execsql));
  1022. new->cmd_type = PLPGSQL_STMT_EXECSQL;
  1023. new->lineno   = $2;
  1024. new->sqlstmt  = read_sqlstmt(';', ";", $1);
  1026. $$ = (PLpgSQL_stmt *)new;
  1027.     }
  1028. ;
  1030. execsql_start : T_WORD
  1031.     { $$ = strdup(yytext); }
  1032. | T_ERROR
  1033.     { $$ = strdup(yytext); }
  1034. ;
  1036. expr_until_semi :
  1037.     { $$ = plpgsql_read_expression(';', ";"); }
  1038. ;
  1040. expr_until_then :
  1041.     { $$ = plpgsql_read_expression(K_THEN, "THEN"); }
  1042. ;
  1044. expr_until_loop :
  1045.     { $$ = plpgsql_read_expression(K_LOOP, "LOOP"); }
  1046. ;
  1048. opt_label :
  1049.     {
  1050. plpgsql_ns_push(NULL);
  1051. $$ = NULL;
  1052.     }
  1053. | '<' '<' opt_lblname '>' '>'
  1054.     {
  1055. plpgsql_ns_push($3);
  1056. $$ = $3;
  1057.     }
  1058. ;
  1060. opt_exitlabel :
  1061.     { $$ = NULL; }
  1062. | T_LABEL
  1063.     { $$ = strdup(yytext); }
  1064. ;
  1066. opt_exitcond : ';'
  1067.     { $$ = NULL; }
  1068. | K_WHEN expr_until_semi
  1069.     { $$ = $2; }
  1070. ;
  1072. opt_lblname : T_WORD
  1073.     { $$ = strdup(yytext); }
  1074. ;
  1076. lno :
  1077.     {
  1078. plpgsql_error_lineno = yylineno;
  1079.         $$ = yylineno;
  1080.     }
  1081. ;
  1083. %%
  1085. #ifndef YYBISON
  1086. #include "pl_scan.c" /* BSD yacc wants it here */
  1087. #endif
  1090. PLpgSQL_expr *
  1091. plpgsql_read_expression (int until, char *s)
  1092. {
  1093.     return read_sqlstmt(until, s, "SELECT ");
  1094. }
  1097. static PLpgSQL_expr *
  1098. read_sqlstmt (int until, char *s, char *sqlstart)
  1099. {
  1100.     int tok;
  1101.     int lno;
  1102.     PLpgSQL_dstring ds;
  1103.     int nparams = 0;
  1104.     int params[1024];
  1105.     char buf[32];
  1106.     PLpgSQL_expr *expr;
  1108.     lno = yylineno;
  1109.     plpgsql_dstring_init(&ds);
  1110.     plpgsql_dstring_append(&ds, sqlstart);
  1112.     while((tok = yylex()) != until) {
  1113. if (tok == ';') break;
  1114. if (plpgsql_SpaceScanned) {
  1115.     plpgsql_dstring_append(&ds, " ");
  1116. }
  1117.         switch (tok) {
  1118.     case T_VARIABLE:
  1119. params[nparams] = yylval.var->varno;
  1120. sprintf(buf, "$%d", ++nparams);
  1121. plpgsql_dstring_append(&ds, buf);
  1122. break;
  1123.         
  1124.     case T_RECFIELD:
  1125. params[nparams] = yylval.recfield->rfno;
  1126. sprintf(buf, "$%d", ++nparams);
  1127. plpgsql_dstring_append(&ds, buf);
  1128. break;
  1129.         
  1130.     case T_TGARGV:
  1131. params[nparams] = yylval.trigarg->dno;
  1132. sprintf(buf, "$%d", ++nparams);
  1133. plpgsql_dstring_append(&ds, buf);
  1134. break;
  1135.         
  1136.     default:
  1137. if (tok == 0) {
  1138.     plpgsql_error_lineno = lno;
  1139.     plpgsql_comperrinfo();
  1140.     elog(ERROR, "missing %s at end of SQL statement", s);
  1141. }
  1142. plpgsql_dstring_append(&ds, yytext);
  1143. break;
  1144.         }
  1145.     }
  1147.     expr = malloc(sizeof(PLpgSQL_expr) + sizeof(int) * nparams - 1);
  1148.     expr->dtype = PLPGSQL_DTYPE_EXPR;
  1149.     expr->query = strdup(plpgsql_dstring_get(&ds));
  1150.     expr->plan = NULL;
  1151.     expr->nparams = nparams;
  1152.     while(nparams-- > 0) {
  1153.         expr->params[nparams] = params[nparams];
  1154.     }
  1155.     plpgsql_dstring_free(&ds);
  1156.     
  1157.     return expr;
  1158. }
  1161. static PLpgSQL_stmt *
  1162. make_select_stmt()
  1163. {
  1164.     int tok;
  1165.     int lno;
  1166.     PLpgSQL_dstring ds;
  1167.     int nparams = 0;
  1168.     int params[1024];
  1169.     char buf[32];
  1170.     PLpgSQL_expr *expr;
  1171.     PLpgSQL_row *row = NULL;
  1172.     PLpgSQL_rec *rec = NULL;
  1173.     PLpgSQL_stmt_select *select;
  1174.     int have_nexttok = 0;
  1176.     lno = yylineno;
  1177.     plpgsql_dstring_init(&ds);
  1178.     plpgsql_dstring_append(&ds, "SELECT ");
  1180.     while((tok = yylex()) != K_INTO) {
  1181. if (tok == ';') {
  1182.     PLpgSQL_stmt_execsql *execsql;
  1184.     expr = malloc(sizeof(PLpgSQL_expr) + sizeof(int) * nparams - 1);
  1185.     expr->dtype = PLPGSQL_DTYPE_EXPR;
  1186.     expr->query = strdup(plpgsql_dstring_get(&ds));
  1187.     expr->plan = NULL;
  1188.     expr->nparams = nparams;
  1189.     while(nparams-- > 0) {
  1190. expr->params[nparams] = params[nparams];
  1191.     }
  1192.     plpgsql_dstring_free(&ds);
  1194.     execsql = malloc(sizeof(PLpgSQL_stmt_execsql));
  1195.     execsql->cmd_type = PLPGSQL_STMT_EXECSQL;
  1196.     execsql->sqlstmt  = expr;
  1198.     return (PLpgSQL_stmt *)execsql;
  1199. }
  1201. if (plpgsql_SpaceScanned) {
  1202.     plpgsql_dstring_append(&ds, " ");
  1203. }
  1204.         switch (tok) {
  1205.     case T_VARIABLE:
  1206. params[nparams] = yylval.var->varno;
  1207. sprintf(buf, "$%d", ++nparams);
  1208. plpgsql_dstring_append(&ds, buf);
  1209. break;
  1210.         
  1211.     case T_RECFIELD:
  1212. params[nparams] = yylval.recfield->rfno;
  1213. sprintf(buf, "$%d", ++nparams);
  1214. plpgsql_dstring_append(&ds, buf);
  1215. break;
  1216.         
  1217.     case T_TGARGV:
  1218. params[nparams] = yylval.trigarg->dno;
  1219. sprintf(buf, "$%d", ++nparams);
  1220. plpgsql_dstring_append(&ds, buf);
  1221. break;
  1222.         
  1223.     default:
  1224. if (tok == 0) {
  1225.     plpgsql_error_lineno = yylineno;
  1226.     plpgsql_comperrinfo();
  1227.     elog(ERROR, "unexpected end of file");
  1228. }
  1229. plpgsql_dstring_append(&ds, yytext);
  1230. break;
  1231.         }
  1232.     }
  1234.     tok = yylex();
  1235.     switch (tok) {
  1236.         case T_ROW:
  1237.     row = yylval.row;
  1238.     break;
  1240.         case T_RECORD:
  1241.     rec = yylval.rec;
  1242.     break;
  1244. case T_VARIABLE:
  1245. case T_RECFIELD:
  1246.     {
  1247. PLpgSQL_var *var;
  1248. PLpgSQL_recfield *recfield;
  1249. int nfields = 1;
  1250. char *fieldnames[1024];
  1251. int varnos[1024];
  1253. switch (tok) {
  1254.     case T_VARIABLE:
  1255. var = yylval.var;
  1256. fieldnames[0] = strdup(yytext);
  1257. varnos[0]     = var->varno;
  1258. break;
  1259.     
  1260.     case T_RECFIELD:
  1261. recfield = yylval.recfield;
  1262. fieldnames[0] = strdup(yytext);
  1263. varnos[0]     = recfield->rfno;
  1264. break;
  1265. }
  1267. while ((tok = yylex()) == ',') {
  1268.     tok = yylex();
  1269.     switch(tok) {
  1270. case T_VARIABLE:
  1271.     var = yylval.var;
  1272.     fieldnames[nfields] = strdup(yytext);
  1273.     varnos[nfields++]   = var->varno;
  1274.     break;
  1276. case T_RECFIELD:
  1277.     recfield = yylval.recfield;
  1278.     fieldnames[0] = strdup(yytext);
  1279.     varnos[0]     = recfield->rfno;
  1280.     break;
  1282. default:
  1283.     elog(ERROR, "plpgsql: %s is not a variable or record field", yytext);
  1284.     }
  1285. }
  1286. row = malloc(sizeof(PLpgSQL_row));
  1287. row->dtype = PLPGSQL_DTYPE_ROW;
  1288. row->refname = strdup("*internal*");
  1289. row->lineno = yylineno;
  1290. row->rowtypeclass = InvalidOid;
  1291. row->nfields = nfields;
  1292. row->fieldnames = malloc(sizeof(char *) * nfields);
  1293. row->varnos = malloc(sizeof(int) * nfields);
  1294. while (--nfields >= 0) {
  1295.     row->fieldnames[nfields] = fieldnames[nfields];
  1296.     row->varnos[nfields] = varnos[nfields];
  1297. }
  1299. plpgsql_adddatum((PLpgSQL_datum *)row);
  1301. have_nexttok = 1;
  1302.     }
  1303.     break;
  1305.         default:
  1306.     {
  1307. if (plpgsql_SpaceScanned) {
  1308.     plpgsql_dstring_append(&ds, " ");
  1309. }
  1310. plpgsql_dstring_append(&ds, yytext);
  1312. while(1) {
  1313.     tok = yylex();
  1314.     if (tok == ';') {
  1315. PLpgSQL_stmt_execsql *execsql;
  1317. expr = malloc(sizeof(PLpgSQL_expr) + sizeof(int) * nparams - 1);
  1318. expr->dtype = PLPGSQL_DTYPE_EXPR;
  1319. expr->query = strdup(plpgsql_dstring_get(&ds));
  1320. expr->plan = NULL;
  1321. expr->nparams = nparams;
  1322. while(nparams-- > 0) {
  1323.     expr->params[nparams] = params[nparams];
  1324. }
  1325. plpgsql_dstring_free(&ds);
  1327. execsql = malloc(sizeof(PLpgSQL_stmt_execsql));
  1328. execsql->cmd_type = PLPGSQL_STMT_EXECSQL;
  1329. execsql->sqlstmt  = expr;
  1331. return (PLpgSQL_stmt *)execsql;
  1332.     }
  1334.     if (plpgsql_SpaceScanned) {
  1335. plpgsql_dstring_append(&ds, " ");
  1336.     }
  1337.     switch (tok) {
  1338. case T_VARIABLE:
  1339.     params[nparams] = yylval.var->varno;
  1340.     sprintf(buf, "$%d", ++nparams);
  1341.     plpgsql_dstring_append(&ds, buf);
  1342.     break;
  1343.     
  1344. case T_RECFIELD:
  1345.     params[nparams] = yylval.recfield->rfno;
  1346.     sprintf(buf, "$%d", ++nparams);
  1347.     plpgsql_dstring_append(&ds, buf);
  1348.     break;
  1349.     
  1350. case T_TGARGV:
  1351.     params[nparams] = yylval.trigarg->dno;
  1352.     sprintf(buf, "$%d", ++nparams);
  1353.     plpgsql_dstring_append(&ds, buf);
  1354.     break;
  1355.     
  1356. default:
  1357.     if (tok == 0) {
  1358. plpgsql_error_lineno = yylineno;
  1359. plpgsql_comperrinfo();
  1360. elog(ERROR, "unexpected end of file");
  1361.     }
  1362.     plpgsql_dstring_append(&ds, yytext);
  1363.     break;
  1364.     }
  1365. }
  1366.     }
  1367.     }
  1369.     /************************************************************
  1370.      * Eat up the rest of the statement after the target fields
  1371.      ************************************************************/
  1372.     while(1) {
  1373. if (!have_nexttok) {
  1374.     tok = yylex();
  1375. }
  1376. have_nexttok = 0;
  1377. if (tok == ';') {
  1378.     break;
  1379. }
  1381. if (plpgsql_SpaceScanned) {
  1382.     plpgsql_dstring_append(&ds, " ");
  1383. }
  1384. switch (tok) {
  1385.     case T_VARIABLE:
  1386. params[nparams] = yylval.var->varno;
  1387. sprintf(buf, "$%d", ++nparams);
  1388. plpgsql_dstring_append(&ds, buf);
  1389. break;
  1391.     case T_RECFIELD:
  1392. params[nparams] = yylval.recfield->rfno;
  1393. sprintf(buf, "$%d", ++nparams);
  1394. plpgsql_dstring_append(&ds, buf);
  1395. break;
  1397.     case T_TGARGV:
  1398. params[nparams] = yylval.trigarg->dno;
  1399. sprintf(buf, "$%d", ++nparams);
  1400. plpgsql_dstring_append(&ds, buf);
  1401. break;
  1403.     default:
  1404. if (tok == 0) {
  1405.     plpgsql_error_lineno = yylineno;
  1406.     plpgsql_comperrinfo();
  1407.     elog(ERROR, "unexpected end of file");
  1408. }
  1409. plpgsql_dstring_append(&ds, yytext);
  1410. break;
  1411. }
  1412.     }
  1414.     expr = malloc(sizeof(PLpgSQL_expr) + sizeof(int) * (nparams - 1));
  1415.     expr->dtype = PLPGSQL_DTYPE_EXPR;
  1416.     expr->query = strdup(plpgsql_dstring_get(&ds));
  1417.     expr->plan = NULL;
  1418.     expr->nparams = nparams;
  1419.     while(nparams-- > 0) {
  1420.         expr->params[nparams] = params[nparams];
  1421.     }
  1422.     plpgsql_dstring_free(&ds);
  1424.     select = malloc(sizeof(PLpgSQL_stmt_select));
  1425.     memset(select, 0, sizeof(PLpgSQL_stmt_select));
  1426.     select->cmd_type = PLPGSQL_STMT_SELECT;
  1427.     select->rec      = rec;
  1428.     select->row      = row;
  1429.     select->query    = expr;
  1430.     
  1431.     return (PLpgSQL_stmt *)select;
  1432. }
  1435. static PLpgSQL_expr *
  1436. make_tupret_expr(PLpgSQL_row *row)
  1437. {
  1438.     PLpgSQL_dstring ds;
  1439.     PLpgSQL_expr *expr;
  1440.     int i;
  1441.     char buf[16];
  1443.     expr = malloc(sizeof(PLpgSQL_expr) + sizeof(int) * (row->nfields - 1));
  1444.     expr->dtype = PLPGSQL_DTYPE_EXPR;
  1446.     plpgsql_dstring_init(&ds);
  1447.     plpgsql_dstring_append(&ds, "SELECT ");
  1449.     for (i = 0; i < row->nfields; i++) {
  1450.         sprintf(buf, "%s$%d", (i > 0) ? "," : "", i + 1);
  1451. plpgsql_dstring_append(&ds, buf);
  1452. expr->params[i] = row->varnos[i];
  1453.     }
  1455.     expr->query         = strdup(plpgsql_dstring_get(&ds));
  1456.     expr->plan          = NULL;
  1457.     expr->plan_argtypes = NULL;
  1458.     expr->nparams       = row->nfields;
  1460.     plpgsql_dstring_free(&ds);
  1461.     return expr;
  1462. }