← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/postgresql-9.1/oneiric-security

« back to all changes in this revision

Viewing changes to src/test/isolation/specparse.y

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2011-05-11 10:41:53 UTC
  • Revision ID: james.westby@ubuntu.com-20110511104153-psbh2o58553fv1m0
Tags: upstream-9.1~beta1
Import upstream version 9.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/isolation/specparse.y
 
1
%{
 
2
/*-------------------------------------------------------------------------
 
3
 *
 
4
 * specparse.y
 
5
 *        bison grammar for the isolation test file format
 
6
 *
 
7
 * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
 
8
 * Portions Copyright (c) 1994, Regents of the University of California
 
9
 *
 
10
 *-------------------------------------------------------------------------
 
11
 */
 
12
 
 
13
#include <stdio.h>
 
14
#include <stdlib.h>
 
15
#include <stdint.h>
 
16
#include <string.h>
 
17
 
 
18
#include "isolationtester.h"
 
19
 
 
20
 
 
21
TestSpec                parseresult;                    /* result of parsing is left here */
 
22
 
 
23
%}
 
24
 
 
25
%expect 0
 
26
%name-prefix="spec_yy"
 
27
 
 
28
%union
 
29
{
 
30
        char       *str;
 
31
        Session    *session;
 
32
        Step       *step;
 
33
        Permutation *permutation;
 
34
        struct
 
35
        {
 
36
                void  **elements;
 
37
                int             nelements;
 
38
        }                       ptr_list;
 
39
}
 
40
 
 
41
%type <str>  opt_setup opt_teardown
 
42
%type <ptr_list> step_list session_list permutation_list opt_permutation_list
 
43
%type <ptr_list> string_list
 
44
%type <session> session
 
45
%type <step> step
 
46
%type <permutation> permutation
 
47
 
 
48
%token <str> sqlblock string
 
49
%token PERMUTATION SESSION SETUP STEP TEARDOWN TEST
 
50
 
 
51
%%
 
52
 
 
53
TestSpec:
 
54
                        opt_setup
 
55
                        opt_teardown
 
56
                        session_list
 
57
                        opt_permutation_list
 
58
                        {
 
59
                                parseresult.setupsql = $1;
 
60
                                parseresult.teardownsql = $2;
 
61
                                parseresult.sessions = (Session **) $3.elements;
 
62
                                parseresult.nsessions = $3.nelements;
 
63
                                parseresult.permutations = (Permutation **) $4.elements;
 
64
                                parseresult.npermutations = $4.nelements;
 
65
                        }
 
66
                ;
 
67
 
 
68
opt_setup:
 
69
                        /* EMPTY */                     { $$ = NULL; }
 
70
                        | SETUP sqlblock        { $$ = $2; }
 
71
                ;
 
72
 
 
73
opt_teardown:
 
74
                        /* EMPTY */                     { $$ = NULL; }
 
75
                        | TEARDOWN sqlblock     { $$ = $2; }
 
76
                ;
 
77
 
 
78
session_list:
 
79
                        session_list session
 
80
                        {
 
81
                                $$.elements = realloc($1.elements,
 
82
                                                                          ($1.nelements + 1) * sizeof(void *));
 
83
                                $$.elements[$1.nelements] = $2;
 
84
                                $$.nelements = $1.nelements + 1;
 
85
                        }
 
86
                        | session
 
87
                        {
 
88
                                $$.nelements = 1;
 
89
                                $$.elements = malloc(sizeof(void *));
 
90
                                $$.elements[0] = $1;
 
91
                        }
 
92
                ;
 
93
 
 
94
session:
 
95
                        SESSION string opt_setup step_list opt_teardown
 
96
                        {
 
97
                                $$ = malloc(sizeof(Session));
 
98
                                $$->name = $2;
 
99
                                $$->setupsql = $3;
 
100
                                $$->steps = (Step **) $4.elements;
 
101
                                $$->nsteps = $4.nelements;
 
102
                                $$->teardownsql = $5;
 
103
                        }
 
104
                ;
 
105
 
 
106
step_list:
 
107
                        step_list step
 
108
                        {
 
109
                                $$.elements = realloc($1.elements,
 
110
                                                                          ($1.nelements + 1) * sizeof(void *));
 
111
                                $$.elements[$1.nelements] = $2;
 
112
                                $$.nelements = $1.nelements + 1;
 
113
                        }
 
114
                        | step
 
115
                        {
 
116
                                $$.nelements = 1;
 
117
                                $$.elements = malloc(sizeof(void *));
 
118
                                $$.elements[0] = $1;
 
119
                        }
 
120
                ;
 
121
 
 
122
 
 
123
step:
 
124
                        STEP string sqlblock
 
125
                        {
 
126
                                $$ = malloc(sizeof(Step));
 
127
                                $$->name = $2;
 
128
                                $$->sql = $3;
 
129
                        }
 
130
                ;
 
131
 
 
132
 
 
133
opt_permutation_list:
 
134
                        permutation_list
 
135
                        {
 
136
                                $$ = $1;
 
137
                        }
 
138
                        | /* EMPTY */
 
139
                        {
 
140
                                $$.elements = NULL;
 
141
                                $$.nelements = 0;
 
142
                        }
 
143
 
 
144
permutation_list:
 
145
                        permutation_list permutation
 
146
                        {
 
147
                                $$.elements = realloc($1.elements,
 
148
                                                                          ($1.nelements + 1) * sizeof(void *));
 
149
                                $$.elements[$1.nelements] = $2;
 
150
                                $$.nelements = $1.nelements + 1;
 
151
                        }
 
152
                        | permutation
 
153
                        {
 
154
                                $$.nelements = 1;
 
155
                                $$.elements = malloc(sizeof(void *));
 
156
                                $$.elements[0] = $1;
 
157
                        }
 
158
                ;
 
159
 
 
160
 
 
161
permutation:
 
162
                        PERMUTATION string_list
 
163
                        {
 
164
                                $$ = malloc(sizeof(Permutation));
 
165
                                $$->stepnames = (char **) $2.elements;
 
166
                                $$->nsteps = $2.nelements;
 
167
                        }
 
168
                ;
 
169
 
 
170
string_list:
 
171
                        string_list string
 
172
                        {
 
173
                                $$.elements = realloc($1.elements,
 
174
                                                                          ($1.nelements + 1) * sizeof(void *));
 
175
                                $$.elements[$1.nelements] = $2;
 
176
                                $$.nelements = $1.nelements + 1;
 
177
                        }
 
178
                        | string
 
179
                        {
 
180
                                $$.nelements = 1;
 
181
                                $$.elements = malloc(sizeof(void *));
 
182
                                $$.elements[0] = $1;
 
183
                        }
 
184
                ;
 
185
 
 
186
%%
 
187
 
 
188
#include "specscanner.c"