ReactOS  0.4.13-dev-455-g28ed234
lex.c File Reference
#include "config.h"
#include "wine/port.h"
#include <assert.h>
#include <limits.h>
#include "vbscript.h"
#include "parse.h"
#include "parser.tab.h"
#include "wine/debug.h"
Include dependency graph for lex.c:

Go to the source code of this file.

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (vbscript)
 
static BOOL is_identifier_char (WCHAR c)
 
static int check_keyword (parser_ctx_t *ctx, const WCHAR *word)
 
static int check_keywords (parser_ctx_t *ctx)
 
static int parse_identifier (parser_ctx_t *ctx, const WCHAR **ret)
 
static int parse_string_literal (parser_ctx_t *ctx, const WCHAR **ret)
 
static int parse_numeric_literal (parser_ctx_t *ctx, void **ret)
 
static int hex_to_int (WCHAR c)
 
static int parse_hex_literal (parser_ctx_t *ctx, LONG *ret)
 
static void skip_spaces (parser_ctx_t *ctx)
 
static int comment_line (parser_ctx_t *ctx)
 
static int parse_next_token (void *lval, parser_ctx_t *ctx)
 
int parser_lex (void *lval, parser_ctx_t *ctx)
 

Variables

static const WCHAR andW [] = {'a','n','d',0}
 
static const WCHAR byrefW [] = {'b','y','r','e','f',0}
 
static const WCHAR byvalW [] = {'b','y','v','a','l',0}
 
static const WCHAR callW [] = {'c','a','l','l',0}
 
static const WCHAR caseW [] = {'c','a','s','e',0}
 
static const WCHAR classW [] = {'c','l','a','s','s',0}
 
static const WCHAR constW [] = {'c','o','n','s','t',0}
 
static const WCHAR defaultW [] = {'d','e','f','a','u','l','t',0}
 
static const WCHAR dimW [] = {'d','i','m',0}
 
static const WCHAR doW [] = {'d','o',0}
 
static const WCHAR eachW [] = {'e','a','c','h',0}
 
static const WCHAR elseW [] = {'e','l','s','e',0}
 
static const WCHAR elseifW [] = {'e','l','s','e','i','f',0}
 
static const WCHAR emptyW [] = {'e','m','p','t','y',0}
 
static const WCHAR endW [] = {'e','n','d',0}
 
static const WCHAR eqvW [] = {'e','q','v',0}
 
static const WCHAR errorW [] = {'e','r','r','o','r',0}
 
static const WCHAR exitW [] = {'e','x','i','t',0}
 
static const WCHAR explicitW [] = {'e','x','p','l','i','c','i','t',0}
 
static const WCHAR falseW [] = {'f','a','l','s','e',0}
 
static const WCHAR forW [] = {'f','o','r',0}
 
static const WCHAR functionW [] = {'f','u','n','c','t','i','o','n',0}
 
static const WCHAR getW [] = {'g','e','t',0}
 
static const WCHAR gotoW [] = {'g','o','t','o',0}
 
static const WCHAR ifW [] = {'i','f',0}
 
static const WCHAR impW [] = {'i','m','p',0}
 
static const WCHAR inW [] = {'i','n',0}
 
static const WCHAR isW [] = {'i','s',0}
 
static const WCHAR letW [] = {'l','e','t',0}
 
static const WCHAR loopW [] = {'l','o','o','p',0}
 
static const WCHAR meW [] = {'m','e',0}
 
static const WCHAR modW [] = {'m','o','d',0}
 
static const WCHAR newW [] = {'n','e','w',0}
 
static const WCHAR nextW [] = {'n','e','x','t',0}
 
static const WCHAR notW [] = {'n','o','t',0}
 
static const WCHAR nothingW [] = {'n','o','t','h','i','n','g',0}
 
static const WCHAR nullW [] = {'n','u','l','l',0}
 
static const WCHAR onW [] = {'o','n',0}
 
static const WCHAR optionW [] = {'o','p','t','i','o','n',0}
 
static const WCHAR orW [] = {'o','r',0}
 
static const WCHAR privateW [] = {'p','r','i','v','a','t','e',0}
 
static const WCHAR propertyW [] = {'p','r','o','p','e','r','t','y',0}
 
static const WCHAR publicW [] = {'p','u','b','l','i','c',0}
 
static const WCHAR remW [] = {'r','e','m',0}
 
static const WCHAR resumeW [] = {'r','e','s','u','m','e',0}
 
static const WCHAR selectW [] = {'s','e','l','e','c','t',0}
 
static const WCHAR setW [] = {'s','e','t',0}
 
static const WCHAR stepW [] = {'s','t','e','p',0}
 
static const WCHAR stopW [] = {'s','t','o','p',0}
 
static const WCHAR subW [] = {'s','u','b',0}
 
static const WCHAR thenW [] = {'t','h','e','n',0}
 
static const WCHAR toW [] = {'t','o',0}
 
static const WCHAR trueW [] = {'t','r','u','e',0}
 
static const WCHAR untilW [] = {'u','n','t','i','l',0}
 
static const WCHAR wendW [] = {'w','e','n','d',0}
 
static const WCHAR whileW [] = {'w','h','i','l','e',0}
 
static const WCHAR xorW [] = {'x','o','r',0}
 
struct {
   const WCHAR *   word
 
   int   token
 
keywords []
 

Function Documentation

◆ check_keyword()

static int check_keyword ( parser_ctx_t ctx,
const WCHAR word 
)
static

Definition at line 159 of file lex.c.

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 }
BOOL is_identifier_char(WCHAR c)
Definition: lex.c:123
GLuint GLuint end
Definition: gl.h:1545
const WCHAR * ptr
Definition: parse.h:256
__wchar_t WCHAR
Definition: xmlstorage.h:180
const GLubyte * c
Definition: glext.h:8905
WINE_UNICODE_INLINE WCHAR tolowerW(WCHAR ch)
Definition: unicode.h:135
const WCHAR * word
Definition: lex.c:78
#define c
Definition: ke_i.h:80

Referenced by check_keywords().

◆ check_keywords()

static int check_keywords ( parser_ctx_t ctx)
static

Definition at line 180 of file lex.c.

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 }
#define max(a, b)
Definition: svc.c:63
static const struct @541 keywords[]
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
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 int check_keyword(parser_ctx_t *ctx, const WCHAR *word)
Definition: lex.c:159
#define ARRAY_SIZE(a)
Definition: main.h:24
#define min(a, b)
Definition: monoChain.cc:55
const WCHAR * word
Definition: lex.c:78

Referenced by parse_next_token().

◆ comment_line()

static int comment_line ( parser_ctx_t ctx)
static

Definition at line 390 of file lex.c.

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 }
static const WCHAR newlineW[]
Definition: reg.c:81
const WCHAR * ptr
Definition: parse.h:256
__wchar_t WCHAR
Definition: xmlstorage.h:180
WINE_UNICODE_INLINE WCHAR * strpbrkW(const WCHAR *str, const WCHAR *accept)
Definition: unicode.h:261
const WCHAR * end
Definition: parse.h:257

Referenced by parse_next_token().

◆ hex_to_int()

static int hex_to_int ( WCHAR  c)
static

Definition at line 353 of file lex.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 }
const GLubyte * c
Definition: glext.h:8905

Referenced by parse_hex_literal().

◆ is_identifier_char()

static BOOL is_identifier_char ( WCHAR  c)
inlinestatic

Definition at line 154 of file lex.c.

155 {
156  return isalnumW(c) || c == '_';
157 }
const GLubyte * c
Definition: glext.h:8905
WINE_UNICODE_INLINE int isalnumW(WCHAR wc)
Definition: unicode.h:190

◆ parse_hex_literal()

static int parse_hex_literal ( parser_ctx_t ctx,
LONG ret 
)
static

Definition at line 364 of file lex.c.

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 }
BOOL is_identifier_char(WCHAR c)
Definition: lex.c:123
long LONG
Definition: pedump.c:60
#define FIXME(fmt,...)
Definition: debug.h:110
const WCHAR * ptr
Definition: parse.h:256
static clock_t begin
Definition: xmllint.c:466
static int hex_to_int(WCHAR c)
Definition: lex.c:353
r l[0]
Definition: byte_order.h:167
#define d
Definition: ke_i.h:81
__wchar_t WCHAR
Definition: xmlstorage.h:180
int ret

Referenced by parse_next_token().

◆ parse_identifier()

static int parse_identifier ( parser_ctx_t ctx,
const WCHAR **  ret 
)
static

Definition at line 200 of file lex.c.

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 }
BOOL is_identifier_char(WCHAR c)
Definition: lex.c:123
static PVOID ptr
Definition: dispmode.c:27
const WCHAR * str
const WCHAR * ptr
Definition: parse.h:256
__wchar_t WCHAR
Definition: xmlstorage.h:180
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
const WCHAR * end
Definition: parse.h:257
static void * parser_alloc(parser_ctx_t *ctx, DWORD size)
Definition: parser.h:57

Referenced by parse_next_token().

◆ parse_next_token()

static int parse_next_token ( void lval,
parser_ctx_t ctx 
)
static

Definition at line 401 of file lex.c.

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 }
static int comment_line(parser_ctx_t *ctx)
Definition: lex.c:390
static void skip_spaces(parser_ctx_t *ctx)
Definition: lex.c:384
static int parse_string_literal(parser_ctx_t *ctx, const WCHAR **ret)
Definition: lex.c:220
static int parse_numeric_literal(parser_ctx_t *ctx, void **ret)
Definition: lex.c:263
static int parse_identifier(parser_ctx_t *ctx, const WCHAR **ret)
Definition: lex.c:200
static int check_keywords(parser_ctx_t *ctx)
Definition: lex.c:180
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:110
const WCHAR * ptr
Definition: parse.h:256
__wchar_t WCHAR
Definition: xmlstorage.h:180
const GLubyte * c
Definition: glext.h:8905
int ret
const WCHAR * end
Definition: parse.h:257
static int parse_hex_literal(parser_ctx_t *ctx, LONG *ret)
Definition: lex.c:364
#define c
Definition: ke_i.h:80
WINE_UNICODE_INLINE int isalphaW(WCHAR wc)
Definition: unicode.h:195
BOOL is_html
Definition: parse.h:261
int last_token
Definition: parse.h:264

Referenced by parser_lex().

◆ parse_numeric_literal()

static int parse_numeric_literal ( parser_ctx_t ctx,
void **  ret 
)
static

Definition at line 263 of file lex.c.

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 }
static size_t double int int int * sign
Definition: printf.c:64
#define TRUE
Definition: types.h:120
#define INT_MAX
Definition: limits.h:40
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define MAXLONGLONG
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 FIXME(fmt,...)
Definition: debug.h:110
const WCHAR * ptr
Definition: parse.h:256
r l[0]
Definition: byte_order.h:167
int64_t LONGLONG
Definition: typedefs.h:66
#define d
Definition: ke_i.h:81
int isinf(double x)
int ret
const WCHAR * end
Definition: parse.h:257
WINE_UNICODE_INLINE int isdigitW(WCHAR wc)
Definition: unicode.h:170
DWORD exp
Definition: msg.c:15681

Referenced by parse_next_token().

◆ parse_string_literal()

static int parse_string_literal ( parser_ctx_t ctx,
const WCHAR **  ret 
)
static

Definition at line 220 of file lex.c.

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 }
#define FIXME(fmt,...)
Definition: debug.h:110
static PVOID ptr
Definition: dispmode.c:27
const WCHAR * ptr
Definition: parse.h:256
__wchar_t WCHAR
Definition: xmlstorage.h:180
int ret
GLenum GLsizei len
Definition: glext.h:6722
const WCHAR * end
Definition: parse.h:257
static void * parser_alloc(parser_ctx_t *ctx, DWORD size)
Definition: parser.h:57

Referenced by parse_next_token().

◆ parser_lex()

int parser_lex ( void lval,
parser_ctx_t ctx 
)

Definition at line 491 of file lex.c.

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 void skip_spaces(parser_ctx_t *ctx)
Definition: lex.c:384
#define FIXME(fmt,...)
Definition: debug.h:110
const WCHAR * ptr
Definition: parse.h:256
static int parse_next_token(void *lval, parser_ctx_t *ctx)
Definition: lex.c:401
const WCHAR * code
Definition: parse.h:255
int ret
unsigned last_nl
Definition: parse.h:265
int last_token
Definition: parse.h:264

◆ skip_spaces()

static void skip_spaces ( parser_ctx_t ctx)
static

Definition at line 384 of file lex.c.

385 {
386  while(*ctx->ptr == ' ' || *ctx->ptr == '\t')
387  ctx->ptr++;
388 }
const WCHAR * ptr
Definition: parse.h:256

Referenced by parse_next_token(), and parser_lex().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( vbscript  )

Variable Documentation

◆ andW

const WCHAR andW[] = {'a','n','d',0}
static

Definition at line 33 of file lex.c.

◆ byrefW

const WCHAR byrefW[] = {'b','y','r','e','f',0}
static

Definition at line 34 of file lex.c.

◆ byvalW

const WCHAR byvalW[] = {'b','y','v','a','l',0}
static

Definition at line 35 of file lex.c.

◆ callW

const WCHAR callW[] = {'c','a','l','l',0}
static

Definition at line 36 of file lex.c.

◆ caseW

const WCHAR caseW[] = {'c','a','s','e',0}
static

Definition at line 37 of file lex.c.

◆ classW

◆ constW

const WCHAR constW[] = {'c','o','n','s','t',0}
static

Definition at line 39 of file lex.c.

◆ defaultW

const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0}
static

Definition at line 40 of file lex.c.

◆ dimW

const WCHAR dimW[] = {'d','i','m',0}
static

Definition at line 41 of file lex.c.

◆ doW

const WCHAR doW[] = {'d','o',0}
static

Definition at line 42 of file lex.c.

◆ eachW

const WCHAR eachW[] = {'e','a','c','h',0}
static

Definition at line 43 of file lex.c.

◆ elseifW

const WCHAR elseifW[] = {'e','l','s','e','i','f',0}
static

Definition at line 45 of file lex.c.

◆ elseW

const WCHAR elseW[] = {'e','l','s','e',0}
static

Definition at line 44 of file lex.c.

◆ emptyW

const WCHAR emptyW[] = {'e','m','p','t','y',0}
static

Definition at line 46 of file lex.c.

◆ endW

const WCHAR endW[] = {'e','n','d',0}
static

Definition at line 47 of file lex.c.

◆ eqvW

const WCHAR eqvW[] = {'e','q','v',0}
static

Definition at line 48 of file lex.c.

◆ errorW

const WCHAR errorW[] = {'e','r','r','o','r',0}
static

Definition at line 49 of file lex.c.

◆ exitW

const WCHAR exitW[] = {'e','x','i','t',0}
static

Definition at line 50 of file lex.c.

Referenced by event_end_dialog(), and wmain().

◆ explicitW

const WCHAR explicitW[] = {'e','x','p','l','i','c','i','t',0}
static

Definition at line 51 of file lex.c.

◆ falseW

const WCHAR falseW[] = {'f','a','l','s','e',0}
static

Definition at line 52 of file lex.c.

◆ forW

const WCHAR forW[] = {'f','o','r',0}
static

Definition at line 53 of file lex.c.

◆ functionW

const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0}
static

Definition at line 54 of file lex.c.

◆ getW

const WCHAR getW[] = {'g','e','t',0}
static

Definition at line 55 of file lex.c.

◆ gotoW

const WCHAR gotoW[] = {'g','o','t','o',0}
static

Definition at line 56 of file lex.c.

◆ ifW

const WCHAR ifW[] = {'i','f',0}
static

Definition at line 57 of file lex.c.

◆ impW

const WCHAR impW[] = {'i','m','p',0}
static

Definition at line 58 of file lex.c.

◆ inW

const WCHAR inW[] = {'i','n',0}
static

Definition at line 59 of file lex.c.

◆ isW

const WCHAR isW[] = {'i','s',0}
static

Definition at line 60 of file lex.c.

◆ keywords

const { ... } keywords[]

Referenced by check_keywords().

◆ letW

const WCHAR letW[] = {'l','e','t',0}
static

Definition at line 61 of file lex.c.

◆ loopW

const WCHAR loopW[] = {'l','o','o','p',0}
static

Definition at line 62 of file lex.c.

◆ meW

const WCHAR meW[] = {'m','e',0}
static

Definition at line 63 of file lex.c.

◆ modW

const WCHAR modW[] = {'m','o','d',0}
static

Definition at line 64 of file lex.c.

Referenced by a_to_w_callback(), and EnumerateLoadedModulesW64().

◆ newW

const WCHAR newW[] = {'n','e','w',0}
static

Definition at line 65 of file lex.c.

◆ nextW

const WCHAR nextW[] = {'n','e','x','t',0}
static

Definition at line 66 of file lex.c.

◆ nothingW

const WCHAR nothingW[] = {'n','o','t','h','i','n','g',0}
static

Definition at line 68 of file lex.c.

◆ notW

const WCHAR notW[] = {'n','o','t',0}
static

Definition at line 67 of file lex.c.

◆ nullW

const WCHAR nullW[] = {'n','u','l','l',0}
static

Definition at line 69 of file lex.c.

◆ onW

const WCHAR onW[] = {'o','n',0}
static

Definition at line 70 of file lex.c.

Referenced by COMM_ParseOnOff(), HTMLDocument_put_designMode(), and update_window_doc().

◆ optionW

const WCHAR optionW[] = {'o','p','t','i','o','n',0}
static

Definition at line 71 of file lex.c.

◆ orW

const WCHAR orW[] = {'o','r',0}
static

Definition at line 72 of file lex.c.

◆ privateW

const WCHAR privateW[] = {'p','r','i','v','a','t','e',0}
static

Definition at line 73 of file lex.c.

◆ propertyW

const WCHAR propertyW[] = {'p','r','o','p','e','r','t','y',0}
static

Definition at line 74 of file lex.c.

◆ publicW

const WCHAR publicW[] = {'p','u','b','l','i','c',0}
static

Definition at line 75 of file lex.c.

◆ remW

const WCHAR remW[] = {'r','e','m',0}
static

Definition at line 76 of file lex.c.

◆ resumeW

const WCHAR resumeW[] = {'r','e','s','u','m','e',0}
static

Definition at line 77 of file lex.c.

◆ selectW

const WCHAR selectW[] = {'s','e','l','e','c','t',0}
static

Definition at line 78 of file lex.c.

◆ setW

const WCHAR setW[] = {'s','e','t',0}
static

Definition at line 79 of file lex.c.

◆ stepW

const WCHAR stepW[] = {'s','t','e','p',0}
static

Definition at line 80 of file lex.c.

◆ stopW

const WCHAR stopW[] = {'s','t','o','p',0}
static

Definition at line 81 of file lex.c.

Referenced by COMM_BuildNewCommDCB().

◆ subW

const WCHAR subW[] = {'s','u','b',0}
static

Definition at line 82 of file lex.c.

◆ thenW

const WCHAR thenW[] = {'t','h','e','n',0}
static

Definition at line 83 of file lex.c.

◆ token

int token

Definition at line 93 of file lex.c.

◆ toW

const WCHAR toW[] = {'t','o',0}
static

Definition at line 84 of file lex.c.

Referenced by COMM_BuildNewCommDCB().

◆ trueW

const WCHAR trueW[] = {'t','r','u','e',0}
static

Definition at line 85 of file lex.c.

◆ untilW

const WCHAR untilW[] = {'u','n','t','i','l',0}
static

Definition at line 86 of file lex.c.

◆ wendW

const WCHAR wendW[] = {'w','e','n','d',0}
static

Definition at line 87 of file lex.c.

◆ whileW

const WCHAR whileW[] = {'w','h','i','l','e',0}
static

Definition at line 88 of file lex.c.

◆ word

const WCHAR* word

Definition at line 92 of file lex.c.

◆ xorW

const WCHAR xorW[] = {'x','o','r',0}
static

Definition at line 89 of file lex.c.