1 : %{
2 : /*
3 : +----------------------------------------------------------------------+
4 : | Zend Engine |
5 : +----------------------------------------------------------------------+
6 : | Copyright (c) 1998-2009 Zend Technologies Ltd. (http://www.zend.com) |
7 : +----------------------------------------------------------------------+
8 : | This source file is subject to version 2.00 of the Zend license, |
9 : | that is bundled with this package in the file LICENSE, and is |
10 : | available through the world-wide-web at the following url: |
11 : | http://www.zend.com/license/2_00.txt. |
12 : | If you did not receive a copy of the Zend license and are unable to |
13 : | obtain it through the world-wide-web, please send a note to |
14 : | license@zend.com so we can mail you a copy immediately. |
15 : +----------------------------------------------------------------------+
16 : | Author: Zeev Suraski <zeev@zend.com> |
17 : +----------------------------------------------------------------------+
18 : */
19 :
20 : /* $Id: zend_ini_parser.y 272371 2008-12-31 11:16:12Z sebastian $ */
21 :
22 : #define DEBUG_CFG_PARSER 0
23 : #include "zend.h"
24 : #include "zend_API.h"
25 : #include "zend_ini.h"
26 : #include "zend_constants.h"
27 : #include "zend_ini_scanner.h"
28 : #include "zend_extensions.h"
29 :
30 : #define YYSTYPE zval
31 :
32 : #ifdef ZTS
33 : #define YYPARSE_PARAM tsrm_ls
34 : #define YYLEX_PARAM tsrm_ls
35 : #endif
36 :
37 : #define ZEND_INI_PARSER_CB (CG(ini_parser_param))->ini_parser_cb
38 : #define ZEND_INI_PARSER_ARG (CG(ini_parser_param))->arg
39 :
40 : int ini_lex(zval *ini_lval TSRMLS_DC);
41 : #ifdef ZTS
42 : int ini_parse(void *arg);
43 : #else
44 : int ini_parse(void);
45 : #endif
46 :
47 : zval yylval;
48 :
49 : #ifndef ZTS
50 : extern int ini_lex(zval *ini_lval TSRMLS_DC);
51 : extern FILE *ini_in;
52 : extern void init_cfg_scanner(void);
53 : #endif
54 :
55 : void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
56 35 : {
57 : int i_result;
58 : int i_op1, i_op2;
59 : char str_result[MAX_LENGTH_OF_LONG];
60 :
61 35 : i_op1 = atoi(Z_STRVAL_P(op1));
62 35 : free(Z_STRVAL_P(op1));
63 35 : if (op2) {
64 20 : i_op2 = atoi(Z_STRVAL_P(op2));
65 20 : free(Z_STRVAL_P(op2));
66 : } else {
67 15 : i_op2 = 0;
68 : }
69 :
70 35 : switch (type) {
71 : case '|':
72 5 : i_result = i_op1 | i_op2;
73 5 : break;
74 : case '&':
75 15 : i_result = i_op1 & i_op2;
76 15 : break;
77 : case '~':
78 15 : i_result = ~i_op1;
79 15 : break;
80 : case '!':
81 0 : i_result = !i_op1;
82 0 : break;
83 : default:
84 0 : i_result = 0;
85 : break;
86 : }
87 :
88 35 : Z_STRLEN_P(result) = zend_sprintf(str_result, "%d", i_result);
89 35 : Z_STRVAL_P(result) = (char *) malloc(Z_STRLEN_P(result)+1);
90 35 : memcpy(Z_STRVAL_P(result), str_result, Z_STRLEN_P(result));
91 35 : Z_STRVAL_P(result)[Z_STRLEN_P(result)] = 0;
92 35 : Z_TYPE_P(result) = IS_STRING;
93 35 : }
94 :
95 : void zend_ini_init_string(zval *result)
96 107783 : {
97 107783 : Z_STRVAL_P(result) = malloc(1);
98 107783 : Z_STRVAL_P(result)[0] = 0;
99 107783 : Z_STRLEN_P(result) = 0;
100 107783 : Z_TYPE_P(result) = IS_STRING;
101 107783 : }
102 :
103 : void zend_ini_add_string(zval *result, zval *op1, zval *op2)
104 6 : {
105 6 : int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2);
106 :
107 6 : Z_STRVAL_P(result) = (char *) realloc(Z_STRVAL_P(op1), length+1);
108 6 : memcpy(Z_STRVAL_P(result)+Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
109 6 : Z_STRVAL_P(result)[length] = 0;
110 6 : Z_STRLEN_P(result) = length;
111 6 : Z_TYPE_P(result) = IS_STRING;
112 6 : }
113 :
114 : void zend_ini_get_constant(zval *result, zval *name)
115 365172 : {
116 : zval z_constant;
117 : TSRMLS_FETCH();
118 :
119 365212 : if (!memchr(Z_STRVAL_P(name), ':', Z_STRLEN_P(name))
120 : && zend_get_constant(Z_STRVAL_P(name), Z_STRLEN_P(name), &z_constant TSRMLS_CC)) {
121 : /* z_constant is emalloc()'d */
122 40 : convert_to_string(&z_constant);
123 40 : Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(z_constant), Z_STRLEN(z_constant));
124 40 : Z_STRLEN_P(result) = Z_STRLEN(z_constant);
125 40 : Z_TYPE_P(result) = Z_TYPE(z_constant);
126 40 : zval_dtor(&z_constant);
127 40 : free(Z_STRVAL_P(name));
128 : } else {
129 365132 : *result = *name;
130 : }
131 365172 : }
132 :
133 : void zend_ini_get_var(zval *result, zval *name)
134 0 : {
135 : zval curval;
136 : char *envvar;
137 : TSRMLS_FETCH();
138 :
139 0 : if (zend_get_configuration_directive(Z_STRVAL_P(name), Z_STRLEN_P(name)+1, &curval) == SUCCESS) {
140 0 : Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(curval), Z_STRLEN(curval));
141 0 : Z_STRLEN_P(result) = Z_STRLEN(curval);
142 0 : } else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRLEN_P(name) TSRMLS_CC)) != NULL ||
143 : (envvar = getenv(Z_STRVAL_P(name))) != NULL) {
144 0 : Z_STRVAL_P(result) = strdup(envvar);
145 0 : Z_STRLEN_P(result) = strlen(envvar);
146 : } else {
147 0 : zend_ini_init_string(result);
148 : }
149 0 : }
150 :
151 :
152 : static void ini_error(char *str)
153 2 : {
154 : char *error_buf;
155 : int error_buf_len;
156 : char *currently_parsed_filename;
157 : TSRMLS_FETCH();
158 :
159 2 : currently_parsed_filename = zend_ini_scanner_get_filename(TSRMLS_C);
160 2 : if (currently_parsed_filename) {
161 2 : error_buf_len = 128+strlen(currently_parsed_filename); /* should be more than enough */
162 2 : error_buf = (char *) emalloc(error_buf_len);
163 :
164 2 : sprintf(error_buf, "Error parsing %s on line %d\n", currently_parsed_filename, zend_ini_scanner_get_lineno(TSRMLS_C));
165 : } else {
166 0 : error_buf = estrdup("Invalid configuration directive\n");
167 : }
168 :
169 2 : if (CG(ini_parser_unbuffered_errors)) {
170 : #ifdef PHP_WIN32
171 : MessageBox(NULL, error_buf, "PHP Error", MB_OK|MB_TOPMOST|0x00200000L);
172 : #else
173 0 : fprintf(stderr, "PHP: %s", error_buf);
174 : #endif
175 : } else {
176 2 : zend_error(E_WARNING, "%s", error_buf);
177 : }
178 2 : efree(error_buf);
179 2 : }
180 :
181 :
182 : ZEND_API int zend_parse_ini_file(zend_file_handle *fh, zend_bool unbuffered_errors, zend_ini_parser_cb_t ini_parser_cb, void *arg)
183 13567 : {
184 : int retval;
185 : zend_ini_parser_param ini_parser_param;
186 : TSRMLS_FETCH();
187 :
188 13567 : ini_parser_param.ini_parser_cb = ini_parser_cb;
189 13567 : ini_parser_param.arg = arg;
190 :
191 13567 : CG(ini_parser_param) = &ini_parser_param;
192 13567 : if (zend_ini_open_file_for_scanning(fh TSRMLS_CC)==FAILURE) {
193 38 : return FAILURE;
194 : }
195 :
196 13529 : CG(ini_parser_unbuffered_errors) = unbuffered_errors;
197 13529 : retval = ini_parse(TSRMLS_C);
198 :
199 13529 : zend_ini_close_file(fh TSRMLS_CC);
200 :
201 13529 : if (retval==0) {
202 13527 : return SUCCESS;
203 : } else {
204 2 : return FAILURE;
205 : }
206 : }
207 :
208 :
209 : ZEND_API int zend_parse_ini_string(char *str, zend_bool unbuffered_errors, zend_ini_parser_cb_t ini_parser_cb, void *arg)
210 13546 : {
211 : zend_ini_parser_param ini_parser_param;
212 : TSRMLS_FETCH();
213 :
214 13546 : ini_parser_param.ini_parser_cb = ini_parser_cb;
215 13546 : ini_parser_param.arg = arg;
216 :
217 13546 : CG(ini_parser_param) = &ini_parser_param;
218 13546 : if (zend_ini_prepare_string_for_scanning(str TSRMLS_CC)==FAILURE) {
219 0 : return FAILURE;
220 : }
221 :
222 13546 : CG(ini_parser_unbuffered_errors) = unbuffered_errors;
223 :
224 13546 : if (ini_parse(TSRMLS_C)) {
225 0 : return SUCCESS;
226 : } else {
227 13546 : return FAILURE;
228 : }
229 : }
230 :
231 :
232 : %}
233 :
234 : %pure_parser
235 : %token TC_STRING
236 : %token TC_ENCAPSULATED_STRING
237 : %token BRACK
238 : %token SECTION
239 : %token CFG_TRUE
240 : %token CFG_FALSE
241 : %token TC_DOLLAR_CURLY
242 : %left '|' '&'
243 : %right '~' '!'
244 :
245 : %%
246 :
247 : statement_list:
248 : statement_list statement
249 : | /* empty */
250 : ;
251 :
252 : statement:
253 : TC_STRING '=' string_or_value {
254 : #if DEBUG_CFG_PARSER
255 : printf("'%s' = '%s'\n", Z_STRVAL($1), Z_STRVAL($3));
256 : #endif
257 513666 : ZEND_INI_PARSER_CB(&$1, &$3, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG);
258 513666 : free(Z_STRVAL($1));
259 513666 : free(Z_STRVAL($3));
260 : }
261 513666 : | TC_STRING BRACK '=' string_or_value {
262 : #if DEBUG_CFG_PARSER
263 : printf("'%s'[ ] = '%s'\n", Z_STRVAL($1), Z_STRVAL($4));
264 : #endif
265 2 : ZEND_INI_PARSER_CB(&$1, &$4, ZEND_INI_PARSER_POP_ENTRY, ZEND_INI_PARSER_ARG);
266 2 : free(Z_STRVAL($1));
267 2 : free(Z_STRVAL($4));
268 : }
269 2 : | TC_STRING { ZEND_INI_PARSER_CB(&$1, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG); free(Z_STRVAL($1)); }
270 1 : | SECTION { ZEND_INI_PARSER_CB(&$1, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG); free(Z_STRVAL($1)); }
271 55 : | '\n'
272 : ;
273 :
274 :
275 : string_or_value:
276 378896 : expr { $$ = $1; }
277 378896 : | CFG_TRUE { $$ = $1; }
278 83 : | CFG_FALSE { $$ = $1; }
279 26906 : | '\n' { zend_ini_init_string(&$$); }
280 107782 : | /* empty */ { zend_ini_init_string(&$$); }
281 1 : ;
282 :
283 :
284 : var_string_list:
285 0 : cfg_var_ref { $$ = $1; }
286 0 : | TC_ENCAPSULATED_STRING { $$ = $1; }
287 13748 : | constant_string { $$ = $1; }
288 365168 : | var_string_list cfg_var_ref { zend_ini_add_string(&$$, &$1, &$2); free($2.value.str.val); }
289 0 : | var_string_list TC_ENCAPSULATED_STRING { zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
290 2 : | var_string_list constant_string { zend_ini_add_string(&$$, &$1, &$2); free($2.value.str.val); }
291 4 : ;
292 :
293 : cfg_var_ref:
294 0 : TC_DOLLAR_CURLY TC_STRING '}' { zend_ini_get_var(&$$, &$2); free($2.value.str.val); }
295 0 : ;
296 :
297 : expr:
298 378916 : var_string_list { $$ = $1; }
299 378916 : | expr '|' expr { zend_ini_do_op('|', &$$, &$1, &$3); }
300 5 : | expr '&' expr { zend_ini_do_op('&', &$$, &$1, &$3); }
301 15 : | '~' expr { zend_ini_do_op('~', &$$, &$2, NULL); }
302 15 : | '!' expr { zend_ini_do_op('!', &$$, &$2, NULL); }
303 0 : | '(' expr ')' { $$ = $2; }
304 0 : ;
305 :
306 : constant_string:
307 365172 : TC_STRING { zend_ini_get_constant(&$$, &$1); }
308 : ;
309 :
310 : /*
311 : * Local variables:
312 : * tab-width: 4
313 : * c-basic-offset: 4
314 : * indent-tabs-mode: t
315 : * End:
316 : */
|
