int
main (int argc, char *argv[])
{
#ifdef WITH_FPU_CONTROL
fpu_control_t cw;
/* cw=895 (0x037f): round to double extended precision
cw=639 (0x027f): round to double precision
cw=127 (0x007f): round to single precision */
if (argc > 1)
{
cw = strtol(argv[1], NULL, 0);
printf ("FPU control word: 0x%x\n", (unsigned int) cw);
_FPU_SETCW (cw);
}
#endif
tests_start_mpfr ();
check_special ();
check_large ();
check_small ();
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
tests_start_mpfr ();
check_inexact ();
check_hard ();
check_special ();
check_lowr ();
check_float (); /* checks single precision */
check_double ();
check_convergence ();
check_64 ();
check4("4.0","4.503599627370496e15", MPFR_RNDZ, 62,
"0.10000000000000000000000000000000000000000000000000000000000000E-49");
check4("1.0","2.10263340267725788209e+187", MPFR_RNDU, 65,
"0.11010011111001101011111001100111110100000001101001111100111000000E-622");
check4("2.44394909079968374564e-150", "2.10263340267725788209e+187",MPFR_RNDU,
65,
"0.11010011111001101011111001100111110100000001101001111100111000000E-1119");
consistency ();
test_20070603 ();
test_20070628 ();
test_generic (2, 800, 50);
tests_end_mpfr ();
return 0;
}
void extract_data(t_env *env, t_data **room)
{
char *line;
int type;
t_data *temp;
get_ant_numbers(env);
temp = *room;
while (get_next_line(0, &line) && ft_printf("%s\n", line))
{
type = what_type(line);
if (type == 1)
get_link(line, temp);
else if (type == 2)
get_room(line, &temp, env);
else if (type == 3)
;
else if (type == 4)
env->type = check_special(line, env);
else
{
ft_putstr("error: invalid line\n");
exit(0);
}
free(line);
}
*room = temp;
}
int
main (int argc, char *argv[])
{
tests_start_mpfr ();
check_inexact ();
check_special ();
test_generic (2, 100, 100);
compare_exp2_exp3(500);
check_worst_cases();
check3("0.0", GMP_RNDU, "1.0");
check3("-1e-170", GMP_RNDU, "1.0");
check3("-1e-170", GMP_RNDN, "1.0");
check3("-8.88024741073346941839e-17", GMP_RNDU, "1.0");
check3("8.70772839244701057915e-01", GMP_RNDN, "2.38875626491680437269");
check3("1.0", GMP_RNDN, "2.71828182845904509080");
check3("-3.42135637628104173534e-07", GMP_RNDZ, "0.999999657864420798958");
/* worst case for argument reduction, very near from 5*log(2),
thanks to Jean-Michel Muller */
check3("3.4657359027997265421", GMP_RNDN, "32.0");
check3("3.4657359027997265421", GMP_RNDU, "32.0");
check3("3.4657359027997265421", GMP_RNDD, "31.999999999999996447");
check3("2.26523754332090625496e+01", GMP_RNDD, "6.8833785261699581146e9");
check3("1.31478962104089092122e+01", GMP_RNDZ, "5.12930793917860137299e+05");
check3("4.25637507920002378103e-01", GMP_RNDU, "1.53056585656161181497e+00");
check3("6.26551618962329307459e-16", GMP_RNDU, "1.00000000000000066613e+00");
check3("-3.35589513871216568383e-03",GMP_RNDD, "9.96649729583626853291e-01");
check3("1.95151388850007272424e+01", GMP_RNDU, "2.98756340674767792225e+08");
check3("2.45045953503350730784e+01", GMP_RNDN, "4.38743344916128387451e+10");
check3("2.58165606081678085104e+01", GMP_RNDD, "1.62925781879432281494e+11");
check3("-2.36539020084338638128e+01",GMP_RNDZ, "5.33630792749924762447e-11");
check3("2.39211946135858077866e+01", GMP_RNDU, "2.44817704330214385986e+10");
check3("-2.78190533055889162029e+01",GMP_RNDZ, "8.2858803483596879512e-13");
check3("2.64028186174889789584e+01", GMP_RNDD, "2.9281844652878973388e11");
check3("2.92086338843268329413e+01", GMP_RNDZ, "4.8433797301907177734e12");
check3("-2.46355324071459982349e+01",GMP_RNDZ, "1.9995129297760994791e-11");
check3("-2.23509444608605427618e+01",GMP_RNDZ, "1.9638492867489702307e-10");
check3("-2.41175390197331687148e+01",GMP_RNDD, "3.3564940885530624592e-11");
check3("2.46363885231578088053e+01", GMP_RNDU, "5.0055014282693267822e10");
check3("111.1263531080090984914932050742208957672119140625", GMP_RNDN, "1.8262572323517295459e48");
check3("-3.56196340354684821250e+02",GMP_RNDN, "2.0225297096141478156e-155");
check3("6.59678273772710895173e+02", GMP_RNDU, "3.1234469273830195529e286");
check3("5.13772529701934331570e+02", GMP_RNDD, "1.3445427121297197752e223");
check3("3.57430211008718345056e+02", GMP_RNDD, "1.6981197246857298443e155");
check3("3.82001814471465536371e+02", GMP_RNDU, "7.9667300591087367805e165");
check3("5.92396038219384422518e+02", GMP_RNDD, "1.880747529554661989e257");
check3("-5.02678550462488090034e+02",GMP_RNDU, "4.8919201895446217839e-219");
check3("5.30015757134837031117e+02", GMP_RNDD, "1.5237672861171573939e230");
check3("5.16239362447650933063e+02", GMP_RNDZ, "1.5845518406744492105e224");
check3("6.00812634798592370977e-01", GMP_RNDN, "1.823600119339019443");
check_exp10 ();
tests_end_mpfr ();
return 0;
}
int
main (void)
{
mpfr_t x, y, z, u;
int inexact;
mpfr_exp_t emax;
tests_start_mpfr ();
/* check prototypes of mpfr_init_set_* */
inexact = mpfr_init_set_si (x, -1, MPFR_RNDN);
inexact = mpfr_init_set (y, x, MPFR_RNDN);
inexact = mpfr_init_set_ui (z, 1, MPFR_RNDN);
inexact = mpfr_init_set_d (u, 1.0, MPFR_RNDN);
emax = mpfr_get_emax ();
set_emax (0);
mpfr_set_prec (x, 3);
mpfr_set_str_binary (x, "0.111");
mpfr_set_prec (y, 2);
mpfr_set (y, x, MPFR_RNDU);
if (!(MPFR_IS_INF (y) && MPFR_SIGN (y) > 0))
{
printf ("Error for y=x=0.111 with px=3, py=2 and emax=0\nx=");
mpfr_dump (x);
printf ("y=");
mpfr_dump (y);
exit (1);
}
set_emax (emax);
mpfr_set_prec (y, 11);
mpfr_set_str_binary (y, "0.11111111100E-8");
mpfr_set_prec (x, 2);
mpfr_set (x, y, MPFR_RNDN);
mpfr_set_str_binary (y, "1.0E-8");
if (mpfr_cmp (x, y))
{
printf ("Error for y=0.11111111100E-8, prec=2, rnd=MPFR_RNDN\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (u);
check_ternary_value ();
check_special ();
check_neg_special ();
test_generic (2, 1000, 10);
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
tests_start_mpfr ();
check_special ();
check_sgn ();
tests_end_mpfr ();
return 0;
}
awk_bool_t
make_builtin(const awk_ext_func_t *funcinfo)
{
NODE *symbol, *f;
INSTRUCTION *b;
const char *sp;
char c;
const char *name = funcinfo->name;
int count = funcinfo->num_expected_args;
sp = name;
if (sp == NULL || *sp == '\0')
fatal(_("make_builtin: missing function name"));
if (! is_letter(*sp))
return awk_false;
for (sp++; (c = *sp++) != '\0';) {
if (! is_identifier_char(c))
return awk_false;
}
f = lookup(name);
if (f != NULL) {
if (f->type == Node_func) {
/* user-defined function */
fatal(_("make_builtin: can't redefine function `%s'"), name);
} else if (f->type == Node_ext_func) {
/* multiple extension() calls etc. */
if (do_lint)
lintwarn(_("make_builtin: function `%s' already defined"), name);
return awk_false;
} else
/* variable name etc. */
fatal(_("make_builtin: function name `%s' previously defined"), name);
} else if (check_special(name) >= 0)
fatal(_("make_builtin: can't use gawk built-in `%s' as function name"), name);
if (count < 0)
fatal(_("make_builtin: negative argument count for function `%s'"),
name);
b = bcalloc(Op_symbol, 1, 0);
b->extfunc = funcinfo->function;
b->expr_count = count;
/* NB: extension sub must return something */
symbol = install_symbol(estrdup(name, strlen(name)), Node_ext_func);
symbol->code_ptr = b;
track_ext_func(name);
return awk_true;
}
int
main (void)
{
test_start ();
check_special ();
test_end ();
return 0;
}
int
main (int argc, char *argv[])
{
int N;
tests_start_mpfr ();
/* with no argument: prints to /dev/null,
tprintf N: prints N tests to stdout */
if (argc == 1)
{
N = 1000;
stdout_redirect = 1;
if (freopen ("/dev/null", "w", stdout) == NULL)
{
/* We failed to open this device, try with a dummy file */
if (freopen ("mpfrtest.txt", "w", stdout) == NULL)
{
/* Output the error message to stderr since it is not
a message about a wrong result in MPFR. Anyway the
stdandard output may have changed. */
fprintf (stderr, "Can't open /dev/null or a temporary file\n");
exit (1);
}
}
}
else
{
stdout_redirect = 0;
N = atoi (argv[1]);
}
check_invalid_format ();
check_special ();
check_mixed ();
/* expensive tests */
if (getenv ("MPFR_CHECK_LARGEMEM") != NULL)
check_long_string();
check_random (N);
test_locale ();
if (stdout_redirect)
{
if ((fflush (stdout) == EOF) || (fclose (stdout) == -1))
perror ("main");
}
tests_end_mpfr ();
return 0;
}
void
make_old_builtin(const char *name, NODE *(*func)(int), int count) /* temporary */
{
NODE *symbol, *f;
INSTRUCTION *b;
const char *sp;
char c;
sp = name;
if (sp == NULL || *sp == '\0')
fatal(_("extension: missing function name"));
if (! is_letter(*sp))
fatal(_("extension: illegal character `%c' in function name `%s'"), *sp, name);
for (sp++; (c = *sp++) != '\0';) {
if (! is_identifier_char(c))
fatal(_("extension: illegal character `%c' in function name `%s'"), c, name);
}
f = lookup(name);
if (f != NULL) {
if (f->type == Node_func) {
/* user-defined function */
fatal(_("extension: can't redefine function `%s'"), name);
} else if (f->type == Node_ext_func) {
/* multiple extension() calls etc. */
if (do_lint)
lintwarn(_("extension: function `%s' already defined"), name);
return;
} else
/* variable name etc. */
fatal(_("extension: function name `%s' previously defined"), name);
} else if (check_special(name) >= 0)
fatal(_("extension: can't use gawk built-in `%s' as function name"), name);
if (count < 0)
fatal(_("make_builtin: negative argument count for function `%s'"),
name);
b = bcalloc(Op_symbol, 1, 0);
b->builtin = func;
b->expr_count = count;
/* NB: extension sub must return something */
symbol = install_symbol(estrdup(name, strlen(name)), Node_old_ext_func);
symbol->code_ptr = b;
track_ext_func(name);
}
int
main (void)
{
mpfr_prec_t p;
tests_start_mpfr ();
check_special ();
for (p = 2 ; p < 200 ; p++)
check_random (p);
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
tests_start_mpfr ();
check_special();
check_reftable ();
check_parse ();
check_overflow ();
check_retval ();
bug20081028 ();
test20100310 ();
tests_end_mpfr ();
return 0;
}
int
main (void)
{
mpfr_prec_t p;
unsigned long n;
tests_start_mpfr ();
check_special ();
test_sort (1764, 1026);
for (p = 2 ; p < 444 ; p += 17)
for (n = 2 ; n < 1026 ; n += 42 + p)
test_sum (p, n);
tests_end_mpfr ();
return 0;
}
int
main (void)
{
mpfr_prec_t p;
tests_start_mpfr ();
check_special ();
for (p = 2; p < 200; p++)
check_random (p);
test_generic (2, 200, 15);
data_check ("data/sqr", mpfr_sqr, "mpfr_sqr");
bad_cases (mpfr_sqr, mpfr_sqrt, "mpfr_sqr", 8, -256, 255, 4, 128, 800, 50);
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
FILE *fout;
int N;
tests_start_mpfr ();
/* with no argument: prints to /dev/null,
tfprintf N: prints N tests to stdout */
if (argc == 1)
{
N = 1000;
fout = fopen ("/dev/null", "w");
/* If we failed to open this device, try with a dummy file */
if (fout == NULL)
{
fout = fopen ("mpfrtest.txt", "w");
if (fout == NULL)
{
printf ("Can't open /dev/null or a temporary file\n");
exit (1);
}
}
}
else
{
fout = stdout;
N = atoi (argv[1]);
}
check_special (fout);
check_mixed (fout);
check_random (fout, N);
bug_20090316 (fout);
fclose (fout);
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
int h;
if (argc == 5)
{
check_random (atoi (argv[1]), atoi (argv[2]), atoi (argv[3]),
(mpfr_rnd_t) atoi (argv[4]));
return 0;
}
tests_start_mpfr ();
if (argc != 1)
{
fprintf (stderr, "Usage: tsum\n tsum n k prec rnd\n");
exit (1);
}
check_simple ();
check_special ();
check_more_special ();
for (h = 0; h <= 64; h++)
check1 (h);
check2 ();
check3 ();
check4 ();
bug20131027 ();
bug20150327 ();
bug20160315 ();
generic_tests ();
check_extreme ();
cancel ();
check_overflow ();
check_underflow ();
check_coverage ();
tests_end_mpfr ();
return 0;
}
int
main (int argc, char* argv[])
{
tests_start_mpfr ();
check_special ();
check_large ();
check4 ("2.0", "1.0", MPFR_RNDN, "1.456791031046906869", -1);
check4 ("6.0", "4.0", MPFR_RNDN, "4.949360872472608925", 1);
check4 ("62.0", "61.0", MPFR_RNDN, "61.498983718845075902", -1);
check4 ("0.5", "1.0", MPFR_RNDN, "0.72839551552345343459", -1);
check4 ("1.0", "2.0", MPFR_RNDN, "1.456791031046906869", -1);
check4 ("234375765.0", "234375000.0", MPFR_RNDN, "234375382.49984394025", 1);
check4 ("8.0", "1.0", MPFR_RNDU, "3.61575617759736274873", 1);
check4 ("1.0", "44.0", MPFR_RNDU, "13.3658354512981243907", 1);
check4 ("1.0", "3.7252902984619140625e-9", MPFR_RNDU,
"0.07553933569711989657765", 1);
test_generic (2, 300, 17);
tests_end_mpfr ();
return 0;
}
static int linenoiseEdit(struct current *current) {
int history_index = 0;
/* The latest history entry is always our current buffer, that
* initially is just an empty string. */
linenoiseHistoryAdd("");
set_current(current, "");
refreshLine(current->prompt, current);
while(1) {
int dir = -1;
int c = fd_read(current);
#ifndef NO_COMPLETION
/* Only autocomplete when the callback is set. It returns < 0 when
* there was an error reading from fd. Otherwise it will return the
* character that should be handled next. */
if (c == '\t' && current->pos == current->chars && completionCallback != NULL) {
c = completeLine(current);
/* Return on errors */
if (c < 0) return current->len;
/* Read next character when 0 */
if (c == 0) continue;
}
#endif
process_char:
if (c == -1) return current->len;
#ifdef USE_TERMIOS
if (c == 27) { /* escape sequence */
c = check_special(current->fd);
}
#endif
switch(c) {
case '\r': /* enter */
history_len--;
free(history[history_len]);
return current->len;
case ctrl('C'): /* ctrl-c */
errno = EAGAIN;
return -1;
case 127: /* backspace */
case ctrl('H'):
if (remove_char(current, current->pos - 1) == 1) {
refreshLine(current->prompt, current);
}
break;
case ctrl('D'): /* ctrl-d */
if (current->len == 0) {
/* Empty line, so EOF */
history_len--;
free(history[history_len]);
return -1;
}
/* Otherwise fall through to delete char to right of cursor */
case SPECIAL_DELETE:
if (remove_char(current, current->pos) == 1) {
refreshLine(current->prompt, current);
}
break;
case SPECIAL_INSERT:
/* Ignore. Expansion Hook.
* Future possibility: Toggle Insert/Overwrite Modes
*/
break;
case ctrl('W'): /* ctrl-w, delete word at left. save deleted chars */
/* eat any spaces on the left */
{
int pos = current->pos;
while (pos > 0 && get_char(current, pos - 1) == ' ') {
pos--;
}
/* now eat any non-spaces on the left */
while (pos > 0 && get_char(current, pos - 1) != ' ') {
pos--;
}
if (remove_chars(current, pos, current->pos - pos)) {
refreshLine(current->prompt, current);
}
}
break;
case ctrl('R'): /* ctrl-r */
{
/* Display the reverse-i-search prompt and process chars */
char rbuf[50];
char rprompt[80];
int rchars = 0;
int rlen = 0;
int searchpos = history_len - 1;
rbuf[0] = 0;
while (1) {
int n = 0;
const char *p = NULL;
int skipsame = 0;
int searchdir = -1;
snprintf(rprompt, sizeof(rprompt), "(reverse-i-search)'%s': ", rbuf);
refreshLine(rprompt, current);
c = fd_read(current);
if (c == ctrl('H') || c == 127) {
if (rchars) {
int p = utf8_index(rbuf, --rchars);
rbuf[p] = 0;
rlen = strlen(rbuf);
}
continue;
}
#ifdef USE_TERMIOS
if (c == 27) {
c = check_special(current->fd);
}
#endif
if (c == ctrl('P') || c == SPECIAL_UP) {
/* Search for the previous (earlier) match */
if (searchpos > 0) {
searchpos--;
}
skipsame = 1;
}
else if (c == ctrl('N') || c == SPECIAL_DOWN) {
/* Search for the next (later) match */
if (searchpos < history_len) {
searchpos++;
}
searchdir = 1;
skipsame = 1;
}
else if (c >= ' ') {
if (rlen >= (int)sizeof(rbuf) + 3) {
continue;
}
n = utf8_getchars(rbuf + rlen, c);
rlen += n;
rchars++;
rbuf[rlen] = 0;
/* Adding a new char resets the search location */
searchpos = history_len - 1;
}
else {
/* Exit from incremental search mode */
break;
}
/* Now search through the history for a match */
for (; searchpos >= 0 && searchpos < history_len; searchpos += searchdir) {
p = strstr(history[searchpos], rbuf);
if (p) {
/* Found a match */
if (skipsame && strcmp(history[searchpos], current->buf) == 0) {
/* But it is identical, so skip it */
continue;
}
/* Copy the matching line and set the cursor position */
set_current(current,history[searchpos]);
current->pos = utf8_strlen(history[searchpos], p - history[searchpos]);
break;
}
}
if (!p && n) {
/* No match, so don't add it */
rchars--;
rlen -= n;
rbuf[rlen] = 0;
}
}
if (c == ctrl('G') || c == ctrl('C')) {
/* ctrl-g terminates the search with no effect */
set_current(current, "");
c = 0;
}
else if (c == ctrl('J')) {
/* ctrl-j terminates the search leaving the buffer in place */
c = 0;
}
/* Go process the char normally */
refreshLine(current->prompt, current);
goto process_char;
}
break;
case ctrl('T'): /* ctrl-t */
if (current->pos > 0 && current->pos <= current->chars) {
/* If cursor is at end, transpose the previous two chars */
int fixer = (current->pos == current->chars);
c = get_char(current, current->pos - fixer);
remove_char(current, current->pos - fixer);
insert_char(current, current->pos - 1, c);
refreshLine(current->prompt, current);
}
break;
case ctrl('V'): /* ctrl-v */
if (has_room(current, 3)) {
/* Insert the ^V first */
if (insert_char(current, current->pos, c)) {
refreshLine(current->prompt, current);
/* Now wait for the next char. Can insert anything except \0 */
c = fd_read(current);
/* Remove the ^V first */
remove_char(current, current->pos - 1);
if (c != -1) {
/* Insert the actual char */
insert_char(current, current->pos, c);
}
refreshLine(current->prompt, current);
}
}
break;
case ctrl('B'):
case SPECIAL_LEFT:
if (current->pos > 0) {
current->pos--;
refreshLine(current->prompt, current);
}
break;
case ctrl('F'):
case SPECIAL_RIGHT:
if (current->pos < current->chars) {
current->pos++;
refreshLine(current->prompt, current);
}
break;
case SPECIAL_PAGE_UP:
dir = history_len - history_index - 1; /* move to start of history */
goto history_navigation;
case SPECIAL_PAGE_DOWN:
dir = -history_index; /* move to 0 == end of history, i.e. current */
goto history_navigation;
case ctrl('P'):
case SPECIAL_UP:
dir = 1;
goto history_navigation;
case ctrl('N'):
case SPECIAL_DOWN:
history_navigation:
if (history_len > 1) {
/* Update the current history entry before to
* overwrite it with tne next one. */
free(history[history_len - 1 - history_index]);
history[history_len - 1 - history_index] = strdup(current->buf);
/* Show the new entry */
history_index += dir;
if (history_index < 0) {
history_index = 0;
break;
} else if (history_index >= history_len) {
history_index = history_len - 1;
break;
}
set_current(current, history[history_len - 1 - history_index]);
refreshLine(current->prompt, current);
}
break;
case ctrl('A'): /* Ctrl+a, go to the start of the line */
case SPECIAL_HOME:
current->pos = 0;
refreshLine(current->prompt, current);
break;
case ctrl('E'): /* ctrl+e, go to the end of the line */
case SPECIAL_END:
current->pos = current->chars;
refreshLine(current->prompt, current);
break;
case ctrl('U'): /* Ctrl+u, delete to beginning of line, save deleted chars. */
if (remove_chars(current, 0, current->pos)) {
refreshLine(current->prompt, current);
}
break;
case ctrl('K'): /* Ctrl+k, delete from current to end of line, save deleted chars. */
if (remove_chars(current, current->pos, current->chars - current->pos)) {
refreshLine(current->prompt, current);
}
break;
case ctrl('Y'): /* Ctrl+y, insert saved chars at current position */
if (current->capture && insert_chars(current, current->pos, current->capture)) {
refreshLine(current->prompt, current);
}
break;
case ctrl('L'): /* Ctrl+L, clear screen */
linenoiseClearScreen();
/* Force recalc of window size for serial terminals */
current->cols = 0;
refreshLine(current->prompt, current);
break;
default:
/* Only tab is allowed without ^V */
if (c == '\t' || c >= ' ') {
if (insert_char(current, current->pos, c) == 1) {
refreshLine(current->prompt, current);
}
}
break;
}
}
return current->len;
}
int
main (int argc, char *argv[])
{
int b;
mpfr_t x;
mpfr_rnd_t r;
char s[MAX_DIGITS + 2];
mpfr_exp_t e, f;
size_t m;
mpfr_prec_t p;
int i;
tests_start_mpfr ();
check_small ();
check_special (2, 2);
for (i = 0; i < ITER; i++)
{
p = 2 + (randlimb () % (MAX_DIGITS - 1));
b = 2 + (randlimb () % 35);
check_special (b, p);
}
mpfr_init2 (x, MAX_DIGITS);
for (i = 0; i < ITER; i++)
{
m = 2 + (randlimb () % (MAX_DIGITS - 1));
mpfr_urandomb (x, RANDS);
e = (mpfr_exp_t) (randlimb () % 21) - 10;
if (!MPFR_IS_ZERO(x))
mpfr_set_exp (x, (e == -10) ? mpfr_get_emin () :
((e == 10) ? mpfr_get_emax () : e));
b = 2 + (randlimb () % 35);
r = RND_RAND ();
mpfr_get_str (s, &f, b, m, x, r);
}
mpfr_clear (x);
check_large ();
check3 ("4.059650008e-83", MPFR_RNDN, "40597");
check3 ("-6.606499965302424244461355e233", MPFR_RNDN, "-66065");
check3 ("-7.4", MPFR_RNDN, "-74000");
check3 ("0.997", MPFR_RNDN, "99700");
check3 ("-4.53063926135729747564e-308", MPFR_RNDN, "-45306");
check3 ("2.14478198760196000000e+16", MPFR_RNDN, "21448");
check3 ("7.02293374921793516813e-84", MPFR_RNDN, "70229");
check3 ("-6.7274500420134077e-87", MPFR_RNDN, "-67275");
check3 ("-6.7274500420134077e-87", MPFR_RNDZ, "-67274");
check3 ("-6.7274500420134077e-87", MPFR_RNDU, "-67274");
check3 ("-6.7274500420134077e-87", MPFR_RNDD, "-67275");
check3 ("-6.7274500420134077e-87", MPFR_RNDA, "-67275");
check3 ("6.7274500420134077e-87", MPFR_RNDN, "67275");
check3 ("6.7274500420134077e-87", MPFR_RNDZ, "67274");
check3 ("6.7274500420134077e-87", MPFR_RNDU, "67275");
check3 ("6.7274500420134077e-87", MPFR_RNDD, "67274");
check3 ("6.7274500420134077e-87", MPFR_RNDA, "67275");
check_bug_base2k ();
check_reduced_exprange ();
tests_end_mpfr ();
return 0;
}
// clean
struct cParseNode* parse_children(unsigned int rule, struct RuleOption* option, struct Grammar* grammar, struct TokenStream* tokens, struct Error* error) {
LOG("parsing children of %d (token at %d)\n", rule, tokens->at);
struct cParseNode* current = UNINITIALIZED;
unsigned int i = 0, m = 0;
unsigned int at = 0;
struct cParseNode* tmp = NULL;
struct RuleItem* item = NULL;
int ignore;
INDENT();
for (i=0;i<option->num;i++) {
item = &option->items[i];
if (!grammar->rules.rules[rule].dont_ignore) {
while (tokens->at < tokens->num) {
ignore = 0;
for (m=0;m<grammar->ignore.num;m++) {
if (tokens->tokens[tokens->at].which == grammar->ignore.tokens[m]) {
ignore = 1;
break;
}
}
if (ignore == 0) {
break;
}
LOG("ignoring white\n");
tmp = _new_parsenode(rule);
tmp->token = &tokens->tokens[tokens->at];
tmp->type = NTOKEN;
current = append_nodes(current, tmp);
LOG("inc token %d %d\n", tokens->at, tokens->at+1);
tokens->at += 1;
}
}
if (tokens->at < tokens->num) {
LOG("At token %d '%s'\n", tokens->at, tokens->tokens[tokens->at].value);
}
if (item->type == RULE) {
LOG(">RULE\n");
/**
if (0 && tokens->at >= tokens->num) { // disabling
error->at = tokens->at;
error->reason = 1;
error->token = NULL;
error->text = "ran out";
// error[1] = ['ran out', rule, i, item->value.which];
// log('not enough tokens')
DEDENT();
return NULL;
}
**/
at = tokens->at;
tmp = parse_rule(item->value.which, grammar, tokens, error);
if (tmp == NULL) {
tokens->at = at;
if (tokens->at >= error->at && error->reason!=1 && error->reason!=4) {
error->at = tokens->at;
error->reason = 2;
error->token = &tokens->tokens[tokens->at];
error->text = "rule failed";
error->wanted = item->value.which;
}
DEDENT();
return NULL;
}
current = append_nodes(current, tmp);
continue;
} else if (item->type == TOKEN) {
LOG(">TOKEN\n");
if (tokens->at >= tokens->num) {
if (item->value.which == tokens->eof) {
LOG("EOF -- passing\n");
tmp = _new_parsenode(rule);
tmp->token = (struct Token*)malloc(sizeof(struct Token));
tmp->token->value = NULL;
tmp->token->which = tokens->eof;
tmp->token->lineno = -1;
tmp->token->charno = -1;
tmp->type = NTOKEN;
current = append_nodes(current, tmp);
continue;
}
LOG("no more tokens\n");
error->at = tokens->at;
error->reason = 1;
error->token = NULL;
error->text = "ran out";
error->wanted = item->value.which;
DEDENT();
return NULL;
}
if (tokens->tokens[tokens->at].which == item->value.which) {
LOG("got token! %d\n", item->value.which);
tmp = _new_parsenode(rule);
tmp->token = &tokens->tokens[tokens->at];
tmp->type = NTOKEN;
current = append_nodes(current, tmp);
LOG("inc token %d %d\n", tokens->at, tokens->at+1);
tokens->at += 1;
continue;
} else {
if (tokens->at > error->at) {
error->at = tokens->at;
error->reason = 3;
error->token = &tokens->tokens[tokens->at];
error->text = "token failed";
error->wanted = option->items[i].value.which;
}
LOG("token failed (wanted %d, got %d)\n",
item->value.which, tokens->tokens[tokens->at].which);
DEDENT();
return NULL;
}
} else if (item->type == LITERAL) {
LOG(">LITERAL\n");
if (tokens->at >= tokens->num) {
error->at = tokens->at;
error->reason = 4;
error->token = NULL;
error->text = item->value.text;
DEDENT();
return NULL;
}
if (strcmp(item->value.text, tokens->tokens[tokens->at].value) == 0) {
LOG("got literal!\n");
tmp = _new_parsenode(rule);
tmp->token = &tokens->tokens[tokens->at];
tmp->type = NTOKEN;
current = append_nodes(current, tmp);
LOG("inc token %d %d\n", tokens->at, tokens->at+1);
tokens->at += 1;
continue;
} else {
if (tokens->at > error->at) {
error->at = tokens->at;
error->reason = 5;
error->token = &tokens->tokens[tokens->at];
error->text = item->value.text;
}
LOG("failed....literally: %s\n", item->value.text);
DEDENT();
return NULL;
}
} else if (item->type == SPECIAL) {
LOG(">SPECIAL\n");
tmp = check_special(rule, item->value.special, current, grammar, tokens, error);
if (tmp == NULL) {
LOG("FAIL SPECIAL\n");
DEDENT();
return NULL;
}
current = tmp;
}
}
DEDENT();
return current;
}
/**
* @brief Parse and process a line in the config file.
*/
int process_config_line(char *line, struct config_params *params)
{
// Ignore comments.
if (line[0] == CONFIG_COMMENT_CHAR)
return 0;
// Extract config parameter name and value.
char parameter[MAX_CONFIG_LINE_LEN] = {0};
char value[MAX_CONFIG_LINE_LEN] = {0};
char trash[MAX_CONFIG_LINE_LEN] = {0};
char columns[MAX_CONFIG_LINE_LEN] = {0};
char* cur_column = NULL;
char column_name[MAX_COLNAME_LEN] = {0};
char data_type[MAX_STRTYPE_SIZE] = {0};
int items = sscanf(line, "%s %s %[^\n]", parameter, value, columns);
if (strcmp(parameter, "table") == 0) // Processing a table
{
if(check_special(value) == false) // Table name contains special characters?
return 1;
// Check if table name already in table list
int i;
for(i = 0; i < params->num_tables; i++)
if(strcmp(params->table_schemas[i].table_name, value) == 0)
return 1;
params->table_schemas[params->num_tables].num_columns = 0; // Initialize number of columns for current table
// Add to list of table names
strcpy(params->table_schemas[params->num_tables].table_name, value);
// Table name comparion done
if(items < 3) // No column names
return 1;
else if(columns[0] == ',') // First character is a comma
return 1;
cur_column = strtok(columns, ","); // Get tokens from a string delimited with commas
while (cur_column != NULL)
{
// Format from design specifications (spaces before and after commas are allowed)
if(sscanf(cur_column, " %[a-zA-Z0-9]:%[intchar0-9[]%s", column_name, data_type, trash) != 2)
if(trash[0] != ']')
return 1;
// Check if column name already in column list
int i;
for(i = 0; i < params->table_schemas[params->num_tables].num_columns; i++)
if(strcmp(params->table_schemas[params->num_tables].column_names[i], column_name) == 0)
return 1;
// Add to list of column names
strcpy(params->table_schemas[params->num_tables].column_names[params->table_schemas[params->num_tables].num_columns], column_name);
if(strcmp(data_type, "int") == 0) // Integer
params->table_schemas[params->num_tables].data_types[params->table_schemas[params->num_tables].num_columns] = 0;
else
{
sscanf(data_type, "char[%d", &(params->table_schemas[params->num_tables].data_types[params->table_schemas[params->num_tables].num_columns])); // Character array (string)
// Size of string cannot be less than 1
if(params->table_schemas[params->num_tables].data_types[params->table_schemas[params->num_tables].num_columns] < 1 ||
params->table_schemas[params->num_tables].data_types[params->table_schemas[params->num_tables].num_columns] > MAX_STRTYPE_SIZE)
return 1;
}
// Increment number of columns
params->table_schemas[params->num_tables].num_columns++;
cur_column = strtok (NULL, ",");
}
// Increment number of tables
params->num_tables++;
}
// Line wasn't as expected.
else if (items != 2)
return 1;
else if (strcmp(parameter, "server_host") == 0)
{
// Checking if server_host already entered, then invalid config file
if(params->server_host[0] == '\0')
strncpy(params->server_host, value, sizeof params->server_host);
else
return 1;
}
else if (strcmp(parameter, "server_port") == 0)
{
// Checking if server_port already entered, then invalid config file
// Checking port range
if(params->server_port == -1 && atoi(value) > 1023 && atoi(value) < 65536)
params->server_port = atoi(value);
else
return 1;
}
else if (strcmp(parameter, "username") == 0)
{
// Checking if server_username already entered, then invalid config file
if(params->username[0] == '\0')
strncpy(params->username, value, sizeof params->username);
else
return 1;
}
else if (strcmp(parameter, "password") == 0)
{
// Checking if server_password already entered, then invalid config file
if(params->password[0] == '\0')
strncpy(params->password, value, sizeof params->password);
else
return 1;
}
else if (strcmp(parameter, "concurrency") == 0)
{
// Checking if server_password already entered, then invalid config file
if(params->concurrency == -1 && (atoi(value) == 1 || atoi(value) == 0))
params->concurrency = atoi(value);
else
return 1;
}
// else if (strcmp(name, "data_directory") == 0) {
// strncpy(params->data_directory, value, sizeof params->data_directory);
//}
else
return 1;
return 0;
}
