instruction
stringlengths 27
1.78k
| output
stringlengths 21
2.78k
|
|---|---|
void _set_no_clock(void)
{
fprintf((FILE *)(ulong)stderr,"_set_no_clock should not be used\n");
/* WARNING: Subroutine does not return */
exit(2);
}
|
void _set_no_clock( BranchModel *bm, const int index, const double value ){
fprintf(stderr, "_set_no_clock should not be used\n");
exit(2);
}
|
void multistate(long *param_1,long param_2)
{
if ((*param_1 != param_2) && (*param_1 = param_2, param_2 == CURLM_STATE_COMPLETED)) {
**(int **)param_1[1] = **(int **)param_1[1] + -1;
}
return;
}
|
void multistate(struct Curl_one_easy *easy, CURLMstate state)
{
CURLMstate oldstate = easy->state;
if(oldstate == state)
return;
easy->state = state;
# 227 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/anasazi/POP-REU-Project/refs/heads/master/QMOLEDEV/cmake-2.6.0/Utilities/cmcurl/multi.c"
if(state == CURLM_STATE_COMPLETED)
easy->easy_handle->multi->num_alive--;
}
|
undefined4 InitPartCircles(undefined8 param_1,undefined8 param_2,undefined4 param_3)
{
GenerateCircles(param_1,param_2,True,False);
return param_3;
}
|
int
InitPartCircles(XParms xp, Parms p, int reps)
{
GenerateCircles(xp, p, True, False);
return reps;
}
|
char spu_backing_mbox_read(long *param_1,undefined4 *param_2)
{
undefined4 uVar1;
char cVar2;
spin_lock(param_1 + 1);
cVar2 = *(char *)((long)param_1 + 0xc);
if (cVar2 != '\0') {
cVar2 = '\x04';
*param_2 = *(undefined4 *)(param_1 + 2);
*(uint *)((long)param_1 + 0xc) = *(uint *)((long)param_1 + 0xc) & 0xffffff00;
uVar1 = MFC_PU_MAILBOX_AVAILABLE_EVENT;
*(undefined4 *)(*param_1 + 0x70) = 1;
gen_spu_event(param_1,uVar1);
}
spin_unlock(param_1 + 1);
return cVar2;
}
|
int spu_backing_mbox_read(struct spu_context *ctx, u32 * data)
{
u32 mbox_stat;
int ret = 0;
spin_lock(&ctx->csa.register_lock);
mbox_stat = ctx->csa.prob.mb_stat_R;
if (mbox_stat & 0x0000ff) {
/* Read the first available word.
* Implementation note: the depth
* of pu_mb_R is currently 1.
*/
*data = ctx->csa.prob.pu_mb_R;
ctx->csa.prob.mb_stat_R &= ~(0x0000ff);
ctx->csa.spu_chnlcnt_RW[28] = 1;
gen_spu_event(ctx, MFC_PU_MAILBOX_AVAILABLE_EVENT);
ret = 4;
}
spin_unlock(&ctx->csa.register_lock);
return ret;
}
|
tcv_write(undefined8 *param_1,undefined4 param_2,undefined4 param_3,long param_4,undefined8 param_5)
{
int iVar1;
undefined4 uVar2;
long lVar3;
iVar1 = tcv_check_and_lock_ok();
if ((param_4 == 0) || (iVar1 == 0)) {
uVar2 = 0xfffffffc;
}
else {
uVar2 = 0xfffffff3;
lVar3 = tcv_is_initialized(param_1);
if (lVar3 != 0) {
uVar2 = (**(code **)*param_1)(param_1,param_2,param_3,param_4,param_5);
}
tcv_unlock(param_1);
}
return uVar2;
}
|
int tcv_write(tcv_t *tcv, uint8_t devaddr, uint8_t regaddr, const uint8_t* data, size_t len)
{
int ret = -13;
if (!tcv_check_and_lock_ok(tcv) || !data)
return -4;
if (tcv_is_initialized(tcv)) {
ret = tcv->fun->raw_write(tcv, devaddr, regaddr, data, len);
}
tcv_unlock(tcv);
return ret;
}
|
undefined8 * new_space_atom(undefined8 param_1,int param_2,undefined8 param_3)
{
undefined4 uVar1;
undefined8 *puVar2;
puVar2 = (undefined8 *)mymalloc(0x18);
if (param_2 < 1) {
general_error(4,0,0x189,
"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/jfdelnero/HXCFE_Amiga_file_selector/refs/heads/master/atari_st/build-tools/vbcc/src/vasm/atom.c"
);
}
puVar2[2] = 0;
*puVar2 = 0x100000004;
uVar1 = new_sblock(param_1,param_2,param_3);
*(undefined4 *)(puVar2 + 1) = uVar1;
return puVar2;
}
|
atom *new_space_atom(expr *space,int size,expr *fill)
{
atom *new = mymalloc(sizeof(*new));
int i;
if (size<1)
general_error(4,(0),393,"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/jfdelnero/HXCFE_Amiga_file_selector/refs/heads/master/atari_st/build-tools/vbcc/src/vasm/atom.c");
new->next = 0;
new->type = 4;
new->align = 1;
new->content.sb = new_sblock(space,size,fill);
return new;
}
|
void vector_shrink(int *param_1)
{
int iVar1;
void *pvVar2;
assert();
iVar1 = param_1[1];
if (*param_1 <= iVar1) {
*param_1 = iVar1;
return;
}
pvVar2 = realloc((void *)(ulong)(uint)param_1[3],(ulong)(uint)(iVar1 * param_1[2]));
param_1[3] = (int)pvVar2;
*param_1 = param_1[1];
return;
}
|
void
vector_shrink( vector_t *self )
{
assert( self );
if( self->capacity > self->size )
{
self->items = realloc( self->items, self->size * self->item_size );
}
self->capacity = self->size;
}
|
long yy_try_NUL_trans(long param_1)
{
long lVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
lVar3 = param_1 * 8;
if (*(long *)(yy_accept + param_1 * 8) != 0) {
yy_last_accepting_cpos = yy_c_buf_p;
yy_last_accepting_state = param_1;
}
lVar1 = *(long *)(yy_base + param_1 * 8) + 1;
if (param_1 != *(long *)(yy_chk + lVar1 * 8)) {
uVar4 = 1;
uVar5 = 1;
do {
uVar2 = (ulong)*(int *)(yy_def + lVar3);
if (0x15f < uVar2) {
uVar4 = *(ulong *)(yy_meta + uVar5 * 8);
uVar5 = uVar4 & 0xffffffff;
}
lVar1 = *(long *)(yy_base + uVar2 * 8);
lVar3 = uVar2 * 8;
} while (*(ulong *)(yy_chk + (lVar1 + uVar4) * 8) != uVar2);
lVar1 = lVar1 + uVar5;
}
lVar3 = *(long *)(yy_nxt + lVar1 * 8);
if (lVar3 == 0x15f) {
lVar3 = 0;
}
return lVar3;
}
|
yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
{
register int yy_is_jam;
register char *yy_cp = (yy_c_buf_p);
register YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 352 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
yy_is_jam = (yy_current_state == 351);
return yy_is_jam ? 0 : yy_current_state;
}
|
int * map_init(int param_1,int param_2)
{
int *piVar1;
void *pvVar2;
int local_14;
piVar1 = (int *)malloc(0x20);
pvVar2 = malloc((ulong)(uint)(param_1 << 3));
*(void **)(piVar1 + 6) = pvVar2;
pvVar2 = malloc((ulong)(uint)(param_1 << 3));
*(void **)(piVar1 + 4) = pvVar2;
for (local_14 = 0; local_14 < param_1; local_14 = local_14 + 1) {
pvVar2 = malloc((ulong)(uint)(param_2 << 2));
*(void **)(*(long *)(piVar1 + 6) + (long)local_14 * 8) = pvVar2;
pvVar2 = malloc((ulong)(uint)(param_2 << 2));
*(void **)(*(long *)(piVar1 + 4) + (long)local_14 * 8) = pvVar2;
}
*piVar1 = param_1;
piVar1[1] = param_2;
*(undefined8 *)(piVar1 + 2) = 0;
return piVar1;
}
|
map_t *map_init(int8_t n, int8_t m)
{
map_t *temp;
int8_t i;
temp = (map_t *)malloc(sizeof(map_t));
temp->map = (int16_t **)malloc(sizeof(int16_t *) * n);
temp->path = (int16_t **)malloc(sizeof(int16_t *) * n);
i = 0;
while(i < n)
{
*(temp->map+i) = (int16_t *)malloc(m*sizeof(int16_t));
*(temp->path+i) = (int16_t *)malloc(m*sizeof(int16_t));
i++;
}
temp->n = n;
temp->m = m;
temp->result = 0;
return temp;
}
|
void entry_acqref(int *param_1)
{
*param_1 = *param_1 + 1;
return;
}
|
void
entry_acqref(struct entry *entry)
{
entry->en_nsamples++;
}
|
int i2_shiftLeft(int param_1,byte param_2)
{
return param_1 << (param_2 & 0x1f);
}
|
i2 i2_shiftLeft(i2 lhs, i2 rhs)
{
i2 z;
z = lhs << rhs;
return z;
}
|
void lowpan_unregister_netdevice(undefined8 param_1)
{
unregister_netdevice();
lowpan_dev_debugfs_exit(param_1);
return;
}
|
void lowpan_unregister_netdevice(struct net_device *dev)
{
unregister_netdevice(dev);
lowpan_dev_debugfs_exit(dev);
}
|
undefined8 md5__encode(long param_1,long param_2,uint param_3)
{
uint local_10;
uint local_c;
local_10 = 0;
for (local_c = 0; local_c < param_3; local_c = local_c + 4) {
*(char *)(param_1 + (ulong)local_c) = (char)*(undefined4 *)(param_2 + (ulong)local_10 * 4);
*(char *)(param_1 + (ulong)(local_c + 1)) =
(char)((uint)*(undefined4 *)(param_2 + (ulong)local_10 * 4) >> 8);
*(char *)(param_1 + (ulong)(local_c + 2)) =
(char)((uint)*(undefined4 *)(param_2 + (ulong)local_10 * 4) >> 0x10);
*(char *)(param_1 + (ulong)(local_c + 3)) =
(char)((uint)*(undefined4 *)(param_2 + (ulong)local_10 * 4) >> 0x18);
local_10 = local_10 + 1;
}
return 1;
}
|
int md5__encode(unsigned char *output, uint32_t *input,
unsigned int len)
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4) {
output[j] = (unsigned char)(input[i] & 0xff);
output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
}
return(1);
}
|
void write_list(undefined8 param_1,undefined8 param_2,char *param_3)
{
long in_FS_OFFSET;
undefined8 local_2c;
uint local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_2c = 0;
strcpy((char *)(ulong)local_24,param_3);
write_list_pattern(param_1,param_2,&local_2c);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void
write_list(FILE *out, const string_list *list, const char *pstr)
{ string_pattern pat;
pat.upper_case = ((bool)0);
pat.drop_extn = ((bool)0);
strcpy(pat.pattern, pstr);
write_list_pattern(out, list, &pat);
}
|
int git_config__update_entry
(undefined8 param_1,undefined8 param_2,char *param_3,int param_4,int param_5)
{
int iVar1;
long in_FS_OFFSET;
int local_1c;
char **local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = (char **)0x0;
local_1c = git_config__lookup_entry(&local_18,param_1,param_2,0);
if (-1 < local_1c) {
if ((local_18 == (char **)0x0) && (param_5 != 0)) {
local_1c = 0;
}
else if ((local_18 == (char **)0x0) || (param_4 != 0)) {
if ((((param_3 == (char *)0x0) || (local_18 == (char **)0x0)) || (*local_18 == (char *)0x0))
|| (iVar1 = strcmp(*local_18,param_3), iVar1 != 0)) {
if ((param_3 == (char *)0x0) && ((local_18 == (char **)0x0 || (*local_18 == (char *)0x0))))
{
local_1c = 0;
}
else {
if (param_3 == (char *)0x0) {
local_1c = git_config_delete_entry(param_1,param_2);
}
else {
local_1c = git_config_set_string(param_1,param_2,param_3);
}
git_config_entry_free(local_18);
}
}
else {
local_1c = 0;
}
}
else {
local_1c = 0;
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_1c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int git_config__update_entry(
git_config *config,
const char *key,
const char *value,
bool overwrite_existing,
bool only_if_existing)
{
int error = 0;
git_config_entry *ce = NULL;
if ((error = git_config__lookup_entry(&ce, config, key, false)) < 0)
return error;
if (!ce && only_if_existing) /* entry doesn't exist */
return 0;
if (ce && !overwrite_existing) /* entry would be overwritten */
return 0;
if (value && ce && ce->value && !strcmp(ce->value, value)) /* no change */
return 0;
if (!value && (!ce || !ce->value)) /* asked to delete absent entry */
return 0;
if (!value)
error = git_config_delete_entry(config, key);
else
error = git_config_set_string(config, key, value);
git_config_entry_free(ce);
return error;
}
|
undefined8 m2_el_vsb_fn(int *param_1)
{
int iVar1;
undefined4 uVar2;
undefined4 uVar3;
undefined4 uVar4;
undefined4 uVar5;
undefined4 uVar6;
undefined8 uVar7;
iVar1 = *param_1;
if (iVar1 == 0x12) {
uVar7 = m2_el_slbase_calc_width(param_1[1]);
return uVar7;
}
if (iVar1 < 0x13) {
if (iVar1 == 0x10) {
return 1;
}
if (iVar1 == 0x11) {
uVar7 = m2_el_slbase_calc_height(param_1[1]);
return uVar7;
}
}
else if (iVar1 == 0x28) {
m2_el_slbase_adjust_top_to_cnt(param_1[1]);
iVar1 = param_1[2];
uVar2 = m2_el_slbase_get_visible_lines(param_1[1]);
uVar3 = m2_el_slbase_get_top(param_1[1]);
uVar4 = m2_el_slbase_get_len(param_1[1]);
uVar5 = m2_el_slbase_calc_height(param_1[1]);
uVar6 = m2_el_slbase_calc_width(param_1[1]);
m2_gfx_draw_vertical_scroll_bar
(((undefined4 *)(long)iVar1)[1],*(undefined4 *)(long)iVar1,uVar6,uVar5,uVar4,uVar3,
uVar2);
}
uVar7 = m2_el_fnfmt_fn(param_1);
return uVar7;
}
|
uint8_t m2_el_vsb_fn(m2_el_fnarg_p fn_arg)
{
switch(fn_arg->msg)
{
case 16:
return 1;
case 17:
return m2_el_slbase_calc_height(fn_arg->element);
case 18:
return m2_el_slbase_calc_width(fn_arg->element);
# 54 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/bdagerman/arduino-projects/refs/heads/master/libraries/M2tklib/utility/m2elsb.c"
case 40:
m2_el_slbase_adjust_top_to_cnt(fn_arg->element);
{
m2_pos_p b = (m2_pos_p)(fn_arg->data);
m2_gfx_draw_vertical_scroll_bar(b->x, b->y,
m2_el_slbase_calc_width(fn_arg->element),
m2_el_slbase_calc_height(fn_arg->element),
m2_el_slbase_get_len(fn_arg->element),
m2_el_slbase_get_top(fn_arg->element),
m2_el_slbase_get_visible_lines(fn_arg->element));
}
break;
}
return m2_el_fnfmt_fn(fn_arg);
}
|
undefined4 repeat_from_dict(undefined8 param_1,undefined4 param_2,undefined8 param_3,long param_4)
{
undefined4 uVar1;
long local_10;
for (local_10 = 0; local_10 < param_4; local_10 = local_10 + 1) {
uVar1 = peek_back(param_1,param_3);
put_byte(param_1,uVar1);
}
return param_2;
}
|
int repeat_from_dict(struct private* pz, int state, uint rep, uint n)
{
uint i;
for(i = 0; i < n; i++)
put_byte(pz, peek_back(pz, rep));
return state;
}
|
void turn_right(void)
{
long lVar1;
lVar1 = motor;
*(undefined4 *)(motor + frontLeft * 4) = 0x50;
*(undefined4 *)(lVar1 + centerLeft * 4) = 0x50;
*(undefined4 *)(lVar1 + backLeft * 4) = 0x50;
*(undefined4 *)(lVar1 + frontRight * 4) = 0;
*(undefined4 *)(lVar1 + centerRight * 4) = 0;
*(undefined4 *)(lVar1 + backRight * 4) = 0;
return;
}
|
void turn_right()
{
motor[frontLeft] = 80;
motor[centerLeft] = 80;
motor[backLeft] = 80;
motor[frontRight] = 0;
motor[centerRight] = 0;
motor[backRight] = 0;
}
|
void closeSerial(int param_1)
{
close(param_1);
return;
}
|
int closeSerial(int fd) {
return(close(fd));
}
|
void spawn(void)
{
nocall("spawn");
return;
}
|
void spawn(void) { nocall("spawn"); }
|
int sg_process_compare_pid(long *param_1,long *param_2)
{
long lVar1;
long lVar2;
int iVar3;
lVar1 = *param_2;
iVar3 = 0;
lVar2 = *param_1;
if (lVar2 != lVar1) {
iVar3 = ((lVar1 <= lVar2) - 1) + (uint)(lVar1 <= lVar2);
}
return iVar3;
}
|
int sg_process_compare_pid(const void *va, const void *vb) {
const sg_process_stats *a = va, *b = vb;
return (a->pid == b->pid) ? 0 : (a->pid < b->pid) ? -1 : 1;
}
|
undefined8 get_data_reg(long *param_1,uint param_2,long *param_3,int *param_4)
{
uint *puVar1;
uint uVar2;
int iVar3;
undefined8 uVar4;
byte bVar5;
uint uVar6;
puVar1 = (uint *)(param_1[2] + (ulong)param_2 * 8);
iVar3 = enum_in_range(puVar1[1],param_1 + 1);
if (iVar3 == 0) {
uVar4 = 0xffffffff;
}
else {
uVar2 = *puVar1;
uVar6 = PINMUX_FLAG_DBIT & uVar2;
bVar5 = (byte)PINMUX_FLAG_DBIT_SHIFT;
*param_3 = *param_1 +
(long)((int)(uVar2 & PINMUX_FLAG_DREG) >> ((byte)PINMUX_FLAG_DREG_SHIFT & 0x1f)) * 4;
uVar4 = 0;
*param_4 = (int)uVar6 >> (bVar5 & 0x1f);
}
return uVar4;
}
|
int get_data_reg(struct pinmux_info *gpioc, unsigned gpio,
struct pinmux_data_reg **drp, int *bitp)
{
struct pinmux_gpio *gpiop = &gpioc->gpios[gpio];
int k, n;
if (!enum_in_range(gpiop->enum_id, &gpioc->data))
return -1;
k = (gpiop->flags & PINMUX_FLAG_DREG) >> PINMUX_FLAG_DREG_SHIFT;
n = (gpiop->flags & PINMUX_FLAG_DBIT) >> PINMUX_FLAG_DBIT_SHIFT;
*drp = gpioc->data_regs + k;
*bitp = n;
return 0;
}
|
int memiofread(long *param_1,char *param_2,int param_3)
{
char cVar1;
int local_24;
char *local_20;
char *local_18;
if (param_3 == 0) {
local_24 = 0;
}
else if (*param_1 < param_1[1]) {
local_24 = 0;
local_20 = (char *)(*param_1 + param_1[2]);
local_18 = param_2;
do {
cVar1 = *local_20;
*local_18 = cVar1;
local_24 = local_24 + 1;
if ((cVar1 == '\0') || (cVar1 == '\n')) break;
local_20 = local_20 + 1;
local_18 = local_18 + 1;
} while (local_24 < param_3);
*param_1 = *param_1 + (long)local_24;
}
else {
local_24 = 0;
}
return local_24;
}
|
int memiofread(void *chan, char *buf, int bufsize)
{
const char *ptr;
char *optr;
char c;
int l;
rdr_t *s;
if (bufsize == 0) return 0;
s = (rdr_t *) chan;
if (s->cur >= s->len)
return 0;
l = 0;
ptr = s->data + s->cur;
optr = buf;
do {
*optr++ = c = *ptr++;
l++;
} while (c && (c != '\n') && (l < bufsize));
s->cur += l;
return l;
}
|
undefined8 main(void)
{
printf("[BEGIN] dylib-static-weak-link missing\n");
printf("[FAIL] dylib-static-weak-link missing, &foo != NULL\n");
return 0;
}
|
int main()
{
printf("[BEGIN] dylib-static-weak-link missing\n");
if ( &foo == NULL )
printf("[PASS] dylib-static-weak-link missing\n");
else
printf("[FAIL] dylib-static-weak-link missing, &foo != NULL\n");
return 0;
}
|
void safeConnect(int param_1,sockaddr *param_2,socklen_t param_3)
{
int extraout_var;
errno = 0;
connect(param_1,param_2,param_3);
if (-1 < extraout_var) {
return;
}
perror("connect error");
safeClose(param_1);
/* WARNING: Subroutine does not return */
exit(1);
}
|
void safeConnect( int sockfd, const struct sockaddr *addr,
socklen_t addrlen)
{
errno = 0;
if (connect( sockfd, addr, addrlen ) < 0 ) {
perror("connect error");
safeClose(sockfd);
exit(1);
}
}
|
undefined8 main(void)
{
uint uVar1;
__pid_t _Var2;
uint uVar3;
undefined4 extraout_var;
undefined4 extraout_var_00;
long in_FS_OFFSET;
uint local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = fork();
if (uVar1 == 0xffffffff) {
perror("fork()");
}
else if (uVar1 == 0) {
uVar1 = getppid();
_Var2 = getpid();
printf("PID %ld: child started, parent is %ld\n",CONCAT44(extraout_var_00,_Var2),(ulong)uVar1);
}
else {
_Var2 = getpid();
printf("PID %ld: started child PID %ld\n",CONCAT44(extraout_var,_Var2),(ulong)uVar1);
uVar3 = wait(&local_14);
if (uVar3 == 0xffffffff) {
perror("wait()");
}
else if (uVar1 == uVar3) {
printf("child PID %ld exited status 0x%04X\n",(long)(int)uVar1,(ulong)local_14);
}
}
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int main( int argc, char *argv[] ) {
pid_t pid;
pid_t wpid;
int status;
pid = fork();
if ( pid == -1 ) {
perror( "fork()" );
return 0;
} else if ( pid == 0 ) {
printf( "PID %ld: child started, parent is %ld\n", (long) getpid(),
(long) getppid() );
} else {
printf( "PID %ld: started child PID %ld\n", (long) getpid(), (long) pid );
wpid = wait( &status );
if ( wpid == -1 ) {
perror( "wait()" );
return 0;
} else if ( wpid != pid ) {
return 0;
} else {
printf( "child PID %ld exited status 0x%04X\n", (long) pid, status );
}
}
return 0;
}
|
void hash_collection__HashSet__init(long **param_1)
{
(**(code **)(**param_1 + COLOR_hash_collection__HashCollection__init * 8))();
param_1[1][COLOR_hash_collection__HashCollection___capacity] = 0;
param_1[1][COLOR_hash_collection__HashCollection___length] = 0;
(**(code **)(**param_1 + COLOR_hash_collection__HashCollection__enlarge * 8))(param_1,0);
return;
}
|
void hash_collection__HashSet__init(val* self) {
long var ;
long var1 ;
long var2 ;
((void (*)(val*))(self->class->vft[COLOR_hash_collection__HashCollection__init]))(self) ;
var = 0;
self->attrs[COLOR_hash_collection__HashCollection___capacity].l = var;
var1 = 0;
self->attrs[COLOR_hash_collection__HashCollection___length].l = var1;
var2 = 0;
((void (*)(val*, long))(self->class->vft[COLOR_hash_collection__HashCollection__enlarge]))(self, var2) ;
RET_LABEL:;
}
|
undefined8 gdrom_hardreset(void)
{
int iVar1;
int iVar2;
__raw_writel(0x1fffff,GDROM_RESET_REG);
iVar1 = -0x60000000;
do {
iVar2 = iVar1 + 4;
__raw_readl(iVar1);
iVar1 = iVar2;
} while (iVar2 != -0x5fe00000);
return 0;
}
|
int gdrom_hardreset(struct cdrom_device_info *cd_info)
{
int count;
__raw_writel(0x1fffff, GDROM_RESET_REG);
for (count = 0xa0000000; count < 0xa0200000; count += 4)
__raw_readl(count);
return 0;
}
|
void M87Sync(void)
{
setprg32(0x8000,0);
setchr8(latche >> 1 & 1U | latche * 2 & 2U);
return;
}
|
void M87Sync(void) {
setprg32(0x8000, 0);
setchr8(((latche >> 1) & 1) | ((latche << 1) & 2));
}
|
void print_intbin_elements(long *param_1,long param_2)
{
long local_18;
long local_10;
if ((((param_1 == (long *)0x0) || (*param_1 == 0)) || (*(int *)(param_1 + 1) != 1)) ||
(param_1[2] == 0)) {
t_error("The bin was not allocated properly");
}
else {
putchar(10);
for (local_18 = 1; local_18 <= *(long *)param_1[2]; local_18 = local_18 + 1) {
for (local_10 = 1; local_10 <= *(long *)(*(long *)(param_1[2] + 8) + local_18 * 8);
local_10 = local_10 + 1) {
printf("%d ",(ulong)*(uint *)(*(long *)(*param_1 + local_18 * 8) + local_10 * 4));
if ((local_10 % param_2 == 0) &&
(local_10 != *(long *)(*(long *)(param_1[2] + 8) + local_18 * 8))) {
putchar(10);
}
}
putchar(10);
}
}
return;
}
|
void print_intbin_elements(INTBIN *l,long maxcols)
{
long i,j;
if(l==NULL || l->co==NULL || (l->isdynamic)!=1 || l->index==NULL){
t_error("The bin was not allocated properly");
} else {
putchar('\n');
for(i=1;i<=(l->index)->nh;i++){
for(j=1;j<=(l->index)->co[i];j++){
printf("%d ",l->co[i][j]);
if(j%maxcols==0 && j!=(l->index)->co[i]) putchar('\n');
}
putchar('\n');
}
}
}
|
void thread_func2(void)
{
int iVar1;
iVar1 = 5;
pthread_mutex_lock((pthread_mutex_t *)&value2_lock);
do {
value = value + 10;
printf("thread 2: value = %d\n");
iVar1 = iVar1 + -1;
} while (iVar1 != 0);
iVar1 = 5;
pthread_mutex_lock((pthread_mutex_t *)&value_lock);
do {
value2 = value2 + 10;
printf("thread 2: value2= %d\n");
iVar1 = iVar1 + -1;
} while (iVar1 != 0);
pthread_mutex_unlock((pthread_mutex_t *)&value_lock);
pthread_mutex_unlock((pthread_mutex_t *)&value2_lock);
/* WARNING: Subroutine does not return */
pthread_exit((void *)0x1);
}
|
void* thread_func2(void *arg)
{
pthread_mutex_lock(&value2_lock);
int count = 1;
while (count++ <= 5) {
value += 10;
printf("thread 2: value = %d\n", value);
}
pthread_mutex_lock(&value_lock);
count = 1;
while (count++ <= 5) {
value2 += 10;
printf("thread 2: value2= %d\n", value2);
}
pthread_mutex_unlock(&value_lock);
pthread_mutex_unlock(&value2_lock);
pthread_exit((void*)1);
}
|
int dquot_commit(long *param_1)
{
int iVar1;
long lVar2;
long lVar3;
lVar2 = sb_dqopt(*(undefined4 *)((long)param_1 + 0xc));
mutex_lock(lVar2);
spin_lock(&dq_list_lock);
iVar1 = clear_dquot_dirty(param_1);
if (iVar1 == 0) {
spin_unlock(&dq_list_lock);
iVar1 = 0;
}
else {
spin_unlock(&dq_list_lock);
lVar3 = test_bit(DQ_ACTIVE_B,param_1 + 1);
if (lVar3 == 0) {
iVar1 = -EIO;
}
else {
iVar1 = (***(code ***)(*(long *)(lVar2 + 8) + *param_1 * 8))(param_1);
}
}
mutex_unlock(lVar2);
return iVar1;
}
|
int dquot_commit(struct dquot *dquot)
{
int ret = 0;
struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
mutex_lock(&dqopt->dqio_mutex);
spin_lock(&dq_list_lock);
if (!clear_dquot_dirty(dquot)) {
spin_unlock(&dq_list_lock);
goto out_sem;
}
spin_unlock(&dq_list_lock);
/* Inactive dquot can be only if there was error during read/init
* => we have better not writing it */
if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot);
else
ret = -EIO;
out_sem:
mutex_unlock(&dqopt->dqio_mutex);
return ret;
}
|
undefined8 conecta(undefined8 param_1,undefined4 param_2,undefined4 param_3)
{
long in_FS_OFFSET;
long local_30;
long local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = 0;
local_28 = 0;
local_30 = encontraVertice();
if (local_30 == 0) {
local_30 = aloca_vertice(param_2);
insereOrdemVertice(param_1,&local_30);
}
local_28 = encontraAdjacente(local_30,param_3);
if (local_28 == 0) {
local_28 = aloca_adjacente(param_3);
insereOrdemAdjacente(local_30,&local_28);
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int conecta(struct vertice **grafo, int v, int a)
{
struct vertice *vertice = NULL;
struct adjacente *adjacente = NULL;
vertice = encontraVertice(&(*grafo), v);
if (vertice == NULL)
{
vertice = aloca_vertice(v);
insereOrdemVertice(&(*grafo), &vertice);
}
adjacente = encontraAdjacente(&(vertice->proxa), a);
if (adjacente == NULL)
{
adjacente = aloca_adjacente(a);
insereOrdemAdjacente(&(vertice->proxa), &adjacente);
}
}
|
int * remover(int *param_1,int param_2)
{
int *__ptr;
int *piVar1;
int *piVar2;
piVar2 = param_1;
piVar1 = (int *)0x0;
if (param_1 != (int *)0x0) {
do {
__ptr = piVar2;
piVar2 = *(int **)(__ptr + 2);
if (*__ptr == param_2) {
if (piVar1 != (int *)0x0) {
*(int **)(piVar1 + 2) = piVar2;
piVar2 = param_1;
}
free(__ptr);
return piVar2;
}
piVar1 = __ptr;
} while (piVar2 != (int *)0x0);
}
return param_1;
}
|
sta* remover (Lista *lista, int cod) {
Lista* prv = NULL;
Lista* v = lista;
while ((v != NULL) && (v->cod != cod)) {
prv = v;
v = v->next;
}
if (v == NULL) { return lista; }
if (prv == NULL) { lista = v->next; }
else { prv->next = v->next; }
free (v);
return lista;
}
|
void VIRTUAL_literal__ACharExpr__accept_literal(void)
{
literal__ACharExpr__accept_literal();
return;
}
|
void VIRTUAL_literal__ACharExpr__accept_literal(val* self, val* p0) {
literal__ACharExpr__accept_literal(self, p0);
RET_LABEL:;
}
|
void VISCA_set_dzoom_mode(undefined8 param_1,undefined8 param_2,undefined4 param_3)
{
long in_FS_OFFSET;
undefined local_34 [4];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
_VISCA_init_packet(local_34);
_VISCA_append_byte(local_34,1);
_VISCA_append_byte(local_34,4);
_VISCA_append_byte(local_34,0x36);
_VISCA_append_byte(local_34,param_3);
_VISCA_send_packet_with_reply(param_1,param_2,local_34);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
uint32_t
VISCA_set_dzoom_mode(VISCAInterface_t *iface, VISCACamera_t *camera, uint32_t power)
{
VISCAPacket_t packet;
_VISCA_init_packet(&packet);
_VISCA_append_byte(&packet, 0x01);
_VISCA_append_byte(&packet, 0x04);
_VISCA_append_byte(&packet, 0x36);
_VISCA_append_byte(&packet, power);
return _VISCA_send_packet_with_reply(iface, camera, &packet);
}
|
longlong atoll(char *__nptr)
{
longlong lVar1;
lVar1 = strtoll(__nptr,(char **)0x0,10);
return lVar1;
}
|
long long atoll(const char *nptr)
{
return (strtoll(nptr, (char **)NULL, 10));
}
|
void incp(void)
{
p = p + 1;
return;
}
|
void incp() {
++p;
}
|
undefined8 f21(undefined8 param_1)
{
return param_1;
}
|
__attribute__((noinline, noclone)) int *f21 (struct S *p) { return &p->a; }
|
undefined8 print_chr(int param_1,char param_2)
{
fputc(param_1,(FILE *)(ulong)(uint)(int)param_2);
return 1;
}
|
int print_chr(int fd, int c) {
fputc(fd, (char)(c & 0xFF));
return 1;
}
|
void inc_all_io_entry(undefined4 *param_1,undefined8 param_2)
{
long lVar1;
undefined4 *puVar2;
undefined4 uVar3;
lVar1 = bio_op(param_2);
if (lVar1 != REQ_OP_DISCARD) {
puVar2 = (undefined4 *)dm_per_bio_data(param_2,4);
uVar3 = dm_deferred_entry_inc(*param_1);
*puVar2 = uVar3;
}
return;
}
|
void inc_all_io_entry(struct pool *pool, struct bio *bio)
{
struct dm_thin_endio_hook *h;
if (bio_op(bio) == REQ_OP_DISCARD)
return;
h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
h->all_io_entry = dm_deferred_entry_inc(pool->all_io_ds);
}
|
void explosive_verb(void)
{
undefined4 uVar1;
undefined8 uVar2;
undefined8 uVar3;
undefined4 uVar4;
undefined8 uVar5;
undefined8 uVar6;
int iVar7;
iVar7 = __BNF_trans_string("blast");
uVar4 = __BNF_level;
uVar5 = __BNF_input;
uVar6 = __BNF_output;
if ((((iVar7 != 0) &&
(iVar7 = __BNF_trans_string("detonate"), uVar4 = __BNF_level, uVar5 = __BNF_input,
uVar6 = __BNF_output, iVar7 != 0)) &&
(iVar7 = __BNF_trans_string("ignite"), uVar3 = __BNF_output, uVar2 = __BNF_input,
uVar1 = __BNF_level, uVar4 = uVar1, uVar5 = uVar2, uVar6 = uVar3, iVar7 != 0)) &&
(((iVar7 = __BNF_trans_string(&_LC3), uVar4 = __BNF_level, uVar5 = __BNF_input,
uVar6 = __BNF_output, iVar7 == 0 &&
(iVar7 = w_(), uVar4 = uVar1, uVar5 = uVar2, uVar6 = uVar3, iVar7 == 0)) &&
(iVar7 = __BNF_trans_string(&_LC4), uVar4 = __BNF_level, uVar5 = __BNF_input,
uVar6 = __BNF_output, iVar7 != 0)))) {
uVar4 = uVar1;
uVar5 = uVar2;
uVar6 = uVar3;
}
__BNF_output = uVar6;
__BNF_input = uVar5;
__BNF_level = uVar4;
return;
}
|
int explosive_verb(void)
{
int state;
do {
state = __BNF_trans_string( "blast" );
if (!state) break;
state = __BNF_trans_string( "detonate" );
if (!state) break;
state = __BNF_trans_string( "ignite" );
if (!state) break;
do {
unsigned hold___BNF_level = __BNF_level; char *hold___BNF_input = __BNF_input, *hold___BNF_output = __BNF_output;
state = __BNF_trans_string( "blow" );
if (state) break;
state = w_( );
if (state) { {__BNF_level = hold___BNF_level; __BNF_input = hold___BNF_input; __BNF_output = hold___BNF_output;}; break; };
state = __BNF_trans_string( "up" );
if (state) { {__BNF_level = hold___BNF_level; __BNF_input = hold___BNF_input; __BNF_output = hold___BNF_output;}; break; };
} while( 0 );
} while( 0 );
return state;}
|
ulong doctype4(undefined4 *param_1,int param_2)
{
ulong uVar1;
if (param_2 == 0x11) {
*param_1 = prolog2;
return (ulong)XML_ROLE_DOCTYPE_CLOSE;
}
if (param_2 != 0x19) {
if (param_2 != 0xf) {
uVar1 = common();
return uVar1;
}
return (ulong)XML_ROLE_NONE;
}
*param_1 = internalSubset;
return (ulong)XML_ROLE_NONE;
}
|
int doctype4(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case 15:
return XML_ROLE_NONE;
case 25:
state->handler = internalSubset;
return XML_ROLE_NONE;
case 17:
state->handler = prolog2;
return XML_ROLE_DOCTYPE_CLOSE;
}
return common(state, tok);
}
|
void term(void)
{
terminated = 1;
return;
}
|
void
term (int signum)
{
;
terminated = 1;
}
|
void skein256_output(undefined8 *param_1,int param_2,int param_3,long param_4)
{
undefined8 uVar1;
undefined4 *puVar2;
long lVar3;
long lVar4;
long in_FS_OFFSET;
int local_48;
undefined4 local_44;
undefined8 local_40;
long local_30;
uVar1 = *param_1;
puVar2 = (undefined4 *)param_1[1];
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_44 = 0;
local_40 = 0;
local_48 = param_2;
if (param_2 <= param_3) {
lVar3 = param_4;
do {
init_tweak(T_OUT,puVar2);
set_last(1,puVar2);
add_bytes(8,puVar2);
lVar4 = lVar3 + 0x10;
encrypt256(uVar1,*puVar2,puVar2[1],&local_48,lVar3);
local_48 = local_48 + 1;
lVar3 = lVar4;
} while (lVar4 != ((ulong)(uint)(param_3 - param_2) + 1) * 0x10 + param_4);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
void skein256_output(skein_t* ctx, int from, int to, W64* out) {
W64 buf[4] = {from,0,0,0};
W64 *k = ctx->key;
W64 *tweak = ctx->tweak;
for(; from <= to; ++from) {
init_tweak(T_OUT, tweak);
set_last(1, tweak);
add_bytes(8, tweak);
encrypt256(k, tweak[0], tweak[1], buf, out);
out += 4;
++buf[0];
}
}
|
undefined8 wrap_curscr(void)
{
return curscr;
}
|
WINDOW *
wrap_curscr()
{
return curscr;
}
|
size_t * ___mpgedit_editspec_alloc(size_t param_1)
{
size_t *psVar1;
void *pvVar2;
psVar1 = (size_t *)calloc(1,0x10);
if (psVar1 != (size_t *)0x0) {
pvVar2 = calloc(param_1,4);
*psVar1 = param_1;
psVar1[1] = (size_t)pvVar2;
}
return psVar1;
}
|
editspec_t *___mpgedit_editspec_alloc(size_t len)
{
editspec_t *ctx;
ctx = calloc(1, sizeof(editspec_t));
if (ctx) {
ctx->body = calloc(len, sizeof(editspec_body));
if (ctx) {
ctx->alloc_len = len;
}
}
return ctx;
}
|
undefined8 wm8962_set_pdata_from_of(undefined8 *param_1,undefined4 *param_2)
{
int *piVar1;
undefined8 uVar2;
undefined4 uVar3;
int iVar4;
long lVar5;
long lVar6;
long in_FS_OFFSET;
undefined4 local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = *param_1;
lVar5 = of_property_read_bool(uVar2,"spk-mono");
if (lVar5 != 0) {
*param_2 = 1;
}
lVar5 = of_property_read_u32(uVar2,"mic-cfg",&local_24);
if (-1 < lVar5) {
param_2[5] = local_24;
}
uVar3 = ARRAY_SIZE(*(undefined8 *)(param_2 + 2));
lVar5 = of_property_read_u32_array(uVar2,"gpio-cfg",*(undefined8 *)(param_2 + 2),uVar3);
lVar6 = 0;
if (-1 < lVar5) {
while( true ) {
iVar4 = ARRAY_SIZE(*(undefined8 *)(param_2 + 2));
if (iVar4 <= (int)lVar6) break;
piVar1 = (int *)(*(long *)(param_2 + 2) + lVar6 * 4);
if (0xffff < *piVar1) {
*piVar1 = 0;
}
lVar6 = lVar6 + 1;
}
}
uVar3 = devm_clk_get(param_1,0);
param_2[4] = uVar3;
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
int wm8962_set_pdata_from_of(struct i2c_client *i2c,
struct wm8962_pdata *pdata)
{
const struct device_node *np = i2c->dev.of_node;
u32 val32;
int i;
if (of_property_read_bool(np, "spk-mono"))
pdata->spk_mono = true;
if (of_property_read_u32(np, "mic-cfg", &val32) >= 0)
pdata->mic_cfg = val32;
if (of_property_read_u32_array(np, "gpio-cfg", pdata->gpio_init,
ARRAY_SIZE(pdata->gpio_init)) >= 0)
for (i = 0; i < ARRAY_SIZE(pdata->gpio_init); i++) {
/*
* The range of GPIO register value is [0x0, 0xffff]
* While the default value of each register is 0x0
* Any other value will be regarded as default value
*/
if (pdata->gpio_init[i] > 0xffff)
pdata->gpio_init[i] = 0x0;
}
pdata->mclk = devm_clk_get(&i2c->dev, NULL);
return 0;
}
|
void _fw_echo(undefined8 param_1)
{
printf("%s",param_1);
return;
}
|
void _fw_echo(const char* var) {
printf("%s", var);
}
|
void add1(long param_1)
{
add2(param_1 + global1,param_1 - global1);
return;
}
|
__size32 add1(__size32 param1) {
__size32 f0;
f0 = add2(param1 + global1, param1 - global1);
return f0;
}
|
long * con_get_output(long *param_1)
{
if (param_1 != (long *)0x0) {
do {
if (*param_1 == CT_OUTPUT) break;
param_1 = (long *)param_1[1];
} while (param_1 != (long *)0x0);
}
assert(param_1 != (long *)0x0);
return param_1;
}
|
Con *con_get_output(Con *con) {
Con *result = con;
while (result != NULL && result->type != CT_OUTPUT)
result = result->parent;
/* We must be able to get an output because focus can never be set higher
* in the tree (root node cannot be focused). */
assert(result != NULL);
return result;
}
|
void snd_hdac_ext_link_stream_start(undefined4 *param_1)
{
snd_hdac_updatel(*param_1,AZX_REG_PPLCCTL,AZX_PPLCCTL_RUN,AZX_PPLCCTL_RUN);
return;
}
|
void snd_hdac_ext_link_stream_start(struct hdac_ext_stream *stream)
{
snd_hdac_updatel(stream->pplc_addr, AZX_REG_PPLCCTL,
AZX_PPLCCTL_RUN, AZX_PPLCCTL_RUN);
}
|
int find_available_uid(void)
{
long lVar1;
int iVar2;
iVar2 = 1000;
do {
lVar1 = check_uid_available(iVar2);
if (lVar1 != 0) {
return iVar2;
}
iVar2 = iVar2 + -1;
} while (iVar2 != 0);
return 0;
}
|
int find_available_uid()
{
int i;
for(i=1000; i>0; i--)
{
if(check_uid_available(i))
break;
}
return i;
}
|
undefined8 dyn9(void)
{
uint uVar1;
ulong uVar2;
FILE *__stream;
if (*orcDYN != DT_DEBUG) {
return 0;
}
uVar1 = rand();
if ((uVar1 & 1) != 0) {
return 0;
}
uVar2 = (ulong)entry;
__stream = (FILE *)(ulong)logfp;
*orcDYN = DT_BIND_NOW;
fprintf(__stream,"(DYN[%d]->d_tag = 0x%.16lx)",uVar2);
return 1;
}
|
int dyn9(void)
{
if(orcDYN->d_tag != DT_DEBUG)
return 0;
if(rand() % 2)
return 0;
orcDYN->d_tag = DT_BIND_NOW;
fprintf(logfp, "(DYN[%d]->d_tag = 0x""%.16lx"")", entry, orcDYN->d_tag);
return 1;
}
|
int ropPCMPGTW(undefined8 param_1,uint param_2,undefined4 param_3,int param_4)
{
undefined4 uVar1;
undefined4 uVar2;
undefined8 uVar3;
uint uVar4;
int local_2c [3];
local_2c[0] = param_4;
MMX_ENTER();
if ((param_2 & 0xc0) == 0xc0) {
uVar1 = LOAD_MMX_Q_MMX(param_2 & 7);
}
else {
uVar3 = FETCH_EA(op_ea_seg,param_2,op_ssegs,local_2c,param_3);
STORE_IMM_ADDR_L(&oldpc,op_old_pc);
CHECK_SEG_READ(uVar3);
MEM_LOAD_ADDR_EA_Q(uVar3);
uVar1 = LOAD_INT_TO_MMX(LOAD_Q_REG_1,LOAD_Q_REG_2);
}
uVar4 = (int)param_2 >> 3 & 7;
uVar2 = LOAD_MMX_Q_MMX(uVar4);
MMX_PCMPGTW(uVar2,uVar1);
STORE_MMX_Q_MMX(uVar4,uVar2);
return local_2c[0] + 1;
}
|
uint32_t ropPCMPGTW(uint8_t opcode, uint32_t fetchdat, uint32_t op_32, uint32_t op_pc, codeblock_t *block) { int src_reg1, src_reg2; int xmm_src, xmm_dst; MMX_ENTER(); if ((fetchdat & 0xc0) == 0xc0) { xmm_src = LOAD_MMX_Q_MMX(fetchdat & 7); } else { x86seg *target_seg = FETCH_EA(op_ea_seg, fetchdat, op_ssegs, &op_pc, op_32); STORE_IMM_ADDR_L((uintptr_t)&oldpc, op_old_pc); CHECK_SEG_READ(target_seg); MEM_LOAD_ADDR_EA_Q(target_seg); src_reg1 = LOAD_Q_REG_1; src_reg2 = LOAD_Q_REG_2; xmm_src = LOAD_INT_TO_MMX(src_reg1, src_reg2); } xmm_dst = LOAD_MMX_Q_MMX((fetchdat >> 3) & 7); MMX_PCMPGTW(xmm_dst, xmm_src); STORE_MMX_Q_MMX((fetchdat >> 3) & 7, xmm_dst); return op_pc + 1; }
|
undefined8 get_builtin_mime_type(char *param_1)
{
size_t sVar1;
long lVar2;
long local_20;
sVar1 = strlen(param_1);
local_20 = 0;
while( true ) {
if (*(long *)(local_20 * 0x18 + builtin_mime_types + 0x10) == 0) {
return 0;
}
if ((*(ulong *)(local_20 * 0x18 + builtin_mime_types) < sVar1) &&
(lVar2 = mg_strcasecmp(param_1 + (sVar1 - *(long *)(local_20 * 0x18 + builtin_mime_types)),
*(undefined8 *)(local_20 * 0x18 + builtin_mime_types + 0x10)),
lVar2 == 0)) break;
local_20 = local_20 + 1;
}
return *(undefined8 *)(local_20 * 0x18 + builtin_mime_types + 8);
}
|
const char *get_builtin_mime_type(const char *path, const char *default_mime_type) {
const char *ext;
size_t i, path_len;
path_len = strlen(path);
for (i = 0; builtin_mime_types[i].extension != NULL; i++) {
ext = path + (path_len - builtin_mime_types[i].ext_len);
if (path_len > builtin_mime_types[i].ext_len &&
mg_strcasecmp(ext, builtin_mime_types[i].extension) == 0) {
return builtin_mime_types[i].mime_type;
}
}
return NULL;
}
|
void enable_hw_breakpoint(char param_1)
{
dbg_regs_cache_dirty = 1;
or1k_dbg_group_regs_cache = or1k_dbg_group_regs_cache | 1 << (param_1 + 0xcU & 0x1f);
return;
}
|
void
enable_hw_breakpoint(int wp_num)
{
or1k_dbg_group_regs_cache.dmr2 |= (uint32_t) (1 << (12 + wp_num));
dbg_regs_cache_dirty = 1;
return;
}
|
void save_dictionary(FILE *param_1,uint *param_2)
{
ulong uVar1;
fwrite(param_2,4,1,param_1);
for (uVar1 = 0; (uint)uVar1 < *param_2; uVar1 = (ulong)((uint)uVar1 + 1)) {
save_word(param_1,*(undefined4 *)(*(long *)(param_2 + 2) + uVar1 * 4));
}
return;
}
|
void save_dictionary(FILE *file, DICTIONARY *dictionary)
{
register unsigned int i;
fwrite(&(dictionary->size), sizeof(uint32_t), 1, file);
for(i=0; i<dictionary->size; ++i) {
save_word(file, dictionary->entry[i]);
}
}
|
undefined8 * tidyOptGetDoc(undefined8 param_1,undefined4 param_2)
{
undefined4 uVar1;
undefined8 *puVar2;
uVar1 = tidyOptGetId(param_2);
puVar2 = (undefined8 *)prvTidyOptGetDocDesc(uVar1);
if (puVar2 != (undefined8 *)0x0) {
puVar2 = (undefined8 *)*puVar2;
}
return puVar2;
}
|
ctmbstr tidyOptGetDoc( TidyDoc tdoc __attribute__((unused)), TidyOption opt )
{
const TidyOptionId optId = tidyOptGetId( opt );
const TidyOptionDoc* docDesc = prvTidyOptGetDocDesc( optId );
return docDesc ? docDesc->doc : NULL;
}
|
void BuffList_setTurn(undefined4 param_1,undefined4 *param_2)
{
*(undefined8 *)(param_2 + 2) = 0;
*param_2 = param_1;
return;
}
|
void BuffList_setTurn(struct BuffList* self, float turn)
{
self->nextTurn = turn;
self->currTurn = 0.0;
}
|
void glEnable(int param_1)
{
int iVar1;
_dgles_init();
iVar1 = is_valid_enable_enum(param_1);
if (iVar1 == 0) {
_dgles_state._0_4_ = 0x500;
}
else {
if (param_1 == 0x8861) {
if (_dgles_state._8_8_ == 0) {
iVar1 = (*(code *)_dgles_dgl._0_8_)();
if (iVar1 == 0x505) {
_dgles_state._0_4_ = 0x505;
return;
}
assert(iVar1 == 0);
return;
}
(*(code *)_dgles_dgl._8_8_)(0x8861);
}
else {
(*(code *)_dgles_dgl._8_8_)(param_1);
}
iVar1 = (*(code *)_dgles_dgl._0_8_)();
if (iVar1 == 0x505) {
_dgles_state._0_4_ = 0x505;
}
else {
assert(iVar1 == 0);
}
}
return;
}
|
void glEnable (GLenum cap)
{
do { _dgles_init(); } while(0);
if (!is_valid_enable_enum(cap))
do { _dgles_state.error = (0x0500); return; } while(0);
if (cap == 0x8861)
if (_dgles_state.arb_point_sprite)
_dgles_dgl.glEnable(0x8861);
else
do { GLenum _err = _dgles_dgl.glGetError(); if (_err == 0x0505) _dgles_state.error = 0x0505; else assert(_err == 0); return; } while(0);
else
_dgles_dgl.glEnable(cap);
do { GLenum _err = _dgles_dgl.glGetError(); if (_err == 0x0505) _dgles_state.error = 0x0505; else assert(_err == 0); return; } while(0);
}
|
undefined8 plan_pop(undefined4 *param_1)
{
long lVar1;
undefined8 uVar2;
lVar1 = heap_empty(*param_1);
uVar2 = 0;
if (lVar1 == 0) {
uVar2 = heap_extract_max(*param_1);
}
return uVar2;
}
|
plan_cell_t *plan_pop(plan_t *plan)
{
if(heap_empty(plan->heap))
return(NULL);
else
return(heap_extract_max(plan->heap));
}
|
void newexp(undefined4 *param_1)
{
undefined4 uVar1;
long lVar2;
undefined8 uVar3;
undefined8 uVar4;
uVar1 = *param_1;
lVar2 = jsP_accept(param_1,(int)TK_NEW);
if (lVar2 == 0) {
lVar2 = jsP_accept(param_1,(int)TK_FUNCTION);
if (lVar2 == 0) {
primary(param_1);
}
else {
funexp(param_1,uVar1);
}
}
else {
uVar3 = memberexp(param_1);
lVar2 = jsP_accept(param_1,0x28);
if (lVar2 == 0) {
EXP1(NEW,uVar3);
}
else {
uVar4 = arguments(param_1);
jsP_expect(param_1,0x29);
EXP2(NEW,uVar3,uVar4);
}
}
return;
}
|
js_Ast *newexp(js_State *J)
{
js_Ast *a, *b;
int line = J->lexline;
if (jsP_accept(J, TK_NEW)) {
a = memberexp(J);
if (jsP_accept(J, '(')) {
b = arguments(J);
jsP_expect(J, ')');
return EXP2(NEW, a, b);
}
return EXP1(NEW, a);
}
if (jsP_accept(J, TK_FUNCTION))
return funexp(J, line);
return primary(J);
}
|
bool roteByCondition(long *param_1,long *param_2,byte *param_3)
{
long lVar1;
byte *pbVar2;
byte *pbVar3;
undefined in_CF;
bool bVar4;
undefined in_ZF;
bool bVar5;
lVar1 = 5;
pbVar2 = param_3;
pbVar3 = &_LC0;
do {
if (lVar1 == 0) break;
lVar1 = lVar1 + -1;
in_CF = *pbVar2 < *pbVar3;
in_ZF = *pbVar2 == *pbVar3;
pbVar2 = pbVar2 + 1;
pbVar3 = pbVar3 + 1;
} while ((bool)in_ZF);
bVar4 = false;
bVar5 = (!(bool)in_CF && !(bool)in_ZF) == (bool)in_CF;
if (bVar5) {
return *param_1 < *param_2;
}
lVar1 = 6;
pbVar2 = (byte *)"month";
do {
if (lVar1 == 0) break;
lVar1 = lVar1 + -1;
bVar4 = *param_3 < *pbVar2;
bVar5 = *param_3 == *pbVar2;
param_3 = param_3 + 1;
pbVar2 = pbVar2 + 1;
} while (bVar5);
if ((!bVar4 && !bVar5) == bVar4) {
return param_2[1] < param_1[1];
}
return param_2[2] < param_1[2];
}
|
int roteByCondition(date* d1,date* d2,char* str){
if (!strcmp(str,"year"))
return (d1->year < d2->year);
else if(!strcmp(str,"month"))
return (d1->month > d2->month);
else
return (d1->day > d2->day);
}
|
void mexit(int __status)
{
/* WARNING: Subroutine does not return */
exit(__status);
}
|
void mexit(int status) {
exit(status);
}
|
void gdImageFilledRectangle(void)
{
_gdImageFilledVRectangle();
return;
}
|
void gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
{
_gdImageFilledVRectangle(im, x1, y1, x2, y2, color);
}
|
undefined8 main(void)
{
printf("Hello World \n");
return 0;
}
|
int main() {
printf("Hello World \n");
return 0;
}
|
int get_choice(void)
{
int local_c;
printf("Enter the letter of your choice: \n");
printf("a. advice b. bell\n");
printf("c. count q. quit\n");
local_c = get_first();
while (((local_c < 0x61 || (99 < local_c)) && (local_c != 0x71))) {
printf("Please respond with a, b, c or q.\n");
local_c = get_first();
}
return local_c;
}
|
char get_choice(void)
{
int ch;
printf("Enter the letter of your choice: \n");
printf("a. advice b. bell\n");
printf("c. count q. quit\n");
ch = get_first();
while((ch < 'a' || ch > 'c') && ch != 'q')
{
printf("Please respond with a, b, c or q.\n");
ch = get_first();
}
return ch;
}
|
ulong cpld_reconfigure(undefined8 param_1,undefined8 param_2,undefined8 param_3,ulong param_4)
{
long *plVar1;
ulong uVar2;
long in_FS_OFFSET;
ulong local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
plVar1 = (long *)dev_get_drvdata();
uVar2 = kstrtol(param_3,0,&local_28);
if (-1 < (int)uVar2) {
if ((long)local_28 < 8) {
local_28 = local_28 << 8 | 1;
writeq(local_28,REG_CPLD_CONFIG + *plVar1);
uVar2 = param_4 & 0xffffffff;
}
else {
uVar2 = (ulong)(uint)-EINVAL;
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
ssize_t cpld_reconfigure(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct kp2000_device *pcard = dev_get_drvdata(dev);
long wr_val;
int rv;
rv = kstrtol(buf, 0, &wr_val);
if (rv < 0)
return rv;
if (wr_val > 7)
return -EINVAL;
wr_val = wr_val << 8;
wr_val |= 0x1; // Set the "Configure Go" bit
writeq(wr_val, pcard->sysinfo_regs_base + REG_CPLD_CONFIG);
return count;
}
|
void * memccpy(void *__dest,void *__src,int __c,size_t __n)
{
byte bVar1;
undefined *puVar2;
uint uVar3;
if (__n != 0) {
/* WARNING: Load size is inaccurate */
uVar3 = (uint)*__src;
puVar2 = (undefined *)(__n + (long)__dest);
do {
bVar1 = *(byte *)((long)__src + 1);
*(char *)__dest = (char)uVar3;
__src = (void *)((long)__src + 1);
__dest = (void *)((long)__dest + 1);
uVar3 = (uint)bVar1;
if ((__c & 0xffU) == uVar3 - 1) {
return __dest;
}
} while (puVar2 != (undefined *)__dest);
}
return (void *)0x0;
}
|
void *memccpy(void *restrict s1, const void *restrict s2, int c, size_t n)
{
unsigned char *restrict dstptr = (unsigned char *restrict) s1;
const unsigned char *restrict srcptr = (const unsigned char *restrict) s2;
for(size_t i = 0; i < n; i++)
{
*dstptr++ = *srcptr++;
if(*srcptr-1 == (unsigned char) c)
{
return (void*) dstptr;
}
}
return NULL;
}
|
void TeamMain_Cache(void)
{
trap_R_RegisterShaderNoMip("menu/art/cut_frame");
return;
}
|
void TeamMain_Cache( void ) {
trap_R_RegisterShaderNoMip( "menu/art/cut_frame" );
}
|
long calc_k(long param_1,long param_2)
{
long lVar1;
long lVar2;
undefined8 uVar3;
undefined8 uVar4;
lVar1 = itofix(4);
if (lVar1 < param_2) {
param_2 = itofix(4);
}
lVar1 = 0;
if (-1 < param_2) {
lVar1 = param_2;
}
lVar2 = itofix(0xed8);
if (lVar2 < param_1) {
uVar3 = itofix(0x10cc);
uVar4 = itofix(0xed8);
lVar2 = idiv(uVar4,uVar3);
lVar2 = mult(_LC0,param_1 - lVar2);
lVar1 = lVar1 - lVar2;
}
return lVar1;
}
|
t_sample calc_k(t_sample f,t_sample k) {
if (k>itofix(4)) k = itofix(4);
if (k < 0) k = 0;
if (f <= itofix(3800)) return k;
k = k - mult(0.5,(f-idiv(itofix(3800),itofix(4300))));
return k;
}
|
int * num_le(int *param_1,long param_2)
{
int extraout_EAX;
int extraout_EAX_00;
double dVar1;
dVar1 = (double)num_check();
if (*param_1 == 0x80) {
num_set_integer(param_1,param_1[1] <= *(int *)(param_2 + 4));
}
else if (*param_1 == 0x81) {
dVar1 = creal(dVar1);
creal(dVar1);
num_set_integer(param_1,extraout_EAX <= extraout_EAX_00);
}
num_free(param_2);
return param_1;
}
|
struct num *num_le(struct num *a, struct num *b)
{
num_check(a, b);
switch (a->type) {
case T_COMPLEX:
num_set_integer(a, creal(a->data.c) <= creal(b->data.c));
break;
case T_INTEGER:
num_set_integer(a, a->data.i <= b->data.i);
break;
}
num_free(b);
return a;
}
|
int num_params(undefined8 *param_1,int param_2,long param_3)
{
int iVar1;
int iVar2;
undefined8 *puVar3;
param_3 = param_3 + (long)param_2 * 8;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar3 = (undefined8 *)(param_3 + -8);
iVar2 = 0;
do {
iVar2 = iVar2 * 2;
iVar1 = *(int *)((long)param_1 + 0x14);
if (iVar1 == 0x81) {
*puVar3 = param_1[1];
iVar2 = iVar2 + 1;
}
else {
if (iVar1 == 0x82) {
return -0x11;
}
if (iVar1 != 0x80) {
return -0x14;
}
*puVar3 = *param_1;
}
param_1 = param_1 + -3;
puVar3 = puVar3 + -1;
} while (puVar3 != (undefined8 *)(param_3 + -0x10 + (ulong)(param_2 - 1) * -8));
}
if (iVar2 < 0) {
iVar2 = 0;
}
return iVar2;
}
|
int
num_params(const ref * op, int count, double *pval)
{
int mask = 0;
pval += count;
while (--count >= 0) {
mask <<= 1;
switch ((((const byte *)&((op)->tas.type_attrs))[1])) {
case t_real:
*--pval = op->value.realval;
break;
case t_integer:
*--pval = op->value.intval;
mask++;
break;
case t__invalid:
return ((-17));
default:
return ((-20));
}
op--;
}
return (mask < 0 ? 0 : mask);
}
|
undefined8 blizzard_enable_plane(byte param_1,int param_2)
{
uint uVar1;
uint uVar2;
uVar1 = 1 << (param_1 & 0x1f);
uVar2 = ~uVar1 & blizzard;
if (param_2 != 0) {
uVar2 = blizzard | uVar1;
}
blizzard = uVar2;
return 0;
}
|
int blizzard_enable_plane(int plane, int enable)
{
if (enable)
blizzard.enabled_planes |= 1 << plane;
else
blizzard.enabled_planes &= ~(1 << plane);
return 0;
}
|
void mem_load_file(undefined8 param_1,undefined4 param_2,uint param_3,char *param_4)
{
FILE *__stream;
void *__ptr;
size_t sVar1;
__stream = fopen(param_4,"r");
if (__stream == (FILE *)0x0) {
perror("Failed to open file");
/* WARNING: Subroutine does not return */
exit(-1);
}
__ptr = malloc((ulong)(param_3 + 1));
if (__ptr != (void *)0x0) {
sVar1 = fread(__ptr,(ulong)param_3,1,__stream);
if (sVar1 != 1) {
perror("Failed to read data");
/* WARNING: Subroutine does not return */
exit(-1);
}
mem_load(param_1,param_2,param_3,__ptr);
fclose(__stream);
free(__ptr);
return;
}
perror("Failed to allocate memory for data");
/* WARNING: Subroutine does not return */
exit(-1);
}
|
void mem_load_file(mem_st *mem, uint16_t dst, uint32_t len, char *fname)
{
uint8_t *data;
size_t obj_read;
FILE *fp;
fp = fopen(fname, "r");
if (!fp) {
perror("Failed to open file");
exit(-1);
}
data = malloc(len+1);
if (!data) {
perror("Failed to allocate memory for data");
exit(-1);
}
obj_read = fread(data, len, 1, fp);
if (obj_read != 1) {
perror("Failed to read data");
exit(-1);
}
mem_load(mem, dst, len, data);
fclose(fp);
free(data);
return;
}
|
void foo4446(void)
{
long lVar1;
long lVar2;
lVar1 = a;
if (0 < n) {
lVar2 = 0;
do {
*(int *)(lVar1 + lVar2 * 4) = (int)lVar2 + 2;
lVar2 = lVar2 + 1;
} while ((int)lVar2 < n);
}
return;
}
|
void foo4446() { int i; for (i = 0; i < n; i++) { a[i] = i + 2; } }
|
void writedigit3_8(uint *param_1)
{
*param_1 = *param_1 | 0x40;
param_1[2] = param_1[2] | 0x60;
param_1[4] = param_1[4] | 0x60;
param_1[6] = param_1[6] | 0x60;
return;
}
|
void writedigit3_8(byte LEDMatrix[]){
LEDMatrix[0] = LEDMatrix[0] | 64;
LEDMatrix[2] = LEDMatrix[2] | 32;
LEDMatrix[2] = LEDMatrix[2] | 64;
LEDMatrix[4] = LEDMatrix[4] | 32;
LEDMatrix[4] = LEDMatrix[4] | 64;
LEDMatrix[6] = LEDMatrix[6] | 32;
LEDMatrix[6] = LEDMatrix[6] | 64;
}
|
void max3100_dowork(long param_1)
{
int iVar1;
if (*(int *)(param_1 + 0xc) != 0) {
return;
}
iVar1 = freezing(current);
if ((iVar1 == 0) && (*(int *)(param_1 + 8) == 0)) {
queue_work(*(undefined4 *)(param_1 + 4),param_1);
return;
}
return;
}
|
void max3100_dowork(struct max3100_port *s)
{
if (!s->force_end_work && !freezing(current) && !s->suspending)
queue_work(s->workqueue, &s->work);
}
|
int find_lsb_set_non_zero(uint param_1)
{
int iVar1;
iVar1 = 0;
for (; (param_1 & 1) == 0; param_1 = param_1 >> 1 | 0x80000000) {
iVar1 = iVar1 + 1;
}
return iVar1;
}
|
int find_lsb_set_non_zero(u32 n)
{
return __builtin_ctz(n);
}
|
void d68040_move16_pi_pi(void)
{
uint uVar1;
int iVar2;
if ((g_cpu_type & 0x10) == 0) {
d68000_illegal();
}
else {
uVar1 = g_address_mask & g_cpu_pc;
g_cpu_pc = g_cpu_pc + 2;
iVar2 = m68k_read_disassembler_16(uVar1);
sprintf((char *)(ulong)g_dasm_str,"move16 (a%d)+,(a%d)+; (4)",(ulong)(g_cpu_ir & 7),
(ulong)(iVar2 >> 0xc & 7));
}
return;
}
|
void d68040_move16_pi_pi(void) {
if (!(g_cpu_type & 16)) { d68000_illegal(); return; };
sprintf(g_dasm_str, "move16 (a%d)+,(a%d)+; (4)", g_cpu_ir & 7, (m68k_read_disassembler_16(((g_cpu_pc += 2) - 2) & g_address_mask) >> 12) & 7);
}
|
void iwm_led_blink_stop(undefined8 param_1)
{
callout_stop();
iwm_mvm_led_disable(param_1);
return;
}
|
void
iwm_led_blink_stop(struct iwm_softc *sc)
{
callout_stop(&sc->sc_led_blink_to);
iwm_mvm_led_disable(sc);
}
|
BLAST_FillLookupTableOptions(double param_1,int *param_2,long param_3,long param_4,int param_5)
{
long lVar1;
if (param_2 == (int *)0x0) {
return 0x4b;
}
if (eBlastTypeBlastn == param_3) {
if (param_4 == 0) {
param_2[4] = eNaLookupTable;
*param_2 = 0xb;
}
else {
param_2[4] = eMBLookupTable;
*param_2 = 0x1c;
}
}
else {
param_2[4] = eAaLookupTable;
}
if (param_1 < 0.0) {
*(undefined8 *)(param_2 + 2) = 0;
}
if (__LC0 < param_1) {
*(double *)(param_2 + 2) = param_1;
}
lVar1 = Blast_ProgramIsRpsBlast(param_3);
if (lVar1 != 0) {
param_2[4] = eRPSLookupTable;
}
if (param_5 == 0) {
if (param_3 == eBlastTypeTblastn) {
return 0;
}
if (param_3 == eBlastTypeBlastp) {
return 0;
}
}
else {
*param_2 = param_5;
if ((eBlastTypeTblastn == param_3) || (eBlastTypeBlastp == param_3)) goto LAB_0010008f;
}
if (eBlastTypeBlastx != param_3) {
return 0;
}
LAB_0010008f:
if (5 < param_5) {
param_2[4] = eCompressedAaLookupTable;
}
return 0;
}
|
Int2
BLAST_FillLookupTableOptions(LookupTableOptions* options,
EBlastProgramType program_number, Boolean is_megablast,
double threshold, Int4 word_size)
{
if (!options)
return 75;
if (program_number == eBlastTypeBlastn) {
if (is_megablast) {
options->lut_type = eMBLookupTable;
options->word_size = 28;
} else {
options->lut_type = eNaLookupTable;
options->word_size = 11;
}
} else {
options->lut_type = eAaLookupTable;
}
if (threshold < 0)
options->threshold = 0;
if (threshold > 0)
options->threshold = threshold;
if (Blast_ProgramIsRpsBlast(program_number))
options->lut_type = eRPSLookupTable;
if (word_size)
options->word_size = word_size;
if ((program_number == eBlastTypeTblastn ||
program_number == eBlastTypeBlastp ||
program_number == eBlastTypeBlastx) &&
word_size > 5)
options->lut_type = eCompressedAaLookupTable;
return 0;
}
|
void alloc_arm_reg(long *param_1,undefined8 param_2,char param_3,byte param_4)
{
byte local_d;
int local_c;
local_d = 0;
for (local_c = 0; local_c < HOST_REGS; local_c = local_c + 1) {
if ((local_c != EXCLUDE_REG) && (param_3 == *(char *)((long)local_c + *param_1))) {
local_d = (byte)(*(int *)(param_1 + 1) >> ((byte)local_c & 0x1f)) & 1;
*(undefined *)((long)local_c + *param_1) = 0xff;
}
}
*(char *)(*param_1 + (long)(char)param_4) = param_3;
*(uint *)(param_1 + 1) = *(uint *)(param_1 + 1) & ~(1 << (param_4 & 0x1f));
*(uint *)(param_1 + 1) = *(uint *)(param_1 + 1) | (int)(char)local_d << (param_4 & 0x1f);
*(uint *)((long)param_1 + 0xc) = *(uint *)((long)param_1 + 0xc) & ~(1 << (param_4 & 0x1f));
return;
}
|
void alloc_arm_reg(struct regstat *cur,int i,signed char reg,char hr)
{
int n;
u32 dirty=0;
for(n=0;n<HOST_REGS;n++)
{
if(n!=EXCLUDE_REG&&cur->regmap[n]==reg) {
dirty=(cur->dirty>>n)&1;
cur->regmap[n]=-1;
}
}
cur->regmap[hr]=reg;
cur->dirty&=~(1<<hr);
cur->dirty|=dirty<<hr;
cur->isdoingcp&=~(1<<hr);
}
|
void list_insert(int *param_1,undefined8 param_2)
{
list_add(param_1,param_2,*param_1);
*param_1 = *param_1 + 1;
return;
}
|
void list_insert (list_t *list, caddr_t sym)
{
list_add (list, sym, list->in_use);
list->in_use++;
}
|
undefined8 leggiDimensioniEMaschera(int param_1,void *param_2,void *param_3,void *param_4)
{
ssize_t sVar1;
sVar1 = read(param_1,param_2,4);
if ((((int)sVar1 != -1) && (sVar1 = read(param_1,param_3,4), (int)sVar1 != -1)) &&
(sVar1 = read(param_1,param_4,1), (int)sVar1 != -1)) {
return 1;
}
return 0;
}
|
int leggiDimensioniEMaschera ( int pfd, unsigned int *r, unsigned int *c, char *maschera )
{
return ( read (pfd,r,sizeof(unsigned int)) != -1 && read (pfd,c,sizeof(unsigned int)) != -1 && read (pfd,maschera,sizeof(char)) != -1 );
}
|
void mc_result_update(long *param_1,long *param_2)
{
long lVar1;
param_1[2] = param_1[2] + param_2[2];
lVar1 = param_2[1];
*param_1 = *param_2 + *param_1;
param_1[1] = lVar1 + param_1[1];
return;
}
|
void mc_result_update(mc_result_t* result, mc_result_t* batch)
{
result->sum_X += batch->sum_X;
result->sum_X2 += batch->sum_X2;
result->ntrials += batch->ntrials;
}
|
void mqttsn_sudirribe(uint **param_1,int param_2,char *param_3,uint param_4)
{
uint *puVar1;
size_t sVar2;
puVar1 = *param_1;
mqttsn_to_state(param_1,mqttsnBusy);
if (param_4 != 0) {
param_4 = 0x20;
}
*puVar1 = param_4;
puVar1[1] = param_2 << 8 | param_2 >> 8;
strcpy((char *)(ulong)puVar1[2],param_3);
sVar2 = strlen(param_3);
mqttsn_send(param_1,0x12,sVar2 + 0xc,1);
*puVar1 = *puVar1 | 0x80;
return;
}
|
void mqttsn_sudirribe(mqttsn_c_t *ctx, uint16_t msg_id, const char *topic, int qos)
{
mqttsn_sudirribe_t *sudirribe = (mqttsn_sudirribe_t*)ctx->message;
;
mqttsn_to_state(ctx, mqttsnBusy);
sudirribe->flags = qos ? (1 << 5) : (0 << 5);
sudirribe->msg_id = (((uint16_t)(msg_id) >> 8) | ((uint16_t)(msg_id) << 8));
strcpy(sudirribe->topic.topic_name, topic);
mqttsn_send(ctx, 0x12, sizeof(mqttsn_sudirribe_t) + strlen(topic), 1);
sudirribe->flags |= (1 << 7);
}
|
void usage(void)
{
puts("Usage:");
puts("\tnum_count <datafile> [num1] [num2] ...");
return;
}
|
void usage(void)
{
puts("Usage:");
puts("\tnum_count <datafile> [num1] [num2] ...");
return;
}
|
void pp_cxx_simple_type_specifier(undefined8 param_1,undefined4 param_2)
{
int iVar1;
undefined4 uVar2;
iVar1 = TREE_CODE(param_2);
if (iVar1 < 0x85) {
if (0x81 < iVar1) {
pp_cxx_unqualified_id(param_1,param_2);
return;
}
if (iVar1 == 0x80) {
LAB_0010007a:
pp_cxx_qualified_id(param_1,param_2);
return;
}
if (iVar1 == 0x81) {
pp_cxx_identifier(param_1,"typename");
uVar2 = TYPE_CONTEXT(param_2);
pp_cxx_nested_name_specifier(param_1,uVar2);
uVar2 = TYPE_NAME(param_2);
pp_cxx_unqualified_id(param_1,uVar2);
return;
}
}
else if (iVar1 - 0x85U < 2) goto LAB_0010007a;
uVar2 = pp_c_base(param_1);
pp_c_type_specifier(uVar2,param_2);
return;
}
|
void
pp_cxx_simple_type_specifier (cxx_pretty_printer *pp, tree t)
{
switch (TREE_CODE (t))
{
case RECORD_TYPE:
case UNION_TYPE:
case ENUMERAL_TYPE:
pp_cxx_qualified_id (pp, t);
break;
case TEMPLATE_TYPE_PARM:
case TEMPLATE_TEMPLATE_PARM:
case TEMPLATE_PARM_INDEX:
pp_cxx_unqualified_id (pp, t);
break;
case TYPENAME_TYPE:
pp_cxx_identifier (pp, "typename");
pp_cxx_nested_name_specifier (pp, TYPE_CONTEXT (t));
pp_cxx_unqualified_id (pp, TYPE_NAME (t));
break;
default:
pp_c_type_specifier (pp_c_base (pp), t);
break;
}
}
|
void crop_filter_defaults(undefined8 param_1)
{
obs_data_set_default_bool(param_1,"relative",1);
return;
}
|
void crop_filter_defaults(obs_data_t *settings)
{
obs_data_set_default_bool(settings, "relative", true);
}
|
void write_on(int param_1)
{
if (-1 < param_1) {
if (maxfds <= param_1) {
maxfds = param_1 + 1;
}
FD_SET(param_1,&mwrfdset);
return;
}
return;
}
|
void
write_on(int fd)
{
if (fd < 0)
return;
if (maxfds <= fd)
maxfds = fd + 1;
FD_SET(fd, &mwrfdset);
}
|
void header(void)
{
myexp(&_LC0);
pro(&_LC0);
init_rt();
main_fil();
return;
}
|
void header()
{
myexp("main");
pro("main");
init_rt();
main_fil();
}
|
void yy_delete_buffer(void **param_1)
{
if (param_1 == (void **)0x0) {
return;
}
if (yy_current_buffer == param_1) {
yy_current_buffer = (void **)0x0;
}
if (param_1[1] == (void *)0x0) {
free(param_1);
return;
}
free(*param_1);
free(param_1);
return;
}
|
void yy_delete_buffer( YY_BUFFER_STATE b )
{
if ( ! b )
return;
if ( b == yy_current_buffer )
yy_current_buffer = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
free( b->yy_ch_buf );
free( b );
}
|
void t_isxdigit_0x24(void)
{
int iVar1;
undefined4 extraout_var;
iVar1 = isxdigit(0x24);
Assert_real(CONCAT44(extraout_var,iVar1) == 0,
"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/bitfixer/bitfixer/refs/heads/master/dg/z88dk/test/suites/ctype/test_isxdigit.c"
,0xb9,"isxdigit should be 0 for $");
return;
}
|
void t_isxdigit_0x24()
{
Assert_real((isxdigit(36) == 0), "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/bitfixer/bitfixer/refs/heads/master/dg/z88dk/test/suites/ctype/test_isxdigit.c", 185, ("isxdigit should be 0 for $"));
}
|
void LS_done(uint *param_1)
{
int iVar1;
undefined4 extraout_var;
iVar1 = fclose((FILE *)(ulong)param_1[1]);
if (CONCAT44(extraout_var,iVar1) != 0) {
syserror(errno,*param_1);
}
free((void *)(ulong)*param_1);
return;
}
|
void LS_done(LS_t *l)
{
if (fclose(l->file)!=0) syserror(errno,l->filename);
free(l->filename);
}
|
int mtab_is_writable(void)
{
int iVar1;
long lVar2;
lVar2 = mtab_is_a_symlink();
if (lVar2 == 0) {
iVar1 = ret_1927;
if (ret_1927 == -1) {
iVar1 = open((char *)(ulong)MOUNTED,O_RDWR | O_CREAT,0x1a4);
if (iVar1 < 0) {
ret_1927 = 0;
iVar1 = ret_1927;
}
else {
close(iVar1);
ret_1927 = 1;
iVar1 = ret_1927;
}
}
}
else {
iVar1 = 0;
}
return iVar1;
}
|
int
mtab_is_writable() {
static int ret = -1;
if (mtab_is_a_symlink())
return 0;
if (ret == -1) {
int fd = open(MOUNTED, O_RDWR | O_CREAT, 0644);
if (fd >= 0) {
close(fd);
ret = 1;
} else
ret = 0;
}
return ret;
}
|
undefined8 main(void)
{
printf("EOF :%d\n",(ulong)EOF);
return 0;
}
|
int main () {
printf("EOF :%d\n",EOF);
return 0;
}
|
void ylog_close(undefined8 *param_1)
{
fclose((FILE *)(ulong)*(uint *)(param_1 + 1));
*param_1 = 0;
return;
}
|
void ylog_close(ylog_context *ctx){
fclose(ctx->file);
ctx->isopen=0;
}
|
void rx_table_print8(void)
{
uint *puVar1;
uint uVar2;
long lVar3;
rx_table_generate8();
fprintf((FILE *)(ulong)stdout,
"static const struct rx_entry rx_table8[%d] __attribute__((__aligned__(4096))) = {",0x1000
);
lVar3 = 0;
uVar2 = 0;
do {
if ((uVar2 & 1) == 0) {
fprintf((FILE *)(ulong)stdout,"\n\t");
}
else {
fprintf((FILE *)(ulong)stdout," ");
}
puVar1 = (uint *)(lVar3 + _rx_table8);
fprintf((FILE *)(ulong)stdout,"{ 0x%03x, 0x%01x, 0x%01x, %d, %d, %d, %d }",(ulong)*puVar1,
(ulong)puVar1[1],(ulong)puVar1[2],(ulong)puVar1[3],(ulong)puVar1[4],(ulong)puVar1[5],
(ulong)puVar1[6]);
if (uVar2 == 0xfff) break;
fprintf((FILE *)(ulong)stdout,",");
uVar2 = uVar2 + 1;
lVar3 = lVar3 + 0x1c;
} while (uVar2 != 0x1000);
fprintf((FILE *)(ulong)stdout,"\n};\n\n");
return;
}
|
void
rx_table_print8(void)
{
int i;
rx_table_generate8();
fprintf(stdout, "static const struct rx_entry rx_table8[%d] __attribute__((__aligned__(4096))) = {", 16 * 256);
for (i = 0; i < 16 * 256; i++) {
if (!(i & 0x1))
fprintf(stdout, "\n\t");
else
fprintf(stdout, " ");
fprintf(stdout, "{ 0x%03x, 0x%01x, 0x%01x, %d, %d, %d, %d }",
_rx_table8[i].bit_string, _rx_table8[i].bit_length, _rx_table8[i].state,
_rx_table8[i].sync, _rx_table8[i].hunt, _rx_table8[i].flag, _rx_table8[i].idle);
if (i != 16 * 256 - 1)
fprintf(stdout, ",");
}
fprintf(stdout, "\n};\n\n");
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.