int Parser::identifyLine(const char *aLine)
{
int res = 0;
res |= parse_address(aLine);
res |= parse_case(aLine);
// if(strchr(aLine,ICON_CHAR)) res |= P_PUSHBUTTON;
if(zip->match(aLine)) res |= (P_ZIP | P_ADDRESS);
if(label->match(aLine)) res |= P_LABEL;
if(address->match(aLine)) res |= P_ADDRESS;
if(res & (P_ADDRESS|P_EMAIL)){
/* Paper and electronic addresses cannot be telephone numbers */
res &= ~P_TELEPHONE;
}
else{
/* Things to check if we are not an address */
if(telephones->match(aLine)) res |= P_TELEPHONE;
if(notphone->match(aLine)) res &= ~P_TELEPHONE;
if(blankLine->match(aLine)) res |= P_BLANKLINE;
/* fix the bug with Office */
if(res & P_OFFICE){
if(telephones->match(aLine)){
res &= ~P_ADDRESS;
res |= P_TELEPHONE;
}
}
}
return res;
}
void draw_map()
{
extern t_client t;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(t.x_cam, t.z_cam, t.y_cam, t.x_position, t.y_position, t.z_position, 0, 0, 1);
glRotated(45, 0, 0, 1);
draw_ground();
glTranslated(-t.x_map, -t.y_map, 0);
for (t.i = 0;t.contenu_map[t.i];t.i++)
parse_case();
glFlush();
SDL_GL_SwapBuffers();
}
/* parse a compound- or a simple-command
* (pipeline and lists are done outside this)
* ----------------------------------------------------------------------- */
union node *parse_command(struct parser *p, int tempflags) {
enum tok_flag tok;
union node *command;
union node **rptr;
tok = parse_gettok(p, tempflags);
switch(tok) {
/* T_FOR begins an iteration statement */
case T_FOR:
command = parse_for(p);
break;
/* T_IF begins a case match statement */
case T_CASE:
command = parse_case(p);
break;
/* T_IF begins a conditional statement */
case T_IF:
command = parse_if(p);
break;
/* T_WHILE/T_UNTIL begin a for-loop statement */
case T_WHILE:
case T_UNTIL:
command = parse_loop(p);
break;
/* T_LP/T_BEGIN start a grouping compound */
case T_LP:
case T_BEGIN:
p->pushback++;
command = parse_grouping(p);
break;
/* handle simple commands */
case T_NAME:
case T_WORD:
case T_REDIR:
case T_ASSIGN:
p->pushback++;
command = parse_simple_command(p);
break;
/* it wasn't a compound command, return now */
default:
p->pushback++;
return NULL;
}
if(command) {
/* they all can have redirections, so parse these now */
rptr = &command->ncmd.rdir;
/*
* in the case of a simple command there are maybe already
* redirections in the list (because in a simple command they
* can appear between arguments), so skip to the end of the list.
*/
while(*rptr)
tree_next(rptr);
while(parse_gettok(p, P_DEFAULT) & T_REDIR)
tree_move(p->tree, rptr);
}
p->pushback++;
return command;
}
int
main(int argc, char **argv)
{
/* static to prevent longjmp clobber warning */
static FILE *stream = NULL;
static unsigned long line_num = 0;
static unsigned long failed_cnt = 0;
static unsigned long bomb_cnt = 0;
static unsigned long success_cnt = 0;
static int ret = 0;
char buf[BUFSIZ];
FILE *fp_in = NULL;
char *endp = NULL;
size_t string_length;
int argv_idx;
int c;
char dt_fmt[50]; /* data type format string */
char *buf_p1;
char *buf_p;
struct bn_tol tol;
/* command line parameters */
static unsigned long test_case_line_num = 0; /* static due to longjmp */
static unsigned long function_num = 0; /* static due to longjmp */
struct bu_vls input_file_name = BU_VLS_INIT_ZERO;
struct bu_vls output_file_name = BU_VLS_INIT_ZERO;
/* function parameter arrays */
int i[50] = {0};
long l[50] = {0};
fastf_t d[50] = {0.0};
unsigned long u[50] = {0};
/* boolean variables */
static int output_file_name_defined = 0; /* static due to longjmp */
static int process_single_test_case = 0; /* static due to longjmp */
static int process_single_function = 0; /* static due to longjmp */
int input_file_name_defined = 0;
int valid_function_number = 0;
int process_test_case = 0;
int early_exit = 0;
static int found_eof = 0; /* static due to longjmp */
/* set initial values in tol structure */
tol.magic = BN_TOL_MAGIC;
tol.dist = BN_TOL_DIST;
tol.dist_sq = tol.dist * tol.dist;
tol.perp = 1e-6;
tol.para = 1.0 - tol.perp;
if (argc < 2) {
bu_log("Too few parameters, %d specified, at least 1 required\n", argc - 1);
bu_exit(EXIT_FAILURE, USAGE);
}
while ((c = bu_getopt(argc, argv, "l:f:i:o:")) != -1) {
switch (c) {
case 'l': /* test case line number */
errno = 0;
test_case_line_num = strtoul(bu_optarg, &endp, 10);
if (errno) {
bu_log("Invalid test case line number '%s' '%s'\n", bu_optarg, strerror(errno));
bu_exit(EXIT_FAILURE, USAGE);
}
if ((*endp != '\0') || (bu_optarg == endp) || (strchr(bu_optarg, '-') != '\0')) {
bu_log("Invalid test case line number '%s'\n", bu_optarg);
bu_exit(EXIT_FAILURE, USAGE);
}
process_single_test_case = 1;
break;
case 'f': /* function number */
errno = 0;
function_num = strtoul(bu_optarg, &endp, 10);
if (errno) {
bu_log("Invalid function number '%s' '%s'\n", bu_optarg, strerror(errno));
bu_exit(EXIT_FAILURE, USAGE);
}
if ((*endp != '\0') || (bu_optarg == endp) || (strchr(bu_optarg, '-') != '\0')) {
bu_log("Invalid function number '%s'\n", bu_optarg);
bu_exit(EXIT_FAILURE, USAGE);
}
process_single_function = 1;
break;
case 'i': /* input file name */
string_length = strlen(bu_optarg);
if (string_length >= BUFSIZ) {
bu_log("Input file name too long, length was %d but must be less than %d\n",
string_length, BUFSIZ);
bu_exit(EXIT_FAILURE, USAGE);
}
bu_vls_strcpy(&input_file_name, bu_optarg);
input_file_name_defined = 1;
break;
case 'o': /* output file name */
string_length = strlen(bu_optarg);
if (string_length >= BUFSIZ) {
bu_log("Output file name too long, length was %d but must be less than %d\n",
string_length, BUFSIZ);
bu_exit(EXIT_FAILURE, USAGE);
}
bu_vls_strcpy(&output_file_name, bu_optarg);
output_file_name_defined = 1;
break;
default:
bu_log("Invalid option '%c'.\n", c);
bu_exit(EXIT_FAILURE, USAGE);
break;
}
}
if (process_single_test_case && process_single_function) {
bu_log("Can not specify both test case line number and function number.\n");
early_exit = 1;
}
if (!input_file_name_defined) {
bu_log("Input file name is required but was not specified.\n");
early_exit = 1;
}
if (early_exit) {
bu_vls_free(&input_file_name);
bu_vls_free(&output_file_name);
bu_exit(EXIT_FAILURE, USAGE);
}
if ((fp_in = fopen(bu_vls_addr(&input_file_name), "r")) == NULL) {
bu_log("Cannot open input file (%s)\n", bu_vls_addr(&input_file_name));
bu_vls_free(&input_file_name);
bu_vls_free(&output_file_name);
return EXIT_FAILURE;
}
if (output_file_name_defined) {
if ((stream = fopen(bu_vls_addr(&output_file_name), "w")) == NULL) {
bu_log("Cannot create output file (%s)\n", bu_vls_addr(&output_file_name));
if (fclose(fp_in) != 0) {
bu_log("Unable to close input file.\n");
}
bu_vls_free(&input_file_name);
bu_vls_free(&output_file_name);
return EXIT_FAILURE;
}
} else {
stream = stderr;
}
/* all output after this point is sent to stream */
fprintf(stream, "Command line parameters: bntester ");
for (argv_idx = 1 ; argv_idx < argc ; argv_idx++) {
fprintf(stream, "%s ", argv[argv_idx]);
}
fprintf(stream, "\n");
if (process_single_test_case) {
fprintf(stream, "Processing only test case on line number: %lu\n", test_case_line_num);
}
if (process_single_function) {
fprintf(stream, "Processing all test cases for function number: %lu\n", function_num);
}
if (!process_single_test_case && !process_single_function) {
fprintf(stream, "Processing all test cases.\n");
}
while (!found_eof) {
if (line_num == ULONG_MAX) {
fprintf(stream, "ERROR: Input data file exceeded max %lu number of lines.\n", ULONG_MAX);
if (fclose(fp_in) != 0) {
fprintf(stream, "Unable to close input file.\n");
}
if (output_file_name_defined) {
if (fclose(stream) != 0) {
bu_log("Unable to close output file.\n");
}
}
bu_vls_free(&input_file_name);
bu_vls_free(&output_file_name);
return EXIT_FAILURE;
}
line_num++;
if (bu_fgets(buf, BUFSIZ, fp_in) == NULL) {
if (feof(fp_in)) {
found_eof = 1;
continue;
}
if (ferror(fp_in)) {
perror("ERROR: Problem reading file, system error message");
if (fclose(fp_in) != 0) {
fprintf(stream, "Unable to close input file.\n");
}
} else {
perror("Oddness reading input file");
}
bu_vls_free(&input_file_name);
bu_vls_free(&output_file_name);
return EXIT_FAILURE;
} else {
/* Skip input data file lines which start with a '#' character
* or a new line character.
*/
if ((buf[0] != '#') && (buf[0] != '\n')) {
buf_p1 = strtok(buf, "\n");
buf_p = strtok(buf_p1, ", ");
/* The 1st parameter of the test case is always an unsigned
* long int which represents the function number. This logic
* validates the test case function number to ensure it is
* an unsigned long int.
*/
valid_function_number = 1;
errno = 0;
u[0] = strtoul(buf_p, &endp, 10);
if (errno) {
fprintf(stream, "Read function number failed, line %lu error msg: '%s' string '%s'\n",
line_num, strerror(errno), buf_p);
valid_function_number = 0;
} else if ((*endp != '\0') || (buf_p == endp) || (strchr(buf_p, '-') != '\0')) {
fprintf(stream, "Read function number failed, line %lu string '%s'\n", line_num, buf_p);
valid_function_number = 0;
}
/* This logic restricts processing of the test case(s) to
* only those specified by the bntester input parameters.
*/
process_test_case = 0;
if (valid_function_number && process_single_test_case && (test_case_line_num == line_num)) {
process_test_case = 1;
} else if (valid_function_number && process_single_function && (function_num == u[0])) {
process_test_case = 1;
} else if (valid_function_number && !process_single_test_case && !process_single_function) {
process_test_case = 1;
}
if (process_test_case) {
/* Each case within this switch corresponds to each
* function to be tested.
*/
switch (u[0]) {
case 1: /* function 'bn_distsq_line3_pt3' */
bu_strlcpy(dt_fmt, "dddddddddd", sizeof(dt_fmt)); /* defines parameter data types */
if (parse_case(buf_p, i, l, d, u, dt_fmt, line_num, stream)) {
/* Parse failed, skipping test case */
ret = 1;
} else {
double result;
if (!BU_SETJUMP) {
/* try */
result = bn_distsq_line3_pt3(&d[0], &d[3], &d[6]);
if (!NEAR_EQUAL(result, d[9], VUNITIZE_TOL)) {
ret = 1;
failed_cnt++;
fprintf(stream, "Failed function %lu test case on line %lu expected = %.15f result = %.15f\n",
u[0], line_num, d[9], result);
} else {
success_cnt++;
}
} else {
/* catch */
BU_UNSETJUMP;
ret = 1;
bomb_cnt++;
fprintf(stream, "Failed function %lu test case on line %lu bu_bomb encountered.\n", u[0], line_num);
} BU_UNSETJUMP;
}
break;
case 2: /* function 'bn_2line3_colinear' */
bu_strlcpy(dt_fmt, "ddddddddddddduddddi", sizeof(dt_fmt));
if (parse_case(buf_p, i, l, d, u, dt_fmt, line_num, stream)) {
/* Parse failed, skipping test case */
ret = 1;
} else {
int result;
if (!BU_SETJUMP) {
/* try */
tol.magic = u[1];
tol.dist = d[13];
tol.dist_sq = d[14];
tol.perp = d[15];
tol.para = d[16];
result = bn_2line3_colinear(&d[0], &d[3], &d[6], &d[9], d[12], &tol);
if (result != i[0]) {
ret = 1;
failed_cnt++;
fprintf(stream, "Failed function %lu test case on line %lu expected = %d result = %d\n",
u[0], line_num, i[0], result);
} else {
success_cnt++;
}
} else {
/* catch */
BU_UNSETJUMP;
ret = 1;
bomb_cnt++;
fprintf(stream, "Failed function %lu test case on line %lu bu_bomb encountered.\n", u[0], line_num);
} BU_UNSETJUMP;
}
break;
case 3: /* function 'bn_isect_line3_line3' */
bu_strlcpy(dt_fmt, "dddddddddddddduddddi", sizeof(dt_fmt));
if (parse_case(buf_p, i, l, d, u, dt_fmt, line_num, stream)) {
/* Parse failed, skipping test case */
ret = 1;
} else {
int result;
fastf_t t_out = 0.0;
fastf_t u_out = 0.0;
int t_fail = 0;
int u_fail = 0;
if (!BU_SETJUMP) {
/* try */
tol.magic = u[1];
tol.dist = d[14];
tol.dist_sq = d[15];
tol.perp = d[16];
tol.para = d[17];
result = bn_isect_line3_line3(&t_out, &u_out, &d[2], &d[5], &d[8], &d[11], &tol);
if (result != i[0]) {
ret = 1;
failed_cnt++;
fprintf(stream, "Failed function %lu test case on line %lu expected = %d result = %d\n",
u[0], line_num, i[0], result);
} else if (result == 0) {
if (!NEAR_EQUAL(t_out, d[0], tol.dist)) {
ret = 1;
failed_cnt++;
fprintf(stream, "Failed function %lu test case on line %lu result = %d expected t = %.15f result t = %.15f\n",
u[0], line_num, result, d[0], t_out);
} else {
success_cnt++;
}
} else if (result == 1) {
t_fail = !NEAR_EQUAL(t_out, d[0], tol.dist);
u_fail = !NEAR_EQUAL(u_out, d[1], tol.dist);
if (t_fail) {
fprintf(stream, "Failed function %lu test case on line %lu result = %d expected t = %.15f result t = %.15f\n",
u[0], line_num, result, d[0], t_out);
}
if (u_fail) {
fprintf(stream, "Failed function %lu test case on line %lu result = %d expected u = %.15f result u = %.15f\n",
u[0], line_num, result, d[1], u_out);
}
if (t_fail || u_fail) {
ret = 1;
failed_cnt++;
} else {
/* No other output to validate when result matches expected and
* result is not 0 and not 1.
*/
success_cnt++;
}
} else {
success_cnt++;
}
} else {
/* catch */
BU_UNSETJUMP;
ret = 1;
bomb_cnt++;
fprintf(stream, "Failed function %lu test case on line %lu bu_bomb encountered.\n", u[0], line_num);
} BU_UNSETJUMP;
}
break;
case 4: /* function 'bn_isect_lseg3_lseg3' */
bu_strlcpy(dt_fmt, "dddddddddddddduddddi", sizeof(dt_fmt));
if (parse_case(buf_p, i, l, d, u, dt_fmt, line_num, stream)) {
/* Parse failed, skipping test case */
ret = 1;
} else {
int result;
fastf_t dist[2] = {0.0, 0.0};
int d0_fail = 0;
int d1_fail = 0;
if (!BU_SETJUMP) {
/* try */
tol.magic = u[1];
tol.dist = d[14];
tol.dist_sq = d[15];
tol.perp = d[16];
tol.para = d[17];
result = bn_isect_lseg3_lseg3(&dist[0], &d[2], &d[5], &d[8], &d[11], &tol);
if (result != i[0]) {
ret = 1;
failed_cnt++;
fprintf(stream, "Failed function %lu test case on line %lu expected = %d result = %d\n",
u[0], line_num, i[0], result);
} else if (result == 0 || result == 1) {
d0_fail = !NEAR_EQUAL(dist[0], d[0], VUNITIZE_TOL);
d1_fail = !NEAR_EQUAL(dist[1], d[1], VUNITIZE_TOL);
if (d0_fail) {
fprintf(stream, "Failed function %lu test case on line %lu result = %d expected dist[0] = %.15f result dist[0] = %.15f\n",
u[0], line_num, result, d[0], dist[0]);
}
if (d1_fail) {
fprintf(stream, "Failed function %lu test case on line %lu result = %d expected dist[1] = %.15f result dist[1] = %.15f\n",
u[0], line_num, result, d[1], dist[1]);
}
if (d0_fail || d1_fail) {
ret = 1;
failed_cnt++;
} else {
/* No other output to validate when result matches expected and
* result is not 0 and not 1.
*/
success_cnt++;
}
} else {
success_cnt++;
}
} else {
/* catch */
BU_UNSETJUMP;
ret = 1;
bomb_cnt++;
fprintf(stream, "Failed function %lu test case on line %lu bu_bomb encountered.\n", u[0], line_num);
} BU_UNSETJUMP;
}
break;
default:
fprintf(stream, "ERROR: Unknown function number %lu test case on line %lu, skipping test case.\n", u[0], line_num);
bu_vls_free(&input_file_name);
bu_vls_free(&output_file_name);
return EXIT_FAILURE;
break;
} /* End of function number switch */
}
} /* End of if statement skipping lines starting with '#' or new line */
}
} /* End of while loop reading lines from data file */
fprintf(stream, "Summary: %lu total test cases success.\n", success_cnt);
fprintf(stream, "Summary: %lu total test cases failed.\n", failed_cnt);
fprintf(stream, "Summary: %lu total test cases bomb.\n", bomb_cnt);
if (output_file_name_defined) {
bu_log("Summary: %lu total test cases success.\n", success_cnt);
bu_log("Summary: %lu total test cases failed.\n", failed_cnt);
bu_log("Summary: %lu total test cases bomb.\n", bomb_cnt);
}
fprintf(stream, "Done.\n");
if (output_file_name_defined) {
bu_log("Done.\n");
}
if (fclose(fp_in) != 0) {
fprintf(stream, "Unable to close input file.\n");
}
if (output_file_name_defined) {
if (fclose(stream) != 0) {
bu_log("Unable to close output file.\n");
}
}
bu_vls_free(&input_file_name);
bu_vls_free(&output_file_name);
return ret;
}
struct node *parse_factor(struct compiler *compiler)
{
switch (lexer_current(compiler))
{
case T_BEGIN:
return parse_begin(compiler);
case T_IF:
return parse_if(compiler);
case T_UNLESS:
return parse_unless(compiler);
case T_CASE:
return parse_case(compiler);
case T_CLASS:
return parse_class(compiler);
case T_MODULE:
return parse_module(compiler);
case T_DEF:
return parse_method(compiler);
case T_YIELD:
return parse_yield(compiler);
case T_RETURN:
return parse_return(compiler);
case T_BREAK:
return parse_break(compiler);
case T_NEXT:
return parse_next(compiler);
case T_REDO:
return parse_redo(compiler);
case T_SQUARE_OPEN:
{
struct node *result = alloc_node(compiler, N_ARRAY);
lexer_next(compiler);
if(lexer_current(compiler) == T_SQUARE_CLOSE)
result->left = 0;
else
result->left = parse_array_element(compiler);
lexer_match(compiler, T_SQUARE_CLOSE);
return result;
}
case T_STRING:
{
struct node *result = alloc_node(compiler, N_STRING);
result->left = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
return result;
}
case T_STRING_START:
{
struct node *result = alloc_node(compiler, N_STRING_CONTINUE);
result->left = 0;
result->middle = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
result->right = parse_statements(compiler);
while(lexer_current(compiler) == T_STRING_CONTINUE)
{
struct node *node = alloc_node(compiler, N_STRING_CONTINUE);
node->left = result;
node->middle = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
node->right = parse_statements(compiler);
result = node;
}
if(lexer_require(compiler, T_STRING_END))
{
struct node *node = alloc_node(compiler, N_STRING_START);
node->left = result;
node->right = (void *)lexer_token(compiler)->start;
lexer_next(compiler);
return node;
}
return result;
}
case T_SELF:
{
lexer_next(compiler);
return &self_node;
}
case T_TRUE:
{
lexer_next(compiler);
return alloc_node(compiler, N_TRUE);
}
case T_FALSE:
{
lexer_next(compiler);
return alloc_node(compiler, N_FALSE);
}
case T_NIL:
{
lexer_next(compiler);
return &nil_node;
}
case T_NUMBER:
{
struct node *result = alloc_node(compiler, N_NUMBER);
char *text = get_token_str(lexer_token(compiler));
result->left = (void* )atoi(text);
lexer_next(compiler);
return result;
}
case T_IVAR:
{
rt_value symbol = rt_symbol_from_lexer(compiler);
lexer_next(compiler);
switch (lexer_current(compiler))
{
case T_ASSIGN_ADD:
case T_ASSIGN_SUB:
case T_ASSIGN_MUL:
case T_ASSIGN_DIV:
{
struct node *result;
enum token_type op_type = lexer_current(compiler) - OP_TO_ASSIGN;
lexer_next(compiler);
result = alloc_node(compiler, N_IVAR_ASSIGN);
result->right = alloc_node(compiler, N_BINARY_OP);
result->right->op = op_type;
result->right->left = alloc_node(compiler, N_IVAR);
result->right->left->left = (void *)symbol;
result->right->right = parse_expression(compiler);
result->left = (void *)symbol;
return result;
}
case T_ASSIGN:
{
struct node *result;
lexer_next(compiler);
result = alloc_node(compiler, N_IVAR_ASSIGN);
result->left = (void *)symbol;
result->right = parse_expression(compiler);
return result;
}
default:
{
struct node *result = alloc_node(compiler, N_IVAR);
result->left = (void *)symbol;
return result;
}
}
}
case T_IDENT:
return parse_identifier(compiler);
case T_EXT_IDENT:
return parse_call(compiler, 0, &self_node, false);
case T_PARAM_OPEN:
{
lexer_next(compiler);
struct node *result = parse_statements(compiler);
lexer_match(compiler, T_PARAM_CLOSE);
return result;
}
default:
{
COMPILER_ERROR(compiler, "Expected expression but found %s", token_type_names[lexer_current(compiler)]);
lexer_next(compiler);
return 0;
}
}
}
