"x", "p" arguments are wrapped with type casting.
Otherwise they are saved as 32-bit ones and poison next arguments.
Change-Id: I3ed635a0b7f1a7cc5c3fc09154ca138466300fea
Signed-off-by: Nikita Kalyazin <n.kalyazin@samsung.com>
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_CUSTOM,
API_ID_da_mark,
- "dp", color, mark_text);
+ "dp", color, voidp_to_uint64(mark_text));
PACK_COMMON_END(0, 0, 2);
PACK_CUSTOM(0, 0, mark_text, color, 0.0f);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_CUSTOM,
API_ID_da_create_chart,
- "p", chart_name);
+ "p", voidp_to_uint64(chart_name));
PACK_COMMON_END(ret, 0, 2);
PACK_CUSTOM(0, 0, chart_name, 0, 0.0f);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_CUSTOM,
API_ID_da_create_series,
- "dpdd", charthandle, seriesname, type, color);
+ "dpdd", charthandle, voidp_to_uint64(seriesname),
+ type, color);
PACK_COMMON_END(ret, 0, 2);
PACK_CUSTOM(charthandle, type, seriesname, color, 0.0f);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_CUSTOM,
API_ID_da_log,
- "dw", series_handle, uservalue);
+ "df", series_handle, uservalue);
PACK_COMMON_END(0, 0, 2);
PACK_CUSTOM(series_handle, 0, "", 0, uservalue);
FLUSH_LOCAL_BUF();
#define CALLER_ADDRESS \
((void*) __builtin_extract_return_addr(__builtin_return_address(0)))
-
+static inline uint64_t voidp_to_uint64(const void *p)
+{
+ return (uint64_t)(uintptr_t)p;
+}
// COMMON
static inline char *pack_int32(char *to, uint32_t val)
bret = gAppCallback.create(user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_create, bret, "p", user_data);
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_create, bret, "p",
+ voidp_to_uint64(user_data));
return bret;
}
gAppCallback.terminate(user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_terminate, 0, "p", user_data);
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_terminate, 0, "p",
+ voidp_to_uint64(user_data));
}
static void _dalc_app_pause(void* user_data)
gAppCallback.pause(user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_pause, 0, "p", user_data);
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_pause, 0, "p",
+ voidp_to_uint64(user_data));
}
static void _dalc_app_resume(void* user_data)
gAppCallback.resume(user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_resume, 0, "p", user_data);
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_resume, 0, "p",
+ voidp_to_uint64(user_data));
}
static void _dalc_app_service(service_h service, void* user_data)
gAppCallback.service(service, user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_service, 0, "dp", (unsigned int)service, user_data);
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_service, 0, "dp",
+ (unsigned int)service,
+ voidp_to_uint64(user_data));
}
static void _dalc_app_deviceorientationchanged(app_device_orientation_e orientation, void* user_data)
char info1_str[16]; \
setProbePoint(&probeInfo); \
PREPARE_LOCAL_BUF(); \
- PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, API_ID, "p", _ARGDETECTOR); \
+ PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, API_ID, "p", voidp_to_uint64(_ARGDETECTOR)); \
PACK_COMMON_END(0, 0, 0); \
sprintf(info1_str, "%d", _INFO1); \
PACK_UIEVENT(_EVENT_GESTURE, _GESTURETYPE, _X, _Y, info1_str, _INFO2); \
setProbePoint(&probeInfo); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, API_ID, "pdp", \
- _ARGDATA, _ARGTYPE, _ARGEVENT); \
+ voidp_to_uint64(_ARGDATA), _ARGTYPE, \
+ voidp_to_uint64(_ARGEVENT)); \
PACK_COMMON_END(0, 0, 0); \
PACK_UIEVENT(_EVENTTYPE, _DETAILTYPE, _X, _Y, _KEYCODE, _EXTRA); \
FLUSH_LOCAL_BUF(); \
AFTER_PACK_ORIGINAL_FD(API_ID_lseek,
offret, (unsigned int)offset, fd, FD_API_OTHER,
- "dxd", fd, offset, whence);
+ "dxd", fd, (uint64_t)(offset), whence);
return offret;
}
ret = ftruncatep(fd, length);
AFTER_PACK_ORIGINAL_FD(API_ID_ftruncate,
- ret, (unsigned int)length, fd, FD_API_DIRECTORY, "dx", fd, length);
+ ret, (unsigned int)length, fd,
+ FD_API_DIRECTORY, "dx", fd, (uint64_t)(length));
return ret;
}
ret = lockfp(fd, function, size);
AFTER_PACK_ORIGINAL_FD(API_ID_lockf,
ret, (unsigned int)size, fd, FD_API_PERMISSION,
- "ddx", fd, function, size);
+ "ddx", fd, function, (uint64_t)(size));
return ret;
}
ssize_t sret;
BEFORE_ORIGINAL_START_END_FD(API_ID_pread, pread, LIBC, fd,
- FD_API_READ_START, "dpxx", fd, buf, nbyte, offset);
+ FD_API_READ_START, "dpxx", fd,
+ voidp_to_uint64(buf),
+ (uint64_t)(nbyte),
+ (uint64_t)(offset));
sret = preadp(fd, buf, nbyte, offset);
AFTER_ORIGINAL_START_END_FD(API_ID_pread, sret, (unsigned int)sret, fd,
- FD_API_READ_END, "dpxx", fd, buf, nbyte, offset);
+ FD_API_READ_END, "dpxx", fd,
+ voidp_to_uint64(buf),
+ (uint64_t)(nbyte),
+ (uint64_t)(offset));
return sret;
}
ssize_t sret;
BEFORE_ORIGINAL_START_END_FD(API_ID_read, read, LIBC, fd, FD_API_READ_START,
- "dpx", fd, buf, nbyte);
+ "dpx", fd, voidp_to_uint64(buf),
+ (uint64_t)(nbyte));
sret = readp(fd, buf, nbyte);
AFTER_ORIGINAL_START_END_FD(API_ID_read, sret, (unsigned int)sret, fd,
- FD_API_READ_END, "dpx", fd, buf, nbyte);
+ FD_API_READ_END, "dpx", fd,
+ voidp_to_uint64(buf),
+ (uint64_t)(nbyte));
return sret;
}
ssize_t sret;
BEFORE_ORIGINAL_START_END_FD(API_ID_pwrite, pwrite, LIBC, fd, FD_API_WRITE_START,
- "dpxx", fd, buf, nbyte, offset);
+ "dpxx", fd, voidp_to_uint64(buf),
+ (uint64_t)(nbyte),
+ (uint64_t)(offset));
sret = pwritep(fd, buf, nbyte, offset);
DEFINE_FILESIZE_FD(fd);
AFTER_ORIGINAL_START_END_FD(API_ID_pwrite, sret, (unsigned int)sret, fd,
- FD_API_WRITE_END, "dpxx", fd, buf, nbyte, offset);
+ FD_API_WRITE_END, "dpxx", fd,
+ voidp_to_uint64(buf),
+ (uint64_t)(nbyte),
+ (uint64_t)(offset));
return sret;
}
ssize_t sret;
BEFORE_ORIGINAL_START_END_FD(API_ID_write, write, LIBC, fd, FD_API_WRITE_START,
- "dpx", fd, buf, nbyte);
+ "dpx", fd, voidp_to_uint64(buf),
+ (uint64_t)(nbyte));
sret = writep(fd, buf, nbyte);
DEFINE_FILESIZE_FD(fd);
AFTER_ORIGINAL_START_END_FD(API_ID_write, sret, (unsigned int)sret, fd,
- FD_API_WRITE_END, "dpx", fd, buf, nbyte);
+ FD_API_WRITE_END, "dpx", fd,
+ voidp_to_uint64(buf),
+ (uint64_t)(nbyte));
return sret;
}
ssize_t sret;
BEFORE_ORIGINAL_START_END_FD(API_ID_readv, readv, LIBC, fd, FD_API_READ_START,
- "dpd", fd, iov, iovcnt);
+ "dpd", fd, voidp_to_uint64(iov), iovcnt);
sret = readvp(fd,iov,iovcnt);
AFTER_ORIGINAL_START_END_FD(API_ID_readv, sret, (unsigned int)sret, fd,
- FD_API_READ_END, "dpd", fd, iov, iovcnt);
+ FD_API_READ_END, "dpd", fd,
+ voidp_to_uint64(iov), iovcnt);
return sret;
}
BEFORE_ORIGINAL_FILE(fstat, LIBC);
ret = fstatp(fd, buf);
- AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "dp", fd, buf);
+ AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "dp", fd,
+ voidp_to_uint64(buf));
return ret;
}
#endif
BEFORE_ORIGINAL_FILE(futimens, LIBC);
ret = futimensp(fd, times);
AFTER_PACK_ORIGINAL_FD(API_ID_futimens,
- ret, 0, fd, FD_API_OTHER, "dp", fd, times);
+ ret, 0, fd, FD_API_OTHER, "dp", fd,
+ voidp_to_uint64(times));
return ret;
}
AFTER_PACK_ORIGINAL_FILEP(API_ID_freopen, fret, 0, fret, FD_API_OPEN,
"ssp", absolutize_filepath(buffer, filename),
- mode, stream);
+ mode, voidp_to_uint64(stream));
return fret;
}
BEFORE_ORIGINAL_FILE(fflush, LIBC);
ret = fflushp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fflush,
- ret, 0, stream, FD_API_OTHER, "p", stream);
+ ret, 0, stream, FD_API_OTHER, "p",
+ voidp_to_uint64(stream));
return ret;
}
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_fclose,
- "p", stream);
+ "p", voidp_to_uint64(stream));
PACK_COMMON_END(ret, newerrno, blockresult);
POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, FD_API_CLOSE);
POST_PACK_PROBEBLOCK_END();
BEFORE_ORIGINAL_FILE(fgetpos, LIBC);
ret = fgetposp(stream, position);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fgetpos,
- ret, 0, stream, FD_API_OTHER, "pp", stream, position);
+ ret, 0, stream, FD_API_OTHER, "pp",
+ voidp_to_uint64(stream),
+ voidp_to_uint64(position));
return ret;
}
ret = fseekp(stream, offset, origin);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fseek,
ret, (unsigned int)offset, stream, FD_API_OTHER,
- "pxd", stream, offset, origin);
+ "pxd", voidp_to_uint64(stream),
+ (uint64_t)(offset), origin);
return ret;
}
BEFORE_ORIGINAL_FILE(fsetpos, LIBC);
ret = fsetposp(stream, pos);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fsetpos,
- ret, 0, stream, FD_API_OTHER, "pp", stream, pos);
+ ret, 0, stream, FD_API_OTHER, "pp",
+ voidp_to_uint64(stream), voidp_to_uint64(pos));
return ret;
}
lret = ftellp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_ftell,
- lret, 0, stream, FD_API_OTHER, "p", stream);
+ lret, 0, stream, FD_API_OTHER, "p",
+ voidp_to_uint64(stream));
return lret;
}
rewindp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_rewind,
- 0, 0, stream, FD_API_OTHER, "p", stream);
+ 0, 0, stream, FD_API_OTHER, "p",
+ voidp_to_uint64(stream));
}
void clearerr(FILE* stream)
clearerrp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_clearerr,
- 0, 0, stream, FD_API_OTHER, "p", stream);
+ 0, 0, stream, FD_API_OTHER, "p",
+ voidp_to_uint64(stream));
}
int feof(FILE* stream)
BEFORE_ORIGINAL_FILE(feof, LIBC);
ret = feofp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_feof,
- ret, 0, stream, FD_API_OTHER, "p", stream);
+ ret, 0, stream, FD_API_OTHER, "p",
+ voidp_to_uint64(stream));
return ret;
}
BEFORE_ORIGINAL_FILE(ferror, LIBC);
ret = ferrorp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_ferror,
- ret, 0, stream, FD_API_OTHER, "p", stream);
+ ret, 0, stream, FD_API_OTHER, "p",
+ voidp_to_uint64(stream));
return ret;
}
BEFORE_ORIGINAL_FILE(fileno, LIBC);
ret = filenop(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fileno,
- ret, 0, stream, FD_API_OTHER, "p", stream);
+ ret, 0, stream, FD_API_OTHER, "p",
+ voidp_to_uint64(stream));
return ret;
}
static int (*vfprintfp)(FILE* stream, const char* format, va_list arg);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfprintf, vfprintf, LIBC, stream,
- FD_API_WRITE_START, "ps", stream, format);
+ FD_API_WRITE_START, "ps",
+ voidp_to_uint64(stream), format);
ret = vfprintfp(stream, format, arg);
AFTER_ORIGINAL_START_END_FILEP(API_ID_vfprintf, ret, ret, stream,
- FD_API_WRITE_END, "ps", stream, format);
+ FD_API_WRITE_END, "ps",
+ voidp_to_uint64(stream), format);
return ret;
}
static int (*vfscanfp)(FILE* stream, const char* format, va_list arg);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfscanf, vfscanf, LIBC, stream,
- FD_API_READ_START, "ps", stream, format);
+ FD_API_READ_START, "ps",
+ voidp_to_uint64(stream), format);
ret = vfscanfp(stream, format, arg);
AFTER_ORIGINAL_START_END_FILEP(API_ID_vfscanf, ret, ret, stream,
- FD_API_READ_END, "ps", stream, format);
+ FD_API_READ_END, "ps",
+ voidp_to_uint64(stream), format);
return ret;
}
static int (*fgetcp)(FILE* stream);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgetc, fgetc, LIBC, stream,
- FD_API_READ_START, "p", stream);
+ FD_API_READ_START, "p",
+ voidp_to_uint64(stream));
ret = fgetcp(stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fgetc, ret, (ret != EOF), stream,
- FD_API_READ_END, "p", stream);
+ FD_API_READ_END, "p",
+ voidp_to_uint64(stream));
return ret;
}
static int (*fputcp)(int character, FILE* stream);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputc, fputc, LIBC, stream,
- FD_API_WRITE_START, "dp", character, stream);
+ FD_API_WRITE_START, "dp", character,
+ voidp_to_uint64(stream));
ret = fputcp(character, stream);
- AFTER_ORIGINAL_START_END_FILEP(API_ID_fputc, ret, (ret == EOF ? 0 : 1), stream,
- FD_API_WRITE_END, "dp", character, stream);
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fputc, ret, (ret == EOF ? 0 : 1),
+ stream, FD_API_WRITE_END, "dp",
+ character, voidp_to_uint64(stream));
return ret;
}
static int (*fputsp)(const char* str, FILE* stream);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputs, fputs, LIBC, stream,
- FD_API_WRITE_START, "sp", str, stream);
+ FD_API_WRITE_START, "sp", str,
+ voidp_to_uint64(stream));
ret = fputsp(str, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fputs, ret, ret, stream,
- FD_API_WRITE_END, "sp", str, stream);
+ FD_API_WRITE_END, "sp", str,
+ voidp_to_uint64(stream));
return ret;
}
static int (*getcp)(FILE* stream);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_getc, getc, LIBC, stream,
- FD_API_READ_START, "p", stream);
+ FD_API_READ_START, "p",
+ voidp_to_uint64(stream));
ret = getcp(stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_getc, ret, (ret == EOF ? 0 : 1), stream,
- FD_API_READ_END, "p", stream);
+ FD_API_READ_END, "p",
+ voidp_to_uint64(stream));
return ret;
}
static int (*putcp)(int character, FILE* stream);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, putc, LIBC, stream,
- FD_API_WRITE_START, "dp", character, stream);
+ FD_API_WRITE_START, "dp", character,
+ voidp_to_uint64(stream));
ret = putcp(character, stream);
- AFTER_ORIGINAL_START_END_FILEP(API_ID_putc, ret, (ret == EOF ? 0 : 1), stream,
- FD_API_WRITE_END, "dp", character, stream);
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_putc, ret, (ret == EOF ? 0 : 1),
+ stream, FD_API_WRITE_END, "dp",
+ character, voidp_to_uint64(stream));
return ret;
}
static int (*ungetcp)(int character, FILE* stream);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, ungetc, LIBC, stream,
- FD_API_WRITE_START, "dp", character, stream);
+ FD_API_WRITE_START, "dp", character,
+ voidp_to_uint64(stream));
ret = ungetcp(character, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_ungetc, ret, 0, stream,
- FD_API_OTHER, "dp", character, stream);
+ FD_API_OTHER, "dp", character,
+ voidp_to_uint64(stream));
return ret;
}
size_t tret;
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fread, fread, LIBC, stream,
- FD_API_READ_START, "pxxp", ptr, size, count, stream);
+ FD_API_READ_START, "pxxp",
+ voidp_to_uint64(ptr),
+ (uint64_t)(size),
+ (uint64_t)(count),
+ voidp_to_uint64(stream));
tret = freadp(ptr, size, count, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fread, tret, tret*size, stream,
- FD_API_READ_END, "pxxp", ptr, size, count, stream);
+ FD_API_READ_END, "pxxp",
+ voidp_to_uint64(ptr),
+ (uint64_t)(size),
+ (uint64_t)(count),
+ voidp_to_uint64(stream));
return tret;
}
size_t tret;
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fwrite, fwrite, LIBC, stream,
- FD_API_WRITE_START, "pxxp", ptr, size, count, stream);
+ FD_API_WRITE_START, "pxxp",
+ voidp_to_uint64(ptr),
+ (uint64_t)(size),
+ (uint64_t)(count),
+ voidp_to_uint64(stream));
tret = fwritep(ptr, size, count, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fwrite, tret, tret*size, stream,
- FD_API_WRITE_END, "pxxp", ptr, size, count, stream);
+ FD_API_WRITE_END, "pxxp",
+ voidp_to_uint64(ptr),
+ (uint64_t)(size),
+ (uint64_t)(count),
+ voidp_to_uint64(stream));
return tret;
}
static int (*vfprintfp)(FILE* stream, const char* format, ...);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fprintf, vfprintf, LIBC, stream,
- FD_API_WRITE_START, "ps", stream, format);
+ FD_API_WRITE_START, "ps",
+ voidp_to_uint64(stream), format);
va_list arg;
va_start(arg, format);
ret = vfprintfp(stream, format, arg);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fprintf, ret, ret, stream,
- FD_API_WRITE_END, "ps", stream, format);
+ FD_API_WRITE_END, "ps",
+ voidp_to_uint64(stream), format);
va_end(arg);
static int (*vfscanfp)(FILE* stream, const char* format, ...);
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fscanf, vfscanf, LIBC, stream,
- FD_API_READ_START, "ps", stream, format);
+ FD_API_READ_START, "ps",
+ voidp_to_uint64(stream), format);
va_list arg;
va_start(arg, format);
ret = vfscanfp(stream, format, arg);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fscanf, ret, ret, stream,
- FD_API_READ_END, "ps", stream, format);
+ FD_API_READ_END, "ps",
+ voidp_to_uint64(stream), format);
va_end(arg);
setbufp(stream, buf);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuf,
- 0, 0, stream, FD_API_OTHER, "pp", stream, buf);
+ 0, 0, stream, FD_API_OTHER, "pp",
+ voidp_to_uint64(stream),
+ voidp_to_uint64(buf));
}
void setbuffer(FILE* stream, char* buf, size_t size)
AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuffer,
0, size, stream, FD_API_OTHER,
- "ppx", stream, buf, size);
+ "ppx", voidp_to_uint64(stream),
+ voidp_to_uint64(buf), (uint64_t)(size));
}
void setlinebuf(FILE* stream)
setlinebufp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setlinebuf,
- 0, 0, stream, FD_API_OTHER, "p", stream);
+ 0, 0, stream, FD_API_OTHER, "p",
+ voidp_to_uint64(stream));
}
int setvbuf(FILE* stream, char* buf, int mode, size_t size)
ret = setvbufp(stream,buf,mode,size);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setvbuf,
ret, size, stream, FD_API_OTHER,
- "ppdx", stream, buf, mode, size);
+ "ppdx",
+ voidp_to_uint64(stream),
+ voidp_to_uint64(buf), mode,
+ (uint64_t)(size));
return ret;
}
glActiveTexturep(texture);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
- texture);
+ (uint64_t)(texture));
}
void glAttachShader(GLuint program, GLuint shader) {
glBindBufferp(target, buffer);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
- target, buffer);
+ (uint64_t)(target), buffer);
}
void glBindFramebuffer(GLenum target, GLuint framebuffer) {
glBindFramebufferp(target, framebuffer);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
- target, framebuffer);
+ (uint64_t)(target), framebuffer);
}
void glBindRenderbuffer(GLenum target, GLuint renderbuffer) {
glBindRenderbufferp(target, renderbuffer);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
- target, renderbuffer);
+ (uint64_t)(target), renderbuffer);
}
void glBindTexture(GLenum target, GLuint texture) {
glBindTexturep(target, texture);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
- target, texture);
+ (uint64_t)(target), texture);
}
void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
BEFORE(glBlendEquation);
glBlendEquationp(mode);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", mode);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
+ (uint64_t)(mode));
}
void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
glBlendEquationSeparatep(modeRGB, modeAlpha);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
- modeRGB, modeAlpha);
+ (uint64_t)(modeRGB), (uint64_t)(modeAlpha));
}
void glBlendFunc(GLenum sfactor, GLenum dfactor) {
glBlendFuncp(sfactor, dfactor);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
- sfactor, dfactor);
+ (uint64_t)(sfactor), (uint64_t)(dfactor));
}
void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
glBlendFuncSeparatep(srcRGB, dstRGB, srcAlpha, dstAlpha);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
- srcRGB, dstRGB, srcAlpha, dstAlpha);
+ (uint64_t)(srcRGB), (uint64_t)(dstRGB),
+ (uint64_t)(srcAlpha), (uint64_t)(dstAlpha));
}
void glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data,
BEFORE(glBufferData);
glBufferDatap(target, size, data, usage);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "xxpx", target, size, data, usage);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxpx",
+ (uint64_t)(target), (uint64_t)(size),
+ voidp_to_uint64(data), (uint64_t)(usage));
}
void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
BEFORE(glBufferSubData);
glBufferSubDatap(target, offset, size, data);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "xxxp", target, offset, size, data);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxp",
+ (uint64_t)(target), (uint64_t)(offset),
+ (uint64_t)(size), voidp_to_uint64(data));
}
// ==================================================================
BEFORE(glCheckFramebufferStatus);
GLenum ret = glCheckFramebufferStatusp(target);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "x", target);
+ AFTER(ret, APITYPE_CONTEXT, "", "x",
+ (uint64_t)(target));
return ret;
}
BEFORE(glClear);
glClearp(mask);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", mask);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
+ (uint64_t)(mask));
}
void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
BEFORE(glCompileShader);
glCompileShaderp(shader);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", shader);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(shader));
}
void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat,
glCompressedTexImage2Dp(target, level, internalformat, width, height,
border, imageSize, data);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "xdxddddp",
- target, level, internalformat, width, height, border, imageSize, data);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxddddp",
+ (uint64_t)(target), level,
+ (uint64_t)(internalformat), width, height, border, imageSize,
+ voidp_to_uint64(data));
}
void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
glCompressedTexSubImage2Dp(target, level, xoffset, yoffset, width, height,
format, imageSize, data);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "xdddddxdp",
- target, level, xoffset, yoffset, width, height, format, imageSize, data);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdddddxdp",
+ (uint64_t)(target), level, xoffset, yoffset, width, height,
+ (uint64_t)(format), imageSize, voidp_to_uint64(data));
}
void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
glCopyTexImage2Dp(target, level, internalformat, x, y, width, height,
border);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "xdxddddd",
- target, level, internalformat, x, y, width, height, border);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxddddd",
+ (uint64_t)(target), level,
+ (uint64_t)(internalformat), x, y, width, height, border);
}
void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
BEFORE(glCopyTexSubImage2D);
glCopyTexSubImage2Dp(target, level, xoffset, yoffset, x, y, width, height);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "xddddddd",
- target, level, xoffset, yoffset, x, y, width, height);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xddddddd",
+ (uint64_t)(target), level, xoffset, yoffset, x, y, width,
+ height);
}
GLuint glCreateProgram(void) {
BEFORE(glCreateShader);
GLuint ret = glCreateShaderp(shaderType);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "x", shaderType);
+ AFTER(ret, APITYPE_CONTEXT, "", "x", (uint64_t)(shaderType));
return ret;
}
BEFORE(glCullFace);
glCullFacep(mode);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", mode);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(mode));
}
// ==================================================================
glDeleteBuffersp(n, buffers);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
- n, buffers);
+ n, voidp_to_uint64(buffers));
}
void glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers) {
glDeleteFramebuffersp(n, framebuffers);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
- n, framebuffers);
+ n, voidp_to_uint64(framebuffers));
}
void glDeleteProgram(GLuint program) {
glDeleteRenderbuffersp(n, renderbuffers);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
- n, renderbuffers);
+ n, voidp_to_uint64(renderbuffers));
}
void glDeleteShader(GLuint shader) {
}
}
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
- n, textures);
+ n, voidp_to_uint64(textures));
} else {
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
- n, textures);
+ n, voidp_to_uint64(textures));
}
}
BEFORE(glDepthFunc);
glDepthFuncp(func);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", func);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(func));
}
void glDepthMask(GLboolean flag) {
BEFORE(glDepthMask);
glDepthMaskp(flag);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", flag);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(flag));
}
void glDepthRangef(GLclampf nearVal, GLclampf farVal) {
BEFORE(glDisable);
glDisablep(cap);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", cap);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
}
void glDisableVertexAttribArray(GLuint index) {
glDrawArraysp(mode, first, count);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
- mode, first, count);
+ (uint64_t)(mode), first, count);
}
void glDrawElements(GLenum mode, GLsizei count, GLenum type,
glDrawElementsp(mode, count, type, indices);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxp",
- mode, count, type, indices);
+ (uint64_t)(mode), count, (uint64_t)(type), indices);
}
// ==================================================================
BEFORE(glEnable);
glEnablep(cap);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", cap);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
}
void glEnableVertexAttribArray(GLuint index) {
renderbuffer);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxd",
- target, attachment, renderbuffertarget, renderbuffer);
+ (uint64_t)(target), (uint64_t)(attachment),
+ (uint64_t)(renderbuffertarget), renderbuffer);
}
void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget,
BEFORE(glFramebufferTexture2D);
glFramebufferTexture2Dp(target, attachment, textarget, texture, level);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "xxxdd", target, attachment, textarget, texture, level);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxdd",
+ (uint64_t)(target), (uint64_t)(attachment),
+ (uint64_t)(textarget), texture, level);
}
void glFrontFace(GLenum mode) {
BEFORE(glFrontFace);
glFrontFacep(mode);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", mode);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
+ (uint64_t)(mode));
}
// ==================================================================
}
}
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
- n, buffers);
+ n, voidp_to_uint64(buffers));
} else {
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
- n, buffers);
+ n, voidp_to_uint64(buffers));
}
}
glGenFramebuffersp(n, framebuffers);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
- n, framebuffers);
+ n, voidp_to_uint64(framebuffers));
}
void glGenRenderbuffers(GLsizei n, GLuint * renderbuffers) {
glGenRenderbuffersp(n, renderbuffers);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
- n, renderbuffers);
+ n, voidp_to_uint64(renderbuffers));
}
void glGenTextures(GLsizei n, GLuint * textures) {
}
}
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
- n, textures);
+ n, voidp_to_uint64(textures));
} else {
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
- n, textures);
+ n, voidp_to_uint64(textures));
}
}
BEFORE(glGenerateMipmap);
glGenerateMipmapp(target);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", target);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(target));
}
//lsh_get
BEFORE(glGetBooleanv);
glGetBooleanvp(pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", pname);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
}
//lsh_get
BEFORE(glGetFloatv);
glGetFloatvp(pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", pname);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
}
//lsh_get
BEFORE(glGetIntegerv);
glGetIntegervp(pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", pname);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
}
//lsh_get
BEFORE(glGetAttribLocation);
glGetAttribLocationp(pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", pname);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
}
//lsh_get
glGetBufferParameterivp(target, value, data);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
- target, value);
+ (uint64_t)(target), (uint64_t)(value));
}
GLenum glGetError(void) {
glGetFramebufferAttachmentParameterivp(target, attachment, pname, params);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
- target, attachment, pname);
+ (uint64_t)(target), (uint64_t)(attachment),
+ (uint64_t)(pname));
}
//lsh_get
glGetProgramivp(program, pname, params);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
- program, pname);
+ program, (uint64_t)(pname));
}
//lsh_get
glGetRenderbufferParameterivp(target, pname, params);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
- target, pname);
+ (uint64_t)(target), (uint64_t)(pname));
}
//lsh_get
glGetShaderPrecisionFormatp(shaderType, precisionType, range, precision);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
- shaderType, precisionType);
+ (uint64_t)(shaderType), (uint64_t)(precisionType));
}
//lsh_get
glGetShaderivp(shader, pname, params);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
- shader, pname);
+ shader, (uint64_t)(pname));
}
const GLubyte* glGetString(GLenum name) {
BEFORE(glGetString);
const GLubyte* ret = glGetStringp(name);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "x", name);
+ AFTER(ret, APITYPE_CONTEXT, "", "x", (uint64_t)(name));
return ret;
}
glGetTexParameterfvp(target, pname, params);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
- target, pname);
+ (uint64_t)(target), (uint64_t)(pname));
}
//lsh_get
glGetTexParameterivp(target, pname, params);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
- target, pname);
+ (uint64_t)(target), (uint64_t)(pname));
}
//lsh_get
glGetVertexAttribfvp(index, pname, params);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
- index, pname);
+ index, (uint64_t)(pname));
}
//lsh_get
glGetVertexAttribivp(index, pname, params);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
- index, pname);
+ index, (uint64_t)(pname));
}
//lsh_get
glGetVertexAttribPointervp(index, pname, pointer);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
- index, pname);
+ index, (uint64_t)(pname));
}
// ==================================================================
glHintp(target, mode);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
- target, mode);
+ (uint64_t)(target), (uint64_t)(mode));
}
// ==================================================================
BEFORE(glIsEnabled);
GLboolean ret = glIsEnabledp(cap);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "x", cap);
+ AFTER(ret, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
return ret;
}
glPixelStoreip(pname, param);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
- pname, param);
+ (uint64_t)(pname), param);
}
void glPolygonOffset(GLfloat factor, GLfloat units) {
glReadPixelsp(x, y, width, height, format, type, data);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "ddddxx", x, y, width, height, format, type);
+ "ddddxx", x, y, width, height,
+ (uint64_t)(format), (uint64_t)(type));
}
void glReleaseShaderCompiler(void) {
glRenderbufferStoragep(target, internalformat, width, height);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
- target, internalformat, width, height);
+ (uint64_t)(target), (uint64_t)(internalformat),
+ width, height);
}
// ==================================================================
glSampleCoveragep(value, invert);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "fx",
- value, invert);
+ value, (uint64_t)(invert));
}
void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
glShaderBinaryp(n, shaders, binaryformat, binary, length);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "dpxpd", n, shaders, binaryformat, binary, length);
+ "dpxpd", n, voidp_to_uint64(shaders),
+ (uint64_t)(binaryformat), voidp_to_uint64(binary), length);
}
//lsh_param
char buf[length[0]];
glGetShaderSource(shader, length[0], NULL, buf);
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf,
- "ddpp", shader, count, string, length);
+ "ddpp", shader, count,
+ voidp_to_uint64(string), voidp_to_uint64(length));
} else {
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "ddpp", shader, count, string, length);
+ "ddpp", shader, count,
+ voidp_to_uint64(string), voidp_to_uint64(length));
}
}
glStencilFuncp(func, ref, mask);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
- func, ref, mask);
+ (uint64_t)(func), ref, mask);
}
void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
glStencilFuncSeparatep(face, func, ref, mask);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
- face, func, ref, mask);
+ (uint64_t)(face), (uint64_t)(func), ref, mask);
}
void glStencilMask(GLuint mask) {
glStencilMaskSeparatep(face, mask);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
- face, mask);
+ (uint64_t)(face), mask);
}
void glStencilOp(GLenum sfail, GLenum dpfail, GLenum dppass) {
glStencilOpp(sfail, dpfail, dppass);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
- sfail, dpfail, dppass);
+ (uint64_t)(sfail), (uint64_t)(dpfail),
+ (uint64_t)(dppass));
}
void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail,
glStencilOpSeparatep(face, sfail, dpfail, dppass);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
- face, sfail, dpfail, dppass);
+ (uint64_t)(face), (uint64_t)(sfail), (uint64_t)(dpfail),
+ (uint64_t)(dppass));
}
// ==================================================================
glTexImage2Dp(target, level, internalformat, width, height, border, format,
type, data);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "xdddddxxp",
- target, level, internalformat, width, height, border, format, type, data);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdddddxxp",
+ (uint64_t)(target), level, internalformat, width, height,
+ border, (uint64_t)(format), (uint64_t)(type),
+ voidp_to_uint64(data));
}
void glTexParameterf(GLenum target, GLenum pname, GLfloat param) {
BEFORE(glTexParameterf);
glTexParameterfp(target, pname, param);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
- target, pname, (GLenum)param);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxf",
+ (uint64_t)(target), (uint64_t)(pname), param);
}
void glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params) {
char param0[8];
sprintf(param0, "%x", (GLenum)params[0]);
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
- target, pname, params);
+ (uint64_t)(target), (uint64_t)(pname),
+ voidp_to_uint64(params));
} else {
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
- target, pname, params);
+ (uint64_t)(target), (uint64_t)(pname),
+ voidp_to_uint64(params));
}
}
glTexParameterip(target, pname, param);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
- target, pname, param);
+ (uint64_t)(target), (uint64_t)(pname),
+ (uint64_t)(param));
}
void glTexParameteriv(GLenum target, GLenum pname, const GLint * params) {
char param0[8];
sprintf(param0, "%x", (GLenum)params[0]);
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
- target, pname, params);
+ (uint64_t)(target), (uint64_t)(pname),
+ voidp_to_uint64(params));
} else {
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
- target, pname, params);
+ (uint64_t)(target),
+ (uint64_t)(pname),
+ voidp_to_uint64(params));
}
}
data);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "xdddddxxp",
- target, level, xoffset, yoffset, width, height, format, type, data);
+ "xdddddxxp",
+ (uint64_t)(target), level, xoffset, yoffset, width, height,
+ (uint64_t)(format), (uint64_t)(type), voidp_to_uint64(data));
}
// ==================================================================
glUniform1fvp(location, count, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
- location, count, value);
+ location, count, voidp_to_uint64(value));
}
void glUniform2fv(GLint location, GLsizei count, const GLfloat *value) {
glUniform2fvp(location, count, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
- location, count, value);
+ location, count, voidp_to_uint64(value));
}
void glUniform3fv(GLint location, GLsizei count, const GLfloat *value) {
glUniform3fvp(location, count, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
- location, count, value);
+ location, count, voidp_to_uint64(value));
}
void glUniform4fv(GLint location, GLsizei count, const GLfloat *value) {
glUniform4fvp(location, count, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
- location, count, value);
+ location, count, voidp_to_uint64(value));
}
void glUniform1i(GLint location, GLint v0) {
glUniform1ivp(location, count, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
- location, count, value);
+ location, count, voidp_to_uint64(value));
}
void glUniform2iv(GLint location, GLsizei count, const GLint *value) {
glUniform2ivp(location, count, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
- location, count, value);
+ location, count, voidp_to_uint64(value));
}
void glUniform3iv(GLint location, GLsizei count, const GLint *value) {
glUniform3ivp(location, count, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
- location, count, value);
+ location, count, voidp_to_uint64(value));
}
void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
glUniformMatrix2fvp(location, count, transpose, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
- location, count, transpose, value);
+ location, count, (uint64_t)(transpose), voidp_to_uint64(value));
}
void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
glUniformMatrix3fvp(location, count, transpose, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
- location, count, transpose, value);
+ location, count, (uint64_t)(transpose), voidp_to_uint64(value));
}
void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
glUniformMatrix4fvp(location, count, transpose, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
- location, count, transpose, value);
+ location, count, (uint64_t)(transpose), voidp_to_uint64(value));
}
void glUniform4iv(GLint location, GLsizei count, const GLint *value) {
glUniform4ivp(location, count, value);
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
- location, count, value);
+ location, count, voidp_to_uint64(value));
}
void glUseProgram(GLuint program) {
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
- "dp", index, v);
+ "dp", index, voidp_to_uint64(v));
}
void glVertexAttrib2fv(GLuint index, const GLfloat *v) {
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
- "dp", index, v);
+ "dp", index, voidp_to_uint64(v));
}
void glVertexAttrib3fv(GLuint index, const GLfloat *v) {
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
- "dp", index, v);
+ "dp", index, voidp_to_uint64(v));
}
void glVertexAttrib4fv(GLuint index, const GLfloat *v) {
error = glGetError();
AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
- "dp", index, v);
+ "dp", index, voidp_to_uint64(v));
}
void glVertexAttribPointer(GLuint index, GLint size, GLenum type,
BEFORE(glVertexAttribPointer);
glVertexAttribPointerp(index, size, type, normalized, stride, pointer);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
- "ddxxdp",
- index, size, type, normalized, stride, pointer);
+ AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxxdp",
+ index, size, (uint64_t)(type), (uint64_t)(normalized),
+ stride, voidp_to_uint64(pointer));
}
void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_realloc,
- "px", (uint64_t)(int) memblock, (uint64_t) size);
+ "px", voidp_to_uint64(memblock), (uint64_t) size);
PACK_COMMON_END(pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_memset,
- "pdx", memblock, c, n);
+ "pdx", voidp_to_uint64(memblock), c,
+ (uint64_t)(n));
PACK_COMMON_END(pret, newerrno, blockresult);
PACK_MEMORY(n, MEMORY_API_MANAGE, pret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_memcmp,
- "ppx", ptr1, ptr2, num);
+ "ppx", voidp_to_uint64(ptr1), voidp_to_uint64(ptr2),
+ (uint64_t)(num));
PACK_COMMON_END(ret, newerrno, blockresult);
PACK_MEMORY(num, MEMORY_API_MANAGE, ret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_memcpy,
- "ppx", destination, source, num);
+ "ppx", voidp_to_uint64(destination),
+ voidp_to_uint64(source),
+ (uint64_t)(num));
PACK_COMMON_END(pret, newerrno, blockresult);
PACK_MEMORY(num, MEMORY_API_MANAGE, pret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new_std__size_t_size__throw__std__bad_alloc_,
- "x", size);
+ "x", (uint64_t)(size));
PACK_COMMON_END(pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new___std__size_t_size__throw__std__bad_alloc_,
- "x", size);
+ "x", (uint64_t)(size));
PACK_COMMON_END(pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete_void__ptr__throw__,
- "p", ptr);
+ "p", voidp_to_uint64(ptr));
PACK_COMMON_END(0, newerrno, blockresult);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete___void__ptr__throw__,
- "p", ptr);
+ "p", voidp_to_uint64(ptr));
PACK_COMMON_END(0, newerrno, blockresult);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new_std__size_t_size__const_std__nothrow_t__nothrow__throw__,
- "xp", size, ¬hrow);
+ "xp", (uint64_t)(size), voidp_to_uint64(¬hrow));
PACK_COMMON_END(pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new___std__size_t_size__const_std__nothrow_t__nothrow__throw__,
- "xp", size, ¬hrow);
+ "xp", (uint64_t)(size), voidp_to_uint64(¬hrow));
PACK_COMMON_END(pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete_void__ptr__const_std__nothrow_t__nothrow__throw__,
- "pp", ptr, ¬hrow);
+ "pp", voidp_to_uint64(ptr), voidp_to_uint64(¬hrow));
PACK_COMMON_END(0, newerrno, blockresult);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete___void__ptr__const_std__nothrow_t__nothrow__throw__,
- "pp", ptr, ¬hrow);
+ "pp", voidp_to_uint64(ptr), voidp_to_uint64(¬hrow));
PACK_COMMON_END(0, newerrno, blockresult);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
char* callAddress = getAddress(address);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
SOCKET_API_ACCEPT_START, info, "dsp",
- socket, callAddress, address_len);
+ socket, callAddress, voidp_to_uint64(address_len));
ret = acceptp(socket, address, address_len);
info.sock = (struct sockaddr *)address;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, socket,
SOCKET_API_ACCEPT_END, info, "dsp",
- socket, callAddress, address_len);
+ socket, callAddress, voidp_to_uint64(address_len));
return ret;
}
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, sockfd,
SOCKET_API_ACCEPT_START, info, "dspd",
- sockfd, callAddress, addrlen, flags);
+ sockfd, callAddress, voidp_to_uint64(addrlen), flags);
ret = accept4p(sockfd, addr, addrlen, flags);
info.sock = (struct sockaddr *)addr;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, sockfd,
SOCKET_API_ACCEPT_END, info, "dspd",
- sockfd, callAddress, addrlen, flags);
+ sockfd, callAddress, voidp_to_uint64(addrlen), flags);
return ret;
}
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
SOCKET_API_SEND_START, info, "dpdd",
- socket, messagP, length, flags);
+ socket, voidp_to_uint64(messagP), length, flags);
sret = sendp(socket, message, length, flags);
result = sret;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
SOCKET_API_SEND_END, info, "dpdd",
- socket, messagP, length, flags);
+ socket, voidp_to_uint64(messagP), length, flags);
return sret;
}
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
SOCKET_API_RECV_START, info, "dpdd",
- socket, bufferP, length, flags);
+ socket, voidp_to_uint64(bufferP), length, flags);
sret = recvp(socket, buffer, length, flags);
result = sret;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
SOCKET_API_RECV_END, info, "dpdd",
- socket, bufferP, length, flags);
+ socket, voidp_to_uint64(bufferP), length, flags);
return sret;
}
info.sock = (struct sockaddr *) dest_addr;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_SEND_START, info, "dpddpd",
- socket, bufferP, length, flags, dest_addr, dest_len);
+ SOCKET_API_SEND_START, info,
+ "dpddpd",
+ socket,
+ voidp_to_uint64(bufferP),
+ length, flags,
+ voidp_to_uint64(dest_addr),
+ dest_len);
sret = sendtop(socket, message, length, flags, dest_addr, dest_len);
result = sret;
info.msg_buf = bufferP;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_SEND_END, info, "dpddpd",
- socket, bufferP, length, flags, dest_addr, dest_len);
+ SOCKET_API_SEND_END, info,
+ "dpddpd",
+ socket,
+ voidp_to_uint64(bufferP),
+ length, flags,
+ voidp_to_uint64(dest_addr),
+ dest_len);
return sret;
}
char *bufferP = (char *)buffer;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_RECV_START, info, "dpddpp",
- socket, bufferP, length, flags, address, address_len);
+ SOCKET_API_RECV_START, info,
+ "dpddpp",
+ socket,
+ voidp_to_uint64(bufferP), length,
+ flags, voidp_to_uint64(address),
+ voidp_to_uint64(address_len));
sret = recvfromp(socket, buffer, length, flags, address, address_len);
info.sock = (struct sockaddr *)address;
info.msg_buf = bufferP;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_RECV_END, info, "dpddpp",
- socket, bufferP, length, flags, address, address_len);
+ SOCKET_API_RECV_END, info,
+ "dpddpp", socket,
+ voidp_to_uint64(bufferP), length,
+ flags, voidp_to_uint64(address),
+ voidp_to_uint64(address_len));
return sret;
}
int* bufferP = (int*) message->msg_name;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_RECV_START, info, "dpd",
- socket, message, flags);
+ SOCKET_API_RECV_START, info,
+ "dpd", socket,
+ voidp_to_uint64(message), flags);
sret = recvmsgp(socket, message, flags);
if (sret <= 0) {
}
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_RECV_END, info, "dpd",
- socket, bufferP, flags);
+ SOCKET_API_RECV_END, info, "dpd",
+ socket, voidp_to_uint64(bufferP),
+ flags);
free(out);
return sret;
}
int* bufferP = (int*) message->msg_name;
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, socket,
- SOCKET_API_SEND_START, info, "dpd",
- socket, message, flags);
+ SOCKET_API_SEND_START, info,
+ "dpd",
+ socket,
+ voidp_to_uint64(message), flags);
sret = sendmsgp(socket, message, flags);
if (sret <= 0) {
}
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(sret, OBJ_DUMMY, socket,
- SOCKET_API_SEND_END, info, "dpd",
- socket, bufferP, flags);
+ SOCKET_API_SEND_END, info, "dpd",
+ socket,
+ voidp_to_uint64(bufferP), flags);
free(out);
return sret;
}
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_OTHER, info,
"dddpp", socket, level, option_name,
- option_value, option_len);
+ voidp_to_uint64(option_value),
+ voidp_to_uint64(option_len));
return ret;
}
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, socket, SOCKET_API_OTHER, info,
"dddpd", socket, level, option_name,
- option_value, option_len);
+ voidp_to_uint64(option_value), option_len);
return ret;
}
info.sock = (struct sockaddr *)addr;
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, fd, SOCKET_API_OTHER, info,
- "dsp", fd, getAddress(addr), len);
+ "dsp", fd, getAddress(addr),
+ voidp_to_uint64(len));
return ret;
}
info.sock = (struct sockaddr *)addr;
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, sockfd, SOCKET_API_OTHER, info,
- "dsp", sockfd, getAddress(addr), addrlen);
+ "dsp", sockfd, getAddress(addr),
+ voidp_to_uint64(addrlen));
return ret;
}
BEFORE_ORIGINAL_SOCK(select, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, 0,
- SOCKET_API_EVENT_START, info, "dpppp",
- nfds, readfds, writefds, exceptfds, timeout);
+ SOCKET_API_EVENT_START, info,
+ "dpppp", nfds,
+ voidp_to_uint64(readfds),
+ voidp_to_uint64(writefds),
+ voidp_to_uint64(exceptfds),
+ voidp_to_uint64(timeout));
ret = selectp(nfds, readfds, writefds, exceptfds, timeout);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, 0,
- SOCKET_API_EVENT_END, info, "dpppp",
- nfds, readfds, writefds, exceptfds, timeout);
+ SOCKET_API_EVENT_END, info,
+ "dpppp", nfds,
+ voidp_to_uint64(readfds),
+ voidp_to_uint64(writefds),
+ voidp_to_uint64(exceptfds),
+ voidp_to_uint64(timeout));
return ret;
}
BEFORE_ORIGINAL_SOCK(pselect, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, 0,
- SOCKET_API_EVENT_START, info, "dppppp",
- nfds, readfds, writefds, exceptfds, ntimeout, sigmask);
+ SOCKET_API_EVENT_START, info,
+ "dppppp", nfds,
+ voidp_to_uint64(readfds),
+ voidp_to_uint64(writefds),
+ voidp_to_uint64(exceptfds),
+ voidp_to_uint64(ntimeout),
+ voidp_to_uint64(sigmask));
ret = pselectp(nfds, readfds, writefds, exceptfds, ntimeout, sigmask);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, 0,
- SOCKET_API_EVENT_END, info, "dppppp",
- nfds, readfds, writefds, exceptfds, ntimeout, sigmask);
+ SOCKET_API_EVENT_END, info,
+ "dppppp", nfds,
+ voidp_to_uint64(readfds),
+ voidp_to_uint64(writefds),
+ voidp_to_uint64(exceptfds),
+ voidp_to_uint64(ntimeout),
+ voidp_to_uint64(sigmask));
return ret;
}
BEFORE_ORIGINAL_SOCK(poll, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, fds->fd,
- SOCKET_API_EVENT_START, info, "pxd",
- fds, nfds, timeout);
+ SOCKET_API_EVENT_START, info,
+ "pxd", voidp_to_uint64(fds),
+ (uint64_t)(nfds), timeout);
ret = pollp(fds, nfds, timeout);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, fds->fd,
- SOCKET_API_EVENT_END, info, "pxd", fds, nfds, timeout);
+ SOCKET_API_EVENT_END, info,
+ "pxd", voidp_to_uint64(fds),
+ (uint64_t)(nfds), timeout);
return ret;
}
BEFORE_ORIGINAL_SOCK(ppoll, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, fds->fd,
- SOCKET_API_EVENT_START, info, "pxpp",
- fds, nfds, timeout_ts, sigmask);
+ SOCKET_API_EVENT_START, info,
+ "pxpp",
+ voidp_to_uint64(fds),
+ (uint64_t)(nfds),
+ voidp_to_uint64(timeout_ts),
+ voidp_to_uint64(sigmask));
ret = ppollp(fds, nfds, timeout_ts, sigmask);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, fds->fd,
- SOCKET_API_EVENT_END, info, "pxpp",
- fds, nfds, timeout_ts, sigmask);
+ SOCKET_API_EVENT_END, info,
+ "pxpp",
+ voidp_to_uint64(fds),
+ (uint64_t)(nfds),
+ voidp_to_uint64(timeout_ts),
+ voidp_to_uint64(sigmask));
return ret;
}
BEFORE_ORIGINAL_SOCK(epoll_wait, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, __epfd,
- SOCKET_API_EVENT_START, info, "dpdd",
- __epfd, __events, __maxevents, __timeout);
+ SOCKET_API_EVENT_START, info,
+ "dpdd", __epfd,
+ voidp_to_uint64(__events),
+ __maxevents, __timeout);
ret = epoll_waitp(__epfd, __events, __maxevents, __timeout);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, __epfd,
- SOCKET_API_EVENT_END, info, "dpdd",
- __epfd, __events, __maxevents, __timeout);
+ SOCKET_API_EVENT_END, info,
+ "dpdd", __epfd,
+ voidp_to_uint64(__events),
+ __maxevents, __timeout);
return ret;
}
BEFORE_ORIGINAL_SOCK(epoll_pwait, LIBC);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_START(NULL, OBJ_DUMMY, __epfd,
- SOCKET_API_EVENT_START, info, "dpdd %p",
- __epfd, __events, __maxevents, __timeout, __ss);
+ SOCKET_API_EVENT_START, info,
+ "dpddp", __epfd,
+ voidp_to_uint64(__events),
+ __maxevents,
+ __timeout,
+ voidp_to_uint64(__ss));
ret = epoll_pwaitp(__epfd, __events, __maxevents, __timeout, __ss);
AFTER_ORIGINAL_LIBC_SOCK_WAIT_FUNC_END(ret, OBJ_DUMMY, __epfd,
- SOCKET_API_EVENT_END, info, "dpdd %p",
- __epfd, __events, __maxevents, __timeout, __ss);
+ SOCKET_API_EVENT_END, info,
+ "dpddp", __epfd,
+ voidp_to_uint64(__events),
+ __maxevents, __timeout,
+ voidp_to_uint64(__ss));
return ret;
}
ret = epoll_ctlp(__epfd, __op, __fd, __event);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, __fd, SOCKET_API_OTHER, info,
- "dddp", __epfd, __op, __fd, __event);
+ "dddp", __epfd, __op, __fd,
+ voidp_to_uint64(__event));
return ret;
}
ret = inet_atonp(cp, inp);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pp", cp, inp);
+ info, "pp", voidp_to_uint64(cp),
+ voidp_to_uint64(inp));
return ret;
}
iret = inet_addrp(cp);
AFTER_ORIGINAL_LIBC_SOCK(iret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", cp);
+ info, "p", voidp_to_uint64(cp));
return iret;
}
iret = inet_networkp(cp);
AFTER_ORIGINAL_LIBC_SOCK(iret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", cp);
+ info, "p", voidp_to_uint64(cp));
return iret;
}
cret = inet_ntopp(af, src, dst, size);
AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "dppd", af, src, dst, size);
+ info, "dppd", af, voidp_to_uint64(src),
+ voidp_to_uint64(dst), size);
return cret;
}
ret = inet_ptonp(af, src, dst);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "dpp", af, src, dst);
+ info, "dpp", af, voidp_to_uint64(src),
+ voidp_to_uint64(dst));
return ret;
}
ret = getaddrinfop(node, service, hints, res);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pppp", node, service, hints, res);
+ info, "pppp",
+ voidp_to_uint64(node),
+ voidp_to_uint64(service),
+ voidp_to_uint64(hints),
+ voidp_to_uint64(res));
return ret;
}
freeaddrinfop(res);
AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", res);
+ info, "p", voidp_to_uint64(res));
}
const char *gai_strerror(int errcode) {
ret = gai_suspendp(list, nitems, timeout);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pdp", list, nitems, timeout);
+ info, "pdp", voidp_to_uint64(list), nitems,
+ voidp_to_uint64(timeout));
return ret;
}
ret = gai_errorp(req);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", req);
+ info, "p", voidp_to_uint64(req));
return ret;
}
ret = gai_cancelp(req);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", req);
+ info, "p", voidp_to_uint64(req));
return ret;
}
ret = getaddrinfo_ap(mode, list, nitems, sevp);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "dpdp", mode, list, nitems, sevp);
+ info, "dpdp", mode,
+ voidp_to_uint64(list), nitems,
+ voidp_to_uint64(sevp));
return ret;
}
//AFTER_ORIGINAL_NOSOCK(FD_API_OTHER, "pd", name, len);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pd", name, len);
+ info, "pd", voidp_to_uint64(name), len);
return ret;
}
ret = setdomainnamep(name, len);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pd", name, len);
+ info, "pd", voidp_to_uint64(name), len);
return ret;
}
ret = gethostnamep(name, len);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pd", name, len);
+ info, "pd", voidp_to_uint64(name), len);
return ret;
}
ret = sethostnamep(name, len);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pd", name, len);
+ info, "pd", voidp_to_uint64(name), len);
return ret;
}
ret = getnameinfop(sa, salen, host, hostlen, serv, servlen, flags);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pdpdpdd",
- sa, salen, host, hostlen, serv, servlen, flags);
+ info, "pdpdpdd",
+ voidp_to_uint64(sa), salen, voidp_to_uint64(host),
+ hostlen, voidp_to_uint64(serv), servlen, flags);
return ret;
}
pret = gethostbynamep(name);
AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", name);
+ info, "p", voidp_to_uint64(name));
return pret;
}
pret = gethostbyaddrp(addr, len, type);
AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pdd", addr, len, type);
+ info, "pdd", voidp_to_uint64(addr), len, type);
return pret;
}
herrorp(s);
AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", s);
+ info, "p", voidp_to_uint64(s));
}
const char *hstrerror(int err) {
pret = gethostbyname2p(name, af);
AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pd", name, af);
+ info, "pd", voidp_to_uint64(name), af);
return pret;
}
ret = gethostent_rp(rret, buf, buflen, result, h_errnop);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "ppdpp", rret, buf, buflen, result, h_errnop);
+ info, "ppdpp", voidp_to_uint64(rret),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result),
+ voidp_to_uint64(h_errnop));
return ret;
}
h_errnop);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pddppdpp",
- addr, len, type, rret, buf, buflen, result, h_errnop);
+ info, "pddppdpp",
+ voidp_to_uint64(addr), len, type,
+ voidp_to_uint64(rret), voidp_to_uint64(buf),
+ buflen, voidp_to_uint64(result),
+ voidp_to_uint64(h_errnop));
return ret;
}
ret = gethostbyname_rp(name, rret, buf, buflen, result, h_errnop);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pppdpp",
- name, rret, buf, buflen, result, h_errnop);
+ info, "pppdpp",
+ voidp_to_uint64(name),
+ voidp_to_uint64(rret),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result),
+ voidp_to_uint64(h_errnop));
return ret;
}
ret = gethostbyname2_rp(name, af, rret, buf, buflen, result, h_errnop);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pdppdpp",
- name, af, rret, buf, buflen, result, h_errnop);
+ info, "pdppdpp",
+ voidp_to_uint64(name), af, voidp_to_uint64(rret),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result),
+ voidp_to_uint64(h_errnop));
return ret;
}
pret = getservbynamep(name, proto);
AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pp", name, proto);
+ info, "pp", voidp_to_uint64(name),
+ voidp_to_uint64(proto));
return pret;
}
pret = getservbyportp(port, proto);
AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "dp", port, proto);
+ info, "dp", port, voidp_to_uint64(proto));
return pret;
}
ret = getservent_rp(result_buf, buf, buflen, result);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "ppdp", result_buf, buf, buflen, result);
+ info, "ppdp",
+ voidp_to_uint64(result_buf),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result));
return ret;
}
ret = getservbyname_rp(name, proto, result_buf, buf, buflen, result);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "ppppdp",
- name, proto, result_buf, buf, buflen, result);
+ info, "ppppdp",
+ voidp_to_uint64(name), voidp_to_uint64(proto),
+ voidp_to_uint64(result_buf), voidp_to_uint64(buf),
+ buflen, voidp_to_uint64(result));
return ret;
}
ret = getservbyport_rp(port, proto, result_buf, buf, buflen, result);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "dpppdp",
- port, proto, result_buf, buf, buflen, result);
+ info, "dpppdp",
+ port, voidp_to_uint64(proto),
+ voidp_to_uint64(result_buf),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result));
return ret;
}
pret = getnetbynamep(name);
AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", name);
+ info, "p", voidp_to_uint64(name));
return pret;
}
ret = getnetent_rp(result_buf, buf, buflen, result, h_errnop);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "ppdpp",
- result_buf, buf, buflen, result, h_errnop);
+ info, "ppdpp",
+ voidp_to_uint64(result_buf),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result),
+ voidp_to_uint64(h_errnop));
return ret;
}
ret = getnetbyname_rp(name, result_buf, buf, buflen, result, h_errnop);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pppdpp",
- name, result_buf, buf, buflen, result, h_errnop);
+ info, "pppdpp",
+ voidp_to_uint64(name),
+ voidp_to_uint64(result_buf),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result),
+ voidp_to_uint64(h_errnop));
return ret;
}
ret = getnetbyaddr_rp(net, type, result_buf, buf, buflen, result, h_errnop);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "ddppdpp",
- net, type, result_buf, buf, buflen, result, h_errnop);
+ info, "ddppdpp",
+ net, type, voidp_to_uint64(result_buf),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result),
+ voidp_to_uint64(h_errnop));
return ret;
}
pret = getprotobynamep(name);
AFTER_ORIGINAL_LIBC_SOCK(pret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", name);
+ info, "p", voidp_to_uint64(name));
return pret;
}
ret = getprotoent_rp(result_buf, buf, buflen, result);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "ppdp", result_buf, buf, buflen, result);
+ info, "ppdp", voidp_to_uint64(result_buf),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result));
return ret;
}
ret = getprotobyname_rp(name, result_buf, buf, buflen, result);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "pppdp", name, result_buf, buf, buflen, result);
+ info, "pppdp", voidp_to_uint64(name),
+ voidp_to_uint64(result_buf),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result));
return ret;
}
ret = getprotobynumber_rp(proto, result_buf, buf, buflen, result);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "dppdp", proto, result_buf, buf, buflen, result);
+ info, "dppdp", proto,
+ voidp_to_uint64(result_buf),
+ voidp_to_uint64(buf), buflen,
+ voidp_to_uint64(result));
return ret;
}
uret = if_nametoindexp(__ifname);
AFTER_ORIGINAL_LIBC_SOCK(uret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", __ifname);
+ info, "p", voidp_to_uint64(__ifname));
return uret;
}
cret = if_indextonamep(__ifindex, __ifname);
AFTER_ORIGINAL_LIBC_SOCK(cret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "dp", __ifindex, __ifname);
+ info, "dp", __ifindex,
+ voidp_to_uint64(__ifname));
return cret;
}
if_freenameindexp(__ptr);
AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", __ptr);
+ info, "p", voidp_to_uint64(__ptr));
}
int getifaddrs(struct ifaddrs **ifap) {
ret = getifaddrsp(ifap);
AFTER_ORIGINAL_LIBC_SOCK(ret, OBJ_DUMMY, 0, SOCKET_API_OTHER,
- info, "p", ifap);
+ info, "p", voidp_to_uint64(ifap));
return ret;
}
freeifaddrsp(ifa);
AFTER_ORIGINAL_LIBC_SOCK(NULL, OBJ_DUMMY, 0, SOCKET_API_OTHER, info,
- "p", ifa);
+ "p", voidp_to_uint64(ifa));
}
//To do
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_init,
ret, mutex, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "pp", mutex, attr);
+ SYNC_API_OTHER, "pp",
+ voidp_to_uint64(mutex), voidp_to_uint64(attr));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_destroy,
ret, mutex, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "p", mutex);
+ SYNC_API_OTHER, "p", voidp_to_uint64(mutex));
return ret;
}
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_mutex_lock,
- "p", mutex);
+ "p", voidp_to_uint64(mutex));
PACK_COMMON_END(0, 0, blockresult);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_mutex_lock,
- "p", mutex);
+ "p", voidp_to_uint64(mutex));
PACK_COMMON_END(ret, errno, blockresult);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_mutex_timedlock,
- "pp", mutex, abs_timeout);
+ "pp", voidp_to_uint64(mutex),
+ voidp_to_uint64(abs_timeout));
PACK_COMMON_END(0, 0, blockresult);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_mutex_timedlock,
- "pp", mutex, abs_timeout);
+ "pp", voidp_to_uint64(mutex),
+ voidp_to_uint64(abs_timeout));
PACK_COMMON_END(ret, errno, blockresult);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_trylock,
ret, mutex, SYNC_PTHREAD_MUTEX,
- SYNC_API_TRY_ACQUIRE, "p", mutex);
+ SYNC_API_TRY_ACQUIRE, "p",
+ voidp_to_uint64(mutex));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_unlock,
ret, mutex, SYNC_PTHREAD_MUTEX,
- SYNC_API_RELEASE, "p", mutex);
+ SYNC_API_RELEASE, "p",
+ voidp_to_uint64(mutex));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_init,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "p", attr);
+ SYNC_API_OTHER, "p",
+ voidp_to_uint64(attr));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_destroy,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "p", attr);
+ SYNC_API_OTHER, "p",
+ voidp_to_uint64(attr));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_getprioceiling,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "pp", attr, prioceiling);
+ SYNC_API_OTHER, "pp",
+ voidp_to_uint64(attr),
+ voidp_to_uint64(prioceiling));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_setprioceiling,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "pd", attr, prioceiling);
+ SYNC_API_OTHER, "pd", voidp_to_uint64(attr),
+ prioceiling);
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_getprotocol,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "pp", attr, protocol);
+ SYNC_API_OTHER, "pp",
+ voidp_to_uint64(attr),
+ voidp_to_uint64(protocol));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_setprotocol,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "pd", attr, protocol);
+ SYNC_API_OTHER, "pd", voidp_to_uint64(attr),
+ protocol);
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_getpshared,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "pp", attr, pshared);
+ SYNC_API_OTHER, "pp",
+ voidp_to_uint64(attr),
+ voidp_to_uint64(pshared));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_setpshared,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "pd", attr, pshared);
+ SYNC_API_OTHER, "pd", voidp_to_uint64(attr),
+ pshared);
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_gettype,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "pp", attr, type);
+ SYNC_API_OTHER, "pp",
+ voidp_to_uint64(attr),
+ voidp_to_uint64(type));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_settype,
ret, 0, SYNC_PTHREAD_MUTEX,
- SYNC_API_OTHER, "pd", attr, type);
+ SYNC_API_OTHER, "pd",
+ voidp_to_uint64(attr),
+ type);
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_init,
ret, cond, SYNC_PTHREAD_COND_VARIABLE,
- SYNC_API_OTHER, "pp", cond, attr);
+ SYNC_API_OTHER, "pp",
+ voidp_to_uint64(cond),
+ voidp_to_uint64(attr));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_destroy,
ret, cond, SYNC_PTHREAD_COND_VARIABLE,
- SYNC_API_OTHER, "p", cond);
+ SYNC_API_OTHER, "p",
+ voidp_to_uint64(cond));
return ret;
}
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_cond_wait,
- "pp", cond, mutex);
+ "pp",
+ voidp_to_uint64(cond),
+ voidp_to_uint64(mutex));
PACK_COMMON_END(0, 0, blockresult);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_cond_wait,
- "pp", cond, mutex);
+ "pp",
+ voidp_to_uint64(cond),
+ voidp_to_uint64(mutex));
PACK_COMMON_END(ret, errno, blockresult);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_cond_timedwait,
- "ppp", cond, mutex, abstime);
+ "ppp",
+ voidp_to_uint64(cond),
+ voidp_to_uint64(mutex),
+ voidp_to_uint64(abstime));
PACK_COMMON_END(0, 0, blockresult);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_cond_timedwait,
- "ppp", cond, mutex, abstime);
+ "ppp",
+ voidp_to_uint64(cond),
+ voidp_to_uint64(mutex),
+ voidp_to_uint64(abstime));
PACK_COMMON_END(ret, errno, blockresult);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
FLUSH_LOCAL_BUF();
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_signal,
ret, cond, SYNC_PTHREAD_COND_VARIABLE,
- SYNC_API_NOTIFY, "p", cond);
+ SYNC_API_NOTIFY, "p", voidp_to_uint64(cond));
return ret;
}
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_broadcast,
ret, cond, SYNC_PTHREAD_COND_VARIABLE,
- SYNC_API_NOTIFY_ALL, "p", cond);
+ SYNC_API_NOTIFY_ALL, "p", voidp_to_uint64(cond));
return ret;
}
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID__da_cleanup_handler,
- "p", data);
+ "p", voidp_to_uint64(data));
PACK_COMMON_END(0, 0, 1);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_STOP);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID__da_ThreadProc,
- "p", params);
+ "p", voidp_to_uint64(params));
PACK_COMMON_END(0, 0, 1);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_START);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID__da_ThreadProc,
- "p", params);
+ "p", voidp_to_uint64(params));
PACK_COMMON_END(ret, 0, 1);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_STOP);
FLUSH_LOCAL_BUF();
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_create,
ret, *thread, THREAD_API_START,
- "pppp", thread, attr, start_routine, arg);
+ "pppp",
+ voidp_to_uint64(thread),
+ voidp_to_uint64(attr),
+ voidp_to_uint64(start_routine),
+ voidp_to_uint64(arg));
return ret;
}
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_pthread_join,
- "xp", thread, retval);
+ "xp", (uint64_t)(thread), voidp_to_uint64(retval));
PACK_COMMON_END(0, 0, blockresult);
PACK_THREAD(thread, THREAD_PTHREAD, THREAD_API_WAIT_START);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_pthread_join,
- "xp", thread, retval);
+ "xp",
+ (uint64_t)(thread),
+ voidp_to_uint64(retval));
PACK_COMMON_END(ret, errno, blockresult);
PACK_THREAD(thread, THREAD_PTHREAD, THREAD_API_WAIT_END);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_pthread_exit,
- "p", retval);
+ "p", voidp_to_uint64(retval));
PACK_COMMON_END(0, 0, blockresult);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_EXIT);
FLUSH_LOCAL_BUF();
ret = pthread_cancelp(thread);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_cancel,
- ret, thread, THREAD_API_STOP, "x", thread);
+ ret, thread, THREAD_API_STOP, "x",
+ (uint64_t)(thread));
return ret;
}
ret = pthread_detachp(thread);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_detach,
- ret, thread, THREAD_API_OTHER, "x", thread);
+ ret, thread, THREAD_API_OTHER, "x",
+ (uint64_t)(thread));
return ret;
}
ret = pthread_equalp(t1, t2);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_equal,
- ret, t1, THREAD_API_OTHER, "xx", t1, t2);
+ ret, t1, THREAD_API_OTHER, "xx",
+ (uint64_t)(t1), (uint64_t)(t2));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_setcancelstate,
ret, pSelf, THREAD_API_OTHER,
- "dp", state, oldstate);
+ "dp", state, voidp_to_uint64(oldstate));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_setcanceltype,
ret, pSelf, THREAD_API_OTHER,
- "dp", type, oldtype);
+ "dp", type, voidp_to_uint64(oldtype));
return ret;
}
ret = pthread_attr_initp(attr);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_init,
- ret, thread, THREAD_API_OTHER, "p", attr);
+ ret, thread, THREAD_API_OTHER, "p",
+ voidp_to_uint64(attr));
return ret;
}
ret = pthread_attr_destroyp(attr);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_destroy,
- ret, thread, THREAD_API_OTHER, "p", attr);
+ ret, thread, THREAD_API_OTHER, "p",
+ voidp_to_uint64(attr));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getdetachstate,
ret, thread, THREAD_API_OTHER,
- "pp", attr, detachstate);
+ "pp", voidp_to_uint64(attr),
+ voidp_to_uint64(detachstate));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setdetachstate,
ret, thread, THREAD_API_OTHER,
- "pd", attr, detachstate);
+ "pd", voidp_to_uint64(attr),
+ detachstate);
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getstacksize,
ret, thread, THREAD_API_OTHER,
- "pp", attr, stacksize);
+ "pp", voidp_to_uint64(attr),
+ voidp_to_uint64(stacksize));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setstacksize,
ret, thread, THREAD_API_OTHER,
- "px", attr, stacksize);
+ "px", voidp_to_uint64(attr),
+ (uint64_t)(stacksize));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getstackaddr,
ret, thread, THREAD_API_OTHER,
- "pp", attr, stackaddr);
+ "pp", voidp_to_uint64(attr),
+ voidp_to_uint64(stackaddr));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setstackaddr,
ret, thread, THREAD_API_OTHER,
- "pp", attr, stackaddr);
+ "pp",
+ voidp_to_uint64(attr),
+ voidp_to_uint64(stackaddr));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getinheritsched,
ret, thread, THREAD_API_OTHER,
- "pp", attr, inheritsched);
+ "pp", voidp_to_uint64(attr),
+ voidp_to_uint64(inheritsched));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setinheritsched,
ret, thread, THREAD_API_OTHER,
- "pd", attr, inheritsched);
+ "pd", voidp_to_uint64(attr),
+ inheritsched);
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getschedparam,
ret, thread, THREAD_API_OTHER,
- "pp", attr, param);
+ "pp", voidp_to_uint64(attr),
+ voidp_to_uint64(param));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setschedparam,
ret, thread, THREAD_API_OTHER,
- "pp", attr, param);
+ "pp",
+ voidp_to_uint64(attr),
+ voidp_to_uint64(param));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getschedpolicy,
ret, thread, THREAD_API_OTHER,
- "pp", attr, policy);
+ "pp", voidp_to_uint64(attr),
+ voidp_to_uint64(policy));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setschedpolicy,
ret, thread, THREAD_API_OTHER,
- "pd", attr, policy);
+ "pd", voidp_to_uint64(attr),
+ policy);
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getguardsize,
ret, thread, THREAD_API_OTHER,
- "pp", attr, guardsize);
+ "pp", voidp_to_uint64(attr),
+ voidp_to_uint64(guardsize));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setguardsize,
ret, thread, THREAD_API_OTHER,
- "px", attr, guardsize);
+ "px", voidp_to_uint64(attr),
+ (uint64_t)(guardsize));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getscope,
ret, thread, THREAD_API_OTHER,
- "pp", attr, contentionscope);
+ "pp", voidp_to_uint64(attr),
+ voidp_to_uint64(contentionscope));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setscope,
ret, thread, THREAD_API_OTHER,
- "pd", attr, contentionscope);
+ "pd", voidp_to_uint64(attr), contentionscope);
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getstack,
ret, thread, THREAD_API_OTHER,
- "ppp", attr, stackaddr, stacksize);
+ "ppp", voidp_to_uint64(attr),
+ voidp_to_uint64(stackaddr),
+ voidp_to_uint64(stacksize));
return ret;
}
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setstack,
ret, thread, THREAD_API_OTHER,
- "ppx", attr, stackaddr, stacksize);
+ "ppx", voidp_to_uint64(attr),
+ voidp_to_uint64(stackaddr),
+ (uint64_t)(stacksize));
return ret;
}
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_UiApp__AddFrame_const_Tizen__Ui__Controls__Frame__frame_,
- "p", &frame);
+ "p", voidp_to_uint64(&frame));
PACK_COMMON_END(ret, 0, 0);
PACK_UICONTROL(parent);
PACK_UICONTROL(&frame);
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_UiApp__RemoveFrame_const_Tizen__Ui__Controls__Frame__frame_,
- "p", &frame);
+ "p", voidp_to_uint64(&frame));
PACK_COMMON_END(0, 0, 0);
PACK_UICONTROL(parent);
PACK_UICONTROL(&frame);
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_void_Control__SetName_const_Tizen__Base__String__name_,
- "p", &name);
+ "p", voidp_to_uint64(&name));
PACK_COMMON_END(0, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(parent);
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_Container__AddControl_const_Control__control_,
- "p", &control);
+ "p", voidp_to_uint64(&control));
PACK_COMMON_END(ret, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(&control);
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_Container__AddControl_Control__control_,
- "p", control);
+ "p", voidp_to_uint64(control));
PACK_COMMON_END(ret, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(control);
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_Container__RemoveControl_const_Control__control_,
- "p", &control);
+ "p", voidp_to_uint64(&control));
PACK_COMMON_END(0, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(&control);
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_Container__RemoveControl_Control__control_,
- "p", control);
+ "p", voidp_to_uint64(control));
PACK_COMMON_END(0, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(control);
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Construct_const_Tizen__Base__String__filePath__const_char__pOpenMode_,
"sp", absolutize_filepath(buffer, temp),
- pOpenMode);
+ voidp_to_uint64(pOpenMode));
PACK_COMMON_END(ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OPEN, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Construct_const_Tizen__Base__String__filePath__const_char__pOpenMode__const_Tizen__Base__ByteBuffer__secretKey_,
- "sp", temp, pOpenMode);
+ "sp", temp,
+ voidp_to_uint64(pOpenMode));
PACK_COMMON_END(ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OPEN, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Read_Tizen__Base__String__buffer_,
- "x", (unsigned long)&buffer);
+ "x", (uint64_t)(&buffer));
PACK_COMMON_END(0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_READ_START, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Read_Tizen__Base__String__buffer_,
- "x", (unsigned long)&buffer);
+ "x", (uint64_t)(&buffer));
PACK_COMMON_END(ret, ret, blockresult);
PACK_RESOURCE(nRead, (unsigned long)this, FD_API_READ_END, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Read_Tizen__Base__ByteBuffer__buffer_,
- "x", (unsigned long)&buffer);
+ "x", (uint64_t)(&buffer));
PACK_COMMON_END(0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_READ_START, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Read_Tizen__Base__ByteBuffer__buffer_,
- "x", (unsigned long)&buffer);
+ "x", (uint64_t)(&buffer));
PACK_COMMON_END(ret, ret, blockresult);
PACK_RESOURCE(nRead, (unsigned long)this, FD_API_READ_END, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_int_File__Read_void__buffer__int_length_,
- "xd", (unsigned long)buffer, length);
+ "xd", (uint64_t)(buffer), length);
PACK_COMMON_END(0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_READ_START, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_int_File__Read_void__buffer__int_length_,
- "xd", (unsigned long)buffer, length);
+ "xd", (uint64_t)(buffer), length);
PACK_COMMON_END(ret, res, blockresult);
PACK_RESOURCE(nRead, (unsigned long)this, FD_API_READ_END, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Seek_FileSeekPosition_position__long_offset_,
- "sx", temp_pos, offset);
+ "sx", temp_pos, (uint64_t)(offset));
PACK_COMMON_END(ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OTHER, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_void__buffer__int_length_,
- "xd", (unsigned long)buffer, length);
+ "xd", (uint64_t)(buffer), length);
PACK_COMMON_END(0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_WRITE_START, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_void__buffer__int_length_,
- "xd", (unsigned long)buffer, length);
+ "xd", (uint64_t)(buffer), length);
PACK_COMMON_END(ret, ret, blockresult);
PACK_RESOURCE(nWritten, (unsigned long)this, FD_API_WRITE_END, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_Tizen__Base__ByteBuffer__buffer_,
- "x", (unsigned long)&buffer);
+ "x", (uint64_t)(&buffer));
PACK_COMMON_END(0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_WRITE_START, size, temp);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_Tizen__Base__ByteBuffer__buffer_,
- "x", (unsigned long)&buffer);
+ "x", (uint64_t)(&buffer));
PACK_COMMON_END(ret, ret, blockresult);
PACK_RESOURCE(nWritten, (unsigned long)this, FD_API_WRITE_END, size, temp);
FLUSH_LOCAL_BUF();
WcharToChar(temp2, hostAddr.GetPointer());
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::Construct", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_SESSION_CONSTRUCT,
- info, "dssxd",
- sessionMode, temp1, temp2, (unsigned int)&pCommonHeader, flag);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_SESSION_CONSTRUCT,
+ info, "dssxd",
+ sessionMode, temp1, temp2,
+ voidp_to_uint64(&pCommonHeader), flag);
return retVal;
}
WcharToChar(temp2, hostAddr.GetPointer());
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::Construct", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_SESSION_CONSTRUCT,
- info, "xdssxd",
- (unsigned int)&netConnection, sessionMode, temp1, temp2, (unsigned int)&pCommonHeader, flag);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_SESSION_CONSTRUCT,
+ info, "xdssxd",
+ voidp_to_uint64(&netConnection), sessionMode,
+ temp1, temp2,
+ voidp_to_uint64(&pCommonHeader), flag);
return retVal;
}
if (retVal == NULL)
newerrno = 1;
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::OpenTransactionN", VT_PTR, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_TRANSACTION_OPEN,
- info, "x", (unsigned int)&auth);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_TRANSACTION_OPEN,
+ info, "x", voidp_to_uint64(&auth));
return retVal;
}
retVal = (this->*CancelTransactionp)(httpTransaction);
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::CancelTransaction", VT_ULONG,
- retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_TRANSACTION_CLOSE, info, "x",
- (unsigned int)&httpTransaction);
+ retVal, (unsigned int)this,
+ (unsigned int)this,
+ HTTP_API_TRANSACTION_CLOSE, info, "x",
+ voidp_to_uint64(&httpTransaction));
return retVal;
}
retVal = (this->*CloseTransactionp)(httpTransaction);
AFTER_ORIGINAL_TIZEN_SOCK("HttpSession::CloseTransaction", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_TRANSACTION_CLOSE,
- info, "x", (unsigned int)&httpTransaction);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_TRANSACTION_CLOSE,
+ info, "x", voidp_to_uint64(&httpTransaction));
return retVal;
}
retVal = (this->*AddHttpTransactionListenerp)(listener);
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::AddHttpTransactionListener",
- VT_ULONG, retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, info, "x", (unsigned int)&listener);
+ VT_ULONG, retVal, (unsigned int)this,
+ (unsigned int)this,
+ HTTP_API_OTHER, info,
+ "x", voidp_to_uint64(&listener));
return retVal;
}
retVal = (this->*RemoveHttpTransactionListenerp)(listener);
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::RemoveHttpTransactionListener",
- VT_ULONG, retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, info, "x", (unsigned int)&listener);
+ VT_ULONG, retVal, (unsigned int)this,
+ (unsigned int)this,
+ HTTP_API_OTHER, info, "x",
+ voidp_to_uint64(&listener));
return retVal;
}
retVal = (this->*SetHttpProgressListenerp)(listener);
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::SetHttpProgressListener",
- VT_ULONG, retVal, (unsigned int)this, (unsigned int)this,
- HTTP_API_OTHER, info, "x", (unsigned int)&listener);
+ VT_ULONG, retVal, (unsigned int)this,
+ (unsigned int)this,
+ HTTP_API_OTHER, info, "x",
+ voidp_to_uint64(&listener));
return retVal;
}
retVal = (this->*SetUserObjectp)(pUserData);
AFTER_ORIGINAL_TIZEN_SOCK("HttpTransaction::SetUserObject", VT_ULONG,
- retVal, (unsigned int)this, (unsigned int)this,
+ retVal, (unsigned int)this,
+ (unsigned int)this,
HTTP_API_OTHER, info, "x",
- (unsigned int)&pUserData);
+ voidp_to_uint64(&pUserData));
return retVal;
}
info.msg_pack_size = nSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetCustomMethod", VT_ULONG,
- retVal, (unsigned int)this, (unsigned int)this,
+ retVal, (unsigned int)this,
+ (unsigned int)this,
HTTP_API_REQUEST, info, "x",
- (unsigned int)&method);
+ voidp_to_uint64(&method));
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::WriteBody", VT_ULONG, retVal,
(unsigned int)this, (unsigned int)this,
HTTP_API_REQUEST, info, "x",
- (unsigned int)&body);
+ voidp_to_uint64(&body));
delete [] out;
return retVal;
}
retVal = (this->*SetEntityp)(entity);
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetEntity", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
- "x", (unsigned int)& entity);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info,
+ "x", voidp_to_uint64(&entity));
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("HttpRequest::SetCookie", VT_ULONG, retVal,
(unsigned int)this, (unsigned int)this,
HTTP_API_REQUEST, info, "x",
- (unsigned int)&cookieString);
+ voidp_to_uint64(&cookieString));
return retVal;
}
info.msg_total_size = bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::WriteBody", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_RESPONSE,
- info, "x", (unsigned int)&body);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_RESPONSE,
+ info, "x", voidp_to_uint64(&body));
delete out;
return retVal;
}
retVal = (this->*Readp)(headerLen, bodyLen, rcvHeaderLen, rcvBodyLen);
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::Read", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
- "ddxx",
- headerLen, bodyLen, (unsigned int)&rcvHeaderLen, (unsigned int)&rcvBodyLen);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info,
+ "ddxx", headerLen, bodyLen,
+ voidp_to_uint64(&rcvHeaderLen),
+ voidp_to_uint64(&rcvBodyLen));
return retVal;
}
retVal = (this->*SetCookiep)(pHeader);
AFTER_ORIGINAL_TIZEN_SOCK("HttpResponse::SetCookie", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, HTTP_API_OTHER, info,
- "x", (unsigned int)&pHeader);
+ (unsigned int)this, (unsigned int)this,
+ HTTP_API_OTHER, info,
+ "x", voidp_to_uint64(&pHeader));
return retVal;
}
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE,
API_ID_result_UiApp__Execute_UiAppInstanceFactory_pUiAppFactory__const_IList__pArguments_,
- "pp", pUiAppFactory, pArguments);
+ "pp", (uint64_t)(pUiAppFactory),
+ voidp_to_uint64(pArguments));
PACK_COMMON_END(ret, 0, 0);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE,
API_ID_void__AppImpl__OnTerminate_void__user_data_,
- "p", user_data);
+ "p", voidp_to_uint64(user_data));
PACK_COMMON_END(0, 0, 0);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE,
API_ID_void__AppInfo__SetAppState_AppState_appState_,
- "p", appState);
+ "p", (uint64_t)(appState));
PACK_COMMON_END(0, 0, 0);
FLUSH_LOCAL_BUF();
}
AFTER_ORIGINAL_TIZEN_SOCK("Socket::Construct", VT_ULONG, retVal,
(unsigned int)this, (unsigned int)this, SOCKET_API_FD_OPEN,
info, "xddd",
- (unsigned int)&netConnection, addressFamily, socketType, protocol);
+ (uint64_t)(&netConnection), addressFamily, socketType, protocol);
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::Receive", VT_NULL, NULL,
(unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START,
- info, "x", (unsigned int)&buffer);
+ info, "x", (uint64_t)(&buffer));
pret = (this->*Receivep)(buffer);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::Receive", VT_ULONG, pret,
(unsigned int)this, (unsigned int)this, SOCKET_API_RECV_END,
- info, "x", (unsigned int)&buffer);
+ info, "x", (uint64_t)(&buffer));
return pret;
}
_ZNK5Tizen3Net7Sockets6Socket11ReceiveFromEPviRNS0_11NetEndPointERi,
Receivep);
- AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::Receive", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START,
- info, "xdx",
- (unsigned int)&pBuffer, length, rcvdLength);
+ AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::Receive", VT_NULL,
+ NULL,
+ (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_RECV_START,
+ info, "xdx",
+ (uint64_t)(&pBuffer),
+ length,
+ (uint64_t)(rcvdLength));
pret = (this->*Receivep)(pBuffer, length, rcvdLength);
info.msg_buf = (char *)pBuffer;
info.msg_total_size = rcvdLength;
info.msg_pack_size = rcvdLength > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : rcvdLength;
- AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::Receive", VT_ULONG, pret,
- (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_END,
- info, "xdx", (unsigned int)&pBuffer, length, rcvdLength);
+ AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::Receive", VT_ULONG,
+ pret,
+ (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_RECV_END,
+ info, "xdx",
+ (uint64_t)(&pBuffer), length,
+ (uint64_t)(rcvdLength));
return pret;
}
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::ReceiveFrom", VT_NULL,
NULL, (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START,
- info, "xs", (unsigned int)&buffer, temp);
+ info, "xs", (uint64_t)(&buffer), temp);
pret = (this->*ReceiveFromp)(buffer, remoteEndPoint);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::ReceiveFrom", VT_ULONG,
pret, (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_END,
- info, "xs", (unsigned int)&buffer, temp);
+ info, "xs", (uint64_t)(&buffer), temp);
delete [] out;
return pret;
}
info.host_port = remoteEndPoint.GetPort();
iv4PeerAddr->GetAddress(&info.host_ip);
- AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::ReceiveFrom", VT_NULL,
- NULL, (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_START,
- info, "xdsx",
- (unsigned int)&pBuffer, length, temp, rcvdLength);
+ AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::ReceiveFrom",
+ VT_NULL,
+ NULL, (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_RECV_START,
+ info, "xdsx",
+ (uint64_t)(&pBuffer),
+ length, temp,
+ (uint64_t)(rcvdLength));
pret = (this->*ReceiveFromp)(pBuffer, length, remoteEndPoint, rcvdLength);
info.msg_pack_size = length > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : length;
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::ReceiveFrom", VT_ULONG,
- pret, (unsigned int)this, (unsigned int)this, SOCKET_API_RECV_END,
- info, "xdsx", (unsigned int)&pBuffer, length, temp, rcvdLength);
+ pret, (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_RECV_END,
+ info, "xdsx",
+ (uint64_t)(&pBuffer),
+ length, temp,
+ (uint64_t)(rcvdLength));
return pret;
}
_ZN5Tizen3Net7Sockets6Socket4SendERNS_4Base10ByteBufferE, Sendp);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::Send", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START,
- info, "x", (unsigned int)&buffer);
+ (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_SEND_START,
+ info, "x",
+ (uint64_t)(&buffer));
pret = (this->*Sendp)(buffer);
int bufferSize = buffer.GetLimit();
info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::Send", VT_ULONG, pret,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_END,
- info, "x", (unsigned int)&buffer);
+ (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_SEND_END,
+ info, "x",
+ (uint64_t)(&buffer));
delete [] out;
return pret;
}
Sendp);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::Send", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START,
- info, "xdx",
- (unsigned int)&pBuffer, length, (unsigned int)&sentLength);
+ (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_SEND_START,
+ info, "xdx",
+ (uint64_t)(&pBuffer),
+ length,
+ (uint64_t)(&sentLength));
pret = (this->*Sendp)(pBuffer, length, sentLength);
info.msg_pack_size = length > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : length;
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::Send", VT_ULONG, pret,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_END,
- info, "xdx", (unsigned int)&pBuffer, length, (unsigned int)&sentLength);
+ (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_SEND_END,
+ info, "xdx",
+ (uint64_t)(&pBuffer), length,
+ (uint64_t)(&sentLength));
return pret;
iv4PeerAddr->GetAddress(&info.host_ip);
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_START("Socket::SendTo", VT_NULL, NULL,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_START,
- info, "xs", (unsigned int)&buffer, temp);
+ (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_SEND_START,
+ info, "xs",
+ (uint64_t)(&buffer),
+ temp);
pret = (this->*SendTop)(buffer, remoteEndPoint);
info.msg_pack_size = bufferSize > SOCKET_SEND_SIZE ? SOCKET_SEND_SIZE : bufferSize;
AFTER_ORIGINAL_TIZEN_SOCK_WAIT_FUNC_END("Socket::SendTo", VT_ULONG, pret,
- (unsigned int)this, (unsigned int)this, SOCKET_API_SEND_END,
- info, "xs", (unsigned int)&buffer, temp);
+ (unsigned int)this,
+ (unsigned int)this,
+ SOCKET_API_SEND_END,
+ info, "xs",
+ (uint64_t)(&buffer),
+ temp);
delete [] out;
return pret;
}
retVal = (this->*Ioctlp)(cmd, value);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::Ioctl", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
- "dx", cmd, (unsigned int) &value);
+ (unsigned int)this, (unsigned int)this,
+ SOCKET_API_OTHER, info,
+ "dx", cmd, (uint64_t)(&value));
return retVal;
}
retVal = (this->*SetSockOptp)(optionLevel, optionName, optionValue);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::SetSockOpt", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
- "ddx",
- optionLevel, optionName, (unsigned int) &optionValue);
+ (unsigned int)this, (unsigned int)this,
+ SOCKET_API_OTHER, info,
+ "ddx", optionLevel, optionName,
+ (uint64_t)(&optionValue));
return retVal;
}
retVal = (this->*SetSockOptp)(optionLevel, optionName, optionValue);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::SetSockOpt", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
- "ddx",
- optionLevel, optionName, (unsigned int) &optionValue);
+ (unsigned int)this, (unsigned int)this,
+ SOCKET_API_OTHER, info,
+ "ddx", optionLevel, optionName,
+ (uint64_t)(&optionValue));
return retVal;
}
retVal = (this->*GetSockOptp)(optionLevel, optionName, optionValue);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::GetSockOpt", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
- "ddx",
- optionLevel, optionName, (unsigned int) &optionValue);
+ (unsigned int)this, (unsigned int)this,
+ SOCKET_API_OTHER, info,
+ "ddx", optionLevel, optionName,
+ (uint64_t)(&optionValue));
return retVal;
}
retVal = (this->*GetSockOptp)(optionLevel, optionName, optionValue);
AFTER_ORIGINAL_TIZEN_SOCK("Socket::GetSockOpt", VT_ULONG, retVal,
- (unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
- "ddx",
- optionLevel, optionName, (unsigned int) &optionValue);
+ (unsigned int)this, (unsigned int)this,
+ SOCKET_API_OTHER, info,
+ "ddx", optionLevel, optionName,
+ (uint64_t)(&optionValue));
return retVal;
}
AFTER_ORIGINAL_TIZEN_SOCK("Socket::RemoveSocketListener", VT_ULONG, retVal,
(unsigned int)this, (unsigned int)this, SOCKET_API_OTHER, info,
- "x", (unsigned int) &listener);
+ "x", (uint64_t)(&listener));
return retVal;
}
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Semaphore__Acquire_long_timeout_,
- "x", timeout);
+ "x", (uint64_t)(timeout));
PACK_COMMON_END(0, 0, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_SEMAPHORE, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Semaphore__Acquire_long_timeout_,
- "x", timeout);
+ "x", (uint64_t)(timeout));
PACK_COMMON_END(ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_SEMAPHORE, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_void___ThreadImpl__ThreadProc_void__params_,
- "p", params);
+ "p", voidp_to_uint64(params));
PACK_COMMON_END((unsigned int)pSelf, 0, blockresult);
PACK_THREAD((unsigned int)pThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_INTERNAL_START);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_void___ThreadImpl__ThreadProc_void__params_,
- "p", params);
+ "p", voidp_to_uint64(params));
PACK_COMMON_END((unsigned int)pSelf, 0, blockresult);
PACK_THREAD((unsigned int)pThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_INTERNAL_STOP);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Sleep_long_milliSeconds_,
- "x", milliSeconds);
+ "x", (uint64_t)(milliSeconds));
PACK_COMMON_END(0, 0, blockresult);
PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_START);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Yield_void_,
- "x", milliSeconds);
+ "x", (uint64_t)(milliSeconds));
PACK_COMMON_END(ret, ret, blockresult);
PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_END);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Construct_ThreadType_threadType__long_stackSize__ThreadPriority_priority_,
- "dxd", threadType, stackSize, priority);
+ "dxd", threadType, (uint64_t)(stackSize),
+ priority);
PACK_COMMON_END(ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Construct_long_stackSize__ThreadPriority_priority_,
- "xd", stackSize, priority);
+ "xd", (uint64_t)(stackSize), priority);
PACK_COMMON_END(ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Construct_const_Tizen__Base__String__name__long_stackSize__ThreadPriority_priority_,
- "sxd", temp, stackSize, priority);
+ "sxd", temp, (uint64_t)(stackSize), priority);
PACK_COMMON_END(ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Construct_const_Tizen__Base__String__name__ThreadType_threadType__long_stackSize__ThreadPriority_priority_,
- "sdxd", temp, threadType, stackSize, priority);
+ "sdxd", temp, threadType,
+ (uint64_t)(stackSize), priority);
PACK_COMMON_END(ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Construct_IRunnable__target__long_stackSize__ThreadPriority_priority_,
- "xxd", (unsigned int) &target, stackSize, priority);
+ "xxd", (uint64_t)(&target),
+ (uint64_t)(stackSize), priority);
PACK_COMMON_END(ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Construct_const_Tizen__Base__String__name__IRunnable__target__long_stackSize__ThreadPriority_priority_,
- "sxxd", temp, (unsigned int) &target, stackSize, priority);
+ "sxxd", temp, (uint64_t)(&target),
+ (uint64_t)(stackSize), priority);
PACK_COMMON_END(ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_EventDrivenThread__Construct_long_stackSize__ThreadPriority_priority_,
- "xd", stackSize, priority);
+ "xd", (uint64_t)(stackSize), priority);
PACK_COMMON_END(ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_EventDrivenThread__Construct_const_Tizen__Base__String__name__long_stackSize__ThreadPriority_priority_,
- "sx", temp, stackSize);
+ "sx", temp, (uint64_t)(stackSize));
PACK_COMMON_END(ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SCENE,
API_ID_void_SceneManagerEventListener__OnSceneTransitionCompleted_const_SceneId__previousSceneId__const_SceneId__currentSceneId_,
- "pp", &previousSceneId, ¤tSceneId);
+ "pp",
+ voidp_to_uint64(&previousSceneId),
+ voidp_to_uint64(¤tSceneId));
PACK_COMMON_END(0, 0, 0);
PACK_SCENE(scene_name, formid, pform, panelid, ppanel, transition, user);
FLUSH_LOCAL_BUF();
projects / platform / core / system / swap-probe.git / commitdiff