ReactOS  0.4.13-dev-242-g611e6d7
lex.c
Go to the documentation of this file.
1 /*
2  * Copyright 2011 Jacek Caban for CodeWeavers
3  *
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.
8  *
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.
13  *
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
17  */
18 
19 #include "config.h"
20 #include "wine/port.h"
21 
22 #include <assert.h>
23 #include <limits.h>
24 
25 #include "vbscript.h"
26 #include "parse.h"
27 #include "parser.tab.h"
28 
29 #include "wine/debug.h"
30 
32 
33 static const WCHAR andW[] = {'a','n','d',0};
34 static const WCHAR byrefW[] = {'b','y','r','e','f',0};
35 static const WCHAR byvalW[] = {'b','y','v','a','l',0};
36 static const WCHAR callW[] = {'c','a','l','l',0};
37 static const WCHAR caseW[] = {'c','a','s','e',0};
38 static const WCHAR classW[] = {'c','l','a','s','s',0};
39 static const WCHAR constW[] = {'c','o','n','s','t',0};
40 static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0};
41 static const WCHAR dimW[] = {'d','i','m',0};
42 static const WCHAR doW[] = {'d','o',0};
43 static const WCHAR eachW[] = {'e','a','c','h',0};
44 static const WCHAR elseW[] = {'e','l','s','e',0};
45 static const WCHAR elseifW[] = {'e','l','s','e','i','f',0};
46 static const WCHAR emptyW[] = {'e','m','p','t','y',0};
47 static const WCHAR endW[] = {'e','n','d',0};
48 static const WCHAR eqvW[] = {'e','q','v',0};
49 static const WCHAR errorW[] = {'e','r','r','o','r',0};
50 static const WCHAR exitW[] = {'e','x','i','t',0};
51 static const WCHAR explicitW[] = {'e','x','p','l','i','c','i','t',0};
52 static const WCHAR falseW[] = {'f','a','l','s','e',0};
53 static const WCHAR forW[] = {'f','o','r',0};
54 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
55 static const WCHAR getW[] = {'g','e','t',0};
56 static const WCHAR gotoW[] = {'g','o','t','o',0};
57 static const WCHAR ifW[] = {'i','f',0};
58 static const WCHAR impW[] = {'i','m','p',0};
59 static const WCHAR inW[] = {'i','n',0};
60 static const WCHAR isW[] = {'i','s',0};
61 static const WCHAR letW[] = {'l','e','t',0};
62 static const WCHAR loopW[] = {'l','o','o','p',0};
63 static const WCHAR meW[] = {'m','e',0};
64 static const WCHAR modW[] = {'m','o','d',0};
65 static const WCHAR newW[] = {'n','e','w',0};
66 static const WCHAR nextW[] = {'n','e','x','t',0};
67 static const WCHAR notW[] = {'n','o','t',0};
68 static const WCHAR nothingW[] = {'n','o','t','h','i','n','g',0};
69 static const WCHAR nullW[] = {'n','u','l','l',0};
70 static const WCHAR onW[] = {'o','n',0};
71 static const WCHAR optionW[] = {'o','p','t','i','o','n',0};
72 static const WCHAR orW[] = {'o','r',0};
73 static const WCHAR privateW[] = {'p','r','i','v','a','t','e',0};
74 static const WCHAR propertyW[] = {'p','r','o','p','e','r','t','y',0};
75 static const WCHAR publicW[] = {'p','u','b','l','i','c',0};
76 static const WCHAR remW[] = {'r','e','m',0};
77 static const WCHAR resumeW[] = {'r','e','s','u','m','e',0};
78 static const WCHAR selectW[] = {'s','e','l','e','c','t',0};
79 static const WCHAR setW[] = {'s','e','t',0};
80 static const WCHAR stepW[] = {'s','t','e','p',0};
81 static const WCHAR stopW[] = {'s','t','o','p',0};
82 static const WCHAR subW[] = {'s','u','b',0};
83 static const WCHAR thenW[] = {'t','h','e','n',0};
84 static const WCHAR toW[] = {'t','o',0};
85 static const WCHAR trueW[] = {'t','r','u','e',0};
86 static const WCHAR untilW[] = {'u','n','t','i','l',0};
87 static const WCHAR wendW[] = {'w','e','n','d',0};
88 static const WCHAR whileW[] = {'w','h','i','l','e',0};
89 static const WCHAR xorW[] = {'x','o','r',0};
90 
91 static const struct {
92  const WCHAR *word;
93  int token;
94 } keywords[] = {
95  {andW, tAND},
96  {byrefW, tBYREF},
97  {byvalW, tBYVAL},
98  {callW, tCALL},
99  {caseW, tCASE},
100  {classW, tCLASS},
101  {constW, tCONST},
102  {defaultW, tDEFAULT},
103  {dimW, tDIM},
104  {doW, tDO},
105  {eachW, tEACH},
106  {elseW, tELSE},
107  {elseifW, tELSEIF},
108  {emptyW, tEMPTY},
109  {endW, tEND},
110  {eqvW, tEQV},
111  {errorW, tERROR},
112  {exitW, tEXIT},
113  {explicitW, tEXPLICIT},
114  {falseW, tFALSE},
115  {forW, tFOR},
116  {functionW, tFUNCTION},
117  {getW, tGET},
118  {gotoW, tGOTO},
119  {ifW, tIF},
120  {impW, tIMP},
121  {inW, tIN},
122  {isW, tIS},
123  {letW, tLET},
124  {loopW, tLOOP},
125  {meW, tME},
126  {modW, tMOD},
127  {newW, tNEW},
128  {nextW, tNEXT},
129  {notW, tNOT},
130  {nothingW, tNOTHING},
131  {nullW, tNULL},
132  {onW, tON},
133  {optionW, tOPTION},
134  {orW, tOR},
135  {privateW, tPRIVATE},
136  {propertyW, tPROPERTY},
137  {publicW, tPUBLIC},
138  {remW, tREM},
139  {resumeW, tRESUME},
140  {selectW, tSELECT},
141  {setW, tSET},
142  {stepW, tSTEP},
143  {stopW, tSTOP},
144  {subW, tSUB},
145  {thenW, tTHEN},
146  {toW, tTO},
147  {trueW, tTRUE},
148  {untilW, tUNTIL},
149  {wendW, tWEND},
150  {whileW, tWHILE},
151  {xorW, tXOR}
152 };
153 
155 {
156  return isalnumW(c) || c == '_';
157 }
158 
159 static int check_keyword(parser_ctx_t *ctx, const WCHAR *word)
160 {
161  const WCHAR *p1 = ctx->ptr;
162  const WCHAR *p2 = word;
163  WCHAR c;
164 
165  while(p1 < ctx->end && *p2) {
166  c = tolowerW(*p1);
167  if(c != *p2)
168  return c - *p2;
169  p1++;
170  p2++;
171  }
172 
173  if(*p2 || (p1 < ctx->end && is_identifier_char(*p1)))
174  return 1;
175 
176  ctx->ptr = p1;
177  return 0;
178 }
179 
180 static int check_keywords(parser_ctx_t *ctx)
181 {
182  int min = 0, max = ARRAY_SIZE(keywords)-1, r, i;
183 
184  while(min <= max) {
185  i = (min+max)/2;
186 
187  r = check_keyword(ctx, keywords[i].word);
188  if(!r)
189  return keywords[i].token;
190 
191  if(r > 0)
192  min = i+1;
193  else
194  max = i-1;
195  }
196 
197  return 0;
198 }
199 
200 static int parse_identifier(parser_ctx_t *ctx, const WCHAR **ret)
201 {
202  const WCHAR *ptr = ctx->ptr++;
203  WCHAR *str;
204  int len;
205 
206  while(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr))
207  ctx->ptr++;
208  len = ctx->ptr-ptr;
209 
210  str = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
211  if(!str)
212  return 0;
213 
214  memcpy(str, ptr, (len+1)*sizeof(WCHAR));
215  str[len] = 0;
216  *ret = str;
217  return tIdentifier;
218 }
219 
220 static int parse_string_literal(parser_ctx_t *ctx, const WCHAR **ret)
221 {
222  const WCHAR *ptr = ++ctx->ptr;
223  WCHAR *rptr;
224  int len = 0;
225 
226  while(ctx->ptr < ctx->end) {
227  if(*ctx->ptr == '\n') {
228  FIXME("newline inside string literal\n");
229  return 0;
230  }
231 
232  if(*ctx->ptr == '"') {
233  if(ctx->ptr[1] != '"')
234  break;
235  len--;
236  ctx->ptr++;
237  }
238  ctx->ptr++;
239  }
240 
241  if(ctx->ptr == ctx->end) {
242  FIXME("unterminated string literal\n");
243  return 0;
244  }
245 
246  len += ctx->ptr-ptr;
247 
248  *ret = rptr = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
249  if(!rptr)
250  return 0;
251 
252  while(ptr < ctx->ptr) {
253  if(*ptr == '"')
254  ptr++;
255  *rptr++ = *ptr++;
256  }
257 
258  *rptr = 0;
259  ctx->ptr++;
260  return tString;
261 }
262 
263 static int parse_numeric_literal(parser_ctx_t *ctx, void **ret)
264 {
265  BOOL use_int = TRUE;
266  LONGLONG d = 0, hlp;
267  int exp = 0;
268  double r;
269 
270  if(*ctx->ptr == '0' && !('0' <= ctx->ptr[1] && ctx->ptr[1] <= '9') && ctx->ptr[1] != '.')
271  return *ctx->ptr++;
272 
273  while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
274  hlp = d*10 + *(ctx->ptr++) - '0';
275  if(d>MAXLONGLONG/10 || hlp<0) {
276  exp++;
277  break;
278  }
279  else
280  d = hlp;
281  }
282  while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
283  exp++;
284  ctx->ptr++;
285  }
286 
287  if(*ctx->ptr == '.') {
288  use_int = FALSE;
289  ctx->ptr++;
290 
291  while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) {
292  hlp = d*10 + *(ctx->ptr++) - '0';
293  if(d>MAXLONGLONG/10 || hlp<0)
294  break;
295 
296  d = hlp;
297  exp--;
298  }
299  while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr))
300  ctx->ptr++;
301  }
302 
303  if(*ctx->ptr == 'e' || *ctx->ptr == 'E') {
304  int e = 0, sign = 1;
305 
306  if(*++ctx->ptr == '-') {
307  ctx->ptr++;
308  sign = -1;
309  }
310 
311  if(!isdigitW(*ctx->ptr)) {
312  FIXME("Invalid numeric literal\n");
313  return 0;
314  }
315 
316  use_int = FALSE;
317 
318  do {
319  e = e*10 + *(ctx->ptr++) - '0';
320  if(sign == -1 && -e+exp < -(INT_MAX/100)) {
321  /* The literal will be rounded to 0 anyway. */
322  while(isdigitW(*ctx->ptr))
323  ctx->ptr++;
324  *(double*)ret = 0;
325  return tDouble;
326  }
327 
328  if(sign*e + exp > INT_MAX/100) {
329  FIXME("Invalid numeric literal\n");
330  return 0;
331  }
332  } while(isdigitW(*ctx->ptr));
333 
334  exp += sign*e;
335  }
336 
337  if(use_int && (LONG)d == d) {
338  LONG l = d;
339  *(LONG*)ret = l;
340  return (short)l == l ? tShort : tLong;
341  }
342 
343  r = exp>=0 ? d*pow(10, exp) : d/pow(10, -exp);
344  if(isinf(r)) {
345  FIXME("Invalid numeric literal\n");
346  return 0;
347  }
348 
349  *(double*)ret = r;
350  return tDouble;
351 }
352 
353 static int hex_to_int(WCHAR c)
354 {
355  if('0' <= c && c <= '9')
356  return c-'0';
357  if('a' <= c && c <= 'f')
358  return c+10-'a';
359  if('A' <= c && c <= 'F')
360  return c+10-'A';
361  return -1;
362 }
363 
365 {
366  const WCHAR *begin = ctx->ptr;
367  LONG l = 0, d;
368 
369  while((d = hex_to_int(*++ctx->ptr)) != -1)
370  l = l*16 + d;
371 
372  if(begin + 9 /* max digits+1 */ < ctx->ptr || (*ctx->ptr != '&' && is_identifier_char(*ctx->ptr))) {
373  FIXME("invalid literal\n");
374  return 0;
375  }
376 
377  if(*ctx->ptr == '&')
378  ctx->ptr++;
379 
380  *ret = l;
381  return (short)l == l ? tShort : tLong;
382 }
383 
384 static void skip_spaces(parser_ctx_t *ctx)
385 {
386  while(*ctx->ptr == ' ' || *ctx->ptr == '\t')
387  ctx->ptr++;
388 }
389 
390 static int comment_line(parser_ctx_t *ctx)
391 {
392  static const WCHAR newlineW[] = {'\n','\r',0};
393  ctx->ptr = strpbrkW(ctx->ptr, newlineW);
394  if(ctx->ptr)
395  ctx->ptr++;
396  else
397  ctx->ptr = ctx->end;
398  return tNL;
399 }
400 
401 static int parse_next_token(void *lval, parser_ctx_t *ctx)
402 {
403  WCHAR c;
404 
405  skip_spaces(ctx);
406  if(ctx->ptr == ctx->end)
407  return ctx->last_token == tNL ? tEOF : tNL;
408 
409  c = *ctx->ptr;
410 
411  if('0' <= c && c <= '9')
412  return parse_numeric_literal(ctx, lval);
413 
414  if(isalphaW(c)) {
415  int ret = check_keywords(ctx);
416  if(!ret)
417  return parse_identifier(ctx, lval);
418  if(ret != tREM)
419  return ret;
420  c = '\'';
421  }
422 
423  switch(c) {
424  case '\n':
425  case '\r':
426  ctx->ptr++;
427  return tNL;
428  case '\'':
429  return comment_line(ctx);
430  case ':':
431  case ')':
432  case ',':
433  case '=':
434  case '+':
435  case '*':
436  case '/':
437  case '^':
438  case '\\':
439  case '.':
440  case '_':
441  return *ctx->ptr++;
442  case '-':
443  if(ctx->is_html && ctx->ptr[1] == '-' && ctx->ptr[2] == '>')
444  return comment_line(ctx);
445  ctx->ptr++;
446  return '-';
447  case '(':
448  /* NOTE:
449  * We resolve empty brackets in lexer instead of parser to avoid complex conflicts
450  * in call statement special case |f()| without 'call' keyword
451  */
452  ctx->ptr++;
453  skip_spaces(ctx);
454  if(*ctx->ptr == ')') {
455  ctx->ptr++;
456  return tEMPTYBRACKETS;
457  }
458  return '(';
459  case '"':
460  return parse_string_literal(ctx, lval);
461  case '&':
462  if(*++ctx->ptr == 'h' || *ctx->ptr == 'H')
463  return parse_hex_literal(ctx, lval);
464  return '&';
465  case '<':
466  switch(*++ctx->ptr) {
467  case '>':
468  ctx->ptr++;
469  return tNEQ;
470  case '=':
471  ctx->ptr++;
472  return tLTEQ;
473  case '!':
474  if(ctx->is_html && ctx->ptr[1] == '-' && ctx->ptr[2] == '-')
475  return comment_line(ctx);
476  }
477  return '<';
478  case '>':
479  if(*++ctx->ptr == '=') {
480  ctx->ptr++;
481  return tGTEQ;
482  }
483  return '>';
484  default:
485  FIXME("Unhandled char %c in %s\n", *ctx->ptr, debugstr_w(ctx->ptr));
486  }
487 
488  return 0;
489 }
490 
491 int parser_lex(void *lval, parser_ctx_t *ctx)
492 {
493  int ret;
494 
495  while(1) {
496  ret = parse_next_token(lval, ctx);
497  if(ret == '_') {
498  skip_spaces(ctx);
499  if(*ctx->ptr != '\n') {
500  FIXME("'_' not followed by newline\n");
501  return 0;
502  }
503  ctx->ptr++;
504  continue;
505  }
506  if(ret != tNL || ctx->last_token != tNL)
507  break;
508 
509  ctx->last_nl = ctx->ptr-ctx->code;
510  }
511 
512  return (ctx->last_token = ret);
513 }
static const WCHAR functionW[]
Definition: lex.c:54
static const WCHAR isW[]
Definition: lex.c:60
static size_t double int int int * sign
Definition: printf.c:64
static const WCHAR classW[]
Definition: lex.c:38
static const WCHAR newlineW[]
Definition: reg.c:81
#define max(a, b)
Definition: svc.c:63
#define TRUE
Definition: types.h:120
static const struct @541 keywords[]
static int comment_line(parser_ctx_t *ctx)
Definition: lex.c:390
#define INT_MAX
Definition: limits.h:40
static void skip_spaces(parser_ctx_t *ctx)
Definition: lex.c:384
static const WCHAR whileW[]
Definition: lex.c:88
BOOL is_identifier_char(WCHAR c)
Definition: lex.c:123
static int parse_string_literal(parser_ctx_t *ctx, const WCHAR **ret)
Definition: lex.c:220
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
static const WCHAR nullW[]
Definition: lex.c:69
static const WCHAR defaultW[]
Definition: lex.c:40
static const WCHAR letW[]
Definition: lex.c:61
static int parse_numeric_literal(parser_ctx_t *ctx, void **ret)
Definition: lex.c:263
GLuint GLuint end
Definition: gl.h:1545
#define MAXLONGLONG
static const WCHAR eqvW[]
Definition: lex.c:48
static int parse_identifier(parser_ctx_t *ctx, const WCHAR **ret)
Definition: lex.c:200
static const WCHAR elseifW[]
Definition: lex.c:45
static const WCHAR byvalW[]
Definition: lex.c:35
static const WCHAR optionW[]
Definition: lex.c:71
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static const WCHAR gotoW[]
Definition: lex.c:56
static int check_keywords(parser_ctx_t *ctx)
Definition: lex.c:180
int token
Definition: lex.c:79
static const WCHAR loopW[]
Definition: lex.c:62
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
float pow(float __x, int __y)
Definition: _cmath.h:458
#define e
Definition: ke_i.h:82
#define debugstr_w
Definition: kernel32.h:32
static const WCHAR meW[]
Definition: lex.c:63
#define FIXME(fmt,...)
Definition: debug.h:110
static PVOID ptr
Definition: dispmode.c:27
static const WCHAR falseW[]
Definition: lex.c:52
const WCHAR * str
static const WCHAR impW[]
Definition: lex.c:58
const WCHAR * ptr
Definition: parse.h:256
static const WCHAR privateW[]
Definition: lex.c:73
static const WCHAR errorW[]
Definition: lex.c:49
static const WCHAR notW[]
Definition: lex.c:67
static int parse_next_token(void *lval, parser_ctx_t *ctx)
Definition: lex.c:401
static clock_t begin
Definition: xmllint.c:466
const WCHAR * code
Definition: parse.h:255
static int hex_to_int(WCHAR c)
Definition: lex.c:353
r l[0]
Definition: byte_order.h:167
static int check_keyword(parser_ctx_t *ctx, const WCHAR *word)
Definition: lex.c:159
int64_t LONGLONG
Definition: typedefs.h:66
static const WCHAR andW[]
Definition: lex.c:33
#define d
Definition: ke_i.h:81
__wchar_t WCHAR
Definition: xmlstorage.h:180
WINE_UNICODE_INLINE WCHAR * strpbrkW(const WCHAR *str, const WCHAR *accept)
Definition: unicode.h:261
static const WCHAR stopW[]
Definition: lex.c:81
static const WCHAR trueW[]
Definition: lex.c:85
int isinf(double x)
static const WCHAR inW[]
Definition: lex.c:59
const GLubyte * c
Definition: glext.h:8905
WINE_UNICODE_INLINE WCHAR tolowerW(WCHAR ch)
Definition: unicode.h:135
static const WCHAR explicitW[]
Definition: lex.c:51
static const WCHAR getW[]
Definition: lex.c:55
static const WCHAR dimW[]
Definition: lex.c:41
static const WCHAR doW[]
Definition: lex.c:42
static const WCHAR constW[]
Definition: lex.c:39
static const WCHAR stepW[]
Definition: lex.c:80
int ret
static const WCHAR exitW[]
Definition: lex.c:50
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
const WCHAR * end
Definition: parse.h:257
static const WCHAR nothingW[]
Definition: lex.c:68
static const WCHAR newW[]
Definition: lex.c:65
WINE_UNICODE_INLINE int isalnumW(WCHAR wc)
Definition: unicode.h:190
static const WCHAR modW[]
Definition: lex.c:64
static const WCHAR untilW[]
Definition: lex.c:86
static void * parser_alloc(parser_ctx_t *ctx, DWORD size)
Definition: parser.h:57
static const WCHAR emptyW[]
Definition: lex.c:46
static const WCHAR propertyW[]
Definition: lex.c:74
static const WCHAR callW[]
Definition: lex.c:36
static const WCHAR eachW[]
Definition: lex.c:43
static const WCHAR forW[]
Definition: lex.c:53
static const WCHAR resumeW[]
Definition: lex.c:77
#define ARRAY_SIZE(a)
Definition: main.h:24
static const WCHAR ifW[]
Definition: lex.c:57
static const WCHAR elseW[]
Definition: lex.c:44
int parser_lex(void *lval, parser_ctx_t *ctx)
Definition: lex.c:1142
static const WCHAR caseW[]
Definition: lex.c:37
WINE_UNICODE_INLINE int isdigitW(WCHAR wc)
Definition: unicode.h:170
static const WCHAR byrefW[]
Definition: lex.c:34
#define min(a, b)
Definition: monoChain.cc:55
DWORD exp
Definition: msg.c:15681
static const WCHAR wendW[]
Definition: lex.c:87
const WCHAR * word
Definition: lex.c:78
static const WCHAR remW[]
Definition: lex.c:76
static int parse_hex_literal(parser_ctx_t *ctx, LONG *ret)
Definition: lex.c:364
static const WCHAR thenW[]
Definition: lex.c:83
static const WCHAR subW[]
Definition: lex.c:82
#define c
Definition: ke_i.h:80
unsigned last_nl
Definition: parse.h:265
static const WCHAR orW[]
Definition: lex.c:72
static const WCHAR selectW[]
Definition: lex.c:78
WINE_UNICODE_INLINE int isalphaW(WCHAR wc)
Definition: unicode.h:195
static const WCHAR toW[]
Definition: lex.c:84
BOOL is_html
Definition: parse.h:261
static const WCHAR publicW[]
Definition: lex.c:75
static const WCHAR onW[]
Definition: lex.c:70
static const WCHAR endW[]
Definition: lex.c:47
static const WCHAR setW[]
Definition: lex.c:79
WINE_DEFAULT_DEBUG_CHANNEL(jscript)
static const WCHAR nextW[]
Definition: lex.c:66
static const WCHAR xorW[]
Definition: lex.c:89
int last_token
Definition: parse.h:264