| /*---------------------------------------------------------------------------* |
| * parseStringTest.c * |
| * * |
| * Copyright 2007, 2008 Nuance Communciations, Inc. * |
| * * |
| * Licensed under the Apache License, Version 2.0 (the 'License'); * |
| * you may not use this file except in compliance with the License. * |
| * * |
| * You may obtain a copy of the License at * |
| * http://www.apache.org/licenses/LICENSE-2.0 * |
| * * |
| * Unless required by applicable law or agreed to in writing, software * |
| * distributed under the License is distributed on an 'AS IS' BASIS, * |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * |
| * See the License for the specific language governing permissions and * |
| * limitations under the License. * |
| * * |
| *---------------------------------------------------------------------------*/ |
| |
| |
| |
| #include "pstdio.h" |
| #include "pmemory.h" |
| #include "plog.h" |
| |
| |
| #include "HashMap.h" |
| #include "SR_Grammar.h" |
| #include "SR_SemanticResult.h" |
| #include "ESR_Session.h" |
| #include "ESR_Locale.h" |
| #include "LCHAR.h" |
| |
| #include "PFileSystem.h" |
| #include "PANSIFileSystem.h" |
| |
| /* for testing RecognizerImpl.c, see below */ |
| #include"buildopt.h" |
| #include"setting.h" |
| #include"srec_sizes.h" |
| #include"SR_GrammarImpl.h" |
| |
| /* defines */ |
| #define MAX_LINE_LENGTH 256 |
| #define MAX_STR_LENGTH 512 |
| #define MAX_SEM_RESULTS 3 |
| #define MAX_KEYS 30 |
| |
| /* protos */ |
| ESR_ReturnCode process_single_key_line(SR_Grammar* grammar, PFile* fin, PFile* fout); |
| ESR_ReturnCode process_multi_key_line(SR_Grammar* grammar, const LCHAR* rootrule, PFile* fin, PFile* fout); |
| |
| /* struct */ |
| typedef struct Opts |
| { |
| int use_parse_by_string_ids; |
| int do_check_all_ids; |
| } |
| Opts; |
| |
| int usage(LCHAR* exename) |
| { |
| pfprintf(PSTDOUT, "usage: %s -base <basefilename> [-in <input file>] [-out <output file>] [-itest <testfilename>]\n", exename); |
| return 1; |
| } |
| |
| void lstr_strip_multiple_spaces(LCHAR* trans) |
| { |
| char *src=trans, *dst=trans; |
| for( ;(*dst = *src)!=L('\0'); src++) { |
| if(*dst != ' ') dst++; |
| else if(src[1] != ' ') dst++; |
| } |
| } |
| |
| /** |
| * Display the Semantic Result |
| */ |
| void display_results(SR_SemanticResult *result, PFile* fout) |
| { |
| size_t i, size, len; |
| LCHAR* keys[MAX_KEYS]; /* array of pointers to strings */ |
| LCHAR value[MAX_STR_LENGTH]; |
| ESR_ReturnCode rc; |
| |
| size = MAX_KEYS; |
| rc = result->getKeyList(result, (LCHAR**) & keys, &size); /* get the key list */ |
| if (rc == ESR_SUCCESS) |
| { |
| for (i = 0; i < size; i++) |
| { |
| len = MAX_STR_LENGTH; |
| if ((rc = result->getValue(result, keys[i], value, &len)) == ESR_SUCCESS) |
| pfprintf(fout, "{%s : %s}\n", keys[i], value); |
| else |
| pfprintf(fout, "Error: %s\n", ESR_rc2str(rc)); |
| } |
| pfprintf(fout, "--Done--\n"); |
| } |
| else |
| pfprintf(fout, "Error: %s\n", ESR_rc2str(rc)); |
| } |
| |
| ESR_ReturnCode Parse(SR_Grammar* grammar, LCHAR* trans, PFile* fout, Opts* opts) |
| { |
| ESR_ReturnCode rc = ESR_SUCCESS; |
| size_t i, result_count, key_count; |
| SR_SemanticResult* semanticResults[MAX_SEM_RESULTS]; |
| wordID wordIDs[32], *wordIDptr; |
| SR_GrammarImpl* pgrammar = (SR_GrammarImpl*)grammar; |
| wordmap* wmap; |
| |
| if (opts->do_check_all_ids) |
| { |
| wordID id; |
| Opts myopts; |
| memcpy(&myopts, opts, sizeof(myopts)); |
| myopts.do_check_all_ids = 0; |
| wmap = pgrammar->syntax->synx->olabels; |
| /* start at word 4 because "eps, -pau- -pau2- @root */ |
| for (id = 4; id < wmap->num_words; id++) |
| { |
| trans = wmap->words[id]; |
| Parse(grammar, trans, fout, &myopts); |
| } |
| return 0; |
| } |
| |
| result_count = MAX_SEM_RESULTS; /* initially not greater than MAX */ |
| for (i = 0; i < result_count; i++) |
| SR_SemanticResultCreate(&semanticResults[i]); /* create the result holders */ |
| lstrtrim(trans); |
| /* check for multiple space separators! */ |
| lstr_strip_multiple_spaces(trans); |
| |
| if (!opts->use_parse_by_string_ids) |
| { |
| rc = grammar->checkParse(grammar, trans, semanticResults, (size_t*) & result_count); |
| } |
| else |
| { |
| char copy_of_trans[256], *p; |
| strcpy(copy_of_trans, trans); |
| wmap = pgrammar->syntax->synx->olabels; |
| wordIDs[0] = wordIDs[1] = MAXwordID; |
| wordIDptr = &wordIDs[0]; |
| for (p = strtok(copy_of_trans, " "); p; p = strtok(NULL, " ")) |
| { |
| for (i = 0; i < wmap->num_words; i++) |
| if (!strcmp(wmap->words[i], p)) |
| { |
| *wordIDptr++ = (wordID)i; |
| break; |
| } |
| if (i == wmap->num_words) |
| { |
| wordIDs[0] = MAXwordID; |
| break; |
| } |
| } |
| *wordIDptr++ = MAXwordID; |
| |
| /* printf("wordids:"); |
| for(wordIDptr=&wordIDs[0]; *wordIDptr!=MAXwordID; wordIDptr++) |
| printf(" %d/%s", *wordIDptr, wmap->words[*wordIDptr]); |
| printf("\n"); */ |
| |
| if (wordIDs[0] == MAXwordID) |
| { |
| result_count = 0; |
| rc = ESR_SUCCESS; |
| } |
| else |
| { |
| rc = pgrammar->semproc->flush(pgrammar->semproc); |
| rc = pgrammar->semproc->setParam(pgrammar->semproc, L("literal"), trans); |
| rc = pgrammar->semproc->checkParseByWordID(pgrammar->semproc, pgrammar->semgraph, |
| wordIDs, semanticResults, &result_count); |
| } |
| } |
| if (rc != ESR_SUCCESS) |
| { |
| pfprintf(fout, "error (%s)\n\n", trans); |
| return rc; |
| } |
| |
| if (result_count < 1) |
| { |
| pfprintf(fout, "no parse (%s)\n\n", trans); |
| } |
| else |
| { |
| key_count = 0xffff; |
| rc = SR_SemanticResultGetKeyCount(semanticResults[0], &key_count); |
| pfprintf(fout, "parse ok (%d results) (%s) (%d)\n", result_count, trans, key_count); |
| for (i = 0; i < result_count; i++) |
| display_results(semanticResults[i], fout); |
| |
| for (i = 0; i < MAX_SEM_RESULTS; i++) |
| { |
| rc = semanticResults[i]->destroy(semanticResults[i]); |
| if (rc != ESR_SUCCESS) |
| return rc; |
| } |
| } |
| return ESR_SUCCESS; |
| } |
| |
| /* tests the transcription against the grammar and then decided based on what was expected of the test |
| whether or not is it considered a pass or fail */ |
| ESR_ReturnCode ParseTestSet(SR_Grammar* grammar, LCHAR* trans, LCHAR* key, LCHAR* ref, LCHAR* result, PFile* fout) |
| { |
| size_t len; |
| ESR_ReturnCode rc; |
| int i, result_count; |
| SR_SemanticResult* semanticResults[MAX_SEM_RESULTS]; |
| LCHAR value[MAX_STR_LENGTH]; |
| |
| result_count = MAX_SEM_RESULTS; |
| for (i = 0; i < result_count; i++) |
| SR_SemanticResultCreate(&semanticResults[i]); |
| |
| lstrtrim(trans); |
| /* check for multiple space separators! */ |
| lstr_strip_multiple_spaces(trans); |
| |
| pfprintf(fout, "checking (%s) ref(%s) res(%s)\n", trans, ref, result); |
| rc = grammar->checkParse(grammar, trans, semanticResults, (size_t*) & result_count); |
| if (rc != ESR_SUCCESS) |
| return rc; |
| |
| /*result file will contain |
| transcription | key | reference | result | PASSESD/FAILED */ |
| |
| if (result_count < 1) /*failed to parse, but this could still be a pass if you expected a failure*/ |
| { |
| pfprintf(fout, "NO PARSE FOR: %s|%s|%s| |", trans, key, ref); |
| if (strcmp("FAIL", result) == 0) |
| pfprintf(fout, "PASSED (%s)\n", trans); |
| else |
| pfprintf(fout, "FAILED (%s)\n", trans); |
| } |
| else /*parsed, look at what was expected, what was returned and which of PASS/FAIL is expected */ |
| { |
| for (i = 0; i < result_count; i++) |
| { |
| len = MAX_STR_LENGTH; |
| if ((rc = semanticResults[i]->getValue(semanticResults[i], key, value, &len)) == ESR_SUCCESS) |
| { |
| pfprintf(fout, "%s|%s|%s|%s|", trans, key, ref, value); |
| |
| if (strcmp(value, ref) == 0 && strcmp("PASS", result) == 0) |
| pfprintf(fout, "PASSED\n"); |
| else |
| pfprintf(fout, "FAILED\n"); |
| } |
| else |
| { |
| pfprintf(fout, "ERROR: %s, while checking key='%s'\n", ESR_rc2str(rc), key); |
| } |
| } |
| |
| /*deallocate semantic results*/ |
| for (i = 0; i < MAX_SEM_RESULTS; i++) |
| { |
| rc = semanticResults[i]->destroy(semanticResults[i]); |
| if (rc != ESR_SUCCESS) |
| return rc; |
| } |
| } |
| return ESR_SUCCESS; |
| } |
| |
| int main(int argc, char **argv) |
| { |
| LCHAR trans[MAX_LINE_LENGTH]; |
| SR_Grammar* grammar = NULL; |
| ESR_ReturnCode rc; |
| LCHAR base[P_PATH_MAX] = L(""); |
| LCHAR infilename[P_PATH_MAX] = L(""); |
| LCHAR inRTfilename[P_PATH_MAX] = L(""); |
| LCHAR outfilename[P_PATH_MAX] = L(""); |
| PFile *fin = NULL, *fout = NULL; |
| int i; |
| LCHAR *rootrule = L("myRoot"), *p; |
| Opts opts = { 0, 0 }; |
| |
| /* |
| * Initialize portable library. |
| */ |
| CHKLOG(rc, PMemInit()); |
| |
| fin = PSTDIN; |
| fout = PSTDOUT; |
| |
| if (argc < 3) |
| { |
| usage(argv[0]); |
| exit(EXIT_FAILURE); |
| } |
| for (i = 1; i < argc; ++i) |
| { |
| if (!LSTRCMP(argv[i], L("-base"))) |
| { |
| ++i; |
| LSTRCPY(base, argv[i]); |
| } |
| else if (!LSTRCMP(argv[i], L("-in"))) |
| { |
| ++i; |
| LSTRCPY(infilename, argv[i]); |
| } |
| else if (!LSTRCMP(argv[i], L("-out"))) |
| { |
| ++i; |
| LSTRCPY(outfilename, argv[i]); |
| } |
| else if (!LSTRCMP(argv[i], L("-itest"))) |
| { |
| ++i; |
| LSTRCPY(inRTfilename, argv[i]); |
| } |
| else if (!LSTRCMP(argv[i], L("-ids"))) |
| { |
| opts.use_parse_by_string_ids = 1; |
| } |
| else if (!LSTRCMP(argv[i], L("-allids"))) |
| { |
| opts.do_check_all_ids = 1; |
| opts.use_parse_by_string_ids = 1; |
| } |
| else |
| return usage(argv[0]); |
| } |
| |
| CHK(rc, PLogInit(NULL, 0)); |
| |
| rc = SR_GrammarLoad(base, &grammar); |
| if (rc != ESR_SUCCESS) |
| goto CLEANUP; |
| |
| if (*outfilename) |
| { |
| if ((fout = pfopen(outfilename, "w")) == NULL) |
| { |
| pfprintf(PSTDOUT, "Could not open file: %s\n", outfilename); |
| rc = 1; |
| goto CLEANUP; |
| } |
| } |
| |
| if (opts.do_check_all_ids) |
| { |
| rc = Parse(grammar, NULL, fout, &opts); |
| } |
| else if (*infilename) |
| { |
| if (LSTRCMP(infilename, "-") == 0) |
| { |
| fin = PSTDIN; |
| } |
| else if ((fin = pfopen(infilename, "r")) == NULL) |
| { |
| pfprintf(PSTDOUT, "Could not open file: %s\n", infilename); |
| rc = 1; |
| goto CLEANUP; |
| } |
| for (;;) |
| { |
| if (pfgets(trans, MAX_LINE_LENGTH, fin) == NULL) |
| { |
| if (!pfeof(fin)) |
| { |
| rc = ESR_READ_ERROR; |
| PLogError(ESR_rc2str(rc)); |
| } |
| break; |
| } |
| if (trans[0] == '#') continue; |
| lstrtrim(trans); |
| /* check for multiple space separators! */ |
| lstr_strip_multiple_spaces(trans); |
| pfprintf(fout, "Transcription: %s\n", trans); |
| if ((rc = Parse(grammar, trans, fout, &opts)) != ESR_SUCCESS) |
| goto CLEANUP; |
| pfprintf(fout, "\n"); |
| } |
| } |
| else if (*inRTfilename) /*using a test file*/ |
| { |
| if ((fin = pfopen(inRTfilename, "r")) == NULL) |
| { |
| pfprintf(PSTDOUT, "Could not open test file: %s\n", inRTfilename); |
| rc = 1; |
| goto CLEANUP; |
| } |
| |
| /*read through the test file parsing it into the variables |
| FORMAT: "the transciption" key "value" |
| */ |
| while (ESR_TRUE) |
| { |
| if (0) rc = process_single_key_line(grammar, fin, fout); |
| else rc = process_multi_key_line(grammar, rootrule, fin, fout); |
| if (rc == ESR_READ_ERROR) |
| { |
| rc = ESR_SUCCESS; |
| break; |
| } |
| } |
| } |
| else |
| { |
| /* get some transcriptions from the user */ |
| pfprintf(PSTDOUT, "\nSemantic Parser Test Program for esr (Nuance Communicaitions, 2007)\n"); |
| pfprintf(PSTDOUT, "'qqq' to quit\n"); |
| |
| while (ESR_TRUE) |
| { |
| pfprintf(PSTDOUT, "> "); |
| |
| if (!fgets(trans, MAX_LINE_LENGTH, PSTDIN)) |
| break; |
| // remove trailing whitespace |
| for(p=&trans[0]; *p!=0 && *p!='\n' && *p!='\r'; p++) {} |
| *p=0; |
| |
| if (!LSTRCMP("qqq", trans)) |
| break; |
| else |
| if ((rc = Parse(grammar, trans, fout, &opts)) != ESR_SUCCESS) |
| goto CLEANUP; |
| } |
| } |
| CLEANUP: |
| if (fin && fin != PSTDIN) |
| pfclose(fin); |
| if (fout && fout != PSTDOUT) |
| pfclose(fout); |
| if (grammar) grammar->destroy(grammar); |
| PLogShutdown(); |
| /* PANSIFileSystemDestroy(); |
| PFileSystemDestroy();*/ |
| PMemShutdown(); |
| return rc; |
| } |
| |
| ESR_ReturnCode process_single_key_line(SR_Grammar* grammar, PFile* fin, PFile* fout) |
| { |
| LCHAR* position; |
| LCHAR line[MAX_LINE_LENGTH]; |
| LCHAR trans[MAX_LINE_LENGTH]; |
| LCHAR key[MAX_LINE_LENGTH]; |
| LCHAR refValue[MAX_LINE_LENGTH]; |
| LCHAR result[MAX_LINE_LENGTH]; |
| ESR_ReturnCode rc; |
| |
| position = pfgets(line, MAX_LINE_LENGTH, fin); |
| if (line[0] == '#') |
| return ESR_SUCCESS; |
| if (!strncmp(line, "__END__", 7)) |
| return ESR_READ_ERROR; |
| if (position == NULL) |
| { |
| if (pfeof(fin)) |
| return ESR_READ_ERROR; |
| else |
| { |
| PLogError(L("ESR_READ_ERROR")); |
| return ESR_READ_ERROR; |
| } |
| } |
| |
| //get the transcription to test |
| if ((position = strtok(line, "\"")) != NULL) |
| { |
| LSTRCPY(trans, position); |
| } |
| else |
| { |
| pfprintf(fout, "INVALID FORMAT for input line 1 \n"); |
| rc = ESR_INVALID_ARGUMENT; |
| goto CLEANUP; |
| } |
| |
| //get the key (meaning) |
| if ((position = strtok(NULL, " \t")) != NULL) |
| { |
| LSTRCPY(key, position); |
| } |
| else |
| { |
| pfprintf(fout, "INVALID FORMAT for input line 2\n"); |
| rc = ESR_INVALID_ARGUMENT; |
| goto CLEANUP; |
| } |
| |
| //get the expected return string |
| if ((position = strtok(NULL, "\"")) != NULL) |
| { |
| LSTRCPY(refValue, position); |
| } |
| else |
| { |
| pfprintf(fout, "INVALID FORMAT for input line 3\n"); |
| rc = ESR_INVALID_ARGUMENT; |
| goto CLEANUP; |
| } |
| |
| //get the expected result PASS/FAIL |
| //there is no need to write PASS, if nothing is written PASS is assumed |
| if ((position = strtok(NULL, " \t\r\n\"")) != NULL) |
| { |
| LSTRCPY(result, position); |
| |
| if (strcmp(result, "PASS") != 0 && strcmp(result, "FAIL") != 0) |
| { |
| pfprintf(fout, "INVALID FORMAT for input line, use either PASS or FAIL\n"); |
| rc = ESR_INVALID_ARGUMENT; |
| goto CLEANUP; |
| } |
| |
| if ((rc = ParseTestSet(grammar, trans, key, refValue, result, fout)) != ESR_SUCCESS) |
| goto CLEANUP; |
| } |
| else |
| { |
| if ((rc = ParseTestSet(grammar, trans, key, refValue, "PASS", fout)) != ESR_SUCCESS) |
| goto CLEANUP; |
| } |
| rc = ESR_SUCCESS; |
| CLEANUP: |
| return rc; |
| } |
| |
| ESR_ReturnCode process_multi_key_line(SR_Grammar* grammar, const LCHAR* rootrule, PFile* fin, PFile* fout) |
| { |
| LCHAR *position, *p; |
| LCHAR line[MAX_LINE_LENGTH]; |
| LCHAR trans[MAX_LINE_LENGTH]; |
| LCHAR keyvals[MAX_LINE_LENGTH]; |
| ESR_ReturnCode rc; |
| SR_SemanticResult* semanticResults[MAX_SEM_RESULTS]; |
| LCHAR refkey[MAX_LINE_LENGTH]; |
| LCHAR refval[MAX_LINE_LENGTH], value[MAX_STR_LENGTH]; |
| size_t i, j, len; |
| size_t result_count; |
| |
| position = pfgets(line, MAX_LINE_LENGTH, fin); |
| if (line[0] == '#') |
| return ESR_SUCCESS; |
| if (!strncmp(line, "__END__", 7)) |
| return ESR_READ_ERROR; |
| if (position == NULL) |
| { |
| if (pfeof(fin)) |
| return ESR_READ_ERROR; |
| else |
| { |
| PLogError(L("ESR_READ_ERROR")); |
| return ESR_READ_ERROR; |
| } |
| } |
| |
| /* we're trying to parse |
| Hello there : BONJOUR |
| */ |
| p = strtok(line, ":"); |
| LSTRCPY(trans, p); |
| /* strip trailing spaces */ |
| for (len = strlen(trans); len > 0 && trans[len-1] == ' '; len--) |
| trans[len-1] = 0; |
| |
| p = strtok(NULL, "\n\r"); |
| /* strip leading spaces */ |
| while (*p == ' ' || *p == '\t') p++; |
| LSTRCPY(keyvals, p); |
| |
| result_count = MAX_SEM_RESULTS; |
| for (i = 0; i < result_count; i++) |
| SR_SemanticResultCreate(&semanticResults[i]); |
| |
| /* pfprintf(fout,"checking (%s) ref(%s)\n", trans, keyvals); */ |
| rc = grammar->checkParse(grammar, trans, semanticResults, (size_t*) & result_count); |
| if (rc != ESR_SUCCESS) |
| return rc; |
| |
| /*result file will contain |
| transcription | key | reference | result | PASSESD/FAILED */ |
| |
| if (result_count < 1) /*failed to parse, but this could still be a pass if you expected a failure*/ |
| { |
| pfprintf(fout, "%s|%s| |", trans, keyvals); |
| if (!strcmp("FAIL", keyvals) || !strcmp(keyvals, "-")) |
| pfprintf(fout, "PASSED\n"); |
| else |
| pfprintf(fout, "FAILED\n"); |
| } |
| else /*parsed, look at what was expected, what was returned and which of PASS/FAIL is expected */ |
| { |
| size_t size, len; |
| LCHAR* keys_available[MAX_KEYS]; /* array of pointers to strings */ |
| size = MAX_KEYS; |
| rc = semanticResults[0]->getKeyList(semanticResults[0], (LCHAR**) & keys_available, &size); |
| |
| for (p = strtok(keyvals, ";"); p; p = strtok(NULL, ";")) |
| { |
| sprintf(refkey, "%s.%s", rootrule, p); |
| p = strchr(refkey, '='); |
| assert(p); |
| *p = 0; |
| p++; |
| if (*p == '\'') p++; |
| LSTRCPY(refval, p); |
| if (refval[ strlen(refval)-1] == '\'') refval[strlen(refval)-1] = 0; |
| |
| for (i = 0; i < result_count; i++) |
| { |
| len = MAX_STR_LENGTH; |
| for (j = 0; j < size; j++) |
| if (!strcmp(keys_available[j], refkey)) break; |
| if (j < size) |
| rc = semanticResults[i]->getValue(semanticResults[i], refkey, value, &len); |
| else |
| { |
| LSTRCPY(value, "<NOSUCHKEY>"); |
| rc = ESR_NO_MATCH_ERROR; |
| } |
| pfprintf(fout, "%s|%s|%s|%s|", trans, refkey, refval, value); |
| if (strcmp(value, refval) == 0) |
| pfprintf(fout, "PASSED\n"); |
| else |
| pfprintf(fout, "FAILED\n"); |
| } |
| } |
| |
| /*deallocate semantic results*/ |
| for (i = 0; i < MAX_SEM_RESULTS; i++) |
| { |
| rc = semanticResults[i]->destroy(semanticResults[i]); |
| if (rc != ESR_SUCCESS) |
| PLogError("%s while destroying", ESR_rc2str(rc)); |
| } |
| } |
| return ESR_SUCCESS; |
| } |
| |
