1 #include "php_psi_stdinc.h"
7 void *psi_parser_proc_Alloc(void*(unsigned long));
8 void psi_parser_proc_Free(void*, void(*)(void*));
9 void psi_parser_proc_(void *, token_t, struct psi_token *, struct psi_parser *);
10 void psi_parser_proc_Trace(FILE *, const char*);
12 struct psi_parser *psi_parser_init(struct psi_parser *P, psi_error_cb error, unsigned flags)
15 P = malloc(sizeof(*P));
17 memset(P, 0, sizeof(*P));
19 psi_data_ctor_with_dtors(PSI_DATA(P), error, flags);
23 P->proc = psi_parser_proc_Alloc(malloc);
25 if (flags & PSI_DEBUG) {
26 psi_parser_proc_Trace(stderr, "PSI> ");
32 bool psi_parser_open_file(struct psi_parser *P, const char *filename)
34 FILE *fp = fopen(filename, "r");
37 P->error(PSI_DATA(P), NULL, PSI_WARNING,
38 "Could not open '%s' for reading: %s",
39 filename, strerror(errno));
43 P->input.type = PSI_PARSE_FILE;
44 P->input.data.file.handle = fp;
51 P->error(PSI_DATA(P), NULL, PSI_WARNING,
52 "Could not stat '%s': %s",
53 filename, strerror(errno));
57 P->input.data.file.buffer = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
58 if (MAP_FAILED == P->input.data.file.buffer) {
59 P->error(PSI_DATA(P), NULL, PSI_WARNING,
60 "Could not map '%s' for reading: %s",
61 filename, strerror(errno));
64 P->input.data.file.length = sb.st_size;
66 P->input.data.file.buffer = malloc(BSIZE);
69 P->file.fn = strdup(filename);
74 bool psi_parser_open_string(struct psi_parser *P, const char *string, size_t length)
76 P->input.type = PSI_PARSE_STRING;
77 P->input.data.string.length = length;
78 if (!(P->input.data.string.buffer = strndup(string, length))) {
82 P->file.fn = strdup("<input>");
87 static ssize_t psi_parser_fill(struct psi_parser *P, size_t n)
89 PSI_DEBUG_PRINT(P, "PSI> Fill: n=%zu (input.type=%d)\n", n, P->input.type);
93 switch (P->input.type) {
95 P->cur = P->tok = P->mrk = P->input.data.file.buffer;
97 P->eof = P->input.data.file.buffer + P->input.data.file.length;
101 P->lim = P->input.data.file.buffer;
105 case PSI_PARSE_STRING:
106 P->cur = P->tok = P->mrk = P->input.data.string.buffer;
107 P->eof = P->input.data.string.buffer + P->input.data.string.length;
112 PSI_DEBUG_PRINT(P, "PSI> Fill: cur=%p lim=%p eof=%p\n", P->cur, P->lim, P->eof);
115 switch (P->input.type) {
116 case PSI_PARSE_STRING:
122 size_t consumed = P->tok - P->buf;
123 size_t reserved = P->lim - P->tok;
124 size_t available = BSIZE - reserved;
128 memmove(P->buf, P->tok, reserved);
135 didread = fread(P->lim, 1, available, P->fp);
137 if (didread < available) {
140 PSI_DEBUG_PRINT(P, "PSI> Fill: consumed=%zu reserved=%zu available=%zu didread=%zu\n",
141 consumed, reserved, available, didread);
147 PSI_DEBUG_PRINT(P, "PSI> Fill: avail=%td\n", P->lim - P->cur);
149 return P->lim - P->cur;
152 void psi_parser_parse(struct psi_parser *P, struct psi_token *T)
155 psi_parser_proc_(P->proc, T->type, T, P);
157 psi_parser_proc_(P->proc, 0, NULL, P);
161 void psi_parser_dtor(struct psi_parser *P)
163 psi_parser_proc_Free(P->proc, free);
165 switch (P->input.type) {
167 if (P->input.data.file.buffer) {
169 munmap(P->input.data.file.buffer, P->input.data.file.length);
171 free(P->input.data.file.buffer);
174 if (P->input.data.file.handle) {
175 fclose(P->input.data.file.handle);
179 case PSI_PARSE_STRING:
180 if (P->input.data.string.buffer) {
181 free(P->input.data.string.buffer);
186 psi_data_dtor(PSI_DATA(P));
188 memset(P, 0, sizeof(*P));
191 void psi_parser_free(struct psi_parser **P)
201 #if BSIZE < YYMAXFILL
202 # error BSIZE must be greater than YYMAXFILL
205 #define RETURN(t) do { \
207 PSI_DEBUG_PRINT(P, "PSI> TOKEN: %d %.*s (EOF=%d %s:%u:%u)\n", \
208 P->num, (int) (P->cur-P->tok), P->tok, P->num == PSI_T_EOF, \
209 P->file.fn, P->line, P->col); \
214 P->col += P->cur - P->tok
216 #define NEWLINE(label) \
221 token_t psi_parser_scan(struct psi_parser *P)
224 psi_parser_fill(P, 0);
232 re2c:define:YYCTYPE = "unsigned char";
233 re2c:define:YYCURSOR = P->cur;
234 re2c:define:YYLIMIT = P->lim;
235 re2c:define:YYMARKER = P->mrk;
236 re2c:define:YYFILL = "{ if (!psi_parser_fill(P,@@)) RETURN(PSI_T_EOF); }";
237 re2c:yyfill:parameter = 0;
242 NSNAME = (NAME)? ("\\" NAME)+;
243 DOLLAR_NAME = '$' W+;
244 QUOTED_STRING = "\"" ([^\"])+ "\"";
245 NUMBER = [+-]? [0-9]* "."? [0-9]+ ([eE] [+-]? [0-9]+)?;
247 "/*" { goto comment; }
248 ("#"|"//") .* "\n" { NEWLINE(nextline); }
249 "(" {RETURN(PSI_T_LPAREN);}
250 ")" {RETURN(PSI_T_RPAREN);}
251 ";" {RETURN(PSI_T_EOS);}
252 "," {RETURN(PSI_T_COMMA);}
253 ":" {RETURN(PSI_T_COLON);}
254 "{" {RETURN(PSI_T_LBRACE);}
255 "}" {RETURN(PSI_T_RBRACE);}
256 "[" {RETURN(PSI_T_LBRACKET);}
257 "]" {RETURN(PSI_T_RBRACKET);}
258 "=" {RETURN(PSI_T_EQUALS);}
259 "*" {RETURN(PSI_T_ASTERISK);}
260 "&" {RETURN(PSI_T_AMPERSAND);}
261 "+" {RETURN(PSI_T_PLUS);}
262 "-" {RETURN(PSI_T_MINUS);}
263 "/" {RETURN(PSI_T_SLASH);}
264 "..." {RETURN(PSI_T_ELLIPSIS);}
265 [\r\n] { NEWLINE(nextline); }
267 'TRUE' {RETURN(PSI_T_TRUE);}
268 'FALSE' {RETURN(PSI_T_FALSE);}
269 'NULL' {RETURN(PSI_T_NULL);}
270 'MIXED' {RETURN(PSI_T_MIXED);}
271 'CALLABLE' {RETURN(PSI_T_CALLABLE);}
272 'VOID' {RETURN(PSI_T_VOID);}
273 'BOOL' {RETURN(PSI_T_BOOL);}
274 'CHAR' {RETURN(PSI_T_CHAR);}
275 'SHORT' {RETURN(PSI_T_SHORT);}
276 'INT' {RETURN(PSI_T_INT);}
277 'LONG' {RETURN(PSI_T_LONG);}
278 'FLOAT' {RETURN(PSI_T_FLOAT);}
279 'DOUBLE' {RETURN(PSI_T_DOUBLE);}
280 'INT8_T' {RETURN(PSI_T_INT8);}
281 'UINT8_T' {RETURN(PSI_T_UINT8);}
282 'INT16_T' {RETURN(PSI_T_INT16);}
283 'UINT16_T' {RETURN(PSI_T_UINT16);}
284 'INT32_T' {RETURN(PSI_T_INT32);}
285 'UINT32_T' {RETURN(PSI_T_UINT32);}
286 'INT64_T' {RETURN(PSI_T_INT64);}
287 'UINT64_T' {RETURN(PSI_T_UINT64);}
288 'UNSIGNED' {RETURN(PSI_T_UNSIGNED);}
289 'SIGNED' {RETURN(PSI_T_SIGNED);}
290 'STRING' {RETURN(PSI_T_STRING);}
291 'ARRAY' {RETURN(PSI_T_ARRAY);}
292 'OBJECT' {RETURN(PSI_T_OBJECT);}
293 'CALLBACK' {RETURN(PSI_T_CALLBACK);}
294 'STATIC' {RETURN(PSI_T_STATIC);}
295 'FUNCTION' {RETURN(PSI_T_FUNCTION);}
296 'TYPEDEF' {RETURN(PSI_T_TYPEDEF);}
297 'STRUCT' {RETURN(PSI_T_STRUCT);}
298 'UNION' {RETURN(PSI_T_UNION);}
299 'ENUM' {RETURN(PSI_T_ENUM);}
300 'CONST' {RETURN(PSI_T_CONST);}
301 'LIB' {RETURN(PSI_T_LIB);}
302 'LET' {RETURN(PSI_T_LET);}
303 'SET' {RETURN(PSI_T_SET);}
304 'RETURN' {RETURN(PSI_T_RETURN);}
305 'FREE' {RETURN(PSI_T_FREE);}
306 'TEMP' {RETURN(PSI_T_TEMP);}
307 'STRLEN' {RETURN(PSI_T_STRLEN);}
308 'STRVAL' {RETURN(PSI_T_STRVAL);}
309 'PATHVAL' {RETURN(PSI_T_PATHVAL);}
310 'INTVAL' {RETURN(PSI_T_INTVAL);}
311 'FLOATVAL' {RETURN(PSI_T_FLOATVAL);}
312 'BOOLVAL' {RETURN(PSI_T_BOOLVAL);}
313 'ARRVAL' {RETURN(PSI_T_ARRVAL);}
314 'OBJVAL' {RETURN(PSI_T_OBJVAL);}
315 'ZVAL' {RETURN(PSI_T_ZVAL);}
316 'COUNT' {RETURN(PSI_T_COUNT);}
317 'CALLOC' {RETURN(PSI_T_CALLOC);}
318 'TO_OBJECT' {RETURN(PSI_T_TO_OBJECT);}
319 'TO_ARRAY' {RETURN(PSI_T_TO_ARRAY);}
320 'TO_STRING' {RETURN(PSI_T_TO_STRING);}
321 'TO_INT' {RETURN(PSI_T_TO_INT);}
322 'TO_FLOAT' {RETURN(PSI_T_TO_FLOAT);}
323 'TO_BOOL' {RETURN(PSI_T_TO_BOOL);}
324 NUMBER {RETURN(PSI_T_NUMBER);}
325 NAME {RETURN(PSI_T_NAME);}
326 NSNAME {RETURN(PSI_T_NSNAME);}
327 DOLLAR_NAME {RETURN(PSI_T_DOLLAR_NAME);}
328 QUOTED_STRING {RETURN(PSI_T_QUOTED_STRING);}
335 "\n" { NEWLINE(comment); }
336 "*" "/" { continue; }
337 [^] { goto comment; }