WCHAR *msi_font_version_from_file( const WCHAR *filename ) { static const WCHAR fmtW[] = {'%','u','.','%','u','.','0','.','0',0}; WCHAR *version, *p, *q, *ret = NULL; if ((version = load_ttf_name_id( filename, NAME_ID_VERSION ))) { int len, major = 0, minor = 0; if ((p = strchrW( version, ';' ))) *p = 0; p = version; while (*p && !isdigitW( *p )) p++; if ((q = strchrW( p, '.' ))) { major = atoiW( p ); p = ++q; while (*q && isdigitW( *q )) q++; if (!*q || *q == ' ') minor = atoiW( p ); else major = 0; } len = strlenW( fmtW ) + 20; ret = msi_alloc( len * sizeof(WCHAR) ); sprintfW( ret, fmtW, major, minor ); msi_free( version ); } return ret; }
static int parse_numeric_literal(parser_ctx_t *ctx, literal_t **literal) { LONG l, d; l = *ctx->ptr++ - '0'; if(!l) { if(*ctx->ptr == 'x' || *ctx->ptr == 'X') { if(++ctx->ptr == ctx->end) { ERR("unexpected end of file\n"); return 0; } while(ctx->ptr < ctx->end && (d = hex_to_int(*ctx->ptr)) != -1) { l = l*16 + d; ctx->ptr++; } if(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)) { WARN("unexpected identifier char\n"); return lex_error(ctx, JS_E_MISSING_SEMICOLON); } *literal = new_double_literal(ctx, l); return tNumericLiteral; } if(isdigitW(*ctx->ptr)) { unsigned base = 8; const WCHAR *ptr; double val = 0; for(ptr = ctx->ptr; ptr < ctx->end && isdigitW(*ptr); ptr++) { if(*ptr > '7') { base = 10; break; } } do { val = val*base + *ctx->ptr-'0'; }while(++ctx->ptr < ctx->end && isdigitW(*ctx->ptr)); /* FIXME: Do we need it here? */ if(ctx->ptr < ctx->end && (is_identifier_char(*ctx->ptr) || *ctx->ptr == '.')) { WARN("wrong char after octal literal: '%c'\n", *ctx->ptr); return lex_error(ctx, JS_E_MISSING_SEMICOLON); } *literal = new_double_literal(ctx, val); return tNumericLiteral; } if(is_identifier_char(*ctx->ptr)) { WARN("wrong char after zero\n"); return lex_error(ctx, JS_E_MISSING_SEMICOLON); } } return parse_double_literal(ctx, l, literal); }
static HRESULT HTMLElementCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid) { HTMLElementCollection *This = impl_from_DispatchEx(dispex); WCHAR *ptr; DWORD idx=0; if(!*name) return DISP_E_UNKNOWNNAME; for(ptr = name; *ptr && isdigitW(*ptr); ptr++) idx = idx*10 + (*ptr-'0'); if(*ptr) { /* the name contains alpha characters, so search by name & id */ for(idx = 0; idx < This->len; ++idx) { if(is_elem_id(This->elems[idx], name) || is_elem_name(This->elems[idx], name)) break; } } if(idx >= This->len) return DISP_E_UNKNOWNNAME; *dispid = DISPID_ELEMCOL_0 + idx; TRACE("ret %x\n", *dispid); return S_OK; }
static HRESULT nsstr_to_truncated_bstr(const nsAString *nsstr, BSTR *ret_ptr) { const PRUnichar *str, *ptr, *end = NULL; BSTR ret; nsAString_GetData(nsstr, &str); for(ptr = str; isdigitW(*ptr); ptr++); if(*ptr == '.') { for(end = ptr++; isdigitW(*ptr); ptr++); if(*ptr) end = NULL; } ret = end ? SysAllocStringLen(str, end-str) : SysAllocString(str); *ret_ptr = ret; return ret ? S_OK : E_OUTOFMEMORY; }
static void Array_on_put(jsdisp_t *dispex, const WCHAR *name) { ArrayInstance *array = (ArrayInstance*)dispex; const WCHAR *ptr = name; DWORD id = 0; if(!isdigitW(*ptr)) return; while(*ptr && isdigitW(*ptr)) { id = id*10 + (*ptr-'0'); ptr++; } if(*ptr) return; if(id >= array->length) array->length = id+1; }
WCHAR *font_version_from_file( const WCHAR *filename ) { WCHAR *version, *p, *ret = NULL; if ((p = version = load_ttf_name_id( filename, NAME_ID_VERSION ))) { while (*p && !isdigitW( *p )) p++; ret = msi_alloc( (strlenW( p ) + 1) * sizeof(WCHAR) ); strcpyW( ret, p ); msi_free( version ); } return ret; }
int vsnprintfW(WCHAR *str, size_t len, const WCHAR *format, va_list valist) { unsigned int written = 0; const WCHAR *iter = format; char bufa[256], fmtbufa[64], *fmta; while (*iter) { while (*iter && *iter != '%') { if (written++ >= len) return -1; *str++ = *iter++; } if (*iter == '%') { if (iter[1] == '%') { if (written++ >= len) return -1; *str++ = '%'; /* "%%"->'%' */ iter += 2; continue; } fmta = fmtbufa; *fmta++ = *iter++; while (*iter == '0' || *iter == '+' || *iter == '-' || *iter == ' ' || *iter == '*' || *iter == '#') { if (*iter == '*') { char *buffiter = bufa; int fieldlen = va_arg(valist, int); sprintf(buffiter, "%d", fieldlen); while (*buffiter) *fmta++ = *buffiter++; } else *fmta++ = *iter; iter++; } while (isdigitW(*iter)) *fmta++ = *iter++; if (*iter == '.') { *fmta++ = *iter++; if (*iter == '*') { char *buffiter = bufa; int fieldlen = va_arg(valist, int); sprintf(buffiter, "%d", fieldlen); while (*buffiter) *fmta++ = *buffiter++; }
static HRESULT domselection_get_dispid(IUnknown *iface, BSTR name, DWORD flags, DISPID *dispid) { WCHAR *ptr; int idx = 0; for(ptr = name; *ptr && isdigitW(*ptr); ptr++) idx = idx*10 + (*ptr-'0'); if(*ptr) return DISP_E_UNKNOWNNAME; *dispid = DISPID_DOM_COLLECTION_BASE + idx; TRACE("ret %x\n", *dispid); return S_OK; }
static HRESULT queryresult_get_dispid(IUnknown *iface, BSTR name, DWORD flags, DISPID *dispid) { queryresult *This = impl_from_IXMLDOMNodeList( (IXMLDOMNodeList*)iface ); WCHAR *ptr; int idx = 0; for(ptr = name; *ptr && isdigitW(*ptr); ptr++) idx = idx*10 + (*ptr-'0'); if(*ptr) return DISP_E_UNKNOWNNAME; if(idx >= xmlXPathNodeSetGetLength(This->result->nodesetval)) return DISP_E_UNKNOWNNAME; *dispid = MSXML_DISPID_CUSTOM_MIN + idx; TRACE("ret %x\n", *dispid); return S_OK; }
static HRESULT HTMLSelectElement_get_dispid(HTMLDOMNode *iface, BSTR name, DWORD flags, DISPID *dispid) { const WCHAR *ptr; DWORD idx = 0; for(ptr = name; *ptr && isdigitW(*ptr); ptr++) { idx = idx*10 + (*ptr-'0'); if(idx > MSHTML_CUSTOM_DISPID_CNT) { WARN("too big idx\n"); return DISP_E_UNKNOWNNAME; } } if(*ptr) return DISP_E_UNKNOWNNAME; *dispid = DISPID_OPTIONCOL_0 + idx; return S_OK; }
static HRESULT HTMLDOMChildrenCollection_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid) { HTMLDOMChildrenCollection *This = impl_from_DispatchEx(dispex); WCHAR *ptr; DWORD idx=0; PRUint32 len = 0; for(ptr = name; *ptr && isdigitW(*ptr); ptr++) idx = idx*10 + (*ptr-'0'); if(*ptr) return DISP_E_UNKNOWNNAME; nsIDOMNodeList_GetLength(This->nslist, &len); if(idx >= len) return DISP_E_UNKNOWNNAME; *dispid = DISPID_CHILDCOL_0 + idx; TRACE("ret %x\n", *dispid); return S_OK; }
int try_parse_ccval(parser_ctx_t *ctx, ccval_t *r) { if(!skip_spaces(ctx)) return -1; if(isdigitW(*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, trueW, NULL)) { *r = ccval_bool(TRUE); return 1; } if(!check_keyword(ctx, falseW, NULL)) { *r = ccval_bool(FALSE); return 1; } return 0; }
static int comp_value(const WCHAR *ptr, int dpc) { int ret = 0; WCHAR ch; if(dpc > 2) dpc = 2; while(dpc--) { if(!*ptr) ret *= 16; else if(isdigitW(ch = *ptr++)) ret = ret*16 + (ch-'0'); else if('a' <= ch && ch <= 'f') ret = ret*16 + (ch-'a') + 10; else if('A' <= ch && ch <= 'F') ret = ret*16 + (ch-'A') + 10; else ret *= 16; } return ret; }
/************************************************************************** * WsEncodeUrl [webservices.@] */ HRESULT WINAPI WsEncodeUrl( const WS_URL *base, ULONG flags, WS_HEAP *heap, WS_STRING *ret, WS_ERROR *error ) { static const WCHAR fmtW[] = {':','%','u',0}; ULONG len = 0, len_scheme, len_enc, ret_size; const WS_HTTP_URL *url = (const WS_HTTP_URL *)base; const WCHAR *scheme; WCHAR *str, *p, *q; ULONG port = 0; HRESULT hr; TRACE( "%p %08x %p %p %p\n", base, flags, heap, ret, error ); if (error) FIXME( "ignoring error parameter\n" ); if (!url || !heap || !ret) return E_INVALIDARG; if (flags) { FIXME( "unimplemented flags %08x\n", flags ); return E_NOTIMPL; } if (!(scheme = scheme_str( url->url.scheme, &len_scheme ))) return WS_E_INVALID_FORMAT; len = len_scheme + 3; /* '://' */ len += 6; /* ':65535' */ if ((hr = url_encode_size( url->host.chars, url->host.length, "", &len_enc )) != S_OK) return hr; len += len_enc; if ((hr = url_encode_size( url->path.chars, url->path.length, "/", &len_enc )) != S_OK) return hr; len += len_enc; if ((hr = url_encode_size( url->query.chars, url->query.length, "/?", &len_enc )) != S_OK) return hr; len += len_enc + 1; /* '?' */ if ((hr = url_encode_size( url->fragment.chars, url->fragment.length, "/?", &len_enc )) != S_OK) return hr; len += len_enc + 1; /* '#' */ ret_size = len * sizeof(WCHAR); if (!(str = ws_alloc( heap, ret_size ))) return WS_E_QUOTA_EXCEEDED; memcpy( str, scheme, len_scheme * sizeof(WCHAR) ); p = str + len_scheme; p[0] = ':'; p[1] = p[2] = '/'; p += 3; if ((hr = url_encode( url->host.chars, url->host.length, p, "", &len_enc )) != S_OK) goto error; p += len_enc; if (url->portAsString.length) { q = url->portAsString.chars; len = url->portAsString.length; while (len && isdigitW( *q )) { if ((port = port * 10 + *q - '0') > 65535) { hr = WS_E_INVALID_FORMAT; goto error; } q++; len--; } if (url->port && port != url->port) { hr = E_INVALIDARG; goto error; } } else port = url->port; if (port == default_port( url->url.scheme )) port = 0; if (port) { WCHAR buf[7]; len = sprintfW( buf, fmtW, port ); memcpy( p, buf, len * sizeof(WCHAR) ); p += len; } if ((hr = url_encode( url->path.chars, url->path.length, p, "/", &len_enc )) != S_OK) goto error; p += len_enc; if (url->query.length) { *p++ = '?'; if ((hr = url_encode( url->query.chars, url->query.length, p, "/?", &len_enc )) != S_OK) goto error; p += len_enc; } if (url->fragment.length) { *p++ = '#'; if ((hr = url_encode( url->fragment.chars, url->fragment.length, p, "/?", &len_enc )) != S_OK) goto error; p += len_enc; } ret->length = p - str; ret->chars = str; return S_OK; error: ws_free( heap, str, ret_size ); return hr; }
/************************************************************************** * WsDecodeUrl [webservices.@] */ HRESULT WINAPI WsDecodeUrl( const WS_STRING *str, ULONG flags, WS_HEAP *heap, WS_URL **ret, WS_ERROR *error ) { HRESULT hr = WS_E_QUOTA_EXCEEDED; WCHAR *p, *q, *decoded = NULL; WS_HTTP_URL *url = NULL; ULONG len, len_decoded, port = 0; TRACE( "%s %08x %p %p %p\n", str ? debugstr_wn(str->chars, str->length) : "null", flags, heap, ret, error ); if (error) FIXME( "ignoring error parameter\n" ); if (!str || !heap) return E_INVALIDARG; if (!str->length) return WS_E_INVALID_FORMAT; if (flags) { FIXME( "unimplemented flags %08x\n", flags ); return E_NOTIMPL; } if (!(decoded = url_decode( str->chars, str->length, heap, &len_decoded )) || !(url = ws_alloc( heap, sizeof(*url) ))) goto error; hr = WS_E_INVALID_FORMAT; p = q = decoded; len = len_decoded; while (len && *q != ':') { q++; len--; }; if (*q != ':') goto error; if ((url->url.scheme = scheme_type( p, q - p )) == ~0u) goto error; if (!--len || *++q != '/') goto error; if (!--len || *++q != '/') goto error; p = ++q; len--; while (len && *q != '/' && *q != ':' && *q != '?' && *q != '#') { q++; len--; }; if (q == p) goto error; url->host.length = q - p; url->host.chars = p; if (len && *q == ':') { p = ++q; len--; while (len && isdigitW( *q )) { if ((port = port * 10 + *q - '0') > 65535) goto error; q++; len--; }; url->port = port; url->portAsString.length = q - p; url->portAsString.chars = p; } if (!port) { url->port = default_port( url->url.scheme ); url->portAsString.length = 0; url->portAsString.chars = NULL; } if (len && *q == '/') { p = q; while (len && *q != '?') { q++; len--; }; url->path.length = q - p; url->path.chars = p; } else url->path.length = 0; if (len && *q == '?') { p = ++q; len--; while (len && *q != '#') { q++; len--; }; url->query.length = q - p; url->query.chars = p; } else url->query.length = 0; if (len && *q == '#') { p = ++q; len--; while (len && *q != '#') { q++; len--; }; url->fragment.length = q - p; url->fragment.chars = p; } else url->fragment.length = 0; *ret = (WS_URL *)url; return S_OK; error: if (decoded != str->chars) ws_free( heap, decoded, len_decoded ); ws_free( heap, url, sizeof(*url) ); return hr; }
/* ECMA-262 5.1 Edition 15.12.1.2 */ static HRESULT parse_json_value(json_parse_ctx_t *ctx, jsval_t *r) { HRESULT hres; switch(skip_spaces(ctx)) { /* JSONNullLiteral */ case 'n': if(!is_keyword(ctx, nullW)) break; *r = jsval_null(); return S_OK; /* JSONBooleanLiteral */ case 't': if(!is_keyword(ctx, trueW)) break; *r = jsval_bool(TRUE); return S_OK; case 'f': if(!is_keyword(ctx, falseW)) break; *r = jsval_bool(FALSE); return S_OK; /* JSONObject */ case '{': { WCHAR *prop_name; jsdisp_t *obj; jsval_t val; hres = create_object(ctx->ctx, NULL, &obj); if(FAILED(hres)) return hres; ctx->ptr++; if(skip_spaces(ctx) == '}') { ctx->ptr++; *r = jsval_obj(obj); return S_OK; } while(1) { if(*ctx->ptr != '"') break; hres = parse_json_string(ctx, &prop_name); if(FAILED(hres)) break; if(skip_spaces(ctx) != ':') { FIXME("missing ':'\n"); heap_free(prop_name); break; } ctx->ptr++; hres = parse_json_value(ctx, &val); if(SUCCEEDED(hres)) { hres = jsdisp_propput_name(obj, prop_name, val); jsval_release(val); } heap_free(prop_name); if(FAILED(hres)) break; if(skip_spaces(ctx) == '}') { ctx->ptr++; *r = jsval_obj(obj); return S_OK; } if(*ctx->ptr++ != ',') { FIXME("expected ','\n"); break; } skip_spaces(ctx); } jsdisp_release(obj); break; } /* JSONString */ case '"': { WCHAR *string; jsstr_t *str; hres = parse_json_string(ctx, &string); if(FAILED(hres)) return hres; /* FIXME: avoid reallocation */ str = jsstr_alloc(string); heap_free(string); if(!str) return E_OUTOFMEMORY; *r = jsval_string(str); return S_OK; } /* JSONArray */ case '[': { jsdisp_t *array; unsigned i = 0; jsval_t val; hres = create_array(ctx->ctx, 0, &array); if(FAILED(hres)) return hres; ctx->ptr++; if(skip_spaces(ctx) == ']') { ctx->ptr++; *r = jsval_obj(array); return S_OK; } while(1) { hres = parse_json_value(ctx, &val); if(FAILED(hres)) break; hres = jsdisp_propput_idx(array, i, val); jsval_release(val); if(FAILED(hres)) break; if(skip_spaces(ctx) == ']') { ctx->ptr++; *r = jsval_obj(array); return S_OK; } if(*ctx->ptr != ',') { FIXME("expected ','\n"); break; } ctx->ptr++; i++; } jsdisp_release(array); break; } /* JSONNumber */ default: { int sign = 1; double n; if(*ctx->ptr == '-') { sign = -1; ctx->ptr++; skip_spaces(ctx); } if(!isdigitW(*ctx->ptr)) break; if(*ctx->ptr == '0') { ctx->ptr++; n = 0; if(is_identifier_char(*ctx->ptr)) break; }else { hres = parse_decimal(&ctx->ptr, ctx->end, &n); if(FAILED(hres)) return hres; } *r = jsval_number(sign*n); return S_OK; } } FIXME("Syntax error at %s\n", debugstr_w(ctx->ptr)); return E_FAIL; }
/********************************************************************* * iswdigit (NTDLL.@) * * Checks if a unicode char wc is a digit * * RETURNS * TRUE: The unicode char wc is a digit. * FALSE: Otherwise */ INT __cdecl NTDLL_iswdigit( WCHAR wc ) { return isdigitW(wc); }
/* The implemented task enumeration and termination behavior does not * exactly match native behavior. On Windows: * * In the case of terminating by process name, specifying a particular * process name more times than the number of running instances causes * all instances to be terminated, but termination failure messages to * be printed as many times as the difference between the specification * quantity and the number of running instances. * * Successful terminations are all listed first in order, with failing * terminations being listed at the end. * * A PID of zero causes taskkill to warn about the inability to terminate * system processes. */ static int send_close_messages(void) { DWORD *pid_list, pid_list_size; DWORD self_pid = GetCurrentProcessId(); unsigned int i; int status_code = 0; pid_list = enumerate_processes(&pid_list_size); if (!pid_list) { taskkill_message(STRING_ENUM_FAILED); return 1; } for (i = 0; i < task_count; i++) { WCHAR *p = task_list[i]; BOOL is_numeric = TRUE; /* Determine whether the string is not numeric. */ while (*p) { if (!isdigitW(*p++)) { is_numeric = FALSE; break; } } if (is_numeric) { DWORD pid = atoiW(task_list[i]); struct pid_close_info info = { pid }; if (pid == self_pid) { taskkill_message(STRING_SELF_TERMINATION); status_code = 1; continue; } EnumWindows(pid_enum_proc, (LPARAM)&info); if (info.found) taskkill_message_printfW(STRING_CLOSE_PID_SEARCH, pid); else { taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]); status_code = 128; } } else { DWORD index; BOOL found_process = FALSE; for (index = 0; index < pid_list_size; index++) { WCHAR process_name[MAX_PATH]; if (get_process_name_from_pid(pid_list[index], process_name, MAX_PATH) && !strcmpiW(process_name, task_list[i])) { struct pid_close_info info = { pid_list[index] }; found_process = TRUE; if (pid_list[index] == self_pid) { taskkill_message(STRING_SELF_TERMINATION); status_code = 1; continue; } EnumWindows(pid_enum_proc, (LPARAM)&info); taskkill_message_printfW(STRING_CLOSE_PROC_SRCH, process_name, pid_list[index]); } } if (!found_process) { taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]); status_code = 128; } } } HeapFree(GetProcessHeap(), 0, pid_list); return status_code; }
static int parse_numeric_literal(parser_ctx_t *ctx, literal_t **literal) { LONG l, d; l = *ctx->ptr++ - '0'; if(ctx->ptr == ctx->end) { *literal = new_int_literal(ctx, l); return tNumericLiteral; } if(!l) { if(*ctx->ptr == 'x' || *ctx->ptr == 'X') { if(++ctx->ptr == ctx->end) { ERR("unexpexted end of file\n"); return 0; } while(ctx->ptr < ctx->end && (d = hex_to_int(*ctx->ptr)) != -1) { l = l*16 + d; ctx->ptr++; } if(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)) { WARN("unexpected identifier char\n"); return lex_error(ctx, E_FAIL); } *literal = new_int_literal(ctx, l); return tNumericLiteral; } if(isdigitW(*ctx->ptr) || is_identifier_char(*ctx->ptr)) { WARN("wrong char after zero\n"); return lex_error(ctx, E_FAIL); } *literal = new_int_literal(ctx, 0); } while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { d = l*10 + *(ctx->ptr)-'0'; /* Check for integer overflow */ if (l > INT_MAX/10 || d < 0) return parse_double_literal(ctx, l, literal); l = d; ctx->ptr++; } if(ctx->ptr < ctx->end) { if(*ctx->ptr == '.' || *ctx->ptr == 'e' || *ctx->ptr == 'E') return parse_double_literal(ctx, l, literal); if(is_identifier_char(*ctx->ptr)) { WARN("unexpected identifier char\n"); return lex_error(ctx, E_FAIL); } } *literal = new_int_literal(ctx, l); return tNumericLiteral; }
BOOL unescape(WCHAR *str, size_t *len) { 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(isdigitW(*p)) { c = *p++ - '0'; if(p < end && isdigitW(*p)) { c = c*8 + (*p++ - '0'); if(p < end && isdigitW(*p)) c = c*8 + (*p++ - '0'); } p--; } else c = *p; } *pd++ = c; p++; } *len = pd - str; return TRUE; }
HRESULT parse_decimal(const WCHAR **iter, const WCHAR *end, double *ret) { const WCHAR *ptr = *iter; LONGLONG d = 0, hlp; int exp = 0; while(ptr < end && isdigitW(*ptr)) { hlp = d*10 + *(ptr++) - '0'; if(d>MAXLONGLONG/10 || hlp<0) { exp++; break; } else d = hlp; } while(ptr < end && isdigitW(*ptr)) { exp++; ptr++; } if(*ptr == '.') { ptr++; while(ptr < end && isdigitW(*ptr)) { hlp = d*10 + *(ptr++) - '0'; if(d>MAXLONGLONG/10 || hlp<0) break; d = hlp; exp--; } while(ptr < end && isdigitW(*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(!isdigitW(*ptr)) { WARN("Expected exponent part\n"); return E_FAIL; } } if(ptr == end) { WARN("unexpected end of file\n"); return E_FAIL; } while(ptr < end && isdigitW(*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; }
static BOOL parse_numeric_literal(parser_ctx_t *ctx, double *ret) { HRESULT hres; if(*ctx->ptr == '0') { ctx->ptr++; if(*ctx->ptr == 'x' || *ctx->ptr == 'X') { double r = 0; int d; if(++ctx->ptr == ctx->end) { ERR("unexpected end of file\n"); return FALSE; } while(ctx->ptr < ctx->end && (d = hex_to_int(*ctx->ptr)) != -1) { r = r*16 + d; ctx->ptr++; } if(ctx->ptr < ctx->end && is_identifier_char(*ctx->ptr)) { WARN("unexpected identifier char\n"); lex_error(ctx, JS_E_MISSING_SEMICOLON); return FALSE; } *ret = r; return TRUE; } if(isdigitW(*ctx->ptr)) { unsigned base = 8; const WCHAR *ptr; double val = 0; for(ptr = ctx->ptr; ptr < ctx->end && isdigitW(*ptr); ptr++) { if(*ptr > '7') { base = 10; break; } } do { val = val*base + *ctx->ptr-'0'; }while(++ctx->ptr < ctx->end && isdigitW(*ctx->ptr)); /* FIXME: Do we need it here? */ if(ctx->ptr < ctx->end && (is_identifier_char(*ctx->ptr) || *ctx->ptr == '.')) { WARN("wrong char after octal literal: '%c'\n", *ctx->ptr); lex_error(ctx, JS_E_MISSING_SEMICOLON); return FALSE; } *ret = val; return TRUE; } if(is_identifier_char(*ctx->ptr)) { WARN("wrong char after zero\n"); lex_error(ctx, JS_E_MISSING_SEMICOLON); return FALSE; } } hres = parse_decimal(&ctx->ptr, ctx->end, ret); if(FAILED(hres)) { lex_error(ctx, hres); return FALSE; } return TRUE; }
static BOOL parse_double_literal(parser_ctx_t *ctx, LONG int_part, double *ret) { LONGLONG d, hlp; int exp = 0; d = int_part; while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { hlp = d*10 + *(ctx->ptr++) - '0'; if(d>MAXLONGLONG/10 || hlp<0) { exp++; break; } else d = hlp; } while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { exp++; ctx->ptr++; } if(*ctx->ptr == '.') { ctx->ptr++; while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { hlp = d*10 + *(ctx->ptr++) - '0'; if(d>MAXLONGLONG/10 || hlp<0) break; d = hlp; exp--; } while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) ctx->ptr++; } if(ctx->ptr < ctx->end && (*ctx->ptr == 'e' || *ctx->ptr == 'E')) { int sign = 1, e = 0; ctx->ptr++; if(ctx->ptr < ctx->end) { if(*ctx->ptr == '+') { ctx->ptr++; }else if(*ctx->ptr == '-') { sign = -1; ctx->ptr++; }else if(!isdigitW(*ctx->ptr)) { WARN("Expected exponent part\n"); lex_error(ctx, E_FAIL); return FALSE; } } if(ctx->ptr == ctx->end) { WARN("unexpected end of file\n"); lex_error(ctx, E_FAIL); return FALSE; } while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { if(e > INT_MAX/10 || (e = e*10 + *ctx->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(*ctx->ptr)) { WARN("wrong char after zero\n"); lex_error(ctx, JS_E_MISSING_SEMICOLON); return FALSE; } *ret = exp>=0 ? d*pow(10, exp) : d/pow(10, -exp); return TRUE; }
static BOOL unescape(WCHAR *str) { WCHAR *pd, *p, c; int i; pd = p = str; while(*p) { if(*p != '\\') { *pd++ = *p++; continue; } p++; c = 0; 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': 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': 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(isdigitW(*p)) { c = *p++ - '0'; if(isdigitW(*p)) { c = c*8 + (*p++ - '0'); if(isdigitW(*p)) c = c*8 + (*p++ - '0'); } p--; } else c = *p; } *pd++ = c; p++; } *pd = 0; return TRUE; }
static int parse_double_literal(parser_ctx_t *ctx, LONG int_part, literal_t **literal) { LONGLONG d, hlp; int exp = 0; if(ctx->ptr == ctx->end || (!isdigitW(*ctx->ptr) && *ctx->ptr!='.' && *ctx->ptr!='e' && *ctx->ptr!='E')) { ERR("Illegal character\n"); return 0; } d = int_part; while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { hlp = d*10 + *(ctx->ptr++) - '0'; if(d>LONGLONG_MAX/10 || hlp<0) { exp++; break; } else d = hlp; } while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { exp++; ctx->ptr++; } if(*ctx->ptr == '.') ctx->ptr++; while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { hlp = d*10 + *(ctx->ptr++) - '0'; if(d>LONGLONG_MAX/10 || hlp<0) break; d = hlp; exp--; } while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) ctx->ptr++; if(ctx->ptr < ctx->end && (*ctx->ptr == 'e' || *ctx->ptr == 'E')) { int sign = 1, e = 0; ctx->ptr++; if(ctx->ptr < ctx->end) { if(*ctx->ptr == '+') { ctx->ptr++; }else if(*ctx->ptr == '-') { sign = -1; ctx->ptr++; }else if(!isdigitW(*ctx->ptr)) { WARN("Expected exponent part\n"); return lex_error(ctx, E_FAIL); } } if(ctx->ptr == ctx->end) { WARN("unexpected end of file\n"); return lex_error(ctx, E_FAIL); } while(ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) { if(e > INT_MAX/10 || (e = e*10 + *ctx->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; } *literal = new_double_literal(ctx, (DOUBLE)d*pow(10, exp)); return tNumericLiteral; }
/********************************************************************* * _wcstod_l - not exported in native msvcrt */ double CDECL MSVCRT__wcstod_l(const MSVCRT_wchar_t* str, MSVCRT_wchar_t** end, MSVCRT__locale_t locale) { MSVCRT_pthreadlocinfo locinfo; unsigned __int64 d=0, hlp; unsigned fpcontrol; int exp=0, sign=1; const MSVCRT_wchar_t *p; double ret; BOOL found_digit = FALSE; if (!MSVCRT_CHECK_PMT(str != NULL)) return 0; if(!locale) locinfo = get_locinfo(); else locinfo = locale->locinfo; p = str; while(isspaceW(*p)) p++; if(*p == '-') { sign = -1; p++; } else if(*p == '+') p++; while(isdigitW(*p)) { found_digit = TRUE; hlp = d*10+*(p++)-'0'; if(d>MSVCRT_UI64_MAX/10 || hlp<d) { exp++; break; } else d = hlp; } while(isdigitW(*p)) { exp++; p++; } if(*p == *locinfo->lconv->decimal_point) p++; while(isdigitW(*p)) { found_digit = TRUE; hlp = d*10+*(p++)-'0'; if(d>MSVCRT_UI64_MAX/10 || hlp<d) break; d = hlp; exp--; } while(isdigitW(*p)) p++; if(!found_digit) { if(end) *end = (MSVCRT_wchar_t*)str; return 0.0; } if(*p=='e' || *p=='E' || *p=='d' || *p=='D') { int e=0, s=1; p++; if(*p == '-') { s = -1; p++; } else if(*p == '+') p++; if(isdigitW(*p)) { while(isdigitW(*p)) { if(e>INT_MAX/10 || (e=e*10+*p-'0')<0) e = INT_MAX; p++; } e *= s; if(exp<0 && e<0 && exp+e>=0) exp = INT_MIN; else if(exp>0 && e>0 && exp+e<0) exp = INT_MAX; else exp += e; } else { if(*p=='-' || *p=='+') p--; p--; } } fpcontrol = _control87(0, 0); _control87(MSVCRT__EM_DENORMAL|MSVCRT__EM_INVALID|MSVCRT__EM_ZERODIVIDE |MSVCRT__EM_OVERFLOW|MSVCRT__EM_UNDERFLOW|MSVCRT__EM_INEXACT, 0xffffffff); if(exp>0) ret = (double)sign*d*pow(10, exp); else ret = (double)sign*d/pow(10, -exp); _control87(fpcontrol, 0xffffffff); if((d && ret==0.0) || isinf(ret)) *MSVCRT__errno() = MSVCRT_ERANGE; if(end) *end = (MSVCRT_wchar_t*)p; return ret; }
static int next_token(parser_ctx_t *ctx, void *lval) { do { skip_spaces(ctx); if(ctx->ptr == ctx->end) return tEOF; }while(skip_comment(ctx) || skip_html_comment(ctx)); if(isalphaW(*ctx->ptr)) { int ret = check_keywords(ctx, lval); if(ret) return ret; return parse_identifier(ctx, lval); } if(isdigitW(*ctx->ptr)) return parse_numeric_literal(ctx, lval); switch(*ctx->ptr) { case '{': case '(': case ')': case '[': case ']': case ';': case ',': case '~': case '?': case ':': return *ctx->ptr++; case '}': *(const WCHAR**)lval = ctx->ptr++; return '}'; case '.': if(++ctx->ptr < ctx->end && isdigitW(*ctx->ptr)) return parse_double_literal(ctx, 0, lval); return '.'; case '<': if(++ctx->ptr == ctx->end) { *(int*)lval = EXPR_LESS; return tRelOper; } switch(*ctx->ptr) { case '=': /* <= */ ctx->ptr++; *(int*)lval = EXPR_LESSEQ; return tRelOper; case '<': /* << */ if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* <<= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNLSHIFT; return tAssignOper; } *(int*)lval = EXPR_LSHIFT; return tShiftOper; default: /* < */ *(int*)lval = EXPR_LESS; return tRelOper; } case '>': if(++ctx->ptr == ctx->end) { /* > */ *(int*)lval = EXPR_GREATER; return tRelOper; } switch(*ctx->ptr) { case '=': /* >= */ ctx->ptr++; *(int*)lval = EXPR_GREATEREQ; return tRelOper; case '>': /* >> */ if(++ctx->ptr < ctx->end) { if(*ctx->ptr == '=') { /* >>= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNRSHIFT; return tAssignOper; } if(*ctx->ptr == '>') { /* >>> */ if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* >>>= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNRRSHIFT; return tAssignOper; } *(int*)lval = EXPR_RRSHIFT; return tRelOper; } } *(int*)lval = EXPR_RSHIFT; return tShiftOper; default: *(int*)lval = EXPR_GREATER; return tRelOper; } case '+': ctx->ptr++; if(ctx->ptr < ctx->end) { switch(*ctx->ptr) { case '+': /* ++ */ ctx->ptr++; return tINC; case '=': /* += */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNADD; return tAssignOper; } } return '+'; case '-': ctx->ptr++; if(ctx->ptr < ctx->end) { switch(*ctx->ptr) { case '-': /* -- or --> */ ctx->ptr++; if(ctx->is_html && ctx->nl && ctx->ptr < ctx->end && *ctx->ptr == '>') { ctx->ptr++; return tHTMLCOMMENT; } return tDEC; case '=': /* -= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNSUB; return tAssignOper; } } return '-'; case '*': if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* *= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNMUL; return tAssignOper; } return '*'; case '%': if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* %= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNMOD; return tAssignOper; } return '%'; case '&': if(++ctx->ptr < ctx->end) { switch(*ctx->ptr) { case '=': /* &= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNAND; return tAssignOper; case '&': /* && */ ctx->ptr++; return tANDAND; } } return '&'; case '|': if(++ctx->ptr < ctx->end) { switch(*ctx->ptr) { case '=': /* |= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNOR; return tAssignOper; case '|': /* || */ ctx->ptr++; return tOROR; } } return '|'; case '^': if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* ^= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNXOR; return tAssignOper; } return '^'; case '!': if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* != */ if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* !== */ ctx->ptr++; *(int*)lval = EXPR_NOTEQEQ; return tEqOper; } *(int*)lval = EXPR_NOTEQ; return tEqOper; } return '!'; case '=': if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* == */ if(++ctx->ptr < ctx->end && *ctx->ptr == '=') { /* === */ ctx->ptr++; *(int*)lval = EXPR_EQEQ; return tEqOper; } *(int*)lval = EXPR_EQ; return tEqOper; } return '='; case '/': if(++ctx->ptr < ctx->end) { if(*ctx->ptr == '=') { /* /= */ ctx->ptr++; *(int*)lval = EXPR_ASSIGNDIV; return kDIVEQ; } } return '/'; case '\"': case '\'': return parse_string_literal(ctx, lval, *ctx->ptr); case '_': case '$': return parse_identifier(ctx, lval); case '@': return '@'; } WARN("unexpected char '%c' %d\n", *ctx->ptr, *ctx->ptr); return 0; }
HRESULT WINAPI PSPropertyKeyFromString(LPCWSTR pszString, PROPERTYKEY *pkey) { int has_minus = 0, has_comma = 0; TRACE("(%s, %p)\n", debugstr_w(pszString), pkey); if (!pszString || !pkey) return E_POINTER; memset(pkey, 0, sizeof(PROPERTYKEY)); if (!string_to_guid(pszString, &pkey->fmtid)) return E_INVALIDARG; pszString += GUIDSTRING_MAX - 1; if (!*pszString) return E_INVALIDARG; /* Only the space seems to be recognized as whitespace. The comma is only * recognized once and processing terminates if another comma is found. */ while (*pszString == ' ' || *pszString == ',') { if (*pszString == ',') { if (has_comma) return S_OK; else has_comma = 1; } pszString++; } if (!*pszString) return E_INVALIDARG; /* Only two minus signs are recognized if no comma is detected. The first * sign is ignored, and the second is interpreted. If a comma is detected * before the minus sign, then only one minus sign counts, and property ID * interpretation begins with the next character. */ if (has_comma) { if (*pszString == '-') { has_minus = 1; pszString++; } } else { if (*pszString == '-') pszString++; /* Skip any intermediate spaces after the first minus sign. */ while (*pszString == ' ') pszString++; if (*pszString == '-') { has_minus = 1; pszString++; } /* Skip any remaining spaces after minus sign. */ while (*pszString == ' ') pszString++; } /* Overflow is not checked. */ while (isdigitW(*pszString)) { pkey->pid *= 10; pkey->pid += (*pszString - '0'); pszString++; } if (has_minus) pkey->pid = ~pkey->pid + 1; return S_OK; }
static int terminate_processes(void) { DWORD *pid_list, pid_list_size; DWORD self_pid = GetCurrentProcessId(); unsigned int i; int status_code = 0; pid_list = enumerate_processes(&pid_list_size); if (!pid_list) { taskkill_message(STRING_ENUM_FAILED); return 1; } for (i = 0; i < task_count; i++) { WCHAR *p = task_list[i]; BOOL is_numeric = TRUE; /* Determine whether the string is not numeric. */ while (*p) { if (!isdigitW(*p++)) { is_numeric = FALSE; break; } } if (is_numeric) { DWORD pid = atoiW(task_list[i]); HANDLE process; if (pid == self_pid) { taskkill_message(STRING_SELF_TERMINATION); status_code = 1; continue; } process = OpenProcess(PROCESS_TERMINATE, FALSE, pid); if (!process) { taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]); status_code = 128; continue; } if (!TerminateProcess(process, 0)) { taskkill_message_printfW(STRING_TERMINATE_FAILED, task_list[i]); status_code = 1; CloseHandle(process); continue; } taskkill_message_printfW(STRING_TERM_PID_SEARCH, pid); CloseHandle(process); } else { DWORD index; BOOL found_process = FALSE; for (index = 0; index < pid_list_size; index++) { WCHAR process_name[MAX_PATH]; if (get_process_name_from_pid(pid_list[index], process_name, MAX_PATH) && !strcmpiW(process_name, task_list[i])) { HANDLE process; if (pid_list[index] == self_pid) { taskkill_message(STRING_SELF_TERMINATION); status_code = 1; continue; } process = OpenProcess(PROCESS_TERMINATE, FALSE, pid_list[index]); if (!process) { taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]); status_code = 128; continue; } if (!TerminateProcess(process, 0)) { taskkill_message_printfW(STRING_TERMINATE_FAILED, task_list[i]); status_code = 1; CloseHandle(process); continue; } found_process = TRUE; taskkill_message_printfW(STRING_TERM_PROC_SEARCH, task_list[i], pid_list[index]); CloseHandle(process); } } if (!found_process) { taskkill_message_printfW(STRING_SEARCH_FAILED, task_list[i]); status_code = 128; } } } HeapFree(GetProcessHeap(), 0, pid_list); return status_code; }
/********************************************************************* * wcstod (MSVCRT.@) */ double CDECL wcstod(const wchar_t* lpszStr, wchar_t** end) { const wchar_t* str = lpszStr; int negative = 0; double ret = 0, divisor = 10.0; TRACE("(%s,%p) semi-stub\n", debugstr_w(lpszStr), end); /* FIXME: * - Should set errno on failure * - Should fail on overflow * - Need to check which input formats are allowed */ while (isspaceW(*str)) str++; if (*str == '-') { negative = 1; str++; } while (isdigitW(*str)) { ret = ret * 10.0 + (*str - '0'); str++; } if (*str == '.') str++; while (isdigitW(*str)) { ret = ret + (*str - '0') / divisor; divisor *= 10; str++; } if (*str == 'E' || *str == 'e' || *str == 'D' || *str == 'd') { int negativeExponent = 0; int exponent = 0; if (*(++str) == '-') { negativeExponent = 1; str++; } while (isdigitW(*str)) { exponent = exponent * 10 + (*str - '0'); str++; } if (exponent != 0) { if (negativeExponent) ret = ret / pow(10.0, exponent); else ret = ret * pow(10.0, exponent); } } if (negative) ret = -ret; if (end) *end = (wchar_t*)str; TRACE("returning %g\n", ret); return ret; }