| /**************************************************************/ | |
| /* ********************************************************** */ | |
| /* * * */ | |
| /* * FLAGS OF SPASS * */ | |
| /* * * */ | |
| /* * $Module: FLAGS * */ | |
| /* * * */ | |
| /* * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 * */ | |
| /* * MPI fuer Informatik * */ | |
| /* * * */ | |
| /* * This program is free software; you can redistribute * */ | |
| /* * it and/or modify it under the terms of the GNU * */ | |
| /* * General Public License as published by the Free * */ | |
| /* * Software Foundation; either version 2 of the License, * */ | |
| /* * or (at your option) any later version. * */ | |
| /* * * */ | |
| /* * This program is distributed in the hope that it will * */ | |
| /* * be useful, but WITHOUT ANY WARRANTY; without even * */ | |
| /* * the implied warranty of MERCHANTABILITY or FITNESS * */ | |
| /* * FOR A PARTICULAR PURPOSE. See the GNU General Public * */ | |
| /* * License for more details. * */ | |
| /* * * */ | |
| /* * You should have received a copy of the GNU General * */ | |
| /* * Public License along with this program; if not, write * */ | |
| /* * to the Free Software Foundation, Inc., 59 Temple * */ | |
| /* * Place, Suite 330, Boston, MA 02111-1307 USA * */ | |
| /* * * */ | |
| /* * * */ | |
| /* $Revision$ * */ | |
| /* $State$ * */ | |
| /* $Date$ * */ | |
| /* $Author$ * */ | |
| /* * * */ | |
| /* * Contact: * */ | |
| /* * Christoph Weidenbach * */ | |
| /* * MPI fuer Informatik * */ | |
| /* * Stuhlsatzenhausweg 85 * */ | |
| /* * 66123 Saarbruecken * */ | |
| /* * Email: weidenb@mpi-sb.mpg.de * */ | |
| /* * Germany * */ | |
| /* * * */ | |
| /* ********************************************************** */ | |
| /**************************************************************/ | |
| /* $RCSfile$ */ | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include "flags.h" | |
| #include "misc.h" | |
| #include "stringsx.h" | |
| /**************************************************************/ | |
| /* Global Declarations */ | |
| /**************************************************************/ | |
| const int flag_CLEAN = -5; | |
| /**************************************************************/ | |
| /* File Local Declarations */ | |
| /**************************************************************/ | |
| /* Define flag properties */ | |
| typedef struct { | |
| int minimum; | |
| int maximum; | |
| FLAG_TYPE type; | |
| const char *name; | |
| } FLAG_PROPERTY; | |
| static FLAGARRAY flag_DEFAULTSTORE; | |
| static FLAG_PROPERTY flag_PROPERTIES[flag_MAXFLAG]; | |
| /**************************************************************/ | |
| /* Functions */ | |
| /**************************************************************/ | |
| static __inline__ void flag_InitIntern (FLAG_ID Flag, FLAG_TYPE Type, | |
| const char *Name, int Value, | |
| int Minimum, int Maximum) | |
| { | |
| FLAG_PROPERTY *property; | |
| flag_CheckFlagIdInRange(Flag); | |
| property = &(flag_PROPERTIES[Flag]); | |
| /* Set the flag type */ | |
| flag_CheckFlagTypeInRange(Type); | |
| property->type = Type; | |
| /* Set flag name */ | |
| property->name = Name; | |
| /* Set flag minimum and maximum */ | |
| property->minimum = Minimum; | |
| property->maximum = Maximum; | |
| /* Set flag value */ | |
| #ifdef CHECK | |
| if (Value > Minimum && Value < Maximum) { | |
| #endif | |
| flag_DEFAULTSTORE[Flag] = Value; | |
| #ifdef CHECK | |
| } | |
| else { | |
| misc_StartErrorReport(); | |
| misc_ErrorReport("\n In flag_InitIntern: Default value out of range."); | |
| misc_ErrorReport("\n Flag: %s. Value: %d.", Name, Value); | |
| misc_FinishErrorReport(); | |
| } | |
| #endif | |
| } | |
| void flag_Init(void) | |
| /************************************************************** | |
| INPUT: None. | |
| RETURNS: Nothing. | |
| EFFECT: Sets all default values for known flags. | |
| MEMORY: Allocates memory for the default store. | |
| ***************************************************************/ | |
| { | |
| /* Autonomous mode */ | |
| flag_InitIntern(flag_AUTO, flag_UNIQUE, "Auto", flag_AUTOON, | |
| flag_AUTOMIN, flag_AUTOMAX); | |
| /* Set of Support Mode */ | |
| flag_InitIntern(flag_SOS, flag_UNIQUE, "SOS", flag_SOSOFF, | |
| flag_SOSMIN, flag_SOSMAX); | |
| /* If set input is considered from stdin and printed to stdout */ | |
| flag_InitIntern(flag_STDIN, flag_UNIQUE, "Stdin", flag_STDINOFF, | |
| flag_STDINMIN, flag_STDINMAX); | |
| /* If set interactive queries are possible */ | |
| flag_InitIntern(flag_INTERACTIVE, flag_UNIQUE, "Interactive", flag_INTERACTIVEOFF, | |
| flag_INTERACTIVEMIN, flag_INTERACTIVEMAX); | |
| /* If set only Flotter CNF-translation is performed */ | |
| flag_InitIntern(flag_FLOTTER, flag_UNIQUE, "Flotter", flag_FLOTTEROFF, | |
| flag_FLOTTERMIN, flag_FLOTTERMAX); | |
| /* Allowed number of loops, -1 means no restriction */ | |
| flag_InitIntern(flag_LOOPS, flag_UNIQUE, "Loops", flag_LOOPSUNLIMITED, | |
| flag_LOOPSMIN, flag_LOOPSMAX); | |
| /* Allowed number of splits, -1 means no restriction */ | |
| flag_InitIntern(flag_SPLITS, flag_UNIQUE, "Splits", flag_SPLITSOFF, | |
| flag_SPLITSMIN, flag_SPLITSMAX); | |
| /* Decides the level of sort usage: if 0 then no sort information is processed, | |
| if 1 all negative monadic literals with a variable as its argument are processed, | |
| if 2 all negative monadic literals are processed */ | |
| flag_InitIntern(flag_SORTS, flag_UNIQUE, "Sorts", flag_SORTSOFF, | |
| flag_SORTSMIN, flag_SORTSMAX); | |
| /* ForwardSubsumption output not activated */ | |
| flag_InitIntern(flag_PSUB, flag_PRINTING, "PSub", flag_PSUBOFF, | |
| flag_PSUBMIN, flag_PSUBMAX); | |
| /* Maximal memory allocation */ | |
| flag_InitIntern(flag_MEMORY, flag_UNIQUE, "Memory", flag_MEMORYUNLIMITED, | |
| flag_MEMORYMIN, flag_MEMORYMAX); | |
| /* Document static soft typing */ | |
| flag_InitIntern(flag_DOCSST, flag_PRINTING, "DocSST", flag_DOCSSTOFF, | |
| flag_DOCSSTMIN, flag_DOCSSTMAX); | |
| /* Rewriting output not activated */ | |
| flag_InitIntern(flag_PREW, flag_PRINTING, "PRew", flag_PREWOFF, | |
| flag_PREWMIN, flag_PREWMAX); | |
| /* Contextual rewriting output not activated */ | |
| flag_InitIntern(flag_PCRW, flag_PRINTING, "PCRw", flag_PCRWOFF, | |
| flag_PCRWMIN, flag_PCRWMAX); | |
| /* Condensing output not activated */ | |
| flag_InitIntern(flag_PCON, flag_PRINTING, "PCon", flag_PCONOFF, | |
| flag_PCONMIN, flag_PCONMAX); | |
| /* Assignment Equation Deletion output not activated */ | |
| flag_InitIntern(flag_PAED, flag_PRINTING, "PAED", flag_PAEDOFF, | |
| flag_PAEDMIN, flag_PAEDMAX); | |
| /* Tautology output not activated */ | |
| flag_InitIntern(flag_PTAUT, flag_PRINTING, "PTaut", flag_PTAUTOFF, | |
| flag_PTAUTMIN, flag_PTAUTMAX); | |
| /* Output of obvious red. not activated */ | |
| flag_InitIntern(flag_POBV, flag_PRINTING, "PObv", flag_POBVOFF, | |
| flag_POBVMIN, flag_POBVMAX); | |
| /* SortSimplification output not activated */ | |
| flag_InitIntern(flag_PSSI, flag_PRINTING, "PSSi", flag_PSSIOFF, | |
| flag_PSSIMIN, flag_PSSIMAX); | |
| /* Static soft typing output not activated */ | |
| flag_InitIntern(flag_PSST, flag_PRINTING, "PSST", flag_PSSTOFF, | |
| flag_PSSTMIN, flag_PSSTMAX); | |
| /* Proof output not activated */ | |
| flag_InitIntern(flag_DOCPROOF, flag_UNIQUE, "DocProof", flag_DOCPROOFOFF, | |
| flag_DOCPROOFMIN, flag_DOCPROOFMAX); | |
| /* Matching Replacement Resolution output not activated */ | |
| flag_InitIntern(flag_PMRR, flag_PRINTING, "PMRR", flag_PMRROFF, | |
| flag_PMRRMIN, flag_PMRRMAX); | |
| /* Unit conflict output not activated */ | |
| flag_InitIntern(flag_PUNC, flag_PRINTING, "PUnC", flag_PUNCOFF, | |
| flag_PUNCMIN, flag_PUNCMAX); | |
| /* Derived clauses output not activated */ | |
| flag_InitIntern(flag_PDER, flag_PRINTING, "PDer", flag_PDEROFF, | |
| flag_PDERMIN, flag_PDERMAX); | |
| /* Given clause output activated */ | |
| flag_InitIntern(flag_PGIVEN, flag_PRINTING, "PGiven", flag_PGIVENON, | |
| flag_PGIVENMIN, flag_PGIVENMAX); | |
| /* If labels are created they are not printed */ | |
| flag_InitIntern(flag_PLABELS, flag_PRINTING, "PLabels", flag_PLABELSOFF, | |
| flag_PLABELSMIN, flag_PLABELSMAX); | |
| /* Kept clauses output not activated */ | |
| flag_InitIntern(flag_PKEPT, flag_PRINTING, "PKept", flag_PKEPTOFF, | |
| flag_PKEPTMIN, flag_PKEPTMAX); | |
| /* Split backtrack emphasizing not activated */ | |
| flag_InitIntern(flag_DOCSPLIT, flag_PRINTING, "DocSplit", flag_DOCSPLITOFF, | |
| flag_DOCSPLITMIN, flag_DOCSPLITMAX); | |
| /* Print information about input clauses */ | |
| flag_InitIntern(flag_PPROBLEM, flag_PRINTING, "PProblem", flag_PPROBLEMON, | |
| flag_PPROBLEMMIN, flag_PPROBLEMMAX); | |
| /* Print all derived empty clauses */ | |
| flag_InitIntern(flag_PEMPTYCLAUSE, flag_PRINTING, "PEmptyClause", flag_PEMPTYCLAUSEOFF, | |
| flag_PEMPTYCLAUSEMIN, flag_PEMPTYCLAUSEMAX); | |
| /* Print statistic about memory, clauses */ | |
| flag_InitIntern(flag_PSTATISTIC, flag_PRINTING, "PStatistic", flag_PSTATISTICON, | |
| flag_PSTATISTICMIN, flag_PSTATISTICMAX); | |
| /* Output saturated set of clauses to file, default no */ | |
| flag_InitIntern(flag_FPMODEL, flag_PRINTING, "FPModel", flag_FPMODELOFF, | |
| flag_FPMODELMIN, flag_FPMODELMAX); | |
| /* Output proof in DFG format to file, default no */ | |
| flag_InitIntern(flag_FPDFGPROOF, flag_PRINTING, "FPDFGProof", flag_FPDFGPROOFOFF, | |
| flag_FPDFGPROOFMIN, flag_FPDFGPROOFMAX); | |
| /* Output the actual values of all SPASS flags */ | |
| flag_InitIntern(flag_PFLAGS, flag_PRINTING, "PFlags", flag_PFLAGSOFF, | |
| flag_PFLAGSMIN, flag_PFLAGSMAX); | |
| /* Optimized skolemization output not activated */ | |
| flag_InitIntern(flag_POPTSKOLEM, flag_PRINTING, "POptSkolem", flag_POPTSKOLEMOFF, | |
| flag_POPTSKOLEMMIN, flag_POPTSKOLEMMAX); | |
| /* Strong skolemization output not activated */ | |
| flag_InitIntern(flag_PSTRSKOLEM, flag_PRINTING, "PStrSkolem", flag_PSTRSKOLEMOFF, | |
| flag_PSTRSKOLEMMIN, flag_PSTRSKOLEMMAX); | |
| /* Printing of clauses deleted by bound restriction not activated */ | |
| flag_InitIntern(flag_PBDC, flag_PRINTING, "PBDC", flag_PBDCOFF, | |
| flag_PBDCMIN, flag_PBDCMAX); | |
| /* Printing of bound increase actions */ | |
| flag_InitIntern(flag_PBINC, flag_PRINTING, "PBInc", flag_PBINCOFF, | |
| flag_PBINCMIN, flag_PBINCMAX); | |
| /* Application of definitions output activated */ | |
| flag_InitIntern(flag_PAPPLYDEFS, flag_PRINTING, "PApplyDefs", flag_PAPPLYDEFSOFF, | |
| flag_PAPPLYDEFSMIN, flag_PAPPLYDEFSMAX); | |
| /* Amount of time (seconds) available to SPASS, -1 means arbitrary */ | |
| flag_InitIntern(flag_TIMELIMIT, flag_UNIQUE, "TimeLimit", flag_TIMELIMITUNLIMITED, | |
| flag_TIMELIMITMIN, flag_TIMELIMITMAX); | |
| /* Select: 0 -> no selection, 1 -> select if multiple maximal literals, 2 -> always select */ | |
| flag_InitIntern(flag_SELECT, flag_UNIQUE, "Select", flag_SELECTIFSEVERALMAXIMAL, | |
| flag_SELECTMIN, flag_SELECTMAX); | |
| /* Activates the inference rule Empty Sort */ | |
| flag_InitIntern(flag_IEMS, flag_INFERENCE, "IEmS", flag_EMPTYSORTOFF, | |
| flag_EMPTYSORTMIN, flag_EMPTYSORTMAX); | |
| /* Activates the inference rule Sort Resolution */ | |
| flag_InitIntern(flag_ISOR, flag_INFERENCE, "ISoR", flag_SORTRESOLUTIONOFF, | |
| flag_SORTRESOLUTIONMIN, flag_SORTRESOLUTIONMAX); | |
| /* Activates the inference rule Equality Resolution */ | |
| flag_InitIntern(flag_IEQR, flag_INFERENCE, "IEqR", flag_EQUALITYRESOLUTIONOFF, | |
| flag_EQUALITYRESOLUTIONMIN, flag_EQUALITYRESOLUTIONMAX); | |
| /* Activates the inference rule Reflexivity Resolution */ | |
| flag_InitIntern(flag_IERR, flag_INFERENCE, "IERR", flag_REFLEXIVITYRESOLUTIONOFF, | |
| flag_REFLEXIVITYRESOLUTIONMIN, flag_REFLEXIVITYRESOLUTIONMAX); | |
| /* Activates the inference rule Equality Factoring */ | |
| flag_InitIntern(flag_IEQF, flag_INFERENCE, "IEqF", flag_EQUALITYFACTORINGOFF, | |
| flag_EQUALITYFACTORINGMIN, flag_EQUALITYFACTORINGMAX); | |
| /* Activates the inference rule Merging Paramodulation */ | |
| flag_InitIntern(flag_IMPM, flag_INFERENCE, "IMPm", flag_MERGINGPARAMODULATIONOFF, | |
| flag_MERGINGPARAMODULATIONMIN, flag_MERGINGPARAMODULATIONMAX); | |
| /* Activates the inference rule Superposition Right */ | |
| flag_InitIntern(flag_ISPR, flag_INFERENCE, "ISpR", flag_SUPERPOSITIONRIGHTOFF, | |
| flag_SUPERPOSITIONRIGHTMIN, flag_SUPERPOSITIONRIGHTMAX); | |
| /* Inference rule Ordered Paramodulation not active */ | |
| flag_InitIntern(flag_IOPM, flag_INFERENCE, "IOPm", flag_ORDEREDPARAMODULATIONOFF, | |
| flag_ORDEREDPARAMODULATIONMIN, flag_ORDEREDPARAMODULATIONMAX); | |
| /* Inference rule Paramodulation not active */ | |
| flag_InitIntern(flag_ISPM, flag_INFERENCE, "ISPm", flag_STANDARDPARAMODULATIONOFF, | |
| flag_STANDARDPARAMODULATIONMIN, flag_STANDARDPARAMODULATIONMAX); | |
| /* Activates the inference rule Superposition Left */ | |
| flag_InitIntern(flag_ISPL, flag_INFERENCE, "ISpL", flag_SUPERPOSITIONLEFTOFF, | |
| flag_SUPERPOSITIONLEFTMIN, flag_SUPERPOSITIONLEFTMAX); | |
| /* Activates the inference rule Ordered Resolution */ | |
| flag_InitIntern(flag_IORE, flag_INFERENCE, "IORe", flag_ORDEREDRESOLUTIONOFF, | |
| flag_ORDEREDRESOLUTIONMIN, flag_ORDEREDRESOLUTIONMAX); | |
| /* Activates the inference rule Standard Resolution */ | |
| flag_InitIntern(flag_ISRE, flag_INFERENCE, "ISRe", flag_STANDARDRESOLUTIONOFF, | |
| flag_STANDARDRESOLUTIONMIN, flag_STANDARDRESOLUTIONMAX); | |
| /* Activates the inference rule Standard Hyperresolution */ | |
| flag_InitIntern(flag_ISHY, flag_INFERENCE, "ISHy", flag_STANDARDHYPERRESOLUTIONOFF, | |
| flag_STANDARDHYPERRESOLUTIONMIN, flag_STANDARDHYPERRESOLUTIONMAX); | |
| /* Activates the inference rule Ordered Hyperresolution */ | |
| flag_InitIntern(flag_IOHY, flag_INFERENCE, "IOHy", flag_ORDEREDHYPERRESOLUTIONOFF, | |
| flag_ORDEREDHYPERRESOLUTIONMIN, flag_ORDEREDHYPERRESOLUTIONMAX); | |
| /* Activates the inference rule UR Resolution */ | |
| flag_InitIntern(flag_IURR, flag_INFERENCE, "IURR", flag_UNITRESULTINGRESOLUTIONOFF, | |
| flag_UNITRESULTINGRESOLUTIONMIN, flag_UNITRESULTINGRESOLUTIONMAX); | |
| /* Activates the inference rule Ordered Factoring */ | |
| flag_InitIntern(flag_IOFC, flag_INFERENCE, "IOFc", flag_FACTORINGOFF, | |
| flag_FACTORINGMIN, flag_FACTORINGMAX); | |
| /* Activates the inference rule Standard Factoring */ | |
| flag_InitIntern(flag_ISFC, flag_INFERENCE, "ISFc", flag_STANDARDFACTORINGOFF, | |
| flag_STANDARDFACTORINGMIN, flag_STANDARDFACTORINGMAX); | |
| /* Activates the inference rule Bounded Unit Resolution */ | |
| flag_InitIntern(flag_IBUR, flag_INFERENCE, "IBUR", flag_BOUNDEDDEPTHUNITRESOLUTIONOFF, | |
| flag_BOUNDEDDEPTHUNITRESOLUTIONMIN, flag_BOUNDEDDEPTHUNITRESOLUTIONMAX); | |
| /* Activates the inference rule Definition Application */ | |
| flag_InitIntern(flag_IDEF, flag_INFERENCE, "IDEF", flag_DEFINITIONAPPLICATIONOFF, | |
| flag_DEFINITIONAPPLICATIONMIN, flag_DEFINITIONAPPLICATIONMAX); | |
| /* Activates the inference rule Unit Resolution */ | |
| flag_InitIntern(flag_IUNR, flag_INFERENCE, "IUnR", flag_UNITRESOLUTIONOFF, | |
| flag_UNITRESOLUTIONMIN, flag_UNITRESOLUTIONMAX); | |
| /* Activates Forward Rewriting */ | |
| flag_InitIntern(flag_RFREW, flag_REDUCTION, "RFRew", flag_RFREWOFF, | |
| flag_RFREWMIN, flag_RFREWMAX); | |
| /* Activates Backward Rewriting */ | |
| flag_InitIntern(flag_RBREW, flag_REDUCTION, "RBRew", flag_RBREWOFF, | |
| flag_RBREWMIN, flag_RBREWMAX); | |
| /* Activates Forward Contextual Rewriting */ | |
| flag_InitIntern(flag_RFCRW, flag_REDUCTION, "RFCRw", flag_RFCRWOFF, | |
| flag_RFCRWMIN, flag_RFCRWMAX); | |
| /* Activates Backward Contextual Rewriting */ | |
| flag_InitIntern(flag_RBCRW, flag_REDUCTION, "RBCRw", flag_RBCRWOFF, | |
| flag_RBCRWMIN, flag_RBCRWMAX); | |
| /* Activates Unit Conflict */ | |
| flag_InitIntern(flag_RUNC, flag_REDUCTION, "RUnC", flag_RUNCOFF, | |
| flag_RUNCMIN, flag_RUNCMAX); | |
| /* Activates Terminator */ | |
| flag_InitIntern(flag_RTER, flag_REDUCTION, "RTer", flag_RTEROFF, | |
| flag_RTERMIN, flag_RTERMAX); | |
| /* Activates Forward Subsumption */ | |
| flag_InitIntern(flag_RFSUB, flag_REDUCTION, "RFSub", flag_RFSUBOFF, | |
| flag_RFSUBMIN, flag_RFSUBMAX); | |
| /* Activates Backward Subsumption */ | |
| flag_InitIntern(flag_RBSUB, flag_REDUCTION, "RBSub", flag_RBSUBOFF, | |
| flag_RBSUBMIN, flag_RBSUBMAX); | |
| /* Activates Forward Matching Replacement Resolution */ | |
| flag_InitIntern(flag_RFMRR, flag_REDUCTION, "RFMRR", flag_RFMRROFF, | |
| flag_RFMRRMIN, flag_RFMRRMAX); | |
| /* Activates Backward Matching Replacement Resolution */ | |
| flag_InitIntern(flag_RBMRR, flag_REDUCTION, "RBMRR", flag_RBMRROFF, | |
| flag_RBMRRMIN, flag_RBMRRMAX); | |
| /* Activates the reduction rule Obvious Reduction */ | |
| flag_InitIntern(flag_ROBV, flag_REDUCTION, "RObv", flag_ROBVOFF, | |
| flag_ROBVMIN, flag_ROBVMAX); | |
| /* Activates the reduction rule Tautology */ | |
| flag_InitIntern(flag_RTAUT, flag_REDUCTION, "RTaut", flag_RTAUTOFF, | |
| flag_RTAUTMIN, flag_RTAUTMAX); | |
| /* Activates the reduction rule Sort Simplification */ | |
| flag_InitIntern(flag_RSSI, flag_REDUCTION, "RSSi", flag_RSSIOFF, | |
| flag_RSSIMIN, flag_RSSIMAX); | |
| /* Activates static soft typing */ | |
| flag_InitIntern(flag_RSST, flag_REDUCTION, "RSST", flag_RSSTOFF, | |
| flag_RSSTMIN, flag_RSSTMAX); | |
| /* Activates Assignment Equation Deletion */ | |
| /* If set to 2 it also eliminates equations */ | |
| /* that are redundant only in non-trivial domains */ | |
| flag_InitIntern(flag_RAED, flag_REDUCTION, "RAED", flag_RAEDOFF, | |
| flag_RAEDMIN, flag_RAEDMAX); | |
| /* Activates Condensing */ | |
| flag_InitIntern(flag_RCON, flag_REDUCTION, "RCon", flag_RCONOFF, | |
| flag_RCONMIN, flag_RCONMAX); | |
| /* Activates reduction of input clauses */ | |
| flag_InitIntern(flag_RINPUT, flag_UNIQUE, "RInput", flag_RINPUTON, | |
| flag_RINPUTMIN, flag_RINPUTMAX); | |
| /* Activates application of definitions */ | |
| flag_InitIntern(flag_APPLYDEFS, flag_UNIQUE, "ApplyDefs", flag_APPLYDEFSOFF, | |
| flag_APPLYDEFSMIN, flag_APPLYDEFSMAX); | |
| /* If true usable and worked off are completely interreduced; otherwise only worked off */ | |
| flag_InitIntern(flag_FULLRED, flag_UNIQUE, "FullRed", flag_FULLREDON, | |
| flag_FULLREDMIN, flag_FULLREDMAX); | |
| /* Activates unit saturation of input clauses */ | |
| flag_InitIntern(flag_SATINPUT, flag_UNIQUE, "SatInput", flag_SATINPUTOFF, | |
| flag_SATINPUTMIN, flag_SATINPUTMAX); | |
| /* Ratio between weight and depth selection of clauses from usable */ | |
| flag_InitIntern(flag_WDRATIO, flag_UNIQUE, "WDRatio", 5, | |
| flag_WDRATIOMIN, flag_WDRATIOMAX); | |
| /* Factor to divide the weight of conjecture clauses to prefer them for selection */ | |
| flag_InitIntern(flag_PREFCON, flag_UNIQUE, "PrefCon", flag_PREFCONUNCHANGED, | |
| flag_PREFCONMIN, flag_PREFCONMAX); | |
| /* Weight of a function symbol; weight of clause is used to select given */ | |
| flag_InitIntern(flag_FUNCWEIGHT, flag_UNIQUE, "FuncWeight", 1, | |
| flag_FUNCWEIGHTMIN, flag_FUNCWEIGHTMAX); | |
| /* Weight of a variable symbol; weight of clause is used to select given */ | |
| flag_InitIntern(flag_VARWEIGHT, flag_UNIQUE, "VarWeight", 1, | |
| flag_VARWEIGHTMIN, flag_VARWEIGHTMAX); | |
| /* Prefer the selection of clauses with many variable occurrences */ | |
| flag_InitIntern(flag_PREFVAR, flag_UNIQUE, "PrefVar", flag_PREFVAROFF, | |
| flag_PREFVARMIN, flag_PREFVARMAX); | |
| /* The type of bound: 0 (no bound) 1 (by clause weight) 2 (by clause term depth) */ | |
| flag_InitIntern(flag_BOUNDMODE, flag_UNIQUE, "BoundMode", flag_BOUNDMODEUNLIMITED, | |
| flag_BOUNDMODEMIN, flag_BOUNDMODEMAX); | |
| /* The initial bound value, where -1 means no restriction */ | |
| flag_InitIntern(flag_BOUNDSTART, flag_UNIQUE, "BoundStart", flag_BOUNDSTARTUNLIMITED, | |
| flag_BOUNDSTARTMIN, flag_BOUNDSTARTMAX); | |
| /* The number of bound saturation loops */ | |
| flag_InitIntern(flag_BOUNDLOOPS, flag_UNIQUE, "BoundLoops", 1, | |
| flag_BOUNDLOOPSMIN, flag_BOUNDLOOPSMAX); | |
| /* Flags for selecting the ordering to use */ | |
| flag_InitIntern(flag_ORD, flag_UNIQUE, "Ordering", flag_ORDKBO, | |
| flag_ORDMIN, flag_ORDMAX); | |
| /* CNF flag, if set optimized skolemization is performed */ | |
| flag_InitIntern(flag_CNFOPTSKOLEM, flag_UNIQUE, "CNFOptSkolem", flag_CNFOPTSKOLEMON, | |
| flag_CNFOPTSKOLEMMIN, flag_CNFOPTSKOLEMMAX); | |
| /* CNF flag, restricts the number of optimized skolemization proof steps */ | |
| flag_InitIntern(flag_CNFPROOFSTEPS, flag_UNIQUE, "CNFProofSteps", 100, | |
| flag_CNFPROOFSTEPSMIN, flag_CNFPROOFSTEPSMAX); | |
| /* CNF flag, if set renaming is performed */ | |
| flag_InitIntern(flag_CNFRENAMING, flag_UNIQUE, "CNFRenaming", flag_CNFRENAMINGON, | |
| flag_CNFRENAMINGMIN, flag_CNFRENAMINGMAX); | |
| /* CNF flag, if set renaming is printed */ | |
| flag_InitIntern(flag_CNFPRENAMING, flag_UNIQUE, "CNFPRenaming", flag_CNFPRENAMINGOFF, | |
| flag_CNFPRENAMINGMIN, flag_CNFPRENAMINGMAX); | |
| /* CNF flag, if set strong skolemization is performed */ | |
| flag_InitIntern(flag_CNFSTRSKOLEM, flag_UNIQUE, "CNFStrSkolem", flag_CNFSTRSKOLEMON, | |
| flag_CNFSTRSKOLEMMIN, flag_CNFSTRSKOLEMMAX); | |
| /* CNF flag, if set reductions on equality literals are performed */ | |
| flag_InitIntern(flag_CNFFEQREDUCTIONS, flag_UNIQUE, "CNFFEqR", flag_CNFFEQREDUCTIONSON, | |
| flag_CNFFEQREDUCTIONSMIN, flag_CNFFEQREDUCTIONSMAX); | |
| /* dfg2otter flag, if set input options for otter are generated */ | |
| flag_InitIntern(flag_TDFG2OTTEROPTIONS, flag_UNIQUE, "TDfg2OtterOptions", flag_TDFG2OTTEROPTIONSOFF, | |
| flag_TDFG2OTTEROPTIONSMIN, flag_TDFG2OTTEROPTIONSMAX); | |
| } | |
| FLAGSTORE flag_DefaultStore(void) | |
| /************************************************************** | |
| INPUT: None. | |
| RETURNS: Default flag store. | |
| ***************************************************************/ | |
| { | |
| return flag_DEFAULTSTORE; | |
| } | |
| void flag_Print(FLAGSTORE Store) | |
| /************************************************************** | |
| INPUT: A FlagStore. | |
| RETURNS: Nothing. | |
| EFFECT: Prints the values of all flags to stdout. | |
| ***************************************************************/ | |
| { | |
| flag_FPrint(stdout, Store); | |
| } | |
| void flag_FPrint(FILE* File, FLAGSTORE Store) | |
| /************************************************************** | |
| INPUT: A File to print to, and a FlagStore. | |
| RETURNS: Nothing. | |
| EFFECT: Prints the values of all flags to File. | |
| ***************************************************************/ | |
| { | |
| FLAG_ID i; | |
| char name[30]; | |
| fputs("list_of_settings(SPASS).{*", File); | |
| for (i = (FLAG_ID) 0; i < flag_MAXFLAG; i+= (FLAG_ID) 3) { | |
| sprintf(name,"set_flag(%s,%d).", flag_Name(i), flag_GetFlagValue(Store, i)); | |
| fprintf(File,"\n %-30s",name); | |
| if (i+1 < flag_MAXFLAG) { | |
| sprintf(name,"set_flag(%s,%d).", flag_Name(i+ (FLAG_ID) 1), flag_GetFlagValue(Store, i+ (FLAG_ID) 1)); | |
| fprintf(File," %-30s",name); | |
| if (i+2 < flag_MAXFLAG) { | |
| sprintf(name," set_flag(%s,%d).", flag_Name(i+ (FLAG_ID) 2), flag_GetFlagValue(Store, i+ (FLAG_ID) 2)); | |
| fprintf(File," %-30s",name); | |
| } | |
| } | |
| } | |
| fputs("*}\nend_of_list.\n", File); | |
| } | |
| BOOL flag_Lookup(const char* String) | |
| /************************************************************** | |
| INPUT: A string <String>. | |
| RETURNS: TRUE iff <String> is the string of a known flag. | |
| ***************************************************************/ | |
| { | |
| return (flag_Id(String) != -1); | |
| } | |
| FLAG_ID flag_Id(const char* String) | |
| /************************************************************** | |
| INPUT: A string <String>. | |
| RETURNS: The identification of the flag <String> if it exists | |
| -1 otherwise. | |
| ***************************************************************/ | |
| { | |
| FLAG_ID i; | |
| for (i = (FLAG_ID) 0; i < flag_MAXFLAG; i++) | |
| if (string_Equal(flag_Name(i), String)) | |
| return i; | |
| return (FLAG_ID) -1; | |
| } | |
| const char* flag_Name(FLAG_ID Flag) | |
| /************************************************************** | |
| INPUT: A FlagId. | |
| RETURNS: The name of the flag <Flag>. | |
| EFFECT: Looks up the name of the flag <Flag> and returns it, | |
| if it exists. | |
| ***************************************************************/ | |
| { | |
| flag_CheckFlagIdInRange(Flag); | |
| return(flag_PROPERTIES[Flag].name); | |
| } | |
| int flag_Minimum(FLAG_ID Flag) | |
| /************************************************************** | |
| INPUT: A FlagId. | |
| RETURNS: The first integer below the minimal legal value | |
| of the flag. | |
| ***************************************************************/ | |
| { | |
| flag_CheckFlagIdInRange(Flag); | |
| return flag_PROPERTIES[Flag].minimum; | |
| } | |
| int flag_Maximum(FLAG_ID Flag) | |
| /************************************************************** | |
| INPUT: A FlagId. | |
| RETURNS: The first integer above the maximal legal value | |
| of the flag. | |
| ***************************************************************/ | |
| { | |
| flag_CheckFlagIdInRange(Flag); | |
| return flag_PROPERTIES[Flag].maximum; | |
| } | |
| FLAG_TYPE flag_Type(FLAG_ID Flag) | |
| /************************************************************** | |
| INPUT: A FlagId. | |
| RETURNS: The flag type. | |
| ***************************************************************/ | |
| { | |
| flag_CheckFlagIdInRange(Flag); | |
| return flag_PROPERTIES[Flag].type; | |
| } | |
| void flag_ClearInferenceRules(FLAGSTORE Store) | |
| /************************************************************** | |
| INPUT: A FlagStore. | |
| RETURNS: Nothing. | |
| EFFECT: Turns all inference rules off. | |
| ***************************************************************/ | |
| { | |
| FLAG_ID i; | |
| for (i = (FLAG_ID) 0; i < flag_MAXFLAG; i++) { | |
| if (flag_IsInference(i)) | |
| flag_SetFlagValue(Store, i, flag_OFF); | |
| } | |
| } | |
| void flag_ClearReductionRules(FLAGSTORE Store) | |
| /************************************************************** | |
| INPUT: A FlagStore. | |
| RETURNS: Nothing. | |
| EFFECT: Turns all reduction rules off. | |
| ***************************************************************/ | |
| { | |
| FLAG_ID i; | |
| for (i = (FLAG_ID) 0; i < flag_MAXFLAG; i++) { | |
| if (flag_IsReduction(i)) { | |
| flag_SetFlagValue(Store, i, flag_OFF); | |
| } | |
| } | |
| } | |
| void flag_ClearPrinting(FLAGSTORE Store) | |
| /************************************************************** | |
| INPUT: A FlagStore. | |
| RETURNS: Nothing. | |
| EFFECT: Turns all printing off. | |
| ***************************************************************/ | |
| { | |
| FLAG_ID i; | |
| for (i = (FLAG_ID) 0; i < flag_MAXFLAG; i++) { | |
| if (flag_IsPrinting(i)) | |
| flag_SetFlagValue(Store, i, flag_OFF); | |
| } | |
| } | |
| void flag_SetReductionsToDefaults(FLAGSTORE Store) | |
| /************************************************************** | |
| INPUT: A FlagStore. | |
| RETURNS: Nothing. | |
| EFFECT: Sets all reduction rules to defaults. | |
| ***************************************************************/ | |
| { | |
| FLAG_ID i; | |
| for (i = (FLAG_ID) 0; i < flag_MAXFLAG; i++) { | |
| if (flag_IsReduction(i)) | |
| flag_SetFlagToDefault(Store, i); | |
| } | |
| } | |
| void flag_InitFlotterSubproofFlags(FLAGSTORE Source, FLAGSTORE Target) | |
| /************************************************************** | |
| INPUT: Two flag stores. | |
| RETURNS: Nothing. | |
| EFFECT: Initializes the flag store <Target> to the values required by a | |
| Flotter subproof. The other flag store is needed to take over | |
| some flags, e.g. DOCPROOF. | |
| ***************************************************************/ | |
| { | |
| /* Deactivate printing */ | |
| flag_ClearPrinting(Target); | |
| /* Deactivate inference rules */ | |
| flag_ClearInferenceRules(Target); | |
| /* Set reductions to default values */ | |
| flag_SetReductionsToDefaults(Target); | |
| flag_SetFlagToDefault(Target, flag_CNFFEQREDUCTIONS); | |
| flag_SetFlagToDefault(Target, flag_RINPUT); | |
| /* Copy flag_DOCPROOF and flag_CNFPROOFSTEPS */ | |
| flag_TransferFlag(Source, Target, flag_DOCPROOF); | |
| flag_TransferFlag(Source, Target, flag_CNFPROOFSTEPS); | |
| /* Activate BoundedDepthUnitResolution */ | |
| flag_SetFlagValue(Target, flag_IBUR, flag_BOUNDEDDEPTHUNITRESOLUTIONON); | |
| /* Activate KBO */ | |
| flag_SetFlagValue(Target, flag_ORD, flag_ORDKBO); | |
| /* Transfer Weights for Terms */ | |
| flag_TransferFlag(Source, Target, flag_FUNCWEIGHT); | |
| flag_TransferFlag(Source, Target, flag_VARWEIGHT); | |
| /* Transfer Selection Strategy, not needed for depth bounded */ | |
| /* unit resolution (see above) but for other potentially useful inference rules */ | |
| flag_TransferFlag(Source, Target, flag_SELECT); | |
| } | |
| void flag_InitFlotterFlags(FLAGSTORE Source, FLAGSTORE Target) | |
| /************************************************************** | |
| INPUT: Two flag stores. | |
| RETURNS: Nothing. | |
| EFFECT: Initalizes the flag store <Target> to the values required by | |
| Flotter. The other flag store is needed to set | |
| some flags, e.g. DOCPROOF. | |
| ***************************************************************/ | |
| { | |
| flag_InitFlotterSubproofFlags(Source, Target); | |
| /* Set ordering to default value */ | |
| flag_SetFlagToDefault(Target, flag_ORD); | |
| /* Set weighting flags to default values */ | |
| flag_SetFlagToDefault(Target, flag_FUNCWEIGHT); | |
| flag_SetFlagToDefault(Target, flag_VARWEIGHT); | |
| /* Copy given values to diverse flags */ | |
| flag_TransferFlag(Source, Target, flag_CNFRENAMING); | |
| flag_TransferFlag(Source, Target, flag_CNFOPTSKOLEM); | |
| flag_TransferFlag(Source, Target, flag_CNFSTRSKOLEM); | |
| flag_TransferFlag(Source, Target, flag_PAPPLYDEFS); | |
| flag_TransferFlag(Source, Target, flag_PBDC); | |
| flag_TransferFlag(Source, Target, flag_PBINC); | |
| flag_TransferFlag(Source, Target, flag_CNFPRENAMING); | |
| flag_TransferFlag(Source, Target, flag_POPTSKOLEM); | |
| flag_TransferFlag(Source, Target, flag_PSTRSKOLEM); | |
| flag_TransferFlag(Source, Target, flag_INTERACTIVE); | |
| } | |
| void flag_CheckStore(FLAGSTORE Store) | |
| /************************************************************** | |
| INPUT: A flag store. | |
| RETURNS: TRUE is the flag store is in a valid state, | |
| FALSE otherwise. | |
| ***************************************************************/ | |
| { | |
| FLAG_ID i; | |
| FLAG value; | |
| /* check all flags */ | |
| for (i = (FLAG_ID) 0; i < flag_MAXFLAG; i ++) { | |
| /* Get flag value first. We can't use flag_GetFlagValue() since it | |
| prints an error message and exits, if a flag is clean. A flag can | |
| be clean, only reading it is an error (for most functions). | |
| */ | |
| value = Store[i]; | |
| if (value != flag_CLEAN) { | |
| flag_CheckFlagValueInRange(i,value); | |
| } | |
| } | |
| } |