It's a draft.
Now new packing function calls are commented.
TODO: add correct return type packing to
PACK_COMMON_END and PACK_RETURN_END calls
in probe_socket/ and probe_tizenapi/
Change-Id: I1238b2a22530620f53e16a18cebd379639f58463
Signed-off-by: Anastasia Lyupa <a.lyupa@samsung.com>
PACK_COMMON_BEGIN(MSG_PROBE_CUSTOM,
API_ID__chart_timerThread,
"", 0);
- PACK_COMMON_END(0, 0, 2);
+ PACK_COMMON_END('p', 0, 0, 2);
PACK_CUSTOM(cur->series_handle, 0, "", 0, value);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_CUSTOM,
API_ID_da_mark,
"dp", color, voidp_to_uint64(mark_text));
- PACK_COMMON_END(0, 0, 2);
+ PACK_COMMON_END('v', 0, 0, 2);
PACK_CUSTOM(0, 0, mark_text, color, 0.0f);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_CUSTOM,
API_ID_da_create_chart,
"p", voidp_to_uint64(chart_name));
- PACK_COMMON_END(ret, 0, 2);
+ PACK_COMMON_END('d', ret, 0, 2);
PACK_CUSTOM(0, 0, chart_name, 0, 0.0f);
FLUSH_LOCAL_BUF();
API_ID_da_create_series,
"dpdd", charthandle, voidp_to_uint64(seriesname),
type, color);
- PACK_COMMON_END(ret, 0, 2);
+ PACK_COMMON_END('d', ret, 0, 2);
PACK_CUSTOM(charthandle, type, seriesname, color, 0.0f);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_CUSTOM,
API_ID_da_log,
"df", series_handle, uservalue);
- PACK_COMMON_END(0, 0, 2);
+ PACK_COMMON_END('v', 0, 0, 2);
PACK_CUSTOM(series_handle, 0, "", 0, uservalue);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SCREENSHOT, API_ID_captureScreen, "", 0);
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('d', 0, 0, 0);
PACK_SCREENSHOT(dstpath, getOrientation());
FLUSH_LOCAL_BUF();
}
return to;
}
+static char __attribute__((used)) *pack_value_by_type(char *to, const char t, va_list *args)
+{
+ uint8_t c;
+ uint32_t d;
+ uint64_t x;
+ uint64_t p;
+ float f;
+ double w;
+ char *s;
+ int n;
+
+ *to++ = t;
+
+ switch (t) {
+ case 'c':
+ c = (uint8_t)va_arg(*args, uint32_t);
+ memcpy(to, &c, sizeof(c));
+ to += sizeof(c);
+ break;
+ case 'd':
+ d = va_arg(*args, uint32_t);
+ memcpy(to, &d, sizeof(d));
+ to += sizeof(d);
+ break;
+ case 'x':
+ x = 0; // real value may be less then uint64_t
+ x = (unsigned long)(uint64_t)va_arg(*args, uint64_t);
+ memcpy(to, &x, sizeof(x));
+ to += sizeof(x);
+ break;
+ case 'p':
+ p = 0; // real value may be less then uint64_t
+ p = (unsigned long)(uintptr_t)va_arg(*args, uint64_t);
+ memcpy(to, &p, sizeof(p));
+ to += sizeof(p);
+ break;
+ case 'f':
+ f = (float)va_arg(*args, double);
+ memcpy(to, &f, sizeof(f));
+ to += sizeof(f);
+ break;
+ case 'w':
+ w = va_arg(*args, double);
+ memcpy(to, &w, sizeof(w));
+ to += sizeof(w);
+ break;
+ case 's':
+ s = va_arg(*args, char *);
+ n = strlen(s) + 1;
+ strncpy(to, s, n);
+ to += n;
+ break;
+ case 'v':
+ case 'n':
+ break;
+ default:
+ to--;
+ break;
+ }
+
+ return to;
+}
+
static char __attribute__((used)) *pack_args(char *to, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
- uint8_t c;
- uint32_t d;
- uint64_t x;
- uint64_t p;
- float f;
- double w;
- char *s;
- int n;
+ for (t = fmt; *t != '\0'; t++)
+ to = pack_value_by_type(to, *t, &args);
- for (t = fmt; *t != '\0'; t++) {
- switch (*t) {
- case 'c':
- c = (uint8_t)va_arg(args, uint32_t);
- *to++ = *t;
- memcpy(to, &c, sizeof(c));
- to += sizeof(c);
- break;
- case 'd':
- d = va_arg(args, uint32_t);
- *to++ = *t;
- memcpy(to, &d, sizeof(d));
- to += sizeof(d);
- break;
- case 'x':
- x = 0; // real value may be less then uint64_t
- x = (unsigned long)(uint64_t)va_arg(args, uint64_t);
- *to++ = *t;
- memcpy(to, &x, sizeof(x));
- to += sizeof(x);
- break;
- case 'p':
- p = 0; // real value may be less then uint64_t
- p = (unsigned long)(uintptr_t)va_arg(args, uint64_t);
- *to++ = *t;
- memcpy(to, &p, sizeof(p));
- to += sizeof(p);
- break;
- case 'f':
- f = (float)va_arg(args, double);
- *to++ = *t;
- memcpy(to, &f, sizeof(f));
- to += sizeof(f);
- break;
- case 'w':
- w = va_arg(args, double);
- *to++ = *t;
- memcpy(to, &w, sizeof(w));
- to += sizeof(w);
- break;
- case 's':
- s = va_arg(args, char *);
- *to++ = *t;
- n = strlen(s) + 1;
- strncpy(to, s, n);
- to += n;
- break;
- default:
- break;
- }
- }
+ va_end(args);
+ return to;
+}
+
+static char __attribute__((used)) *pack_ret(char *to, char ret_type, ...)
+{
+ va_list args;
+
+ va_start(args, ret_type);
+ to = pack_value_by_type(to, ret_type, &args);
va_end(args);
return to;
RET_PTR = BUF_PTR; \
} while (0)
-#define PACK_COMMON_END(ret, errn, intern_call) \
- do { \
- BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)(ret)); \
- BUF_PTR = pack_int64(BUF_PTR, (uint64_t)errn); \
- BUF_PTR = pack_int32(BUF_PTR, (uint32_t)intern_call); \
- BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)CALLER_ADDRESS); \
- BUF_PTR = pack_int32(BUF_PTR, 0); \
- BUF_PTR = pack_int32(BUF_PTR, 0); \
+#define PACK_COMMON_END(ret_type, ret, errn, intern_call) \
+ do { \
+ /*BUF_PTR = pack_ret(BUF_PTR, ret_type, (uintptr_t)ret);*/ \
+ BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)(ret)); \
+ BUF_PTR = pack_int64(BUF_PTR, (uint64_t)errn); \
+ BUF_PTR = pack_int32(BUF_PTR, (uint32_t)intern_call); \
+ BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)CALLER_ADDRESS); \
+ BUF_PTR = pack_int32(BUF_PTR, 0); \
+ BUF_PTR = pack_int32(BUF_PTR, 0); \
} while (0)
-#define PACK_RETURN_END(ret) \
+#define PACK_RETURN_END(ret_type, ret) \
+ /*RET_PTR = pack_ret(RET_PTR, ret_type, (uintptr_t)ret);*/ \
RET_PTR = pack_int64(RET_PTR, (uintptr_t)(ret));
#define PACK_MEMORY(size, memory_api_type, addr) \
/* p = PACK_COMMON_BEGIN(p, 42, "cdxpfws", 'a', 10, (uint64_t)80, */
/* (uint64_t)0, 0.19, 0.33, "hello!"); */
-/* p = PACK_COMMON_END(p, 0); */
+/* p = PACK_COMMON_END('p', p, 0); */
/* int fd = creat("out.bin", 0644); */
/* if (fd == -1) { */
if(postBlockBegin(blockresult)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
- PACK_COMMON_END(RETVALUE, errno, blockresult);
+ PACK_COMMON_END('p', RETVALUE, errno, blockresult);
#define POST_PROBEBLOCK_END() \
FLUSH_LOCAL_BUF(); \
app_event_callback_s gAppCallback;
-#define PACK_ORIGINAL_APPFWCYCLE(API_ID, RVAL, INPUTFORMAT, ...) \
+#define PACK_ORIGINAL_APPFWCYCLE(API_ID, RTYPE, RVAL, INPUTFORMAT, ...) \
newerrno = errno; \
do { \
if(postBlockBegin(blockresult)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult); \
FLUSH_LOCAL_BUF(); \
postBlockEnd(); \
} \
bret = gAppCallback.create(user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_create, bret, "p",
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_create, 'b', bret, "p",
voidp_to_uint64(user_data));
return bret;
gAppCallback.terminate(user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_terminate, 0, "p",
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_terminate, 'v', 0, "p",
voidp_to_uint64(user_data));
}
gAppCallback.pause(user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_pause, 0, "p",
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_pause, 'v', 0, "p",
voidp_to_uint64(user_data));
}
gAppCallback.resume(user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_resume, 0, "p",
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_resume, 'v', 0, "p",
voidp_to_uint64(user_data));
}
gAppCallback.service(service, user_data);
- PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_service, 0, "dp",
+ PACK_ORIGINAL_APPFWCYCLE(API_ID__dalc_app_service, 'v', 0, "dp",
(unsigned int)service,
voidp_to_uint64(user_data));
}
PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT,
API_ID_on_orientation_changed,
"dd", angle, (uint32_t)capi);
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('v', 0, 0, 0);
PACK_UIEVENT(_EVENT_ORIENTATION, 0, 0, 0, "", convert_angle(external_angle));
FLUSH_LOCAL_BUF();
}
setProbePoint(&probeInfo); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, API_ID, "p", voidp_to_uint64(_ARGDETECTOR)); \
- PACK_COMMON_END(0, 0, 0); \
+ PACK_COMMON_END('v', 0, 0, 0); \
sprintf(info1_str, "%d", _INFO1); \
PACK_UIEVENT(_EVENT_GESTURE, _GESTURETYPE, _X, _Y, info1_str, _INFO2); \
FLUSH_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, API_ID, "pdp", \
voidp_to_uint64(_ARGDATA), _ARGTYPE, \
voidp_to_uint64(_ARGEVENT)); \
- PACK_COMMON_END(0, 0, 0); \
+ PACK_COMMON_END('c', 0, 0, 0); \
PACK_UIEVENT(_EVENTTYPE, _DETAILTYPE, _X, _Y, _KEYCODE, _EXTRA); \
FLUSH_LOCAL_BUF(); \
} while (0)
* only about regular files or sockets, so this logic implemented in macro.
* Watch out when reusing it somewhere else
*/
-#define AFTER_PACK_ORIGINAL_FD(API_ID, RVAL, SIZE, FD, APITYPE, INPUTFORMAT, ...) \
+#define AFTER_PACK_ORIGINAL_FD(API_ID, RTYPE, RVAL, SIZE, FD, APITYPE, INPUTFORMAT, ...) \
POST_PACK_PROBEBLOCK_BEGIN(); \
_fstatret = fstat(FD, &_statbuf); \
if (stat_regular_or_socket_p(&_statbuf)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult); \
POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, FD, APITYPE); \
} \
POST_PACK_PROBEBLOCK_END()
-#define AFTER_PACK_ORIGINAL_NOFD(API_ID, RVAL, SIZE, APITYPE, INPUTFORMAT, ...) \
+#define AFTER_PACK_ORIGINAL_NOFD(API_ID, RTYPE, RVAL, SIZE, APITYPE, INPUTFORMAT, ...) \
POST_PACK_PROBEBLOCK_BEGIN(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult); \
POST_PACK_PROBEBLOCK_MIDDLE_NOFD(SIZE, APITYPE); \
POST_PACK_PROBEBLOCK_END()
-#define AFTER_PACK_ORIGINAL_FILEP(API_ID, RVAL, SIZE, FILEP, APITYPE, INPUTFORMAT, ...) \
+#define AFTER_PACK_ORIGINAL_FILEP(API_ID, RTYPE, RVAL, SIZE, FILEP, APITYPE, INPUTFORMAT, ...) \
POST_PACK_PROBEBLOCK_BEGIN(); \
GET_FD_FROM_FILEP(FILEP); \
if(_fd != -1) { \
} \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult); \
POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, _fd, APITYPE); \
POST_PACK_PROBEBLOCK_END()
{
return S_ISREG(buf->st_mode) || S_ISSOCK(buf->st_mode);
}
-#define BEFORE_ORIGINAL_START_END_FD(API_ID, FUNCNAME, LIBNAME, FD, APITYPE, INPUTFORMAT, ...) \
+#define BEFORE_ORIGINAL_START_END_FD(API_ID, RTYPE, FUNCNAME, LIBNAME, FD, APITYPE, INPUTFORMAT, ...) \
DECLARE_VARIABLE_FD; \
GET_REAL_FUNC(FUNCNAME, LIBNAME); \
PRE_PROBEBLOCK_BEGIN(); \
DEFINE_FILESIZE_FD(fd); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(0, 0, blockresult); \
+ PACK_COMMON_END(RTYPE, 0, 0, blockresult); \
PACK_RESOURCE(0, FD, APITYPE, _filesize, _filepath); \
FLUSH_LOCAL_BUF(); \
} \
PRE_PROBEBLOCK_END();
-#define AFTER_ORIGINAL_START_END_FD(API_ID, RVAL, SIZE, FD, APITYPE, INPUTFORMAT, ...) \
+#define AFTER_ORIGINAL_START_END_FD(API_ID, RTYPE, RVAL, SIZE, FD, APITYPE, INPUTFORMAT, ...) \
POST_PACK_PROBEBLOCK_BEGIN(); \
setProbePoint(&probeInfo); \
_fstatret = fstat(FD, &_statbuf); \
if (stat_regular_or_socket_p(&_statbuf)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult); \
PACK_RESOURCE(SIZE, FD, APITYPE, _filesize, _filepath); \
FLUSH_LOCAL_BUF(); \
} \
-#define BEFORE_ORIGINAL_START_END_NOFD(API_ID, FUNCNAME, LIBNAME, APITYPE, INPUTFORMAT, ...) \
+#define BEFORE_ORIGINAL_START_END_NOFD(API_ID, RTYPE, FUNCNAME, LIBNAME, APITYPE, INPUTFORMAT, ...) \
DECLARE_VARIABLE_FD; \
GET_REAL_FUNC(FUNCNAME, LIBNAME); \
PRE_PROBEBLOCK_BEGIN(); \
DEFINE_FILESIZE_0(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(0, 0, blockresult); \
+ PACK_COMMON_END(RTYPE, 0, 0, blockresult); \
POST_PACK_PROBEBLOCK_MIDDLE_NOFD(0, APITYPE); \
PRE_PROBEBLOCK_END()
-#define BEFORE_ORIGINAL_START_END_FILEP(API_ID, FUNCNAME, LIBNAME, FILEP, APITYPE, INPUTFORMAT, ...) \
+#define BEFORE_ORIGINAL_START_END_FILEP(API_ID, RTYPE, FUNCNAME, LIBNAME, FILEP, APITYPE, INPUTFORMAT, ...) \
DECLARE_VARIABLE_FD; \
GET_REAL_FUNC(FUNCNAME, LIBNAME); \
PRE_PROBEBLOCK_BEGIN(); \
} \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(0, 0, blockresult); \
+ PACK_COMMON_END(RTYPE, 0, 0, blockresult); \
POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, APITYPE); \
PRE_PROBEBLOCK_END()
-#define AFTER_ORIGINAL_START_END_NOFD(API_ID, RVAL, SIZE, APITYPE, INPUTFORMAT, ...) \
+#define AFTER_ORIGINAL_START_END_NOFD(API_ID, RTYPE, RVAL, SIZE, APITYPE, INPUTFORMAT, ...) \
POST_PACK_PROBEBLOCK_BEGIN(); \
setProbePoint(&probeInfo); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult); \
POST_PACK_PROBEBLOCK_MIDDLE_NOFD(SIZE, APITYPE); \
POST_PACK_PROBEBLOCK_END()
-#define AFTER_ORIGINAL_START_END_FILEP(API_ID, RVAL, SIZE, FILEP, APITYPE, INPUTFORMAT, ...) \
+#define AFTER_ORIGINAL_START_END_FILEP(API_ID, RTYPE, RVAL, SIZE, FILEP, APITYPE, INPUTFORMAT, ...) \
POST_PACK_PROBEBLOCK_BEGIN(); \
setProbePoint(&probeInfo); \
GET_FD_FROM_FILEP(FILEP); \
} \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL, newerrno, blockresult); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult); \
POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, _fd, APITYPE); \
POST_PACK_PROBEBLOCK_END()
ret = openp(path, oflag, mode);
- AFTER_PACK_ORIGINAL_FD(API_ID_open, ret, 0, ret, FD_API_OPEN, "sdd",
+ AFTER_PACK_ORIGINAL_FD(API_ID_open, 'd', ret, 0, ret, FD_API_OPEN, "sdd",
absolutize_filepath(buffer, path), oflag, mode);
return ret;
ret = openatp(fd, path, oflag, mode);
- AFTER_PACK_ORIGINAL_FD(API_ID_openat, ret, 0, ret, FD_API_OPEN, "dsdd",
- fd, absolutize_filepath(buffer, path), oflag,
- mode);
+ AFTER_PACK_ORIGINAL_FD(API_ID_openat, 'd', ret, 0, ret, FD_API_OPEN,
+ "dsdd", fd, absolutize_filepath(buffer, path),
+ oflag, mode);
return ret;
}
ret = creatp(path, mode);
- AFTER_PACK_ORIGINAL_FD(API_ID_creat, ret, 0, ret, FD_API_OPEN, "sd",
+ AFTER_PACK_ORIGINAL_FD(API_ID_creat, 'd', ret, 0, ret, FD_API_OPEN, "sd",
absolutize_filepath(buffer, path), mode);
return ret;
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_close,
"d", fd);
- PACK_COMMON_END(ret, newerrno, blockresult);
+ PACK_COMMON_END('d', ret, newerrno, blockresult);
POST_PACK_PROBEBLOCK_MIDDLE_FD(0, fd, FD_API_CLOSE);
POST_PACK_PROBEBLOCK_END();
offret = lseekp(fd, offset, whence);
AFTER_PACK_ORIGINAL_FD(API_ID_lseek,
- offret, (unsigned int)offset, fd, FD_API_OTHER,
+ 'x', offret, (unsigned int)offset, fd, FD_API_OTHER,
"dxd", fd, (uint64_t)(offset), whence);
return offret;
ret = fsyncp(fd);
AFTER_PACK_ORIGINAL_FD(API_ID_fsync,
- ret, 0, fd, FD_API_OTHER, "d", fd);
+ 'd', ret, 0, fd, FD_API_OTHER, "d", fd);
return ret;
}
ret = fdatasyncp(fd);
AFTER_PACK_ORIGINAL_FD(API_ID_fdatasync,
- ret, 0, fd, FD_API_OTHER, "d", fd);
+ 'd', ret, 0, fd, FD_API_OTHER, "d", fd);
return ret;
}
ret = ftruncatep(fd, length);
AFTER_PACK_ORIGINAL_FD(API_ID_ftruncate,
- ret, (unsigned int)length, fd,
+ 'd', ret, (unsigned int)length, fd,
FD_API_DIRECTORY, "dx", fd, (uint64_t)(length));
return ret;
BEFORE_ORIGINAL_FILE(fchown, LIBC);
ret = fchownp(fd, owner, group);
- AFTER_PACK_ORIGINAL_FD(API_ID_fchown, ret, 0, fd, FD_API_PERMISSION,
+ AFTER_PACK_ORIGINAL_FD(API_ID_fchown, 'd', ret, 0, fd, FD_API_PERMISSION,
"ddd", fd, owner, group);
return ret;
}
BEFORE_ORIGINAL_FILE(lockf, LIBC);
ret = lockfp(fd, function, size);
AFTER_PACK_ORIGINAL_FD(API_ID_lockf,
- ret, (unsigned int)size, fd, FD_API_PERMISSION,
+ 'd', ret, (unsigned int)size, fd, FD_API_PERMISSION,
"ddx", fd, function, (uint64_t)(size));
return ret;
}
BEFORE_ORIGINAL_FILE(fchmod, LIBC);
ret = fchmodp(fd, mode);
AFTER_PACK_ORIGINAL_FD(API_ID_fchmod,
- ret, 0, fd, FD_API_PERMISSION, "dd", fd, mode);
+ 'd', ret, 0, fd, FD_API_PERMISSION, "dd", fd, mode);
return ret;
}
static ssize_t (*preadp)(int fd, void *buf, size_t nbyte, off_t offset);
ssize_t sret;
- BEFORE_ORIGINAL_START_END_FD(API_ID_pread, pread, LIBC, fd,
+ BEFORE_ORIGINAL_START_END_FD(API_ID_pread, 'x', pread, LIBC, fd,
FD_API_READ_START, "dpxx", fd,
voidp_to_uint64(buf),
(uint64_t)(nbyte),
sret = preadp(fd, buf, nbyte, offset);
- AFTER_ORIGINAL_START_END_FD(API_ID_pread, sret, (unsigned int)sret, fd,
+ AFTER_ORIGINAL_START_END_FD(API_ID_pread, 'x', sret, (unsigned int)sret, fd,
FD_API_READ_END, "dpxx", fd,
voidp_to_uint64(buf),
(uint64_t)(nbyte),
static ssize_t (*readp)(int fildes, void *buf, size_t nbyte);
ssize_t sret;
- BEFORE_ORIGINAL_START_END_FD(API_ID_read, read, LIBC, fd, FD_API_READ_START,
+ BEFORE_ORIGINAL_START_END_FD(API_ID_read, 'x', read, LIBC, fd, FD_API_READ_START,
"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,
+ AFTER_ORIGINAL_START_END_FD(API_ID_read, 'x', sret, (unsigned int)sret, fd,
FD_API_READ_END, "dpx", fd,
voidp_to_uint64(buf),
(uint64_t)(nbyte));
static ssize_t (*pwritep)(int fd, const void *buf, size_t nbyte, off_t offset);
ssize_t sret;
- BEFORE_ORIGINAL_START_END_FD(API_ID_pwrite, pwrite, LIBC, fd, FD_API_WRITE_START,
+ BEFORE_ORIGINAL_START_END_FD(API_ID_pwrite, 'x', pwrite, LIBC, fd, FD_API_WRITE_START,
"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,
+ AFTER_ORIGINAL_START_END_FD(API_ID_pwrite, 'x', sret, (unsigned int)sret, fd,
FD_API_WRITE_END, "dpxx", fd,
voidp_to_uint64(buf),
(uint64_t)(nbyte),
static ssize_t (*writep)(int fildes, const void *buf, size_t nbyte);
ssize_t sret;
- BEFORE_ORIGINAL_START_END_FD(API_ID_write, write, LIBC, fd, FD_API_WRITE_START,
+ BEFORE_ORIGINAL_START_END_FD(API_ID_write, 'x', write, LIBC, fd, FD_API_WRITE_START,
"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,
+ AFTER_ORIGINAL_START_END_FD(API_ID_write, 'x', sret, (unsigned int)sret, fd,
FD_API_WRITE_END, "dpx", fd,
voidp_to_uint64(buf),
(uint64_t)(nbyte));
static ssize_t (*readvp)(int fd, const struct iovec *iov, int iovcnt);
ssize_t sret;
- BEFORE_ORIGINAL_START_END_FD(API_ID_readv, readv, LIBC, fd, FD_API_READ_START,
+ BEFORE_ORIGINAL_START_END_FD(API_ID_readv, 'x', readv, LIBC, fd, FD_API_READ_START,
"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,
+ AFTER_ORIGINAL_START_END_FD(API_ID_readv, 'x', sret, (unsigned int)sret, fd,
FD_API_READ_END, "dpd", fd,
voidp_to_uint64(iov), iovcnt);
ret = fcntlp(fd, cmd, arg);
AFTER_PACK_ORIGINAL_FD(API_ID_fcntl,
- ret, 0, fd, FD_API_OTHER, "ddd", fd, cmd, arg);
+ 'd', ret, 0, fd, FD_API_OTHER, "ddd", fd, cmd, arg);
return ret;
}
ret = dupp(fd);
AFTER_PACK_ORIGINAL_FD(API_ID_dup,
- ret, 0, ret, FD_API_OPEN, "d", fd);
+ 'd', ret, 0, ret, FD_API_OPEN, "d", fd);
return ret;
}
ret = dup2p(fd, fd2);
AFTER_PACK_ORIGINAL_FD(API_ID_dup2,
- ret, 0, ret, FD_API_OPEN, "dd", fd, fd2);
+ 'd', ret, 0, ret, FD_API_OPEN, "dd", fd, fd2);
return ret;
}
BEFORE_ORIGINAL_FILE(futimens, LIBC);
ret = futimensp(fd, times);
AFTER_PACK_ORIGINAL_FD(API_ID_futimens,
- ret, 0, fd, FD_API_OTHER, "dp", fd,
+ 'd', ret, 0, fd, FD_API_OTHER, "dp", fd,
voidp_to_uint64(times));
return ret;
}
fret = fopenp(filename, mode);
- AFTER_PACK_ORIGINAL_FILEP(API_ID_fopen, fret, 0, fret, FD_API_OPEN, "ss",
- absolutize_filepath(buffer, filename),
- mode);
+ AFTER_PACK_ORIGINAL_FILEP(API_ID_fopen,
+ 'p', fret, 0, fret, FD_API_OPEN, "ss",
+ absolutize_filepath(buffer, filename), mode);
return fret;
}
fret = freopenp(filename, mode, stream);
- AFTER_PACK_ORIGINAL_FILEP(API_ID_freopen, fret, 0, fret, FD_API_OPEN,
+ AFTER_PACK_ORIGINAL_FILEP(API_ID_freopen, 'p', fret, 0, fret, FD_API_OPEN,
"ssp", absolutize_filepath(buffer, filename),
mode, voidp_to_uint64(stream));
fret = fdopenp(fildes, mode);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fdopen,
- fret, 0, fret, FD_API_OPEN, "ds", fildes, mode);
+ 'p', fret, 0, fret, FD_API_OPEN, "ds", fildes, mode);
return fret;
}
BEFORE_ORIGINAL_FILE(fflush, LIBC);
ret = fflushp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fflush,
- ret, 0, stream, FD_API_OTHER, "p",
+ 'd', ret, 0, stream, FD_API_OTHER, "p",
voidp_to_uint64(stream));
return ret;
}
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_fclose,
"p", voidp_to_uint64(stream));
- PACK_COMMON_END(ret, newerrno, blockresult);
+ PACK_COMMON_END('d', ret, newerrno, blockresult);
POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, FD_API_CLOSE);
POST_PACK_PROBEBLOCK_END();
_filepath = "<temp file>";
fret = tmpfilep();
AFTER_PACK_ORIGINAL_FILEP(API_ID_tmpfile,
- fret, 0, fret, FD_API_OPEN, "s", "");
+ 'p', fret, 0, fret, FD_API_OPEN, "s", "");
return fret;
}
BEFORE_ORIGINAL_FILE(fgetpos, LIBC);
ret = fgetposp(stream, position);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fgetpos,
- ret, 0, stream, FD_API_OTHER, "pp",
+ 'd', ret, 0, stream, FD_API_OTHER, "pp",
voidp_to_uint64(stream),
voidp_to_uint64(position));
return ret;
BEFORE_ORIGINAL_FILE(fseek, LIBC);
ret = fseekp(stream, offset, origin);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fseek,
- ret, (unsigned int)offset, stream, FD_API_OTHER,
+ 'd', ret, (unsigned int)offset, stream, FD_API_OTHER,
"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",
+ 'd', 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",
+ 'x', 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",
+ 'v', 0, 0, stream, FD_API_OTHER, "p",
voidp_to_uint64(stream));
}
clearerrp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_clearerr,
- 0, 0, stream, FD_API_OTHER, "p",
+ 'v', 0, 0, stream, FD_API_OTHER, "p",
voidp_to_uint64(stream));
}
BEFORE_ORIGINAL_FILE(feof, LIBC);
ret = feofp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_feof,
- ret, 0, stream, FD_API_OTHER, "p",
+ 'd', 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",
+ 'd', 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",
+ 'd', 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,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfprintf, 'd', vfprintf, LIBC, stream,
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,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_vfprintf, 'd', ret, ret, stream,
FD_API_WRITE_END, "ps",
voidp_to_uint64(stream), format);
{
static int (*vfscanfp)(FILE* stream, const char* format, va_list arg);
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfscanf, vfscanf, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfscanf, 'd', vfscanf, LIBC, stream,
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,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_vfscanf, 'd', ret, ret, stream,
FD_API_READ_END, "ps",
voidp_to_uint64(stream), format);
{
static int (*fgetcp)(FILE* stream);
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgetc, fgetc, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgetc, 'd', fgetc, LIBC, 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,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fgetc, 'd', ret, (ret != EOF), stream,
FD_API_READ_END, "p",
voidp_to_uint64(stream));
static char* (*fgetsp)(char* str, int num, FILE* stream);
char* cret;
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgets, FD_API_READ_START,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgets, 'p', FD_API_READ_START,
fgets, LIBC, stream, "sdp", str, size, stream);
cret = fgetsp(str, size, stream);
- AFTER_ORIGINAL_START_END_FILEP(API_ID_fgets, cret, (ret == NULL ? 0 : strlen(cret)),
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fgets, 'p', cret, (ret == NULL ? 0 : strlen(cret)),
stream, FD_API_READ_END, "sdp", str, size, stream);
return cret;
{
static int (*fputcp)(int character, FILE* stream);
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputc, fputc, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputc, 'd', fputc, LIBC, 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),
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fputc, 'd', ret, (ret == EOF ? 0 : 1),
stream, FD_API_WRITE_END, "dp",
character, voidp_to_uint64(stream));
{
static int (*fputsp)(const char* str, FILE* stream);
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputs, fputs, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputs, 'd', fputs, LIBC, 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,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fputs, 'd', ret, ret, stream,
FD_API_WRITE_END, "sp", str,
voidp_to_uint64(stream));
{
static int (*getcp)(FILE* stream);
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_getc, getc, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_getc, 'd', getc, LIBC, 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,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_getc, 'd', ret, (ret == EOF ? 0 : 1), stream,
FD_API_READ_END, "p",
voidp_to_uint64(stream));
{
static int (*putcp)(int character, FILE* stream);
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, putc, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', putc, LIBC, 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),
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', ret, (ret == EOF ? 0 : 1),
stream, FD_API_WRITE_END, "dp",
character, voidp_to_uint64(stream));
{
static int (*ungetcp)(int character, FILE* stream);
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, ungetc, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', ungetc, LIBC, 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,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_ungetc, 'd', ret, 0, stream,
FD_API_OTHER, "dp", character,
voidp_to_uint64(stream));
static size_t (*freadp)(void* ptr, size_t size, size_t count, FILE* stream);
size_t tret;
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_fread, fread, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fread, 'x', fread, LIBC, stream,
FD_API_READ_START, "pxxp",
voidp_to_uint64(ptr),
(uint64_t)(size),
tret = freadp(ptr, size, count, stream);
- AFTER_ORIGINAL_START_END_FILEP(API_ID_fread, tret, tret*size, stream,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fread, 'x', tret, tret*size, stream,
FD_API_READ_END, "pxxp",
voidp_to_uint64(ptr),
(uint64_t)(size),
static size_t (*fwritep)(const void* ptr, size_t size, size_t count, FILE* stream);
size_t tret;
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_fwrite, fwrite, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fwrite, 'x', fwrite, LIBC, stream,
FD_API_WRITE_START, "pxxp",
voidp_to_uint64(ptr),
(uint64_t)(size),
tret = fwritep(ptr, size, count, stream);
- AFTER_ORIGINAL_START_END_FILEP(API_ID_fwrite, tret, tret*size, stream,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fwrite, 'x', tret, tret*size, stream,
FD_API_WRITE_END, "pxxp",
voidp_to_uint64(ptr),
(uint64_t)(size),
{
static int (*vfprintfp)(FILE* stream, const char* format, ...);
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_fprintf, vfprintf, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fprintf, 'd', vfprintf, LIBC, stream,
FD_API_WRITE_START, "ps",
voidp_to_uint64(stream), format);
ret = vfprintfp(stream, format, arg);
- AFTER_ORIGINAL_START_END_FILEP(API_ID_fprintf, ret, ret, stream,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fprintf, 'd', ret, ret, stream,
FD_API_WRITE_END, "ps",
voidp_to_uint64(stream), format);
{
static int (*vfscanfp)(FILE* stream, const char* format, ...);
- BEFORE_ORIGINAL_START_END_FILEP(API_ID_fscanf, vfscanf, LIBC, stream,
+ BEFORE_ORIGINAL_START_END_FILEP(API_ID_fscanf, 'd', vfscanf, LIBC, stream,
FD_API_READ_START, "ps",
voidp_to_uint64(stream), format);
ret = vfscanfp(stream, format, arg);
- AFTER_ORIGINAL_START_END_FILEP(API_ID_fscanf, ret, ret, stream,
+ AFTER_ORIGINAL_START_END_FILEP(API_ID_fscanf, 'd', ret, ret, stream,
FD_API_READ_END, "ps",
voidp_to_uint64(stream), format);
{
static int (*vprintfp)(const char* format, ...);
- BEFORE_ORIGINAL_START_END_NOFD(API_ID_printf, vprintf, LIBC,
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_printf, 'd', vprintf, LIBC,
FD_API_WRITE_START, "s", format);
va_list arg;
va_start(arg, format);
ret = vprintfp(format, arg);
- AFTER_ORIGINAL_START_END_NOFD(API_ID_printf, ret, ret,
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_printf, 'd', ret, ret,
FD_API_WRITE_END, "s", format);
va_end(arg);
{
static int (*vscanfp)(const char* format, ...);
- BEFORE_ORIGINAL_START_END_NOFD(API_ID_scanf, vscanf, LIBC,
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_scanf, 'd', vscanf, LIBC,
FD_API_READ_START, "s", format);
va_list arg;
va_start(arg, format);
ret = vscanfp(format, arg);
- AFTER_ORIGINAL_START_END_NOFD(API_ID_scanf, ret, ret,
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_scanf, 'd', ret, ret,
FD_API_READ_END, "s", format);
va_end(arg);
{
static int (*getcharp)();
- BEFORE_ORIGINAL_START_END_NOFD(API_ID_getchar, getchar, LIBC,
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_getchar, 'd', getchar, LIBC,
FD_API_READ_START, "", 0);
ret = getcharp();
- AFTER_ORIGINAL_START_END_NOFD(API_ID_getchar, ret, (ret == EOF ? 0 : 1),
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_getchar, 'd', ret, (ret == EOF ? 0 : 1),
FD_API_READ_END, "", 0);
return ret;
{
static int (*putcharp)(int c);
- BEFORE_ORIGINAL_START_END_NOFD(API_ID_putchar, putchar, LIBC,
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_putchar, 'd', putchar, LIBC,
FD_API_WRITE_START, "d", c);
ret = putcharp(c);
- AFTER_ORIGINAL_START_END_NOFD(API_ID_putchar, ret, (ret == EOF ? 0 : 1),
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_putchar, 'd', ret, (ret == EOF ? 0 : 1),
FD_API_WRITE_END, "d", c);
return ret;
static char* (*getsp)(char* str);
char* cret;
- BEFORE_ORIGINAL_START_END_NOFD(API_ID_gets, gets, LIBC,
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_gets, 'p', gets, LIBC,
FD_API_READ_START, "s", str);
cret = getsp(str);
- AFTER_ORIGINAL_START_END_NOFD(API_ID_gets, cret, strlen(cret),
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_gets, 'p', cret, strlen(cret),
FD_API_READ_END, "s", str);
return cret;
{
static int (*putsp)(const char* str);
- BEFORE_ORIGINAL_START_END_NOFD(API_ID_puts, puts, LIBC,
+ BEFORE_ORIGINAL_START_END_NOFD(API_ID_puts, 'd', puts, LIBC,
FD_API_WRITE_START, "s", str);
ret = putsp(str);
- AFTER_ORIGINAL_START_END_NOFD(API_ID_puts, ret, ret,
+ AFTER_ORIGINAL_START_END_NOFD(API_ID_puts, 'd', ret, ret,
FD_API_WRITE_END, "s", str);
return ret;
setbufp(stream, buf);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuf,
- 0, 0, stream, FD_API_OTHER, "pp",
+ 'v', 0, 0, stream, FD_API_OTHER, "pp",
voidp_to_uint64(stream),
voidp_to_uint64(buf));
}
setbufferp(stream, buf, size);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuffer,
- 0, size, stream, FD_API_OTHER,
+ 'v', 0, size, stream, FD_API_OTHER,
"ppx", voidp_to_uint64(stream),
voidp_to_uint64(buf), (uint64_t)(size));
}
setlinebufp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setlinebuf,
- 0, 0, stream, FD_API_OTHER, "p",
+ 'v', 0, 0, stream, FD_API_OTHER, "p",
voidp_to_uint64(stream));
}
BEFORE_ORIGINAL_FILE(setvbuf, LIBC);
ret = setvbufp(stream,buf,mode,size);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setvbuf,
- ret, size, stream, FD_API_OTHER,
+ 'd', ret, size, stream, FD_API_OTHER,
"ppdx",
voidp_to_uint64(stream),
voidp_to_uint64(buf), mode,
BEFORE(glActiveTexture);
glActiveTexturep(texture);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
(uint64_t)(texture));
}
BEFORE(glAttachShader);
glAttachShaderp(program, shader);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
program, shader);
}
BEFORE(glBindAttribLocation);
glBindAttribLocationp(program, index, name);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dds",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dds",
program, index, name);
}
BEFORE(glBindBuffer);
glBindBufferp(target, buffer);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
(uint64_t)(target), buffer);
}
BEFORE(glBindFramebuffer);
glBindFramebufferp(target, framebuffer);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
(uint64_t)(target), framebuffer);
}
BEFORE(glBindRenderbuffer);
glBindRenderbufferp(target, renderbuffer);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
(uint64_t)(target), renderbuffer);
}
BEFORE(glBindTexture);
glBindTexturep(target, texture);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
(uint64_t)(target), texture);
}
BEFORE(glBlendColor);
glBlendColorp(red, green, blue, alpha);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ffff",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ffff",
red, green, blue, alpha);
}
BEFORE(glBlendEquation);
glBlendEquationp(mode);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
(uint64_t)(mode));
}
BEFORE(glBlendEquationSeparate);
glBlendEquationSeparatep(modeRGB, modeAlpha);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
(uint64_t)(modeRGB), (uint64_t)(modeAlpha));
}
BEFORE(glBlendFunc);
glBlendFuncp(sfactor, dfactor);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
(uint64_t)(sfactor), (uint64_t)(dfactor));
}
BEFORE(glBlendFuncSeparate);
glBlendFuncSeparatep(srcRGB, dstRGB, srcAlpha, dstAlpha);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
(uint64_t)(srcRGB), (uint64_t)(dstRGB),
(uint64_t)(srcAlpha), (uint64_t)(dstAlpha));
}
BEFORE(glBufferData);
glBufferDatap(target, size, data, usage);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxpx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxpx",
(uint64_t)(target), (uint64_t)(size),
voidp_to_uint64(data), (uint64_t)(usage));
}
BEFORE(glBufferSubData);
glBufferSubDatap(target, offset, size, data);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxp",
+ AFTER('v', 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",
+ AFTER('d', ret, APITYPE_CONTEXT, "", "x",
(uint64_t)(target));
return ret;
BEFORE(glClear);
glClearp(mask);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
(uint64_t)(mask));
}
BEFORE(glClearColor);
glClearColorp(red, green, blue, alpha);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ffff",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ffff",
red, green, blue, alpha);
}
BEFORE(glClearDepthf);
glClearDepthfp(depth);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "f", depth);
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "f", depth);
}
void glClearStencil(GLint s) {
BEFORE(glClearStencil);
glClearStencilp(s);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", s);
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", s);
}
void glColorMask(GLboolean red, GLboolean green, GLboolean blue,
BEFORE(glColorMask);
glColorMaskp(red, green, blue, alpha);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
red, green, blue, alpha);
}
BEFORE(glCompileShader);
glCompileShaderp(shader);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(shader));
+ AFTER('v', 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",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxddddp",
(uint64_t)(target), level,
(uint64_t)(internalformat), width, height, border, imageSize,
voidp_to_uint64(data));
glCompressedTexSubImage2Dp(target, level, xoffset, yoffset, width, height,
format, imageSize, data);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdddddxdp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdddddxdp",
(uint64_t)(target), level, xoffset, yoffset, width, height,
(uint64_t)(format), imageSize, voidp_to_uint64(data));
}
glCopyTexImage2Dp(target, level, internalformat, x, y, width, height,
border);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxddddd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxddddd",
(uint64_t)(target), level,
(uint64_t)(internalformat), x, y, width, height, border);
}
BEFORE(glCopyTexSubImage2D);
glCopyTexSubImage2Dp(target, level, xoffset, yoffset, x, y, width, height);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xddddddd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xddddddd",
(uint64_t)(target), level, xoffset, yoffset, x, y, width,
height);
}
BEFORE(glCreateProgram);
GLuint ret = glCreateProgramp();
error = glGetError();
- AFTER_NO_PARAM(ret, APITYPE_CONTEXT, "");
+ AFTER_NO_PARAM('d', ret, APITYPE_CONTEXT, "");
return ret;
}
BEFORE(glCreateShader);
GLuint ret = glCreateShaderp(shaderType);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "x", (uint64_t)(shaderType));
+ AFTER('d', ret, APITYPE_CONTEXT, "", "x", (uint64_t)(shaderType));
return ret;
}
BEFORE(glCullFace);
glCullFacep(mode);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(mode));
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(mode));
}
// ==================================================================
BEFORE(glDeleteBuffers);
glDeleteBuffersp(n, buffers);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
n, voidp_to_uint64(buffers));
}
BEFORE(glDeleteFramebuffers);
glDeleteFramebuffersp(n, framebuffers);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
n, voidp_to_uint64(framebuffers));
}
BEFORE(glDeleteProgram);
glDeleteProgramp(program);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
program);
}
BEFORE(glDeleteRenderbuffers);
glDeleteRenderbuffersp(n, renderbuffers);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
n, voidp_to_uint64(renderbuffers));
}
BEFORE(glDeleteShader);
glDeleteShaderp(shader);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", shader);
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", shader);
}
void glDeleteTextures(GLsizei n, const GLuint * textures) {
bufP += sprintf(buf + bufP, ",");
}
}
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
n, voidp_to_uint64(textures));
} else {
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
n, voidp_to_uint64(textures));
}
}
BEFORE(glDepthFunc);
glDepthFuncp(func);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(func));
+ AFTER('v', 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", (uint64_t)(flag));
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(flag));
}
void glDepthRangef(GLclampf nearVal, GLclampf farVal) {
BEFORE(glDepthRangef);
glDepthRangefp(nearVal, farVal);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ff",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ff",
nearVal, farVal);
}
BEFORE(glDetachShader);
glDetachShaderp(program, shader);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
program, shader);
}
BEFORE(glDisable);
glDisablep(cap);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
}
void glDisableVertexAttribArray(GLuint index) {
BEFORE(glDisableVertexAttribArray);
glDisableVertexAttribArrayp(index);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", index);
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", index);
}
void glDrawArrays(GLenum mode, GLint first, GLsizei count) {
BEFORE(glDrawArrays);
glDrawArraysp(mode, first, count);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
(uint64_t)(mode), first, count);
}
BEFORE(glDrawElements);
glDrawElementsp(mode, count, type, indices);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdxp",
(uint64_t)(mode), count, (uint64_t)(type), indices);
}
BEFORE(glEnable);
glEnablep(cap);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
}
void glEnableVertexAttribArray(GLuint index) {
BEFORE(glEnableVertexAttribArray);
glEnableVertexAttribArrayp(index);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", index);
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", index);
}
#undef eglSwapBuffers
BEFORE_EGL(eglSwapBuffers);
EGLBoolean ret = eglSwapBuffersp(dpy, surface);
error = eglGetError();
- AFTER_NO_PARAM(ret, APITYPE_CONTEXT, "");
+ AFTER_NO_PARAM('d', ret, APITYPE_CONTEXT, "");
return ret;
}
BEFORE_OSP_UIFW(_SglSwapBuffers);
EGLBoolean ret = _SglSwapBuffersp(dpy, surface);
error = eglGetError();
- AFTER_NO_PARAM(ret, APITYPE_CONTEXT, "");
+ AFTER_NO_PARAM('d', ret, APITYPE_CONTEXT, "");
return ret;
}
BEFORE(glFinish);
glFinishp();
error = glGetError();
- AFTER_NO_PARAM(NO_RETURN_VALUE, APITYPE_CONTEXT, "");
+ AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
void glFlush(void) {
BEFORE(glFlush);
glFlushp();
error = glGetError();
- AFTER_NO_PARAM(NO_RETURN_VALUE, APITYPE_CONTEXT, "");
+ AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
void glFramebufferRenderbuffer(GLenum target, GLenum attachment,
glFramebufferRenderbufferp(target, attachment, renderbuffertarget,
renderbuffer);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxd",
(uint64_t)(target), (uint64_t)(attachment),
(uint64_t)(renderbuffertarget), renderbuffer);
}
BEFORE(glFramebufferTexture2D);
glFramebufferTexture2Dp(target, attachment, textarget, texture, level);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxdd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxdd",
(uint64_t)(target), (uint64_t)(attachment),
(uint64_t)(textarget), texture, level);
}
BEFORE(glFrontFace);
glFrontFacep(mode);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x",
(uint64_t)(mode));
}
bufP += sprintf(buf + bufP, ",");
}
}
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
n, voidp_to_uint64(buffers));
} else {
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
n, voidp_to_uint64(buffers));
}
}
BEFORE(glGenFramebuffers);
glGenFramebuffersp(n, framebuffers);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
n, voidp_to_uint64(framebuffers));
}
BEFORE(glGenRenderbuffers);
glGenRenderbuffersp(n, renderbuffers);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
n, voidp_to_uint64(renderbuffers));
}
bufP += sprintf(buf + bufP, ",");
}
}
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "dp",
n, voidp_to_uint64(textures));
} else {
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dp",
n, voidp_to_uint64(textures));
}
}
BEFORE(glGenerateMipmap);
glGenerateMipmapp(target);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(target));
+ AFTER('v', 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", (uint64_t)(pname));
+ AFTER('v', 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", (uint64_t)(pname));
+ AFTER('v', 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", (uint64_t)(pname));
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
}
//lsh_get
BEFORE(glGetActiveAttrib);
glGetActiveAttribp(program, index, bufSize, length, size, type, name);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
program, index, bufSize);
}
BEFORE(glGetActiveUniform);
glGetActiveUniformp(program, index, bufSize, length, size, type, name);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
program, index, bufSize);
}
BEFORE(glGetAttachedShaders);
glGetAttachedShadersp(program, maxCount, count, shaders);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
program, maxCount);
}
BEFORE(glGetAttribLocation);
glGetAttribLocationp(pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "x", (uint64_t)(pname));
}
//lsh_get
BEFORE(glGetBufferParameteriv);
glGetBufferParameterivp(target, value, data);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
(uint64_t)(target), (uint64_t)(value));
}
BEFORE(glGetError);
GLenum ret = glGetErrorp();
// error = glGetError();
- AFTER_NO_PARAM(ret, APITYPE_CONTEXT, "");
+ AFTER_NO_PARAM('d', ret, APITYPE_CONTEXT, "");
return ret;
}
BEFORE(glGetFramebufferAttachmentParameteriv);
glGetFramebufferAttachmentParameterivp(target, attachment, pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
(uint64_t)(target), (uint64_t)(attachment),
(uint64_t)(pname));
}
BEFORE(glGetProgramInfoLog);
glGetProgramInfoLogp(program, maxLength, length, infoLog);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
program, maxLength);
}
BEFORE(glGetProgramiv);
glGetProgramivp(program, pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
program, (uint64_t)(pname));
}
BEFORE(glGetRenderbufferParameteriv);
glGetRenderbufferParameterivp(target, pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
(uint64_t)(target), (uint64_t)(pname));
}
BEFORE(glGetShaderInfoLog);
glGetShaderInfoLogp(shader, maxLength, length, infoLog);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
shader, maxLength);
}
BEFORE(glGetShaderPrecisionFormat);
glGetShaderPrecisionFormatp(shaderType, precisionType, range, precision);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
(uint64_t)(shaderType), (uint64_t)(precisionType));
}
BEFORE(glGetShaderSource);
glGetShaderSourcep(shader, bufSize, length, source);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
shader, bufSize);
}
BEFORE(glGetShaderiv);
glGetShaderivp(shader, pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
shader, (uint64_t)(pname));
}
BEFORE(glGetString);
const GLubyte* ret = glGetStringp(name);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "x", (uint64_t)(name));
+ AFTER('p', ret, APITYPE_CONTEXT, "", "x", (uint64_t)(name));
return ret;
}
BEFORE(glGetTexParameterfv);
glGetTexParameterfvp(target, pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
(uint64_t)(target), (uint64_t)(pname));
}
BEFORE(glGetTexParameteriv);
glGetTexParameterivp(target, pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
(uint64_t)(target), (uint64_t)(pname));
}
BEFORE(glGetUniformfv);
glGetUniformfvp(program, location, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
program, location);
}
BEFORE(glGetUniformiv);
glGetUniformivp(program, location, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
program, location);
}
BEFORE(glGetUniformLocation);
GLint ret = glGetUniformLocationp(program, name);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "d", program);
+ AFTER('d', ret, APITYPE_CONTEXT, "", "d", program);
return ret;
}
BEFORE(glGetVertexAttribfv);
glGetVertexAttribfvp(index, pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
index, (uint64_t)(pname));
}
BEFORE(glGetVertexAttribiv);
glGetVertexAttribivp(index, pname, params);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
index, (uint64_t)(pname));
}
BEFORE(glGetVertexAttribPointerv);
glGetVertexAttribPointervp(index, pname, pointer);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dx",
index, (uint64_t)(pname));
}
BEFORE(glHint);
glHintp(target, mode);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xx",
(uint64_t)(target), (uint64_t)(mode));
}
BEFORE(glIsBuffer);
GLboolean ret = glIsBufferp(buffer);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "d", buffer);
+ AFTER('c', ret, APITYPE_CONTEXT, "", "d", buffer);
return ret;
}
BEFORE(glIsEnabled);
GLboolean ret = glIsEnabledp(cap);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
+ AFTER('c', ret, APITYPE_CONTEXT, "", "x", (uint64_t)(cap));
return ret;
}
BEFORE(glIsFramebuffer);
GLboolean ret = glIsFramebufferp(framebuffer);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "d", framebuffer);
+ AFTER('c', ret, APITYPE_CONTEXT, "", "d", framebuffer);
return ret;
}
BEFORE(glIsProgram);
GLboolean ret = glIsProgramp(program);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "d", program);
+ AFTER('c', ret, APITYPE_CONTEXT, "", "d", program);
return ret;
}
BEFORE(glIsRenderbuffer);
GLboolean ret = glIsRenderbufferp(renderbuffer);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "d", renderbuffer);
+ AFTER('c', ret, APITYPE_CONTEXT, "", "d", renderbuffer);
return ret;
}
BEFORE(glIsShader);
GLboolean ret = glIsShaderp(shader);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "d", shader);
+ AFTER('c', ret, APITYPE_CONTEXT, "", "d", shader);
return ret;
}
BEFORE(glIsTexture);
GLboolean ret = glIsTexturep(texture);
error = glGetError();
- AFTER(ret, APITYPE_CONTEXT, "", "d", texture);
+ AFTER('c', ret, APITYPE_CONTEXT, "", "d", texture);
return ret;
}
BEFORE(glLineWidth);
glLineWidthp(width);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "f", width);
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "f", width);
}
void glLinkProgram(GLuint program) {
type[0]);
}
}
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "d",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf, "d",
program);
}
BEFORE(glPixelStorei);
glPixelStoreip(pname, param);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
(uint64_t)(pname), param);
}
BEFORE(glPolygonOffset);
glPolygonOffsetp(factor, units);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ff",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ff",
factor, units);
}
BEFORE(glReadPixels);
glReadPixelsp(x, y, width, height, format, type, data);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
"ddddxx", x, y, width, height,
(uint64_t)(format), (uint64_t)(type));
}
BEFORE(glReleaseShaderCompiler);
glReleaseShaderCompilerp();
error = glGetError();
- AFTER_NO_PARAM(NO_RETURN_VALUE, APITYPE_CONTEXT, "");
+ AFTER_NO_PARAM('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "");
}
void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width,
BEFORE(glRenderbufferStorage);
glRenderbufferStoragep(target, internalformat, width, height);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
(uint64_t)(target), (uint64_t)(internalformat),
width, height);
}
BEFORE(glSampleCoverage);
glSampleCoveragep(value, invert);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "fx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "fx",
value, (uint64_t)(invert));
}
BEFORE(glScissor);
glScissorp(x, y, width, height);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
x, y, width, height);
}
BEFORE(glShaderBinary);
glShaderBinaryp(n, shaders, binaryformat, binary, length);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
"dpxpd", n, voidp_to_uint64(shaders),
(uint64_t)(binaryformat), voidp_to_uint64(binary), length);
}
glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, length);
char buf[length[0]];
glGetShaderSource(shader, length[0], NULL, buf);
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, buf,
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, buf,
"ddpp", shader, count,
voidp_to_uint64(string), voidp_to_uint64(length));
} else {
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
"ddpp", shader, count,
voidp_to_uint64(string), voidp_to_uint64(length));
}
BEFORE(glStencilFunc);
glStencilFuncp(func, ref, mask);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdd",
(uint64_t)(func), ref, mask);
}
BEFORE(glStencilFuncSeparate);
glStencilFuncSeparatep(face, func, ref, mask);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxdd",
(uint64_t)(face), (uint64_t)(func), ref, mask);
}
BEFORE(glStencilMask);
glStencilMaskp(mask);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", mask);
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d", mask);
}
void glStencilMaskSeparate(GLenum face, GLuint mask) {
BEFORE(glStencilMaskSeparate);
glStencilMaskSeparatep(face, mask);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xd",
(uint64_t)(face), mask);
}
BEFORE(glStencilOp);
glStencilOpp(sfail, dpfail, dppass);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
(uint64_t)(sfail), (uint64_t)(dpfail),
(uint64_t)(dppass));
}
BEFORE(glStencilOpSeparate);
glStencilOpSeparatep(face, sfail, dpfail, dppass);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxxx",
(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",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xdddddxxp",
(uint64_t)(target), level, internalformat, width, height,
border, (uint64_t)(format), (uint64_t)(type),
voidp_to_uint64(data));
BEFORE(glTexParameterf);
glTexParameterfp(target, pname, param);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxf",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxf",
(uint64_t)(target), (uint64_t)(pname), param);
}
if(error == GL_NO_ERROR) {
char param0[8];
sprintf(param0, "%x", (GLenum)params[0]);
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
(uint64_t)(target), (uint64_t)(pname),
voidp_to_uint64(params));
} else {
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
(uint64_t)(target), (uint64_t)(pname),
voidp_to_uint64(params));
}
BEFORE(glTexParameteri);
glTexParameterip(target, pname, param);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxx",
(uint64_t)(target), (uint64_t)(pname),
(uint64_t)(param));
}
if(error == GL_NO_ERROR) {
char param0[8];
sprintf(param0, "%x", (GLenum)params[0]);
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, param0, "xxp",
(uint64_t)(target), (uint64_t)(pname),
voidp_to_uint64(params));
} else {
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "xxp",
(uint64_t)(target),
(uint64_t)(pname),
voidp_to_uint64(params));
glTexImage2Dp(target, level, xoffset, yoffset, width, height, format, type,
data);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
"xdddddxxp",
(uint64_t)(target), level, xoffset, yoffset, width, height,
(uint64_t)(format), (uint64_t)(type), voidp_to_uint64(data));
BEFORE(glUniform1f);
glUniform1fp(location, v0);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "df",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "df",
location, v0);
}
BEFORE(glUniform2f);
glUniform2fp(location, v0, v1);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dff",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dff",
location, v0, v1);
}
BEFORE(glUniform3f);
glUniform3fp(location, v0, v1, v2);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dfff",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dfff",
location, v0, v1, v2);
}
BEFORE(glUniform4f);
glUniform4fp(location, v0, v1, v2, v3);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
"dffff", location, v0, v1, v2, v3);
}
BEFORE(glUniform1fv);
glUniform1fvp(location, count, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
location, count, voidp_to_uint64(value));
}
BEFORE(glUniform2fv);
glUniform2fvp(location, count, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
location, count, voidp_to_uint64(value));
}
BEFORE(glUniform3fv);
glUniform3fvp(location, count, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
location, count, voidp_to_uint64(value));
}
BEFORE(glUniform4fv);
glUniform4fvp(location, count, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
location, count, voidp_to_uint64(value));
}
BEFORE(glUniform1i);
glUniform1ip(location, v0);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dd",
location, v0);
}
BEFORE(glUniform2i);
glUniform2ip(location, v0, v1);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddd",
location, v0, v1);
}
BEFORE(glUniform3i);
glUniform3ip(location, v0, v1, v2);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
location, v0, v1, v2);
}
BEFORE(glUniform4i);
glUniform4ip(location, v0, v1, v2, v3);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "",
"ddddd", location, v0, v1, v2, v3);
}
BEFORE(glUniform1iv);
glUniform1ivp(location, count, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
location, count, voidp_to_uint64(value));
}
BEFORE(glUniform2iv);
glUniform2ivp(location, count, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
location, count, voidp_to_uint64(value));
}
BEFORE(glUniform3iv);
glUniform3ivp(location, count, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
location, count, voidp_to_uint64(value));
}
BEFORE(glUniformMatrix2fv);
glUniformMatrix2fvp(location, count, transpose, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
location, count, (uint64_t)(transpose), voidp_to_uint64(value));
}
BEFORE(glUniformMatrix3fv);
glUniformMatrix3fvp(location, count, transpose, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
location, count, (uint64_t)(transpose), voidp_to_uint64(value));
}
BEFORE(glUniformMatrix4fv);
glUniformMatrix4fvp(location, count, transpose, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxp",
location, count, (uint64_t)(transpose), voidp_to_uint64(value));
}
BEFORE(glUniform4iv);
glUniform4ivp(location, count, value);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddp",
location, count, voidp_to_uint64(value));
}
BEFORE(glUseProgram);
glUseProgramp(program);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
program);
}
BEFORE(glValidateProgram);
glValidateProgramp(program);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "d",
program);
}
sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
"df", index, v0);
}
sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
"dff", index, v0, v1);
}
sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
"dfff", index, v0, v1, v2);
}
sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
"dffff", index, v0, v1, v2, v3);
}
sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
"dp", index, voidp_to_uint64(v));
}
sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
"dp", index, voidp_to_uint64(v));
}
sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
"dp", index, voidp_to_uint64(v));
}
sprintf(contextValue, "%f,%f,%f,%f", cv[0], cv[1], cv[2], cv[3]);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, contextValue,
"dp", index, voidp_to_uint64(v));
}
BEFORE(glVertexAttribPointer);
glVertexAttribPointerp(index, size, type, normalized, stride, pointer);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxxdp",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "ddxxdp",
index, size, (uint64_t)(type), (uint64_t)(normalized),
stride, voidp_to_uint64(pointer));
}
BEFORE(glViewport);
glViewportp(x, y, width, height);
error = glGetError();
- AFTER(NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
+ AFTER('v', NO_RETURN_VALUE, APITYPE_CONTEXT, "", "dddd",
x, y, width, height);
}
sprintf(maxValString, "%d,%d", maxVal[0], maxVal[1]); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_GL, vAPI_ID, "", 0); \
- PACK_COMMON_END(1, 0, 0); \
+ PACK_COMMON_END('p', 1, 0, 0); \
PACK_GL_ADD(APITYPE_INIT, 0, maxValString); \
FLUSH_LOCAL_BUF(); \
} \
} \
PRE_PROBEBLOCK()
-#define AFTER(RET_VAL, APITYPE, CONTEXT_VAL, INPUTFORMAT, ...) \
+#define AFTER(RET_TYPE, RET_VAL, APITYPE, CONTEXT_VAL, INPUTFORMAT, ...) \
POST_PACK_PROBEBLOCK_BEGIN(); \
PREPARE_LOCAL_BUF(); \
- PACK_COMMON_BEGIN(MSG_PROBE_GL, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
- PACK_COMMON_END(RET_VAL, error, blockresult); \
+ PACK_COMMON_BEGIN(MSG_PROBE_GL, vAPI_ID, INPUTFORMAT, __VA_ARGS__); \
+ PACK_COMMON_END(RET_TYPE, RET_VAL, error, blockresult); \
PACK_GL_ADD(APITYPE, get_current_nsec() - start_nsec, CONTEXT_VAL); \
FLUSH_LOCAL_BUF(); \
POST_PACK_PROBEBLOCK_END()
-#define AFTER_NO_PARAM(RETVAL, APITYPE, CONTEXTVALUE) \
- AFTER(RETVAL, APITYPE, CONTEXTVALUE, "", 0)
+#define AFTER_NO_PARAM(RET_TYPE, RETVAL, APITYPE, CONTEXTVALUE) \
+ AFTER(RET_TYPE, RETVAL, APITYPE, CONTEXTVALUE, "", 0)
#endif /* DA_GLES20_H_ */
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_malloc,
"x", (int64_t) size);
- PACK_COMMON_END(pret, newerrno, blockresult);
+ PACK_COMMON_END('p', pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_free,
"p", (int64_t)(int) ptr);
- PACK_COMMON_END(0, newerrno, blockresult);
+ PACK_COMMON_END('v', 0, newerrno, blockresult);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_realloc,
"px", voidp_to_uint64(memblock), (uint64_t) size);
- PACK_COMMON_END(pret, newerrno, blockresult);
+ PACK_COMMON_END('p', pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_calloc,
"xx", (uint64_t)nelem, (uint64_t)elsize);
- PACK_COMMON_END(pret, newerrno, blockresult);
+ PACK_COMMON_END('p', pret, newerrno, blockresult);
PACK_MEMORY(nelem * elsize, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
API_ID_memset,
"pdx", voidp_to_uint64(memblock), c,
(uint64_t)(n));
- PACK_COMMON_END(pret, newerrno, blockresult);
+ PACK_COMMON_END('p', pret, newerrno, blockresult);
PACK_MEMORY(n, MEMORY_API_MANAGE, pret);
FLUSH_LOCAL_BUF();
API_ID_memcmp,
"ppx", voidp_to_uint64(ptr1), voidp_to_uint64(ptr2),
(uint64_t)(num));
- PACK_COMMON_END(ret, newerrno, blockresult);
+ PACK_COMMON_END('d', ret, newerrno, blockresult);
PACK_MEMORY(num, MEMORY_API_MANAGE, ret);
FLUSH_LOCAL_BUF();
"ppx", voidp_to_uint64(destination),
voidp_to_uint64(source),
(uint64_t)(num));
- PACK_COMMON_END(pret, newerrno, blockresult);
+ PACK_COMMON_END('p', pret, newerrno, blockresult);
PACK_MEMORY(num, MEMORY_API_MANAGE, pret);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new_std__size_t_size__throw__std__bad_alloc_,
"x", (uint64_t)(size));
- PACK_COMMON_END(pret, newerrno, blockresult);
+ PACK_COMMON_END('p', pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new___std__size_t_size__throw__std__bad_alloc_,
"x", (uint64_t)(size));
- PACK_COMMON_END(pret, newerrno, blockresult);
+ PACK_COMMON_END('p', pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete_void__ptr__throw__,
"p", voidp_to_uint64(ptr));
- PACK_COMMON_END(0, newerrno, blockresult);
+ PACK_COMMON_END('v', 0, newerrno, blockresult);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete___void__ptr__throw__,
"p", voidp_to_uint64(ptr));
- PACK_COMMON_END(0, newerrno, blockresult);
+ PACK_COMMON_END('v', 0, newerrno, blockresult);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new_std__size_t_size__const_std__nothrow_t__nothrow__throw__,
"xp", (uint64_t)(size), voidp_to_uint64(¬hrow));
- PACK_COMMON_END(pret, newerrno, blockresult);
+ PACK_COMMON_END('p', pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new___std__size_t_size__const_std__nothrow_t__nothrow__throw__,
"xp", (uint64_t)(size), voidp_to_uint64(¬hrow));
- PACK_COMMON_END(pret, newerrno, blockresult);
+ PACK_COMMON_END('p', pret, newerrno, blockresult);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete_void__ptr__const_std__nothrow_t__nothrow__throw__,
"pp", voidp_to_uint64(ptr), voidp_to_uint64(¬hrow));
- PACK_COMMON_END(0, newerrno, blockresult);
+ PACK_COMMON_END('v', 0, newerrno, blockresult);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete___void__ptr__const_std__nothrow_t__nothrow__throw__,
"pp", voidp_to_uint64(ptr), voidp_to_uint64(¬hrow));
- PACK_COMMON_END(0, newerrno, blockresult);
+ PACK_COMMON_END('v', 0, newerrno, blockresult);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
if(postBlockBegin(blockresult)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
- PACK_COMMON_END(RETVALUE, errno, blockresult)
+ PACK_COMMON_END('p', RETVALUE, errno, blockresult)
//lib END Function
setProbePoint(&probeInfo); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
- PACK_COMMON_END(RETVALUE, errno, blockresult)
+ PACK_COMMON_END('p', RETVALUE, errno, blockresult)
#define BEFORE_ORIGINAL_TIZEN_NET(FUNCNAME, FUNCTIONPOINTER) \
DECLARE_VARIABLE_STANDARD_OSP_NET(FUNCNAME); \
if(postBlockBegin(blockresult)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
- PACK_COMMON_END(RETVALUE, errno, blockresult)
+ PACK_COMMON_END('p', RETVALUE, errno, blockresult)
#define APPEND_NETWORK_LOG_BASIC(LCTYPE, APINAME) \
log.length = sprintf(log.data, "%d`,%d`,%s`,%lu`,%d`,%d", \
if(postBlockBegin(blockresult)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
- PACK_COMMON_END(RETVALUE, errno, blockresult)
+ PACK_COMMON_END('p', RETVALUE, errno, blockresult)
#define POST_PROBEBLOCK_TIZEN_FUNC_END_BEGIN(APINAME, LCTYPE, RETTYPE, RETVALUE, INPUTFORMAT, ...) \
if(postBlockBegin(blockresult)) { \
setProbePoint(&probeInfo); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
- PACK_COMMON_END(RETVALUE, errno, blockresult)
+ PACK_COMMON_END('p', RETVALUE, errno, blockresult)
#define APPEND_LOG_TIZEN_RESULT(RETTYPE, RETVALUE) \
__appendTypeLog(&log, 4, NULL, RETTYPE, RETVALUE, VT_INT, 0, \
GET_REAL_FUNC(FUNCNAME, LIBNAME); \
PRE_PROBEBLOCK()
-#define AFTER_PACK_ORIGINAL_SYNC(API_ID, RVAL, SYNCVAL, SYNCTYPE, APITYPE, INPUTFORMAT, ...) \
- POST_PACK_PROBEBLOCK_BEGIN(); \
- PREPARE_LOCAL_BUF(); \
- PACK_COMMON_BEGIN(MSG_PROBE_SYNC, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL, errno, blockresult); \
- PACK_SYNC(SYNCVAL, SYNCTYPE, APITYPE); \
- FLUSH_LOCAL_BUF(); \
+#define AFTER_PACK_ORIGINAL_SYNC(API_ID, RTYPE, RVAL, SYNCVAL, SYNCTYPE, APITYPE, INPUTFORMAT, ...) \
+ POST_PACK_PROBEBLOCK_BEGIN(); \
+ PREPARE_LOCAL_BUF(); \
+ PACK_COMMON_BEGIN(MSG_PROBE_SYNC, API_ID, INPUTFORMAT, __VA_ARGS__); \
+ PACK_COMMON_END(RTYPE, RVAL, errno, blockresult); \
+ PACK_SYNC(SYNCVAL, SYNCTYPE, APITYPE); \
+ FLUSH_LOCAL_BUF(); \
POST_PACK_PROBEBLOCK_END()
#ifdef __cplusplus
GET_REAL_FUNC(FUNCNAME, LIBNAME); \
PRE_PROBEBLOCK()
-#define AFTER_PACK_ORIGINAL_THREAD(API_ID, RVAL, THREADVAL, APITYPE, INPUTFORMAT, ...) \
- POST_PACK_PROBEBLOCK_BEGIN(); \
- PREPARE_LOCAL_BUF(); \
+#define AFTER_PACK_ORIGINAL_THREAD(API_ID, RTYPE, RVAL, THREADVAL, APITYPE, INPUTFORMAT, ...) \
+ POST_PACK_PROBEBLOCK_BEGIN(); \
+ PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_THREAD, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RVAL, errno, blockresult); \
- PACK_THREAD(THREADVAL, THREAD_PTHREAD, APITYPE); \
- FLUSH_LOCAL_BUF(); \
+ PACK_COMMON_END(RTYPE, RVAL, errno, blockresult); \
+ PACK_THREAD(THREADVAL, THREAD_PTHREAD, APITYPE); \
+ FLUSH_LOCAL_BUF(); \
POST_PACK_PROBEBLOCK_END()
#endif // __DA_THREAD_H__
ret = pthread_mutex_initp(mutex, attr);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_init,
- ret, mutex, SYNC_PTHREAD_MUTEX,
+ 'd', ret, mutex, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "pp",
voidp_to_uint64(mutex), voidp_to_uint64(attr));
ret = pthread_mutex_destroyp(mutex);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_destroy,
- ret, mutex, SYNC_PTHREAD_MUTEX,
+ 'd', ret, mutex, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "p", voidp_to_uint64(mutex));
return ret;
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_mutex_lock,
"p", voidp_to_uint64(mutex));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('d', 0, 0, blockresult);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_mutex_lock,
"p", voidp_to_uint64(mutex));
- PACK_COMMON_END(ret, errno, blockresult);
+ PACK_COMMON_END('p', ret, errno, blockresult);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
API_ID_pthread_mutex_timedlock,
"pp", voidp_to_uint64(mutex),
voidp_to_uint64(abs_timeout));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('d', 0, 0, blockresult);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
API_ID_pthread_mutex_timedlock,
"pp", voidp_to_uint64(mutex),
voidp_to_uint64(abs_timeout));
- PACK_COMMON_END(ret, errno, blockresult);
+ PACK_COMMON_END('d', ret, errno, blockresult);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
ret = pthread_mutex_trylockp(mutex);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_trylock,
- ret, mutex, SYNC_PTHREAD_MUTEX,
+ 'd', ret, mutex, SYNC_PTHREAD_MUTEX,
SYNC_API_TRY_ACQUIRE, "p",
voidp_to_uint64(mutex));
ret = pthread_mutex_unlockp(mutex);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutex_unlock,
- ret, mutex, SYNC_PTHREAD_MUTEX,
+ 'd', ret, mutex, SYNC_PTHREAD_MUTEX,
SYNC_API_RELEASE, "p",
voidp_to_uint64(mutex));
ret = pthread_mutexattr_initp(attr);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_init,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "p",
voidp_to_uint64(attr));
ret = pthread_mutexattr_destroyp(attr);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_destroy,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "p",
voidp_to_uint64(attr));
ret = pthread_mutexattr_getprioceilingp(attr, prioceiling);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_getprioceiling,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "pp",
voidp_to_uint64(attr),
voidp_to_uint64(prioceiling));
ret = pthread_mutexattr_setprioceilingp(attr, prioceiling);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_setprioceiling,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "pd", voidp_to_uint64(attr),
prioceiling);
ret = pthread_mutexattr_getprotocolp(attr, protocol);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_getprotocol,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "pp",
voidp_to_uint64(attr),
voidp_to_uint64(protocol));
ret = pthread_mutexattr_setprotocolp(attr, protocol);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_setprotocol,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "pd", voidp_to_uint64(attr),
protocol);
ret = pthread_mutexattr_getpsharedp(attr, pshared);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_getpshared,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "pp",
voidp_to_uint64(attr),
voidp_to_uint64(pshared));
ret = pthread_mutexattr_setpsharedp(attr, pshared);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_setpshared,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "pd", voidp_to_uint64(attr),
pshared);
ret = pthread_mutexattr_gettypep(attr, type);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_gettype,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "pp",
voidp_to_uint64(attr),
voidp_to_uint64(type));
ret = pthread_mutexattr_settypep(attr, type);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_mutexattr_settype,
- ret, 0, SYNC_PTHREAD_MUTEX,
+ 'd', ret, 0, SYNC_PTHREAD_MUTEX,
SYNC_API_OTHER, "pd",
voidp_to_uint64(attr),
type);
ret = pthread_cond_initp(cond, attr);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_init,
- ret, cond, SYNC_PTHREAD_COND_VARIABLE,
+ 'd', ret, cond, SYNC_PTHREAD_COND_VARIABLE,
SYNC_API_OTHER, "pp",
voidp_to_uint64(cond),
voidp_to_uint64(attr));
ret = pthread_cond_destroyp(cond);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_destroy,
- ret, cond, SYNC_PTHREAD_COND_VARIABLE,
+ 'd', ret, cond, SYNC_PTHREAD_COND_VARIABLE,
SYNC_API_OTHER, "p",
voidp_to_uint64(cond));
"pp",
voidp_to_uint64(cond),
voidp_to_uint64(mutex));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('d', 0, 0, blockresult);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
FLUSH_LOCAL_BUF();
"pp",
voidp_to_uint64(cond),
voidp_to_uint64(mutex));
- PACK_COMMON_END(ret, errno, blockresult);
+ PACK_COMMON_END('d', ret, errno, blockresult);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
FLUSH_LOCAL_BUF();
voidp_to_uint64(cond),
voidp_to_uint64(mutex),
voidp_to_uint64(abstime));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('d', 0, 0, blockresult);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
FLUSH_LOCAL_BUF();
voidp_to_uint64(cond),
voidp_to_uint64(mutex),
voidp_to_uint64(abstime));
- PACK_COMMON_END(ret, errno, blockresult);
+ PACK_COMMON_END('d', ret, errno, blockresult);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
FLUSH_LOCAL_BUF();
ret = pthread_cond_signalp(cond);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_signal,
- ret, cond, SYNC_PTHREAD_COND_VARIABLE,
+ 'd', ret, cond, SYNC_PTHREAD_COND_VARIABLE,
SYNC_API_NOTIFY, "p", voidp_to_uint64(cond));
return ret;
ret = pthread_cond_broadcastp(cond);
AFTER_PACK_ORIGINAL_SYNC(API_ID_pthread_cond_broadcast,
- ret, cond, SYNC_PTHREAD_COND_VARIABLE,
+ 'd', ret, cond, SYNC_PTHREAD_COND_VARIABLE,
SYNC_API_NOTIFY_ALL, "p", voidp_to_uint64(cond));
return ret;
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID__da_cleanup_handler,
"p", voidp_to_uint64(data));
- PACK_COMMON_END(0, 0, 1);
+ PACK_COMMON_END('v', 0, 0, 1);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_STOP);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID__da_ThreadProc,
"p", voidp_to_uint64(params));
- PACK_COMMON_END(0, 0, 1);
+ PACK_COMMON_END('p', 0, 0, 1);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID__da_ThreadProc,
"p", voidp_to_uint64(params));
- PACK_COMMON_END(ret, 0, 1);
+ PACK_COMMON_END('p', 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,
+ 'd', ret, *thread, THREAD_API_START,
"pppp",
voidp_to_uint64(thread),
voidp_to_uint64(attr),
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_pthread_join,
"xp", (uint64_t)(thread), voidp_to_uint64(retval));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('d', 0, 0, blockresult);
PACK_THREAD(thread, THREAD_PTHREAD, THREAD_API_WAIT_START);
FLUSH_LOCAL_BUF();
"xp",
(uint64_t)(thread),
voidp_to_uint64(retval));
- PACK_COMMON_END(ret, errno, blockresult);
+ PACK_COMMON_END('d', ret, errno, blockresult);
PACK_THREAD(thread, THREAD_PTHREAD, THREAD_API_WAIT_END);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_pthread_exit,
"p", voidp_to_uint64(retval));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('v', 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",
+ 'd', 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",
+ 'd', ret, thread, THREAD_API_OTHER, "x",
(uint64_t)(thread));
return ret;
newerrno = errno;
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_self,
- ret_pthr, ret_pthr, THREAD_API_OTHER, "", 0);
+ 'p', ret_pthr, ret_pthr, THREAD_API_OTHER, "", 0);
return ret_pthr;
}
ret = pthread_equalp(t1, t2);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_equal,
- ret, t1, THREAD_API_OTHER, "xx",
+ 'd', ret, t1, THREAD_API_OTHER, "xx",
(uint64_t)(t1), (uint64_t)(t2));
return ret;
ret = pthread_setcancelstatep(state, oldstate);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_setcancelstate,
- ret, pSelf, THREAD_API_OTHER,
+ 'd', ret, pSelf, THREAD_API_OTHER,
"dp", state, voidp_to_uint64(oldstate));
return ret;
ret = pthread_setcanceltypep(type, oldtype);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_setcanceltype,
- ret, pSelf, THREAD_API_OTHER,
+ 'd', ret, pSelf, THREAD_API_OTHER,
"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",
+ 'd', 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",
+ 'd', ret, thread, THREAD_API_OTHER, "p",
voidp_to_uint64(attr));
return ret;
ret = pthread_attr_getdetachstatep(attr, detachstate);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getdetachstate,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp", voidp_to_uint64(attr),
voidp_to_uint64(detachstate));
ret = pthread_attr_setdetachstatep(attr, detachstate);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setdetachstate,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pd", voidp_to_uint64(attr),
detachstate);
ret = pthread_attr_getstacksizep(attr, stacksize);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getstacksize,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp", voidp_to_uint64(attr),
voidp_to_uint64(stacksize));
ret = pthread_attr_setstacksizep(attr, stacksize);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setstacksize,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"px", voidp_to_uint64(attr),
(uint64_t)(stacksize));
ret = pthread_attr_getstackaddrp(attr, stackaddr);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getstackaddr,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp", voidp_to_uint64(attr),
voidp_to_uint64(stackaddr));
ret = pthread_attr_setstackaddrp(attr, stackaddr);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setstackaddr,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp",
voidp_to_uint64(attr),
voidp_to_uint64(stackaddr));
ret = pthread_attr_getinheritschedp(attr, inheritsched);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getinheritsched,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp", voidp_to_uint64(attr),
voidp_to_uint64(inheritsched));
ret = pthread_attr_setinheritschedp(attr, inheritsched);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setinheritsched,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pd", voidp_to_uint64(attr),
inheritsched);
ret = pthread_attr_getschedparamp(attr, param);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getschedparam,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp", voidp_to_uint64(attr),
voidp_to_uint64(param));
ret = pthread_attr_setschedparamp(attr, param);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setschedparam,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp",
voidp_to_uint64(attr),
voidp_to_uint64(param));
ret = pthread_attr_getschedpolicyp(attr, policy);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getschedpolicy,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp", voidp_to_uint64(attr),
voidp_to_uint64(policy));
ret = pthread_attr_setschedpolicyp(attr, policy);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setschedpolicy,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pd", voidp_to_uint64(attr),
policy);
ret = pthread_attr_getguardsizep(attr, guardsize);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getguardsize,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp", voidp_to_uint64(attr),
voidp_to_uint64(guardsize));
ret = pthread_attr_setguardsizep(attr, guardsize);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setguardsize,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"px", voidp_to_uint64(attr),
(uint64_t)(guardsize));
ret = pthread_attr_getscopep(attr, contentionscope);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getscope,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pp", voidp_to_uint64(attr),
voidp_to_uint64(contentionscope));
ret = pthread_attr_setscopep(attr, contentionscope);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setscope,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"pd", voidp_to_uint64(attr), contentionscope);
return ret;
ret = pthread_attr_getstackp(attr, stackaddr, stacksize);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_getstack,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"ppp", voidp_to_uint64(attr),
voidp_to_uint64(stackaddr),
voidp_to_uint64(stacksize));
ret = pthread_attr_setstackp(attr, stackaddr, stacksize);
AFTER_PACK_ORIGINAL_THREAD(API_ID_pthread_attr_setstack,
- ret, thread, THREAD_API_OTHER,
+ 'd', ret, thread, THREAD_API_OTHER,
"ppx", voidp_to_uint64(attr),
voidp_to_uint64(stackaddr),
(uint64_t)(stacksize));
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_UiApp__AddFrame_const_Tizen__Ui__Controls__Frame__frame_,
"p", voidp_to_uint64(&frame));
- PACK_COMMON_END(ret, 0, 0);
+ PACK_COMMON_END('p', ret, 0, 0);
PACK_UICONTROL(parent);
PACK_UICONTROL(&frame);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_UiApp__RemoveFrame_const_Tizen__Ui__Controls__Frame__frame_,
"p", voidp_to_uint64(&frame));
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
PACK_UICONTROL(parent);
PACK_UICONTROL(&frame);
}
if(bOption)
{
- PACK_RETURN_END(ret);
+ PACK_RETURN_END('p', ret);
}
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_void_Control__SetName_const_Tizen__Base__String__name_,
"p", voidp_to_uint64(&name));
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(parent);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_Container__AddControl_const_Control__control_,
"p", voidp_to_uint64(&control));
- PACK_COMMON_END(ret, 0, 0);
+ PACK_COMMON_END('p', ret, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(&control);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_Container__AddControl_Control__control_,
"p", voidp_to_uint64(control));
- PACK_COMMON_END(ret, 0, 0);
+ PACK_COMMON_END('p', ret, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(control);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_Container__RemoveControl_const_Control__control_,
"p", voidp_to_uint64(&control));
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(&control);
}
if(bOption)
{
- PACK_RETURN_END(ret);
+ PACK_RETURN_END('p', ret);
}
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_Container__RemoveControl_Control__control_,
"p", voidp_to_uint64(control));
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(control);
}
if(bOption)
{
- PACK_RETURN_END(ret);
+ PACK_RETURN_END('p', ret);
}
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_result_Container__RemoveControl_int_index_,
"d", index);
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(pcontrol);
}
if(bOption)
{
- PACK_RETURN_END(ret);
+ PACK_RETURN_END('p', ret);
}
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UICONTROL,
API_ID_void_Container__RemoveAllControls_void_,
"", 0);
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
PACK_UICONTROL(this);
PACK_UICONTROL(pcontrol);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID_result_File__Construct_const_Tizen__Base__String__filePath__const_Tizen__Base__String__openMode__bool_createParentDirectories_,
"ssd", absolutize_filepath(buffer,temp_path),
temp_mode, createParentDirectories);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OPEN, size, temp_path);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Construct_const_Tizen__Base__String__filePath__const_Tizen__Base__String__openMode_,
- "ss", absolutize_filepath(buffer, temp_path),
- temp_mode);
- PACK_COMMON_END(ret, ret, blockresult);
+ "ss", absolutize_filepath(buffer, temp_path), temp_mode);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OPEN, size, temp_path);
FLUSH_LOCAL_BUF();
API_ID_result_File__Construct_const_Tizen__Base__String__filePath__const_char__pOpenMode_,
"sp", absolutize_filepath(buffer, temp),
voidp_to_uint64(pOpenMode));
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OPEN, size, temp);
FLUSH_LOCAL_BUF();
API_ID_result_File__Construct_const_Tizen__Base__String__filePath__const_char__pOpenMode__const_Tizen__Base__ByteBuffer__secretKey_,
"sp", temp,
voidp_to_uint64(pOpenMode));
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OPEN, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Flush_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OTHER, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_Tizen__Base__String_File__GetName_void__const,
"", 0);
- PACK_COMMON_END(ret.GetPointer(), res, blockresult);
+ PACK_COMMON_END('p', ret.GetPointer(), res, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OTHER, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Read_Tizen__Base__String__buffer_,
"x", (uint64_t)(&buffer));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_READ_START, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Read_Tizen__Base__String__buffer_,
"x", (uint64_t)(&buffer));
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(nRead, (unsigned long)this, FD_API_READ_END, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Read_Tizen__Base__ByteBuffer__buffer_,
"x", (uint64_t)(&buffer));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_READ_START, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Read_Tizen__Base__ByteBuffer__buffer_,
"x", (uint64_t)(&buffer));
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(nRead, (unsigned long)this, FD_API_READ_END, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_int_File__Read_void__buffer__int_length_,
"xd", (uint64_t)(buffer), length);
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_READ_START, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_int_File__Read_void__buffer__int_length_,
"xd", (uint64_t)(buffer), length);
- PACK_COMMON_END(ret, res, blockresult);
+ PACK_COMMON_END('p', ret, res, blockresult);
PACK_RESOURCE(nRead, (unsigned long)this, FD_API_READ_END, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Seek_FileSeekPosition_position__long_offset_,
"sx", temp_pos, (uint64_t)(offset));
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OTHER, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_int_File__Tell_void__const,
"", 0);
- PACK_COMMON_END(ret, res, blockresult);
+ PACK_COMMON_END('p', ret, res, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OTHER, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Truncate_int_length_,
"d", length);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_OTHER, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_void__buffer__int_length_,
"xd", (uint64_t)(buffer), length);
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_WRITE_START, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_void__buffer__int_length_,
"xd", (uint64_t)(buffer), length);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(nWritten, (unsigned long)this, FD_API_WRITE_END, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_Tizen__Base__ByteBuffer__buffer_,
"x", (uint64_t)(&buffer));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_WRITE_START, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_Tizen__Base__ByteBuffer__buffer_,
"x", (uint64_t)(&buffer));
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(nWritten, (unsigned long)this, FD_API_WRITE_END, size, temp);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_Tizen__Base__String__buffer_,
"s", temp_buf);
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_WRITE_START, size, temp_path);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_result_File__Write_const_Tizen__Base__String__buffer_,
"s", temp_buf);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_RESOURCE(nWritten, (unsigned long)this, FD_API_WRITE_END, size, temp_path);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_File___File_void_,
"", 0);
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_RESOURCE(0, (unsigned long)this, FD_API_CLOSE, size, "");
FLUSH_LOCAL_BUF();
API_ID_result_UiApp__Execute_UiAppInstanceFactory_pUiAppFactory__const_IList__pArguments_,
"pp", (uint64_t)(pUiAppFactory),
voidp_to_uint64(pArguments));
- PACK_COMMON_END(ret, 0, 0);
+ PACK_COMMON_END('p', ret, 0, 0);
FLUSH_LOCAL_BUF();
unregister_orientation_event_listener(handler);
PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE,
API_ID_void__AppImpl__OnTerminate_void__user_data_,
"p", voidp_to_uint64(user_data));
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
FLUSH_LOCAL_BUF();
probeBlockEnd();
PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE,
API_ID_void__AppInfo__SetAppState_AppState_appState_,
"p", (uint64_t)(appState));
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
FLUSH_LOCAL_BUF();
}
probeBlockEnd();
PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE,
API_ID_void__UiAppImpl__OnBackground_void_,
"", 0);
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
FLUSH_LOCAL_BUF();
probeBlockEnd();
PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE,
API_ID_void__UiAppImpl__OnForeground_void_,
"", 0);
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('p', 0, 0, 0);
FLUSH_LOCAL_BUF();
SCREENSHOT_UNLOCK();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Mutex__Create_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MUTEX, SYNC_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Mutex__Create_const_Tizen__Base__String__name_,
"s", temp);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MUTEX, SYNC_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Mutex__Release_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MUTEX, SYNC_API_RELEASE);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Mutex__Acquire_void_,
"", 0);
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Mutex__Acquire_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Mutex__TryToAcquire_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MUTEX, SYNC_API_TRY_ACQUIRE);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Semaphore__Create_int_count_,
"d", count);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_SEMAPHORE, SYNC_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Semaphore__Create_const_Tizen__Base__String__name__int_count_,
"sd", temp, count);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_SEMAPHORE, SYNC_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Semaphore__Acquire_long_timeout_,
"x", (uint64_t)(timeout));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_SEMAPHORE, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Semaphore__Acquire_long_timeout_,
"x", (uint64_t)(timeout));
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_SEMAPHORE, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Semaphore__TryToAcquire_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_SEMAPHORE, SYNC_API_TRY_ACQUIRE);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Semaphore__Release_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_SEMAPHORE, SYNC_API_RELEASE);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Monitor__Construct_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MONITOR, SYNC_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Monitor__Enter_void_,
"", 0);
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MONITOR, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Monitor__Enter_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MONITOR, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Monitor__Exit_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MONITOR, SYNC_API_RELEASE);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Monitor__Wait_void_,
"", 0);
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MONITOR, SYNC_API_COND_WAIT_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Monitor__Wait_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MONITOR, SYNC_API_COND_WAIT_END);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Monitor__Notify_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MONITOR, SYNC_API_NOTIFY);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_result_Monitor__NotifyAll_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_SYNC((unsigned int) this, SYNC_TIZEN_MONITOR, SYNC_API_NOTIFY_ALL);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_void___ThreadImpl__ThreadProc_void__params_,
"p", voidp_to_uint64(params));
- PACK_COMMON_END((unsigned int)pSelf, 0, blockresult);
+ PACK_COMMON_END('p', (unsigned int)pSelf, 0, blockresult);
PACK_THREAD((unsigned int)pThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_INTERNAL_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_void___ThreadImpl__ThreadProc_void__params_,
"p", voidp_to_uint64(params));
- PACK_COMMON_END((unsigned int)pSelf, 0, blockresult);
+ PACK_COMMON_END('p', (unsigned int)pSelf, 0, blockresult);
PACK_THREAD((unsigned int)pThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_INTERNAL_STOP);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Sleep_long_milliSeconds_,
"x", (uint64_t)(milliSeconds));
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Yield_void_,
"x", (uint64_t)(milliSeconds));
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_END);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_Thread__Thread__GetCurrentThread_void_,
"", 0);
- PACK_COMMON_END((unsigned int)currentThread, res, blockresult);
+ PACK_COMMON_END('p', (unsigned int)currentThread, res, blockresult);
PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Yield_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Exit_int_exitCode_,
"d", exitCode);
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_THREAD((unsigned int)currentThread, THREAD_TIZENTHREAD_WORKER, THREAD_API_EXIT);
FLUSH_LOCAL_BUF();
API_ID_result_Thread__Construct_ThreadType_threadType__long_stackSize__ThreadPriority_priority_,
"dxd", threadType, (uint64_t)(stackSize),
priority);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Construct_long_stackSize__ThreadPriority_priority_,
"xd", (uint64_t)(stackSize), priority);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Construct_const_Tizen__Base__String__name__long_stackSize__ThreadPriority_priority_,
"sxd", temp, (uint64_t)(stackSize), priority);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
API_ID_result_Thread__Construct_const_Tizen__Base__String__name__ThreadType_threadType__long_stackSize__ThreadPriority_priority_,
"sdxd", temp, threadType,
(uint64_t)(stackSize), priority);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
API_ID_result_Thread__Construct_IRunnable__target__long_stackSize__ThreadPriority_priority_,
"xxd", (uint64_t)(&target),
(uint64_t)(stackSize), priority);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
API_ID_result_Thread__Construct_const_Tizen__Base__String__name__IRunnable__target__long_stackSize__ThreadPriority_priority_,
"sxxd", temp, (uint64_t)(&target),
(uint64_t)(stackSize), priority);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__GetExitCode_int__exitCode__const,
"d", exitCode);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_const_Tizen__Base__String___Thread__GetName_void__const,
"", 0);
- PACK_COMMON_END(ret.GetPointer(), res, blockresult);
+ PACK_COMMON_END('p', ret.GetPointer(), res, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_OTHER);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Join_void_,
"", 0);
- PACK_COMMON_END(0, 0, blockresult);
+ PACK_COMMON_END('p', 0, 0, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Join_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_WAIT_END);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Start_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_Thread__Stop_void_,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_WORKER, THREAD_API_STOP);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_EventDrivenThread__Construct_long_stackSize__ThreadPriority_priority_,
"xd", (uint64_t)(stackSize), priority);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_EventDrivenThread__Construct_const_Tizen__Base__String__name__long_stackSize__ThreadPriority_priority_,
"sx", temp, (uint64_t)(stackSize));
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_NEW);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_result_EventDrivenThread__Quit__,
"", 0);
- PACK_COMMON_END(ret, ret, blockresult);
+ PACK_COMMON_END('p', ret, ret, blockresult);
PACK_THREAD((unsigned int) this, THREAD_TIZENTHREAD_EVENTDRIVEN, THREAD_API_STOP);
FLUSH_LOCAL_BUF();
"pp",
voidp_to_uint64(&previousSceneId),
voidp_to_uint64(¤tSceneId));
- PACK_COMMON_END(0, 0, 0);
+ PACK_COMMON_END('v', 0, 0, 0);
PACK_SCENE(scene_name, formid, pform, panelid, ppanel, transition, user);
FLUSH_LOCAL_BUF();
}
projects / platform / core / system / swap-probe.git / commitdiff