Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-31 21:11:54 +00:00
Code Issues Projects Releases Packages Wiki Activity

[WINESYNC] reg: Use malloc(), realloc() and free() from stdlib.h instead of wine/heap.h.

Browse source 
Signed-off-by: Hugh McMaster <hugh.mcmaster@outlook.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>

wine commit id be718697a2e1b30944c019218ef635f6737503d5 by Hugh McMaster <hugh.mcmaster@outlook.com>

manual adjustment needed
This commit is contained in:
winesync 2022-01-16 20:35:56 +01:00 • committed by Thomas Csovcsity
parent 9b91b79551
commit 68d5548fd5
8 changed files with 82 additions and 113 deletions
Download patch file Download diff file Expand all files Collapse all files

15
base/applications/cmdutils/reg/add.c
View file

@ -17,7 +17,6 @@
*/ */
#include <errno.h> #include <errno.h>
#include <stdlib.h>
#include "reg.h" #include "reg.h"
static DWORD wchar_get_type(const WCHAR *type_name) static DWORD wchar_get_type(const WCHAR *type_name)
@ -64,7 +63,7 @@ static LPBYTE get_regdata(const WCHAR *data, DWORD reg_type, WCHAR separator, DW
case REG_EXPAND_SZ: case REG_EXPAND_SZ:
{ {
*reg_count = (lstrlenW(data) + 1) * sizeof(WCHAR); *reg_count = (lstrlenW(data) + 1) * sizeof(WCHAR);
out_data = heap_xalloc(*reg_count); out_data = malloc(*reg_count);
lstrcpyW((LPWSTR)out_data,data); lstrcpyW((LPWSTR)out_data,data);
break; break;
} }
@ -80,7 +79,7 @@ static LPBYTE get_regdata(const WCHAR *data, DWORD reg_type, WCHAR separator, DW
break; break;
} }
*reg_count = sizeof(DWORD); *reg_count = sizeof(DWORD);
out_data = heap_xalloc(*reg_count); out_data = malloc(*reg_count);
((LPDWORD)out_data)[0] = val; ((LPDWORD)out_data)[0] = val;
break; break;
} }
@ -89,7 +88,7 @@ static LPBYTE get_regdata(const WCHAR *data, DWORD reg_type, WCHAR separator, DW
BYTE hex0, hex1; BYTE hex0, hex1;
int i = 0, destByteIndex = 0, datalen = lstrlenW(data); int i = 0, destByteIndex = 0, datalen = lstrlenW(data);
*reg_count = ((datalen + datalen % 2) / 2) * sizeof(BYTE); *reg_count = ((datalen + datalen % 2) / 2) * sizeof(BYTE);
out_data = heap_xalloc(*reg_count); out_data = malloc(*reg_count);
if(datalen % 2) if(datalen % 2)
{ {
hex1 = hexchar_to_byte(data[i++]); hex1 = hexchar_to_byte(data[i++]);
@ -108,7 +107,7 @@ static LPBYTE get_regdata(const WCHAR *data, DWORD reg_type, WCHAR separator, DW
break; break;
no_hex_data: no_hex_data:
/* cleanup, print error */ /* cleanup, print error */
heap_free(out_data); free(out_data);
output_message(STRING_MISSING_HEXDATA); output_message(STRING_MISSING_HEXDATA);
out_data = NULL; out_data = NULL;
break; break;
@ -116,7 +115,7 @@ static LPBYTE get_regdata(const WCHAR *data, DWORD reg_type, WCHAR separator, DW
case REG_MULTI_SZ: case REG_MULTI_SZ:
{ {
int i, destindex, len = lstrlenW(data); int i, destindex, len = lstrlenW(data);
WCHAR *buffer = heap_xalloc((len + 2) * sizeof(WCHAR)); WCHAR *buffer = malloc((len + 2) * sizeof(WCHAR));
for (i = 0, destindex = 0; i < len; i++, destindex++) for (i = 0, destindex = 0; i < len; i++, destindex++)
{ {
@ -132,7 +131,7 @@ static LPBYTE get_regdata(const WCHAR *data, DWORD reg_type, WCHAR separator, DW
if (destindex && !buffer[destindex - 1] && (!buffer[destindex] || destindex == 1)) if (destindex && !buffer[destindex - 1] && (!buffer[destindex] || destindex == 1))
{ {
heap_free(buffer); free(buffer);
output_message(STRING_INVALID_STRING); output_message(STRING_INVALID_STRING);
return NULL; return NULL;
} }
@ -201,7 +200,7 @@ int reg_add(HKEY root, WCHAR *path, WCHAR *value_name, BOOL value_empty,
} }
RegSetValueExW(key, value_name, 0, reg_type, reg_data, reg_count); RegSetValueExW(key, value_name, 0, reg_type, reg_data, reg_count);
heap_free(reg_data); free(reg_data);
} }
RegCloseKey(key); RegCloseKey(key);

8
base/applications/cmdutils/reg/delete.c
View file

@ -65,7 +65,7 @@ int reg_delete(HKEY root, WCHAR *path, WCHAR *key_name, WCHAR *value_name,
WCHAR *value_name; WCHAR *value_name;
LONG rc; LONG rc;
value_name = heap_xalloc(max_value_len * sizeof(WCHAR)); value_name = malloc(max_value_len * sizeof(WCHAR));
while (1) while (1)
{ {
@ -76,7 +76,7 @@ int reg_delete(HKEY root, WCHAR *path, WCHAR *key_name, WCHAR *value_name,
rc = RegDeleteValueW(key, value_name); rc = RegDeleteValueW(key, value_name);
if (rc != ERROR_SUCCESS) if (rc != ERROR_SUCCESS)
{ {
heap_free(value_name); free(value_name);
RegCloseKey(key); RegCloseKey(key);
output_message(STRING_VALUEALL_FAILED, key_name); output_message(STRING_VALUEALL_FAILED, key_name);
return 1; return 1;
@ -85,11 +85,11 @@ int reg_delete(HKEY root, WCHAR *path, WCHAR *key_name, WCHAR *value_name,
else if (rc == ERROR_MORE_DATA) else if (rc == ERROR_MORE_DATA)
{ {
max_value_len *= 2; max_value_len *= 2;
value_name = heap_xrealloc(value_name, max_value_len * sizeof(WCHAR)); value_name = realloc(value_name, max_value_len * sizeof(WCHAR));
} }
else break; else break;
} }
heap_free(value_name); free(value_name);
} }
else if (value_name || value_empty) else if (value_name || value_empty)
{ {

45
base/applications/cmdutils/reg/export.c
View file

@ -17,7 +17,6 @@
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include "reg.h" #include "reg.h"
static void write_file(HANDLE hFile, const WCHAR *str) static void write_file(HANDLE hFile, const WCHAR *str)
@ -42,7 +41,7 @@ static WCHAR *escape_string(WCHAR *str, size_t str_len, size_t *line_len)
escape_count++; escape_count++;
} }
buf = heap_xalloc((str_len + escape_count + 1) * sizeof(WCHAR)); buf = malloc((str_len + escape_count + 1) * sizeof(WCHAR));
for (i = 0, pos = 0; i < str_len; i++, pos++) for (i = 0, pos = 0; i < str_len; i++, pos++)
{ {
@ -87,11 +86,11 @@ static size_t export_value_name(HANDLE hFile, WCHAR *name, size_t len)
if (name && *name) if (name && *name)
{ {
WCHAR *str = escape_string(name, len, &line_len); WCHAR *str = escape_string(name, len, &line_len);
WCHAR *buf = heap_xalloc((line_len + 4) * sizeof(WCHAR)); WCHAR *buf = malloc((line_len + 4) * sizeof(WCHAR));
line_len = swprintf(buf, quoted_fmt, str); line_len = swprintf(buf, quoted_fmt, str);
write_file(hFile, buf); write_file(hFile, buf);
heap_free(buf); free(buf);
heap_free(str); free(str);
} }
else else
{ {
@ -111,16 +110,16 @@ static void export_string_data(WCHAR **buf, WCHAR *data, size_t size)
if (size) if (size)
len = size / sizeof(WCHAR) - 1; len = size / sizeof(WCHAR) - 1;
str = escape_string(data, len, &line_len); str = escape_string(data, len, &line_len);
*buf = heap_xalloc((line_len + 3) * sizeof(WCHAR)); *buf = malloc((line_len + 3) * sizeof(WCHAR));
swprintf(*buf, fmt, str); swprintf(*buf, fmt, str);
heap_free(str); free(str);
} }
static void export_dword_data(WCHAR **buf, DWORD *data) static void export_dword_data(WCHAR **buf, DWORD *data)
{ {
static const WCHAR fmt[] = {'d','w','o','r','d',':','%','0','8','x',0}; static const WCHAR fmt[] = {'d','w','o','r','d',':','%','0','8','x',0};
*buf = heap_xalloc(15 * sizeof(WCHAR)); *buf = malloc(15 * sizeof(WCHAR));
swprintf(*buf, fmt, *data); swprintf(*buf, fmt, *data);
} }
@ -137,10 +136,10 @@ static size_t export_hex_data_type(HANDLE hFile, DWORD type)
} }
else else
{ {
WCHAR *buf = heap_xalloc(15 * sizeof(WCHAR)); WCHAR *buf = malloc(15 * sizeof(WCHAR));
line_len = swprintf(buf, hexp_fmt, type); line_len = swprintf(buf, hexp_fmt, type);
write_file(hFile, buf); write_file(hFile, buf);
heap_free(buf); free(buf);
} }
return line_len; return line_len;
@ -160,7 +159,7 @@ static void export_hex_data(HANDLE hFile, WCHAR **buf, DWORD type,
if (!size) return; if (!size) return;
num_commas = size - 1; num_commas = size - 1;
*buf = heap_xalloc(size * 3 * sizeof(WCHAR)); *buf = malloc(size * 3 * sizeof(WCHAR));
for (i = 0, pos = 0; i < size; i++) for (i = 0, pos = 0; i < size; i++)
{ {
@ -217,7 +216,7 @@ static void export_data(HANDLE hFile, WCHAR *value_name, DWORD value_len,
if (size || type == REG_SZ) if (size || type == REG_SZ)
{ {
write_file(hFile, buf); write_file(hFile, buf);
heap_free(buf); free(buf);
} }
export_newline(hFile); export_newline(hFile);
@ -228,10 +227,10 @@ static void export_key_name(HANDLE hFile, WCHAR *name)
static const WCHAR fmt[] = {'\r','\n','[','%','s',']','\r','\n',0}; static const WCHAR fmt[] = {'\r','\n','[','%','s',']','\r','\n',0};
WCHAR *buf; WCHAR *buf;
buf = heap_xalloc((lstrlenW(name) + 7) * sizeof(WCHAR)); buf = malloc((lstrlenW(name) + 7) * sizeof(WCHAR));
swprintf(buf, fmt, name); swprintf(buf, fmt, name);
write_file(hFile, buf); write_file(hFile, buf);
heap_free(buf); free(buf);
} }
static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path) static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path)
@ -247,8 +246,8 @@ static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path)
export_key_name(hFile, path); export_key_name(hFile, path);
value_name = heap_xalloc(max_value_len * sizeof(WCHAR)); value_name = malloc(max_value_len * sizeof(WCHAR));
data = heap_xalloc(max_data_bytes); data = malloc(max_data_bytes);
i = 0; i = 0;
for (;;) for (;;)
@ -267,21 +266,21 @@ static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path)
if (data_size > max_data_bytes) if (data_size > max_data_bytes)
{ {
max_data_bytes = data_size; max_data_bytes = data_size;
data = heap_xrealloc(data, max_data_bytes); data = realloc(data, max_data_bytes);
} }
else else
{ {
max_value_len *= 2; max_value_len *= 2;
value_name = heap_xrealloc(value_name, max_value_len * sizeof(WCHAR)); value_name = realloc(value_name, max_value_len * sizeof(WCHAR));
} }
} }
else break; else break;
} }
heap_free(data); free(data);
heap_free(value_name); free(value_name);
subkey_name = heap_xalloc(MAX_SUBKEY_LEN * sizeof(WCHAR)); subkey_name = malloc(MAX_SUBKEY_LEN * sizeof(WCHAR));
path_len = lstrlenW(path); path_len = lstrlenW(path);
@ -298,13 +297,13 @@ static int export_registry_data(HANDLE hFile, HKEY key, WCHAR *path)
export_registry_data(hFile, subkey, subkey_path); export_registry_data(hFile, subkey, subkey_path);
RegCloseKey(subkey); RegCloseKey(subkey);
} }
heap_free(subkey_path); free(subkey_path);
i++; i++;
} }
else break; else break;
} }
heap_free(subkey_name); free(subkey_name);
return 0; return 0;
} }

43
base/applications/cmdutils/reg/import.c
View file

@ -18,7 +18,6 @@
#include <errno.h> #include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include "reg.h" #include "reg.h"
#include <wine/debug.h> #include <wine/debug.h>
@ -31,7 +30,7 @@ static WCHAR *GetWideString(const char *strA)
WCHAR *strW; WCHAR *strW;
int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0); int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0);
strW = heap_xalloc(len * sizeof(WCHAR)); strW = malloc(len * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, strA, -1, strW, len); MultiByteToWideChar(CP_ACP, 0, strA, -1, strW, len);
return strW; return strW;
} }
@ -45,7 +44,7 @@ static WCHAR *GetWideStringN(const char *strA, int size, DWORD *len)
WCHAR *strW; WCHAR *strW;
*len = MultiByteToWideChar(CP_ACP, 0, strA, size, NULL, 0); *len = MultiByteToWideChar(CP_ACP, 0, strA, size, NULL, 0);
strW = heap_xalloc(*len * sizeof(WCHAR)); strW = malloc(*len * sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, strA, size, strW, *len); MultiByteToWideChar(CP_ACP, 0, strA, size, strW, *len);
return strW; return strW;
} }
@ -192,7 +191,7 @@ static BOOL convert_hex_csv_to_hex(struct parser *parser, WCHAR **str)
/* The worst case is 1 digit + 1 comma per byte */ /* The worst case is 1 digit + 1 comma per byte */
size = ((lstrlenW(*str) + 1) / 2) + parser->data_size; size = ((lstrlenW(*str) + 1) / 2) + parser->data_size;
parser->data = heap_xrealloc(parser->data, size); parser->data = realloc(parser->data, size);
s = *str; s = *str;
d = (BYTE *)parser->data + parser->data_size; d = (BYTE *)parser->data + parser->data_size;
@ -358,7 +357,7 @@ static void close_key(struct parser *parser)
{ {
if (parser->hkey) if (parser->hkey)
{ {
heap_free(parser->key_name); free(parser->key_name);
parser->key_name = NULL; parser->key_name = NULL;
RegCloseKey(parser->hkey); RegCloseKey(parser->hkey);
@ -383,7 +382,7 @@ static LONG open_key(struct parser *parser, WCHAR *path)
if (res == ERROR_SUCCESS) if (res == ERROR_SUCCESS)
{ {
parser->key_name = heap_xalloc((lstrlenW(path) + 1) * sizeof(WCHAR)); parser->key_name = malloc((lstrlenW(path) + 1) * sizeof(WCHAR));
lstrcpyW(parser->key_name, path); lstrcpyW(parser->key_name, path);
} }
else else
@ -395,7 +394,7 @@ static LONG open_key(struct parser *parser, WCHAR *path)
static void free_parser_data(struct parser *parser) static void free_parser_data(struct parser *parser)
{ {
if (parser->parse_type == REG_DWORD || parser->parse_type == REG_BINARY) if (parser->parse_type == REG_DWORD || parser->parse_type == REG_BINARY)
heap_free(parser->data); free(parser->data);
parser->data = NULL; parser->data = NULL;
parser->data_size = 0; parser->data_size = 0;
@ -429,7 +428,7 @@ static void prepare_hex_string_data(struct parser *parser)
parser->data = GetWideStringN(parser->data, parser->data_size, &parser->data_size); parser->data = GetWideStringN(parser->data, parser->data_size, &parser->data_size);
parser->data_size *= sizeof(WCHAR); parser->data_size *= sizeof(WCHAR);
heap_free(data); free(data);
} }
} }
} }
@ -482,12 +481,12 @@ static WCHAR *header_state(struct parser *parser, WCHAR *pos)
if (!parser->is_unicode) if (!parser->is_unicode)
{ {
header = heap_xalloc((lstrlenW(line) + 3) * sizeof(WCHAR)); header = malloc((lstrlenW(line) + 3) * sizeof(WCHAR));
header[0] = parser->two_wchars[0]; header[0] = parser->two_wchars[0];
header[1] = parser->two_wchars[1]; header[1] = parser->two_wchars[1];
lstrcpyW(header + 2, line); lstrcpyW(header + 2, line);
parser->reg_version = parse_file_header(header); parser->reg_version = parse_file_header(header);
heap_free(header); free(header);
} }
else parser->reg_version = parse_file_header(line); else parser->reg_version = parse_file_header(line);
@ -627,7 +626,7 @@ static WCHAR *delete_key_state(struct parser *parser, WCHAR *pos)
/* handler for parser DEFAULT_VALUE_NAME state */ /* handler for parser DEFAULT_VALUE_NAME state */
static WCHAR *default_value_name_state(struct parser *parser, WCHAR *pos) static WCHAR *default_value_name_state(struct parser *parser, WCHAR *pos)
{ {
heap_free(parser->value_name); free(parser->value_name);
parser->value_name = NULL; parser->value_name = NULL;
set_state(parser, DATA_START); set_state(parser, DATA_START);
@ -639,14 +638,14 @@ static WCHAR *quoted_value_name_state(struct parser *parser, WCHAR *pos)
{ {
WCHAR *val_name = pos, *p; WCHAR *val_name = pos, *p;
heap_free(parser->value_name); free(parser->value_name);
parser->value_name = NULL; parser->value_name = NULL;
if (!unescape_string(val_name, &p)) if (!unescape_string(val_name, &p))
goto invalid; goto invalid;
/* copy the value name in case we need to parse multiple lines and the buffer is overwritten */ /* copy the value name in case we need to parse multiple lines and the buffer is overwritten */
parser->value_name = heap_xalloc((lstrlenW(val_name) + 1) * sizeof(WCHAR)); parser->value_name = malloc((lstrlenW(val_name) + 1) * sizeof(WCHAR));
lstrcpyW(parser->value_name, val_name); lstrcpyW(parser->value_name, val_name);
set_state(parser, DATA_START); set_state(parser, DATA_START);
@ -757,7 +756,7 @@ static WCHAR *dword_data_state(struct parser *parser, WCHAR *pos)
{ {
WCHAR *line = pos; WCHAR *line = pos;
parser->data = heap_xalloc(sizeof(DWORD)); parser->data = malloc(sizeof(DWORD));
if (!convert_hex_to_dword(line, parser->data)) if (!convert_hex_to_dword(line, parser->data))
goto invalid; goto invalid;
@ -879,14 +878,14 @@ static WCHAR *get_lineA(FILE *fp)
static char *buf, *next; static char *buf, *next;
char *line; char *line;
heap_free(lineW); free(lineW);
if (!fp) goto cleanup; if (!fp) goto cleanup;
if (!size) if (!size)
{ {
size = REG_VAL_BUF_SIZE; size = REG_VAL_BUF_SIZE;
buf = heap_xalloc(size); buf = malloc(size);
*buf = 0; *buf = 0;
next = buf; next = buf;
} }
@ -903,7 +902,7 @@ static WCHAR *get_lineA(FILE *fp)
if (size - len < 3) if (size - len < 3)
{ {
size *= 2; size *= 2;
buf = heap_xrealloc(buf, size); buf = realloc(buf, size);
} }
if (!(count = fread(buf + len, 1, size - len - 1, fp))) if (!(count = fread(buf + len, 1, size - len - 1, fp)))
{ {
@ -925,7 +924,7 @@ static WCHAR *get_lineA(FILE *fp)
cleanup: cleanup:
lineW = NULL; lineW = NULL;
if (size) heap_free(buf); free(buf);
size = 0; size = 0;
return NULL; return NULL;
} }
@ -941,7 +940,7 @@ static WCHAR *get_lineW(FILE *fp)
if (!size) if (!size)
{ {
size = REG_VAL_BUF_SIZE; size = REG_VAL_BUF_SIZE;
buf = heap_xalloc(size * sizeof(WCHAR)); buf = malloc(size * sizeof(WCHAR));
*buf = 0; *buf = 0;
next = buf; next = buf;
} }
@ -959,7 +958,7 @@ static WCHAR *get_lineW(FILE *fp)
if (size - len < 3) if (size - len < 3)
{ {
size *= 2; size *= 2;
buf = heap_xrealloc(buf, size * sizeof(WCHAR)); buf = realloc(buf, size * sizeof(WCHAR));
} }
if (!(count = fread(buf + len, sizeof(WCHAR), size - len - 1, fp))) if (!(count = fread(buf + len, sizeof(WCHAR), size - len - 1, fp)))
{ {
@ -978,7 +977,7 @@ static WCHAR *get_lineW(FILE *fp)
} }
cleanup: cleanup:
if (size) heap_free(buf); free(buf);
size = 0; size = 0;
return NULL; return NULL;
} }
@ -1036,7 +1035,7 @@ int reg_import(int argc, WCHAR *argvW[])
if (parser.reg_version == REG_VERSION_INVALID) if (parser.reg_version == REG_VERSION_INVALID)
goto error; goto error;
heap_free(parser.value_name); free(parser.value_name);
close_key(&parser); close_key(&parser);
fclose(fp); fclose(fp);

42
base/applications/cmdutils/reg/query.c
View file

@ -41,7 +41,7 @@ static WCHAR *reg_data_to_wchar(DWORD type, const BYTE *src, DWORD size_bytes)
{ {
case REG_SZ: case REG_SZ:
case REG_EXPAND_SZ: case REG_EXPAND_SZ:
buffer = heap_xalloc(size_bytes); buffer = malloc(size_bytes);
lstrcpyW(buffer, (WCHAR *)src); lstrcpyW(buffer, (WCHAR *)src);
break; break;
case REG_NONE: case REG_NONE:
@ -50,7 +50,7 @@ static WCHAR *reg_data_to_wchar(DWORD type, const BYTE *src, DWORD size_bytes)
WCHAR *ptr; WCHAR *ptr;
static const WCHAR fmt[] = {'%','0','2','X',0}; static const WCHAR fmt[] = {'%','0','2','X',0};
buffer = heap_xalloc((size_bytes * 2 + 1) * sizeof(WCHAR)); buffer = malloc((size_bytes * 2 + 1) * sizeof(WCHAR));
ptr = buffer; ptr = buffer;
for (i = 0; i < size_bytes; i++) for (i = 0; i < size_bytes; i++)
ptr += swprintf(ptr, 3, fmt, src[i]); ptr += swprintf(ptr, 3, fmt, src[i]);
@ -63,7 +63,7 @@ static WCHAR *reg_data_to_wchar(DWORD type, const BYTE *src, DWORD size_bytes)
const int zero_x_dword = 10; const int zero_x_dword = 10;
static const WCHAR fmt[] = {'0','x','%','x',0}; static const WCHAR fmt[] = {'0','x','%','x',0};
buffer = heap_xalloc((zero_x_dword + 1) * sizeof(WCHAR)); buffer = malloc((zero_x_dword + 1) * sizeof(WCHAR));
swprintf(buffer, zero_x_dword + 1, fmt, *(DWORD *)src); swprintf(buffer, zero_x_dword + 1, fmt, *(DWORD *)src);
break; break;
} }
@ -76,13 +76,13 @@ static WCHAR *reg_data_to_wchar(DWORD type, const BYTE *src, DWORD size_bytes)
if (size_bytes <= two_wchars) if (size_bytes <= two_wchars)
{ {
buffer = heap_xalloc(sizeof(WCHAR)); buffer = malloc(sizeof(WCHAR));
*buffer = 0; *buffer = 0;
return buffer; return buffer;
} }
tmp_size = size_bytes - two_wchars; /* exclude both null terminators */ tmp_size = size_bytes - two_wchars; /* exclude both null terminators */
buffer = heap_xalloc(tmp_size * 2 + sizeof(WCHAR)); buffer = malloc(tmp_size * 2 + sizeof(WCHAR));
len = tmp_size / sizeof(WCHAR); len = tmp_size / sizeof(WCHAR);
for (i = 0, destindex = 0; i < len; i++, destindex++) for (i = 0, destindex = 0; i < len; i++, destindex++)
@ -123,7 +123,7 @@ static void output_value(const WCHAR *value_name, DWORD type, BYTE *data, DWORD
{ {
reg_data = reg_data_to_wchar(type, data, data_size); reg_data = reg_data_to_wchar(type, data, data_size);
output_string(fmt, reg_data); output_string(fmt, reg_data);
heap_free(reg_data); free(reg_data);
} }
else else
{ {
@ -146,7 +146,7 @@ static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse)
WCHAR *subkey_name, *subkey_path; WCHAR *subkey_name, *subkey_path;
HKEY subkey; HKEY subkey;
data = heap_xalloc(max_data_bytes); data = malloc(max_data_bytes);
for (;;) for (;;)
{ {
@ -155,7 +155,7 @@ static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse)
if (rc == ERROR_MORE_DATA) if (rc == ERROR_MORE_DATA)
{ {
max_data_bytes = data_size; max_data_bytes = data_size;
data = heap_xrealloc(data, max_data_bytes); data = realloc(data, max_data_bytes);
} }
else break; else break;
} }
@ -168,7 +168,7 @@ static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse)
num_values_found++; num_values_found++;
} }
heap_free(data); free(data);
if (!recurse) if (!recurse)
{ {
@ -185,7 +185,7 @@ static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse)
return 0; return 0;
} }
subkey_name = heap_xalloc(MAX_SUBKEY_LEN * sizeof(WCHAR)); subkey_name = malloc(MAX_SUBKEY_LEN * sizeof(WCHAR));
path_len = lstrlenW(path); path_len = lstrlenW(path);
@ -202,13 +202,13 @@ static int query_value(HKEY key, WCHAR *value_name, WCHAR *path, BOOL recurse)
query_value(subkey, value_name, subkey_path, recurse); query_value(subkey, value_name, subkey_path, recurse);
RegCloseKey(subkey); RegCloseKey(subkey);
} }
heap_free(subkey_path); free(subkey_path);
i++; i++;
} }
else break; else break;
} }
heap_free(subkey_name); free(subkey_name);
return 0; return 0;
} }
@ -227,8 +227,8 @@ static int query_all(HKEY key, WCHAR *path, BOOL recurse)
output_string(fmt, path); output_string(fmt, path);
value_name = heap_xalloc(max_value_len * sizeof(WCHAR)); value_name = malloc(max_value_len * sizeof(WCHAR));
data = heap_xalloc(max_data_bytes); data = malloc(max_data_bytes);
i = 0; i = 0;
for (;;) for (;;)
@ -246,24 +246,24 @@ static int query_all(HKEY key, WCHAR *path, BOOL recurse)
if (data_size > max_data_bytes) if (data_size > max_data_bytes)
{ {
max_data_bytes = data_size; max_data_bytes = data_size;
data = heap_xrealloc(data, max_data_bytes); data = realloc(data, max_data_bytes);
} }
else else
{ {
max_value_len *= 2; max_value_len *= 2;
value_name = heap_xrealloc(value_name, max_value_len * sizeof(WCHAR)); value_name = realloc(value_name, max_value_len * sizeof(WCHAR));
} }
} }
else break; else break;
} }
heap_free(data); free(data);
heap_free(value_name); free(value_name);
if (i || recurse) if (i || recurse)
output_string(newlineW); output_string(newlineW);
subkey_name = heap_xalloc(MAX_SUBKEY_LEN * sizeof(WCHAR)); subkey_name = malloc(MAX_SUBKEY_LEN * sizeof(WCHAR));
path_len = lstrlenW(path); path_len = lstrlenW(path);
@ -282,7 +282,7 @@ static int query_all(HKEY key, WCHAR *path, BOOL recurse)
query_all(subkey, subkey_path, recurse); query_all(subkey, subkey_path, recurse);
RegCloseKey(subkey); RegCloseKey(subkey);
} }
heap_free(subkey_path); free(subkey_path);
} }
else output_string(fmt_path, path, subkey_name); else output_string(fmt_path, path, subkey_name);
i++; i++;
@ -290,7 +290,7 @@ static int query_all(HKEY key, WCHAR *path, BOOL recurse)
else break; else break;
} }
heap_free(subkey_name); free(subkey_name);
if (i && !recurse) if (i && !recurse)
output_string(newlineW); output_string(newlineW);

36
base/applications/cmdutils/reg/reg.c
View file

@ -16,7 +16,6 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/ */
#include <stdlib.h>
#include "reg.h" #include "reg.h"
#include <wine/debug.h> #include <wine/debug.h>
@ -69,30 +68,6 @@ const struct reg_type_rels type_rels[] =
{REG_MULTI_SZ, type_multi_sz}, {REG_MULTI_SZ, type_multi_sz},
}; };
void *heap_xalloc(size_t size)
{
void *buf = heap_alloc(size);
if (!buf)
{
ERR("Out of memory!\n");
exit(1);
}
return buf;
}
void *heap_xrealloc(void *buf, size_t size)
{
void *new_buf = heap_realloc(buf, size);
if (!new_buf)
{
ERR("Out of memory!\n");
exit(1);
}
return new_buf;
}
void output_writeconsole(const WCHAR *str, DWORD wlen) void output_writeconsole(const WCHAR *str, DWORD wlen)
{ {
DWORD count, ret; DWORD count, ret;
@ -108,11 +83,11 @@ void output_writeconsole(const WCHAR *str, DWORD wlen)
* one in that case. * one in that case.
*/ */
len = WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, NULL, 0, NULL, NULL); len = WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, NULL, 0, NULL, NULL);
msgA = heap_xalloc(len); msgA = malloc(len);
WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, msgA, len, NULL, NULL); WideCharToMultiByte(GetConsoleOutputCP(), 0, str, wlen, msgA, len, NULL, NULL);
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE); WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
heap_free(msgA); free(msgA);
} }
} }
@ -233,7 +208,7 @@ WCHAR *build_subkey_path(WCHAR *path, DWORD path_len, WCHAR *subkey_name, DWORD
WCHAR *subkey_path; WCHAR *subkey_path;
static const WCHAR fmt[] = {'%','s','\\','%','s',0}; static const WCHAR fmt[] = {'%','s','\\','%','s',0};
subkey_path = heap_xalloc((path_len + subkey_len + 2) * sizeof(WCHAR)); subkey_path = malloc((path_len + subkey_len + 2) * sizeof(WCHAR));
swprintf(subkey_path, fmt, path, subkey_name); swprintf(subkey_path, fmt, path, subkey_name);
return subkey_path; return subkey_path;
@ -255,13 +230,13 @@ static WCHAR *get_long_key(HKEY root, WCHAR *path)
if (!path) if (!path)
{ {
long_key = heap_xalloc((len + 1) * sizeof(WCHAR)); long_key = malloc((len + 1) * sizeof(WCHAR));
lstrcpyW(long_key, root_rels[i].long_name); lstrcpyW(long_key, root_rels[i].long_name);
return long_key; return long_key;
} }
len += lstrlenW(path) + 1; /* add one for the backslash */ len += lstrlenW(path) + 1; /* add one for the backslash */
long_key = heap_xalloc((len + 1) * sizeof(WCHAR)); long_key = malloc((len + 1) * sizeof(WCHAR));
swprintf(long_key, fmt, root_rels[i].long_name, path); swprintf(long_key, fmt, root_rels[i].long_name, path);
return long_key; return long_key;
} }
@ -376,7 +351,6 @@ int __cdecl wmain(int argc, WCHAR *argvW[])
output_message(STRING_REG_HELP); output_message(STRING_REG_HELP);
return 1; return 1;
} }
else if (argc == 2) /* Valid operation, no arguments supplied */ else if (argc == 2) /* Valid operation, no arguments supplied */
{ {
output_message(STRING_INVALID_SYNTAX); output_message(STRING_INVALID_SYNTAX);

4
base/applications/cmdutils/reg/reg.h
View file

@ -19,8 +19,8 @@
#ifndef __REG_H__ #ifndef __REG_H__
#define __REG_H__ #define __REG_H__
#include <stdlib.h>
#include <windows.h> #include <windows.h>
#include <wine/heap.h>
#include "resource.h" #include "resource.h"
#define MAX_SUBKEY_LEN 257 #define MAX_SUBKEY_LEN 257
@ -33,8 +33,6 @@ struct reg_type_rels {
extern const struct reg_type_rels type_rels[8]; extern const struct reg_type_rels type_rels[8];
void *heap_xalloc(size_t size);
void *heap_xrealloc(void *buf, size_t size);
void output_writeconsole(const WCHAR *str, DWORD wlen); void output_writeconsole(const WCHAR *str, DWORD wlen);
void WINAPIV output_message(unsigned int id, ...); void WINAPIV output_message(unsigned int id, ...);
void WINAPIV output_string(const WCHAR *fmt, ...); void WINAPIV output_string(const WCHAR *fmt, ...);

2
sdk/tools/winesync/reg.cfg
View file

@ -4,4 +4,4 @@ directories:
files: files:
programs/reg/resource.h: base/applications/cmdutils/reg/resource.h programs/reg/resource.h: base/applications/cmdutils/reg/resource.h
tags: tags:
wine: 42420f4d6c13cc4818e10c9b0cd9ee64c3715db3 wine: be718697a2e1b30944c019218ef635f6737503d5