void writer(int num)
{
unsigned char *buffr= malloc(TEST_PAGE_SIZE);
uint i;
for (i= 0; i < number_of_tests; i++)
{
uint end;
uint page= get_len(number_of_pages);
pagecache_read(&pagecache, &file1, page, 3, buffr,
PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_WRITE,
0);
end= check_page(buffr, page * TEST_PAGE_SIZE, 1, page, num);
put_rec(buffr, end, get_len(record_length_limit), num);
pagecache_write(&pagecache, &file1, page, 3, buffr,
PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN,
PAGECACHE_WRITE_DELAY,
0, LSN_IMPOSSIBLE);
if (i % flush_divider == 0)
flush_pagecache_blocks(&pagecache, &file1, FLUSH_FORCE_WRITE);
}
free(buffr);
}
static void flush_imgs(struct mdp_blit_req *req, struct ppp_regs *regs,
struct file *src_file, struct file *dst_file)
{
#ifdef CONFIG_ANDROID_PMEM
uint32_t src0_len, src1_len, dst0_len, dst1_len;
if (!(req->flags & MDP_BLIT_NON_CACHED)) {
/* flush src images to memory before dma to mdp */
get_len(&req->src, &req->src_rect, regs->src_bpp, &src0_len,
&src1_len);
flush_pmem_file(src_file, req->src.offset, src0_len);
if (IS_PSEUDOPLNR(req->src.format))
flush_pmem_file(src_file, req->src.offset + src0_len,
src1_len);
/* flush dst images */
get_len(&req->dst, &req->dst_rect, regs->dst_bpp, &dst0_len,
&dst1_len);
flush_pmem_file(dst_file, req->dst.offset, dst0_len);
if (IS_PSEUDOPLNR(req->dst.format))
flush_pmem_file(dst_file, req->dst.offset + dst0_len,
dst1_len);
}
#endif
}
void final_print_32_cigam(uint64_t size, uint64_t addr, char *text)
{
uint64_t i;
int j;
i = 0;
while (i < size)
{
j = 0;
print_addr(get_len(addr, BASE_HEX), addr, 32);
while (j < 16 && i < size)
{
if ((text[i] >= 0 && get_len(text[i], BASE_HEX) == 1)
|| (text[i] < 0 && get_len(text[i] + 256, BASE_HEX) == 1))
ft_putnbr(0);
if (text[i] < 0)
put_base(text[i] + 256, BASE_HEX);
else
put_base(text[i], BASE_HEX);
if ((j + 1) % 4 == 0)
ft_putchar(' ');
++j;
++i;
addr++;
}
ft_putstr("\n");
}
}
static void sanitise_sendmsg(int childno)
{
struct msghdr *msg;
struct sockaddr *sa = NULL;
socklen_t salen;
msg = malloc(sizeof(struct msghdr));
shm->scratch[childno] = (unsigned long) msg;
if (msg == NULL) {
// just do something weird.
shm->syscall[childno].a2 = (unsigned long) get_address();
return;
}
generate_sockaddr((struct sockaddr **) &sa, (socklen_t *) &salen, rand() % TRINITY_PF_MAX);
msg->msg_name = sa;
msg->msg_namelen = salen;
msg->msg_iov = get_address();
msg->msg_iovlen = get_len();
msg->msg_control = get_address();
msg->msg_controllen = get_len();
msg->msg_flags = rand32();
shm->syscall[childno].a2 = (unsigned long) msg;
}
std::shared_ptr<ListNode<T>> overlapping_list (List<T>& l1, List<T>& l2)
{
std::shared_ptr<ListNode<T>> res;
int l1_len = get_len(l1);
int l2_len = get_len(l2);
auto x = l1.head;
auto y = l2.head;
auto delta = l1_len - l2_len;
delta = delta >= 0 ? delta : -delta;
advance_head(l1_len >= l2_len ? x : y, delta);
while (x && y && x->next != y->next) {
x = x->next;
y = y->next;
}
return x ? x->next : nullptr;
}
void CvGBTrees::do_subsample()
{
int n = get_len(sample_idx);
int* idx = subsample_train->data.i;
for (int i = 0; i < n; i++ )
idx[i] = i;
if (subsample_test)
for (int i = 0; i < n; i++)
{
int a = (*rng)(n);
int b = (*rng)(n);
int t;
CV_SWAP( idx[a], idx[b], t );
}
/*
int n = get_len(sample_idx);
if (subsample_train == 0)
subsample_train = cvCreateMat(1, n, CV_32S);
int* subsample_data = subsample_train->data.i;
for (int i=0; i<n; ++i)
subsample_data[i] = i;
subsample_test = 0;
*/
}
void perform_read_step(uc_engine *uc){
char buff[4096*4];
uint64_t addr = get_addr();
uint64_t len = get_len()%(4096*4);
printf("read(uc,0x%"PRIx64",0x%"PRIx64"); //%d\n", addr, len, step);
uc_mem_read(uc, addr, buff, len);
}
void FileAccessJAndroid::seek_end(int64_t p_position) {
ERR_FAIL_COND(!is_open());
seek(get_len());
}
void perform_write_step(uc_engine *uc){
char buff[4096*4];
memset((void *)buff, 0, 4096*4);
uint64_t addr = get_addr();
uint64_t len = get_len()%(4096*3);
printf("write(uc,0x%"PRIx64",0x%"PRIx64"); //%d\n", addr, len, step);
uc_mem_write(uc, addr, buff, len);
}
float calcKineticEnergy(owConfigProrerty * config, float * v_buffer, float * p_buffer){
float e = 0.f;
for(int i=0;i < config->getParticleCount();i++){
if((int)(p_buffer[4 * i + 3]) != BOUNDARY_PARTICLE){
e += mass * pow(get_len(v_buffer + 4 * i + 0),2.0f)/2.0f; //
}
}
return e;
}
/* Simulate how the CPU works. */
void cpu_exec(volatile uint32_t n) {
if(nemu_state == END) {
printf("Program execution has ended. To restart the program, exit NEMU and run again.\n");
return;
}
nemu_state = RUNNING;
#ifdef DEBUG
volatile uint32_t n_temp = n;
#endif
setjmp(jbuf);
for(; n > 0; n --) {
#ifdef DEBUG
swaddr_t eip_temp = cpu.eip;
if((n & 0xffff) == 0) {
/* Output some dots while executing the program. */
fputc('.', stderr);
}
#endif
/* Execute one instruction, including instruction fetch,
* instruction decode, and the actual execution. */
int instr_len = exec(cpu.eip);
// if (cpu.eip>=0xc0100740 && cpu.eip <=0xc0100744) printf("%08x %d\n", cpu.eip, instr_len);
cpu.eip += instr_len;
// if (cpu.eip>=0xc0100740 && cpu.eip <=0xc0100744) printf("%08x %d\n", cpu.eip, instr_len);
#ifdef DEBUG
print_bin_instr(eip_temp, instr_len);
strcat(asm_buf, assembly);
Log_write("%s\n", asm_buf);
if(n_temp < MAX_INSTR_TO_PRINT) {
printf("%s\n", asm_buf);
}
#endif
/* TODO: check watchpoints here. */
if (check()) {
nemu_state=STOP;
}
if(nemu_state != RUNNING) { return; }
if(cpu.INTR & eflags.IF) {
uint32_t intr_no = i8259_query_intr();
i8259_ack_intr();
int len;
len = get_len();
cpu.eip--;
raise_intr(intr_no, len);
}
}
if(nemu_state == RUNNING) { nemu_state = STOP; }
}
static int valid_src_dst(unsigned long src_start, unsigned long src_len,
unsigned long dst_start, unsigned long dst_len,
struct mdp_blit_req *req, struct ppp_regs *regs)
{
unsigned long src_min_ok = src_start;
unsigned long src_max_ok = src_start + src_len;
unsigned long dst_min_ok = dst_start;
unsigned long dst_max_ok = dst_start + dst_len;
uint32_t src0_len, src1_len, dst0_len, dst1_len;
get_len(&req->src, &req->src_rect, regs->src_bpp, &src0_len,
&src1_len);
get_len(&req->dst, &req->dst_rect, regs->dst_bpp, &dst0_len,
&dst1_len);
if (regs->src0 < src_min_ok || regs->src0 > src_max_ok ||
regs->src0 + src0_len > src_max_ok) {
DLOG("invalid_src %x %x %lx %lx\n", regs->src0,
src0_len, src_min_ok, src_max_ok);
return 0;
}
if (regs->src_cfg & PPP_SRC_PLANE_PSEUDOPLNR) {
if (regs->src1 < src_min_ok || regs->src1 > src_max_ok ||
regs->src1 + src1_len > src_max_ok) {
DLOG("invalid_src1");
return 0;
}
}
if (regs->dst0 < dst_min_ok || regs->dst0 > dst_max_ok ||
regs->dst0 + dst0_len > dst_max_ok) {
DLOG("invalid_dst");
return 0;
}
if (regs->dst_cfg & PPP_SRC_PLANE_PSEUDOPLNR) {
if (regs->dst1 < dst_min_ok || regs->dst1 > dst_max_ok ||
regs->dst1 + dst1_len > dst_max_ok) {
DLOG("invalid_dst1");
return 0;
}
}
return 1;
}
answer_t len_max(point_t buf[], int number)
{
answer_t result = {};
result.point_one = 1;
result.point_two = 2;
double maxlen = get_len(buf[0], buf[1]);
for (int i = 0; i < number; ++i)
for (int j = 1; j < number; ++j)
if (get_len(buf[i], buf[j]) > maxlen)
{
maxlen = get_len(buf[i], buf[j]);
result.point_one = i;
result.point_two = j;
}
result.rebro = maxlen;
return result;
}
void Draw_Grain::Draw(wxWindowDC *dc)
{
//wxPen pen = wxPen("BLACK",1,wxSOLID);
wxPen pen = wxPen(get_color(),1,wxSOLID);
dc->SetPen(pen);
double r_u = sqrt ( get_ux() * get_ux()
+ get_uy() * get_uy()
+ get_uz() * get_uz() );
if ( r_u != 0 ) // Not null direction vector
{
dc->DrawLine(
(int) ( get_x() - get_len()/2 * get_ux() / r_u ),
(int) ( get_y() - get_len()/2 * get_uy() / r_u ),
(int) ( get_x() + get_len()/2 * get_ux() / r_u ),
(int) ( get_y() + get_len()/2 * get_uy() / r_u )
);
}
}
int main(){
int Switch = 1;
pstack s;
int flag = 0;
while(Switch){
printf("1 - create stack 2 - push stack 3 - pop stack 4 - get the top data 5 - get the len of stack 0 - exit\n");
scanf("%d", &Switch);
if(Switch > 1 && flag == 0){
printf("Error!\n");
continue;
}
switch(Switch){
case 1:{
s = create_stack();
flag = 1;
break;
}
case 2:{
int data;
printf("please input the data\n");
scanf("%d", &data);
push_stack(data, s);
break;
}
case 3:{
pop_stack(s);
break;
}
case 4:{
if(s->Len == 0){
printf("Error!\n");
break;
}
int top;
top = get_top(s);
printf("the top data is %d\n", top);
break;
}
case 5:{
int Len;
Len = get_len(s);
printf("the len of stack is %d\n", Len);
break;
}
case 0:
break;
}
}
return 0;
}
/*
* SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags)
*/
static void sanitise_sendmsg(struct syscallrecord *rec)
{
struct msghdr *msg;
struct sockaddr *sa = NULL;
socklen_t salen;
rec->a1 = generic_fd_from_socketinfo((struct socketinfo *) rec->a1);
msg = zmalloc(sizeof(struct msghdr));
generate_sockaddr((struct sockaddr **) &sa, (socklen_t *) &salen, rand() % TRINITY_PF_MAX);
msg->msg_name = sa;
msg->msg_namelen = salen;
msg->msg_iov = get_address();
msg->msg_iovlen = get_len();
msg->msg_control = get_address();
msg->msg_controllen = get_len();
msg->msg_flags = rand32();
rec->a2 = (unsigned long) msg;
}
void recv_data(u32 *ip, u16 *port, char *buf, u16 *buf_len)
{
char tmp[10], c;
u16 len;
u8 fd;
u16 i;
struct ip_port_map *map;
while (1) {
c = bus_recieve();
if (c == '+') {
msleep(20);
} else if (c == '\0') {
msleep(20);
continue;
} else {
msleep(1);
continue;
}
/* read IPD */
for (i = 0; i < 4; i++)
tmp[i] = bus_recieve();
if (strncmp(tmp, "IPD,", 4) != 0)
continue;
/* read fd */
for (i = 0; i < 2; i++)
tmp[i] = bus_recieve();
//fd is from '0' to '9'
fd = tmp[0] - '0';
/* get length */
len = get_len(tmp);
for (i = 0; i < len; i++)
buf[i] = bus_recieve();
break;
}
map = get_ip_port(fd);
*ip = map->ip;
*port = map->remote_port;
*buf_len = len;
}
int read_all_data (int fd, char *buf, int *index, int *reported, int size, int out)
{
int ret, len;
if (fd < 0)
return 1;
while (1)
{
ret = wait_fd (fd, 1, 250000);
if (!ret)
return 0;
assert (size > *index + 10);
len = read (fd, buf + *index, size - *index);
if (!len)
return 1;
ret = errno;
if (len == -1 && ret == ECONNRESET)
assert (len > 0);
*index += len;
assert (*index >= *reported);
while (*index - *reported >= 6)
{
len = get_len (buf + *reported);
if (*index - *reported < 6 + len)
break;
printf ("Received %s (%d,%d) (0x%x,0x%x) from %s (6+%u bytes).\n",
buf[*reported + 1] == 2 ? "SNAC" : "FLAP",
buf[*reported + 7], buf[*reported + 9], buf[*reported + 7], buf[*reported + 9],
out ? "server" : "client", len);
*reported += len + 6;
}
if (*index > *reported)
{
printf ("Received %d unreported bytes.\n", *index - *reported);
for (len = *reported; len < *index; len++)
{
printf ("<%x|%c> ", buf[len], buf[len]);
if (!(len % 8))
printf ("\n");
}
if ((len - 1) % 8)
printf ("\n");
}
}
}
/*
* HMAC strcmp
* - finished in about 1.3 second for any string inputs
*/
int hmac_strcmp(void *msg1, void *msg2, int *result, int loop)
{
unsigned char hval1[64];
unsigned char hval2[64];
unsigned int len1;
unsigned int len2;
int cnt;
int rc = 0;
len1 = get_len(msg1);
len2 = get_len(msg2);
cnt=0;
while (cnt++ < loop) {
rc |= get_hmac(msg1, len1, hval1, &len1);
msg1 = hval1;
rc |= get_hmac(msg2, len2, hval2, &len2);
msg2 = hval2;
dprint(hval1, len1);
dprint(hval2, len2);
}
*result = strncmp((const char*)hval1, (const char*)hval2, 64);
return rc;
}
/*func that creates a cpy of the string passed as parameter*/
char *copy_string(char *str) {
/*gets the length of str*/
int len = get_len(str);
/*allocates mem for new_str*/
char *new_str = malloc(sizeof(char *) * len+1);
/*cpy_str is of same size as str*/
char *cpy_str = new_str;
/*copies str to cpy_str*/
while (*str != 0) {
*cpy_str = *str;
cpy_str++;
str++;
}
return new_str;
}
void reader(int num)
{
unsigned char *buffr= malloc(TEST_PAGE_SIZE);
uint i;
for (i= 0; i < number_of_tests; i++)
{
uint page= get_len(number_of_pages);
pagecache_read(&pagecache, &file1, page, 3, buffr,
PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_LEFT_UNLOCKED,
0);
check_page(buffr, page * TEST_PAGE_SIZE, 0, page, -num);
}
free(buffr);
}
bool BString::writeToDevice(QIODevice &device)
{
if (!m_valid)
return false;
QString str = QString("%1:").
arg(get_len());
QCString utfString = str.utf8();
/* Don't write null terminator */
device.writeBlock (utfString.data(), utfString.size() - 1);
// Output the actual data
device.writeBlock (m_data.data(), m_data.size() - 1);
// Done
return true;
}
void NetStackMemoryManager::copy_to_buf(net_stack_mem_buf_t *to_buf, const void *ptr, uint32_t len)
{
while (to_buf && len) {
void *copy_to_ptr = get_ptr(to_buf);
uint32_t copy_to_len = get_len(to_buf);
if (copy_to_len > len) {
copy_to_len = len;
len = 0;
} else {
len -= copy_to_len;
}
memcpy(copy_to_ptr, ptr, copy_to_len);
ptr = static_cast<const uint8_t *>(ptr) + copy_to_len;
to_buf = get_next(to_buf);
}
}
void
ShellSort(int p[]) {
int length = get_len(src);
int i, j;
int increment = length;
do {
increment = increment / 3 + 1;
for (i = increment + 1; i <= length; i++) {
if (p[i] < p[i - increment]) {
p[0] = p[i];
for (j = i - increment; j > 0 && p[0] < p[j]; j -= increment) {
p[j + increment] = p[j];
}
p[j + increment] = p[0];
}
}
} while(increment > 1);
}
// processes an incoming byte in the midi state machine
void midi_msg_proc(uint8_t b)
{
bool is_status = ((b & 0x80) != 0);
// handle status byte
if (is_status) {
if (is_realtime(b)) {
// real-time, no data, process immediately
msg_handle_fn(b, NULL, 0);
} else {
// non real-time
idx = 0;
len = get_len(b);
status = b;
if (len == 0) {
// no data, process immediately
msg_handle_fn(status, NULL, len);
status = next_status(status);
}
}
return;
}
// handle data byte
if ((status > 0) && (len > 0)) {
if (idx < len) {
// store data byte
data[idx++] = b;
if (idx == len) {
idx = 0;
// process it
msg_handle_fn(status, data, len);
// prepare for next message
status = next_status(status);
}
} else {
// overrun, should never happen
}
} else {
// unexpected data, ignore it
}
}
void reverse(char s[])
{
int i = 0;
int j;
char tmp;
int len;
len = get_len(s);
j = len-1;
while (i!=j)
{
//printf("i is %c, j is %c.\n", s[i], s[j]);
tmp = s[i];
s[i] = s[j];
s[j] = tmp;
i++;
j--;
if (i == j || (j-i) == 1)
break;
}
}
int main(int argc, char **argv)
{
t_letter *msg;
t_letter *key;
t_letter *res;
char *base;
int flag;
if (argc != 8)
{
my_printf("Usage : %s <message> <nb1 nb2 nb3 nb4> <base> <flag>\n", argv[0]);
return (0);
}
if ((msg = get_message(argv[1])) == NULL)
return (1);
if ((key = get_key(argv)) == NULL)
return (1);
base = argv[6];
flag = my_getnbr(argv[7]);
return (0);
res = my_crypt_101(msg, key, get_len(msg));
}
char *ft_imaxtoa(intmax_t n)
{
char *str;
int is_minus;
int i;
if (n == 0)
return (ft_strdup("0"));
if (n < -9223372036854775807)
return (ft_strdup("-9223372036854775808"));
is_minus = check_minus(&n);
i = get_len(n, is_minus);
if (!(str = ft_strnew(i + 1)))
return (NULL);
str[--i] = '\0';
while (i--)
{
str[i] = (n % 10) + '0';
n /= 10;
}
if (is_minus)
str[0] = '-';
return (str);
}
char *parse_note_string(char *ptr, struct defaults *def, struct note *note){
char len_string[3];
char pitch_string[3];
char octave_string[2];
char dot[2];
// eat whitespace / commas and advance the pointer
char* dummy = malloc(strlen(ptr)+1);
if (dummy == NULL){ error("malloc failed");}
dummy[0] = '\0';
sscanf(ptr,"%[ ,]",dummy);
ptr += strlen(dummy);
free(dummy);
DEBUG&&printf("Begin Parsing Note String...\n");
ptr = get_len(ptr, len_string, def->len);
DEBUG&&printf("get_len Successful...\n");
ptr = get_pitch(ptr, pitch_string);
DEBUG&&printf("get_pitch Successful...\n");
ptr = get_octave(ptr, octave_string, def->oct);
DEBUG&&printf("get_octave Successful...\n");
ptr = get_dot(ptr, dot);
DEBUG&&printf("get_dot Successful...\n");
strcpy(note->pitch, pitch_string);
sscanf(len_string, "%d", &(note->length));
sscanf(octave_string, "%d", &(note->octave));
note->divisor = calc_divisor(pitch_string, octave_string);
DEBUG&&printf("divisor successful\n");
note->cycles = calc_cycles(def, len_string, dot);
DEBUG&&printf("cycles successful\n");
return ptr;
}
char *ft_itoa(int n)
{
char *str;
int is_minus;
int i;
if (n == 0)
return (ft_strdup("0"));
if (n == -2147483648)
return (ft_strdup("-2147483648"));
is_minus = check_minus(&n);
i = get_len(n, is_minus);
if (!(str = ft_strnew(sizeof(i) + 1)))
return (NULL);
str[--i] = '\0';
while (i--)
{
str[i] = (n % 10) + '0';
n /= 10;
}
if (is_minus)
str[0] = '-';
return (str);
}
