lex.c File Reference

#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:

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, 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_date_literal (parser_ctx_t *ctx, DATE *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, unsigned *loc, parser_ctx_t *ctx)
int	parser_lex (void *lval, unsigned *loc, parser_ctx_t *ctx)

Variables
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 106 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 128 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 384 of file lex.c.

{
    ctx->ptr = wcspbrk(ctx->ptr, L"\n\r");
    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 345 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 101 of file lex.c.

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

parse_date_literal()

static int parse_date_literal ( parser_ctx_t *  ctx, DATE *  ret  )

static

Definition at line 211 of file lex.c.

{
    const WCHAR *ptr = ++ctx->ptr;
    WCHAR *rptr;
    int len = 0;
    HRESULT res;
 
    while(ctx->ptr < ctx->end) {
        if(*ctx->ptr == '\n' || *ctx->ptr == '\r') {
            FIXME("newline inside date literal\n");
            return 0;
        }
 
       if(*ctx->ptr == '#')
            break;
       ctx->ptr++;
    }
 
    if(ctx->ptr == ctx->end) {
        FIXME("unterminated date literal\n");
        return 0;
    }
 
    len += ctx->ptr-ptr;
 
    rptr = malloc((len+1)*sizeof(WCHAR));
    if(!rptr)
        return 0;
 
    memcpy( rptr, ptr, len * sizeof(WCHAR));
    rptr[len] = 0;
    res = VarDateFromStr(rptr, ctx->lcid, 0, ret);
    free(rptr);
    if (FAILED(res)) {
        FIXME("Invalid date literal\n");
        return 0;
    }
 
    ctx->ptr++;
    return tDate;
}

Referenced by parse_next_token().

parse_hex_literal()

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

static

Definition at line 356 of file lex.c.

{
    const WCHAR *begin = ctx->ptr;
    unsigned l = 0, d;
 
    while((d = hex_to_int(*++ctx->ptr)) != -1)
        l = l*16 + d;
 
    if(begin + 9 /* max digits+1 */ < ctx->ptr) {
        FIXME("invalid literal\n");
        return 0;
    }
 
    if(*ctx->ptr == '&') {
        ctx->ptr++;
        *ret = l;
    }else {
        *ret = l == (UINT16)l ? (INT16)l : 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 148 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, unsigned *  loc, parser_ctx_t *  ctx  )

static

Definition at line 394 of file lex.c.

{
    WCHAR c;
 
    skip_spaces(ctx);
    *loc = ctx->ptr - ctx->code;
    if(ctx->ptr == ctx->end)
        return ctx->last_token == tNL ? 0 : tNL;
 
    c = *ctx->ptr;
 
    if('0' <= c && c <= '9')
        return parse_numeric_literal(ctx, lval);
 
    if(iswalpha(c)) {
        int ret = 0;
        if(ctx->last_token != '.' && ctx->last_token != tDOT)
            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 '_':
        return *ctx->ptr++;
    case '.':
        /*
         * We need to distinguish between '.' used as part of a member expression and
         * a beginning of a dot expression (a member expression accessing with statement
         * expression) and a floating point number like ".2" .
         */
        c = ctx->ptr > ctx->code ? ctx->ptr[-1] : '\n';
        if (is_identifier_char(c) || c == ')') {
            ctx->ptr++;
            return '.';
        }
        c = ctx->ptr[1];
        if('0' <= c && c <= '9')
            return parse_numeric_literal(ctx, lval);
        ctx->ptr++;
        return tDOT;
    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;
        }
        /*
         * Parser can't predict if bracket is part of argument expression or an argument
         * in call expression. We predict it here instead.
         */
        if(ctx->last_token == tIdentifier || ctx->last_token == ')')
            return '(';
        return tEXPRLBRACKET;
    case '"':
        return parse_string_literal(ctx, lval);
    case '#':
        return parse_date_literal(ctx, lval);
    case '&':
        if((*++ctx->ptr == 'h' || *ctx->ptr == 'H') && hex_to_int(ctx->ptr[1]) != -1)
            return parse_hex_literal(ctx, lval);
        return '&';
    case '=':
        switch(*++ctx->ptr) {
        case '<':
            ctx->ptr++;
            return tLTEQ;
        case '>':
            ctx->ptr++;
            return tGTEQ;
        }
        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 '>':
        switch(*++ctx->ptr) {
        case '=':
            ctx->ptr++;
            return tGTEQ;
        case '<':
            ctx->ptr++;
            return tNEQ;
        }
        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 253 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 && is_digit(*ctx->ptr)) {
        hlp = d*10 + *(ctx->ptr++) - '0';
        if(d>MAXLONGLONG/10 || hlp<0) {
            exp++;
            break;
        }
        else
            d = hlp;
    }
    while(ctx->ptr < ctx->end && is_digit(*ctx->ptr)) {
        exp++;
        ctx->ptr++;
    }
 
    if(*ctx->ptr == '.') {
        use_int = FALSE;
        ctx->ptr++;
 
        while(ctx->ptr < ctx->end && is_digit(*ctx->ptr)) {
            hlp = d*10 + *(ctx->ptr++) - '0';
            if(d>MAXLONGLONG/10 || hlp<0)
                break;
 
            d = hlp;
            exp--;
        }
        while(ctx->ptr < ctx->end && is_digit(*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(!is_digit(*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(is_digit(*ctx->ptr))
                    ctx->ptr++;
                *(double*)ret = 0;
                return tDouble;
            }
 
            if(sign*e + exp > INT_MAX/100) {
                FIXME("Invalid numeric literal\n");
                return 0;
            }
        } while(is_digit(*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 168 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,
		unsigned *	loc,
		parser_ctx_t *	ctx
	)

Definition at line 523 of file lex.c.

{
    int ret;
 
    if (ctx->last_token == tEXPRESSION)
    {
        ctx->last_token = tNL;
        return tEXPRESSION;
    }
 
    while(1) {
        ret = parse_next_token(lval, loc, 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 378 of file lex.c.

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

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

vbscript

)

Variable Documentation

const struct { ... } keywords[]

token

int token

(

void

)

Definition at line 37 of file lex.c.

word

const WCHAR* word

Definition at line 36 of file lex.c.