static void realloc_obj(T **ptr, Int old_num, Int new_num,
const char *eyec="AzMemTools::realloc_obj",
const char *errmsg="") {
check_overflow(new_num, eyec, errmsg);
T *new_ptr = NULL;
if (new_num > 0) {
try {
new_ptr = new T[new_num];
}
catch (std::bad_alloc &ba) {
throw new AzException(AzAllocError, eyec, errmsg, ba.what());
}
if (new_ptr == NULL) throw new AzException(AzAllocError, eyec, errmsg);
Int cpy_num = myMIN(old_num, new_num);
if (cpy_num > 0 && *ptr != NULL) {
Int ix;
try {
for (ix = 0; ix < cpy_num; ++ix) new_ptr[ix].transfer_from(&((*ptr)[ix]));
}
catch (AzException *e) {
delete [] new_ptr;
throw e;
}
}
}
delete [] *ptr;
*ptr = new_ptr;
}
void lock_system(void)
{
int i;
int fd;
int pid = getpid();
char fname[1000];
if (guest) return;
if (locked) {
locked++;
return;
}
check_overflow(strlen(root_directory()) + strlen(LOCKFILE) + 10, sizeof(fname));
sprintf(fname,"%s/%s", root_directory(), LOCKFILE);
for (i=0;i<TIMEOUT;i++) {
fd = open(fname, O_EXCL | O_CREAT | O_WRONLY, 0644);
if (fd != -1) {
write(fd, &pid, sizeof(pid));
close(fd);
locked = 1;
return;
}
sleep(1);
}
if (unlink(fname)) fatal("unable to create/remove lockfile %s : %s\n",
fname, strerror(errno));
/* damn, something probably died while it was locked. We'll
claim the lock for ourselves so that we can recover */
locked = 1;
}
static void realloc(T ***ptr, Int old_num, Int new_num,
const char *eyec="AzPMemTools::realloc",
const char *errmsg="")
{
check_overflow(new_num, eyec, errmsg);
T **new_ptr = NULL;
if (new_num > 0) {
try {
new_ptr = new T *[new_num];
}
catch (std::bad_alloc &ba) {
throw new AzException(AzAllocError, eyec, errmsg, ba.what());
}
if (new_ptr == NULL) throw new AzException(AzAllocError, eyec, errmsg);
Int cpy_num = myMIN(old_num, new_num);
Int ix;
for (ix = 0; ix < cpy_num; ++ix) {
*(new_ptr + ix) = *(*ptr + ix);
*(*ptr + ix) = NULL;
}
for ( ; ix < new_num; ++ix) *(new_ptr + ix) = NULL;
}
free(ptr, old_num);
*ptr = new_ptr;
}
int string_to_integer(char *s){ /* returns first integer in a string */
int number, flag;
number=0;
flag=0; /* for checking concurrency of negative signs */
while (*s){
if (*s == '-')
switch_flag(&flag);
if (*s >= '0' && *s <= '9'){
while (*s >= '0' && *s <= '9'){
if (check_overflow (number, s)){
number = 0;
break;
}
if (flag) /* if number is negative */
number = (number * 10) - (*s - '0');
else
number = (number * 10) + (*s - '0');
s++;
}
break;
}
s++;
}
return number;
}
int parse_line (char *line, int line_length)
{
int i, ret, buffer_index;
char buffer[32];
memset(buffer, 0, 32);
buffer_index = ret = 0;
printf("%s", line);
for (i = 0; i < line_length; i++) {
if (isspace(line[i]) && !buffer_index)
continue;
else if (line[i] == '#') {
ret = DIRECTIVE_FOUND;
break;
} else if (isspace(line[i])) {
if (is_string(buffer))
return parse_string(line, i, line_length, 1);
else if (is_variable(buffer[0]) && find_assign(line, i, line_length))
return parse_string(line, i-1, line_length, 0);
else {
memset(buffer, 0, 32);
buffer_index = 0;
}
} else {
buffer[buffer_index++] = line[i];
if (check_overflow(buffer_index, 32))
return OVERFLOW_DETECTED;
}
}
fwrite(line, strlen(line), sizeof(char), tmp);
return ret;
}
static int xbt_log_layout_simple_doit(xbt_log_layout_t l,
xbt_log_event_t ev,
const char *fmt)
{
char *p = ev->buffer;
int rem_size = ev->buffer_size;
const char *procname;
int len;
*p = '[';
check_overflow(1);
/* Display the proc info if available */
procname = xbt_procname();
if (procname && *procname) {
len = snprintf(p, rem_size, "%s:%s:(%d) ",
SIMIX_host_self_get_name(), procname, xbt_getpid());
check_overflow(len);
}
else if (!procname) {
len = snprintf(p, rem_size, "%s::(%d) ",
SIMIX_host_self_get_name(), xbt_getpid());
check_overflow(len);
}
/* Display the date */
len = snprintf(p, rem_size, "%f] ",
surf_get_clock() - simple_begin_of_time);
check_overflow(len);
/* Display file position if not INFO */
if (ev->priority != xbt_log_priority_info && !xbt_log_no_loc) {
len = snprintf(p, rem_size, "%s:%d: ",
ev->fileName, ev->lineNum);
check_overflow(len);
}
/* Display category name */
len = snprintf(p, rem_size, "[%s/%s] ",
ev->cat->name, xbt_log_priority_names[ev->priority]);
check_overflow(len);
/* Display user-provided message */
len = vsnprintf(p, rem_size, fmt, ev->ap);
check_overflow(len);
/* End it */
*p = '\n';
check_overflow(1);
*p = '\0';
return 1;
}
int syntax_check(token_t *root, int count) {
/*the number of OPEN brackets and CLOSE brackets check*/
if (count != 0) {
printf("error:The number of \'(\' and \')\' have to be equal\n");
return -1;
}
token_t *tmp = root;
if (check_overflow(tmp) == -1) {
return -1;
}
check_double(tmp);
return 0;
}
static void alloc(T **ptr, Int num, const char *eyec="AzMemTools::alloc",
const char *errmsg="") {
*ptr = NULL;
check_overflow(num, eyec, errmsg);
if (num == 0) return;
try {
*ptr = new T[num];
}
catch (std::bad_alloc &ba) {
throw new AzException(AzAllocError, eyec, errmsg, ba.what(), num);
}
if (*ptr == NULL) throw new AzException(AzAllocError, eyec, errmsg);
}
static void alloc(T ***ptr, Int num, const char *eyec="AzPMemTools::alloc", const char *errmsg="") {
*ptr = NULL;
if (num == 0) return;
check_overflow(num, eyec, errmsg);
try {
*ptr = new T *[num];
}
catch (std::bad_alloc &ba) {
throw new AzException(AzAllocError, eyec, errmsg, ba.what());
}
if (*ptr == NULL) throw new AzException(AzAllocError, eyec, errmsg);
Int ix;
for (ix = 0; ix < num; ++ix) (*ptr)[ix] = NULL;
}
int
main (void)
{
mpfr_prec_t p;
tests_start_mpfr ();
check_special ();
for(p = 2 ; p < 200 ; p++)
check_random (p);
check_overflow ();
tests_end_mpfr ();
return 0;
}
static void
alltst (void)
{
mpfr_exp_t emin, emax;
ext = 0;
test_small ();
test_large_small ();
check_overflow ();
emin = mpfr_get_emin ();
emax = mpfr_get_emax ();
set_emin (MPFR_EMIN_MIN);
set_emax (MPFR_EMAX_MAX);
if (mpfr_get_emin () != emin || mpfr_get_emax () != emax)
{
ext = 1;
test_small ();
test_large_small ();
check_overflow ();
set_emin (emin);
set_emax (emax);
}
}
void eval_static(Node node) /*;eval_static*/
{
/* Top level evaluation of static expressions and constant folding. The
* recursive procedure const_fold is invoked, and a top-level range
* check on numeric results is performed.
*/
/* If the node type is set to as_ivalue, the the N_VAL field will
* be a Const.
*/
Const result;
result = const_fold(node);
if (result->const_kind != CONST_OM)
check_overflow(node, result);
}
int
main (int argc, char *argv[])
{
tests_start_mpfr ();
check_special();
check_reftable ();
check_parse ();
check_overflow ();
check_retval ();
bug20081028 ();
test20100310 ();
tests_end_mpfr ();
return 0;
}
int
main (int argc, char **argv)
{
struct mpfi_function_t i_mul_z;
mpfi_fun_init_IIZ (&i_mul_z, mpfi_mul_z, mpfr_mul_z);
test_start ();
check_data (&i_mul_z, "mul_z.dat");
check_random (&i_mul_z, 2, 1000, 10);
check_overflow ();
test_end ();
mpfi_fun_clear (&i_mul_z);
return 0;
}
int
main (int argc, char **argv)
{
struct mpfi_function_t i_add_fr;
test_start ();
mpfi_fun_init_IIR (&i_add_fr, mpfi_add_fr, mpfr_add);
check_data (&i_add_fr, "add_fr.dat");
check_overflow ();
check_random (&i_add_fr, 2, 1000, 10);
test_end ();
mpfi_fun_clear (&i_add_fr);
return 0;
}
int
main (int argc, char **argv)
{
struct mpfi_function_t i_add_q;
mpfi_fun_init_IIQ (&i_add_q, mpfi_add_q, mpfr_add_q);
test_start ();
check_data (&i_add_q, "add_q.dat");
if (getenv ("MPFI_CHECK_EXPENSIVE_OVERFLOW") != NULL)
check_overflow ();
test_end ();
mpfi_fun_clear (&i_add_q);
return 0;
}
void unlock_system(void)
{
char fname[1000];
if (guest) return;
if (locked > 1) {
locked--;
return;
}
if (!locked) return;
check_overflow(strlen(root_directory()) + strlen(LOCKFILE) + 10, sizeof(fname));
sprintf(fname,"%s/%s", root_directory(), LOCKFILE);
unlink(fname);
locked = 0;
}
int
main (int argc, char *argv[])
{
int h;
if (argc == 5)
{
check_random (atoi (argv[1]), atoi (argv[2]), atoi (argv[3]),
(mpfr_rnd_t) atoi (argv[4]));
return 0;
}
tests_start_mpfr ();
if (argc != 1)
{
fprintf (stderr, "Usage: tsum\n tsum n k prec rnd\n");
exit (1);
}
check_simple ();
check_special ();
check_more_special ();
for (h = 0; h <= 64; h++)
check1 (h);
check2 ();
check3 ();
check4 ();
bug20131027 ();
bug20150327 ();
bug20160315 ();
generic_tests ();
check_extreme ();
cancel ();
check_overflow ();
check_underflow ();
check_coverage ();
tests_end_mpfr ();
return 0;
}
//test all possible solutions on the bip
long long find_solutions(bip inst, bool with_print){
assert(is_initialized(inst));
//check for overflow
if(!check_overflow(inst)){
fprintf(stderr, "Coefficients too large. Overflow! \n");
return -1;
}
if (greatereq==inst.ordin) {
for (int i=0; i<inst.rows; ++i) {
for (int j=0; j<inst.columns; ++j) {
int temp = -(*get_elem(inst, i, j));
set_elem(inst, i, j, temp);
}
inst.vector[i]=-inst.vector[i];
}
}
pre_order(inst, with_print);
long long sols=bip_enumerate(inst, with_print);
return sols;
}
static void realloc_base(T **ptr, Int old_num, Int new_num,
const char *eyec="AzMemTools::realloc_base",
const char *errmsg="") {
check_overflow(new_num, eyec, errmsg);
T *new_ptr = NULL;
if (new_num > 0) {
try {
new_ptr = new T[new_num];
}
catch (std::bad_alloc &ba) {
throw new AzException(AzAllocError, eyec, errmsg, ba.what());
}
if (new_ptr == NULL) throw new AzException(AzAllocError, eyec, errmsg);
Int cpy_num = myMIN(old_num, new_num);
if (cpy_num > 0 && *ptr != NULL) {
Int ix;
for (ix = 0; ix < cpy_num; ++ix) {
*(new_ptr+ix) = *(*ptr+ix);
}
}
}
delete [] *ptr;
*ptr = new_ptr;
}
int parse_string (char *line, int offset, int line_length, int type)
{
int state, i, ret;
char var_name[32];
int var_index;
char assignment[256];
int assign_index;
char buffer[256];
int size;
memset(var_name, 0, 32);
var_index = 0;
memset(assignment, 0, 256);
assign_index = 0;
state = ret = 0;
for (i = offset; i < line_length && state != 3; i++) {
switch(state) {
case 0:
if (isspace(line[i]))
continue;
if (is_variable(line[i])) {
var_name[var_index++] = line[i];
ret = check_overflow(var_index, 32);
} else {
if (line[i] == ';')
state = 3;
else if (line[i] == '=')
state = 1;
}
break;
case 1:
if (!isspace(line[i])) {
if (line[i] == '\"')
state = 2;
} else
continue;
break;
case 2:
if (!isspace(line[i])) {
if (line[i] == '\"')
state = 3;
else {
assignment[assign_index++] = line[i];
ret = check_overflow(assign_index, 256);
}
} else
continue;
break;
default:
break;
}
}
if (type == 1) {
if (root != NULL)
insert_symbol(root, var_name);
size = snprintf(buffer, 256, "\tchar %s = calloc(%d, sizeof(char));\n\0",
var_name, assign_index+1);
fwrite(buffer, size, sizeof(char), tmp);
if (assign_index) {
size = snprintf(buffer, 256, "\tstrcpy(%s, \"%s\");\n\0",
var_name, assignment);
fwrite(buffer, size, sizeof(char), tmp);
}
} else {
size = snprintf(buffer, 256, "\t%s = realloc(%s, %d);\n\0",
var_name, var_name, assign_index+1);
fwrite(buffer, size, sizeof(char), tmp);
size = snprintf(buffer, 256, "\tstrcpy(%s, \"%s\");\n\0",
var_name, (assign_index)? assignment : "0");
fwrite(buffer, size, sizeof(char), tmp);
}
printf("Var_name: %s - Assign: %s Assign_size: %d\n", var_name, assignment, assign_index);
return ret;
}
static void
tests (void)
{
check_alloc ();
check_nans ();
check_inexact ();
check_case_1b ();
check_case_2 ();
check64();
coverage_bk_eq_0 ();
check("293607738.0", "1.9967571564050541e-5", MPFR_RNDU, 64, 53, 53,
"2.9360773800002003e8");
check("880524.0", "-2.0769715792901673e-5", MPFR_RNDN, 64, 53, 53,
"8.8052399997923023e5");
check("1196426492.0", "-1.4218093058435347e-3", MPFR_RNDN, 64, 53, 53,
"1.1964264919985781e9");
check("982013018.0", "-8.941829477291838e-7", MPFR_RNDN, 64, 53, 53,
"9.8201301799999905e8");
check("1092583421.0", "1.0880649218158844e9", MPFR_RNDN, 64, 53, 53,
"2.1806483428158846e9");
check("1.8476886419022969e-6", "961494401.0", MPFR_RNDN, 53, 64, 53,
"9.6149440100000179e8");
check("-2.3222118418069868e5", "1229318102.0", MPFR_RNDN, 53, 64, 53,
"1.2290858808158193e9");
check("-3.0399171300395734e-6", "874924868.0", MPFR_RNDN, 53, 64, 53,
"8.749248679999969e8");
check("9.064246624706179e1", "663787413.0", MPFR_RNDN, 53, 64, 53,
"6.6378750364246619e8");
check("-1.0954322421551264e2", "281806592.0", MPFR_RNDD, 53, 64, 53,
"2.8180648245677572e8");
check("5.9836930386056659e-8", "1016217213.0", MPFR_RNDN, 53, 64, 53,
"1.0162172130000001e9");
check("-1.2772161928500301e-7", "1237734238.0", MPFR_RNDN, 53, 64, 53,
"1.2377342379999998e9");
check("-4.567291988483277e8", "1262857194.0", MPFR_RNDN, 53, 64, 53,
"8.0612799515167236e8");
check("4.7719471752925262e7", "196089880.0", MPFR_RNDN, 53, 53, 53,
"2.4380935175292528e8");
check("4.7719471752925262e7", "196089880.0", MPFR_RNDN, 53, 64, 53,
"2.4380935175292528e8");
check("-1.716113812768534e-140", "1271212614.0", MPFR_RNDZ, 53, 64, 53,
"1.2712126139999998e9");
check("-1.2927455200185474e-50", "1675676122.0", MPFR_RNDD, 53, 64, 53,
"1.6756761219999998e9");
check53("1.22191250737771397120e+20", "948002822.0", MPFR_RNDN,
"122191250738719408128.0");
check53("9966027674114492.0", "1780341389094537.0", MPFR_RNDN,
"11746369063209028.0");
check53("2.99280481918991653800e+272", "5.34637717585790933424e+271",
MPFR_RNDN, "3.5274425367757071711e272");
check_same();
check53("6.14384195492641560499e-02", "-6.14384195401037683237e-02",
MPFR_RNDU, "9.1603877261370314499e-12");
check53("1.16809465359248765399e+196", "7.92883212101990665259e+196",
MPFR_RNDU, "9.0969267746123943065e196");
check53("3.14553393112021279444e-67", "3.14553401015952024126e-67", MPFR_RNDU,
"6.2910679412797336946e-67");
check53("5.43885304644369509058e+185","-1.87427265794105342763e-57",MPFR_RNDN,
"5.4388530464436950905e185");
check53("5.43885304644369509058e+185","-1.87427265794105342763e-57",MPFR_RNDZ,
"5.4388530464436944867e185");
check53("5.43885304644369509058e+185","-1.87427265794105342763e-57",MPFR_RNDU,
"5.4388530464436950905e185");
check53("5.43885304644369509058e+185","-1.87427265794105342763e-57",MPFR_RNDD,
"5.4388530464436944867e185");
check2b("1.001010101110011000000010100101110010111001010000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e358",187,
"-1.11100111001101100010001111111110101101110001000000000000000000000000000000000000000000e160",87,
"1.001010101110011000000010100101110010111001010000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111e358",178,
MPFR_RNDD);
check2b("-1.111100100011100111010101010101001010100100000111001000000000000000000e481",70,
"1.1111000110100011110101111110110010010000000110101000000000000000e481",65,
"-1.001010111111101011010000001100011101100101000000000000000000e472",61,
MPFR_RNDD);
check2b("1.0100010111010000100101000000111110011100011001011010000000000000000000000000000000e516",83,
"-1.1001111000100001011100000001001100110011110010111111000000e541",59,
"-1.1001111000100001011011110111000001001011100000011110100000110001110011010011000000000000000000000000000000000000000000000000e541",125,
MPFR_RNDZ);
check2b("-1.0010111100000100110001011011010000000011000111101000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e261",155,
"-1.00111110100011e239",15,
"-1.00101111000001001100101010101110001100110001111010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e261",159,
MPFR_RNDD);
check2b("-1.110111000011111011000000001001111101101001010100111000000000000000000000000e880",76,
"-1.1010010e-634",8,
"-1.11011100001111101100000000100111110110100101010011100000000000000000000000e880",75,
MPFR_RNDZ);
check2b("1.00100100110110101001010010101111000001011100100101010000000000000000000000000000e-530",81,
"-1.101101111100000111000011001010110011001011101001110100000e-908",58,
"1.00100100110110101001010010101111000001011100100101010e-530",54,
MPFR_RNDN);
check2b("1.0101100010010111101000000001000010010010011000111011000000000000000000000000000000000000000000000000000000000000000000e374",119,
"1.11100101100101e358",15,
"1.01011000100110011000010110100100100100100110001110110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e374",150,
MPFR_RNDZ);
check2b("-1.10011001000010100000010100100110110010011111101111000000000000000000000000000000000000000000000000000000000000000000e-172",117,
"1.111011100000101010110000100100110100100001001000011100000000e-173",61,
"-1.0100010000001001010110011011101001001011101011110001000000000000000e-173",68,
MPFR_RNDZ);
check2b("-1.011110000111101011100001100110100011100101000011011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-189",175,
"1.1e631",2,
"1.011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111e631",115,
MPFR_RNDZ);
check2b("-1.101011101001011101100011001000001100010100001101011000000000000000000000000000000000000000000e-449",94,
"-1.01111101010111000011000110011101000111001100110111100000000000000e-429",66,
"-1.01111101010111000100110010000110100100101111111111101100010100001101011000000000000000000000000000000000000000e-429",111,
MPFR_RNDU);
check2b("-1.101011101001011101100011001000001100010100001101011000000000000000000000000000000000000000000e-449",94,
"-1.01111101010111000011000110011101000111001100110111100000000000000e-429",66,
"-1.01111101010111000100110010000110100100101111111111101100010100001101011000000000000000000000000000000000000000e-429",111,
MPFR_RNDD);
check2b("-1.1001000011101000110000111110010100100101110101111100000000000000000000000000000000000000000000000000000000e-72",107,
"-1.001100011101100100010101101010101011010010111111010000000000000000000000000000e521",79,
"-1.00110001110110010001010110101010101101001011111101000000000000000000000000000000000000000000000001e521",99,
MPFR_RNDD);
check2b("-1.01010001111000000101010100100100110101011011100001110000000000e498",63,
"1.010000011010101111000100111100011100010101011110010100000000000e243",64,
"-1.010100011110000001010101001001001101010110111000011100000000000e498",64,
MPFR_RNDN);
check2b("1.00101100010101000011010000011000111111011110010111000000000000000000000000000000000000000000000000000000000e178",108,
"-1.10101101010101000110011011111001001101111111110000100000000e160",60,
"1.00101100010100111100100011000011111001000010011101110010000000001111100000000000000000000000000000000000e178",105,
MPFR_RNDN);
check2b("1.00110011010100111110011010110100111101110101100100110000000000000000000000000000000000000000000000e559",99,
"-1.011010110100111011100110100110011100000000111010011000000000000000e559",67,
"-1.101111111101011111111111001001100100011100001001100000000000000000000000000000000000000000000e556",94,
MPFR_RNDU);
check2b("-1.100000111100101001100111011100011011000001101001111100000000000000000000000000e843",79,
"-1.1101101010110000001001000100001100110011000110110111000000000000000000000000000000000000000000e414",95,
"-1.1000001111001010011001110111000110110000011010100000e843",53,
MPFR_RNDD);
check2b("-1.110110010110100010100011000110111001010000010111110000000000e-415",61,
"-1.0000100101100001111100110011111111110100011101101011000000000000000000e751",71,
"-1.00001001011000011111001100111111111101000111011010110e751",54,
MPFR_RNDN);
check2b("-1.1011011011110001001101010101001000010100010110111101000000000000000000000e258",74,
"-1.00011100010110110101001011000100100000100010101000010000000000000000000000000000000000000000000000e268",99,
"-1.0001110011001001000011110001000111010110101011110010011011110100000000000000000000000000000000000000e268",101,
MPFR_RNDD);
check2b("-1.1011101010011101011000000100100110101101101110000001000000000e629",62,
"1.111111100000011100100011100000011101100110111110111000000000000000000000000000000000000000000e525",94,
"-1.101110101001110101100000010010011010110110111000000011111111111111111111111111111111111111111111111111101e629",106,
MPFR_RNDD);
check2b("1.111001000010001100010000001100000110001011110111011000000000000000000000000000000000000e152",88,
"1.111110111001100100000100111111010111000100111111001000000000000000e152",67,
"1.1110111111011110000010101001011011101010000110110100e153",53,
MPFR_RNDN);
check2b("1.000001100011110010110000110100001010101101111011110100e696",55,
"-1.1011001111011100100001011110100101010101110111010101000000000000000000000000000000000000000000000000000000000000e730",113,
"-1.1011001111011100100001011110100100010100010011100010e730",53,
MPFR_RNDN);
check2b("-1.11010111100001001111000001110101010010001111111001100000000000000000000000000000000000000000000000000000000000e530",111,
"1.01110100010010000000010110111101011101000001111101100000000000000000000000000000000000000000000000e530",99,
"-1.1000110011110011101010101101111101010011011111000000000000000e528",62,
MPFR_RNDD);
check2b("-1.0001100010010100111101101011101000100100010011100011000000000000000000000000000000000000000000000000000000000e733",110,
"-1.001000000111110010100101010100110111001111011011001000000000000000000000000000000000000000000000000000000000e710",109,
"-1.000110001001010011111000111110110001110110011000110110e733",55,
MPFR_RNDN);
check2b("-1.1101011110000100111100000111010101001000111111100110000000000000000000000e530",74,
"1.01110100010010000000010110111101011101000001111101100000000000000000000000000000000000000000000000000000000000e530",111,
"-1.10001100111100111010101011011111010100110111110000000000000000000000000000e528",75,
MPFR_RNDU);
check2b("1.00110011010100111110011010110100111101110101100100110000000000000000000000000000000000000000000000e559",99,
"-1.011010110100111011100110100110011100000000111010011000000000000000e559",67,
"-1.101111111101011111111111001001100100011100001001100000000000000000000000000000000000000000000e556",94,
MPFR_RNDU);
check2b("-1.100101111110110000000110111111011010011101101111100100000000000000e-624",67,
"1.10111010101110100000010110101000000000010011100000100000000e-587",60,
"1.1011101010111010000001011010011111110100011110001011111111001000000100101100010010000011100000000000000000000e-587",110,
MPFR_RNDU);
check2b("-1.10011001000010100000010100100110110010011111101111000000000000000000000000000000000000000000000000000000000000000000e-172",117,
"1.111011100000101010110000100100110100100001001000011100000000e-173",61,
"-1.0100010000001001010110011011101001001011101011110001000000000000000e-173",68,
MPFR_RNDZ);
check2b("1.1000111000110010101001010011010011101100010110001001000000000000000000000000000000000000000000000000e167",101,
"1.0011110010000110000000101100100111000001110110110000000000000000000000000e167",74,
"1.01100101010111000101001111111111010101110001100111001000000000000000000000000000000000000000000000000000e168",105,
MPFR_RNDZ);
check2b("1.100101111111110010100101110111100001110000100001010000000000000000000000000000000000000000000000e808",97,
"-1.1110011001100000100000111111110000110010100111001011000000000000000000000000000000e807",83,
"1.01001001100110001100011111000000000001011010010111010000000000000000000000000000000000000000000e807",96,
MPFR_RNDN);
check2b("1e128",128,
"1e0",128,
"100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001e0",256,
MPFR_RNDN);
/* Checking double precision (53 bits) */
check53("-8.22183238641455905806e-19", "7.42227178769761587878e-19",MPFR_RNDD,
"-7.9956059871694317927e-20");
check53("5.82106394662028628236e+234","-5.21514064202368477230e+89",MPFR_RNDD,
"5.8210639466202855763e234");
check53("5.72931679569871602371e+122","-5.72886070363264321230e+122",
MPFR_RNDN, "4.5609206607281141508e118");
check53("-5.09937369394650450820e+238", "2.70203299854862982387e+250",
MPFR_RNDD, "2.7020329985435301323e250");
check53("-2.96695924472363684394e+27", "1.22842938251111500000e+16",MPFR_RNDD,
"-2.96695924471135255027e27");
check53("1.74693641655743793422e-227", "-7.71776956366861843469e-229",
MPFR_RNDN, "1.669758720920751867e-227");
/* x = -7883040437021647.0; for (i=0; i<468; i++) x = x / 2.0;*/
check53("-1.03432206392780011159e-125", "1.30127034799251347548e-133",
MPFR_RNDN,
"-1.0343220509150965661100887242027378881805094180354e-125");
check53("1.05824655795525779205e+71", "-1.06022698059744327881e+71",MPFR_RNDZ,
"-1.9804226421854867632e68");
check53("-5.84204911040921732219e+240", "7.26658169050749590763e+240",
MPFR_RNDD, "1.4245325800982785854e240");
check53("1.00944884131046636376e+221","2.33809162651471520268e+215",MPFR_RNDN,
"1.0094511794020929787e221");
/*x = 7045852550057985.0; for (i=0; i<986; i++) x = x / 2.0;*/
check53("4.29232078932667367325e-278",
"1.0773525047389793833221116707010783793203080117586e-281"
, MPFR_RNDU, "4.2933981418314132787e-278");
check53("5.27584773801377058681e-80", "8.91207657803547196421e-91", MPFR_RNDN,
"5.2758477381028917269e-80");
check53("2.99280481918991653800e+272", "5.34637717585790933424e+271",
MPFR_RNDN, "3.5274425367757071711e272");
check53("4.67302514390488041733e-184", "2.18321376145645689945e-190",
MPFR_RNDN, "4.6730273271186420541e-184");
check53("5.57294120336300389254e+71", "2.60596167942024924040e+65", MPFR_RNDZ,
"5.5729438093246831053e71");
check53("6.6052588496951015469e24", "4938448004894539.0", MPFR_RNDU,
"6.6052588546335505068e24");
check53("1.23056185051606761523e-190", "1.64589756643433857138e-181",
MPFR_RNDU, "1.6458975676649006598e-181");
check53("2.93231171510175981584e-280", "3.26266919161341483877e-273",
MPFR_RNDU, "3.2626694848445867288e-273");
check53("5.76707395945001907217e-58", "4.74752971449827687074e-51", MPFR_RNDD,
"4.747530291205672325e-51");
check53("277363943109.0", "11.0", MPFR_RNDN, "277363943120.0");
check53("1.44791789689198883921e-140", "-1.90982880222349071284e-121",
MPFR_RNDN, "-1.90982880222349071e-121");
/* tests for particular cases (Vincent Lefevre, 22 Aug 2001) */
check53("9007199254740992.0", "1.0", MPFR_RNDN, "9007199254740992.0");
check53("9007199254740994.0", "1.0", MPFR_RNDN, "9007199254740996.0");
check53("9007199254740992.0", "-1.0", MPFR_RNDN, "9007199254740991.0");
check53("9007199254740994.0", "-1.0", MPFR_RNDN, "9007199254740992.0");
check53("9007199254740996.0", "-1.0", MPFR_RNDN, "9007199254740996.0");
check_overflow ();
check_1111 ();
check_1minuseps ();
}
static int xbt_log_layout_format_doit(xbt_log_layout_t l, xbt_log_event_t ev, const char *msg_fmt)
{
char *p = ev->buffer;
int rem_size = ev->buffer_size;
int precision = -1;
int length = -1;
char *q;
for (q = l->data ; *q != '\0' ; q++) {
if (*q == '%') {
q++;
handle_modifier:
switch (*q) {
case '\0':
fprintf(stderr, "Layout format (%s) ending with %%\n", (char *)l->data);
xbt_abort();
case '%':
*p = '%';
check_overflow(1);
break;
case 'n': /* platform-dependant line separator; LOG4J compliant */
*p = '\n';
check_overflow(1);
break;
case 'e': /* plain space; SimGrid extension */
*p = ' ';
check_overflow(1);
break;
case '.': /* precision specifier */
precision = strtol(q + 1, &q, 10);
goto handle_modifier;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9': /* length modifier */
length = strtol(q, &q, 10);
goto handle_modifier;
case 'c': /* category name; LOG4J compliant
should accept a precision postfix to show the hierarchy */
show_string(ev->cat->name);
break;
case 'p': /* priority name; LOG4J compliant */
show_string(xbt_log_priority_names[ev->priority]);
break;
case 'h': /* host name; SimGrid extension */
show_string(SIMIX_host_self_get_name());
break;
case 't': /* thread name; LOG4J compliant */
show_string(SIMIX_process_self_get_name());
break;
case 'P': /* process name; SimGrid extension */
show_string(xbt_procname());
break;
case 'i': /* process PID name; SimGrid extension */
show_int(xbt_getpid());
break;
case 'F': /* file name; LOG4J compliant */
show_string(ev->fileName);
break;
case 'l': { /* location; LOG4J compliant */
int len, sz;
set_sz_from_precision();
len = snprintf(p, sz, "%s:%d", ev->fileName, ev->lineNum);
check_overflow(MIN(sz, len));
break;
}
case 'L': /* line number; LOG4J compliant */
show_int(ev->lineNum);
break;
case 'M': /* method (ie, function) name; LOG4J compliant */
show_string(ev->functionName);
break;
case 'b': /* backtrace; called %throwable in LOG4J */
case 'B': /* short backtrace; called %throwable{short} in LOG4J */
// TODO, backtrace
#if 0 && HAVE_BACKTRACE && HAVE_EXECINFO_H && HAVE_POPEN && defined(ADDR2LINE)
{
xbt_ex_t e("");
e.used = backtrace((void **) e.bt, XBT_BACKTRACE_SIZE);
e.bt_strings = NULL;
xbt_ex_setup_backtrace(&e);
if (*q == 'B') {
show_string(e.bt_strings[1] + 8);
} else {
xbt_strbuff_t buff = xbt_strbuff_new();
int i;
xbt_strbuff_append(buff, e.bt_strings[1] + 8);
for (i = 2; i < e.used; i++) {
xbt_strbuff_append(buff, "\n");
xbt_strbuff_append(buff, e.bt_strings[i] + 8);
}
show_string(buff->data);
xbt_strbuff_free(buff);
}
}
#else
show_string("(no backtrace on this arch)");
#endif
break;
case 'd': /* date; LOG4J compliant */
show_double(surf_get_clock());
break;
case 'r': /* application age; LOG4J compliant */
show_double(surf_get_clock() - format_begin_of_time);
break;
case 'm': { /* user-provided message; LOG4J compliant */
int len, sz;
set_sz_from_precision();
len = vsnprintf(p, sz, msg_fmt, ev->ap);
check_overflow(MIN(sz, len));
break;
}
default:
fprintf(stderr, ERRMSG, *q, (char *)l->data);
xbt_abort();
}
} else {
*p = *q;
check_overflow(1);
}
}
*p = '\0';
return 1;
}
//---------------------------------------------------------------------------------------------
void BitMessage::write_bits(int32_t value, int32_t num_bits)
{
int32_t put;
int32_t fraction;
// check if m_write is void
if (!m_write)
{
printf( "cannot write to message" );
}
// check if the number of bits is valid
if (num_bits == 0 || num_bits < -31 || num_bits > 32)
{
printf( "bad numBits %i", num_bits);
}
// check for value overflows
// this should be an error floatly, as it can go unnoticed and cause either bandwidth or corrupted data transmitted
if (num_bits != 32)
{
if (num_bits > 0)
{
if (value > (1 << num_bits) - 1)
{
printf( "value overflow %d %d", value, num_bits );
}
else if (value < 0)
{
printf( "value overflow %d %d", value, num_bits );
}
}
else
{
int32_t r = 1 << (-1 - num_bits);
if (value > r - 1)
{
printf( "value overflow %d %d", value, num_bits );
}
else if (value < -r)
{
printf( "value overflow %d %d", value, num_bits );
}
}
}
// Change sign if it's negative
if (num_bits < 0 )
{
num_bits = -num_bits;
}
// check for msg overflow
if (check_overflow(num_bits))
{
return;
}
// write the bits
while(num_bits)
{
if (m_write_bit == 0)
{
m_write[m_cur_size] = 0;
m_cur_size++;
}
put = 8 - m_write_bit;
if (put > num_bits)
{
put = num_bits;
}
fraction = value & ((1 << put) - 1);
m_write[m_cur_size - 1] |= fraction << m_write_bit;
num_bits -= put;
value >>= put;
m_write_bit = (m_write_bit + put) & 7;
}
}
/************************************************************************
** Function: ProcessUsgDetail
**
** Purpose: Read a detail usage record from usage file.
**
** returns: SUCCESS - no errors, or "soft" (minor) error. SUCCESS
** means that the record will be saved in either
** CDR_DATA or CDR_DATA_WORK.
** FAILURE - serious parsing error. return FAILURE implies
** "hard" error. Such records will be written to
** the bad image file.
** Note that records with hard errors will be
** written to bad image file as is. This means
** error codes are NOT saved. This is why we
** return immediately for FAILURE case.
**
** General idea is that missing data will be considered a "soft" error
** where as non-numeric data in a numeric field will be considered a
** hard error.
*************************************************************************
*/
int ProcessUsgDetail(CDR_DATA_STRUCT *cdr_data,
RECORD_TYPE_STRUCT *rec_type,
int minimize,
int *checksum1,
int *checksum2,
int *checksum3)
{
char *ptr;
char tmpstr[1024];
char gstrScratch1[1024];
int pos; /* floating pointer into cdr_data->usg_rec */
/* for time field, we need to convert to the usage time zone if
** it is provided. But sometime we do not have timezone in usage
** file, in this case we will convert to default timezone?
** To convert time, we need to wait after the whole usage record
** has been processed, then do conversion if necessary
*/
short trans_dt_type = -1; /* -1 means not supplied in usg file,no op */
short second_dt_type = -1;/* -1 means not supplied in usg file,no op */
short rate_dt_type = -1; /* -1 means not supplied in usg file,no op */
short new_timezone = FALSE; /* to indicate whether there is a timezone
** in the usage record
*/
char usage_tz[szUnixTZ+1+3];
char unix_tz[szUnixTZ+1];
short size; /* size of input field */
tiny isdst; /* ignored */
int i;
int j;
pos = 0;
ptr = gstrScratch1;
if(mpsIsLogLevelHigh())
{
sprintf(tmpstr, "\nProcessing Record Type \'%s\'",
rec_type->record_type);
emit(ERRLOC,MPS_GENERIC_INFORM,tmpstr);
sprintf(tmpstr, "===================================");
emit(ERRLOC,MPS_GENERIC_INFORM,tmpstr);
sprintf(tmpstr, "%-20.20s %-20.20s %-12.12s %-5.5s %-15.12s",
"Field Name From", "Field Name To","Field Type", "Size","Field Value");
emit(ERRLOC,MPS_GENERIC_INFORM,tmpstr);
sprintf(tmpstr,
"=============== =============== ============ ===== ===========");
emit(ERRLOC,MPS_GENERIC_INFORM,tmpstr);
}
for(i = rec_type->from_pos; i <= rec_type->to_pos; i++)
{
size = gsField_Mapping[i].field_from_size;
/* Skip over some fields if in minimize / non-debug mode */
if ( minimize && !mpsIsLogLevelHigh() )
{
switch(gsField_Mapping[i].field_to_id)
{
case to_type_id_usg:
case to_point_origin:
case to_point_target:
case to_trans_dt:
case to_timezone:
case to_external_id:
case to_external_id_type:
case to_home_carrier_sid_bid:
case to_num_tax_details:
break;
default:
pos += size;
continue;
}
}
switch(gsField_Mapping[i].field_from_type)
{
case binary:
j = ParseHex((char *)cdr_data->usg_rec+pos, (int) size);
pos += size;
if(mpsIsLogLevelHigh())
{
sprintf(tmpstr,
"%-20.20s %-20.20s %-12.12s %-6d%-12d",
gsField_Mapping[i].field_from_name,
gsField_Mapping[i].field_to_name,
"(binary)",
size,
j);
emit(ERRLOC,MPS_GENERIC_INFORM,tmpstr);
}
break;
default:
if((gsField_Mapping[i].field_to_id == to_annotation) ||
(gsField_Mapping[i].field_to_id == to_customer_tag) ||
(gsField_Mapping[i].field_to_id == to_roaming_detail))
{
extract_field_no_strip(&ptr, (char *)cdr_data->usg_rec, &pos, (int) size);
} else {
extract_field(&ptr, (char *)cdr_data->usg_rec, &pos, (int) size);
}
if(mpsIsLogLevelHigh())
{
sprintf(tmpstr,
"%-20.20s %-20.20s %-12.12s %-6d%-s",
gsField_Mapping[i].field_from_name,
gsField_Mapping[i].field_to_name,
"(a/n str)",
size,
ptr);
emit(ERRLOC,MPS_GENERIC_INFORM,tmpstr);
}
break;
}
if(gsField_Mapping[i].is_ignored)
{
continue;
}
if(gsField_Mapping[i].is_required && ptr[0] == '\0' &&
gsField_Mapping[i].field_from_type != binary)
{
emit(ERRLOC,CAP_FIELD_MISSING_X,gsField_Mapping[i].field_from_name);
set_cdr_error_code(cdr_data, CAP_FIELD_MISSING);
sprintf(tmpstr, "%d,Field: \"%s\"",
CAP_FIELD_MISSING,gsField_Mapping[i].field_to_name);
emit(ERRLOC,MPS_GEN_ERROR,tmpstr );
set_mps_error_struct(tmpstr,"");
}
/* if we need to convert from string to a numeric field *
** we need to check no digital char and overflow */
if(gsField_Mapping[i].field_to_type != to_string)
{
if(gsField_Mapping[i].field_from_type != binary)
{
if(numeric_string(ptr))
{
if(gsField_Mapping[i].field_to_type == to_numeric)
{
}
else
{
if(convert_to_number(ptr,&j,
(short) gsField_Mapping[i].field_to_type) == FAILURE)
{
/* conversion caused overflow */
j = 0;
set_cdr_error_code(cdr_data, CAP_VALUE_OVERFLOW);
sprintf(tmpstr,
"%d,convert \"%s\" to \"%s\" caused overflow",
CAP_VALUE_OVERFLOW,
ptr,
gsField_Mapping[i].field_to_name);
set_mps_error_struct(tmpstr,"");
}
}
}
else
{
/* some non-numeric characters for numeric field */
j = 0;
set_cdr_error_code(cdr_data, CAP_BAD_NUM_FIELD);
sprintf(tmpstr,
"%d,Field value: \"%s\"",
CAP_BAD_NUM_FIELD,
ptr);
emit(ERRLOC,CAP_BAD_NUM_FIELD );
sprintf(tmpstr, "%-20.20s: \"%s\"",
gsField_Mapping[i].field_from_name,gstrScratch1);
emit(ERRLOC,MPS_GEN_ERROR,tmpstr );
set_mps_error_struct(tmpstr,"");
}
}
else
{
/* when we get a binary field, we need to check overflow
** since we may get the int and try to convert to a tiny */
if(check_overflow(j, (short) gsField_Mapping[i].field_to_type) == FAILURE)
{
j = 0;
/* conversion caused overflow */
set_cdr_error_code(cdr_data, CAP_VALUE_OVERFLOW);
sprintf(tmpstr,
"%d,convert %d to \"%s\" caused overflow",
CAP_VALUE_OVERFLOW,
j,
gsField_Mapping[i].field_to_name);
emit(ERRLOC,MPS_GEN_ERROR,tmpstr );
set_mps_error_struct(tmpstr,"");
}
}
}
switch(gsField_Mapping[i].field_to_id)
{
case to_ext_tracking_id:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->ext_tracking_id, ptr, szExtTrackingId);
cdr_data->ext_tracking_id[szExtTrackingId] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->ext_tracking_id, tmpstr,szExtTrackingId);
cdr_data->ext_tracking_id[szExtTrackingId] = '\0';
}
break;
case to_trans_id:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->trans_id, ptr, szTransID);
cdr_data->trans_id[szTransID] = '\0';
}
else
{
sprintf(cdr_data->trans_id,"%d",j);
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->trans_id, tmpstr, szTransID);
cdr_data->trans_id[szTransID] = '\0';
}
break;
case to_element_id:
cdr_data->element_id = j;
break;
case to_type_id_usg:
cdr_data->type_id_usg = j;
cdr_data->orig_type_id_usg = j;
break;
case to_rate_class:
cdr_data->rate_class = j;
break;
case to_bill_class:
cdr_data->bill_class = j;
break;
case to_num_tax_details:
cdr_data->num_tax_details = j;
break;
case to_provider_id:
cdr_data->provider_id = j;
break;
case to_provider_class:
cdr_data->provider_class = j;
break;
case to_jurisdiction:
cdr_data->jurisdiction = j;
break;
case to_rate_currency_code:
cdr_data->rate_currency_code = j;
break;
case to_emf_create_date:
break;
case to_point_origin:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->point_origin, ptr, szUsagePoint);
cdr_data->point_origin[szUsagePoint] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->point_origin, tmpstr, szUsagePoint);
cdr_data->point_origin[szUsagePoint] = '\0';
}
break;
case to_country_dial_code_origin:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->country_dial_code_origin, ptr,
szDialCode);
cdr_data->country_dial_code_origin[szDialCode] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->country_dial_code_origin, tmpstr, szDialCode);
cdr_data->country_dial_code_origin[szDialCode] = '\0';
}
break;
case to_point_tax_code_origin:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->point_tax_code_origin, ptr, szTaxCode);
cdr_data->point_tax_code_origin[szTaxCode] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->point_tax_code_origin, tmpstr, szTaxCode);
cdr_data->point_tax_code_origin[szTaxCode] = '\0';
}
break;
case to_point_tax_code_type_origin:
cdr_data->point_tax_code_type_origin = j;
break;
case to_point_target:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->point_target, ptr, szUsagePoint);
cdr_data->point_target[szUsagePoint] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->point_target, tmpstr, szUsagePoint);
cdr_data->point_target[szUsagePoint] = '\0';
}
break;
case to_point_tax_code_target:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->point_tax_code_target, ptr, szTaxCode);
cdr_data->point_tax_code_target[szTaxCode] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->point_tax_code_target, tmpstr, szTaxCode);
cdr_data->point_tax_code_target[szTaxCode] = '\0';
}
break;
case to_point_tax_code_type_target:
cdr_data->point_tax_code_type_target = j;
break;
case to_trans_dt:
/* if time comes in as unix time save it in the trans_time field
** and do conversion later by using a timezone
*/
if(gsField_Mapping[i].field_to_type == to_int)
cdr_data->trans_time = j;
else
{
/* if time comes in as char string save the string and convert
** to YYYYMMDD HH:MM:SS according the input format
*/
if(convert_date_string(cdr_data->trans_dt, gstrScratch1,
gsField_Mapping[i].date_format_type) == FAILURE)
{
emit(ERRLOC, MPS_BAD_FIELD, "trans_dt", cdr_data->trans_dt);
set_cdr_error_code(cdr_data, CAP_BAD_PRIMTIME);
sprintf(tmpstr,
"%d,%s: \"%s\"",
CAP_BAD_PRIMTIME,gsField_Mapping[i].field_to_name,
cdr_data->trans_dt);
emit(ERRLOC, MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
break;
}
}
trans_dt_type = gsField_Mapping[i].field_to_type;
break;
case to_second_dt:
/* if time comes in as unix time save it in the trans_time field
** and do conversion later by using a timezone
*/
if(gsField_Mapping[i].field_to_type == to_int)
cdr_data->second_time = j;
else
{
/* if time comes in as char string save the string and convert
** to YYYYMMDD HH:MM:SS according the input format later
*/
if(convert_date_string(cdr_data->second_dt, gstrScratch1,
gsField_Mapping[i].date_format_type) == FAILURE)
{
emit(ERRLOC, MPS_BAD_FIELD,"second_dt",cdr_data->second_dt);
set_cdr_error_code(cdr_data, CAP_BAD_SECONDTIME);
sprintf(tmpstr,
"%d,%s: \"%s\"",
CAP_BAD_SECONDTIME,
gsField_Mapping[i].field_to_name,
cdr_data->second_dt);
emit(ERRLOC, MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
break;
}
}
second_dt_type = gsField_Mapping[i].field_to_type;
break;
case to_timezone:
cdr_data->timezone = j;
new_timezone = TRUE;
break;
case to_primary_units:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->primary_units), j);
}
else
{
arb_numeric_from_string(&(cdr_data->primary_units), ptr);
if ( arb_numeric_to_int( &(cdr_data->primary_units), &j) == FAILURE)
{
j = cdr_data->primary_units.low;
}
}
*checksum1 += j;
break;
case to_primary_type:
cdr_data->primary_type = j;
break;
case to_second_units:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->second_units), j);
}
else
{
arb_numeric_from_string(&(cdr_data->second_units), ptr);
if ( arb_numeric_to_int( &(cdr_data->second_units), &j) == FAILURE)
{
j = cdr_data->second_units.low;
}
}
*checksum2 += j;
break;
case to_second_type:
cdr_data->second_type = j;
break;
case to_third_units:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->third_units), j);
}
else
{
arb_numeric_from_string(&(cdr_data->third_units), ptr);
if ( arb_numeric_to_int( &(cdr_data->third_units), &j) == FAILURE)
{
j = cdr_data->third_units.low;
}
}
*checksum3 += j;
break;
case to_third_type:
cdr_data->third_type = j;
break;
case to_federal_tax:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->federal_tax), j);
}
else
{
arb_numeric_from_string(&(cdr_data->federal_tax), ptr);
}
break;
case to_state_tax:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->state_tax), j);
}
else
{
arb_numeric_from_string(&(cdr_data->state_tax), ptr);
}
break;
case to_county_tax:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->county_tax), j);
}
else
{
arb_numeric_from_string(&(cdr_data->county_tax), ptr);
}
break;
case to_city_tax:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->city_tax), j);
}
else
{
arb_numeric_from_string(&(cdr_data->city_tax), ptr);
}
break;
case to_other_tax:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->other_tax), j);
}
else
{
arb_numeric_from_string(&(cdr_data->other_tax), ptr);
}
break;
case to_units_currency_code:
cdr_data->units_currency_code = j;
break;
case to_annotation:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->annotation, ptr, size);
cdr_data->annotation[size] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->annotation, tmpstr, size);
cdr_data->annotation[size] = '\0';
}
break;
case to_customer_tag:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->customer_tag, ptr, szCustomerTag);
cdr_data->customer_tag[szCustomerTag] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->customer_tag, tmpstr, szCustomerTag);
cdr_data->customer_tag[szCustomerTag] = '\0';
}
break;
case to_geocode:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->geocode, ptr, szTaxCode);
cdr_data->geocode[szTaxCode] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->geocode, tmpstr, szTaxCode);
cdr_data->geocode[szTaxCode] = '\0';
}
break;
case to_roaming_detail:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->roaming_detail, ptr, size);
cdr_data->roaming_detail[size] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->roaming_detail, tmpstr, size);
cdr_data->roaming_detail[size] = '\0';
}
break;
case to_rated_units:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->rated_units), j);
}
else
arb_numeric_from_string(&(cdr_data->rated_units), ptr);
break;
case to_total_amt:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->total_amt), j);
}
else
arb_numeric_from_string(&(cdr_data->total_amt), ptr);
break;
case to_base_amt:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->base_amt), j);
}
else
arb_numeric_from_string(&(cdr_data->base_amt), ptr);
break;
case to_unrounded_amount:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->unrounded_amount), j);
}
else
arb_numeric_from_string(&(cdr_data->unrounded_amount), ptr);
break;
case to_foreign_amount:
if(gsField_Mapping[i].field_from_type == binary)
{
arb_numeric_from_int(&(cdr_data->foreign_amount), j);
}
else
arb_numeric_from_string(&(cdr_data->foreign_amount), ptr);
break;
case to_rate_period:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->rate_period, ptr, szRatePeriod);
cdr_data->rate_period[szRatePeriod] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->rate_period, tmpstr, szRatePeriod);
cdr_data->rate_period[szRatePeriod] = '\0';
}
break;
case to_rate_dt:
/* if time comes in as unix time save it in the trans_time field
** and do conversion later by using a timezone
*/
if(gsField_Mapping[i].field_to_type == to_int)
cdr_data->rate_time = j;
else
{
if(convert_date_string(cdr_data->rate_dt, gstrScratch1,
gsField_Mapping[i].date_format_type) == FAILURE)
{
emit(ERRLOC, MPS_BAD_FIELD,"rate_dt",cdr_data->rate_dt);
set_cdr_error_code(cdr_data, CAP_BAD_RATETIME);
sprintf(tmpstr,
"%d,%s: \"%s\"",
CAP_BAD_RATETIME,
gsField_Mapping[i].field_to_name,
cdr_data->rate_dt);
emit(ERRLOC, MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
break;
}
}
rate_dt_type = gsField_Mapping[i].field_to_type;
break;
case to_no_bill:
cdr_data->no_bill = j;
break;
case to_comp_status:
cdr_data->comp_status = j;
break;
case to_cdr_status:
cdr_data->cdr_status = j;
break;
case to_external_id:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->external_id, ptr, size);
cdr_data->external_id[size] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->external_id, tmpstr, size);
cdr_data->external_id[size] = '\0';
}
break;
case to_external_id_type:
cdr_data->external_id_type = j;
break;
case to_account_no:
cdr_data->account_no = j;
break;
case to_kp_subscr_no:
cdr_data->kp_subscr_no = j;
break;
case to_kp_subscr_no_resets:
cdr_data->kp_subscr_no_resets = j;
break;
case to_kp_server_id:
cdr_data->kp_server_id = j;
break;
case to_ccard_account:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->miu_ccard_account, ptr, szCCardAcct);
cdr_data->miu_ccard_account[szCCardAcct] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->miu_ccard_account, tmpstr, szCCardAcct);
cdr_data->miu_ccard_account[szCCardAcct] = '\0';
}
break;
case to_ccard_carrier_code:
cdr_data->miu_ccard_carrier_code = j;
break;
case to_ccard_ownr_fname:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->miu_ccard_ownr_fname, ptr, szCCardOwnr);
cdr_data->miu_ccard_ownr_fname[szCCardOwnr] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->miu_ccard_ownr_fname, tmpstr, szCCardOwnr);
cdr_data->miu_ccard_ownr_fname[szCCardOwnr] = '\0';
}
break;
case to_ccard_ownr_lname:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->miu_ccard_ownr_lname, ptr, szCCardOwnr);
cdr_data->miu_ccard_ownr_lname[szCCardOwnr] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->miu_ccard_ownr_lname, tmpstr, szCCardOwnr);
cdr_data->miu_ccard_ownr_lname[szCCardOwnr] = '\0';
}
break;
case to_ccard_expire:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->miu_ccard_expire, ptr, szCCardExpire);
cdr_data->miu_ccard_expire[szCCardExpire] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->miu_ccard_expire, tmpstr, szCCardExpire);
cdr_data->miu_ccard_expire[szCCardExpire] = '\0';
}
break;
case to_ccard_carrier:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->miu_ccard_carrier, ptr, szCCCarrier);
cdr_data->miu_ccard_carrier[szCCCarrier] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->miu_ccard_carrier, tmpstr, szCCCarrier);
cdr_data->miu_ccard_carrier[szCCCarrier] = '\0';
}
break;
case to_free_flag:
cdr_data->free_flag = j;
break;
case to_home_carrier_sid_bid:
cdr_data->home_carrier_sid_bid = j;
break;
case to_open_item_id:
cdr_data->open_item_id = j;
break;
case to_cell_name_origin:
if(gsField_Mapping[i].field_from_type != binary)
{
strncpy(cdr_data->cell_name_origin, ptr, szCellName);
cdr_data->cell_name_origin[szCellName] = '\0';
}
else
{
sprintf(tmpstr,"%d",j);
strncpy(cdr_data->cell_name_origin, tmpstr, szCellName);
cdr_data->cell_name_origin[szCellName] = '\0';
}
break;
}
}
if(new_timezone)
{
if(timezone_lookup(cdr_data->timezone,unix_tz,&isdst) != SUCCESS)
{
emit(ERRLOC, CAP_BAD_USG_TIMEZONE, cdr_data->timezone);
set_cdr_error_code(cdr_data, CAP_BAD_TIMEZONE);
sprintf(tmpstr,"%d,Timezone:%d",CAP_BAD_TIMEZONE,cdr_data->timezone);
emit(ERRLOC, MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
return(SUCCESS);
}
/* if we get a unix time do conversion
** from int to arbor/bp date format */
if(trans_dt_type == to_int || second_dt_type == to_int ||
rate_dt_type == to_int)
{
if(mpsGetGuideTZ() == TIMEZONE_NOT_USED)
{
/* convert to input usage record's timezone
** (already saved in cdr_data)
*/
strcpy(usage_tz, unix_tz);
}
else
{
/* Use guiding timezone instead.
** NOTE: in this case, the timezone from the usage record
** IS DISCARDED !!
*/
strcpy(usage_tz, mpsGetGuideTZstr());
cdr_data->timezone = mpsGetGuideTZ(); /* int version of mpsGetGuideTZstr() */
}
/* ----------------------------------------------------
** Convert trans_dt & second_dt to appropriate timezone
** since we are converting a unix time_t, the "from_tz" arg
** of convert_timezone (arg 3) is not used.
*/
if(trans_dt_type == to_int)
{
if(convert_timezone(cdr_data->trans_time, cdr_data->trans_dt, "GMT0", usage_tz)
== FAILURE)
{
emit(ERRLOC, CAP_BAD_USG_TIMEZONE, cdr_data->timezone);
set_cdr_error_code(cdr_data, CAP_BAD_TIMEZONE);
sprintf(tmpstr,
"%d,Timezone:%d",
CAP_BAD_TIMEZONE,cdr_data->timezone);
emit(ERRLOC, MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
return(SUCCESS);
}
}
if(second_dt_type == to_int)
{
if(convert_timezone(cdr_data->second_time, cdr_data->second_dt, "GMT0", usage_tz)
== FAILURE)
{
emit(ERRLOC, CAP_BAD_USG_TIMEZONE, cdr_data->timezone);
set_cdr_error_code(cdr_data, CAP_BAD_TIMEZONE);
sprintf(tmpstr,
"%d,Timezone:%d",
CAP_BAD_TIMEZONE,cdr_data->timezone);
emit(ERRLOC, MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
return(SUCCESS);
}
}
if(rate_dt_type == to_int)
{
if(convert_timezone(cdr_data->rate_time, cdr_data->rate_dt, "GMT0", usage_tz)
== FAILURE)
{
emit(ERRLOC, CAP_BAD_USG_TIMEZONE, cdr_data->timezone);
set_cdr_error_code(cdr_data, CAP_BAD_TIMEZONE);
sprintf(tmpstr,
"%d,Timezone:%d",
CAP_BAD_TIMEZONE,cdr_data->timezone);
emit(ERRLOC, MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
return(SUCCESS);
}
}
}
}
else
{
/* no timezone provided, get the default time zone later */
if(trans_dt_type == to_int || second_dt_type == to_int ||
rate_dt_type == to_int)
{
if(mpsGetGuideTZ() == TIMEZONE_NOT_USED)
{
/* no default set, do not know what to convert to, hard error */
emit(ERRLOC,CAP_NO_TIMEZONE);
sprintf(tmpstr,
"%d,No timezone",
CAP_NO_TIMEZONE);
emit(ERRLOC,MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
return(SUCCESS);
}
else
{
/* Use guiding timezone */
strcpy(usage_tz, mpsGetGuideTZstr());
cdr_data->timezone = mpsGetGuideTZ(); /* int version of mpsGetGuideTZstr() */
/* ----------------------------------------------------
** Convert trans_dt & second_dt to appropriate timezone
*/
if(trans_dt_type == to_int)
{
if(convert_timezone(cdr_data->trans_time, cdr_data->trans_dt,
"GMT0", usage_tz) == FAILURE)
{
emit(ERRLOC, CAP_BAD_USG_TIMEZONE, cdr_data->timezone);
set_cdr_error_code(cdr_data, CAP_BAD_TIMEZONE);
sprintf(tmpstr,
"%d,Timezone:%d",
CAP_BAD_TIMEZONE,cdr_data->timezone);
emit(ERRLOC,MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
return(SUCCESS);
}
}
if(second_dt_type == to_int)
{
if(convert_timezone(cdr_data->second_time, cdr_data->second_dt,
"GMT0", usage_tz) == FAILURE)
{
emit(ERRLOC, CAP_BAD_USG_TIMEZONE, cdr_data->timezone);
set_cdr_error_code(cdr_data, CAP_BAD_TIMEZONE);
sprintf(tmpstr,
"%d,Timezone:%d",
CAP_BAD_TIMEZONE,cdr_data->timezone);
emit(ERRLOC,MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
return(SUCCESS);
}
}
if(rate_dt_type == to_int)
{
if(convert_timezone(cdr_data->rate_time, cdr_data->rate_dt,
"GMT0", usage_tz) == FAILURE)
{
emit(ERRLOC, CAP_BAD_USG_TIMEZONE, cdr_data->timezone);
set_cdr_error_code(cdr_data, CAP_BAD_TIMEZONE);
sprintf(tmpstr,
"%d,Timezone:%d",
CAP_BAD_TIMEZONE,cdr_data->timezone);
emit(ERRLOC,MPS_GEN_ERROR, tmpstr );
set_mps_error_struct(tmpstr,"");
return(SUCCESS);
}
}
}
}
}
return(SUCCESS);
} /* ProcessUsgDetail() */
