2 * Copyright 2011 Jacek Caban for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "parser.tab.h"
25 #include "wine/debug.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(vbscript
);
29 static const WCHAR andW
[] = {'a','n','d',0};
30 static const WCHAR byrefW
[] = {'b','y','r','e','f',0};
31 static const WCHAR byvalW
[] = {'b','y','v','a','l',0};
32 static const WCHAR callW
[] = {'c','a','l','l',0};
33 static const WCHAR classW
[] = {'c','l','a','s','s',0};
34 static const WCHAR constW
[] = {'c','o','n','s','t',0};
35 static const WCHAR defaultW
[] = {'d','e','f','a','u','l','t',0};
36 static const WCHAR dimW
[] = {'d','i','m',0};
37 static const WCHAR doW
[] = {'d','o',0};
38 static const WCHAR eachW
[] = {'e','a','c','h',0};
39 static const WCHAR elseW
[] = {'e','l','s','e',0};
40 static const WCHAR elseifW
[] = {'e','l','s','e','i','f',0};
41 static const WCHAR emptyW
[] = {'e','m','p','t','y',0};
42 static const WCHAR endW
[] = {'e','n','d',0};
43 static const WCHAR eqvW
[] = {'e','q','v',0};
44 static const WCHAR errorW
[] = {'e','r','r','o','r',0};
45 static const WCHAR exitW
[] = {'e','x','i','t',0};
46 static const WCHAR explicitW
[] = {'e','x','p','l','i','c','i','t',0};
47 static const WCHAR falseW
[] = {'f','a','l','s','e',0};
48 static const WCHAR forW
[] = {'f','o','r',0};
49 static const WCHAR functionW
[] = {'f','u','n','c','t','i','o','n',0};
50 static const WCHAR getW
[] = {'g','e','t',0};
51 static const WCHAR gotoW
[] = {'g','o','t','o',0};
52 static const WCHAR ifW
[] = {'i','f',0};
53 static const WCHAR impW
[] = {'i','m','p',0};
54 static const WCHAR inW
[] = {'i','n',0};
55 static const WCHAR isW
[] = {'i','s',0};
56 static const WCHAR letW
[] = {'l','e','t',0};
57 static const WCHAR loopW
[] = {'l','o','o','p',0};
58 static const WCHAR meW
[] = {'m','e',0};
59 static const WCHAR modW
[] = {'m','o','d',0};
60 static const WCHAR newW
[] = {'n','e','w',0};
61 static const WCHAR nextW
[] = {'n','e','x','t',0};
62 static const WCHAR notW
[] = {'n','o','t',0};
63 static const WCHAR nothingW
[] = {'n','o','t','h','i','n','g',0};
64 static const WCHAR nullW
[] = {'n','u','l','l',0};
65 static const WCHAR onW
[] = {'o','n',0};
66 static const WCHAR optionW
[] = {'o','p','t','i','o','n',0};
67 static const WCHAR orW
[] = {'o','r',0};
68 static const WCHAR privateW
[] = {'p','r','i','v','a','t','e',0};
69 static const WCHAR propertyW
[] = {'p','r','o','p','e','r','t','y',0};
70 static const WCHAR publicW
[] = {'p','u','b','l','i','c',0};
71 static const WCHAR remW
[] = {'r','e','m',0};
72 static const WCHAR resumeW
[] = {'r','e','s','u','m','e',0};
73 static const WCHAR setW
[] = {'s','e','t',0};
74 static const WCHAR stepW
[] = {'s','t','e','p',0};
75 static const WCHAR stopW
[] = {'s','t','o','p',0};
76 static const WCHAR subW
[] = {'s','u','b',0};
77 static const WCHAR thenW
[] = {'t','h','e','n',0};
78 static const WCHAR toW
[] = {'t','o',0};
79 static const WCHAR trueW
[] = {'t','r','u','e',0};
80 static const WCHAR untilW
[] = {'u','n','t','i','l',0};
81 static const WCHAR wendW
[] = {'w','e','n','d',0};
82 static const WCHAR whileW
[] = {'w','h','i','l','e',0};
83 static const WCHAR xorW
[] = {'x','o','r',0};
106 {explicitW
, tEXPLICIT
},
109 {functionW
, tFUNCTION
},
123 {nothingW
, tNOTHING
},
128 {privateW
, tPRIVATE
},
129 {propertyW
, tPROPERTY
},
146 static inline BOOL
is_identifier_char(WCHAR c
)
148 return isalnumW(c
) || c
== '_';
151 static int check_keyword(parser_ctx_t
*ctx
, const WCHAR
*word
)
153 const WCHAR
*p1
= ctx
->ptr
;
154 const WCHAR
*p2
= word
;
157 while(p1
< ctx
->end
&& *p2
) {
165 if(*p2
|| (p1
< ctx
->end
&& is_identifier_char(*p1
)))
172 static int check_keywords(parser_ctx_t
*ctx
)
174 int min
= 0, max
= sizeof(keywords
)/sizeof(keywords
[0])-1, r
, i
;
179 r
= check_keyword(ctx
, keywords
[i
].word
);
181 return keywords
[i
].token
;
192 static int parse_identifier(parser_ctx_t
*ctx
, const WCHAR
**ret
)
194 const WCHAR
*ptr
= ctx
->ptr
++;
198 while(ctx
->ptr
< ctx
->end
&& is_identifier_char(*ctx
->ptr
))
202 str
= parser_alloc(ctx
, (len
+1)*sizeof(WCHAR
));
206 memcpy(str
, ptr
, (len
+1)*sizeof(WCHAR
));
212 static int parse_string_literal(parser_ctx_t
*ctx
, const WCHAR
**ret
)
214 const WCHAR
*ptr
= ++ctx
->ptr
;
218 while(ctx
->ptr
< ctx
->end
) {
219 if(*ctx
->ptr
== '\n') {
220 FIXME("newline inside string literal\n");
224 if(*ctx
->ptr
== '"') {
225 if(ctx
->ptr
[1] != '"')
233 if(ctx
->ptr
== ctx
->end
) {
234 FIXME("unterminated string literal\n");
240 *ret
= rptr
= parser_alloc(ctx
, (len
+1)*sizeof(WCHAR
));
244 while(ptr
< ctx
->ptr
) {
255 static int parse_numeric_literal(parser_ctx_t
*ctx
, void **ret
)
259 if(*ctx
->ptr
== '0' && !('0' <= ctx
->ptr
[1] && ctx
->ptr
[1] <= '9') && ctx
->ptr
[1] != '.')
263 n
= n
*10 + *ctx
->ptr
++ - '0';
264 }while('0' <= *ctx
->ptr
&& *ctx
->ptr
<= '9');
266 if(*ctx
->ptr
!= '.') {
270 return (short)l
== l
? tShort
: tLong
;
274 while('0' <= *++ctx
->ptr
&& *ctx
->ptr
<= '9')
275 n
+= (e
/= 10.0)*(*ctx
->ptr
-'0');
282 static int hex_to_int(WCHAR c
)
284 if('0' <= c
&& c
<= '9')
286 if('a' <= c
&& c
<= 'f')
288 if('A' <= c
&& c
<= 'F')
293 static int parse_hex_literal(parser_ctx_t
*ctx
, LONG
*ret
)
295 const WCHAR
*begin
= ctx
->ptr
;
298 while((d
= hex_to_int(*++ctx
->ptr
)) != -1)
301 if(begin
+ 9 /* max digits+1 */ < ctx
->ptr
|| (*ctx
->ptr
!= '&' && is_identifier_char(*ctx
->ptr
))) {
302 FIXME("invalid literal\n");
310 return (short)l
== l
? tShort
: tLong
;
313 static void skip_spaces(parser_ctx_t
*ctx
)
315 while(*ctx
->ptr
== ' ' || *ctx
->ptr
== '\t' || *ctx
->ptr
== '\r')
319 static int parse_next_token(void *lval
, parser_ctx_t
*ctx
)
324 if(ctx
->ptr
== ctx
->end
)
325 return ctx
->last_token
== tNL
? tEOF
: tNL
;
329 if('0' <= c
&& c
<= '9')
330 return parse_numeric_literal(ctx
, lval
);
333 int ret
= check_keywords(ctx
);
335 return parse_identifier(ctx
, lval
);
346 ctx
->ptr
= strchrW(ctx
->ptr
, '\n');
367 * We resolve empty brackets in lexer instead of parser to avoid complex conflicts
368 * in call statement special case |f()| without 'call' keyword
372 if(*ctx
->ptr
== ')') {
374 return tEMPTYBRACKETS
;
378 return parse_string_literal(ctx
, lval
);
380 if(*++ctx
->ptr
== 'h' || *ctx
->ptr
== 'H')
381 return parse_hex_literal(ctx
, lval
);
384 switch(*++ctx
->ptr
) {
394 if(*++ctx
->ptr
== '=') {
400 FIXME("Unhandled char %c in %s\n", *ctx
->ptr
, debugstr_w(ctx
->ptr
));
406 int parser_lex(void *lval
, parser_ctx_t
*ctx
)
411 ret
= parse_next_token(lval
, ctx
);
414 if(*ctx
->ptr
!= '\n') {
415 FIXME("'_' not followed by newline\n");
421 if(ret
!= tNL
|| ctx
->last_token
!= tNL
)
424 ctx
->last_nl
= ctx
->ptr
-ctx
->code
;
427 return (ctx
->last_token
= ret
);