void ProofControlInit(ProofState_p state,ProofControl_p control, HeuristicParms_p params, FVIndexParms_p fvi_params, PStack_p wfcb_defs, PStack_p hcb_defs) { PStackPointer sp; Scanner_p in; assert(control && control->wfcbs); assert(state && state->axioms && state->signature); assert(params); assert(!control->ocb); assert(!control->hcb); SpecFeaturesCompute(&(control->problem_specs), state->axioms,state->signature); control->ocb = TOSelectOrdering(state, params, &(control->problem_specs)); in = CreateScanner(StreamTypeInternalString, DefaultWeightFunctions, true, NULL); WeightFunDefListParse(control->wfcbs, in, control->ocb, state); DestroyScanner(in); for(sp = 0; sp < PStackGetSP(wfcb_defs); sp++) { in = CreateScanner(StreamTypeOptionString, PStackElementP(wfcb_defs, sp) , true, NULL); WeightFunDefListParse(control->wfcbs, in, control->ocb, state); DestroyScanner(in); } in = CreateScanner(StreamTypeInternalString, DefaultHeuristics, true, NULL); HeuristicDefListParse(control->hcbs, in, control->wfcbs, control->ocb, state); DestroyScanner(in); for(sp = 0; sp < PStackGetSP(hcb_defs); sp++) { in = CreateScanner(StreamTypeOptionString, PStackElementP(hcb_defs, sp) , true, NULL); HeuristicDefListParse(control->hcbs, in, control->wfcbs, control->ocb, state); DestroyScanner(in); } control->heuristic_parms = *params; control->fvi_parms = *fvi_params; control->hcb = GetHeuristic(params->heuristic_name, state, control, params); if(!control->heuristic_parms.split_clauses) { control->fvi_parms.symbol_slack = 0; } }
static String ParseEncoding(InStm *stm) { Ptr<LexScanner> scanner = CreateScanner(stm); // skip version if (scanner->GetToken() != LexScanner::Token(LexScanner::XMLDECL) || scanner->GetToken().type_ != LexScanner::VERSION) { scanner->Error("XML version error"); } // check if next is encoding LexScanner::Token t = scanner->GetToken(); if(t != LexScanner::Token(LexScanner::ENCODING)) return "UTF-8"; // skip '=' if (scanner->GetToken().type_ != LexScanner::EQ) scanner->Error("XML header: '=' expected"); // next should be string value t = scanner->GetToken(); if(t.type_ != LexScanner::VALUE) scanner->Error("XML header: 'value' expected"); return t.s_; }
void process_formulas(char* infile, TB_p terms, OCB_p ocb, ClauseSet_p *demodulators) { WFormula_p form; Scanner_p in; if(infile) { in = CreateScanner(StreamTypeFile, infile, true, NULL); ScannerSetFormat(in, parse_format); while(!TestInpTok(in, NoToken)) { form = WFormulaParse(in, terms); WFormulaPrint(GlobalOut, form, true); form->tformula = TermComputeLINormalform(ocb, terms, form->tformula, demodulators, 1, false, false); fprintf(GlobalOut, " ==> "); WFormulaPrint(GlobalOut, form, true); fprintf(GlobalOut, "\n"); WFormulaFree(form); } DestroyScanner(in); } }
bool FileVarsGetIdentifier(FileVars_p vars, char* name, char **value) { StrTree_p cell = StrTreeFind(&(vars->vars), name); Scanner_p in; if(!cell) { return false; } in = CreateScanner(StreamTypeInternalString, cell->val1.p_val, true, NULL); if(!TestInpTok(in, Identifier)) { DStr_p errpos = DStrAlloc(); DStrAppendStr(errpos, "Identifier value requested for file variable "); DStrAppendStr(errpos, name); DStrAppendStr(errpos, "read from \""); DStrAppendStr(errpos, cell->val2.p_val); DStrAppendStr(errpos, "\", but no such value present."); Error(DStrView(errpos), SYNTAX_ERROR); DStrFree(errpos); } DestroyScanner(in); *value = cell->val1.p_val; return true; }
long FileVarsReadFromFile(char* file, FileVars_p vars) { long res; Scanner_p in; in = CreateScanner(StreamTypeFile, file, true, NULL); res = FileVarsParse(in, vars); DestroyScanner(in); return res; }
ProofState_p parse_spec(CLState_p state, IOFormat parse_format, bool error_on_empty, FunctionProperties free_symb_prop, long* ax_no) { ProofState_p proofstate; Scanner_p in; int i; StrTree_p skip_includes = NULL; long parsed_ax_no; proofstate = ProofStateAlloc(free_symb_prop); for(i=0; state->argv[i]; i++) { in = CreateScanner(StreamTypeFile, state->argv[i], true, NULL); ScannerSetFormat(in, parse_format); FormulaAndClauseSetParse(in, proofstate->axioms, proofstate->f_axioms, proofstate->original_terms, NULL, &skip_includes); CheckInpTok(in, NoToken); DestroyScanner(in); } VERBOUT2("Specification read\n"); parsed_ax_no = ProofStateAxNo(proofstate); if(error_on_empty && (parsed_ax_no == 0)) { #ifdef PRINT_SOMEERRORS_STDOUT fprintf(GlobalOut, "# Error: Input file contains no clauses or formulas\n"); TSTPOUT(GlobalOut, "InputError"); #endif Error("Input file contains no clauses or formulas", OTHER_ERROR); } *ax_no = parsed_ax_no; return proofstate; }
void process_raw_feature_files(char *argv[], SpecLimits_p limits) { char *name; int i; Scanner_p in; RawSpecFeatureCell features; for(i=0; argv[i]; i++) { in = CreateScanner(StreamTypeFile, argv[i], true, NULL); while(!TestInpTok(in, NoToken)) { name = parse_raw_feature_line(in, &features); RawSpecFeaturesClassify(&features, limits, raw_mask); fprintf(GlobalOut, "%s : ", name); RawSpecFeaturesPrint(GlobalOut, &features); fprintf(GlobalOut, "\n"); FREE(name); } DestroyScanner(in); } }
void process_terms(char* infile, TB_p terms, OCB_p ocb, ClauseSet_p *demodulators) { Term_p t, tp; Scanner_p in; if(infile) { in = CreateScanner(StreamTypeFile, infile, true, NULL); ScannerSetFormat(in, parse_format); while(!TestInpTok(in, NoToken)) { t = TBTermParse(in, terms); tp = TermComputeLINormalform(ocb, terms, t, demodulators, 1, false, false); TBPrintTermFull(GlobalOut, terms, t); fprintf(GlobalOut, " ==> "); TBPrintTermFull(GlobalOut, terms, tp); fprintf(GlobalOut, "\n"); } DestroyScanner(in); } }
void process_clauses(char* infile, TB_p terms, OCB_p ocb, ClauseSet_p *demodulators) { Clause_p clause; Scanner_p in; if(infile) { in = CreateScanner(StreamTypeFile, infile, true, NULL); ScannerSetFormat(in, parse_format); while(!TestInpTok(in, NoToken)) { clause = ClauseParse(in, terms); ClausePrint(GlobalOut, clause, true); ClauseComputeLINormalform(ocb, terms, clause, demodulators, 1, false); fprintf(GlobalOut, " ==> "); ClausePrint(GlobalOut, clause, true); fprintf(GlobalOut, "\n"); ClauseFree(clause); } DestroyScanner(in); } }
int main(int argc, char* argv[]) { /* Scanner_p in; */ CLState_p state; Scanner_p in; PCLProt_p prot; long steps, proof_steps, neg_steps; int i; assert(argv[0]); InitIO(NAME); ESignalSetup(SIGTERM); ESignalSetup(SIGINT); /* We need consistent name->var mappings here because we potentially read the compressed input format. */ ClausesHaveLocalVariables = false; state = process_options(argc, argv); GlobalOut = OutOpen(outname); OpenGlobalOut(outname); prot = PCLProtAlloc(); if(state->argc == 0) { CLStateInsertArg(state, "-"); } steps = 0; for(i=0; state->argv[i]; i++) { in = CreateScanner(StreamTypeFile, state->argv[i], true, NULL); ScannerSetFormat(in, TPTPFormat); steps+=PCLProtParse(in, prot); CheckInpTok(in, NoToken); DestroyScanner(in); } VERBOUT2("PCL input read\n"); PCLProtStripFOF(prot); PCLProtResetTreeData(prot, false); PCLProtMarkProofClauses(prot); PCLProtProofDistance(prot); PCLProtUpdateGRefs(prot); proof_steps = PCLProtCountProp(prot, PCLIsProofStep); neg_steps = proof_steps?neg_proportion*proof_steps:neg_examples; PCLProtSelectExamples(prot, neg_steps); fprintf(GlobalOut, "# Axioms:\n"); PCLProtPrintPropClauses(GlobalOut, prot, PCLIsInitial, lop_format); fprintf(GlobalOut, ".\n\n# Examples:\n"); PCLProtPrintExamples(GlobalOut, prot); PCLProtFree(prot); CLStateFree(state); fflush(GlobalOut); OutClose(GlobalOut); ExitIO(); #ifdef CLB_MEMORY_DEBUG MemFlushFreeList(); MemDebugPrintStats(stdout); #endif return EXIT_SUCCESS; }
int main(int argc, char* argv[]) { ProofState_p fstate; Scanner_p in; int i; CLState_p state; SpecFeatureCell features; SpecLimits_p limits; StrTree_p skip_includes = NULL; assert(argv[0]); InitIO(NAME); limits = SpecLimitsAlloc(); state = process_options(argc, argv, limits); OpenGlobalOut(outname); if(state->argc == 0) { CLStateInsertArg(state, "-"); } if(parse_features) { if(raw_classify) { process_raw_feature_files(state->argv, limits); } else { process_feature_files(state->argv, limits); } } else { for(i=0; state->argv[i]; i++) { fstate = ProofStateAlloc(FPIgnoreProps); in = CreateScanner(StreamTypeFile, state->argv[i], true, NULL); ScannerSetFormat(in, parse_format); FormulaAndClauseSetParse(in, fstate->axioms, fstate->f_axioms, fstate->original_terms, NULL, & skip_includes); if(raw_classify) { do_raw_classification(state->argv[i], fstate, limits); } else { FormulaSetPreprocConjectures(fstate->f_axioms, fstate->f_ax_archive, false, false); FormulaSetCNF(fstate->f_axioms, fstate->f_ax_archive, fstate->axioms, fstate->original_terms, fstate->freshvars, fstate->gc_original_terms); if(!no_preproc) { ClauseSetPreprocess(fstate->axioms, fstate->watchlist, fstate->archive, fstate->tmp_terms, eqdef_incrlimit, eqdef_maxclauses); } SpecFeaturesCompute(&features, fstate->axioms, fstate->signature); SpecFeaturesAddEval(&features, limits); if(!tptp_header) { fprintf(GlobalOut, "%s : ", state->argv[i]); SpecFeaturesPrint(GlobalOut, &features); fprintf(GlobalOut, " : "); SpecTypePrint(GlobalOut, &features, mask); fprintf(GlobalOut, "\n"); } else { print_tptp_header(fstate, features); } DestroyScanner(in); ProofStateFree(fstate); } } } CLStateFree(state); SpecLimitsCellFree(limits); fflush(GlobalOut); OutClose(GlobalOut); ExitIO(); #ifdef CLB_MEMORY_DEBUG MemFlushFreeList(); MemDebugPrintStats(stdout); #endif return 0; }
int main(int argc, char* argv[]) { TB_p terms; GCAdmin_p collector; VarBank_p freshvars; Sig_p sig; ClauseSet_p clauses; FormulaSet_p formulas, f_ax_archive; Scanner_p in; int i; CLState_p state; StrTree_p skip_includes = NULL; ClauseSet_p demodulators[1]; OCB_p ocb; assert(argv[0]); InitIO(NAME); #ifdef STACK_SIZE IncreaseMaxStackSize(argv, STACK_SIZE); #endif ESignalSetup(SIGXCPU); state = process_options(argc, argv); OpenGlobalOut(outname); if(state->argc == 0) { CLStateInsertArg(state, "-"); } sig = SigAlloc(); SigInsertInternalCodes(sig); terms = TBAlloc(sig); collector = GCAdminAlloc(terms); clauses = ClauseSetAlloc(); formulas = FormulaSetAlloc(); f_ax_archive = FormulaSetAlloc(); GCRegisterClauseSet(collector, clauses); GCRegisterFormulaSet(collector, formulas); GCRegisterFormulaSet(collector, f_ax_archive); for(i=0; state->argv[i]; i++) { in = CreateScanner(StreamTypeFile, state->argv[i], true, NULL); ScannerSetFormat(in, parse_format); /* ClauseSetParseList(in, clauses, terms); */ FormulaAndClauseSetParse(in,clauses, formulas, terms, NULL, &skip_includes); CheckInpTok(in, NoToken); DestroyScanner(in); } CLStateFree(state); if(FormulaSetPreprocConjectures(formulas, f_ax_archive, false, false)) { VERBOUT("Negated conjectures.\n"); } freshvars = VarBankAlloc(); if(FormulaSetCNF(formulas, f_ax_archive, clauses, terms, freshvars, collector)) { VERBOUT("CNFization done\n"); } VarBankFree(freshvars); GCDeregisterFormulaSet(collector, formulas); FormulaSetFree(formulas); GCDeregisterFormulaSet(collector, f_ax_archive); FormulaSetFree(f_ax_archive); demodulators[0] = ClauseSetAlloc(); demodulators[0]->demod_index = PDTreeAlloc(); GCRegisterClauseSet(collector, demodulators[0]); build_rw_system(demodulators[0], clauses); GCDeregisterClauseSet(collector, clauses); ClauseSetFree(clauses); VERBOUT("# Demodulators\n"); VERBOSE(ClauseSetPrint(stderr, demodulators[0], true););
int main(int argc, char* argv[]) { CLState_p state; Scanner_p in; BatchSpec_p spec; StructFOFSpec_p ctrl; char *prover = "eprover"; char *category = NULL; char *train_dir = NULL; long now, start, res; assert(argv[0]); InitIO(NAME); DocOutputFormat = tstp_format; OutputFormat = TSTPFormat; state = process_options(argc, argv); OpenGlobalOut(outname); if((state->argc < 1) || (state->argc > 2)) { Error("Usage: e_ltb_runner <spec> [<path-to-eprover>] \n", USAGE_ERROR); } if(state->argc >= 2) { prover = state->argv[1]; } in = CreateScanner(StreamTypeFile, state->argv[0], true, NULL); ScannerSetFormat(in, TSTPFormat); AcceptDottedId(in, "division.category"); category = ParseDottedId(in); if(TestInpId(in, "division")) { AcceptDottedId(in, "division.category.training_directory"); train_dir = ParseContinous(in); } while(!TestInpTok(in, NoToken)) { start = GetSecTime(); spec = BatchSpecParse(in, prover, category, train_dir, TSTPFormat); /* BatchSpecPrint(GlobalOut, spec); */ if(total_wtc_limit && !spec->total_wtc_limit) { spec->total_wtc_limit = total_wtc_limit; } if(spec->per_prob_limit<=0 && total_wtc_limit<=0) { Error("Either the per-problem time limit or the global " "time limit must be set to a value > 0", USAGE_ERROR); } /* BatchSpecPrint(stdout, spec); */ ctrl = StructFOFSpecAlloc(); BatchStructFOFSpecInit(spec, ctrl); now = GetSecTime(); res = BatchProcessProblems(spec, ctrl, MAX(0,total_wtc_limit-(now-start))); now = GetSecTime(); fprintf(GlobalOut, "\n\n# == WCT: %4lds, Solved: %4ld/%4d ==\n", now-start, res, BatchSpecProblemNo(spec)); if(interactive) { BatchProcessInteractive(spec, ctrl, stdout); } StructFOFSpecFree(ctrl); BatchSpecFree(spec); fprintf(GlobalOut, "# =============== Batch done ===========\n\n"); } DestroyScanner(in); if(category) { FREE(category); } if(train_dir) { FREE(train_dir); } CLStateFree(state); OutClose(GlobalOut); ExitIO(); #ifdef CLB_MEMORY_DEBUG MemFlushFreeList(); MemDebugPrintStats(stdout); #endif return 0; }
int main(int argc, char* argv[]) { CLState_p state; StructFOFSpec_p ctrl; PStack_p prob_names = PStackAlloc(); int i; AxFilterSet_p filters; Scanner_p in; DStr_p corename; char *tname; assert(argv[0]); InitIO(NAME); DocOutputFormat = tstp_format; OutputFormat = TSTPFormat; state = process_options(argc, argv); OpenGlobalOut(outname); if(filtername) { filters = AxFilterSetAlloc(); in = CreateScanner(StreamTypeFile, filtername, true, NULL); AxFilterSetParse(in, filters); DestroyScanner(in); } else { filters = AxFilterSetCreateInternal(AxFilterDefaultSet); } if(dumpfilter) { AxFilterSetPrint(GlobalOut, filters); } if(state->argc < 1) { Error("Usage: e_axfilter <problem> [<options>]\n", USAGE_ERROR); } for(i=0; state->argv[i]; i++) { PStackPushP(prob_names, state->argv[i]); } /* Base name is the stripped base of the first argument */ tname = FileNameStrip(state->argv[0]); corename = DStrAlloc(); DStrAppendStr(corename, tname); FREE(tname); ctrl = StructFOFSpecAlloc(); StructFOFSpecParseAxioms(ctrl, prob_names, parse_format); StructFOFSpecInitDistrib(ctrl); StructFOFSpecResetShared(ctrl); for(i=0; i<AxFilterSetElements(filters); i++) { /* SigPrint(stdout,ctrl->sig); */ filter_problem(ctrl, AxFilterSetGetFilter(filters,i), DStrView(corename)); } StructFOFSpecFree(ctrl); DStrFree(corename); AxFilterSetFree(filters); CLStateFree(state); PStackFree(prob_names); OutClose(GlobalOut); ExitIO(); #ifdef CLB_MEMORY_DEBUG MemFlushFreeList(); MemDebugPrintStats(stdout); #endif return 0; }