double get_pow(double x, int n) { if (n == 1) return x; if (n == 0) return 1; double tmp = get_pow(x, n / 2); if (n % 2) return tmp * tmp * x; else return tmp * tmp; }
static void *ralloc(void *ptr, size_t size, enum m_state state) { //LOG("Request for size change to %zd\n", size); if (size == 0) { shee(ptr); return NULL; } if (ptr == NULL) { return shalloc(size); } struct block *b = B_HEAD(ptr); unsigned long size_pow = get_pow(B_SIZE + size); /* No need for allocation, size would be the same */ if (b->k_size == size_pow) { return ptr; } void *new_ptr; if (state == ZERO) { new_ptr = shcalloc(1, size); } else { new_ptr = shalloc(size); } /* In case of failure, previous data is lost */ if (new_ptr == NULL) { shee(ptr); return NULL; } /* Previous data must be preserved, if possible */ memcpy(new_ptr, ptr, MIN(B_DATA_SIZE(b), B_DATA_SIZE(B_HEAD(new_ptr)))); shee(ptr); return new_ptr; }
double pow(double x, int n) { double ret = get_pow(x, abs(n)); if (n < 0) { ret = 1 / ret; } return ret; }
double primary() { Token t = ts.get(); switch (t.kind) { case '(': { double d = expression(); t = ts.get(); if (t.kind != ')') error("'(' expected"); return d; } case sqrtsymb: return get_square(); case powsymb: return get_pow(); case '-': return - primary(); case name: { t2 = ts.get(); cin >> if(t.kind == '=') return set_value(); return get_value(t.name); } case '+': return primary(); case number: return t.value; default: error("primary expected"); } }
static node_t *get_spow(token_stack_t *stack, GError **err) { const token_t *token; node_t *node; GError *tmp_err = NULL; token = token_peak(stack); if (!token) { set_error(err, "Expected '(', number, constant or function", token); return NULL; } if (token->type == TOK_OPERATOR && token->val.op == '-') { g_free(token_pop(stack)); node = g_malloc(sizeof(node_t)); node->type = NODE_OPERATOR; node->val.op = OP_UMINUS; node->left = NULL; node->right = get_spow(stack, &tmp_err); if (tmp_err) g_propagate_error(err, tmp_err); } else { node = get_pow(stack, &tmp_err); if (tmp_err) g_propagate_error(err, tmp_err); } return node; }
void *shcalloc(size_t nmemb, size_t size) { /* Nothing to do */ if (nmemb == 0 || size == 0) { return NULL; } return alloc(get_pow(B_SIZE + nmemb*size), ZERO); }
void *shalloc(size_t size) { /* Nothing to do */ if (size == 0) { return NULL; } return alloc(get_pow(B_SIZE + size), FREE); }
static int init_pool() { /* Get current heap break address */ if ((mp.base_addr = sbrk(0)) == (void *) -1) { perror("sbrk"); return -1; } /* First block on heap will contain 'avail' array */ /* First-block initialization for the avail array containing heads of lists with available memory, it has length of (max pool size + 1) */ /* Logarithm of the space, we can adress */ mp.max_size = CHAR_BIT*sizeof(void *); /* We want to have available pointers to all the memory we can adress */ mp.init_size = get_pow(B_SIZE + (mp.max_size + 1)*(sizeof(struct avail_head))); if (sbrk(pow2(mp.init_size)) == (void *) -1) { perror("sbrk"); return -1; } mp.pool_size = mp.init_size; /* Initialize the first block, which will contain 'avail' array */ struct block *first_b; first_b = (struct block *) mp.base_addr; first_b->state = USED; first_b->k_size = mp.init_size; LOG("--## POOL INIT INFO ##--\n"); LOG("## Heap memory begins at base_addr = %p\n", mp.base_addr); LOG("## Size of the first block is init_size = 2^%lu = %luB\n", mp.init_size, pow2(mp.init_size)); LOG("## Maximum pool size is max_size = 2^%lu = %luB\n", mp.max_size, -1L); /* Init 'avail', array of cyclic linked list */ mp.avail = (struct avail_head *) B_DATA(first_b); int i; for (i=0; i <= mp.max_size; i++) { mp.avail[i].next = (struct block *) &mp.avail[i]; mp.avail[i].prev = (struct block *) &mp.avail[i]; } first_b->prev = (struct block *) &mp.avail[first_b->k_size]; first_b->next = (struct block *) &mp.avail[first_b->k_size]; //TODO WIP int err; if ((err = pthread_create(&cleaner_th, NULL, cleaning_work, NULL)) != 0) { printf("pthread_create() ERROR %d!\n", err); return -1; } if ((err = pthread_detach(cleaner_th)) != 0) { printf("pthread_detach() ERROR %d!\n", err); return -1; } //TODO WIP LOG("--## END OF POOL INIT INFO ##--\n"); return 0; }
int parse_sub(char* subnet_string, uint32_t* subnet, uint32_t* subnet_mask) { int valid = 0; unsigned int A,B,C,D,E,F,G,H; int read_int = sscanf(subnet_string, "%u.%u.%u.%u/%u.%u.%u.%u", &A, &B, &C, &D, &E, &F, &G, &H); if(read_int >= 5) { if( A <= 255 && B <= 255 && C <= 255 && D <= 255) { unsigned char* sub = (unsigned char*)(subnet); unsigned char* msk = (unsigned char*)(subnet_mask); *( sub ) = (unsigned char)A; *( sub + 1 ) = (unsigned char)B; *( sub + 2 ) = (unsigned char)C; *( sub + 3 ) = (unsigned char)D; if(read_int == 5) { unsigned int mask = E; if(mask <= 32) { int msk_index; for(msk_index=0; msk_index*8 < mask; msk_index++) { int bit_index; msk[msk_index] = 0; for(bit_index=0; msk_index*8 + bit_index < mask && bit_index < 8; bit_index++) { msk[msk_index] = msk[msk_index] + get_pow(2, 7-bit_index); } } } valid = 1; } if(read_int == 8) { if( E <= 255 && F <= 255 && G <= 255 && H <= 255) *( msk ) = (unsigned char)E; *( msk + 1 ) = (unsigned char)F; *( msk + 2 ) = (unsigned char)G; *( msk + 3 ) = (unsigned char)H; valid = 1; } } } if(valid) { *subnet = (*subnet & *subnet_mask ); } return valid; }
void aff_nb(int nb, int stock) { char c; int pow; pow = get_pow(nb); while (pow != 1) { stock = nb / pow; c = stock + 48; nb = nb - (stock * pow); pow = pow / 10; my_putchar(c); is_easy(nb); } }
/** * 項 * * @param[in] calc calcinfo構造体 * @return 値 */ static dbl term(calcinfo *calc) { dbl x = 0.0, y = 0.0; /* 値 */ dbglog("start"); if (is_error(calc)) return EX_ERROR; x = factor(calc); dbglog(calc->fmt, x); while (true) { if (calc->ch == '*') { readch(calc); x *= factor(calc); } else if (calc->ch == '/') { readch(calc); y = factor(calc); if (y == 0) { /* ゼロ除算エラー */ set_errorcode(calc, E_DIVBYZERO); return EX_ERROR; } x /= y; } else if (calc->ch == '^') { readch(calc); y = factor(calc); x = get_pow(calc, x, y); } else { break; } } dbglog(calc->fmt, x); return x; }
static void *alloc(unsigned long size_pow, enum m_state state) { /* Pool not initialized */ if (mp.base_addr == NULL) { /* Try to initialize it */ if (init_pool() == -1) { errno = ENOMEM; return NULL; } } // LOG("BEFORE ALLOC\n"); // print_avail_map(); /* Size in power of 2, which needs to be reserved */ //LOG("Request for 2^%lu = %luB\n", size_pow, pow2(size_pow)); /* Size of the first suitable block which is available (in pow of 2) */ unsigned long j; /* Find the value of 'j' in available memory space if possible */ //LOG("--## FINDING J ##--\n"); for (j=size_pow; j < mp.pool_size; j++) { if (!list_empty(&mp.avail[j])) { break; } //LOG("j=%lu not suitable\n", j); } /* Do we need to enlarge the pool? - by making buddy for existing largest block */ //LOG("--## ENLARGING ##--\n"); while (list_empty(&mp.avail[j])) { //LOG("j=%lu <= pool_size=%lu <= max=%lu\n", j, mp.pool_size, mp.max_size); /* Cannot adress this amount of memory */ if (get_pow((unsigned long)mp.base_addr) + size_pow >= mp.max_size) { //TODO ktery pouzit? //if (mp.max_size >= mp.max_size) { LOG("Maximum size reached!\n"); errno = ENOMEM; return NULL; } //LOG("Enlarging the pool.\n"); void *new_addr; if ((new_addr = sbrk(pow2(mp.pool_size))) == (void *)-1) { LOG("sbrk pool-enlarge error!\n"); errno = ENOMEM; return NULL; } //TODO bez prepsani zpusobuje neporadek s valgrindem //memset(new_addr, 0, pow2(mp.pool_size)); /* Pool was enlarged, we have twice as much space */ mp.pool_size++; /* New memory block, buddy for previous block, will live in this space */ //LOG("new_addr = %p\n", new_addr); struct block *nb = (struct block *) new_addr; nb->state = FREE; nb->k_size = mp.pool_size - 1; //LOG("k_size = %lu\n", nb->k_size); /* Avail array must be edited, we've got new free block of size 2^(nb->k_size) */ struct block *p; p = mp.avail[nb->k_size].next; //LOG("p point %p head to %p\n", p, &mp.avail[nb->k_size]); nb->next = p; p->prev = nb; nb->prev = (struct block *) &mp.avail[nb->k_size]; mp.avail[nb->k_size].next = nb; } /* We now have the 'j' value set */ //LOG("--## REMOVING BLOCK FROM AVAIL ARRAY ##--\n"); /* Remove this block from avail array */ struct block *l, *p; l = mp.avail[j].prev; //LOG("L position = %p\n", l); p = l->prev; mp.avail[j].prev = p; p->next = (struct block *) &mp.avail[j]; enum m_state block_state = l->state; l->state = USED; /* Now we need to divide the block if space in it is too large */ //LOG("--## DIVIDING BLOCK ##--\n"); while (j != size_pow) { //LOG("divination for j=%lu\n", j); j--; p = (struct block *)((unsigned long)l + pow2(j)); //LOG("pointering to %p\n", p); p->state = FREE; p->k_size = j; p->prev = (struct block *) &mp.avail[j]; p->next = (struct block *) &mp.avail[j]; /* Add this block into avail array */ mp.avail[j].prev = p; mp.avail[j].next = p; } l->k_size = size_pow; /* Does the memory need to be cleared? */ if (state == ZERO && block_state != ZERO) { memset(B_DATA(l), 0, B_DATA_SIZE(l)); } // LOG("AFTER ALLOC\n"); // print_avail_map(); // LOG("\n"); return B_DATA(l); }
/* * implement a simple function to get positive powers of positive integers so we don't have to mess with math.h * all we really need are powers of 2 for calculating netmask * This is only called a couple of times, so speed isn't an issue either */ static unsigned long get_pow(unsigned long base, unsigned long pow) { unsigned long ret = pow == 0 ? 1 : base*get_pow(base, pow-1); return ret; }
static void print_bandwidth_args( struct ipt_bandwidth_info* info ) { if(info->cmp == BANDWIDTH_CHECK) { if(info->check_type == BANDWIDTH_CHECK_NOSWAP) { printf("--bcheck "); } else { printf("--bcheck_with_src_dst_swap "); } } printf("--id %s ", info->id); if(info->cmp != BANDWIDTH_CHECK) { /* determine current time in seconds since epoch, with offset for current timezone */ int minuteswest = get_minutes_west(); time_t now; time(&now); now = now - (minuteswest*60); if(info->type == BANDWIDTH_COMBINED) { printf("--type combined "); } if(info->type == BANDWIDTH_INDIVIDUAL_SRC) { printf("--type individual_src "); } if(info->type == BANDWIDTH_INDIVIDUAL_DST) { printf("--type individual_dst "); } if(info->type == BANDWIDTH_INDIVIDUAL_LOCAL) { printf("--type individual_local "); } if(info->type == BANDWIDTH_INDIVIDUAL_REMOTE) { printf("--type individual_remote "); } if(info->local_subnet != 0) { unsigned char* sub = (unsigned char*)(&(info->local_subnet)); int msk_bits=0; int pow=0; for(pow=0; pow<32; pow++) { uint32_t test = get_pow(2, pow); msk_bits = ( (info->local_subnet_mask & test) == test) ? msk_bits+1 : msk_bits; } printf("--subnet %u.%u.%u.%u/%u ", (unsigned char)sub[0], (unsigned char)sub[1], (unsigned char)sub[2], (unsigned char)sub[3], msk_bits); } if(info->cmp == BANDWIDTH_GT) { printf("--greater_than %lld ", info->bandwidth_cutoff); } if(info->cmp == BANDWIDTH_LT) { printf("--less_than %lld ", info->bandwidth_cutoff); } if (info->type == BANDWIDTH_COMBINED) /* too much data to print for multi types, have to use socket to get/set data */ { if( info->reset_interval != BANDWIDTH_NEVER && info->next_reset != 0 && info->next_reset < now) { /* * current bandwidth only gets reset when first packet after reset interval arrives, so output * zero if we're already past interval, but no packets have arrived */ printf("--current_bandwidth 0 "); } else { printf("--current_bandwidth %lld ", info->current_bandwidth); } } if(info->reset_is_constant_interval) { printf("--reset_interval %ld ", info->reset_interval); } else { if(info->reset_interval == BANDWIDTH_MINUTE) { printf("--reset_interval minute "); } else if(info->reset_interval == BANDWIDTH_HOUR) { printf("--reset_interval hour "); } else if(info->reset_interval == BANDWIDTH_DAY) { printf("--reset_interval day "); } else if(info->reset_interval == BANDWIDTH_WEEK) { printf("--reset_interval week "); } else if(info->reset_interval == BANDWIDTH_MONTH) { printf("--reset_interval month "); } } if(info->reset_time > 0) { printf("--reset_time %ld ", info->reset_time); } if(info->num_intervals_to_save > 0) { printf("--intervals_to_save %d ", info->num_intervals_to_save); } } }