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(), and try_parse_ccval().

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(), and try_parse_ccval().

compiler_alloc_string_len()

jsstr_t * compiler_alloc_string_len	(	struct _compiler_ctx_t *	ctx,
		const WCHAR *	str,
		unsigned	len
	)

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(), and parse_string_literal().

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(), and skip_code().

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;
}

is_identifier_char()

BOOL is_identifier_char

(

WCHAR

c

)

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 *	ctx,
		BOOL	bval
	)

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().

parse_cc_expr()

BOOL parse_cc_expr

(

parser_ctx_t *

)

Referenced by cc_token(), and skip_code().

parse_decimal()

HRESULT parse_decimal	(	const WCHAR **	iter,
		const WCHAR *	end,
		double *	ret
	)

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 *

ctx

)

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;
}

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);
}

parser_lex()

int parser_lex	(	void *	lval,
		parser_ctx_t *	ctx
	)

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 *

)

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 **
	)

Referenced by compile_script().

try_parse_ccval()

BOOL try_parse_ccval	(	parser_ctx_t *	ctx,
		ccval_t *	r
	)

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;
}

unescape()

BOOL unescape	(	WCHAR *	str,
		size_t *	len
	)

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().