char* integer_to_string(integer x) {
int i, result_len;
char* result =
(char*)malloc((int)ceil(COMPONENT_BITS*x.num_components/LOG_2_10) + 2);
integer ten = create_integer(1);
ten.c[0] = 10;
if (is_zero_integer(x)) {
strcpy(result, "0");
} else {
for (i = 0; !is_zero_integer(x); i++) {
result[i] = (char)mod_small_integer(x, 10) + '0';
divide_small_integer(x, 10, x);
}
result[i] = '\0';
}
result_len = strlen(result);
for(i=0; i < result_len/2; i++) {
char temp = result[i];
result[i] = result[result_len - i - 1];
result[result_len - i - 1] = temp;
}
free_integer(ten);
return result;
}
integer string_to_integer(char* s) {
integer result = create_integer((int)ceil(LOG_2_10*strlen(s)/COMPONENT_BITS));
set_zero_integer(result);
integer digit = create_integer(1);
int i;
for (i = 0; s[i] != '\0'; i++) {
multiply_small_integer(result, 10, result);
digit.c[0] = s[i] - '0';
add_integer(result, digit, result);
}
free_integer(digit);
return result;
}
integer hex_to_integer(unsigned char* data, unsigned int datalenBytes, unsigned int pad){
integer base=string_to_integer("256");
int siz=datalenBytes;
integer radix=create_integer(siz);
set_zero_integer(radix);
radix.c[0]=1;
integer result=create_integer(siz*2+pad);
set_zero_integer(result);
integer digit=create_integer(1);
for(int i=datalenBytes-1; i>=0; i--){
digit.c[0]=data[i];
integer part_res=create_integer(1+radix.num_components+1);
set_zero_integer(part_res);
multiply_integer(digit,radix,part_res);
add_integer(result,part_res,result);
free_integer(part_res);
integer radix_temp=create_integer(radix.num_components);
copy_integer(radix,radix_temp);
multiply_integer(radix_temp,base,radix);
free_integer(radix_temp);
}
optimize_integer(result);
return result;
}
void mod_integer(integer left, integer right, integer result) {
integer mod_two_power = create_integer(right.num_components + 1);
int i, bit;
set_zero_integer(result);
set_zero_integer(mod_two_power);
mod_two_power.c[0] = 1;
for(i=0; i<left.num_components; i++) {
for(bit=0; bit<COMPONENT_BITS; bit++) {
if ((left.c[i] & (1 << bit)) != 0) {
add_integer(result, mod_two_power, result);
if (compare_integers(result, right) >= 0) {
subtract_integer(result, right, result);
}
}
shift_left_one_integer(mod_two_power);
if (compare_integers(mod_two_power, right) >= 0) {
subtract_integer(mod_two_power, right, mod_two_power);
}
}
}
free_integer(mod_two_power);
}
int main (void)
{
int choice = 0;
gdsl_queue_t q = gdsl_queue_alloc ("Q", alloc_integer, free_integer);
do
{
printf ("\t\tMENU - QUEUE\n\n");
printf ("\t1> Put\n");
printf ("\t2> Pop\n");
printf ("\t3> Get Head\n");
printf ("\t4> Get Tail\n");
printf ("\t5> Flush\n");
printf ("\t6> Search\n");
printf ("\t7> Display\n");
printf ("\t8> Dump\n");
printf ("\t9> XML display\n");
printf ("\t0> Quit\n\n" );
printf ("\t\tYour choice: " );
scanf ("%d", &choice );
switch (choice)
{
case 1:
{
int value;
printf ("Enter an integer value: ");
scanf ("%d", &value);
gdsl_queue_insert (q, (void*) &value);
}
break;
case 2:
if (!gdsl_queue_is_empty (q))
{
int* value = (int*) gdsl_queue_remove (q);
printf ("Value: %d\n", *value);
free_integer (value);
}
else
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
break;
case 3:
{
if (!gdsl_queue_is_empty (q))
{
int head = *(int*) gdsl_queue_get_head (q);
printf ("Head = %d\n", head);
}
else
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
}
break;
case 4:
{
if (!gdsl_queue_is_empty (q))
{
int tail = *(int*) gdsl_queue_get_tail (q);
printf ("Tail = %d\n", tail);
}
else
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
}
break;
case 5:
if (gdsl_queue_is_empty (q))
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
else
{
gdsl_queue_flush (q);
}
break;
case 6:
{
int pos;
int* value;
printf ("Enter an integer value to search an element by its position: ");
scanf ("%d", &pos);
value = (int*) gdsl_queue_search_by_position (q, pos);
if (value != NULL)
{
printf ("Value found at position %d = %d\n", pos, *value);
}
}
break;
case 7:
if (gdsl_queue_is_empty (q))
{
printf ("The queue '%s' is empty\n", gdsl_queue_get_name (q));
}
else
{
printf ("%s = ", gdsl_queue_get_name (q));
gdsl_queue_map_forward (q, my_display_integer, NULL);
}
break;
case 8:
gdsl_queue_dump (q, my_write_integer, stdout, NULL);
break;
case 9:
gdsl_queue_write_xml (q, my_write_integer, stdout, NULL);
break;
}
}
while (choice != 0);
gdsl_queue_free (q);
exit (EXIT_SUCCESS);
}
int pow_mod(unsigned char** result,unsigned char* p,unsigned char* q, unsigned char* r,unsigned int keyLengthBytes){
std::set_new_handler(newh);
Array<integer> factors;
integer div=hex_to_integer(q,keyLengthBytes,0);
int siz=keyLengthBytes;
integer power_of_two=create_integer(siz);
set_zero_integer(power_of_two);
integer zero=create_integer(1);
set_zero_integer(zero);
integer two=string_to_integer("2");
integer one=string_to_integer("1");
int i=0;
integer div_temp=create_integer(div.num_components);
integer rem=create_integer(div.num_components+2);
while(compare_integers(div, zero) == 1){
set_zero_integer(rem);
mod_integer(div, two,rem);
copy_integer(div,div_temp);
divide_small_integer(div_temp,2,div);
if(compare_integers(rem, zero) == 1){
integer ptt=create_integer(power_of_two.num_components);
copy_integer(power_of_two,ptt);
factors.pushBack(ptt);
}
add_integer(power_of_two,one,power_of_two);
i++;
}
free_integer(rem);
free_integer(div_temp);
Array<integer> partial_results;
integer part_res=hex_to_integer(p,keyLengthBytes,2);
integer ri=hex_to_integer(r,keyLengthBytes,1);
integer idx = create_integer(part_res.num_components);
set_zero_integer(idx);
integer part_res_temp1=create_integer(part_res.num_components);
integer part_res_temp2=create_integer(part_res.num_components);
integer part_res_temp3=create_integer(part_res.num_components);
for(int i=0; i<factors.size(); i++){
while(compare_integers(factors[i],idx)==1){
copy_integer(part_res,part_res_temp1);
copy_integer(part_res,part_res_temp2);
multiply_integer(part_res_temp1,part_res_temp2,part_res);
copy_integer(part_res,part_res_temp3);
mod_integer(part_res_temp3,ri,part_res);
add_integer(idx,one,idx);
}
integer ptt=create_integer(part_res.num_components);
copy_integer(part_res,ptt);
partial_results.pushBack(ptt);
}
free_integer(part_res_temp1);
free_integer(part_res_temp2);
free_integer(part_res_temp3);
integer resulti=create_integer(ri.num_components+1);
set_zero_integer(resulti);
resulti.c[0]=1;
integer resulti_temp=create_integer(resulti.num_components);
integer resulti_temp2=create_integer(resulti.num_components);
for(int i=0; i<partial_results.size(); i++){
copy_integer(resulti,resulti_temp);
multiply_integer(resulti_temp,partial_results[i],resulti);
copy_integer(resulti,resulti_temp2);
mod_integer(resulti_temp2,ri,resulti);
}
free_integer(resulti_temp);
free_integer(resulti_temp2);
int lol=integer_to_binary(result,resulti,keyLengthBytes);
return lol;
}
int main (void)
{
int choix = 0;
gdsl_stack_t s = gdsl_stack_alloc ("S", alloc_integer, free_integer);
do
{
printf ("\t\tMENU - STACK\n\n");
printf ("\t1> Push\n");
printf ("\t2> Pop\n");
printf ("\t3> Get\n");
printf ("\t4> Flush\n");
printf ("\t5> Search\n");
printf ("\t6> Display\n");
printf ("\t7> Dump\n");
printf ("\t8> XML display\n");
printf ("\t0> Quit\n\n");
printf ("\t\tYour choice: ");
scanf ("%d", &choix);
switch (choix)
{
case 1:
{
int value;
printf ("Enter integer value: ");
scanf ("%d", &value);
gdsl_stack_insert (s, (void*) &value);
}
break;
case 2:
if (!gdsl_stack_is_empty (s))
{
free_integer (gdsl_stack_remove (s));
}
else
{
printf ("The stack '%s' is empty\n", gdsl_stack_get_name (s));
}
break;
case 3:
{
int* top;
if (!gdsl_stack_is_empty (s))
{
top = (int*) gdsl_stack_get_top (s);
printf ("Value = %d\n", *top);
}
else
{
printf ("The stack '%s' is empty\n", gdsl_stack_get_name (s));
}
}
break;
case 4:
if (gdsl_stack_is_empty (s))
{
printf ("The stack '%s' is empty\n", gdsl_stack_get_name (s));
}
else
{
gdsl_stack_flush (s);
}
break;
case 5:
{
int pos;
int* value;
printf ("Enter an integer value to search an element by its position: ");
scanf ("%d", &pos);
value = (int*) gdsl_stack_search_by_position (s, pos);
if (value != NULL)
{
printf ("Value found at position %d = %d\n", pos, *value);
}
}
break;
case 6:
if (gdsl_stack_is_empty (s))
{
printf ("The stack '%s' is empty\n", gdsl_stack_get_name (s));
}
else
{
printf ("%s = ( ", gdsl_stack_get_name (s));
gdsl_stack_map_forward (s, my_display_integer, NULL);
printf (")\n");
}
break;
case 7:
gdsl_stack_dump (s, print_integer, stdout, NULL);
break;
case 8:
gdsl_stack_write_xml (s, print_integer, stdout, NULL);
break;
}
}
while (choix != 0);
gdsl_stack_free (s);
exit (EXIT_SUCCESS);
}
