parser.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ccval_t
struct	_parser_ctx_t
struct	literal_t
struct	_variable_declaration_t
struct	_statement_t
struct	block_statement_t
struct	var_statement_t
struct	expression_statement_t
struct	if_statement_t
struct	while_statement_t
struct	for_statement_t
struct	forin_statement_t
struct	branch_statement_t
struct	with_statement_t
struct	labelled_statement_t
struct	_case_clausule_t
struct	switch_statement_t
struct	catch_block_t
struct	try_statement_t
struct	_expression_t
struct	_parameter_t
struct	_source_elements_t
struct	_function_expression_t
struct	binary_expression_t
struct	unary_expression_t
struct	conditional_expression_t
struct	member_expression_t
struct	_argument_t
struct	call_expression_t
struct	identifier_expression_t
struct	literal_expression_t
struct	_array_element_t
struct	array_literal_expression_t
struct	_property_definition_t
struct	property_value_expression_t

Typedefs
typedef struct _source_elements_t	source_elements_t
typedef struct _expression_t	expression_t
typedef struct _statement_t	statement_t
typedef struct _parser_ctx_t	parser_ctx_t
typedef struct _variable_declaration_t	variable_declaration_t
typedef struct _case_clausule_t	case_clausule_t
typedef struct _parameter_t	parameter_t
typedef struct _function_expression_t	function_expression_t
typedef struct _argument_t	argument_t
typedef struct _array_element_t	array_element_t
typedef struct _property_definition_t	property_definition_t

Enumerations
enum	literal_type_t {   LT_DOUBLE, LT_STRING, LT_BOOL, LT_NULL,   LT_REGEXP }
enum	statement_type_t {   STAT_BLOCK, STAT_BREAK, STAT_CONTINUE, STAT_EMPTY,   STAT_EXPR, STAT_FOR, STAT_FORIN, STAT_IF,   STAT_LABEL, STAT_RETURN, STAT_SWITCH, STAT_THROW,   STAT_TRY, STAT_VAR, STAT_WHILE, STAT_WITH,   STAT_ASSIGN, STAT_CALL, STAT_CONST, STAT_DIM,   STAT_DOUNTIL, STAT_DOWHILE, STAT_EXITDO, STAT_EXITFOR,   STAT_EXITFUNC, STAT_EXITPROP, STAT_EXITSUB, STAT_FOREACH,   STAT_FORTO, STAT_FUNC, STAT_IF, STAT_ONERROR,   STAT_SELECT, STAT_SET, STAT_STOP, STAT_UNTIL,   STAT_WHILE, STAT_WHILELOOP, STAT_RETVAL }
enum	expression_type_t {   EXPR_COMMA, EXPR_OR, EXPR_AND, EXPR_BOR,   EXPR_BXOR, EXPR_BAND, EXPR_INSTANCEOF, EXPR_IN,   EXPR_ADD, EXPR_SUB, EXPR_MUL, EXPR_DIV,   EXPR_MOD, EXPR_DELETE, EXPR_VOID, EXPR_TYPEOF,   EXPR_MINUS, EXPR_PLUS, EXPR_POSTINC, EXPR_POSTDEC,   EXPR_PREINC, EXPR_PREDEC, EXPR_EQ, EXPR_EQEQ,   EXPR_NOTEQ, EXPR_NOTEQEQ, EXPR_LESS, EXPR_LESSEQ,   EXPR_GREATER, EXPR_GREATEREQ, EXPR_BITNEG, EXPR_LOGNEG,   EXPR_LSHIFT, EXPR_RSHIFT, EXPR_RRSHIFT, EXPR_ASSIGN,   EXPR_ASSIGNLSHIFT, EXPR_ASSIGNRSHIFT, EXPR_ASSIGNRRSHIFT, EXPR_ASSIGNADD,   EXPR_ASSIGNSUB, EXPR_ASSIGNMUL, EXPR_ASSIGNDIV, EXPR_ASSIGNMOD,   EXPR_ASSIGNAND, EXPR_ASSIGNOR, EXPR_ASSIGNXOR, EXPR_COND,   EXPR_ARRAY, EXPR_MEMBER, EXPR_NEW, EXPR_CALL,   EXPR_THIS, EXPR_FUNC, EXPR_IDENT, EXPR_ARRAYLIT,   EXPR_PROPVAL, EXPR_LITERAL, EXPR_ADD, EXPR_AND,   EXPR_BOOL, EXPR_BRACKETS, EXPR_CONCAT, EXPR_DIV,   EXPR_DOUBLE, EXPR_EMPTY, EXPR_EQUAL, EXPR_EQV,   EXPR_EXP, EXPR_GT, EXPR_GTEQ, EXPR_IDIV,   EXPR_IMP, EXPR_INT, EXPR_IS, EXPR_LT,   EXPR_LTEQ, EXPR_ME, EXPR_MEMBER, EXPR_MOD,   EXPR_MUL, EXPR_NEG, EXPR_NEQUAL, EXPR_NEW,   EXPR_NOARG, EXPR_NOT, EXPR_NOTHING, EXPR_NULL,   EXPR_OR, EXPR_STRING, EXPR_SUB, EXPR_XOR }

Functions
HRESULT	script_parse (script_ctx_t *, struct _compiler_ctx_t *, const WCHAR *, const WCHAR *, BOOL, parser_ctx_t **) DECLSPEC_HIDDEN
void	parser_release (parser_ctx_t *) DECLSPEC_HIDDEN
int	parser_lex (void *, parser_ctx_t *) DECLSPEC_HIDDEN
static void *	parser_alloc (parser_ctx_t *ctx, DWORD size)
static void *	parser_alloc_tmp (parser_ctx_t *ctx, DWORD size)
BOOL	is_identifier_char (WCHAR) DECLSPEC_HIDDEN
BOOL	unescape (WCHAR *, size_t *) DECLSPEC_HIDDEN
HRESULT	parse_decimal (const WCHAR **, const WCHAR *, double *) DECLSPEC_HIDDEN
literal_t *	parse_regexp (parser_ctx_t *) DECLSPEC_HIDDEN
literal_t *	new_boolean_literal (parser_ctx_t *, BOOL) DECLSPEC_HIDDEN
BOOL	try_parse_ccval (parser_ctx_t *, ccval_t *) DECLSPEC_HIDDEN
BOOL	parse_cc_expr (parser_ctx_t *) DECLSPEC_HIDDEN
static ccval_t	ccval_num (double n)
static ccval_t	ccval_bool (BOOL b)
static BOOL	get_ccbool (ccval_t v)
static double	get_ccnum (ccval_t v)
jsstr_t *	compiler_alloc_string_len (struct _compiler_ctx_t *, const WCHAR *, unsigned) DECLSPEC_HIDDEN

Typedef Documentation

argument_t

typedef struct _argument_t argument_t

array_element_t

typedef struct _array_element_t array_element_t

case_clausule_t

typedef struct _case_clausule_t case_clausule_t

expression_t

typedef struct _expression_t expression_t

Definition at line 22 of file parser.h.

function_expression_t

typedef struct _function_expression_t function_expression_t

parameter_t

typedef struct _parameter_t parameter_t

parser_ctx_t

typedef struct _parser_ctx_t parser_ctx_t

property_definition_t

typedef struct _property_definition_t property_definition_t

source_elements_t

typedef struct _source_elements_t source_elements_t

Definition at line 21 of file parser.h.

statement_t

typedef struct _statement_t statement_t

Definition at line 23 of file parser.h.

variable_declaration_t

typedef struct _variable_declaration_t variable_declaration_t

Enumeration Type Documentation

expression_type_t

enum expression_type_t

Enumerator
EXPR_COMMA
EXPR_OR
EXPR_AND
EXPR_BOR
EXPR_BXOR
EXPR_BAND
EXPR_INSTANCEOF
EXPR_IN
EXPR_ADD
EXPR_SUB
EXPR_MUL
EXPR_DIV
EXPR_MOD
EXPR_DELETE
EXPR_VOID
EXPR_TYPEOF
EXPR_MINUS
EXPR_PLUS
EXPR_POSTINC
EXPR_POSTDEC
EXPR_PREINC
EXPR_PREDEC
EXPR_EQ
EXPR_EQEQ
EXPR_NOTEQ
EXPR_NOTEQEQ
EXPR_LESS
EXPR_LESSEQ
EXPR_GREATER
EXPR_GREATEREQ
EXPR_BITNEG
EXPR_LOGNEG
EXPR_LSHIFT
EXPR_RSHIFT
EXPR_RRSHIFT
EXPR_ASSIGN
EXPR_ASSIGNLSHIFT
EXPR_ASSIGNRSHIFT
EXPR_ASSIGNRRSHIFT
EXPR_ASSIGNADD
EXPR_ASSIGNSUB
EXPR_ASSIGNMUL
EXPR_ASSIGNDIV
EXPR_ASSIGNMOD
EXPR_ASSIGNAND
EXPR_ASSIGNOR
EXPR_ASSIGNXOR
EXPR_COND
EXPR_ARRAY
EXPR_MEMBER
EXPR_NEW
EXPR_CALL
EXPR_THIS
EXPR_FUNC
EXPR_IDENT
EXPR_ARRAYLIT
EXPR_PROPVAL
EXPR_LITERAL
EXPR_ADD
EXPR_AND
EXPR_BOOL
EXPR_BRACKETS
EXPR_CONCAT
EXPR_DIV
EXPR_DOUBLE
EXPR_EMPTY
EXPR_EQUAL
EXPR_EQV
EXPR_EXP
EXPR_GT
EXPR_GTEQ
EXPR_IDIV
EXPR_IMP
EXPR_INT
EXPR_IS
EXPR_LT
EXPR_LTEQ
EXPR_ME
EXPR_MEMBER
EXPR_MOD
EXPR_MUL
EXPR_NEG
EXPR_NEQUAL
EXPR_NEW
EXPR_NOARG
EXPR_NOT
EXPR_NOTHING
EXPR_NULL
EXPR_OR
EXPR_STRING
EXPR_SUB
EXPR_XOR

Definition at line 216 of file parser.h.

             {
     EXPR_COMMA,
     EXPR_OR,
     EXPR_AND,
     EXPR_BOR,
     EXPR_BXOR,
     EXPR_BAND,
     EXPR_INSTANCEOF,
     EXPR_IN,
     EXPR_ADD,
     EXPR_SUB,
     EXPR_MUL,
     EXPR_DIV,
     EXPR_MOD,
     EXPR_DELETE,
     EXPR_VOID,
     EXPR_TYPEOF,
     EXPR_MINUS,
     EXPR_PLUS,
     EXPR_POSTINC,
     EXPR_POSTDEC,
     EXPR_PREINC,
     EXPR_PREDEC,
     EXPR_EQ,
     EXPR_EQEQ,
     EXPR_NOTEQ,
     EXPR_NOTEQEQ,
     EXPR_LESS,
     EXPR_LESSEQ,
     EXPR_GREATER,
     EXPR_GREATEREQ,
     EXPR_BITNEG,
     EXPR_LOGNEG,
     EXPR_LSHIFT,
     EXPR_RSHIFT,
     EXPR_RRSHIFT,
     EXPR_ASSIGN,
     EXPR_ASSIGNLSHIFT,
     EXPR_ASSIGNRSHIFT,
     EXPR_ASSIGNRRSHIFT,
     EXPR_ASSIGNADD,
     EXPR_ASSIGNSUB,
     EXPR_ASSIGNMUL,
     EXPR_ASSIGNDIV,
     EXPR_ASSIGNMOD,
     EXPR_ASSIGNAND,
     EXPR_ASSIGNOR,
     EXPR_ASSIGNXOR,
     EXPR_COND,
     EXPR_ARRAY,
     EXPR_MEMBER,
     EXPR_NEW,
     EXPR_CALL,
     EXPR_THIS,
     EXPR_FUNC,
     EXPR_IDENT,
     EXPR_ARRAYLIT,
     EXPR_PROPVAL,
     EXPR_LITERAL
} expression_type_t;

literal_type_t

enum literal_type_t

Enumerator
LT_DOUBLE
LT_STRING
LT_BOOL
LT_NULL
LT_REGEXP

Definition at line 72 of file parser.h.

             {
    LT_DOUBLE,
    LT_STRING,
    LT_BOOL,
    LT_NULL,
    LT_REGEXP
}literal_type_t;

statement_type_t

enum statement_type_t

Enumerator
STAT_BLOCK
STAT_BREAK
STAT_CONTINUE
STAT_EMPTY
STAT_EXPR
STAT_FOR
STAT_FORIN
STAT_IF
STAT_LABEL
STAT_RETURN
STAT_SWITCH
STAT_THROW
STAT_TRY
STAT_VAR
STAT_WHILE
STAT_WITH
STAT_ASSIGN
STAT_CALL
STAT_CONST
STAT_DIM
STAT_DOUNTIL
STAT_DOWHILE
STAT_EXITDO
STAT_EXITFOR
STAT_EXITFUNC
STAT_EXITPROP
STAT_EXITSUB
STAT_FOREACH
STAT_FORTO
STAT_FUNC
STAT_IF
STAT_ONERROR
STAT_SELECT
STAT_SET
STAT_STOP
STAT_UNTIL
STAT_WHILE
STAT_WHILELOOP
STAT_RETVAL

Definition at line 104 of file parser.h.

             {
    STAT_BLOCK,
    STAT_BREAK,
    STAT_CONTINUE,
    STAT_EMPTY,
    STAT_EXPR,
    STAT_FOR,
    STAT_FORIN,
    STAT_IF,
    STAT_LABEL,
    STAT_RETURN,
    STAT_SWITCH,
    STAT_THROW,
    STAT_TRY,
    STAT_VAR,
    STAT_WHILE,
    STAT_WITH
} statement_type_t;

Function Documentation

ccval_bool()

static ccval_t ccval_bool ( BOOL  b )

inlinestatic

Definition at line 387 of file parser.h.

{
    ccval_t r;
    r.is_num = FALSE;
    r.u.b = b;
    return r;
}

Referenced by init_cc(), try_parse_ccval(), and yyparse().

ccval_num()

static ccval_t ccval_num ( double  n )

inlinestatic

Definition at line 379 of file parser.h.

{
    ccval_t r;
    r.is_num = TRUE;
    r.u.n = n;
    return r;
}

Referenced by init_cc(), try_parse_ccval(), and yyparse().

compiler_alloc_string_len()

jsstr_t* compiler_alloc_string_len	(	struct _compiler_ctx_t *	,
		const WCHAR *	,
		unsigned
	)

Definition at line 133 of file compile.c.

{
    jsstr_t *new_str;

    if(!ctx->code->str_pool_size) {
        ctx->code->str_pool = heap_alloc(8 * sizeof(jsstr_t*));
        if(!ctx->code->str_pool)
            return NULL;
        ctx->code->str_pool_size = 8;
    }else if(ctx->code->str_pool_size == ctx->code->str_cnt) {
        jsstr_t **new_pool;

        new_pool = heap_realloc(ctx->code->str_pool, ctx->code->str_pool_size*2*sizeof(jsstr_t*));
        if(!new_pool)
            return NULL;

        ctx->code->str_pool = new_pool;
        ctx->code->str_pool_size *= 2;
    }

    new_str = jsstr_alloc_len(str, len);
    if(!new_str)
        return NULL;

    ctx->code->str_pool[ctx->code->str_cnt++] = new_str;
    return new_str;
}

Referenced by compiler_alloc_string(), parse_regexp(), parse_string_literal(), and yyparse().

get_ccbool()

static BOOL get_ccbool ( ccval_t  v )

inlinestatic

Definition at line 395 of file parser.h.

{
    return v.is_num ? v.u.n != 0 : v.u.b;
}

Referenced by cc_token(), skip_code(), and yyparse().

get_ccnum()

static double get_ccnum ( ccval_t  v )

inlinestatic

Definition at line 400 of file parser.h.

{
    return v.is_num ? v.u.n : v.u.b;
}

Referenced by yyparse().

is_identifier_char()

BOOL is_identifier_char

(

WCHAR

)

Definition at line 81 of file lex.c.

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

Referenced by cc_token(), check_keyword(), is_keyword(), parse_cc_identifier(), parse_decimal(), parse_hex_literal(), parse_identifier(), parse_numeric_literal(), and skip_comment().

new_boolean_literal()

literal_t* new_boolean_literal	(	parser_ctx_t *	,
		BOOL
	)

Definition at line 387 of file lex.c.

{
    literal_t *ret = parser_alloc(ctx, sizeof(literal_t));

    ret->type = LT_BOOL;
    ret->u.bval = bval;

    return ret;
}

Referenced by cc_token(), and yyparse().

parse_cc_expr()

BOOL parse_cc_expr

(

parser_ctx_t *

)

Definition at line 1841 of file cc_parser.tab.c.

{
    ctx->hres = S_OK;
    cc_parser_parse(ctx);
    return SUCCEEDED(ctx->hres);
}

Referenced by cc_token(), and skip_code().

parse_decimal()

HRESULT parse_decimal	(	const WCHAR **	,
		const WCHAR *	,
		double *
	)

Definition at line 397 of file lex.c.

{
    const WCHAR *ptr = *iter;
    LONGLONG d = 0, hlp;
    int exp = 0;

    while(ptr < end && iswdigit(*ptr)) {
        hlp = d*10 + *(ptr++) - '0';
        if(d>MAXLONGLONG/10 || hlp<0) {
            exp++;
            break;
        }
        else
            d = hlp;
    }
    while(ptr < end && iswdigit(*ptr)) {
        exp++;
        ptr++;
    }

    if(*ptr == '.') {
        ptr++;

        while(ptr < end && iswdigit(*ptr)) {
            hlp = d*10 + *(ptr++) - '0';
            if(d>MAXLONGLONG/10 || hlp<0)
                break;

            d = hlp;
            exp--;
        }
        while(ptr < end && iswdigit(*ptr))
            ptr++;
    }

    if(ptr < end && (*ptr == 'e' || *ptr == 'E')) {
        int sign = 1, e = 0;

        if(++ptr < end) {
            if(*ptr == '+') {
                ptr++;
            }else if(*ptr == '-') {
                sign = -1;
                ptr++;
            }else if(!iswdigit(*ptr)) {
                WARN("Expected exponent part\n");
                return E_FAIL;
            }
        }

        if(ptr == end) {
            WARN("unexpected end of file\n");
            return E_FAIL;
        }

        while(ptr < end && iswdigit(*ptr)) {
            if(e > INT_MAX/10 || (e = e*10 + *ptr++ - '0')<0)
                e = INT_MAX;
        }
        e *= sign;

        if(exp<0 && e<0 && e+exp>0) exp = INT_MIN;
        else if(exp>0 && e>0 && e+exp<0) exp = INT_MAX;
        else exp += e;
    }

    if(is_identifier_char(*ptr)) {
        WARN("wrong char after zero\n");
        return JS_E_MISSING_SEMICOLON;
    }

    *ret = exp>=0 ? d*pow(10, exp) : d/pow(10, -exp);
    *iter = ptr;
    return S_OK;
}

Referenced by next_token(), parse_json_value(), and parse_numeric_literal().

parse_regexp()

literal_t* parse_regexp

(

parser_ctx_t *

)

Definition at line 1115 of file lex.c.

{
    const WCHAR *re, *flags_ptr;
    BOOL in_class = FALSE;
    DWORD re_len, flags;
    literal_t *ret;
    HRESULT hres;

    TRACE("\n");

    while(*--ctx->ptr != '/');

    /* Simple regexp pre-parser; '/' if used in char class does not terminate regexp literal */
    re = ++ctx->ptr;
    while(ctx->ptr < ctx->end) {
        if(*ctx->ptr == '\\') {
            if(++ctx->ptr == ctx->end)
                break;
        }else if(in_class) {
            if(*ctx->ptr == '\n')
                break;
            if(*ctx->ptr == ']')
                in_class = FALSE;
        }else {
            if(*ctx->ptr == '/')
                break;

            if(*ctx->ptr == '[')
                in_class = TRUE;
        }
        ctx->ptr++;
    }

    if(ctx->ptr == ctx->end || *ctx->ptr != '/') {
        WARN("pre-parsing failed\n");
        return NULL;
    }

    re_len = ctx->ptr-re;

    flags_ptr = ++ctx->ptr;
    while(ctx->ptr < ctx->end && iswalnum(*ctx->ptr))
        ctx->ptr++;

    hres = parse_regexp_flags(flags_ptr, ctx->ptr-flags_ptr, &flags);
    if(FAILED(hres))
        return NULL;

    ret = parser_alloc(ctx, sizeof(literal_t));
    ret->type = LT_REGEXP;
    ret->u.regexp.str = compiler_alloc_string_len(ctx->compiler, re, re_len);
    ret->u.regexp.flags = flags;
    return ret;
}

Referenced by yyparse().

parser_alloc()

static void* parser_alloc ( parser_ctx_t *  ctx, DWORD  size  )

inlinestatic

Definition at line 58 of file parser.h.

{
    return heap_pool_alloc(&ctx->heap, size);
}

Referenced by new_boolean_literal(), new_double_literal(), parse_identifier(), parse_regexp(), and parse_string_literal().

parser_alloc_tmp()

static void* parser_alloc_tmp ( parser_ctx_t *  ctx, DWORD  size  )

inlinestatic

Definition at line 63 of file parser.h.

{
    return heap_pool_alloc(&ctx->script->tmp_heap, size);
}

Referenced by new_argument_list(), new_case_list(), new_element_list(), new_parameter_list(), new_property_list(), new_statement_list(), and new_variable_list().

parser_lex()

int parser_lex	(	void *	,
		parser_ctx_t *
	)

Definition at line 1102 of file lex.c.

{
    int ret;

    ctx->nl = ctx->ptr == ctx->begin;

    do {
        ret = next_token(ctx, lval);
    } while(ret == '@' && !(ret = cc_token(ctx, lval)));

    return ret;
}

parser_release()

void parser_release

(

parser_ctx_t *

)

Definition at line 4361 of file parser.tab.c.

{
    script_release(ctx->script);
    heap_pool_free(&ctx->heap);
    heap_free(ctx);
}

Referenced by compile_script(), and release_compiler().

script_parse()

HRESULT script_parse	(	script_ctx_t *	,
		struct _compiler_ctx_t *	,
		const WCHAR *	,
		const WCHAR *	,
		BOOL	,
		parser_ctx_t **
	)

Definition at line 4368 of file parser.tab.c.

{
    parser_ctx_t *parser_ctx;
    heap_pool_t *mark;
    HRESULT hres;

    const WCHAR html_tagW[] = {'<','/','s','c','r','i','p','t','>',0};

    parser_ctx = heap_alloc_zero(sizeof(parser_ctx_t));
    if(!parser_ctx)
        return E_OUTOFMEMORY;

    parser_ctx->hres = JS_E_SYNTAX;
    parser_ctx->is_html = delimiter && !wcsicmp(delimiter, html_tagW);

    parser_ctx->begin = parser_ctx->ptr = code;
    parser_ctx->end = parser_ctx->begin + lstrlenW(parser_ctx->begin);

    script_addref(ctx);
    parser_ctx->script = ctx;

    mark = heap_pool_mark(&ctx->tmp_heap);
    heap_pool_init(&parser_ctx->heap);

    parser_ctx->compiler = compiler;
    parser_parse(parser_ctx);
    parser_ctx->compiler = NULL;

    heap_pool_clear(mark);
    hres = parser_ctx->hres;
    if(FAILED(hres)) {
        WARN("parser failed around %s\n",
            debugstr_w(parser_ctx->begin+20 > parser_ctx->ptr ? parser_ctx->begin : parser_ctx->ptr-20));
        parser_release(parser_ctx);
        return hres;
    }

    *ret = parser_ctx;
    return S_OK;
}

Referenced by compile_script().

try_parse_ccval()

BOOL try_parse_ccval	(	parser_ctx_t *	,
		ccval_t *
	)

Definition at line 907 of file lex.c.

{
    if(!skip_spaces(ctx))
        return -1;

    if(iswdigit(*ctx->ptr)) {
        double n;

        if(!parse_numeric_literal(ctx, &n))
            return -1;

        *r = ccval_num(n);
        return 1;
    }

    if(*ctx->ptr == '@') {
        const WCHAR *ident;
        unsigned ident_len;
        cc_var_t *cc_var;

        if(!parse_cc_identifier(ctx, &ident, &ident_len))
            return -1;

        cc_var = find_cc_var(ctx->script->cc, ident, ident_len);
        *r = cc_var ? cc_var->val : ccval_num(NAN);
        return 1;
    }

    if(!check_keyword(ctx, L"true", NULL)) {
        *r = ccval_bool(TRUE);
        return 1;
    }

    if(!check_keyword(ctx, L"false", NULL)) {
        *r = ccval_bool(FALSE);
        return 1;
    }

    return 0;
}

Referenced by cc_parser_lex().

unescape()

BOOL unescape	(	WCHAR *	,
		size_t *
	)

Definition at line 227 of file lex.c.

{
    WCHAR *pd, *p, c, *end = str + *len;
    int i;

    pd = p = str;
    while(p < end) {
        if(*p != '\\') {
            *pd++ = *p++;
            continue;
        }

        if(++p == end)
            return FALSE;

        switch(*p) {
        case '\'':
        case '\"':
        case '\\':
            c = *p;
            break;
        case 'b':
            c = '\b';
            break;
        case 't':
            c = '\t';
            break;
        case 'n':
            c = '\n';
            break;
        case 'f':
            c = '\f';
            break;
        case 'r':
            c = '\r';
            break;
        case 'x':
            if(p + 2 >= end)
                return FALSE;
            i = hex_to_int(*++p);
            if(i == -1)
                return FALSE;
            c = i << 4;

            i = hex_to_int(*++p);
            if(i == -1)
                return FALSE;
            c += i;
            break;
        case 'u':
            if(p + 4 >= end)
                return FALSE;
            i = hex_to_int(*++p);
            if(i == -1)
                return FALSE;
            c = i << 12;

            i = hex_to_int(*++p);
            if(i == -1)
                return FALSE;
            c += i << 8;

            i = hex_to_int(*++p);
            if(i == -1)
                return FALSE;
            c += i << 4;

            i = hex_to_int(*++p);
            if(i == -1)
                return FALSE;
            c += i;
            break;
        default:
            if(iswdigit(*p)) {
                c = *p++ - '0';
                if(p < end && iswdigit(*p)) {
                    c = c*8 + (*p++ - '0');
                    if(p < end && iswdigit(*p))
                        c = c*8 + (*p++ - '0');
                }
                p--;
            }
            else
                c = *p;
        }

        *pd++ = c;
        p++;
    }

    *len = pd - str;
    return TRUE;
}

Referenced by parse_json_string(), parse_string_literal(), and PathCreateFromUrlW().