#include <assert.h>
#include <limits.h>
#include <math.h>
#include "vbscript.h"
#include "parse.h"
#include "parser.tab.h"
#include "wine/debug.h"

Include dependency graph for lex.c:

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (vbscript)

static BOOL	is_identifier_char (WCHAR c)

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

static int	check_keywords (parser_ctx_t ctx, const WCHAR *lval)

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,
		const WCHAR **	lval
	)

static

Definition at line 161 of file lex.c.

{
    const WCHAR *p1 = ctx->ptr;
    const WCHAR *p2 = word;
    WCHAR c;
 
    while(p1 < ctx->end && *p2) {
        c = towlower(*p1);
        if(c != *p2)
            return c - *p2;
        p1++;
        p2++;
    }
 
    if(*p2 || (p1 < ctx->end && is_identifier_char(*p1)))
        return 1;
 
    ctx->ptr = p1;
    *lval = word;
    return 0;
}

◆ check_keywords()

static int check_keywords	(	parser_ctx_t *	ctx,
		const WCHAR **	lval
	)

static

Definition at line 183 of file lex.c.

{
    int min = 0, max = ARRAY_SIZE(keywords)-1, r, i;
 
    while(min <= max) {
        i = (min+max)/2;
 
        r = check_keyword(ctx, keywords[i].word, lval);
        if(!r)
            return keywords[i].token;
 
        if(r > 0)
            min = i+1;
        else
            max = i-1;
    }
 
    return 0;
}

◆ comment_line()

static int comment_line ( parser_ctx_t * ctx )

static

Definition at line 395 of file lex.c.

{
    static const WCHAR newlineW[] = {'\n','\r',0};
    ctx->ptr = wcspbrk(ctx->ptr, newlineW);
    if(ctx->ptr)
        ctx->ptr++;
    else
        ctx->ptr = ctx->end;
    return tNL;
}

Referenced by parse_next_token().

◆ hex_to_int()

static int hex_to_int ( WCHAR c )

static

Definition at line 358 of file lex.c.

{
    if('0' <= c && c <= '9')
        return c-'0';
    if('a' <= c && c <= 'f')
        return c+10-'a';
    if('A' <= c && c <= 'F')
        return c+10-'A';
    return -1;
}

◆ is_identifier_char()

static BOOL is_identifier_char ( WCHAR c )

inlinestatic

Definition at line 156 of file lex.c.

{
    return iswalnum(c) || c == '_';
}

◆ parse_hex_literal()

static int parse_hex_literal	(	parser_ctx_t *	ctx,
		LONG *	ret
	)

static

Definition at line 369 of file lex.c.

{
    const WCHAR *begin = ctx->ptr;
    LONG l = 0, d;
 
    while((d = hex_to_int(*++ctx->ptr)) != -1)
        l = l*16 + d;
 
    if(begin + 9 /* max digits+1 */ < ctx->ptr || (*ctx->ptr != '&' && is_identifier_char(*ctx->ptr))) {
        FIXME("invalid literal\n");
        return 0;
    }
 
    if(*ctx->ptr == '&')
        ctx->ptr++;
 
    *ret = l;
    return tInt;
}

Referenced by parse_next_token().

◆ parse_identifier()

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

static

Definition at line 203 of file lex.c.

{
    const WCHAR *ptr = ctx->ptr++;
    WCHAR *str;
    int len;
 
    while(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr))
        ctx->ptr++;
    len = ctx->ptr-ptr;
 
    str = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
    if(!str)
        return 0;
 
    memcpy(str, ptr, (len+1)*sizeof(WCHAR));
    str[len] = 0;
    *ret = str;
    return tIdentifier;
}

◆ parse_next_token()

static int parse_next_token	(	void *	lval,
		parser_ctx_t *	ctx
	)

static

Definition at line 406 of file lex.c.

{
    WCHAR c;
 
    skip_spaces(ctx);
    if(ctx->ptr == ctx->end)
        return ctx->last_token == tNL ? tEOF : tNL;
 
    c = *ctx->ptr;
 
    if('0' <= c && c <= '9')
        return parse_numeric_literal(ctx, lval);
 
    if(iswalpha(c)) {
        int ret = check_keywords(ctx, lval);
        if(!ret)
            return parse_identifier(ctx, lval);
        if(ret != tREM)
            return ret;
        c = '\'';
    }
 
    switch(c) {
    case '\n':
    case '\r':
        ctx->ptr++;
        return tNL;
    case '\'':
        return comment_line(ctx);
    case ':':
    case ')':
    case ',':
    case '=':
    case '+':
    case '*':
    case '/':
    case '^':
    case '\\':
    case '.':
    case '_':
        return *ctx->ptr++;
    case '-':
        if(ctx->is_html && ctx->ptr[1] == '-' && ctx->ptr[2] == '>')
            return comment_line(ctx);
        ctx->ptr++;
        return '-';
    case '(':
        /* NOTE:
         * We resolve empty brackets in lexer instead of parser to avoid complex conflicts
         * in call statement special case |f()| without 'call' keyword
         */
        ctx->ptr++;
        skip_spaces(ctx);
        if(*ctx->ptr == ')') {
            ctx->ptr++;
            return tEMPTYBRACKETS;
        }
        return '(';
    case '"':
        return parse_string_literal(ctx, lval);
    case '&':
        if(*++ctx->ptr == 'h' || *ctx->ptr == 'H')
            return parse_hex_literal(ctx, lval);
        return '&';
    case '<':
        switch(*++ctx->ptr) {
        case '>':
            ctx->ptr++;
            return tNEQ;
        case '=':
            ctx->ptr++;
            return tLTEQ;
        case '!':
            if(ctx->is_html && ctx->ptr[1] == '-' && ctx->ptr[2] == '-')
                return comment_line(ctx);
        }
        return '<';
    case '>':
        if(*++ctx->ptr == '=') {
            ctx->ptr++;
            return tGTEQ;
        }
        return '>';
    default:
        FIXME("Unhandled char %c in %s\n", *ctx->ptr, debugstr_w(ctx->ptr));
    }
 
    return 0;
}

Referenced by parser_lex().

◆ parse_numeric_literal()

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

static

Definition at line 266 of file lex.c.

{
    BOOL use_int = TRUE;
    LONGLONG d = 0, hlp;
    int exp = 0;
    double r;
 
    if(*ctx->ptr == '0' && !('0' <= ctx->ptr[1] && ctx->ptr[1] <= '9') && ctx->ptr[1] != '.')
        return *ctx->ptr++;
 
    while(ctx->ptr < ctx->end && iswdigit(*ctx->ptr)) {
        hlp = d*10 + *(ctx->ptr++) - '0';
        if(d>MAXLONGLONG/10 || hlp<0) {
            exp++;
            break;
        }
        else
            d = hlp;
    }
    while(ctx->ptr < ctx->end && iswdigit(*ctx->ptr)) {
        exp++;
        ctx->ptr++;
    }
 
    if(*ctx->ptr == '.') {
        use_int = FALSE;
        ctx->ptr++;
 
        while(ctx->ptr < ctx->end && iswdigit(*ctx->ptr)) {
            hlp = d*10 + *(ctx->ptr++) - '0';
            if(d>MAXLONGLONG/10 || hlp<0)
                break;
 
            d = hlp;
            exp--;
        }
        while(ctx->ptr < ctx->end && iswdigit(*ctx->ptr))
            ctx->ptr++;
    }
 
    if(*ctx->ptr == 'e' || *ctx->ptr == 'E') {
        int e = 0, sign = 1;
 
        ctx->ptr++;
        if(*ctx->ptr == '-') {
            ctx->ptr++;
            sign = -1;
        }else if(*ctx->ptr == '+') {
            ctx->ptr++;
        }
 
        if(!iswdigit(*ctx->ptr)) {
            FIXME("Invalid numeric literal\n");
            return 0;
        }
 
        use_int = FALSE;
 
        do {
            e = e*10 + *(ctx->ptr++) - '0';
            if(sign == -1 && -e+exp < -(INT_MAX/100)) {
                /* The literal will be rounded to 0 anyway. */
                while(iswdigit(*ctx->ptr))
                    ctx->ptr++;
                *(double*)ret = 0;
                return tDouble;
            }
 
            if(sign*e + exp > INT_MAX/100) {
                FIXME("Invalid numeric literal\n");
                return 0;
            }
        } while(iswdigit(*ctx->ptr));
 
        exp += sign*e;
    }
 
    if(use_int && (LONG)d == d) {
        *(LONG*)ret = d;
        return tInt;
    }
 
    r = exp>=0 ? d*pow(10, exp) : d/pow(10, -exp);
    if(isinf(r)) {
        FIXME("Invalid numeric literal\n");
        return 0;
    }
 
    *(double*)ret = r;
    return tDouble;
}

◆ parse_string_literal()

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

static

Definition at line 223 of file lex.c.

{
    const WCHAR *ptr = ++ctx->ptr;
    WCHAR *rptr;
    int len = 0;
 
    while(ctx->ptr < ctx->end) {
        if(*ctx->ptr == '\n' || *ctx->ptr == '\r') {
            FIXME("newline inside string literal\n");
            return 0;
        }
 
       if(*ctx->ptr == '"') {
            if(ctx->ptr[1] != '"')
                break;
            len--;
            ctx->ptr++;
        }
        ctx->ptr++;
    }
 
    if(ctx->ptr == ctx->end) {
        FIXME("unterminated string literal\n");
        return 0;
    }
 
    len += ctx->ptr-ptr;
 
    *ret = rptr = parser_alloc(ctx, (len+1)*sizeof(WCHAR));
    if(!rptr)
        return 0;
 
    while(ptr < ctx->ptr) {
        if(*ptr == '"')
            ptr++;
        *rptr++ = *ptr++;
    }
 
    *rptr = 0;
    ctx->ptr++;
    return tString;
}

◆ parser_lex()

int parser_lex	(	void *	lval,
		parser_ctx_t *	ctx
	)

Definition at line 496 of file lex.c.

{
    int ret;
 
    if (ctx->last_token == tEXPRESSION)
    {
        ctx->last_token = tNL;
        return tEXPRESSION;
    }
 
    while(1) {
        ret = parse_next_token(lval, ctx);
        if(ret == '_') {
            skip_spaces(ctx);
            if(*ctx->ptr != '\n' && *ctx->ptr != '\r') {
                FIXME("'_' not followed by newline\n");
                return 0;
            }
            if(*ctx->ptr == '\r')
                ctx->ptr++;
            if(*ctx->ptr == '\n')
                ctx->ptr++;
            continue;
        }
        if(ret != tNL || ctx->last_token != tNL)
            break;
 
        ctx->last_nl = ctx->ptr-ctx->code;
    }
 
    return (ctx->last_token = ret);
}

◆ skip_spaces()

static void skip_spaces ( parser_ctx_t * ctx )

static

Definition at line 389 of file lex.c.

{
    while(*ctx->ptr == ' ' || *ctx->ptr == '\t')
        ctx->ptr++;
}

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( vbscript )

Variable Documentation

◆ andW

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

static

Definition at line 35 of file lex.c.

◆ byrefW

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

static

Definition at line 36 of file lex.c.

◆ byvalW

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

static

Definition at line 37 of file lex.c.

◆ callW

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

static

Definition at line 38 of file lex.c.

◆ caseW

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

static

Definition at line 39 of file lex.c.

◆ classW

const WCHAR classW[] = {'c','l','a','s','s',0}

static

Definition at line 40 of file lex.c.

Referenced by FindWindowExA(), get_system_propval(), set_profile_device_key(), SetupOpenInfFileA(), test_builtinproc(), test_DsClientMakeSpnForTargetServer(), test_IsWindowUnicode(), test_IWbemPath_GetClassName(), test_IWbemPath_GetText(), test_IWbemPath_SetClassName(), test_MDI_create(), test_stub(), and wmain().

◆ constW

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

static

Definition at line 41 of file lex.c.

◆ defaultW

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

static

Definition at line 42 of file lex.c.

Referenced by build_resource_string(), client_security_SetBlanket(), is_valid_xml_space_value(), parse_resource(), register_dsound_devices(), register_midiout_devices(), register_waveout_devices(), test_CreateTypeLib(), test_dsound(), test_midiout(), test_waveout(), and wbem_services_OpenNamespace().

◆ dimW

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

static

Definition at line 43 of file lex.c.

◆ doW

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

static

Definition at line 44 of file lex.c.

◆ eachW

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

static

Definition at line 45 of file lex.c.

◆ elseifW

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

static

Definition at line 47 of file lex.c.

◆ elseW

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

static

Definition at line 46 of file lex.c.

◆ emptyW

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

static

Definition at line 48 of file lex.c.

◆ endW

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

static

Definition at line 49 of file lex.c.

Referenced by reader_parse_stag().

◆ eqvW

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

static

Definition at line 50 of file lex.c.

◆ errorW

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

static

Definition at line 51 of file lex.c.

◆ exitW

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

static

Definition at line 52 of file lex.c.

Referenced by wmain().

◆ explicitW

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

static

Definition at line 53 of file lex.c.

◆ falseW

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

static

Definition at line 54 of file lex.c.

◆ forW

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

static

Definition at line 55 of file lex.c.

◆ functionW

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

static

Definition at line 56 of file lex.c.

◆ getW

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

static

Definition at line 57 of file lex.c.

◆ gotoW

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

static

Definition at line 58 of file lex.c.

◆ ifW

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

static

Definition at line 59 of file lex.c.

◆ impW

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

static

Definition at line 60 of file lex.c.

◆ inW

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

static

Definition at line 61 of file lex.c.

Referenced by build_signature_table_name(), test_get_atom_name(), test_graph_builder_connect(), and test_local_get_atom_name().

◆ isW

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

static

Definition at line 62 of file lex.c.

Referenced by CallWindowProcT(), column_fill_hditem(), CreateEditLabelT(), debuglvcolumn_t(), debuglvitem_t(), debugstr_t(), debugtext_t(), debugtext_tn(), EditLblWndProcT(), LISTVIEW_EditLabelT(), LISTVIEW_EndEditLabelT(), LISTVIEW_GetColumnT(), LISTVIEW_GetItemExtT(), LISTVIEW_GetItemT(), LISTVIEW_GetItemTextT(), LISTVIEW_GetStringWidthT(), LISTVIEW_InsertColumnT(), LISTVIEW_InsertItemT(), LISTVIEW_SetColumnT(), LISTVIEW_SetItemT(), LISTVIEW_SetItemTextT(), notify_dispinfoT(), set_main_item(), set_sub_item(), STATUSBAR_SetTextT(), TAB_DumpItemExternalT(), textcmpWT(), textdupTtoW(), textfreeT(), textlenT(), textsetptrT(), TOOLBAR_GetButtonText(), TOOLBAR_SetButtonInfo(), TOOLTIPS_AddToolT(), TOOLTIPS_CopyInfoT(), TOOLTIPS_DelToolT(), TOOLTIPS_EnumToolsT(), TOOLTIPS_GetCurrentToolT(), TOOLTIPS_GetTextT(), TOOLTIPS_GetToolInfoT(), TOOLTIPS_HitTestT(), TOOLTIPS_IsCallbackString(), TOOLTIPS_SetTitleT(), TOOLTIPS_SetToolInfoT(), TOOLTIPS_UpdateTipTextT(), TREEVIEW_DoSetItemT(), TREEVIEW_GetItemT(), TREEVIEW_InsertItemT(), and TREEVIEW_SetItemT().

◆

const struct { ... } keywords[]

◆ letW

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

static

Definition at line 63 of file lex.c.

◆ loopW

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

static

Definition at line 64 of file lex.c.

◆ meW

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

static

Definition at line 65 of file lex.c.

◆ modW

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

static

Definition at line 66 of file lex.c.

Referenced by a_to_w_callback(), and EnumerateLoadedModulesW64().

◆ newW

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

static

Definition at line 67 of file lex.c.

◆ nextW

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

static

Definition at line 68 of file lex.c.

◆ nothingW

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

static

Definition at line 70 of file lex.c.

◆ notW

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

static

Definition at line 69 of file lex.c.

◆ nullW

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

static

Definition at line 71 of file lex.c.

◆ onW

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

static

Definition at line 72 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 73 of file lex.c.

◆ orW

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

static

Definition at line 74 of file lex.c.

◆ privateW

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

static

Definition at line 75 of file lex.c.

◆ propertyW

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

static

Definition at line 76 of file lex.c.

◆ publicW

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

static

Definition at line 77 of file lex.c.

◆ remW

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

static

Definition at line 78 of file lex.c.

◆ resumeW

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

static

Definition at line 79 of file lex.c.

◆ selectW

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

static

Definition at line 80 of file lex.c.

◆ setW

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

static

Definition at line 81 of file lex.c.

◆ stepW

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

static

Definition at line 82 of file lex.c.

◆ stopW

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

static

Definition at line 83 of file lex.c.

Referenced by COMM_BuildNewCommDCB().

◆ subW

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

static

Definition at line 84 of file lex.c.

◆ thenW

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

static

Definition at line 85 of file lex.c.

◆ token

int token ( void )

Definition at line 95 of file lex.c.

◆ toW

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

static

Definition at line 86 of file lex.c.

Referenced by COMM_BuildNewCommDCB().

◆ trueW

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

static

Definition at line 87 of file lex.c.

◆ untilW

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

static

Definition at line 88 of file lex.c.

◆ wendW

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

static

Definition at line 89 of file lex.c.

◆ whileW

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

static

Definition at line 90 of file lex.c.

◆ word

const WCHAR* word

Definition at line 94 of file lex.c.

◆ xorW

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

static

Definition at line 91 of file lex.c.

Functions

Variables

Function Documentation

◆ check_keyword()

◆ check_keywords()

◆ comment_line()

◆ hex_to_int()

◆ is_identifier_char()

◆ parse_hex_literal()

◆ parse_identifier()

◆ parse_next_token()

◆ parse_numeric_literal()

◆ parse_string_literal()

◆ parser_lex()

◆ skip_spaces()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ andW

◆ byrefW

◆ byvalW

◆ callW

◆ caseW

◆ classW

◆ constW

◆ defaultW

◆ dimW

◆ doW

◆ eachW

◆ elseifW

◆ elseW

◆ emptyW

◆ endW

◆ eqvW

◆ errorW

◆ exitW

◆ explicitW

◆ falseW

◆ forW

◆ functionW

◆ getW

◆ gotoW

◆ ifW

◆ impW

◆ inW

◆ isW

◆

◆ letW

◆ loopW

◆ meW

◆ modW

◆ newW

◆ nextW

◆ nothingW

◆ notW

◆ nullW

◆ onW

◆ optionW

◆ orW

◆ privateW

◆ propertyW

◆ publicW

◆ remW

◆ resumeW

◆ selectW

◆ setW

◆ stepW

◆ stopW

◆ subW

◆ thenW

◆ token

◆ toW

◆ trueW

◆ untilW

◆ wendW

◆ whileW

◆ word

◆ xorW