int main(int argc, char **argv) {
struct json_result result;
json_init_result(&result);
char *s = strdup(" ['hello', ['a', 'b', ['c', 'd', 'e'], 'you']");
fix_quotes(s);
printf("%s\n", s);
int rc = json_parse(s, &result);
printf("rc = %d\n", rc);
debug(&result);
printf("allocations = %d\n", result.allocations);
json_release_result(&result);
printf("after releasing, net allocations = %d\n", result.allocations);
free(s);
}
void apply_box_testing(BLOCK_LIST *block_list) {
BLOCK_IT block_it(block_list);
ROW_IT row_it;
ROW *row;
INT16 row_count = 0;
WERD_IT word_it;
WERD *word;
WERD *bln_word;
INT16 word_count = 0;
PBLOB_IT blob_it;
DENORM denorm;
INT16 count = 0;
char ch[2];
WERD *outword; //bln best choice
//segmentation
WERD_CHOICE *best_choice; //tess output
WERD_CHOICE *raw_choice; //top choice permuter
//detailed results
BLOB_CHOICE_LIST_CLIST blob_choices;
INT16 char_count = 0;
INT16 correct_count = 0;
INT16 err_count = 0;
INT16 rej_count = 0;
#ifndef SECURE_NAMES
WERDSTATS wordstats; //As from newdiff
#endif
char tess_rej_str[3];
char tess_long_str[3];
ch[1] = '\0';
strcpy (tess_rej_str, "|A");
strcpy (tess_long_str, "|B");
for (block_it.mark_cycle_pt ();
!block_it.cycled_list (); block_it.forward ()) {
row_it.set_to_list (block_it.data ()->row_list ());
for (row_it.mark_cycle_pt (); !row_it.cycled_list (); row_it.forward ()) {
row = row_it.data ();
row_count++;
word_count = 0;
word_it.set_to_list (row->word_list ());
for (word_it.mark_cycle_pt ();
!word_it.cycled_list (); word_it.forward ()) {
word = word_it.data ();
word_count++;
if ((strlen (word->text ()) == 1) &&
!STRING (applybox_test_exclusions).contains (*word->text ())
&& (word->gblob_list ()->length () == 1)) {
/* Here is a word with a single char label and a single blob so test it */
bln_word =
make_bln_copy (word, row, row->x_height (), &denorm);
blob_it.set_to_list (bln_word->blob_list ());
ch[0] = *word->text ();
char_count++;
best_choice = tess_segment_pass1 (bln_word,
&denorm,
tess_default_matcher,
raw_choice,
&blob_choices, outword);
/*
Test for TESS screw up on word. Recog_word has already ensured that the
choice list, outword blob lists and best_choice string are the same
length. A TESS screw up is indicated by a blank filled or 0 length string.
*/
if ((best_choice->string ().length () == 0) ||
(strspn (best_choice->string ().string (), " ") ==
best_choice->string ().length ())) {
rej_count++;
tprintf ("%d:%d: \"%s\" -> TESS FAILED\n",
row_count, word_count, ch);
#ifndef SECURE_NAMES
wordstats.word (tess_rej_str, 2, ch, 1);
#endif
}
else {
if ((best_choice->string ().length () !=
outword->blob_list ()->length ()) ||
(best_choice->string ().length () !=
blob_choices.length ())) {
tprintf
("ASSERT FAIL String:\"%s\"; Strlen=%d; #Blobs=%d; #Choices=%d\n",
best_choice->string ().string (),
best_choice->string ().length (),
outword->blob_list ()->length (),
blob_choices.length ());
}
ASSERT_HOST (best_choice->string ().length () ==
outword->blob_list ()->length ());
ASSERT_HOST (best_choice->string ().length () ==
blob_choices.length ());
fix_quotes ((char *) best_choice->string ().string (),
//turn to double
outword, &blob_choices);
if (strcmp (best_choice->string ().string (), ch) != 0) {
err_count++;
tprintf ("%d:%d: \"%s\" -> \"%s\"\n",
row_count, word_count, ch,
best_choice->string ().string ());
}
else
correct_count++;
#ifndef SECURE_NAMES
if (best_choice->string ().length () > 2)
wordstats.word (tess_long_str, 2, ch, 1);
else
wordstats.word ((char *) best_choice->string ().
string (),
best_choice->string ().length (), ch,
1);
#endif
}
delete bln_word;
delete outword;
delete best_choice;
delete raw_choice;
blob_choices.deep_clear ();
count++;
}
}
}
}
#ifndef SECURE_NAMES
wordstats.print (1, 100.0);
wordstats.conf_matrix ();
tprintf ("Tested %d chars: %d correct; %d rejected by tess; %d errs\n",
char_count, correct_count, rej_count, err_count);
#endif
}
/**********************************************************************
* save_answer
*
* Write an answer to the output file that is the raw guess (without
* context) directly from the classifier.
**********************************************************************/
void save_answer(TWERD *word,
TEXTROW *row,
A_CHOICE *best_choice,
A_CHOICE *raw_choice,
int firstpass) {
static TEXTROW *last_row;
char raw_answer[CHARS_PER_LINE];
int answer_already;
int good_answer;
char *string = NULL;
if (best_choice) {
good_answer = AcceptableResult (best_choice, raw_choice);
string = class_string (best_choice);
}
else {
good_answer = FALSE;
}
if (firstpass) {
/* First pass */
if (string) {
/* Got answer */
add_document_word(best_choice);
word->guess = string;
fix_quotes (word->guess);
strcpy (raw_answer, word->guess);
record_certainty (class_certainty (best_choice), 1);
if (good_answer) {
record_certainty (class_certainty (best_choice), 2);
strcat (raw_answer, " ");
strcat (raw_answer, class_string (raw_choice));
word->guess = strsave (raw_answer);
word->guess[strlen (string)] = 0;
if (string) {
strfree(string);
class_string (best_choice) = NULL;
}
}
else {
/* Not good enough */
if (word->guess)
strfree (word->guess);
word->guess = NULL;
}
}
else {
word->guess = NULL;
raw_answer[0] = '\0';
}
}
else {
/* Second pass */
answer_already = (word->guess != NULL);
if (answer_already) {
write_text_files (word,
&word->guess[strlen (word->guess) + 1],
(row != last_row), TRUE, TRUE);
}
else {
/* Required second pass */
if (string) {
if (!good_answer && tessedit_save_stats) {
SaveBadWord (string, class_certainty (best_choice));
}
record_certainty (class_certainty (best_choice), 2);
word->guess = class_string (best_choice);
fix_quotes (word->guess);
write_text_files (word, class_string (raw_choice),
(row != last_row), good_answer, FALSE);
}
}
}
/* Word Display */
if (display_text) {
if (row != last_row)
cprintf ("\n");
if (word->guess && strlen (word->guess))
cprintf ("%s ", word->guess);
else
cprintf ("%s ", raw_answer);
fflush(stdout);
}
last_row = row;
}