// This is slightly more complex, because in the event of a
// SIZE ERROR. we need to leave the original value untouched
- unsigned char *stash = (unsigned char *)malloc(destination_s);
+ unsigned char *stash = static_cast<unsigned char *>(malloc(destination_s));
+ massert(stash);
memcpy(stash, destination->data+destination_o, destination_s);
__gg__int128_to_qualified_field(destination,
{
// This is slightly more complex, because in the event of a
// SIZE ERROR. we need to leave the original value untouched
- unsigned char *stash = (unsigned char *)malloc(destination_s);
+ assert(destination_s);
+ unsigned char *stash = static_cast<unsigned char *>(malloc(destination_s));
+ massert(stash);
memcpy(stash, destination->data+destination_o, destination_s);
__gg__float128_to_qualified_field(destination,
destination_o,
size_t,
size_t,
size_t,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **A = __gg__treeplet_1f;
- size_t *A_o = __gg__treeplet_1o;
- size_t *A_s = __gg__treeplet_1s;
- cblc_field_t **B = __gg__treeplet_2f;
- size_t *B_o = __gg__treeplet_2o;
- size_t *B_s = __gg__treeplet_2s;
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **A = __gg__treeplet_1f;
+ const size_t *A_o = __gg__treeplet_1o;
+ const size_t *A_s = __gg__treeplet_1s;
+ cblc_field_t **B = __gg__treeplet_2f;
+ const size_t *B_o = __gg__treeplet_2o;
+ const size_t *B_s = __gg__treeplet_2s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
GCOB_FP128 avalue = __gg__float128_from_qualified_field(A[0], A_o[0], A_s[0]);
GCOB_FP128 bvalue = __gg__float128_from_qualified_field(B[0], B_o[0], B_s[0]);
for(int i=0; i<4; i++)
{
uint128 temp = (uint128)product.i64[i] * multiplier;
- product.i64[i] = *(uint64_t *)(&temp);
- overflows[i+1] = *(uint64_t *)((uint8_t *)(&temp) + 8);
+ product.i64[i] = *PTRCAST(uint64_t, &temp);
+ overflows[i+1] = *PTRCAST(uint64_t, PTRCAST(uint8_t, &temp) + 8);
}
for(int i=1; i<4; i++)
}
static int
-add_int256_to_int256(int256 &sum, const int256 addend)
+add_int256_to_int256(int256 &sum, const int256 &addend)
{
uint128 overflows[3] = {};
for(int i=0; i<2; i++)
for( int i=3; i>=0; i-- )
{
// Left shift temp 64 bits:
- *(uint64_t *)(((uint8_t *)&temp)+8) = *(uint64_t *)(((uint8_t *)&temp)+0);
+ *PTRCAST(uint64_t, ((PTRCAST(uint8_t, &temp))+8))
+ = *PTRCAST(uint64_t, ((PTRCAST(uint8_t, &temp))+0));
// Put the high digit of val into the bottom of temp
- *(uint64_t *)(((uint8_t *)&temp)+0) = val.i64[i];
+ *PTRCAST(uint64_t, ((PTRCAST(uint8_t, &temp))+0)) = val.i64[i];
// Divide that combinary by divisor to get the new digits
val.i64[i] = temp / divisor;
{
int overflow = 0;
// It has been decreed that at this juncture the result must fit into
- // MAX_FIXED_POINT_DIGITS. If the result does not, we have an OVERFLOW error.
+ // MAX_FIXED_POINT_DIGITS. If the result does not, we have an OVERFLOW
+ // error.
int is_negative = val.data[31] & 0x80;
if( is_negative )
negate_int256(val);
}
- // As long as there are some decimal places left, we hold our nose and right-
- // shift a too-large value rightward by decimal digits. In other words, we
- // truncate the fractional part to make room for the integer part:
+ // As long as there are some decimal places left, we hold our nose and
+ // right-shift a too-large value rightward by decimal digits. In other
+ // words, we truncate the fractional part to make room for the integer part:
while(rdigits > 0 && val.i128[1] )
{
divide_int256_by_int64(val, 10UL);
// These sixteen bytes comprise the binary value of 10^38
static const uint8_t C1038[] = {0x00, 0x00, 0x00, 0x00, 0x40, 0x22, 0x8a, 0x09,
0x7a, 0xc4, 0x86, 0x5a, 0xa8, 0x4c, 0x3b, 0x4b};
- static const uint128 biggest = *(uint128 *)C1038;
+ static const uint128 biggest = *reinterpret_cast<const uint128 *>(C1038);
// If we still have some rdigits to throw away, we can keep shrinking
// the value:
static void
get_int256_from_qualified_field(int256 &var,
int &rdigits,
- cblc_field_t *field,
+ const cblc_field_t *field,
size_t field_o,
size_t field_s)
{
size_t nA,
size_t ,
size_t ,
- cbl_round_t *,
+ const cbl_round_t *,
int ,
int *compute_error
)
// The result goes into the temporary phase1_result.
- cblc_field_t **A = __gg__treeplet_1f;
- size_t *A_o = __gg__treeplet_1o;
- size_t *A_s = __gg__treeplet_1s;
+ cblc_field_t **A = __gg__treeplet_1f;
+ const size_t *A_o = __gg__treeplet_1o;
+ const size_t *A_s = __gg__treeplet_1s;
// Let us prime the pump with the first value of A[]
get_int256_from_qualified_field(phase1_result, phase1_rdigits, A[0], A_o[0], A_s[0]);
if( phase1_rdigits > temp_rdigits )
{
scale_int256_by_digits(temp, phase1_rdigits - temp_rdigits);
- temp_rdigits = phase1_rdigits;
}
else if( phase1_rdigits < temp_rdigits )
{
size_t ,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
// This is the assignment phase of an ADD Format 1
if( rdigits_a > rdigits_b )
{
scale_int256_by_digits(value_b, rdigits_a - rdigits_b);
- rdigits_b = rdigits_a;
}
else if( rdigits_a < rdigits_b )
{
size_t ,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
// This is the assignment phase of an ADD Format 2
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
// We take phase1_result and put it into C
size_t nA,
size_t ,
size_t ,
- cbl_round_t *,
+ const cbl_round_t *,
int ,
int *compute_error
)
// The result goes into the temporary phase1_result_ffloat.
- cblc_field_t **A = __gg__treeplet_1f;
- size_t *A_o = __gg__treeplet_1o;
- size_t *A_s = __gg__treeplet_1s;
+ cblc_field_t **A = __gg__treeplet_1f;
+ const size_t *A_o = __gg__treeplet_1o;
+ const size_t *A_s = __gg__treeplet_1s;
// Let us prime the pump with the first value of A[]
phase1_result_float = __gg__float128_from_qualified_field(A[0], A_o[0], A_s[0]);
size_t ,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
// This is the assignment phase of an ADD Format 2
size_t ,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
// This is the assignment phase of an ADD Format 2
size_t nA,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
// This is an ADD Format 3. Each A[i] gets accumulated into each C[i]. When
// both are fixed, we do fixed arithmetic. When either is a FldFloat, we
// do floating-point arithmetic.
- cblc_field_t **A = __gg__treeplet_1f;
- size_t *A_o = __gg__treeplet_1o;
- size_t *A_s = __gg__treeplet_1s;
+ cblc_field_t **A = __gg__treeplet_1f;
+ const size_t *A_o = __gg__treeplet_1o;
+ const size_t *A_s = __gg__treeplet_1s;
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
if( rdigits_a > rdigits_b )
{
scale_int256_by_digits(value_b, rdigits_a - rdigits_b);
- rdigits_b = rdigits_a;
}
else if( rdigits_a < rdigits_b )
{
size_t ,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
// This is the assignment phase of an ADD Format 1
else if( rdigits_a < rdigits_b )
{
scale_int256_by_digits(value_a, rdigits_b - rdigits_a);
- rdigits_a = rdigits_b;
}
// The two numbers have the same number of rdigits. It's now safe to add
size_t nA,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
// This is the calculation phase of a fixed-point SUBTRACT Format 2
- cblc_field_t **B = __gg__treeplet_2f;
- size_t *B_o = __gg__treeplet_2o;
- size_t *B_s = __gg__treeplet_2s;
+ cblc_field_t **B = __gg__treeplet_2f;
+ const size_t *B_o = __gg__treeplet_2o;
+ const size_t *B_s = __gg__treeplet_2s;
// Add up all the A values
__gg__add_fixed_phase1( not_expected_e ,
else if( rdigits_a < rdigits_b )
{
scale_int256_by_digits(value_a, rdigits_b - rdigits_a);
- rdigits_a = rdigits_b;
}
// The two numbers have the same number of rdigits. It's now safe to add
phase1_rdigits = rdigits_b;
}
-
extern "C"
void
__gg__subtractf1_float_phase2(cbl_arith_format_t ,
size_t ,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
// This is the assignment phase of an ADD Format 2
*rounded++);
}
-
extern "C"
void
__gg__subtractf2_float_phase1(cbl_arith_format_t ,
size_t nA,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
// This is the calculation phase of a fixed-point SUBTRACT Format 2
- cblc_field_t **B = __gg__treeplet_2f;
- size_t *B_o = __gg__treeplet_2o;
- size_t *B_s = __gg__treeplet_2s;
+ cblc_field_t **B = __gg__treeplet_2f;
+ const size_t *B_o = __gg__treeplet_2o;
+ const size_t *B_s = __gg__treeplet_2s;
// Add up all the A values
__gg__add_float_phase1( not_expected_e ,
size_t nA,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
// This is an ADD Format 3. Each A[i] gets accumulated into each C[i]. Each
// SUBTRACTION is treated separately.
- cblc_field_t **A = __gg__treeplet_1f;
- size_t *A_o = __gg__treeplet_1o;
- size_t *A_s = __gg__treeplet_1s;
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **A = __gg__treeplet_1f;
+ const size_t *A_o = __gg__treeplet_1o;
+ const size_t *A_s = __gg__treeplet_1s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
else if( rdigits_a < rdigits_b )
{
scale_int256_by_digits(value_a, rdigits_b - rdigits_a);
- rdigits_a = rdigits_b;
}
// The two numbers have the same number of rdigits. It's now safe to add
size_t ,
size_t ,
size_t ,
- cbl_round_t *,
+ const cbl_round_t *,
int ,
int *)
{
// We are getting just the one value, which we are converting to the necessary
// intermediate form
- cblc_field_t **A = __gg__treeplet_1f;
- size_t *A_o = __gg__treeplet_1o;
- size_t *A_s = __gg__treeplet_1s;
+ cblc_field_t **A = __gg__treeplet_1f;
+ const size_t *A_o = __gg__treeplet_1o;
+ const size_t *A_s = __gg__treeplet_1s;
if( A[0]->type == FldFloat )
{
__int128 ab_value,
__int128 cd_value)
{
- int is_negative = ( ((uint8_t *)(&ab_value))[15]^((uint8_t *)(&cd_value))[15]) & 0x80;
+ int is_negative = ( (PTRCAST(uint8_t, (&ab_value)))[15]
+ ^(PTRCAST(uint8_t, (&cd_value)))[15]) & 0x80;
if( ab_value < 0 )
{
ab_value = -ab_value;
uint128 BD;
// Let's extract the digits.
- uint64_t a = *(uint64_t *)((unsigned char *)(&ab_value)+8);
- uint64_t b = *(uint64_t *)((unsigned char *)(&ab_value)+0);
- uint64_t c = *(uint64_t *)((unsigned char *)(&cd_value)+8);
- uint64_t d = *(uint64_t *)((unsigned char *)(&cd_value)+0);
+ uint64_t a = *PTRCAST(uint64_t, (PTRCAST(unsigned char, (&ab_value))+8));
+ uint64_t b = *PTRCAST(uint64_t, (PTRCAST(unsigned char, (&ab_value))+0));
+ uint64_t c = *PTRCAST(uint64_t, (PTRCAST(unsigned char, (&cd_value))+8));
+ uint64_t d = *PTRCAST(uint64_t, (PTRCAST(unsigned char, (&cd_value))+0));
// multiply (a0 + b) * (c0 + d)
size_t ,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
int error_this_time=0;
if( error_this_time && on_size_error)
{
*compute_error |= error_this_time;
- rounded++;
}
else
{
*compute_error |= conditional_stash(C[0], C_o[0], C_s[0],
on_size_error,
a_value,
- *rounded++);
+ *rounded);
}
done:
return;
size_t ,
size_t ,
size_t nC,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **A = __gg__treeplet_1f;
- size_t *A_o = __gg__treeplet_1o;
- size_t *A_s = __gg__treeplet_1s;
- cblc_field_t **B = __gg__treeplet_2f;
- size_t *B_o = __gg__treeplet_2o;
- size_t *B_s = __gg__treeplet_2s;
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **A = __gg__treeplet_1f;
+ const size_t *A_o = __gg__treeplet_1o;
+ const size_t *A_s = __gg__treeplet_1s;
+ cblc_field_t **B = __gg__treeplet_2f;
+ const size_t *B_o = __gg__treeplet_2o;
+ const size_t *B_s = __gg__treeplet_2s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
uint128 temp;
uint128 overflow = 0;
- uint128 *as128 = (uint128 *)buf;
+ uint128 *as128 = PTRCAST(uint128, buf);
for( size_t i=0; i<places; i++ )
{
}
// We are going to be referencing the 64-bit pices of the 128-bit divisor:
- uint64_t *divisor64 = (uint64_t *)&divisor;
+ uint64_t *divisor64 = PTRCAST(uint64_t, &divisor);
quotient.i128[1] = 0;
quotient.i128[0] = dividend;
int bits_to_shift = 0;
int i=15;
- while( ((uint8_t *)(&divisor))[i] == 0 )
+ while( (PTRCAST(uint8_t, &divisor))[i] == 0 )
{
i -= 1;
bits_to_shift += 8;
- }
- uint8_t tail = ((uint8_t *)(&divisor))[i];
+ } uint8_t tail = ( PTRCAST(uint8_t, &divisor) )[i];
while( !(tail & 0x80) )
{
bits_to_shift += 1;
// Shift both the numerator and the divisor that number of bits
- shift_in_place128((uint8_t *)&numerator, sizeof(numerator), bits_to_shift);
- shift_in_place128((uint8_t *)&divisor, sizeof(divisor), bits_to_shift);
-
+ shift_in_place128( PTRCAST(uint8_t, &numerator), sizeof(numerator), bits_to_shift);
+ shift_in_place128( PTRCAST(uint8_t, &divisor), sizeof(divisor), bits_to_shift);
// We are now ready to do the guess-multiply-subtract loop. We know that
// the result will have two places, so we know we are going to go through
// We develop our guess for a quotient by dividing the top two places of
// the numerator area by C
uint128 temp;
- uint64_t *temp64 = (uint64_t *)&temp;
+ uint64_t *temp64 = PTRCAST(uint64_t, &temp);
temp64[1] = numerator.i64[q_place+2];
temp64[0] = numerator.i64[q_place+1];
subber[2] = 0;
// Start with the bottom 128 bits of the "subber"
- *(uint128 *)subber = (uint128) divisor64[0] * quotient.i64[q_place];
+ *PTRCAST(uint128, subber) = (uint128) divisor64[0] * quotient.i64[q_place];
// Get the next 128 bits of subber
- temp = (uint128) divisor64[1] * quotient.i64[q_place];
+ temp = (uint128) divisor64[1] * quotient.i64[q_place];
// Add the top of the first product to the bottom of the second:
subber[1] += temp64[0];
// the numerator:
uint64_t borrow = 0;
- for(size_t i=0; i<3; i++)
+ for(size_t j=0; j<3; j++)
{
- if( numerator.i64[q_place + i] == 0 && borrow )
+ if( numerator.i64[q_place + j] == 0 && borrow )
{
// We are subtracting from zero and we have a borrow. Leave the
// borrow on and just do the subtraction:
- numerator.i64[q_place + i] -= subber[i];
+ numerator.i64[q_place + j] -= subber[j];
}
else
{
- uint64_t stash = numerator.i64[q_place + i];
- numerator.i64[q_place + i] -= borrow;
- numerator.i64[q_place + i] -= subber[i];
- if( numerator.i64[q_place + i] > stash )
+ uint64_t stash = numerator.i64[q_place + j];
+ numerator.i64[q_place + j] -= borrow;
+ numerator.i64[q_place + j] -= subber[j];
+ if( numerator.i64[q_place + j] > stash )
{
// After subtracting, the value got bigger, which means we have
// to borrow from the next value to the left
{
// We need to add subber back into the numerator area
uint64_t carry = 0;
- for(size_t i=0; i<3; i++)
+ for(size_t ii=0; ii<3; ii++)
{
- if( numerator.i64[q_place + i] == 0xFFFFFFFFFFFFFFFFUL && carry )
+ if( numerator.i64[q_place + ii] == 0xFFFFFFFFFFFFFFFFUL && carry )
{
// We are at the top and have a carry. Just leave the carry on
// and do the addition:
- numerator.i64[q_place + i] += subber[i];
+ numerator.i64[q_place + ii] += subber[ii];
}
else
{
// We are not at the top.
- uint64_t stash = numerator.i64[q_place + i];
- numerator.i64[q_place + i] += carry;
- numerator.i64[q_place + i] += subber[i];
- if( numerator.i64[q_place + i] < stash )
+ uint64_t stash = numerator.i64[q_place + ii];
+ numerator.i64[q_place + ii] += carry;
+ numerator.i64[q_place + ii] += subber[ii];
+ if( numerator.i64[q_place + ii] < stash )
{
// The addition caused the result to get smaller, meaning that
// we wrapped around:
size_t ,
size_t ,
size_t ,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
int error_this_time=0;
if( error_this_time && on_size_error)
{
- rounded++;
}
else
{
*compute_error |= conditional_stash(C[0], C_o[0], C_s[0],
on_size_error,
b_value,
- *rounded++);
+ *rounded);
}
done:
return;
size_t ,
size_t ,
size_t nC,
- cbl_round_t *rounded,
+ const cbl_round_t *rounded,
int on_error_flag,
int *compute_error
)
{
- cblc_field_t **A = __gg__treeplet_1f;
- size_t *A_o = __gg__treeplet_1o;
- size_t *A_s = __gg__treeplet_1s;
- cblc_field_t **B = __gg__treeplet_2f;
- size_t *B_o = __gg__treeplet_2o;
- size_t *B_s = __gg__treeplet_2s;
- cblc_field_t **C = __gg__treeplet_3f;
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **A = __gg__treeplet_1f;
+ const size_t *A_o = __gg__treeplet_1o;
+ const size_t *A_s = __gg__treeplet_1s;
+ cblc_field_t **B = __gg__treeplet_2f;
+ const size_t *B_o = __gg__treeplet_2o;
+ const size_t *B_s = __gg__treeplet_2s;
+ cblc_field_t **C = __gg__treeplet_3f;
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
int error_this_time=0;
int *compute_error
)
{
- cblc_field_t **A = __gg__treeplet_1f; // Numerator
- size_t *A_o = __gg__treeplet_1o;
- size_t *A_s = __gg__treeplet_1s;
- cblc_field_t **B = __gg__treeplet_2f; // Denominator
- size_t *B_o = __gg__treeplet_2o;
- size_t *B_s = __gg__treeplet_2s;
- cblc_field_t **C = __gg__treeplet_3f; // Has remainder, then quotient
- size_t *C_o = __gg__treeplet_3o;
- size_t *C_s = __gg__treeplet_3s;
+ cblc_field_t **A = __gg__treeplet_1f; // Numerator
+ const size_t *A_o = __gg__treeplet_1o;
+ const size_t *A_s = __gg__treeplet_1s;
+ cblc_field_t **B = __gg__treeplet_2f; // Denominator
+ const size_t *B_o = __gg__treeplet_2o;
+ const size_t *B_s = __gg__treeplet_2s;
+ cblc_field_t **C = __gg__treeplet_3f; // Has remainder, then quotient
+ const size_t *C_o = __gg__treeplet_3o;
+ const size_t *C_s = __gg__treeplet_3s;
bool on_size_error = !!(on_error_flag & ON_SIZE_ERROR);
int error_this_time=0;
nsubscript = N;
if(N)
{
- subscript_alls = (bool *) malloc(nsubscript);
- subscripts = (size_t *)malloc(nsubscript);
- subscript_limits = (size_t *)malloc(nsubscript);
+ subscript_alls = static_cast<bool *>(malloc(nsubscript));
+ subscripts = static_cast<size_t *>(malloc(nsubscript));
+ subscript_limits = static_cast<size_t *>(malloc(nsubscript));
+ massert(subscript_alls);
+ massert(subscripts);
+ massert(subscript_limits);
}
done = false;
}
static
double
-get_value_as_double_from_qualified_field( cblc_field_t *input,
+get_value_as_double_from_qualified_field( const cblc_field_t *input,
size_t input_o,
size_t input_s)
{
static
GCOB_FP128 kahan_summation(size_t ncount,
cblc_field_t **source,
- size_t *source_o,
- size_t *source_s,
- int *flags,
+ const size_t *source_o,
+ const size_t *source_s,
+ const int *flags,
size_t *k_count)
{
// We use compensated addition. Look up Kahan summation.
GCOB_FP128
variance( size_t ncount,
cblc_field_t **source,
- size_t *source_o,
- size_t *source_s,
- int *flags)
+ const size_t *source_o,
+ const size_t *source_s,
+ const int *flags)
{
// In order to avoid catastrophic cancellation, we are going to use an
// algorithm that is a bit wasteful of time, but is described as particularly
// days of January show up in the final week of the prior year.
sprintf(stime,
- "%4.4u%2.2u%2.2uT" // YYYYMMSS
- "%2.2u%2.2u%2.2u" // hhmmss
- ".%9.9u" // .sssssssss
- "%c%2.2u%2.2u" // +hhmm
- "W%2.2u" // Www
- "%1u" // DOW [1-7], 1 for Monday
- "%3.3u" // DDD day of year, 001 - 365,366
- "%4.4u", // ZZZZ Year for YYYY-Www-D
+ "%4.4d%2.2d%2.2dT" // YYYYMMSS
+ "%2.2d%2.2d%2.2d" // hhmmss
+ ".%9.9d" // .sssssssss
+ "%c%2.2d%2.2d" // +hhmm
+ "W%2.2d" // Www
+ "%1d" // DOW [1-7], 1 for Monday
+ "%3.3d" // DDD day of year, 001 - 365,366
+ "%4.4d", // ZZZZ Year for YYYY-Www-D
ctm.YYYY,
ctm.MM,
ctm.DD,
static
void
populate_ctm_from_date( struct cobol_tm &ctm,
- cblc_field_t *pdate,
+ const cblc_field_t *pdate,
size_t pdate_offset,
size_t pdate_size)
{
static
void
populate_ctm_from_time( struct cobol_tm &ctm,
- cblc_field_t *ptime,
+ const cblc_field_t *ptime,
size_t ptime_o,
size_t ptime_s,
- cblc_field_t *poffset,
+ const cblc_field_t *poffset,
size_t poffset_o,
size_t poffset_s)
{
static
void
-ftime_replace(char *dest, char const * const dest_end,
- char const *source, char const * const source_end,
+ftime_replace(char *dest,
+ char const * const dest_end,
+ char const * source,
+ char const * const source_end,
char const * const ftime)
{
// This routine is highly dependent on the source format being correct.
extern "C"
void
__gg__abs(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__acos( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__annuity(cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_offset,
size_t arg1_size,
- cblc_field_t *arg2,
+ const cblc_field_t *arg2,
size_t arg2_offset,
size_t arg2_size)
{
extern "C"
void
__gg__asin( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__atan( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__byte_length(cblc_field_t *dest,
- cblc_field_t */*source*/,
+ const cblc_field_t */*source*/,
size_t /*source_offset*/,
size_t source_size)
{
extern "C"
void
__gg__char( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__combined_datetime(cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_offset,
size_t arg1_size,
- cblc_field_t *arg2,
+ const cblc_field_t *arg2,
size_t arg2_offset,
size_t arg2_size)
{
extern "C"
void
__gg__cos(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__date_of_integer(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__date_to_yyyymmdd( cblc_field_t *dest,
- cblc_field_t *par1,
+ const cblc_field_t *par1,
size_t par1_o,
size_t par1_s,
- cblc_field_t *par2,
+ const cblc_field_t *par2,
size_t par2_o,
size_t par2_s,
- cblc_field_t *par3,
+ const cblc_field_t *par3,
size_t par3_o,
size_t par3_s)
{
extern "C"
void
__gg__day_of_integer( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__day_to_yyyyddd( cblc_field_t *dest,
- cblc_field_t *par1,
+ const cblc_field_t *par1,
size_t par1_o,
size_t par1_s,
- cblc_field_t *par2,
+ const cblc_field_t *par2,
size_t par2_o,
size_t par2_s,
- cblc_field_t *par3,
+ const cblc_field_t *par3,
size_t par3_o,
size_t par3_s)
{
extern "C"
void
__gg__exp(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__exp10(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__factorial(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__formatted_current_date( cblc_field_t *dest, // Destination string
- cblc_field_t *input, // datetime format
+ const cblc_field_t *input, // datetime format
size_t input_offset,
size_t input_size)
{
// FUNCTION CURRENT-DATE
// Establish the destination, and set it to spaces
- char *d = (char *)dest->data;
- char *dend = d + dest->capacity;
+ char *d = PTRCAST(char, dest->data);
+ const char *dend = d + dest->capacity;
memset(d, internal_space, dest->capacity);
// Establish the formatting string:
- char *format = (char *)(input->data+input_offset);
- char *format_end = format + input_size;
+ const char *format = PTRCAST(char, (input->data+input_offset));
+ const char *format_end = format + input_size;
bool is_zulu = false;
- char *p = format;
+ const char *p = format;
while( p < format_end )
{
int ch = *p++;
extern "C"
void
__gg__formatted_date(cblc_field_t *dest, // Destination string
- cblc_field_t *arg1, // datetime format
+ const cblc_field_t *arg1, // datetime format
size_t arg1_offset,
size_t arg1_size,
- cblc_field_t *arg2, // integer date
+ const cblc_field_t *arg2, // integer date
size_t arg2_offset,
size_t arg2_size)
{
// FUNCTION FORMATTED-DATE
// Establish the destination, and set it to spaces
- char *d = (char *)dest->data;
- char *dend = d + dest->capacity;
+ char *d = PTRCAST(char, dest->data);
+ const char *dend = d + dest->capacity;
memset(d, internal_space, dest->capacity);
// Establish the formatting string:
- char *format = (char *)(arg1->data+arg1_offset);
- char *format_end = format + arg1_size;
+ char *format = PTRCAST(char, (arg1->data+arg1_offset));
+ const char *format_end = format + arg1_size;
struct cobol_tm ctm = {};
extern "C"
void
__gg__formatted_datetime( cblc_field_t *dest, // Destination string
- cblc_field_t *par1, // datetime format
+ const cblc_field_t *par1, // datetime format
size_t par1_o,
size_t par1_s,
- cblc_field_t *par2, // integer date
+ const cblc_field_t *par2, // integer date
size_t par2_o,
size_t par2_s,
- cblc_field_t *par3, // numeric time
+ const cblc_field_t *par3, // numeric time
size_t par3_o,
size_t par3_s,
- cblc_field_t *par4, // optional offset in seconds
+ const cblc_field_t *par4, // optional offset in seconds
size_t par4_o,
size_t par4_s
)
// FUNCTION FORMATTED-DATETIME
// Establish the destination, and set it to spaces
- char *d = (char *)dest->data;
- char *dend = d + dest->capacity;
+ char *d = PTRCAST(char, (dest->data));
+ const char *dend = d + dest->capacity;
memset(d, internal_space, dest->capacity);
// Establish the formatting string:
- char *format = (char *)(par1->data+par1_o);
+ char *format = PTRCAST(char, (par1->data+par1_o));
char *format_end = format + par1_s;
trim_trailing_spaces(format, format_end);
bool is_zulu = is_zulu_format(format, format_end);
extern "C"
void
__gg__formatted_time( cblc_field_t *dest,// Destination string
- cblc_field_t *par1, // datetime format
+ const cblc_field_t *par1, // datetime format
size_t par1_o,
size_t par1_s,
- cblc_field_t *par2,// numeric time
+ const cblc_field_t *par2,// numeric time
size_t par2_o,
size_t par2_s,
- cblc_field_t *par4, // optional offset in seconds
+ const cblc_field_t *par4, // optional offset in seconds
size_t par4_o,
size_t par4_s)
// FUNCTION FORMATTED-TIME
// Establish the destination, and set it to spaces
- char *d = (char *)dest->data;
- char *dend = d + dest->capacity;
+ char *d = PTRCAST(char, dest->data);
+ const char *dend = d + dest->capacity;
memset(d, internal_space, dest->capacity);
// Establish the formatting string:
- char *format = (char *)(par1->data+par1_o);
+ char *format = PTRCAST(char, (par1->data+par1_o));
char *format_end = format + par1_s;
trim_trailing_spaces(format, format_end);
bool is_zulu = is_zulu_format(format, format_end);
extern "C"
void
__gg__integer(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__integer_of_date(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__integer_of_day( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__integer_part( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__fraction_part(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
-__gg__log( cblc_field_t *dest,
- cblc_field_t *source,
- size_t source_offset,
- size_t source_size)
+__gg__log(cblc_field_t *dest,
+ const cblc_field_t *source,
+ size_t source_offset,
+ size_t source_size)
{
// FUNCTION LOG
GCOB_FP128 value = __gg__float128_from_qualified_field(source,
extern "C"
void
-__gg__log10( cblc_field_t *dest,
- cblc_field_t *source,
- size_t source_offset,
- size_t source_size)
+__gg__log10(cblc_field_t *dest,
+ const cblc_field_t *source,
+ size_t source_offset,
+ size_t source_size)
{
// FUNCTION LOG10
GCOB_FP128 value = __gg__float128_from_qualified_field(source,
|| __gg__treeplet_1f[0]->type == FldLiteralA) )
{
cblc_field_t *best_field ;
- unsigned char *best_location ;
- size_t best_length ;
+ unsigned char *best_location = nullptr ;
+ size_t best_length = 0 ;
int best_attr ;
int best_flags ;
}
}
+
__gg__adjust_dest_size(dest, best_length);
dest->type = FldAlphanumeric;
+ assert(best_location);
memcpy(dest->data, best_location, best_length);
}
else
extern "C"
void
__gg__lower_case( cblc_field_t *dest,
- cblc_field_t *input,
+ const cblc_field_t *input,
size_t input_offset,
size_t input_size)
{
size_t source_length = input_size;
memset(dest->data, internal_space, dest_length);
memcpy(dest->data, input->data+input_offset, std::min(dest_length, source_length));
- internal_to_ascii((char *)dest->data, dest_length);
+ internal_to_ascii( PTRCAST(char, dest->data), dest_length);
std::transform(dest->data, dest->data + dest_length, dest->data,
[](unsigned char c) { return std::tolower(c); });
- ascii_to_internal_str((char *)dest->data, dest_length);
+ ascii_to_internal_str( PTRCAST(char, dest->data), dest_length);
}
extern "C"
size_t list_size = 1;
- GCOB_FP128 *the_list = (GCOB_FP128 *)malloc(list_size *sizeof(GCOB_FP128));
+ GCOB_FP128 *the_list = static_cast<GCOB_FP128 *>(malloc(list_size *sizeof(GCOB_FP128)));
+ massert(the_list);
size_t k_count = 0;
assert(ncount);
for(size_t i=0; i<ncount; i++)
if(k_count >= list_size)
{
list_size *= 2;
- the_list = (GCOB_FP128 *)realloc(the_list, list_size *sizeof(GCOB_FP128));
+ the_list = PTRCAST(GCOB_FP128, realloc(the_list, list_size *sizeof(GCOB_FP128)));
+ massert(the_list);
}
+ assert(the_list);
the_list[k_count] = __gg__float128_from_qualified_field(__gg__treeplet_1f[i],
__gg__treeplet_1o[i],
__gg__treeplet_1s[i]);
if( ( __gg__treeplet_1f[0]->type == FldAlphanumeric
|| __gg__treeplet_1f[0]->type == FldLiteralA) )
{
- cblc_field_t *best_field ;
- unsigned char *best_location ;
- size_t best_length ;
- int best_attr ;
- int best_flags ;
+ cblc_field_t *best_field ;
+ unsigned char *best_location = nullptr ;
+ size_t best_length = 0 ;
+ int best_attr ;
+ int best_flags ;
bool first_time = true;
assert(ncount);
__gg__adjust_dest_size(dest, best_length);
dest->type = FldAlphanumeric;
+ assert(best_location);
memcpy(dest->data, best_location, best_length);
}
else
static int
numval( cblc_field_t *dest,
- cblc_field_t *input,
+ const cblc_field_t *input,
size_t input_offset,
size_t input_size)
{
// Returns the one-based character position of a bad character
// returns zero if it is okay
- char *p = (char *)(input->data + input_offset);
- char *pend = p + input_size;
+ const char *p = PTRCAST(char, (input->data + input_offset));
+ const char *pend = p + input_size;
int errpos = 0;
__int128 retval = 0;
static
int
numval_c( cblc_field_t *dest,
- cblc_field_t *src,
+ const cblc_field_t *src,
size_t src_offset,
size_t src_size,
- cblc_field_t *crcy,
+ const cblc_field_t *crcy,
size_t crcy_offset,
size_t crcy_size
)
{
size_t errcode = 0;
- char *pstart = (char *)(src->data+src_offset);
+ char *pstart = PTRCAST(char, (src->data+src_offset));
char *pend = pstart + src_size;
char *p = pstart;
char *currency_end;
if( crcy )
{
- currency_start = (char *)(crcy->data+crcy_offset);
+ currency_start = PTRCAST(char, (crcy->data+crcy_offset));
currency_end = currency_start + crcy_size;
}
else
if( sign )
{
// A second sign isn't allowed
- state = final_space;
errcode = p - pstart;
p = pend;
}
extern "C"
void
__gg__numval( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__test_numval(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__numval_c( cblc_field_t *dest,
- cblc_field_t *src,
+ const cblc_field_t *src,
size_t src_offset,
size_t src_size,
- cblc_field_t *crcy,
+ const cblc_field_t *crcy,
size_t crcy_offset,
size_t crcy_size
)
extern "C"
void
__gg__test_numval_c(cblc_field_t *dest,
- cblc_field_t *src,
+ const cblc_field_t *src,
size_t src_offset,
size_t src_size,
- cblc_field_t *crcy,
+ const cblc_field_t *crcy,
size_t crcy_offset,
size_t crcy_size
)
extern "C"
void
__gg__ord(cblc_field_t *dest,
- cblc_field_t *input,
+ const cblc_field_t *input,
size_t input_offset,
size_t /*input_size*/)
{
// We get our input in internal_character form.
- char *arg = (char *)(input->data + input_offset);
+ const char *arg = PTRCAST(char, (input->data + input_offset));
// The ORD function takes a single-character string and returns the
// ordinal position of that character.
extern "C"
void
__gg__rem(cblc_field_t *dest,
- cblc_field_t *par1,
+ const cblc_field_t *par1,
size_t par1_offset,
size_t par1_size,
- cblc_field_t *par2,
+ const cblc_field_t *par2,
size_t par2_offset,
size_t par2_size)
{
extern "C"
void
__gg__trim( cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_offset,
size_t arg1_size,
- cblc_field_t *arg2,
+ const cblc_field_t *arg2,
size_t arg2_offset,
size_t arg2_size)
{
// No matter what, we want to find the leftmost non-space and the
// rightmost non-space:
- char *left = (char *)(arg1->data+arg1_offset);
+ char *left = PTRCAST(char, (arg1->data+arg1_offset));
char *right = left + arg1_size-1;
// Find left and right: the first and last non-spaces
{
// We want to leave any trailing spaces, so we return 'right' to its
// original value:
- right = (char *)(arg1->data+arg1_offset) + arg1_size-1;
+ right = PTRCAST(char, (arg1->data+arg1_offset)) + arg1_size-1;
}
else if( type == TRAILING )
{
// We want to leave any leading spaces, so we return 'left' to its
// original value:
- left = (char *)(arg1->data+arg1_offset);
+ left = PTRCAST(char, (arg1->data+arg1_offset));
}
if( left > right )
// compiler believes the capacity to be at compile-time. But we obviously
// think it'll be okay.
- char *dest_left = (char *)dest->data;
+ char *dest_left = PTRCAST(char, dest->data);
char *dest_right = dest_left + dest->capacity - 1;
- char *dest_end = dest_left + dest->capacity;
+ const char *dest_end = dest_left + dest->capacity;
while( dest_left <= dest_right && left <= right )
{
extern "C"
void
__gg__random( cblc_field_t *dest,
- cblc_field_t *input,
+ const cblc_field_t *input,
size_t input_offset,
size_t input_size)
{
extern "C"
void
__gg__reverse(cblc_field_t *dest,
- cblc_field_t *input,
+ const cblc_field_t *input,
size_t input_offset,
size_t input_size)
{
extern "C"
void
__gg__sign( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__sin(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__sqrt( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__tan(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__test_date_yyyymmdd( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
source_offset,
source_size);
int retval;
- int dd = yyyymmdd % 100;
int mmdd = yyyymmdd % 10000;
int mm = mmdd / 100;
- int yyyy = yyyymmdd / 10000;
- int jy;
- int jm;
- int jd;
- double JD;
if( yyyymmdd < 16010000 || yyyymmdd > 99999999 )
{
retval = 1;
}
else
{
+ int dd = yyyymmdd % 100;
+ int yyyy = yyyymmdd / 10000;
+ int jy;
+ int jm;
+ int jd;
+ double JD;
+
// If there is something wrong with the number of days per month for a
// given year, the Julian Date conversion won't reverse properly.
// For example, January 32 will come back as February 1
extern "C"
void
__gg__test_day_yyyyddd( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
extern "C"
void
__gg__upper_case( cblc_field_t *dest,
- cblc_field_t *input,
+ const cblc_field_t *input,
size_t input_offset,
size_t input_size)
{
size_t source_length = input_size;
memset(dest->data, internal_space, dest_length);
memcpy(dest->data, input->data+input_offset, std::min(dest_length, source_length));
- internal_to_ascii((char *)dest->data, dest_length);
+ internal_to_ascii( PTRCAST(char, dest->data), dest_length);
std::transform(dest->data, dest->data + dest_length, dest->data,
[](unsigned char c) { return std::toupper(c); });
- ascii_to_internal_str((char *)dest->data, dest_length);
+ ascii_to_internal_str( PTRCAST(char, dest->data), dest_length);
}
extern "C"
extern "C"
void
__gg__year_to_yyyy( cblc_field_t *dest,
- cblc_field_t *par1,
+ const cblc_field_t *par1,
size_t par1_o,
size_t par1_s,
- cblc_field_t *par2,
+ const cblc_field_t *par2,
size_t par2_o,
size_t par2_s,
- cblc_field_t *par3,
+ const cblc_field_t *par3,
size_t par3_o,
size_t par3_s)
{
static
int
-gets_int(int ndigits, char *p, char *pend, int *digits)
+gets_int(int ndigits, const char *p, const char *pend, int *digits)
{
// This routine returns the value of the integer at p. If there is something
// wrong with the integer, it returns a negative number, the value being the
static
int
-gets_year(char *p, char *pend, struct cobol_tm &ctm)
+gets_year(const char *p, const char *pend, struct cobol_tm &ctm)
{
// Populates ctm.YYYY, ctm.days_in_year, and ctm.weeks_in_year, which are
// all determined by the YYYY value.
{
return 2;
}
- if( digits[0] == 0 && digits[1] < 5)
- {
- return 2;
- }
if( digits[2] == -1 )
{
return 3;
static
int
-gets_month(char *p, char *pend, struct cobol_tm &ctm)
+gets_month(const char *p, const char *pend, struct cobol_tm &ctm)
{
// Populates ctm.MM
static
int
-gets_day(char *p, char *pend, struct cobol_tm &ctm)
+gets_day(const char *p, const char *pend, struct cobol_tm &ctm)
{
// Populates ctm.DD, ctm.day_of_week, ctm.week_of_year, ctm.day_of_week
{
return 2;
}
- if(DD >= 0)
+ if( DD >= 0 )
{
- if( DD >= 0 )
+ if( DD == 0)
{
- if( DD == 0)
- {
- // If zero, we know we failed at the second '0' in "00"
- retval = 2;
- }
- else if( DD >= 40)
+ // If zero, we know we failed at the second '0' in "00"
+ retval = 2;
+ }
+ else if( DD >= 40)
+ {
+ // 40 or more, then we knew there was trouble at the first digit
+ retval = 1;
+ }
+ else if(ctm.MM == 2 && DD >=30)
+ {
+ // It's February, so if we see 3x we know on the 3 that we are in
+ // error:
+ retval = 1;
+ }
+ else
+ {
+ static const int month_days[13] = {-1,31,28,31,30,31,30,31,31,30,31,30,31};
+ int days_in_month = month_days[ctm.MM];
+ if( ctm.MM == 2 && ctm.days_in_year == 366 )
{
- // 40 or more, then we knew there was trouble at the first digit
- retval = 1;
+ days_in_month = 29;
}
- else if(ctm.MM == 2 && DD >=30)
+
+ if( DD > days_in_month )
{
- // It's February, so if we see 3x we know on the 3 that we are in
- // error:
- retval = 1;
+ retval = 2;
}
else
{
- static const int month_days[13] = {-1,31,28,31,30,31,30,31,31,30,31,30,31};
- int days_in_month = month_days[ctm.MM];
- if( ctm.MM == 2 && ctm.days_in_year == 366 )
- {
- days_in_month = 29;
- }
-
- if( DD > days_in_month )
- {
- retval = 2;
- }
- else
- {
- // We have a good YYYY-MM-DD
- ctm.DD = DD;
- double JD = YMD_to_JD(ctm.YYYY, ctm.MM, DD);
- double JD_Jan0 = YMD_to_JD(ctm.YYYY, 1, 0);
- ctm.day_of_year = (int)(JD - JD_Jan0);
- ctm.day_of_week = JD_to_DOW(JD);
- }
+ // We have a good YYYY-MM-DD
+ ctm.DD = DD;
+ double JD = YMD_to_JD(ctm.YYYY, ctm.MM, DD);
+ double JD_Jan0 = YMD_to_JD(ctm.YYYY, 1, 0);
+ ctm.day_of_year = (int)(JD - JD_Jan0);
+ ctm.day_of_week = JD_to_DOW(JD);
}
}
}
static
int
-gets_day_of_week(char *p, char *pend, struct cobol_tm &ctm)
+gets_day_of_week(const char *p, const char *pend, struct cobol_tm &ctm)
{
// This is just a simple D, for day-of-week. The COBOL spec is that
// it be 1 to 7, 1 being Monday
static
int
-gets_day_of_year(char *p, char *pend, struct cobol_tm &ctm)
+gets_day_of_year(const char *p, const char *pend, struct cobol_tm &ctm)
{
// This is a three-digit day-of-year, 001 through 365,366
int digits[3];
static
int
-gets_week(char *p, char *pend, struct cobol_tm &ctm)
+gets_week(const char *p, const char *pend, struct cobol_tm &ctm)
{
// This is a two-digit value, 01 through 52,53
int digits[2];
static
int
-gets_hours(char *p, char *pend, struct cobol_tm &ctm, bool in_offset)
+gets_hours( const char *p,
+ const char *pend,
+ struct cobol_tm &ctm,
+ bool in_offset)
{
// This is a two-digit value, 01 through 23
int digits[2];
static
int
-gets_minutes(char *p, char *pend, struct cobol_tm &ctm, bool in_offset)
+gets_minutes( const char *p,
+ const char *pend,
+ struct cobol_tm &ctm,
+ bool in_offset)
{
// This is a two-digit value, 01 through 59
int digits[2];
static
int
-gets_seconds(char *p, char *pend, struct cobol_tm &ctm)
+gets_seconds(const char *p, const char *pend, struct cobol_tm &ctm)
{
// This is a two-digit value, 01 through 59
int digits[2];
static
int
-gets_nanoseconds(char *f, char *f_end, char *p, char *pend, struct cobol_tm &ctm)
+gets_nanoseconds( const char *f,
+ const char *f_end,
+ const char *p,
+ const char *pend,
+ struct cobol_tm &ctm)
{
// Because nanoseconds digits to the right of the decimal point can vary from
// one digit to our implementation-specific limit of nine characters, this
int ncount = 0;
int nanoseconds = 0;
- char *pinit = p;
+ const char *pinit = p;
while( f < f_end && *f == internal_s && p < pend )
{
f += 1;
static
int
fill_cobol_tm(cobol_tm &ctm,
- cblc_field_t *par1,
+ const cblc_field_t *par1,
size_t par1_offset,
size_t par1_size,
- cblc_field_t *par2,
+ const cblc_field_t *par2,
size_t par2_offset,
size_t par2_size)
{
// Establish the formatting string:
- char *format = (char *)(par1->data+par1_offset);
+ char *format = PTRCAST(char, (par1->data+par1_offset));
char *format_end = format + par1_size;
// Establish the string to be checked:
- char *source = (char *)(par2->data+par2_offset);
+ char *source = PTRCAST(char, (par2->data+par2_offset));
char *source_end = source + par2_size;
// Let's eliminate trailing spaces...
extern "C"
void
__gg__test_formatted_datetime(cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_offset,
size_t arg1_size,
- cblc_field_t *arg2,
+ const cblc_field_t *arg2,
size_t arg2_offset,
size_t arg2_size)
extern "C"
void
__gg__integer_of_formatted_date(cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_offset,
size_t arg1_size,
- cblc_field_t *arg2,
+ const cblc_field_t *arg2,
size_t arg2_offset,
size_t arg2_size)
{
extern "C"
void
__gg__seconds_from_formatted_time(cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_offset,
size_t arg1_size,
- cblc_field_t *arg2,
+ const cblc_field_t *arg2,
size_t arg2_offset,
size_t arg2_size)
{
extern "C"
void
__gg__hex_of(cblc_field_t *dest,
- cblc_field_t *field,
+ const cblc_field_t *field,
size_t field_offset,
size_t field_size)
{
extern "C"
void
__gg__highest_algebraic(cblc_field_t *dest,
- cblc_field_t *var,
+ const cblc_field_t *var,
size_t,
size_t)
{
extern "C"
void
__gg__lowest_algebraic( cblc_field_t *dest,
- cblc_field_t *var,
+ const cblc_field_t *var,
size_t,
size_t)
{
}
static int
-floating_format_tester(char const * const f, char * const f_end)
+floating_format_tester(char const * const f, char const * const f_end)
{
int retval = -1;
char decimal_point = __gg__get_decimal_point();
extern "C"
void
__gg__numval_f( cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
GCOB_FP128 value = 0;
- char *data = (char * )(source->data + source_offset);
- char *data_end = data + source_size;
+ const char *data = PTRCAST(char, (source->data + source_offset));
+ const char *data_end = data + source_size;
int error = floating_format_tester(data, data_end);
extern "C"
void
__gg__test_numval_f(cblc_field_t *dest,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size)
{
- char *data = (char * )(source->data + source_offset);
- char *data_end = data + source_size;
+ const char *data = PTRCAST(char, (source->data + source_offset));
+ const char *data_end = data + source_size;
int error = floating_format_tester(data, data_end);
}
static bool
-ismatch(char *a1, char *a2, char *b1, char *b2)
+ismatch(const char *a1, const char *a2, const char *b1, const char *b2)
{
bool retval = true;
while( a1 < a2 && b1 < b2 )
}
static bool
-iscasematch(char *a1, char *a2, char *b1, char *b2)
+iscasematch(const char *a1, const char *a2, const char *b1, const char *b2)
{
bool retval = true;
while( a1 < a2 && b1 < b2 )
return retval;
}
-static char *
-strstr(char *haystack, char *haystack_e, char *needle, char *needle_e)
+static
+const char *
+strstr( const char *haystack,
+ const char *haystack_e,
+ const char *needle,
+ const char *needle_e)
{
- char *retval = NULL;
- char *pend = haystack_e - (needle_e - needle);
+ const char *retval = NULL;
+ const char *pend = haystack_e - (needle_e - needle);
while( haystack <= pend )
{
if(ismatch(haystack, haystack_e, needle, needle_e))
return retval;
}
-static char *
-strcasestr(char *haystack, char *haystack_e, char *needle, char *needle_e)
+static
+const char *
+strcasestr( const char *haystack,
+ const char *haystack_e,
+ const char *needle,
+ const char *needle_e)
{
- char *retval = NULL;
- char *pend = haystack_e - (needle_e - needle);
+ const char *retval = NULL;
+ const char *pend = haystack_e - (needle_e - needle);
while( haystack <= pend )
{
if(iscasematch(haystack, haystack_e, needle, needle_e))
return retval;
}
-static char *
-strlaststr(char *haystack, char *haystack_e, char *needle, char *needle_e)
+static
+const char *
+strlaststr( const char *haystack,
+ const char *haystack_e,
+ const char *needle,
+ const char *needle_e)
{
- char *retval = NULL;
- char *pend = haystack_e - (needle_e - needle);
+ const char *retval = NULL;
+ const char *pend = haystack_e - (needle_e - needle);
while( haystack <= pend )
{
if(ismatch(haystack, haystack_e, needle, needle_e))
return retval;
}
-static char *
-strcaselaststr(char *haystack, char *haystack_e, char *needle, char *needle_e)
+static
+const char *
+strcaselaststr( const char *haystack,
+ const char *haystack_e,
+ const char *needle,
+ const char *needle_e)
{
- char *retval = NULL;
- char *pend = haystack_e - (needle_e - needle);
+ const char *retval = NULL;
+ const char *pend = haystack_e - (needle_e - needle);
while( haystack <= pend )
{
if(iscasematch(haystack, haystack_e, needle, needle_e))
extern "C"
-void __gg__substitute(cblc_field_t *dest,
- cblc_field_t *arg1_f,
- size_t arg1_o,
- size_t arg1_s,
- size_t N,
- uint8_t *control
- )
+void
+__gg__substitute( cblc_field_t *dest,
+ const cblc_field_t *arg1_f,
+ size_t arg1_o,
+ size_t arg1_s,
+ size_t N,
+ const uint8_t *control)
{
// arg2 is the Group 1 triplet.
// arg3 is the Group 2 triplet
size_t *arg2_o = __gg__treeplet_1o;
size_t *arg2_s = __gg__treeplet_1s;
cblc_field_t **arg3_f = __gg__treeplet_2f;
- size_t *arg3_o = __gg__treeplet_2o;
- size_t *arg3_s = __gg__treeplet_2s;
+ const size_t *arg3_o = __gg__treeplet_2o;
+ const size_t *arg3_s = __gg__treeplet_2s;
- ssize_t retval_size = 256;
- char *retval = (char *)malloc(retval_size);
+ ssize_t retval_size;
+ retval_size = 256;
+ char *retval = static_cast<char *>(malloc(retval_size));
+ massert(retval);
*retval = '\0';
- char *haystack = (char *)(arg1_f->data + arg1_o);
- char *haystack_e = haystack + arg1_s;
+ const char *haystack = PTRCAST(char, (arg1_f->data + arg1_o));
+ const char *haystack_e = haystack + arg1_s;
ssize_t outdex = 0;
- char **pflasts = (char **)malloc(N * sizeof(char *));
+ const char **pflasts = static_cast<const char **>(malloc(N * sizeof(char *)));
+ massert(pflasts);
if( arg1_s == 0 )
{
{
pflasts[i] = strcasestr(haystack,
haystack_e,
- (char *)(arg2_f[i]->data+arg2_o[i]),
- (char *)(arg2_f[i]->data+arg2_o[i]) + arg2_s[i]);
+ PTRCAST(char, (arg2_f[i]->data+arg2_o[i])),
+ PTRCAST(char, (arg2_f[i]->data+arg2_o[i])) + arg2_s[i]);
}
else if( control[i] & substitute_last_e)
{
pflasts[i] = strcaselaststr(haystack,
haystack_e,
- (char *)(arg2_f[i]->data+arg2_o[i]),
- (char *)(arg2_f[i]->data+arg2_o[i]) + arg2_s[i]);
+ PTRCAST(char, (arg2_f[i]->data+arg2_o[i])),
+ PTRCAST(char, (arg2_f[i]->data+arg2_o[i])) + arg2_s[i]);
}
else
{
{
pflasts[i] = strstr(haystack,
haystack_e,
- (char *)(arg2_f[i]->data+arg2_o[i]),
- (char *)(arg2_f[i]->data+arg2_o[i]) + arg2_s[i]);
+ PTRCAST(char, (arg2_f[i]->data+arg2_o[i])),
+ PTRCAST(char, (arg2_f[i]->data+arg2_o[i])) + arg2_s[i]);
}
else if( control[i] & substitute_last_e)
{
pflasts[i] = strlaststr(haystack,
haystack_e,
- (char *)(arg2_f[i]->data+arg2_o[i]),
- (char *)(arg2_f[i]->data+arg2_o[i]) + arg2_s[i]);
+ PTRCAST(char, (arg2_f[i]->data+arg2_o[i])),
+ PTRCAST(char, (arg2_f[i]->data+arg2_o[i])) + arg2_s[i]);
}
else
{
> retval_size )
{
retval_size *= 2;
- retval = (char *)realloc(retval, retval_size);
+ retval = static_cast<char *>(realloc(retval, retval_size));
+ massert(retval);
}
// We checked earlier for FIRST/LAST matches
continue;
}
- char *needle = (char *)(arg2_f[i]->data+arg2_o[i]);
- char *needle_e = (char *)(arg2_f[i]->data+arg2_o[i]) + arg2_s[i];
+ const char *needle = PTRCAST(char, arg2_f[i]->data+arg2_o[i]);
+ const char *needle_e = PTRCAST(char, arg2_f[i]->data+arg2_o[i]) + arg2_s[i];
matched = (control[i] & substitute_anycase_e) && iscasematch(
haystack,
haystack_e,
while( outdex + 1 > retval_size )
{
retval_size *= 2;
- retval = (char *)realloc(retval, retval_size);
+ retval = static_cast<char *>(realloc(retval, retval_size));
+ massert(retval);
}
retval[outdex++] = *haystack++;
}
extern "C"
void
__gg__locale_compare( cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_o,
size_t arg1_s,
- cblc_field_t *arg2,
+ const cblc_field_t *arg2,
size_t arg2_o,
size_t arg2_s,
- cblc_field_t *arg_locale,
+ const cblc_field_t *arg_locale,
size_t /*arg_locale_o*/,
size_t /*arg_locale_s*/
)
extern "C"
void
__gg__locale_date(cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_o,
size_t /*arg1_s*/,
- cblc_field_t *arg_locale,
+ const cblc_field_t *arg_locale,
size_t /*arg_locale_o*/,
size_t /*arg_locale_s*/)
{
extern "C"
void
__gg__locale_time(cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_o,
size_t /*arg1_s*/,
- cblc_field_t *arg_locale,
+ const cblc_field_t *arg_locale,
size_t /*arg_locale_o*/,
size_t /*arg_locale_s*/)
extern "C"
void
__gg__locale_time_from_seconds( cblc_field_t *dest,
- cblc_field_t *arg1,
+ const cblc_field_t *arg1,
size_t arg1_o,
size_t arg1_s,
- cblc_field_t *arg_locale,
+ const cblc_field_t *arg_locale,
size_t /*arg_locale_o*/,
size_t /*arg_locale_s*/)
{
// Default locale
tm tm = {};
- int rdigits;
+ int rdigits=0;
long seconds = (long)__gg__binary_value_from_qualified_field(&rdigits,
arg1,
arg1_o,
#include "gfileio.h"
#include "charmaps.h"
#include "valconv.h"
-
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/types.h>
-
#include <execinfo.h>
-
#include "exceptl.h"
/* BSD extension. */
// location information are established in the "last_exception..." variables.
// This is in accordance with the ISO requirements of "14.6.13.1.1 General" that
// describe how a "last exception status" is maintained.
-// other "location" information
+// other "location" information
static int last_exception_code;
static const char *last_exception_program_id;
static const char *last_exception_section;
* 4. handled, where handled == type
*
* If the statement includes some kind of ON ERROR
- * clause that covers it, the generated code does not raise an EC.
+ * clause that covers it, the generated code does not raise an EC.
*
* The status is updated by __gg_match_exception if it runs, else
- * __gg__check_fatal_exception.
+ * __gg__check_fatal_exception.
*
* If a Declarative is matched, its section number is passed to handled_by(),
* which does two things:
* 1. sets isection to record the declarative
* 2. for a nonfatal EC, sets handled, indication no further action is needed
*
- * A Declarative may use RESUME, which clears ec_status, which is a "handled" state.
- *
- * Default processing ensures return to initial state.
+ * A Declarative may use RESUME, which clears ec_status, which is a "handled" state.
+ *
+ * Default processing ensures return to initial state.
*/
class ec_status_t {
public:
struct file_status_t {
- size_t ifile;
- cblc_file_prior_op_t operation;
- cbl_file_mode_t mode;
+ size_t ifile;
+ cblc_file_prior_op_t operation;
+ cbl_file_mode_t mode;
cblc_field_t *user_status;
const char * filename;
- file_status_t() : ifile(0) , operation(file_op_none), mode(file_mode_none_e) {}
- file_status_t( cblc_file_t *file )
- : ifile(file->symbol_table_index)
- , operation(file->prior_op)
- , mode(cbl_file_mode_t(file->mode_char))
- , user_status(file->user_status)
- , filename(file->filename)
- {}
+ file_status_t()
+ : ifile(0)
+ , operation(file_op_none)
+ , mode(file_mode_none_e)
+ , user_status(nullptr)
+ , filename(nullptr)
+ {}
+// cppcheck-suppress noExplicitConstructor
+ file_status_t( const cblc_file_t *file )
+ : ifile(file->symbol_table_index)
+ , operation(file->prior_op)
+ , mode(cbl_file_mode_t(file->mode_char))
+ , user_status(file->user_status)
+ , filename(file->filename)
+ {}
const char * op_str() const {
switch( operation ) {
case file_op_none: return "none";
return "???";
}
};
- private:
+ private:
char msg[132];
ec_type_t type, handled;
size_t isection;
bool is_fatal() const;
ec_status_t& update();
-
+
bool is_enabled() const { return enabled.match(type); }
bool is_enabled( ec_type_t ec) const { return enabled.match(ec); }
ec_status_t& handled_by( size_t declarative_section ) {
isection = declarative_section;
- // A fatal exception remains unhandled unless RESUME clears it.
- if( ! is_fatal() ) {
+ // A fatal exception remains unhandled unless RESUME clears it.
+ if( ! is_fatal() ) {
handled = type;
}
return *this;
return *this;
}
bool unset() const { return isection == 0 && lineno == 0; }
-
+
void reset_environment() const;
ec_status_t& copy_environment();
-
+
// Return the EC's type if it is *not* handled.
ec_type_t unhandled() const {
bool was_handled = ec_cmp(type, handled);
::declaratives = declaratives;
}
+
+// This is the default truncation mode
static cbl_truncation_mode truncation_mode = trunc_std_e;
+extern "C"
+void
+__gg__set_truncation_mode(cbl_truncation_mode trunc_mode)
+ {
+ truncation_mode = trunc_mode;
+ }
+
struct program_state
{
// These are the run-time values of these characters.
void *retval = malloc(a);
fprintf(stderr, " --malloc(%p)-- ", retval);
return retval;
- return retval;
}
#endif
abort();
}
+void
+__gg__mabort()
+ {
+ __gg__abort("Memory allocation error\n");
+ }
+
extern "C"
char
__gg__get_decimal_point()
if( new_size > *size )
{
*size = new_size;
- *block = (int *)realloc(*block, new_size * sizeof(int));
+ *block = static_cast<int *>(realloc(*block, new_size * sizeof(int)));
}
}
if( new_size > treeplet_1_size )
{
treeplet_1_size = new_size;
- __gg__treeplet_1f = (cblc_field_t **)realloc(__gg__treeplet_1f, new_size * sizeof(cblc_field_t *));
- __gg__treeplet_1o = (size_t *)realloc(__gg__treeplet_1o, new_size * sizeof(size_t));
- __gg__treeplet_1s = (size_t *)realloc(__gg__treeplet_1s, new_size * sizeof(size_t));
+ __gg__treeplet_1f = static_cast<cblc_field_t **>(realloc(__gg__treeplet_1f, new_size * sizeof(cblc_field_t *)));
+ __gg__treeplet_1o = static_cast<size_t *>(realloc(__gg__treeplet_1o, new_size * sizeof(size_t)));
+ __gg__treeplet_1s = static_cast<size_t *>(realloc(__gg__treeplet_1s, new_size * sizeof(size_t)));
}
break;
case 2:
if( new_size > treeplet_2_size )
{
treeplet_2_size = new_size;
- __gg__treeplet_2f = (cblc_field_t **)realloc(__gg__treeplet_2f, new_size * sizeof(cblc_field_t *));
- __gg__treeplet_2o = (size_t *)realloc(__gg__treeplet_2o, new_size * sizeof(size_t));
- __gg__treeplet_2s = (size_t *)realloc(__gg__treeplet_2s, new_size * sizeof(size_t));
+ __gg__treeplet_2f = static_cast<cblc_field_t **>(realloc(__gg__treeplet_2f, new_size * sizeof(cblc_field_t *)));
+ __gg__treeplet_2o = static_cast<size_t *>(realloc(__gg__treeplet_2o, new_size * sizeof(size_t)));
+ __gg__treeplet_2s = static_cast<size_t *>(realloc(__gg__treeplet_2s, new_size * sizeof(size_t)));
}
break;
case 3:
if( new_size > treeplet_3_size )
{
treeplet_3_size = new_size;
- __gg__treeplet_3f = (cblc_field_t **)realloc(__gg__treeplet_3f, new_size * sizeof(cblc_field_t *));
- __gg__treeplet_3o = (size_t *)realloc(__gg__treeplet_3o, new_size * sizeof(size_t));
- __gg__treeplet_3s = (size_t *)realloc(__gg__treeplet_3s, new_size * sizeof(size_t));
+ __gg__treeplet_3f = static_cast<cblc_field_t **>(realloc(__gg__treeplet_3f, new_size * sizeof(cblc_field_t *)));
+ __gg__treeplet_3o = static_cast<size_t *>(realloc(__gg__treeplet_3o, new_size * sizeof(size_t)));
+ __gg__treeplet_3s = static_cast<size_t *>(realloc(__gg__treeplet_3s, new_size * sizeof(size_t)));
}
break;
case 4:
if( new_size > treeplet_4_size )
{
treeplet_4_size = new_size;
- __gg__treeplet_4f = (cblc_field_t **)realloc(__gg__treeplet_4f, new_size * sizeof(cblc_field_t *));
- __gg__treeplet_4o = (size_t *)realloc(__gg__treeplet_4o, new_size * sizeof(size_t));
- __gg__treeplet_4s = (size_t *)realloc(__gg__treeplet_4s, new_size * sizeof(size_t));
+ __gg__treeplet_4f = static_cast<cblc_field_t **>(realloc(__gg__treeplet_4f, new_size * sizeof(cblc_field_t *)));
+ __gg__treeplet_4o = static_cast<size_t *>(realloc(__gg__treeplet_4o, new_size * sizeof(size_t)));
+ __gg__treeplet_4s = static_cast<size_t *>(realloc(__gg__treeplet_4s, new_size * sizeof(size_t)));
}
break;
}
}
static int
-var_is_refmod( cblc_field_t *var )
+var_is_refmod( const cblc_field_t *var )
{
return (var->attr & refmod_e) != 0;
}
}
static bool
-value_is_too_big( cblc_field_t *var,
- __int128 value,
- int source_rdigits)
+value_is_too_big(const cblc_field_t *var,
+ __int128 value,
+ int source_rdigits)
{
// This routine is in support of arithmetic ON SIZE ERROR. It returns
// TRUE if var hasn't enough bytes to hold the decimal representation
extern "C"
void
-__gg__string_to_alpha_edited_ascii( char *dest,
- char *source,
- int slength,
- char *picture)
+__gg__string_to_alpha_edited_ascii( char *dest,
+ const char *source,
+ int slength,
+ const char *picture)
{
- char *dupe = (char *)malloc(slength);
+ char *dupe = static_cast<char *>(malloc(slength));
+ massert(dupe);
memcpy(dupe, source, slength);
ascii_to_internal_str(dupe, slength);
__gg__string_to_alpha_edited(dest, dupe, slength, picture);
{
float tvalue = (float)value;
tvalue /= (float)__gg__power_of_ten(source_rdigits);
- *(float *)location = tvalue;
+ *PTRCAST(float, location) = tvalue;
break;
}
{
double tvalue = (double)value;
tvalue /= (double)__gg__power_of_ten(source_rdigits);
- *(double *)location = tvalue;
+ *PTRCAST(double, location) = tvalue;
break;
}
default:
{
- bool size_error = false;
-
int target_rdigits = var->rdigits;
if( var->attr & intermediate_e && var->type == FldNumericBin5)
{
else
{
// Value is now scaled to the target's target_rdigits
+ bool size_error = false;
int is_negative = value < 0 ;
// Note that sending a signed value to an alphanumeric strips off
// any plus or minus signs.
- size_error = __gg__binary_to_string_internal( (char *)location,
- length, value);
+ size_error = __gg__binary_to_string_internal(
+ PTRCAST(char, location),
+ length, value);
break;
case FldNumericDisplay:
{
// The sign character goes into the first location
size_error =
- __gg__binary_to_string_internal((char *)(location+1),
+ __gg__binary_to_string_internal(PTRCAST(char, location+1),
length-1, value);
location[0] = sign_ch;
}
{
// The sign character goes into the last location
size_error =
- __gg__binary_to_string_internal( (char *)location,
- length-1, value);
+ __gg__binary_to_string_internal(PTRCAST(char, location),
+ length-1, value);
location[length-1] = sign_ch;
}
}
// The sign information is not separate, so we put it into
// the number
size_error =
- __gg__binary_to_string_internal(( char *)location,
+ __gg__binary_to_string_internal(PTRCAST(char, location),
length, value);
if( size_error && is_negative )
else
{
// It's a simple positive number
- size_error = __gg__binary_to_string_internal( (char *)location,
+ size_error = __gg__binary_to_string_internal( PTRCAST(char,
+ location),
length, value);
}
// Convert that string according to the PICTURE clause
size_error |= __gg__string_to_numeric_edited(
- (char *)location,
+ PTRCAST(char, location),
ach,
target_rdigits,
is_negative,
var->picture);
- ascii_to_internal_str((char *)location, var->capacity);
+ ascii_to_internal_str( PTRCAST(char, location), var->capacity);
}
break;
// Convert that string according to the PICTURE clause
__gg__string_to_alpha_edited(
- (char *)location,
+ PTRCAST(char, location),
ach,
strlen(ach),
var->picture);
}
static __int128
-edited_to_binary( const char *ps_,
+edited_to_binary( char *ps_,
int length,
int *rdigits)
{
- const unsigned char *ps = (const unsigned char *)ps_;
+ const unsigned char *ps = const_cast<const unsigned char *>(PTRCAST(unsigned char, ps_));
// This routine is used for converting NumericEdited strings to
// binary.
__int128 result = 0;
- unsigned char ch;
-
// We need to check the last two characters. If CR or DB, then the result
// is negative:
if( length >= 2)
while( index < length )
{
- ch = ps[index++] & 0xFF;
+ unsigned char ch = ps[index++] & 0xFF;
if( ch == ascii_to_internal(__gg__decimal_point) )
{
delta_r = 1;
}
}
- if( result == 0 )
- {
- hyphen = 0;
- }
- else if( hyphen )
+ if( hyphen )
{
result = -result;
}
}
// move the bytes of psource into retval, flipping them end-to-end
- unsigned char *dest = (unsigned char *)&retval;
+ unsigned char *dest = PTRCAST(unsigned char, &retval);
while(capacity > 0)
{
*dest++ = psource[--capacity];
__int128 retval = 0 ;
// move the bytes of psource into retval, flipping them end-to-end
- unsigned char *dest = (unsigned char *)&retval;
+ unsigned char *dest = PTRCAST(unsigned char, &retval);
while(capacity > 0)
{
*dest++ = psource[--capacity];
static
__int128
-get_binary_value_local( int *rdigits,
- cblc_field_t *resolved_var,
- unsigned char *resolved_location,
- size_t resolved_length)
+get_binary_value_local( int *rdigits,
+ const cblc_field_t *resolved_var,
+ unsigned char *resolved_location,
+ size_t resolved_length)
{
__int128 retval = 0;
case FldGroup :
case FldAlphanumeric :
// Read the data area as a dirty string:
- retval = __gg__dirty_to_binary_internal( (const char *)resolved_location,
+ retval = __gg__dirty_to_binary_internal( PTRCAST(const char,
+ resolved_location),
resolved_length,
rdigits );
break;
// Turn all the bits on
memset( &retval, 0xFF, sizeof(retval) );
- // Make it positive
- ((unsigned char *)&retval)[sizeof(retval)-1] = 0x3F;
+ // Make it positive by turning off the highest order bit:
+ (PTRCAST(unsigned char, &retval))[sizeof(retval)-1] = 0x3F;
*rdigits = resolved_var->rdigits;
}
else
// We know where the decimal point is because of rdigits. Because
// we know that it a clean string of ASCII digits, we can use the
// dirty converter:
- retval = __gg__dirty_to_binary_internal((const char *)resolved_location,
+ retval = __gg__dirty_to_binary_internal(PTRCAST(const char,
+ resolved_location),
resolved_length,
rdigits );
*rdigits = resolved_var->rdigits;
break;
case FldNumericEdited :
- retval = edited_to_binary( (const char *)resolved_location,
+ retval = edited_to_binary( PTRCAST(char, resolved_location),
resolved_length,
rdigits);
break;
if( resolved_var->attr & signable_e)
{
retval = big_endian_to_binary_signed(
- (const unsigned char *)resolved_location,
+ PTRCAST(const unsigned char, resolved_location),
resolved_length);
}
else
{
retval = big_endian_to_binary_unsigned(
- (const unsigned char *)resolved_location,
+ PTRCAST(const unsigned char, resolved_location),
resolved_length);
}
*rdigits = resolved_var->rdigits;
if( resolved_var->attr & signable_e)
{
retval = little_endian_to_binary_signed(
- (const unsigned char *)resolved_location,
+ PTRCAST(const unsigned char, resolved_location),
resolved_length);
}
else
{
retval = little_endian_to_binary_unsigned(
- (const unsigned char *)resolved_location,
+ PTRCAST(const unsigned char, resolved_location),
resolved_length);
}
*rdigits = resolved_var->rdigits;
char ach[32];
time_t t = cobol_time();
- struct tm *local = localtime(&t);
+ const struct tm *local = localtime(&t);
sprintf(ach,
"%2.2d%2.2d%2.2d",
char ach[32];
time_t t = cobol_time();
- struct tm *local = localtime(&t);
+ const struct tm *local = localtime(&t);
sprintf(ach,
"%4.4d%2.2d%2.2d",
char ach[32];
time_t t = cobol_time();
- struct tm *local = localtime(&t);
+ const struct tm *local = localtime(&t);
sprintf(ach,
"%2.2d%3.3d",
char ach[32];
time_t t = cobol_time();
- struct tm *local = localtime(&t);
+ const struct tm *local = localtime(&t);
sprintf(ach,
"%4.4d%3.3d",
char ach[32];
time_t t = cobol_time();
- struct tm *local = localtime(&t);
+ const struct tm *local = localtime(&t);
sprintf(ach,
"%1.1d",
__gg__setop_compare(
const char *candidate,
int capacity,
- const char *domain)
+ char *domain)
{
// This routine is called to compare the characters of 'candidate'
// against the list of character pairs in 'domain'
int retval = 0;
- int ch;
int l;
int h;
- const char *d;
+ char *d;
for(int i=0; i<capacity; i++)
{
- ch = (*candidate++ & 0xFF);
+ int ch = (*candidate++ & 0xFF);
d = domain;
while(*d)
{
// See the comments in genapi.cc::get_class_condition_string
// to see how this string was encoded.
- l = (int)strtoll(d, (char **)&d, 16);
+ l = (int)strtoll(d, reinterpret_cast<char **>(&d), 16);
if( l < 0 )
{
l = -l;
if( *d == '/' )
{
d += 1;
- h = (int)strtoll(d, (char **)&d, 16);
+ h = (int)strtoll(d, reinterpret_cast<char **>(&d), 16);
if( h < 0 )
{
h = -h;
}
static int
-get_scaled_rdigits(cblc_field_t *field)
+get_scaled_rdigits(const cblc_field_t *field)
{
int retval;
if( !(field->attr & scaled_e) )
break;
}
- unsigned char *running_location = actual_location;
+ const unsigned char *running_location = actual_location;
// We need the counts of digits to the left and right of the decimal point
int rdigits = get_scaled_rdigits(var);
rdigits += ldigits;
}
- int index = 0; // This is the running index into our output destination
if( rdigits )
{
// We need room for the inside decimal point
if( actual_location )
{
+ int index = 0; // This is the running index into our output destination
if( var->attr & signable_e )
{
if( var->attr & separate_e )
// the user.
if( (*dest)[index-1] != (char)DEGENERATE_HIGH_VALUE )
{
- turn_sign_bit_off((unsigned char *)&ch);
+ turn_sign_bit_off( PTRCAST(unsigned char, &ch));
}
(*dest)[index++] = ch;
}
char ch = *running_location++;
if( (*dest)[index-1] != (char)DEGENERATE_HIGH_VALUE )
{
- turn_sign_bit_off((unsigned char *)&ch);
+ turn_sign_bit_off(PTRCAST(unsigned char, &ch));
}
(*dest)[index++] = ch;
}
}
__gg__realloc_if_necessary(dest, dest_size, nsize);
- bool is_signed = value < 0;
-
if( var->attr & signable_e )
{
- if( is_signed )
+ if( value < 0 )
{
(*dest)[index++] = internal_minus;
}
actual_location,
actual_length);
char ach[64];
- sprintf(ach, "%lu", (size_t)value);
+ sprintf(ach, "%lu", (unsigned long)value);
__gg__realloc_if_necessary(dest, dest_size, strlen(ach)+1);
strcpy(*dest, ach);
}
// side, and 9999999 and then 1E+7 on the high side
// 10,000,000 = 1E7
char ach[64];
- _Float32 floatval = *(_Float32 *)actual_location;
+ _Float32 floatval = *PTRCAST(_Float32, actual_location);
strfromf32(ach, sizeof(ach), "%.9E", floatval);
char *p = strchr(ach, 'E');
if( !p )
// We will also format numbers so that we produce 0.01 and 1E-3 on the low
// side, and 9999999 and then 1E+15 on the high side
char ach[64];
- _Float64 floatval = *(_Float64 *)actual_location;
+ _Float64 floatval = *PTRCAST(_Float64, actual_location);
strfromf64(ach, sizeof(ach), "%.17E", floatval);
char *p = strchr(ach, 'E');
if( !p )
if( var->attr & scaled_e && var->type != FldNumericDisplay )
{
static size_t buffer_size = MINIMUM_ALLOCATION_SIZE;
- static char * buffer = (char *)malloc(buffer_size);
+ static char *buffer = static_cast<char *>(malloc(buffer_size));
+ massert(buffer);
if( var->rdigits > 0)
{
// We have something like 123 or +123. We need to insert a decimal
{
p2 += 1;
}
- strcpy((char *)p1, (char *)p2);
+ strcpy(PTRCAST(char, p1), PTRCAST(char, p2));
}
done:
{
// We are working with a figurative constant
- test = (char *)malloc(conditional_length);
+ test = static_cast<char *>(malloc(conditional_length));
+ massert(test);
test_len = conditional_length;
// This is where we handle the zero-length strings that
// nonetheless can magically be expanded into figurative
else if( list_len < conditional_length )
{
// 'list' is too short; we have to right-fill with spaces:
- test = (char *)malloc(conditional_length);
+ test = static_cast<char *>(malloc(conditional_length));
+ massert(test);
test_len = conditional_length;
memset(test, internal_space, conditional_length);
memcpy(test, list, list_len);
}
else
{
- test = (char *)malloc(list_len);
+ test = static_cast<char *>(malloc(list_len));
+ massert(test);
test_len = list_len;
memcpy(test, list, list_len);
}
}
else
{
- cmpval = cstrncmp(test, (char *)conditional_location, conditional_length);
+ cmpval = cstrncmp (test,
+ PTRCAST(char, conditional_location),
+ conditional_length);
if( cmpval == 0 && (int)strlen(test) != conditional_length )
{
// When strncmp returns 0, the actual smaller string is the
}
static GCOB_FP128
-get_float128( cblc_field_t *field,
+get_float128( const cblc_field_t *field,
unsigned char *location )
{
GCOB_FP128 retval=0;
switch( field->capacity )
{
case 4:
- retval = *(_Float32 *)location;
+ retval = *PTRCAST(_Float32 , location);
break;
case 8:
- retval = *(_Float64 *)location;
+ retval = *PTRCAST(_Float64 , location);
break;
case 16:
// retval = *(_Float128 *)location; doesn't work, because the SSE
{
// We need to replace any commas with periods
static size_t size = 128;
- static char *buffer = (char *)malloc(size);
+ static char *buffer = static_cast<char *>(malloc(size));
while( strlen(field->initial)+1 > size )
{
size *= 2;
- buffer = (char *)malloc(size);
+ buffer = static_cast<char *>(malloc(size));
}
+ massert(buffer);
strcpy(buffer, field->initial);
char *p = strchr(buffer, ',');
if(p)
conditional,
conditional_location,
conditional_length);
- char *walker = list->initial;
+ const char *walker = list->initial;
while(*walker)
{
char left_flag;
case FldFloat:
{
- GCOB_FP128 value = get_float128(conditional, conditional_location) ;
- char *walker = list->initial;
+ GCOB_FP128 fp128 = get_float128(conditional, conditional_location) ;
+ const char *walker = list->initial;
while(*walker)
{
char left_flag;
right_len);
}
- if( left_value <= value && value <= right_value )
+ if( left_value <= fp128 && fp128 <= right_value )
{
retval = 0;
break;
static
int
-compare_strings(char *left_string,
- size_t left_length,
- bool left_all,
- char *right_string,
- size_t right_length,
- bool right_all)
+compare_strings(const char *left_string,
+ size_t left_length,
+ bool left_all,
+ const char *right_string,
+ size_t right_length,
+ bool right_all)
{
int retval = 0;
size_t i = 0;
retval = 0;
retval = value < 0 ? -1 : retval;
retval = value > 0 ? 1 : retval;
+ compare = true;
break;
}
retval = 0;
retval = value < 0 ? -1 : retval;
retval = value > 0 ? 1 : retval;
+ compare = true;
break;
}
compare = true;
break;
}
- compare = true;
goto fixup_retval;
- break;
}
}
}
if( local_is_alpha(left_side->type, left_address_of)
&& local_is_alpha(right_side->type, right_address_of) )
{
- retval = compare_strings( (char *)left_location,
+ retval = compare_strings( reinterpret_cast<char *>(left_location),
left_length,
left_all,
- (char *)right_location,
+ reinterpret_cast<char *>(right_location),
right_length,
right_all );
// literal to be the same flavor as the left side:
// We need to replace any commas with periods
static size_t size = 128;
- static char *buffer = (char *)malloc(size);
+ static char *buffer = static_cast<char *>(malloc(size));
while( strlen(right_side->initial)+1 > size )
{
size *= 2;
- buffer = (char *)malloc(size);
+ buffer = static_cast<char *>(malloc(size));
}
+ massert(buffer);
strcpy(buffer, right_side->initial);
if( __gg__decimal_point == ',' )
{
{
case 4:
{
- _Float32 left_value = *(_Float32 *)left_location;
- _Float32 right_value = strtof(buffer, NULL);
+ _Float32 left_value4 = *PTRCAST(_Float32, left_location);
+ _Float32 right_value4 = strtof(buffer, NULL);
retval = 0;
- retval = left_value < right_value ? -1 : retval;
- retval = left_value > right_value ? 1 : retval;
+ retval = left_value4 < right_value4 ? -1 : retval;
+ retval = left_value4 > right_value4 ? 1 : retval;
break;
}
case 8:
{
- _Float64 left_value = *(_Float64 *)left_location;
- _Float64 right_value = strtod(buffer, NULL);
+ _Float64 left_value8 = *PTRCAST(_Float64, left_location);
+ _Float64 right_value8 = strtod(buffer, NULL);
retval = 0;
- retval = left_value < right_value ? -1 : retval;
- retval = left_value > right_value ? 1 : retval;
+ retval = left_value8 < right_value8 ? -1 : retval;
+ retval = left_value8 > right_value8 ? 1 : retval;
break;
}
case 16:
{
//_Float128 left_value = *(_Float128 *)left_location;
- GCOB_FP128 left_value;
- memcpy(&left_value, left_location, 16);
- GCOB_FP128 right_value = strtofp128(buffer, NULL);
+ GCOB_FP128 left_value16;
+ memcpy(&left_value16, left_location, 16);
+ GCOB_FP128 right_value16 = strtofp128(buffer, NULL);
retval = 0;
- retval = left_value < right_value ? -1 : retval;
- retval = left_value > right_value ? 1 : retval;
+ retval = left_value16 < right_value16 ? -1 : retval;
+ retval = left_value16 > right_value16 ? 1 : retval;
break;
}
}
if( right_refmod )
{
- retval = compare_strings( (char *)left_location,
+ retval = compare_strings( reinterpret_cast<char *>(left_location),
left_length,
left_all,
- (char *)right_location,
+ reinterpret_cast<char *>(right_location),
right_length,
right_all);
compare = true;
// VAL5 EQUAL "005" is TRUE
if( left_side->type == FldLiteralA )
{
- left_location = (unsigned char *)left_side->data;
+ left_location = reinterpret_cast<unsigned char *>(left_side->data);
left_length = left_side->capacity;
}
static size_t right_string_size = MINIMUM_ALLOCATION_SIZE;
- static char *right_string = (char *)malloc(right_string_size);
+ static char *right_string
+ = static_cast<char *>(malloc(right_string_size));
right_string = format_for_display_internal(
&right_string,
left_length -= 1;
}
- char *right_fixed;
+ const char *right_fixed;
if( *right_string == internal_plus || *right_string == internal_minus )
{
right_fixed = right_string + 1;
right_fixed = right_string;
}
- retval = compare_strings( (char *)left_location,
+ retval = compare_strings( reinterpret_cast<char *>(left_location),
left_length,
left_all,
right_fixed,
extern "C"
void
-__gg__sort_table( cblc_field_t *table,
- size_t table_o,
- size_t depending_on,
- size_t nkeys,
- cblc_field_t **keys,
- size_t *ascending,
- int duplicates )
+__gg__sort_table( const cblc_field_t *table,
+ size_t table_o,
+ size_t depending_on,
+ size_t nkeys,
+ cblc_field_t **keys,
+ size_t *ascending,
+ int duplicates )
{
size_t buffer_size = 128;
- unsigned char *contents = (unsigned char *)malloc(buffer_size);
+ unsigned char *contents = static_cast<unsigned char *>(malloc(buffer_size));
size_t offset = 0;
std::vector<size_t>offsets;
size_t record_size = table->capacity;
while( offset + sizeof(size_t) + record_size > buffer_size )
{
buffer_size *= 2;
- contents = (unsigned char *)realloc(contents, buffer_size);
+ contents = static_cast<unsigned char *>(realloc(contents, buffer_size));
}
offsets.push_back(offset);
memcpy(contents+offset, &record_size, sizeof(size_t));
{
//fprintf(stderr, "ABORTING on %2.2d %s %d\n", var->level, var->name, var->type);
//abort();
- var->data = (unsigned char *)malloc(var->capacity);
+ var->data = static_cast<unsigned char *>(malloc(var->capacity));
}
// Set the "initialized" bit, which is tested in parser_symbol_add to make
// We need to convert the options to the internal native codeset
size_t buffer_size = 4;
- char *buffer = (char *)malloc(buffer_size);
+ char *buffer = static_cast<char *>(malloc(buffer_size));
size_t index = 0;
- cblc_field_t *parent = var->parent;
+ const cblc_field_t *parent = var->parent;
switch(parent->type)
{
case FldGroup:
while(*walker)
{
static size_t first_size = MINIMUM_ALLOCATION_SIZE;
- static char *first = (char *)malloc(first_size);
+ static char *first = static_cast<char *>(malloc(first_size));
static size_t last_size = MINIMUM_ALLOCATION_SIZE;
- static char *last = (char *)malloc(last_size);
+ static char *last = static_cast<char *>(malloc(last_size));
if( (*walker & 0xFF) == 0xFF )
{
strcpy(first, walker);
while(index + strlen(first) + strlen(last) + 3 > buffer_size)
{
buffer_size *= 2;
- buffer = (char *)realloc(buffer, buffer_size);
+ buffer = static_cast<char *>(realloc(buffer, buffer_size));
}
strcpy(buffer+index, first);
index += strlen(first) + 1;
}
if( index > 0 )
{
- buffer = (char *)realloc(buffer, index);
+ buffer = static_cast<char *>(realloc(buffer, index));
local_initial = buffer;
}
}
// memory to the default. But if a parent has been initialized, we must not
// touch our memory:
bool a_parent_initialized = false;
- if( var->data && !explicitly )
+ if( !explicitly )
{
while(parent)
{
__gg__abort("Unknown variable type");
}
- char *location = (char *)save_the_location;
+ char *location = reinterpret_cast<char *>(save_the_location);
there_is_more = false;
size_t i=0;
}
}
- outer_location = (unsigned char *)location;
+ outer_location = reinterpret_cast<unsigned char *>(location);
} while(there_is_more);
var->data = save_the_location;
// and dest are alphanumeric
dest_length = dest_length ? dest_length : field->capacity;
- char *to = (char *)field->data + dest_offset;
+ char *to = reinterpret_cast<char *>(field->data + dest_offset);
const char *from = source_location;
size_t count = std::min(dest_length, source_length);
alpha_to_alpha_move(cblc_field_t *dest,
size_t dest_offset,
size_t dest_size,
- cblc_field_t *source,
+ const cblc_field_t *source,
size_t source_offset,
size_t source_size,
bool source_move_all)
alpha_to_alpha_move_from_location( dest,
dest_offset,
dest_size,
- (char *)(source->data + source_offset),
+ reinterpret_cast<char *>(source->data + source_offset),
source_size,
source_move_all);
}
{
int size_error = 0; // This is the return value
- bool moved = true;
-
__int128 value;
int rdigits;
- size_t min_length;
-
cbl_figconst_t source_figconst =
(cbl_figconst_t)(fsource->attr & FIGCONST_MASK);
cbl_field_type_t dest_type = (cbl_field_type_t)fdest->type;
* standard COBOL and its use should be avoided
*/
- int special_char;
+ int special_char = 0; // quiets cppcheck
if( source_figconst == low_value_e )
{
special_char = ascii_to_internal(__gg__low_value_character);
}
else
{
+ size_t min_length;
+ bool moved = true;
switch( dest_type )
{
case FldGroup:
// alphanumeric. We ignore any sign bit, and just
// move the characters:
- int rdigits;
- __int128 value;
-
size_t source_digits
= fsource->digits
+ ( fsource->rdigits < 0
fsource,
source_offset,
source_size);
- sprintf(ach, "%lu", (size_t)value);
+ sprintf(ach, "%lu", (unsigned long)value);
char *pach = ach;
{
rdigits = get_scaled_rdigits(fdest);
bool negative = false;
- __int128 value=0;
+ __int128 value128 = 0;
switch(fsource->capacity)
{
case 4:
{
- _Float32 val = *(_Float32 *)(fsource->data+source_offset);
+ _Float32 val = *PTRCAST(_Float32, fsource->data+source_offset);
if(val < 0)
{
negative = true;
val = -val;
}
- val *= (_Float32)__gg__power_of_ten(rdigits);
- value = (__int128)val;
+ val *= static_cast<_Float32>(__gg__power_of_ten(rdigits));
+ value128 = (__int128)val;
break;
}
case 8:
{
- _Float64 val = *(_Float64 *)(fsource->data+source_offset);
+ _Float64 val = *PTRCAST(_Float64, fsource->data+source_offset);
if(val < 0)
{
negative = true;
val = -val;
}
val *= (_Float32)__gg__power_of_ten(rdigits);
- value = (__int128)val;
+ value128 = (__int128)val;
break;
}
case 16:
val = -val;
}
val *= (_Float32)__gg__power_of_ten(rdigits);
- value = (__int128)val;
+ value128 = (__int128)val;
break;
}
}
if( negative )
{
- value = -value;
+ value128 = -value128;
}
__gg__int128_to_qualified_field(
fdest,
dest_offset,
dest_size,
- value,
+ value128,
rdigits,
rounded,
&size_error );
// We are converted a floating-point value fixed-point
rdigits = get_scaled_rdigits(fdest);
- GCOB_FP128 value=0;
+ GCOB_FP128 fp128=0;
switch(fsource->capacity)
{
case 4:
{
- value = *(_Float32 *)(fsource->data+source_offset);
+ fp128 = *reinterpret_cast<_Float32 *>(fsource->data+source_offset);
break;
}
case 8:
{
- value = *(_Float64 *)(fsource->data+source_offset);
+ fp128 = *reinterpret_cast<_Float64 *>(fsource->data+source_offset);
break;
}
case 16:
{
// value = *(_Float128 *)(fsource->data+source_offset);
- memcpy(&value, fsource->data+source_offset, 16);
+ memcpy(&fp128, fsource->data+source_offset, 16);
break;
}
}
__gg__float128_to_qualified_field(
fdest,
dest_offset,
- value,
+ fp128,
rounded,
&size_error);
break;
case FldNumericDisplay:
{
- int rdigits;
- __int128 value;
-
int source_digits = fsource->digits + (fsource->rdigits<0 ? -fsource->rdigits : 0) ;
// Pick up the absolute value of the source
}
// And move them into place:
- __gg__string_to_alpha_edited( (char *)(fdest->data+dest_offset),
+ __gg__string_to_alpha_edited( reinterpret_cast<char *>(fdest->data+dest_offset),
ach,
source_digits,
fdest->picture);
default:
{
static size_t display_string_size = MINIMUM_ALLOCATION_SIZE;
- static char *display_string = (char *)malloc(display_string_size);
+ static char *display_string = static_cast<char *>(malloc(display_string_size));
size_t display_string_length = dest_size;
__gg__realloc_if_necessary( &display_string,
&display_string,
&display_string_size,
fsource,
- (unsigned char *)(fsource->data+source_offset),
+ reinterpret_cast<unsigned char *>(fsource->data+source_offset),
source_size,
source_flags && REFER_T_ADDRESS_OF);
display_string_length = strlen(display_string);
}
- __gg__string_to_alpha_edited( (char *)(fdest->data+dest_offset),
+ __gg__string_to_alpha_edited( reinterpret_cast<char *>(fdest->data+dest_offset),
display_string,
display_string_length,
fdest->picture);
{
case 4:
{
- *(float *)(fdest->data+dest_offset) = strtof(ach, NULL);
+ *PTRCAST(float, fdest->data+dest_offset) = strtod(ach, NULL);
break;
}
case 8:
{
- *(double *)(fdest->data+dest_offset) = strtod(ach, NULL);
+ *PTRCAST(double, fdest->data+dest_offset) = strtod(ach, NULL);
break;
}
case 16:
memcpy(fdest->data+dest_offset, &t, 16);
break;
}
- break;
}
break;
}
case FldAlphaEdited:
{
static size_t display_string_size = MINIMUM_ALLOCATION_SIZE;
- static char *display_string = (char *)malloc(display_string_size);
+ static char *display_string = static_cast<char *>(malloc(display_string_size));
__gg__realloc_if_necessary( &display_string,
&display_string_size,
memset(display_string, internal_space, display_string_size);
size_t len = std::min(display_string_size, strlen);
memcpy(display_string, str, len);
- __gg__string_to_alpha_edited( (char *)(field->data+field_offset),
+ __gg__string_to_alpha_edited( reinterpret_cast<char *>(field->data+field_offset),
display_string,
field_size,
field->picture);
{
case 4:
{
- *(float *)(field->data+field_offset) = strtof(ach, NULL);
+ *PTRCAST(float, field->data+field_offset) = strtod(ach, NULL);
break;
}
case 8:
{
- *(double *)(field->data+field_offset) = strtod(ach, NULL);
+ *PTRCAST(double, field->data+field_offset) = strtod(ach, NULL);
break;
}
case 16:
memcpy(field->data+field_offset, &t, 16);
break;
}
- break;
}
break;
}
// Read the file into memory
size_t buffer_size = 128;
- unsigned char *contents = (unsigned char *)malloc(buffer_size);
+ unsigned char *contents = static_cast<unsigned char *>(malloc(buffer_size));
size_t offset = 0;
std::vector<size_t>offsets;
size_t bytes_read;
while( offset + sizeof(size_t) + bytes_read > buffer_size )
{
buffer_size *= 2;
- contents = (unsigned char *)realloc(contents, buffer_size);
+ contents = static_cast<unsigned char *>(realloc(contents, buffer_size));
}
offsets.push_back(offset);
return;
}
- unsigned char *prior_winner = (unsigned char *)malloc(the_biggest);
+ unsigned char *prior_winner = static_cast<unsigned char *>(malloc(the_biggest));
+ massert(prior_winner);
*prior_winner = '\0';
for(;;)
if( refer )
{
- unsigned char *data = refer->data + refer_o;
+ const unsigned char *data = refer->data + refer_o;
cbl_figconst_t figconst
= (cbl_figconst_t)(refer->attr & FIGCONST_MASK);
static
void
-inspect_backward_format_1(size_t integers[])
+inspect_backward_format_1(const size_t integers[])
{
size_t int_index = 0;
size_t cblc_index = 0;
std::vector<id_2_result> id_2_results(n_identifier_2);
// Pick up identifier_1, which is the string being inspected
- cblc_field_t *id1 = __gg__treeplet_1f[cblc_index];
- size_t id1_o = __gg__treeplet_1o[cblc_index];
- size_t id1_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id1 = __gg__treeplet_1f[cblc_index];
+ size_t id1_o = __gg__treeplet_1o[cblc_index];
+ size_t id1_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
// normalize it, according to the language specification.
normalized_operand normalized_id_1 = normalize_id(id1, id1_o, id1_s);
// We are counting characters. There is no identifier-3,
// but we we hard-code the length to one to represent a
// single character.
- comparand next_comparand;
+ comparand next_comparand = {};
next_comparand.id_2_index = i;
next_comparand.operation = operation;
next_comparand.identifier_3.length = 1;
- cblc_field_t *id4_before = __gg__treeplet_1f [cblc_index];
- size_t id4_before_o = __gg__treeplet_1o[cblc_index];
- size_t id4_before_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_before = __gg__treeplet_1f [cblc_index];
+ size_t id4_before_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_before_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_after = __gg__treeplet_1f [cblc_index];
- size_t id4_after_o = __gg__treeplet_1o[cblc_index];
- size_t id4_after_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_after = __gg__treeplet_1f [cblc_index];
+ size_t id4_after_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_after_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
normalized_operand normalized_id_4_before
for(size_t k=0; k<pair_count; k++)
{
- comparand next_comparand;
+ comparand next_comparand = {};
next_comparand.id_2_index = i;
next_comparand.operation = operation;
- cblc_field_t *id3 = __gg__treeplet_1f[cblc_index];
- size_t id3_o = __gg__treeplet_1o[cblc_index];
- size_t id3_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id3 = __gg__treeplet_1f[cblc_index];
+ size_t id3_o = __gg__treeplet_1o[cblc_index];
+ size_t id3_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
- size_t id4_before_o = __gg__treeplet_1o[cblc_index];
- size_t id4_before_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
+ size_t id4_before_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_before_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_after = __gg__treeplet_1f[cblc_index];
- size_t id4_after_o = __gg__treeplet_1o[cblc_index];
- size_t id4_after_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_after = __gg__treeplet_1f[cblc_index];
+ size_t id4_after_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_after_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
next_comparand.identifier_3
std::vector<id_2_result> id_2_results(n_identifier_2);
// Pick up identifier_1, which is the string being inspected
- cblc_field_t *id1 = __gg__treeplet_1f[cblc_index];
- size_t id1_o = __gg__treeplet_1o[cblc_index];
- size_t id1_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id1 = __gg__treeplet_1f[cblc_index];
+ size_t id1_o = __gg__treeplet_1o[cblc_index];
+ size_t id1_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
// normalize it, according to the language specification.
normalized_operand normalized_id_1
// We are counting characters. There is no identifier-3,
// but we we hard-code the length to one to represent a
// single character.
- comparand next_comparand;
+ comparand next_comparand = {};
next_comparand.id_2_index = i;
next_comparand.operation = operation;
next_comparand.identifier_3.length = 1;
- cblc_field_t *id4_before = __gg__treeplet_1f [cblc_index];
- size_t id4_before_o = __gg__treeplet_1o[cblc_index];
- size_t id4_before_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_before = __gg__treeplet_1f [cblc_index];
+ size_t id4_before_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_before_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_after = __gg__treeplet_1f [cblc_index];
- size_t id4_after_o = __gg__treeplet_1o[cblc_index];
- size_t id4_after_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_after = __gg__treeplet_1f [cblc_index];
+ size_t id4_after_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_after_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
normalized_operand normalized_id_4_before
for(size_t k=0; k<pair_count; k++)
{
- comparand next_comparand;
+ comparand next_comparand = {};
next_comparand.id_2_index = i;
next_comparand.operation = operation;
- cblc_field_t *id3 = __gg__treeplet_1f[cblc_index];
- size_t id3_o = __gg__treeplet_1o[cblc_index];
- size_t id3_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id3 = __gg__treeplet_1f[cblc_index];
+ size_t id3_o = __gg__treeplet_1o[cblc_index];
+ size_t id3_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
- size_t id4_before_o = __gg__treeplet_1o[cblc_index];
- size_t id4_before_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
+ size_t id4_before_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_before_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_after = __gg__treeplet_1f[cblc_index];
- size_t id4_after_o = __gg__treeplet_1o[cblc_index];
- size_t id4_after_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_after = __gg__treeplet_1f[cblc_index];
+ size_t id4_after_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_after_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
next_comparand.identifier_3
static
void
-inspect_backward_format_2(size_t integers[])
+inspect_backward_format_2(const size_t integers[])
{
size_t int_index = 0;
size_t cblc_index = 0;
{
case bound_characters_e:
{
- comparand next_comparand;
+ comparand next_comparand = {};
next_comparand.operation = operation;
- cblc_field_t *id5 = __gg__treeplet_1f[cblc_index];
- size_t id5_o = __gg__treeplet_1o[cblc_index];
- size_t id5_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id5 = __gg__treeplet_1f[cblc_index];
+ size_t id5_o = __gg__treeplet_1o[cblc_index];
+ size_t id5_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
- size_t id4_before_o = __gg__treeplet_1o[cblc_index];
- size_t id4_before_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
+ size_t id4_before_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_before_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_after = __gg__treeplet_1f [cblc_index];
- size_t id4_after_o = __gg__treeplet_1o[cblc_index];
- size_t id4_after_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_after = __gg__treeplet_1f [cblc_index];
+ size_t id4_after_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_after_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
next_comparand.identifier_5
for(size_t k=0; k<pair_count; k++)
{
- comparand next_comparand;
+ comparand next_comparand = {};
next_comparand.operation = operation;
- cblc_field_t *id3 = __gg__treeplet_1f[cblc_index];
- size_t id3_o = __gg__treeplet_1o[cblc_index];
- size_t id3_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id3 = __gg__treeplet_1f[cblc_index];
+ size_t id3_o = __gg__treeplet_1o[cblc_index];
+ size_t id3_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id5 = __gg__treeplet_1f[cblc_index];
- size_t id5_o = __gg__treeplet_1o[cblc_index];
- size_t id5_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id5 = __gg__treeplet_1f[cblc_index];
+ size_t id5_o = __gg__treeplet_1o[cblc_index];
+ size_t id5_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
- size_t id4_before_o = __gg__treeplet_1o[cblc_index];
- size_t id4_before_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
+ size_t id4_before_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_before_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_after = __gg__treeplet_1f[cblc_index];
- size_t id4_after_o = __gg__treeplet_1o[cblc_index];
- size_t id4_after_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_after = __gg__treeplet_1f[cblc_index];
+ size_t id4_after_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_after_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
next_comparand.identifier_3 = normalize_id(id3, id3_o, id3_s);
{
case bound_characters_e:
{
- comparand next_comparand;
+ comparand next_comparand = {} ;
next_comparand.operation = operation;
- cblc_field_t *id5 = __gg__treeplet_1f[cblc_index];
- size_t id5_o = __gg__treeplet_1o[cblc_index];
- size_t id5_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id5 = __gg__treeplet_1f[cblc_index];
+ size_t id5_o = __gg__treeplet_1o[cblc_index];
+ size_t id5_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
- size_t id4_before_o = __gg__treeplet_1o[cblc_index];
- size_t id4_before_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
+ size_t id4_before_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_before_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_after = __gg__treeplet_1f [cblc_index];
- size_t id4_after_o = __gg__treeplet_1o[cblc_index];
- size_t id4_after_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_after = __gg__treeplet_1f [cblc_index];
+ size_t id4_after_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_after_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
next_comparand.identifier_5
for(size_t k=0; k<pair_count; k++)
{
- comparand next_comparand;
+ comparand next_comparand = {};
next_comparand.operation = operation;
- cblc_field_t *id3 = __gg__treeplet_1f[cblc_index];
- size_t id3_o = __gg__treeplet_1o[cblc_index];
- size_t id3_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id3 = __gg__treeplet_1f[cblc_index];
+ size_t id3_o = __gg__treeplet_1o[cblc_index];
+ size_t id3_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id5 = __gg__treeplet_1f[cblc_index];
- size_t id5_o = __gg__treeplet_1o[cblc_index];
- size_t id5_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id5 = __gg__treeplet_1f[cblc_index];
+ size_t id5_o = __gg__treeplet_1o[cblc_index];
+ size_t id5_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
- size_t id4_before_o = __gg__treeplet_1o[cblc_index];
- size_t id4_before_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_before = __gg__treeplet_1f[cblc_index];
+ size_t id4_before_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_before_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
- cblc_field_t *id4_after = __gg__treeplet_1f[cblc_index];
- size_t id4_after_o = __gg__treeplet_1o[cblc_index];
- size_t id4_after_s = __gg__treeplet_1s[cblc_index];
+ const cblc_field_t *id4_after = __gg__treeplet_1f[cblc_index];
+ size_t id4_after_o = __gg__treeplet_1o[cblc_index];
+ size_t id4_after_s = __gg__treeplet_1s[cblc_index];
cblc_index += 1;
next_comparand.identifier_3 = normalize_id(id3, id3_o, id3_s);
static size_t psz_before_size = MINIMUM_ALLOCATION_SIZE;
static size_t psz_figstring_size = MINIMUM_ALLOCATION_SIZE;
- static char *psz_input = (char *)malloc(psz_input_size );
- static char *psz_original = (char *)malloc(psz_original_size );
- static char *psz_replacement = (char *)malloc(psz_replacement_size);
- static char *psz_after = (char *)malloc(psz_after_size );
- static char *psz_before = (char *)malloc(psz_before_size );
- static char *psz_figstring = (char *)malloc(psz_figstring_size );
+ static char *psz_input = static_cast<char *>(malloc(psz_input_size ));
+ static char *psz_original = static_cast<char *>(malloc(psz_original_size ));
+ static char *psz_replacement = static_cast<char *>(malloc(psz_replacement_size));
+ static char *psz_after = static_cast<char *>(malloc(psz_after_size ));
+ static char *psz_before = static_cast<char *>(malloc(psz_before_size ));
+ static char *psz_figstring = static_cast<char *>(malloc(psz_figstring_size ));
bool all = replacement_size == (size_t)(-1LL);
if( all )
}
char *pstart = NULL;
- char *pend = NULL;
+ const char *pend = NULL;
if( backward )
{
if( strlen(psz_before) )
case FldAlphanumeric:
case FldAlphaEdited:
{
- char *to = (char *)(field->data + offset);
+ char *to = reinterpret_cast<char *>(field->data + offset);
size_t dest_length = length ? length : field->capacity;
size_t source_length = strlen_from;
size_t count = std::min(dest_length, source_length);
extern "C"
int
-__gg__string(size_t integers[])
+__gg__string(const size_t integers[])
{
// The first integer is the count of identifier-2 values. Call it N
// The following N integers are the counts of each of the identifier-1 values,
// And so on
cblc_field_t **ref = __gg__treeplet_1f;
- size_t *ref_o = __gg__treeplet_1o;
- size_t *ref_s = __gg__treeplet_1s;
+ const size_t *ref_o = __gg__treeplet_1o;
+ const size_t *ref_s = __gg__treeplet_1s;
static const int INDEX_OF_POINTER = 1;
- size_t index_int = 0;
size_t index_cblc = 0 ;
char figlow[2] = {ascii_to_internal(__gg__low_value_character), 0x00};
fighigh[0] = ascii_to_internal(__gg__high_value_character);
}
- // Pick up the number of identifier-2 values
- size_t N = integers[index_int++];
// Pick up the target
- cblc_field_t *tgt = ref[index_cblc];
- size_t tgt_o = ref_o[index_cblc];
- size_t tgt_s = ref_s[index_cblc];
+ const cblc_field_t *tgt = ref[index_cblc];
+ size_t tgt_o = ref_o[index_cblc];
+ size_t tgt_s = ref_s[index_cblc];
index_cblc += 1;
- char *dest = (char *)(tgt->data + tgt_o);
+ char *dest = reinterpret_cast<char *>(tgt->data + tgt_o);
ssize_t dest_length = tgt_s;
// Skip over the index of POINTER:
{
// We are go for looping through identifier-2 values:
+ size_t index_int = 0;
+
+ // Pick up the number of identifier-2 values
+ size_t N = integers[index_int++];
+
for( size_t i=0; i<N; i++ )
{
size_t M = integers[index_int++];
// Pick up the identifier_2 DELIMITED BY value
- cblc_field_t *id2 = ref[index_cblc];
- size_t id2_o = ref_o[index_cblc];
- size_t id2_s = ref_s[index_cblc];
+ const cblc_field_t *id2 = ref[index_cblc];
+ size_t id2_o = ref_o[index_cblc];
+ size_t id2_s = ref_s[index_cblc];
index_cblc += 1;
char *piece;
- char *piece_end;
+ const char *piece_end;
cbl_figconst_t figconst = (cbl_figconst_t) ( id2
? (id2->attr & FIGCONST_MASK)
: 0 );
piece_end = piece + 1;
break;
default:
- piece = id2 ? (char *)(id2->data + id2_o) : NULL;
+ piece = id2 ? reinterpret_cast<char *>(id2->data + id2_o) : NULL;
piece_end = id2 ? piece + id2_s : NULL;
break;
}
- for(size_t i=0; i<M; i++)
+ for(size_t j=0; j<M; j++)
{
// Pick up the next identifier-1 source string:
- cblc_field_t *id1 = ref[index_cblc];
+ const cblc_field_t *id1 = ref[index_cblc];
size_t id1_o = ref_o[index_cblc];
size_t id1_s = ref_s[index_cblc];
index_cblc += 1;
- const char *whole = id1 ? (const char *)(id1->data + id1_o): NULL ;
+ const char *whole = id1 ? reinterpret_cast<char *>(id1->data + id1_o): NULL ;
const char *whole_end = id1 ? whole + id1_s : NULL;
// As usual, we need to cope with figurative constants:
- cbl_figconst_t figconst = (cbl_figconst_t) ( id1 ? (id1->attr & FIGCONST_MASK) : 0 );
+ figconst = (cbl_figconst_t) ( id1 ? (id1->attr & FIGCONST_MASK) : 0 );
switch( figconst )
{
case low_value_e:
whole, whole_end);
if(found)
{
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wcast-qual"
- char *wfound = (char *)found;
-#pragma GCC diagnostic pop
- whole_end = wfound;
+ whole_end = found;
}
}
while(whole < whole_end)
int advance )
{
static size_t display_string_size = MINIMUM_ALLOCATION_SIZE;
- static char *display_string = (char *)malloc(display_string_size);
+ static char *display_string = static_cast<char *>(malloc(display_string_size));
format_for_display_internal(&display_string,
&display_string_size,
// Let's honor the locale of the system, as best we can:
static size_t converted_size = MINIMUM_ALLOCATION_SIZE;
- static char *converted = (char *)malloc(converted_size);
+ static char *converted = static_cast<char *>(malloc(converted_size));
internal_to_console(&converted, &converted_size, display_string, strlen(display_string));
if(ss == -1)
{
fprintf(stderr, "__gg__display() %s %p\n", field->name, qual_data);
- fprintf(stderr, "__gg__display() %zd\n", converted_size);
+ fprintf(stderr, "__gg__display() %ld\n", static_cast<long>(converted_size));
fprintf(stderr, "__gg__display() ");
for(size_t i=0; i<converted_size; i++)
{
if( advance )
{
- ss = write( file_descriptor,
- "\n",
- 1);
+ write( file_descriptor,
+ "\n",
+ 1);
}
}
extern "C"
void
-__gg__display_string( int file_descriptor,
- char *str,
- size_t length,
- int advance )
+__gg__display_string( int file_descriptor,
+ const char *str,
+ size_t length,
+ int advance )
{
// Let's honor the locale of the system, as best we can:
static size_t converted_size = MINIMUM_ALLOCATION_SIZE;
- static char *converted = (char *)malloc(converted_size);
+ static char *converted = static_cast<char *>(malloc(converted_size));
size_t max_possible = 2 * length;
if( max_possible > converted_size )
{
converted_size = max_possible;
- converted = (char *)realloc(converted, converted_size);
+ converted = static_cast<char *>(realloc(converted, converted_size));
}
__gg__ascii_to_console(&converted, &converted_size, str, length);
}
}
- char *buffer = (char *)malloc(max_chars+1);
+ char *buffer = static_cast<char *>(malloc(max_chars+1));
+ massert(buffer);
memset(buffer, ascii_space, max_chars);
buffer[max_chars] = NULLCH;
size_t i = 0;
extern "C"
__int128
__gg__binary_value_from_qualified_field(int *rdigits,
- cblc_field_t *var,
+ const cblc_field_t *var,
size_t offset,
size_t size)
{
extern "C"
GCOB_FP128
-__gg__float128_from_qualified_field( cblc_field_t *field, size_t offset, size_t size)
+__gg__float128_from_qualified_field(const cblc_field_t *field, size_t offset, size_t size)
{
GCOB_FP128 retval=0;
if( field->type == FldFloat || field->type == FldLiteralN )
}
static __int128
-float128_to_int128( int *rdigits,
- cblc_field_t *field,
- GCOB_FP128 value,
- cbl_round_t rounded,
- int *compute_error)
+float128_to_int128( int *rdigits,
+ const cblc_field_t *field,
+ GCOB_FP128 value,
+ cbl_round_t rounded,
+ int *compute_error)
{
__int128 retval = 0;
if( value == INFINITY )
}
if( value < 0 )
{
- *(float *)(data) = -INFINITY;
+ *PTRCAST(float, data) = -INFINITY;
}
else
{
- *(float *)(data) = INFINITY;
+ *PTRCAST(float, data) = INFINITY;
}
}
else
{
- *(float *)(data) = (float)value;
+ *PTRCAST(float, data) = static_cast<float>(value);
}
break;
}
if( value < 0 )
{
- *(double *)(data) = -INFINITY;
+ *PTRCAST(double, data) = -INFINITY;
}
else
{
- *(double *)(data) = INFINITY;
+ *PTRCAST(double, data) = INFINITY;
}
}
else
{
- *(double *)(data) = (double)value;
+ *PTRCAST(double, data) = static_cast<double>(value);
}
break;
__int128 bit = 1;
char ach[129];
memset(ach, 0, sizeof(ach));
- char *p = getenv("UPSI");
+ const char *p = getenv("UPSI");
if( p )
{
snprintf(ach, sizeof(ach), "%s", p);
bool leading = !!(field->attr & leading_e);
bool separate = !!(field->attr & separate_e);
- char *digits = (char *)(field->data + offset);
+ char *digits = reinterpret_cast<char *>(field->data + offset);
char *digits_e = digits + size;
if( leading && separate && signable )
}
static int
-is_packed_numeric(cblc_field_t *field, size_t offset, size_t size)
+is_packed_numeric(const cblc_field_t *field, size_t offset, size_t size)
{
int retval = 1;
bool is_comp6 = !!(field->attr&packed_no_sign_e);
int digits = field->digits;
bool signable = !!(field->attr & signable_e);
- unsigned char *bytes = field->data + offset;
+ const unsigned char *bytes = field->data + offset;
int nybble = 0;
int nybble_e = nybble + digits;
}
static int
-is_alpha_a_number(cblc_field_t *field, size_t offset, size_t size)
+is_alpha_a_number(const cblc_field_t *field,
+ size_t offset,
+ size_t size)
{
int retval = 1;
- unsigned char *bytes = (field->data + offset);
+ const unsigned char *bytes = (field->data + offset);
for( size_t i=0; i<size; i++ )
{
unsigned char ch = bytes[i];
// The default answer is TRUE
int retval = 1;
- const unsigned char *alpha = (unsigned char *)(field->data+offset);
+ const unsigned char *alpha = reinterpret_cast<unsigned char *>(field->data+offset);
size_t str_length = size;
if( env_length < name_length+1 )
{
env_length = name_length+1;
- env = (char *)realloc(env, env_length);
+ env = static_cast<char *>(realloc(env, env_length));
}
memcpy(env, name->data + name_offset, name_length);
env[name_length] = '\0';
__gg__internal_to_console_in_place(trimmed_env, strlen(trimmed_env));
// Pick up the environment variable, and convert it to the internal codeset
- char *p = getenv(trimmed_env);
+ const char *p = getenv(trimmed_env);
if(p)
{
char *pp = strdup(p);
if( env_length < name_length+1 )
{
env_length = name_length+1;
- env = (char *)realloc(env, env_length);
+ env = static_cast<char *>(realloc(env, env_length));
}
if( val_length < value_length+1 )
{
val_length = value_length+1;
- val = (char *)realloc(val, val_length);
+ val = static_cast<char *>(realloc(val, val_length));
}
+ massert(val);
+ massert(env);
+
// The name and the value arrive in the internal codeset:
memcpy(env, name->data+name_offset , name_length);
env[name_length] = '\0';
if( bytes_read )
{
char *p = input;
- char *p_end = p + bytes_read;
+ const char *p_end = p + bytes_read;
char prior_char = '\0';
while( p < p_end )
{
if( prior_char == '\0' )
{
stashed_argc += 1;
- stashed_argv = (char **)realloc(stashed_argv,
- stashed_argc * sizeof(char *));
+ stashed_argv = static_cast<char **>(realloc(stashed_argv,
+ stashed_argc * sizeof(char *)));
stashed_argv[stashed_argc-1] = p;
}
prior_char = *p++;
int retcode;
command_line_plan_b();
size_t length = 1;
- char *retval = (char *)malloc(length);
+ char *retval = static_cast<char *>(malloc(length));
+ massert(retval);
*retval = NULLCH;
for( int i=1; i<stashed_argc; i++ )
while( strlen(retval) + strlen(stashed_argv[i]) + 2 > length )
{
length *= 2;
- retval = (char *)realloc(retval, length);
+ retval = static_cast<char *>(realloc(retval, length));
+ massert(retval);
}
if( *retval )
{
extern "C"
void
-__gg__set_pointer(cblc_field_t *target,
- size_t target_o,
- int target_flags,
- cblc_field_t *source,
- size_t source_o,
- int source_flags)
+__gg__set_pointer(cblc_field_t *target,
+ size_t target_o,
+ int target_flags,
+ const cblc_field_t *source,
+ size_t source_o,
+ int source_flags)
{
void *source_address;
if( source_flags & REFER_T_ADDRESS_OF )
// This is SET <something> TO POINTER
if( source )
{
- source_address = *(void **)(source->data + source_o);
+ source_address = *reinterpret_cast<void **>(source->data + source_o);
}
else
{
{
// This is SET ADDRESS OF target TO ....
// We know it has to be an unqualified LINKAGE level 01 or level 77
- target->data = (unsigned char *)source_address;
+ target->data = reinterpret_cast<unsigned char *>(source_address);
// The caller will propogate data + offset to their children.
}
else
// This is [almost certainly] INITIALIZE <pointer> when -fdefaultbyte
// was specified.
memset( target->data+target_o,
- *(unsigned char *)source_address,
+ *reinterpret_cast<unsigned char *>(source_address),
target->capacity);
}
else
{
- *(void **)(target->data+target_o) = source_address;
+ *reinterpret_cast<void **>(target->data+target_o) = source_address;
}
}
}
void
__gg__ascii_to_internal_field(cblc_field_t *var)
{
- ascii_to_internal_str((char *)var->data, var->capacity);
+ ascii_to_internal_str(reinterpret_cast<char *>(var->data), var->capacity);
}
extern "C"
__gg__internal_to_console_in_place(char *loc, size_t length)
{
static size_t dest_size = MINIMUM_ALLOCATION_SIZE;
- static char *dest = (char *)malloc(dest_size);
+ static char *dest = static_cast<char *>(malloc(dest_size));
internal_to_console(&dest, &dest_size, loc, length);
memcpy(loc, dest, length);
extern "C"
int
-__gg__routine_to_call(char *name,
- int program_id)
+__gg__routine_to_call(const char *name,
+ int program_id)
{
// The list of names is sorted, so at the very least this should be replaced
// with a binary search:
char **names = *(it->second);
int retval = -1;
- int i=0;
if( names )
{
+ int i=0;
while(*names)
{
if( strstr(*names, name) )
extern "C"
__int128
-__gg__fetch_call_by_value_value(cblc_field_t *field,
+__gg__fetch_call_by_value_value(const cblc_field_t *field,
size_t field_o,
size_t field_s)
{
int rdigits;
- unsigned char *data = field->data + field_o;
- size_t length = field_s;
+ unsigned char *data = field->data + field_o;
+ const size_t length = field_s;
__int128 retval = 0;
switch(field->type)
case FldAlphanumeric:
case FldAlphaEdited:
case FldLiteralA:
- retval = *(char *)data;
+ retval = *reinterpret_cast<char *>(data);
break;
case FldFloat:
switch(length)
{
case 4:
- *(float *)(&retval) = *(float *)data;
+ *PTRCAST(float, &retval) = *PTRCAST(float, data);
break;
case 8:
- *(double *)(&retval) = *(double *)data;
+ *PTRCAST(double, &retval) = *PTRCAST(double, data);
break;
case 16:
switch(dest->capacity)
{
case 4:
- *(float *)(dest->data) = *(float *)¶meter;
+ *PTRCAST(float, dest->data) = *PTRCAST(float, (¶meter));
break;
case 8:
- *(double *)(dest->data) = *(double *)¶meter;
+ *PTRCAST(double, dest->data) = *PTRCAST(double, (¶meter));
break;
case 16:
extern "C"
int
-__gg__literaln_alpha_compare(char *left_side,
- cblc_field_t *right,
- size_t offset,
- size_t length,
- int flags)
+__gg__literaln_alpha_compare(const char *left_side,
+ const cblc_field_t *right,
+ size_t offset,
+ size_t length,
+ int flags)
{
int retval;
if( length == 0 )
{
length = right->capacity;
}
- retval = compare_strings( (char *)left_side,
+ retval = compare_strings( left_side,
strlen(left_side),
false,
- (char *)right->data + offset,
+ reinterpret_cast<char *>((right->data + offset)),
length,
!!(flags & REFER_T_MOVE_ALL) );
return retval;
}
static char *
-string_in(char *str, char *str_e, char *frag, char *frag_e)
+string_in( char *str,
+ const char *str_e,
+ const char *frag,
+ const char *frag_e)
{
// This simple routine could be improved. Instead of using memcmp, we could
// use established, albeit complex, techniques of string searching:
extern "C"
int
-__gg__unstring( cblc_field_t *id1, // The string being unstring
- size_t id1_o,
- size_t id1_s,
+__gg__unstring( const cblc_field_t *id1, // The string being unstring
+ size_t id1_o,
+ size_t id1_s,
size_t ndelimiteds, // The number of DELIMITED entries
- char *all_flags, // The number of ALL flags, one per ndelimiteds
+ const char *all_flags, // The number of ALL flags, one per ndelimiteds
size_t nreceivers, // The number of DELIMITER receivers
cblc_field_t *id7, // The index of characters, both for starting updated at end
size_t id7_o,
// resolved. Each might have an identifier-5 delimiter, and each might have
// an identifier-6 count.
- cblc_field_t **id2 = __gg__treeplet_1f; // The delimiting strings; one per ndelimiteds
- size_t *id2_o = __gg__treeplet_1o;
- size_t *id2_s = __gg__treeplet_1s;
- cblc_field_t **id4 = __gg__treeplet_2f; // The delimited string; one per nreceiver
- size_t *id4_o = __gg__treeplet_2o;
- size_t *id4_s = __gg__treeplet_2s;
- cblc_field_t **id5 = __gg__treeplet_3f; // The delimiting string; one per receiver
- size_t *id5_o = __gg__treeplet_3o;
- size_t *id5_s = __gg__treeplet_3s;
- cblc_field_t **id6 = __gg__treeplet_4f; // The count of characters examined; one per receiver
- size_t *id6_o = __gg__treeplet_4o;
- size_t *id6_s = __gg__treeplet_4s;
+ // The delimiting strings; one per ndelimiteds
+ cblc_field_t **id2 = __gg__treeplet_1f;
+ const size_t *id2_o = __gg__treeplet_1o;
+ const size_t *id2_s = __gg__treeplet_1s;
+ // The delimited string; one per nreceiver
+ cblc_field_t **id4 = __gg__treeplet_2f;
+ const size_t *id4_o = __gg__treeplet_2o;
+ const size_t *id4_s = __gg__treeplet_2s;
+ // The delimiting string; one per receiver
+ cblc_field_t **id5 = __gg__treeplet_3f;
+ const size_t *id5_o = __gg__treeplet_3o;
+ const size_t *id5_s = __gg__treeplet_3s;
+ // The count of characters examined; one per receiver
+ cblc_field_t **id6 = __gg__treeplet_4f;
+ const size_t *id6_o = __gg__treeplet_4o;
+ const size_t *id6_s = __gg__treeplet_4s;
// Initialize the state variables
int overflow = 0;
goto done;
}
- left = (char *)(id1->data+id1_o) + pointer-1;
- right = (char *)(id1->data+id1_o) + id1_s;
+ left = reinterpret_cast<char *>(id1->data+id1_o) + pointer-1;
+ right = reinterpret_cast<char *>(id1->data+id1_o) + id1_s;
if( ndelimiteds == 0 )
{
default:
pfound = string_in( left,
right,
- (char *)(id2[i]->data+id2_o[i]),
- (char *)(id2[i]->data+id2_o[i]) + id2_s[i]);
+ reinterpret_cast<char *>(id2[i]->data+id2_o[i]),
+ reinterpret_cast<char *>((id2[i]->data+id2_o[i])
+ + id2_s[i]));
break;
}
else
{
move_string(id5[nreceiver], id5_o[nreceiver], id5_s[nreceiver],
- (char *)(id2[ifound]->data+id2_o[ifound]),
+ reinterpret_cast<char *>(id2[ifound]->data+id2_o[ifound]),
id2_s[ifound]);
}
}
local_ec_type_of( file_status_t status )
{
int status10 = (int)status / 10;
- assert( 0 <= status10 ); // was enum, can't be negative.
- if( 10 < status10 )
+ assert( 0 <= status10 ); // was enum, can't be negative.
+ if( 10 < status10 )
{
__gg__abort("local_ec_type_of(): status10 out of range");
}
-
+
static const std::vector<ec_type_t> ec_by_status {
/* 0 */ ec_none_e, // ec_io_warning_e if low byte is nonzero
- /* 1 */ ec_io_at_end_e,
+ /* 1 */ ec_io_at_end_e,
/* 2 */ ec_io_invalid_key_e,
/* 3 */ ec_io_permanent_error_e,
/* 4 */ ec_io_logic_error_e,
*/
struct exception_descr_t {
bool location;
- std::set<size_t> files;
+ //std::set<size_t> files;
};
struct cbl_exception_t {
- size_t program, file;
+// size_t program,
+ size_t file;
ec_type_t type;
cbl_file_mode_t mode;
};
{
#if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
/* Declared in errno.h, when available. */
- const char *ident = program_invocation_short_name;
+ static const char * const ident = program_invocation_short_name;
#elif defined (HAVE_GETPROGNAME)
/* Declared in stdlib.h. */
- const char *ident = getprogname();
+ static const char * const ident = getprogname();
#else
/* Avoid a NULL entry. */
- const char *ident = "unnamed_COBOL_program";
+ static const char * const ident = "unnamed_COBOL_program";
#endif
static bool first_time = true;
- static int priority = LOG_INFO, option = LOG_PERROR, facility = LOG_USER;
+ static const int priority = LOG_INFO, option = LOG_PERROR, facility = LOG_USER;
ec_disposition_t disposition = ec_category_fatal_e;
if( first_time ) {
* specific EC. It's matched based on the file's status, irrespective of
* whether or not EC-I-O is enabled. USE Format 1 Declaratives are honored
* regardless of any >>TURN directive.
- *
+ *
* An EC is enabled by the >>TURN directive. The only ECs that can be disabled
* are those that were explicitly enabled. If EC-I-O is enabled, and mentioned
* in a Declarative with USE Format 3, then it is matched just like any other.
auto ec = ec_status.update().unhandled();
- if( ec != ec_none_e ) {
+ if( ec != ec_none_e ) {
/*
- * An EC was raised and was not handled by the statement.
- * We know the EC and, for I/O, the current file and its mode.
- * Scan declaratives for a match:
+ * An EC was raised and was not handled by the statement.
+ * We know the EC and, for I/O, the current file and its mode.
+ * Scan declaratives for a match:
* - EC is enabled or program has a Format 1 Declarative
* - EC matches the Declarative's USE statement
- * Format 1 declaratives apply only to EC-I-O, whether or not enabled.
+ * Format 1 declaratives apply only to EC-I-O, whether or not enabled.
* Format 1 may be restricted to a particular mode (for all files).
- * Format 1 and 3 may be restricted to a set of files.
+ * Format 1 and 3 may be restricted to a set of files.
*/
auto f = ec_status.file_status();
- cbl_exception_t raised = { 0, f.ifile, ec, f.mode };
+ cbl_exception_t raised = { /*0,*/ f.ifile, ec, f.mode };
bool enabled = enabled_ECs.match(ec);
if( MATCH_DECLARATIVE ) enabled_ECs.dump("match_exception enabled");
p->section);
}
}
- assert(ec != ec_none_e);
- } // end EC match logic
+ assert(ec != ec_none_e);
+ } // end EC match logic
// If a declarative matches the raised exception, return its
// symbol_table index.
extern "C"
GCOB_FP128
-__gg__float128_from_location(cblc_field_t *var, unsigned char *location)
+__gg__float128_from_location( const cblc_field_t *var,
+ const unsigned char *location)
{
GCOB_FP128 retval = 0;
switch( var->capacity )
{
case 4:
{
- retval = *(_Float32 *)location;
+ retval = *reinterpret_cast<_Float32 *>(
+ const_cast<unsigned char *>(location));
break;
}
case 8:
{
- retval = *(_Float64 *)location;
+ retval = *reinterpret_cast<_Float64 *>(
+ const_cast<unsigned char *>(location));
break;
}
extern "C"
__int128
-__gg__integer_from_float128(cblc_field_t *field)
+__gg__integer_from_float128(const cblc_field_t *field)
{
GCOB_FP128 fvalue = __gg__float128_from_location(field, field->data);
// we round() to take care of the possible 2.99999999999... problem.
extern "C"
void
-__gg__set_exception_file(cblc_file_t *file)
+__gg__set_exception_file(const cblc_file_t *file)
{
ec_type_t ec = local_ec_type_of( file->io_status );
if( ec )
extern "C"
void
-__gg__func_exception_file(cblc_field_t *dest, cblc_file_t *file)
+__gg__func_exception_file(cblc_field_t *dest,
+ const cblc_file_t *file)
{
char ach[128];
if( !file )
last_exception_statement = __gg__exception_statement ;
// These are set in __gg__set_exception_file just before this routine is
- // called. In cases where the ec is not a file-i-o operation, we clear
+ // called. In cases where the ec is not a file-i-o operation, we clear
// them here:
if( !(ec & ec_io_e) )
{
extern "C"
int
-__gg__is_float_infinite(cblc_field_t *source, size_t offset)
+__gg__is_float_infinite(const cblc_field_t *source, size_t offset)
{
int retval = 0;
switch(source->capacity)
{
case 4:
- retval = fpclassify( *(_Float32*)(source->data+offset)) == FP_INFINITE;
+ retval = fpclassify( *reinterpret_cast<_Float32*>(source->data+offset)) == FP_INFINITE;
break;
case 8:
- retval = fpclassify( *(_Float64*)(source->data+offset)) == FP_INFINITE;
+ retval = fpclassify( *reinterpret_cast<_Float64*>(source->data+offset)) == FP_INFINITE;
break;
case 16:
// retval = *(_Float128*)(source->data+offset) == INFINITY;
extern "C"
int
-__gg__float32_from_128( cblc_field_t *dest,
- size_t dest_offset,
- cblc_field_t *source,
- size_t source_offset)
+__gg__float32_from_128( const cblc_field_t *dest,
+ size_t dest_offset,
+ const cblc_field_t *source,
+ size_t source_offset)
{
int retval = 0;
//_Float128 value = *(_Float128*)(source->data+source_offset);
}
else
{
- *(_Float32 *)(dest->data+dest_offset) = (_Float32)value;
+ *reinterpret_cast<_Float32 *>(dest->data+dest_offset) = (_Float32)value;
}
return retval;
}
extern "C"
int
-__gg__float32_from_64( cblc_field_t *dest,
- size_t dest_offset,
- cblc_field_t *source,
- size_t source_offset)
+__gg__float32_from_64( const cblc_field_t *dest,
+ size_t dest_offset,
+ const cblc_field_t *source,
+ size_t source_offset)
{
int retval = 0;
- _Float64 value = *(_Float64*)(source->data+source_offset);
+ _Float64 value = *reinterpret_cast<_Float64*>(source->data+source_offset);
if( FP128_FUNC(fabs)(value) > GCOB_FP128_LITERAL (3.4028235E38) )
{
retval = 1;
}
else
{
- *(_Float32 *)(dest->data+dest_offset) = (_Float32)value;
+ *reinterpret_cast<_Float32 *>(dest->data+dest_offset) = (_Float32)value;
}
return retval;
}
extern "C"
int
-__gg__float64_from_128( cblc_field_t *dest,
- size_t dest_offset,
- cblc_field_t *source,
- size_t source_offset)
+__gg__float64_from_128( const cblc_field_t *dest,
+ size_t dest_offset,
+ const cblc_field_t *source,
+ size_t source_offset)
{
int retval = 0;
// _Float128 value = *(_Float128*)(source->data+source_offset);
}
else
{
- *(_Float64 *)(dest->data+dest_offset) = (_Float64)value;
+ *reinterpret_cast<_Float64 *>(dest->data+dest_offset) = (_Float64)value;
}
return retval;
}
extern "C"
void
-__gg__copy_as_big_endian(unsigned char *dest, unsigned char *source)
+__gg__copy_as_big_endian( unsigned char *dest,
+ const unsigned char *source)
{
// copy eight bytes of source to dest, flipping the endianness
for(size_t i=0; i<8; i++)
extern "C"
unsigned char *
-__gg__get_figconst_data(cblc_field_t *field)
+__gg__get_figconst_data(const cblc_field_t *field)
{
unsigned char *retval = NULL;
cbl_figconst_t figconst = (cbl_figconst_t)(size_t)(field->initial);
{
while( !retval )
{
- dirent *entry = readdir(dir);
+ const dirent *entry = readdir(dir);
if( !entry )
{
break;
{
handle_executable = dlopen(NULL, RTLD_LAZY);
}
- if( !retval )
+ //if( !retval )
{
retval = dlsym(handle_executable, unmangled_name);
}
extern "C"
void
-__gg__just_mangle_name( cblc_field_t *field,
- char **mangled_name
+__gg__just_mangle_name( const cblc_field_t *field,
+ char **mangled_name
)
{
static char ach_name[1024];
static char ach_unmangled[1024];
static char ach_mangled[1024];
+ assert(field);
+ assert(field->data);
+
size_t length;
length = field->capacity;
memcpy(ach_name, field->data, length);
bool is_pointer = false;
- if( (field && field->type == FldPointer) )
+ if( field->type == FldPointer )
{
is_pointer = true;
}
extern "C"
void *
-__gg__function_handle_from_literal(int program_id,
- char *literal)
+__gg__function_handle_from_literal(int program_id,
+ const char *literal)
{
void *retval = NULL;
static char ach_unmangled[1024];
}
PFUNC **pointers_p = it->second;
PFUNC *pointers = *pointers_p;
- retval = (void *)pointers[function_index];
+ retval = reinterpret_cast<void *>(pointers[function_index]);
}
else
{
extern "C"
void *
-__gg__function_handle_from_name(int program_id,
- cblc_field_t *field,
- size_t offset,
- size_t length )
+__gg__function_handle_from_name(int program_id,
+ const cblc_field_t *field,
+ size_t offset,
+ size_t length )
{
void *retval = NULL;
static char ach_name[1024];
}
PFUNC **pointers_p = it->second;
PFUNC *pointers = *pointers_p;
- retval = (void *)pointers[function_index];
+ retval = reinterpret_cast<void *>(pointers[function_index]);
}
else
{
cblc_field_t *src, // The row
size_t src_o,
size_t nspans, // The number of spans
- size_t *spans,
+ const size_t *spans,
size_t table,
size_t ntbl,
- size_t *tbls)
+ const size_t *tbls)
{
static std::unordered_map<size_t, size_t> rows_in_table;
static std::unordered_map<size_t, size_t> widths_of_table;
// We need to know the width of one row of this table, which is different
// depending on type of src:
- cblc_field_t *parent = src;
+ const cblc_field_t *parent = src;
while( parent )
{
if( parent->occurs_upper )
std::vector<size_t> subtable_spans
= spans_in_table [subtable_index];
- unsigned char *subtable_source = source + subtable_offset;
+ const unsigned char *subtable_source = source + subtable_offset;
if( subtable_spans.size() == 0 )
{
{
// Target is a pointer. Free the data location
int rdigits;
- void *ptr = (void *)get_binary_value_local(&rdigits,
+ size_t addrv = get_binary_value_local(&rdigits,
target,
target->data + offset,
sizeof(void *));
+ void *ptr = reinterpret_cast<void *>(addrv);
if( ptr )
{
free(ptr);
// And set the data location to zero
- *(char **)(target->data + offset) = NULL;
+ *static_cast<char **>(static_cast<void *>(target->data + offset))
+ = NULL;
}
}
}
extern "C"
void
-__gg__allocate( cblc_field_t *first,
- size_t first_offset,
- int initialized,
- int default_byte,
- cblc_field_t *f_working_byte,
- cblc_field_t *f_local_byte,
- cblc_field_t *returning,
- size_t returning_offset)
+__gg__allocate( cblc_field_t *first,
+ size_t first_offset,
+ int initialized,
+ int default_byte,
+ cblc_field_t *f_working_byte,
+ cblc_field_t *f_local_byte,
+ const cblc_field_t *returning,
+ size_t returning_offset)
{
int working_byte = get_the_byte(f_working_byte);
int local_byte = get_the_byte(f_local_byte);
+ int fill_char;
unsigned char *retval = NULL;
if( first->attr & based_e )
// first is the BASED variable we are allocating memory for
if( first->capacity )
{
- retval = (unsigned char *)malloc(first->capacity);
+ retval = static_cast<unsigned char *>(malloc(first->capacity));
+ fill_char = 0;
if( initialized )
{
// This is ISO 2023 ALLOCATE rule 7 (ALL TO VALUE)
- int fill_char = 0;
if( default_byte >= 0 )
{
fill_char = default_byte;
else
{
// This is ISO 2023 ALLOCATE rule 9 (pointers NULL, otherwise OPT_INIT)
- int fill_char = 0;
if( default_byte >= 0 )
{
fill_char = default_byte;
tsize /= pof10;
if( tsize )
{
- retval = (unsigned char *)malloc(tsize);
+ retval = static_cast<unsigned char *>(malloc(tsize));
+ if(!retval)
+ {
+ abort();
+ }
- int fill_char = 0;
+ fill_char = 0;
if( initialized )
{
// This is ISO 2023 rule 6 (defaultbyte if specified, else zero)
if( returning )
{
// 'returning' has to be a FldPointer variable; assign the retval to it.
- *(unsigned char **)(returning->data + returning_offset) = retval;
+ *reinterpret_cast<unsigned char **>(returning->data + returning_offset) = retval;
}
}
__gg__module_name(cblc_field_t *dest, module_type_t type)
{
static size_t result_size = 64;
- static char *result = (char *)malloc(result_size);
+ static char *result = static_cast<char *>(malloc(result_size));
+ massert(result);
strcpy(result, "");
if( strlen(result) + module_name_stack[i].substr(1).length() + 4 > result_size)
{
result_size *= 2;
- result = (char *)realloc(result, result_size);
+ result = static_cast<char *>(realloc(result, result_size));
}
strcat(result, module_name_stack[i].substr(1).c_str());
strcat(result, ";");
extern "C"
void
-__gg__set_env_name( cblc_field_t *var,
- size_t offset,
- size_t length )
+__gg__set_env_name( const cblc_field_t *var,
+ size_t offset,
+ size_t length )
{
free(sv_envname);
- sv_envname = (char *)malloc(length+1);
+ sv_envname = static_cast<char *>(malloc(length+1));
+ massert(sv_envname);
memcpy(sv_envname, var->data+offset, length);
sv_envname[length] = '\0';
}
extern "C"
void
-__gg__set_env_value(cblc_field_t *value,
- size_t offset,
- size_t length )
+__gg__set_env_value(const cblc_field_t *value,
+ size_t offset,
+ size_t length )
{
size_t name_length = strlen(sv_envname);
size_t value_length = length;
- static char *env = NULL;
- static size_t env_length = 0;
- static char *val = NULL;
- static size_t val_length = 0;
+ static size_t env_length = 16;
+ static char *env = static_cast<char *>(malloc(env_length+1));
+ static size_t val_length = 16;
+ static char *val = static_cast<char *>(malloc(val_length+1));
if( env_length < name_length+1 )
{
env_length = name_length+1;
- env = (char *)realloc(env, env_length);
+ env = static_cast<char *>(realloc(env, env_length));
}
if( val_length < value_length+1 )
{
val_length = value_length+1;
- val = (char *)realloc(val, val_length);
+ val = static_cast<char *>(realloc(val, val_length));
}
+ massert(env);
+ massert(val);
// The name and the value arrive in the internal codeset:
memcpy(env, sv_envname, name_length);
projects / thirdparty / gcc.git / commitdiff
