int main(int argc, char* argv[]) {
int n,i;
int last_pipe[2];
struct grammar g;
if (argc != 4) {
fatal("Usage: %s <workers number> <grammar file> <starting symbol>\n",
argv[0]);
}
n = atoi(argv[1]);
if (n <= 0) {
fatal("Number of workers should be a positive integer");
}
if (strlen(argv[3]) != 1 || !is_upper(argv[3][0])) {
fatal("Starting symbol should be a single nonterminal (uppercase)\n");
}
create_pipe(last_pipe);
make_loop(n, last_pipe, argv[2]);
read_grammar(&g, argv[2]);
work(&g, argv[3][0]);
for (i = 1; i < n; i++) {
if (wait(0) == -1) syserr("Error in wait()\n");
}
return 0;
}
int main()
{
std::list<std::string> sentence = gen_sentence(read_grammar(std::cin));
std::list<std::string>::const_iterator it = sentence.begin();
if(!sentence.empty()) {
std::cout << *it;
++it;
}
while(it != sentence.end()) {
std::cout << " " << *it;
++it;
}
std::cout << std::endl;
return 0;
}
int main() {
// Read in grammar and generate a sentence from it
std::vector<std::string> sentence = gen_sentence(read_grammar(std::cin));
// write sentence to screen
std::vector<std::string>::const_iterator it = sentence.begin();
if (!sentence.empty()) {
std::cout << *it;
++it;
}
while (it != sentence.end()) {
std::cout << " " << *it;
++it;
}
std::cout << std::endl;
return 0;
}
int main(int argc, char *argv[]) {
//regex_test();
/*
CFG<Parse_data> *cfg = read_grammar(ss.str());
if (cfg)
cout << endl << cfg->str() << endl << endl;
*/
SymbolTable *symtab = new SymbolTable();
Lexer<int> *lexer = read_lexer(file_to_string(argv[1]), symtab);
CFG<int> *cfg = read_grammar(file_to_string(argv[2]), symtab);
//cout << cfg->dfa->str() << endl << endl;
cfg->parse(lexer->lex(file_to_string(argv[3]), true, true), true);
// for (int i = 0; i < lexer->rules.size()-2; ++i) {
// cout << lexer->rules[i].regex.dfa->str() << endl;
// }
return 0;
}
int
main(int argc, char **argv)
{
si_t si = make_si(1024);
FILE *grammarfp = stdin;
FILE *yieldfp;
FILE *tracefp = stderr; /* set this to NULL to stop trace output */
FILE *summaryfp = stderr; /* set this to NULL to stop parse stats */
grammar g0, g = NULL;
int maxlen = 0, minits = 0, maxits = 0;
FLOAT stoptol = 1e-7;
int nanneal = 0, randseed = 97;
FLOAT rule_bias_default = 0;
FLOAT annealstart = 1, annealstop = 1;
FLOAT jitter0 = 0, jitter = 0;
int debuglevel = 0, nruns = 1, irun = 0;
FLOAT wordscale=1;
int VariationalBayes=0;
int tmp;
char filename[100];
{
int chr;
while ((chr = getopt(argc, argv, "a:g:s:p:l:m:n:d:t:b:B:N:j:J:S:d:R:T:VW:")) != -1)
switch (chr) {
case 'a':
rule_bias_default = atof(optarg);
break;
case 'g':
memcpy (filename, optarg, strlen (optarg));
tmp = strlen (optarg);
filename[tmp] = 'N';
tmp++;
filename[tmp] = 'e';
tmp++;
filename[tmp] = 'w';
tmp++;
filename[tmp] = '\0';
tmp++;
grammarfp = fopen(optarg, "r");
if (grammarfp == NULL) {
fprintf(stderr, "Error: couldn't open grammarfile %s\n%s",
optarg, usage);
exit(EXIT_FAILURE);
}
break;
case 's':
stoptol = atof(optarg);
break;
case 'p':
minruleprob = atof(optarg);
break;
case 'l':
maxlen = atoi(optarg);
break;
case 'm':
minits = atoi(optarg);
break;
case 'n':
maxits = atoi(optarg);
break;
case 'b':
annealstart = atof(optarg);
break;
case 'B':
annealstop = atof(optarg);
break;
case 'N':
nanneal = atoi(optarg);
break;
case 'j':
jitter0 = atof(optarg);
break;
case 'J':
jitter = atof(optarg);
break;
case 'S':
randseed = atoi(optarg);
break;
case 'd':
debuglevel = atoi(optarg);
break;
case 'R':
nruns = atoi(optarg);
break;
case 'T':
summaryfp = fopen(optarg, "w");
break;
case 'V':
VariationalBayes = 1;
break;
case 'W':
wordscale = atof(optarg);
break;
case '?':
default:
fprintf(stderr, "Error: unknown command line flag %c\n\n%s\n",
chr, usage);
exit(EXIT_FAILURE);
break;
}
}
if (optind + 1 != argc) {
fprintf(stderr, "Error: expect a yieldfile\n\n%s\n", usage);
exit(EXIT_FAILURE);
}
if ((yieldfp = fopen(argv[optind], "r")) == NULL) {
fprintf(stderr, "Error: Couldn't open yieldfile %s\n%s", argv[optind], usage);
exit(EXIT_FAILURE);
}
srand(randseed);
if (summaryfp && debuglevel >= 100)
fprintf(summaryfp, "# rule_bias_default (-a) = %g, stoptol (-s) = %g, minruleprob (-p) = %g, "
"maxlen (-l) = %d, minits (-m) = %d, maxits = (-n) = %d, annealstart (-b) = %g, "
"annealstop (-B) = %g, nanneal (-N) = %d, jitter0 (-j) = %g, jitter (-J) = %g, "
"VariationalBayes (-V) = %d, wordscale (-W) = %g, randseed (-S) = %d, "
"debuglevel (-d) = %d, nruns (-R) = %d\n",
rule_bias_default, stoptol, minruleprob, maxlen, minits, maxits, annealstart,
annealstop, nanneal, jitter0, jitter, VariationalBayes, wordscale, randseed, debuglevel, nruns);
g0 = read_grammar(grammarfp, si, rule_bias_default);
write_grammar(stdout, g0, si, minruleprob);
set_rule_weights(g0, g0->weights, VariationalBayes); /* normalize rule counts */
signal(SIGINT, write_grammar_);
for (irun = 0; irun < nruns; ++irun) {
FLOAT entropy;
g = copy_grammar(g0, si);
if (summaryfp && debuglevel >= 100)
fprintf(summaryfp, "# Run %d\n", irun);
g_global = g;
si_global = si;
if (jitter0 > 0)
jitter_weights(g, jitter0);
entropy = inside_outside(g, si, yieldfp, tracefp, summaryfp, debuglevel, maxlen,
minits, maxits, stoptol, minruleprob, jitter, VariationalBayes, wordscale,
annealstart, annealstop, nanneal);
if (summaryfp && debuglevel >= 0)
fprintf(summaryfp, "# run %d, entropy %g, %ld rules\n", irun, entropy, (long) g->nrules);
if (debuglevel >= 1) {
write_grammar(stdout, g, si, minruleprob);
FILE* grammarfp = fopen(filename, "w");
//write_grammar(stdout, g, si, minruleprob);
write_grammar(grammarfp, g, si, minruleprob);
fprintf(stdout, "\n");
fflush(stdout);
}
free_grammar(g);
}
free_grammar(g0);
si_free(si);
if (mmm_blocks_allocated)
fprintf(stderr, "Error in mrf(): %ld memory block(s) not deallocated\n",
mmm_blocks_allocated);
/* check that everything has been deallocated */
assert(mmm_blocks_allocated == 0);
exit(EXIT_SUCCESS);
}
int
main(int argc, char **argv)
{
si_t si = make_si(1024);
FILE *grammarfp = stdin, *yieldfp;
FILE *tracefp = NULL; /* trace output */
FILE *summaryfp = stderr; /* end of parse stats output */
FILE *parsefp = stdout; /* parse trees */
FILE *probfp = NULL; /* max_neglog_prob */
chart_cell root_cell;
grammar g;
chart c;
vindex terms;
int maxsentlen = 0;
int sentenceno = 0, parsed_sentences = 0, failed_sentences = 0;
double sum_neglog_prob = 0;
int sentfrom = 0;
int sentto = 0;
srand(RAND_SEED); /* seed random number generator */
if (argc<2 || argc>6) {
fprintf(stderr, "%s yieldfile [maxsentlen [grammarfile [sentfrom sentto]]]\n", argv[0]);
exit(EXIT_FAILURE);
}
if ((yieldfp = fopen(argv[1], "r")) == NULL) {
fprintf(stderr, "%s: Couldn't open yieldfile %s\n", argv[0], argv[1]);
exit(EXIT_FAILURE);
}
if (argc >= 3)
if (!sscanf(argv[2], "%d", &maxsentlen)) {
fprintf(stderr, "%s: Couldn't parse maxsentlen %s\n", argv[0], argv[2]);
exit(EXIT_FAILURE);
}
if (argc >= 4)
if ((grammarfp = fopen(argv[3], "r")) == NULL) {
fprintf(stderr, "%s: Couldn't open grammarfile %s\n", argv[0], argv[3]);
exit(EXIT_FAILURE);
}
if (argc >= 6) {
if (!sscanf(argv[4], "%d", &sentfrom)) {
fprintf(stderr, "%s: Couldn't parse sentfrom %s\n", argv[0], argv[4]);
exit(EXIT_FAILURE);
}
if (!sscanf(argv[5], "%d", &sentto)) {
fprintf(stderr, "%s: Couldn't parse sentto %s\n", argv[0], argv[5]);
exit(EXIT_FAILURE);
}
}
g = read_grammar(grammarfp, si);
/* write_grammar(tracefp, g, si); */
while ((terms = read_terms(yieldfp, si))) {
sentenceno++;
if (sentfrom && sentenceno < sentfrom) {
vindex_free(terms);
continue;
}
if (sentto && sentenceno > sentto) {
vindex_free(terms);
break;
}
/* skip if sentence is too long */
if (!maxsentlen || (int) terms->n <= maxsentlen) {
size_t i;
if (tracefp) {
fprintf(tracefp, "\nSentence %d:\n", sentenceno);
for (i=0; i<terms->n; i++)
fprintf(tracefp, " %s", si_index_string(si, terms->e[i]));
fprintf(tracefp, "\n");
}
c = cky(*terms, g, si);
/* fetch best root node */
root_cell = sihashcc_ref(CHART_ENTRY(c, 0, terms->n), g.root_label);
if (root_cell) {
tree parse_tree = bintree_tree(&root_cell->tree, si);
double prob = (double) root_cell->prob;
parsed_sentences++;
assert(prob > 0.0);
sum_neglog_prob -= log(prob);
if (probfp)
fprintf(probfp, "max_neglog_prob(%d, %g).\n",
sentenceno, -log(prob));
if (tracefp)
fprintf(tracefp, " Prob = %g\n", prob);
if (parsefp) {
write_tree(parsefp, parse_tree, si);
fprintf(parsefp, "\n");
/* write_prolog_tree(parsefp, parse_tree, si); */
}
free_tree(parse_tree);
}
else {
failed_sentences++;
if (tracefp)
fprintf(tracefp, "Failed to parse\n");
if (parsefp)
fprintf(parsefp, "parse_failure.\n");
}
chart_free(c, terms->n); /* free the chart */
}
else { /* sentence too long */
if (parsefp)
fprintf(parsefp, "too_long.\n");
}
vindex_free(terms); /* free the terms */
assert(trees_allocated == 0);
assert(bintrees_allocated == 0);
}
free_grammar(g);
si_free(si);
if (summaryfp) {
fprintf(summaryfp, "\n%d/%d = %g%% test sentences met the length criteron,"
" of which %d/%d = %g%% were parsed\n",
parsed_sentences+failed_sentences, sentenceno,
(double) (100.0 * (parsed_sentences+failed_sentences)) /
sentenceno,
parsed_sentences, parsed_sentences+failed_sentences,
(double) (100.0 * parsed_sentences) /
(parsed_sentences + failed_sentences));
fprintf(summaryfp, "Sum(-log prob) = %g\n", sum_neglog_prob);
}
/* check that everything has been deallocated */
/* printf("mmm_blocks_allocated = %ld\n", (long) mmm_blocks_allocated); */
assert(mmm_blocks_allocated == 0);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int s;
int numsentences;
FILE *words;
char grammar[1000];
char buffer[1000];
float temp;
int npflag;
time_t g_time;
time_t s_time;
if(argc!=8)
{
fprintf(stderr,"ERROR in command line, usage:\n cat countsfile | parser.out sentences-file grammarfile beamsize punctuation-flag distaflag distvflag npflag\n");
return 0;
}
sscanf(argv[1],"%s",buffer);
words=fopen(buffer,"r");
assert(words!=NULL);
sscanf(argv[2],"%s",grammar);
sscanf(argv[3],"%f",&temp);
BEAMPROB = log(temp);
sscanf(argv[4],"%d",&PUNC_FLAG);
sscanf(argv[5],"%d",&DISTAFLAG);
sscanf(argv[6],"%d",&DISTVFLAG);
sscanf(argv[7],"%d",&npflag);
assert(npflag==0 || npflag==1);
set_treebankoutputflag(npflag);
mymalloc_init();
mymalloc_char_init();
hash_make_table(8000007,&new_hash);
effhash_make_table(1000003,&eff_hash);
read_grammar(grammar);
numsentences=read_sentences(words,sentences,2500);
fprintf(stderr,"NUMSENTENCES %d\n",numsentences);
read_events(stdin,&new_hash,-1);
for(s=0;s<numsentences;s++)
{
time(&g_time);
pthresh = -5000000;
parse_sentence(&sentences[s]);
/* print_chart();*/
time(&s_time);
printf("TIME %d\n",(int) (s_time-g_time));
}
return 1;
}
