2024-03-04  Steven Eker  <eker@pup>

	* subtermProcess.hh (class SubtermProcess): SharedValue -> shared_ptr

	* applicationProcess.hh (class ApplicationProcess): SharedValue ->
	shared_ptr

	* matchProcess.hh (class MatchProcess): SharedValue -> shared_ptr

	* subtermTask.hh (class SubtermTask): SharedValue -> shared_ptr

	* rewriteTask.hh (class RewriteTask): SharedValue -> shared_ptr

	* matchProcess.cc (MatchProcess::MatchProcess): SharedValue -> shared_ptr

	* applicationProcess.cc (ApplicationProcess::doRewrite)
	(ApplicationProcess::resolveRemainingConditionFragments): SharedValue ->
	shared_ptr

	* rewriteTask.cc (RewriteTask::RewriteTask): SharedValue -> shared_ptr

	* subtermTask.cc (SubtermTask::SubtermTask): SharedValue -> shared_ptr

	* sharedValue.hh: deleted

===================================Maude158===========================================

2024-01-23  Steven Eker  <eker@pup>

	* applicationProcess.cc (ApplicationProcess::ApplicationProcess): always
	PositionState::RESPECT_FROZEN; this means in the no label case we can also
	PositionState::RESPECT_UNSTACKABLE

2024-01-17  Steven Eker  <eker@pup>

	* applicationProcess.cc (ApplicationProcess::ApplicationProcess): new
	rule for passing flags to RewriteSearchState(): if we are applying rules
	without a specific label we now explicitly allow setting and respecting
	unrewritable flags, and setting unstackable flags; we never respect
	unstackable flags to avoid missing frozen positions

2023-05-15  Steven Eker  <eker@pup>

	* applicationStrategy.cc (ApplicationStrategy::decompose): added comment to
	explain why we return the value returned by new

===================================Maude150===========================================

2023-04-04  Steven Eker  <eker@pup>

	* subtermTask.hh (class SubtermTask): use Vector<Vector<DagNode*>>
	for results now that we have move semantics for reallocation

2023-03-28  Steven Eker  <eker@pup>

	* variableBindingsManager.hh (VariableBindingsManager::Entry::free):
	contractTo(0) -> clear()

===================================Maude144===========================================

2023-03-13  Steven Eker  <eker@pup>

	* callStrategy.cc (CallStrategy::decompose): don't pass tailCall
	argument to CallProcess()

	* callProcess.cc (CallProcess::CallProcess): don't take tailCall
	argument or initialize tailCall member

	* callProcess.hh (class CallProcess): deleted data member tailCall;
	updated decl for ctor

===================================Maude143===========================================

2020-12-11  Steven Eker  <eker2@eker10>

	* subtermTask.cc: pass maintainInvariants = true to instantiate()

	* variableBindingsManager.cc: pass maintainInvariants = true to
	instantiate()

2020-11-23  Rubén Rubio  <rubenrub@ucm.es>

	* branchStrategy.cc (decompose): pass the iteration stack position
	to the BranchTask

	* branchTask.cc (BranchTask): added argument iterationCheckpoint
	(executionSucceeded): check for iteration cycles and interrupt them

	* branchTask.hh: added attribute iterationCheckpoint
	(BranchTask): added argument iterationCheckpoint

===================================Maude132===========================================

2019-12-03  Steven Eker  <eker@mu>

	* rewriteTask.cc: use safeCastNonNull<>()

===================================Maude127===========================================

2019-12-02  Rubén Rubio  <rubenrub@ucm.es>

	* depthFirstStrategicSearch.cc: added

	* depthFirstStrategicSearch.hh: added

	* fairStrategicSearch.cc: added

	* fairStrategicSearch.hh: added

	* strategicSearch.cc (StrategicSearch): removed inDepth and nextToRun
	attributes
	(~StrategicSearch): removed nextToRun deletion
	(findNextSolution): removed (now pure virtual, moved to FairStrategicSearch)
	(findNextSolutionInDepth): removed (moved to DepthFirstStrategicSearch)

	* strategicSearch.hh: corrected header guard, removed list import,
	protected inheritance for StrategicTask, and some private attributes
	made protected
	(findNextSolution): made pure virtual
	(findNextSolutionInDepth): removed

2019-11-14  Rubén Rubio  <rubenrub@ucm.es>

	* applicationProcess.cc (ApplicationProcess): changed computeGroundFlags call to
	computeBaseSort, after generalization by Steven

	* applicationStrategy.cc (process): changed computeGroundFlags call to
	computeBaseSort, after generalization by Steven

	* callStrategy.cc (process, decompose): changed computeGroundFlags call to
	computeBaseSort, after generalization by Steven

	* variableBindingsManager.cc (computeGroundFlags): removed

	* variableBindingsManager.hh (computeGroundFlags): removed

2019-10-23  Rubén Rubio  <rubenrub@ucm.es>

	* applicationProcess.cc (ApplicationProcess): bugfix: only ALLOW_NONEXEC if
	there is a defined strategy label, since the all strategy should not apply
	nonexec rules

2019-09-19  Rubén Rubio  <rubenrub@ucm.es>

	* applicationProcess.cc (process): changed computeBaseSorts call to
	computeGroundFlags

	* applicationStrategy.cc (check, prepare): moved valueDags[i].prepare()
	from check to prepare to check variables before the eager flags are set

	* callStrategy.cc (decompose): changed computeBaseSorts call to
	computeGroundFlags
	(tailCall): become method of CallStrategy

	* callStrategy.hh (tailCall): added

	* variableBindingsManager.cc (computeGroundFlags): added

	* variableBindingsManager.hh (computeGroundFlags): added

2019-05-25  Rubén Rubio  <rubenrub@ucm.es>

	* callProcess.cc (run): create a tracing context. Commented
	warning about non-matching strategy calls

	* strategicSearch.cc (StrategicSearch): added attribute inDepth
	(findNextSolution): handle depth-first search
	(findNextSolutionInDepth): used a ghost node to make
	the process list behave like a stack

	* strategicSearch.hh: added attribute inDepth
	(lastSolution): added

	* subtermStrategy.cc (check): now variables preserve their values in
	match/matchrew

	* subtermTask.cc (SubtermTask): ground flags are correctly set, so the
	result of instantiate is assumed to be non-null

	* testStrategy.cc (check): now variables preserve their values in
	match/matchrew

2018-12-20  Rubén Rubio  <rubenrub@ucm.es>

	* applicationProcess.cc (ApplicationProcess): do not ignore condition
	when executing the 'all' strategy
	(run): check condition explicitely only if not 'all'
	(process): call to computeBaseSortForGroundSubterms on the
	substitution values

	* callProcess.cc (callProcess, run): updated comments and spacing

	* callStrategy.cc (process): call to computeBaseSortForGroundSubterms
	on the call term
	(decompose): updated comments and style
	(equal): a finer equality relation

	* strategicSearch.cc (findNextSolutionInDepth): added

	* strategicSearch.hh (findNextSolutionInDepth): added

	* variableBindingsManager.cc (instantiate): removed call to
	computeBaseSortForGroundSubterms on the term to be instantiated

2018-10-09  Rubén Rubio  <rubenrub@ucm.es>

	* callStrategy.cc (equal): added

	* callStrategy.hh (equal): added

	* concatenationStrategy.cc (Concatenation): missing & in constructor
	argument

	* concatenationStrategy.hh (Concatenation): missing & in constructor
	argument

	* Makefile.am: add strategyExpression.cc

	* matchProcess.cc (MatchProcess): pass rewriteState by const-reference

	* strategyExpression.cc: added

	* strategyExpression.hh (equal): added

	* strategyStackManager.cc (push): use StrategyExpression::equal


2018-09-28  Steven Eker  <eker@install.csl.sri.com>

	* testStrategy.cc (decompose): transferCount() -> transferCountTo()

	* matchProcess.cc (run): transferCount() -> transferCountFrom()

	* applicationProcess.cc (resolveRemainingConditionFragments):+
	transferCount() -> transferCountFrom()

===================================Maude119===========================================

2018-09-17  Rubén Rubio  <rubenrub@ucm.es>

	* applicationProcess.cc (ApplicationProcess): instantiate only if not ground
	and corrected the call to transferCount

	* applicationStrategy.cc (ApplicationStrategy): do not normalize and
	prepare value DAGs yet
	(check): changed input arguments and normalize and prepare DAGS

	* applicationStrategy.hh (check): changed input arguments
	(getVariableInfo): removed

	* branchStrategy.cc (check): changed input arguments

	* branchStrategy.hh (check): changed input arguments

	* callProcess.cc (run): use context shape when opening context

	* callStrategy.cc (check): changed input arguments and added variable
	indexation
	(decompose): instantiate only if not ground and transfer count

	* callStrategy.hh: removed varInfo field and inheritance from BadFlag
	(check): changed input arguments
	(getVariableInfo): removed

	* concatenationStrategy.cc (check): changed input arguments

	* concatenationStrategy.hh (check): changed input arguments

	* iterationStrategy.cc (check): changed input arguments

	* iterationStrategy.hh (check): changed input arguments

	* oneStrategy.cc (check): changed input arguments

	* oneStrategy.hh (check): changed input arguments

	* strategicSearch.cc (StrategicSearch): init VariableBindingsManager

	* strategyExpression.hh (check): changed input arguments

	* subtermProcess.cc (run): open context with the context specification
	and only if not empty

	* subtermStrategy.cc (SubtermStrategy): move most checks to check
	(check): call checkSubterms and build context specification and index
	translation
	(checkSubterms): code from the constructor
	(rebuild): adjust to new meaning of indices
	(decompose): remove BadFlag and use index translation

	* subtermStrategy.hh: do not inherit from BadFlag and added fields
	contextSpec and indexTranslation
	(getContextSpec, checkSubterms): added
	(check): changed input arguments

	* subtermTask.cc (SubtermTask): init match substitution

	* testStrategy.cc (check): changed input arguments and build index
	translation

	* testStrategy.hh: removed inheritance from BadFlag and added field
	inputTranslation
	(check): changed input arguments

	* trivialStrategy.cc (check): changed input arguments

	* trivialStrategy.hh (check): changed input arguments

	* unionStrategy.cc (check): changed input arguments

	* unionStrategy.hh (check): changed input arguments

	* variableBindingsManager.cc (VariableBindingsManager): added argument
	for the substitution size
	(~VariableBindingsManager): added
	(openContext): added a context specification as an argument
	and it is used
	(instantiate): removed variable info argument and usage
	(buildInitialSubstitution): added index translation as input argument

	* variableBindingsManager.hh: new data field like a queue of free
	cells, a cached substitution and a static empty vector of DAG nodes
	(VariableBindingsManager, ~VariableBindingsManager): added
	(openContext): added overload and context specification as arguments
	(instantiate): changed input arguments
	(buildInitialSubstitution): changed input arguments
	(TermCompare): removed
	(Entry): inherit from RootContainer instead of SimpleRootContainer
	and change content to a vector of DAG nodes
	(closeContext): modified to use the new entries and the queue
	(parentContext): removed
	(init, free): added

2018-09-11  Rubén Rubio  <rubenrub@ucm.es>

	* callProcess.cc (CallProcess): added parameter tailCall
	(run): task are created one level up for tail calls

	* callProcess.hh: added attribute tailCall
	(CallProcess): added parameter tailCall

	* callStrategy.cc (decompose): non-tail simple calls are handled with
	a call task
	(tailCall): added

	* variableBindingsManager.hh (closeContext): ensure context is not
	empty before deleting

2018-07-18  Rubén Rubio  <rubenrub@ucm.es>

	* subtermTask.cc (subtermTask): fixed a memory leak,
	the extension info was not deleted

2018-04-18  Rubén Rubio  <rubenrub@ucm.es>

	* applicationProcess.cc (ApplicationProcess): added reduction of
	the substitution values
	(~ApplicationProcess): added
	(run): removed warning about wrong number of substrategies in
	conditional rules

	* applicationProcess.hh: new data member instedSubstitution
	(~ApplicationProcess): added

	* applicationStrategy.cc (process): removed filling sort info

	* applicationStrategy.hh (getValues): added

	* callProcess.cc (CallProcess): receives a RewritingContext instead of
	a DagNode
	(run): added tracing of strategy calls

	* callProcess.hh: callContext is now a pointer
	(CallProcess): receives a RewritingContext instead of a DagNode

	* callStrategy.cc (CallStrategy, check): callTerm is now a CachedDag
	(~CallStrategy): removed
	(process): removed filling sort information
	(decompose): added tracing of simple strategy calls, and call arguments
	are reduced

	* callStrategy.hh: call term is now a CachedDag
	(~CallStrategy): removed

	* subtermStrategy.cc (rebuild): receives DagRoots instead of DagNodes
	(decompose): added GC_SUBSTITUTION in MatchSearchState construction

	* subtermStrategy.hh (rebuild): receives DagRoots instead of DagNodes

	* subtermTask.cc (pushSolution): fixed a memory leak

	* testStrategy.cc (decompose): added GC_SUBSTITUTION in
	MatchSearchState construction

	* variableBindingsManager.cc (openContext): removed creation of DagRoots
	(getValue): changed return type to DagNode
	(instantiate): receives a Term instead of a DagNode, and computes the
	base sort
	(buildInitialSubstitution): creates DagRoots for the initial substitution
	(markReachableNodes): added

	* variableBindingsManager.hh: Bindings is a map to DagNodes instead
	of DagRoots, and Entry subclasses SimpleRootContainer
	(getValue): changed return type to DagNode
	(getValues): changed return type to a vector of DagNodes
	(instantiate): receives a DagNode instead of a Term
	(markReachableNodes): added

2018-04-11  Rubén Rubio  <rubenrub@ucm.es>

	* oneStrategy.cc: added

	* oneStrategy.hh: added

	* oneTask.cc: added

	* oneTask.hh: added

2018-04-06  Rubén Rubio  <rubenrub@ucm.es>

	* callStrategy.cc (decompose): call arguments are reduced

	* callStrategy.hh (getVariableInfo): added getter for variable information

	* subtermStrategy.cc (decompose): set initial search substitution

	* testStrategy.cc (getPattern): added getter for the pattern
	(decompose): set initial search substitution

	* variableBindingsManager.cc (openContext): using tables for storing
	bindings and deleted importation of bindings from its parents.
	(TermCompare): added
	(getValue): added
	(instantiate): use getValue and call computeBaseSortForGroundTerm to
	have isGround flags properly set
	(buildInitialSubstitution): added

	* variableBindingsManager.hh: using tables for storing bindings.
	(TermCompare): struct to give a sorting function for map.
	(getValue): added
	(buildInitialSubstituion): added
	(getVariables): deleted

2018-03-23  Rubén Rubio  <rubenrub@ucm.es>

	* applicationProcess.cc (ApplicationProcess): instantiation of
	the substitution according to the context
	(run): two -questionable- warnings are issued when the given strategies
	number differ from the number of rewriting conditions

	* applicationStrategy.cc (ApplicationStrategy): variable in the substitution
	values are indexed (to be instantiated) and other minor changes
	(check, process): added

	* applicationStrategy.hh: added variableInfo data member 
	(getVariableInfo, check, process): add
	(getValues): changed to be a const function

	* branchStrategy.cc (check, process): added

	* branchStrategy.hh (check, process): added

	* callProcess.cc: added

	* callProcess.hh: added

	* callStrategy.cc: added

	* callStrategy.hh: added

	* callTask.cc: added

	* callTask.hh: added

	* concatenationStrategy.cc (check, process): added

	* concatenationStrategy.hh (check, process): added

	* decompositionProcess.cc: the file comment was out of place (copied-pasted)

	* iterationStrategy.cc (check, process): added

	* iterationStrategy.hh (check, process): added

	* matchProcess.cc: using SharedPointer instead of
	SharedRewriteSearchState

	* matchProcess.hh: using SharedPointer instead of
	SharedRewriteSearchState

	* rewriteTask.cc (~RewriteTask): the extension info copy is freed
	(executionsExhausted): removed argument name to avoid a compiler warning
	(RewriteTask): using SharedPointer instead of SharedRewriteSearchState

	* rewriteTask.hh: using SharedPointer instead of
	SharedRewriteSearchState

	* sharedRewriteSearchState.cc: deleted. A shared match search state was
	also required so this has been replaced by a generic shared pointers.

	* sharedRewriteSearchState.hh: renamed to sharedValue.hh

	* sharedValue.hh: shared pointer adapted from SharedRewriteSearchState code

	* strategicSearch.hh: inheritance from VariableBindingManager

	* strategicTask.cc (StrategicTask): added ContextId constructor and changed the
	other to take their context from the task's parent

	* strategicTask.hh: added varsContext data member
	(StrategicTask): added ContextId constructor
	(getVarsContext): added

	* strategyExpression.hh (check, process): added

	* strategyLanguage.hh: added CallProcess, CallTask, SubtermProcess, SubtermTask and
	VariableBindingsManager

	* subtermProcess.cc: added

	* subtermProcess.hh: added

	* subtermStrategy.cc: added

	* subtermStrategy.hh: added

	* subtermTask.cc: added

	* subtermTask.hh: added

	* testStrategy.cc (check, process): added
	(TestStrategy): use lazy pattern
	(decompose): bad flag checking and initial substitution

	* testStrategy.hh: inheritance from BadFlag
	(getCondition): is now a const function
	(check, process): added

	* trivialStrategy.cc (check, process): added

	* trivialStrategy.cc (check, process): added

	* unionStrategy.cc (check, process): added

	* unionStrategy.hh (check, process): added

	* variableBindingsManager.cc: added

	* variableBindingsManager.hh: added

2017-09-27  Steven Eker  <eker@install.csl.sri.com>

	* strategyLanguage.hh: added class SubtermStrategy

	* subtermStrategy.cc: created

	* subtermStrategy.hh: created

2017-09-14  Steven Eker  <eker@install.csl.sri.com>

	* testStrategy.hh: fix comment

===================================Maude116===========================================

2017-03-31  Steven Eker  <eker@install.csl.sri.com>

	* strategicSearch.hh (StrategicTask): derive from CacheableState

===================================Maude112a===========================================

2017-01-11  Steven Eker  <eker@install.csl.sri.com>

	* applicationProcess.cc (resolveRemainingConditionFragments): stack<> -> Stack<>

===================================Maude111b===========================================

2016-10-12  Steven Eker  <eker@install.csl.sri.com>

	* applicationStrategy.cc (ApplicationStrategy): fix
	signed/unsigned comparison warning in Assert()

===================================Maude111===========================================

2010-09-22  Steven Eker  <eker@rho>

	* applicationProcess.hh (class ApplicationProcess): updated decl
	for doRewrite()

	* branchTask.hh (class BranchTask): startIndex replaces startDag;
	updated decl for ctor

	* branchTask.cc (BranchTask::BranchTask): take startIndex rather
	than startDag
	(BranchTask::executionSucceeded): use startIndex rather than
	startDag
	(BranchTask::executionsExhausted): use startIndex rather than
	startDag

	* applicationProcess.hh (class ApplicationProcess): updated decl
	for ctor

	* applicationProcess.cc (ApplicationProcess::ApplicationProcess):
	take startIndex rather than startDag

	* applicationStrategy.cc (ApplicationStrategy::decompose): use
	getDagIndex() in place of getDag()

	* testStrategy.cc (TestStrategy::decompose): use getDagIndex()

	* branchStrategy.cc (BranchStrategy::decompose): use getDagIndex()
	rather than getDag()

	* applicationProcess.cc (ApplicationProcess::doRewrite): return
	result index
	(ApplicationProcess::run): use resultIndex

	* rewriteTask.cc (RewriteTask::RewriteTask): pass an index to
	DecompositionProcess()

	* rewriteTask.hh (class RewriteTask): updated decl for
	executionSucceeded()

	* rewriteTask.cc (RewriteTask::RewriteTask): initialize hashConsSet
	(RewriteTask::executionSucceeded): use hashConsSet and resultIndex

	* rewriteTask.hh (class RewriteTask): added data member hashConsSet

	* branchTask.hh (class BranchTask): updated decl for
	executionSucceeded()

	* branchTask.cc (BranchTask::executionSucceeded): use resultIndex
	rather than result

	* strategicSearch.cc (StrategicSearch::executionSucceeded): take
	resultIndex rather than result
	(StrategicSearch::findNextSolution): use solutionIndex

	* strategicSearch.hh (class StrategicSearch): solution becomes
	solutionIndex

	* strategicSearch.cc (StrategicSearch::StrategicSearch): call
	insert() to get a dagIndex to pass to DecompositionProcess()

	* strategicSearch.hh (class StrategicSearch): updated decl for
	executionSucceeded()

	* strategicTask.hh (class StrategicTask): updated decl for
	resultIndex

	* strategicExecution.hh (class StrategicExecution): updated decl
	for succeeded()

	* strategicExecution.cc (StrategicExecution::succeeded): take
	resultIndex rather than result

	* decompositionProcess.cc
	(DecompositionProcess::DecompositionProcess): take dagIndex (both
	versions)
	(DecompositionProcess::run): no need to look up dagIndex

	* decompositionProcess.hh (class DecompositionProcess): update
	ctor decl
	(class DecompositionProcess): dag becomes dagIndex
	(DecompositionProcess::getDag): becomes getDagIndex()

2010-09-16  Steven Eker  <eker@rho>

	* decompositionProcess.cc (DecompositionProcess::run): use
	HashConsSet rather than DagNodeCache

	* applicationProcess.cc (ApplicationProcess::doRewrite): use
	HashConsSet rather than DagNodeCache

	* strategicSearch.hh (class StrategicSearch): derive from
	HashConsSet rather than DagNodeCache

===================================Maude95===========================================

2008-09-11  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc (resolveRemainingConditionFragments):
	remove cute coding; don't look up a AssignmentConditionFragment*
	twice

===================================Maude91a===========================================

2007-09-28  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc (resolveRemainingConditionFragments):
	justify two uses of clone() and turn one into a copy()
	(doRewrite): justify use of clone()

	* rewriteTask.cc (RewriteTask, executionSucceeded): justify use of
	clone()

===================================Maude89h===========================================

2007-01-23  Steven Eker  <eker@goo.csl.sri.com>

	* strategicTask.cc (alreadySeen): ugly hack to avoid a UMR in
	purify

2006-12-15  Steven Eker  <eker@goo.csl.sri.com>

	* decompositionProcess.cc (run): check if we've been here before
	on behalf of the same task
	(run): need to call finished if we are goind to die because of
	redundancy

	* strategicExecution.hh (getOwner): added

	* strategicTask.cc (alreadySeen): added

	* strategicTask.hh (class StrategicTask): added typedefs State and
	SeenSet and data member seenSet and decl for alreadySeen()

2006-12-14  Steven Eker  <eker@goo.csl.sri.com>

	* decompositionProcess.hh (class DecompositionProcess): deleted
	decl for non-stack verison of DecompositionProcess()

	* decompositionProcess.cc (DecompositionProcess): deleted
	non-stack version

	* strategyStackManager.cc (push): fix missing return statement bug

	* rewriteTask.cc (RewriteTask): pass a StackId to
	DecompositionProcess()

	* strategicSearch.cc (StrategicSearch): pass a StackId to
	DecompositionProcess()

	* rewriteTask.cc (RewriteTask): update pending argument

	* rewriteTask.hh (class RewriteTask): use StrategyStackManager for
	pending

	* matchProcess.cc (MatchProcess): update pending argument

	* matchProcess.hh (class MatchProcess): use StrategyStackManager
	for pending

	* branchTask.cc (BranchTask): initialize strategyStackManager; use
	a push() in order to call stack version of DecompositionProcess()
	(executionsExhausted, executionSucceeded): use
	strategyStackManager
	(executionSucceeded): pass strategyStackManager to our ctor

	* branchTask.hh (class BranchTask): added strategyStackManager
	data member

	* unionStrategy.cc (decompose): update now that we need to pass
	strategy manager to pushStrategy()

	* concatenationStrategy.cc (decompose): update now that we need to
	pass strategy manager to pushStrategy()

	* iterationStrategy.cc (decompose): update now that we need to
	pass strategy manager to pushStrategy()

	* branchStrategy.cc (decompose): pass strategyStackManager arg

	* branchTask.hh (class BranchTask): update decls as pending is now
	a StrategyStackManager::StackId

	* applicationProcess.cc: rewritten using class
	StrategyStackManager

	* applicationProcess.hh (class ApplicationProcess): update decls
	as pending is now a StrategyStackManager::StackId

	* decompositionProcess.cc (run): rewritten using
	StrategyStackManager

	* strategyStackManager.hh (class StrategyStackManager): added enum
	Constants

	* strategicExecution.hh (class StrategicExecution): deleted
	typedef StrategyStack

	* decompositionProcess.hh (class DecompositionProcess): update
	decls as pending is now a StrategyStackManager::StackId
	(pushStrategy): rewritten

	* strategicSearch.hh (class StrategicSearch): derive from StrategyStackManager

	* strategyLanguage.hh: added fwd decl for class
	StrategyStackManager

2006-12-13  Steven Eker  <eker@goo.csl.sri.com>

	* strategyStackManager.hh: created

	* strategyStackManager.cc: created

===================================Maude88d===========================================

2006-11-10  Steven Eker  <eker@goo.csl.sri.com>

	* strategicSearch.hh (class StrategicSearch): added data member
	strategy and decl for dtor

	* strategicSearch.cc (StrategicSearch): save strategy
	(~StrategicSearch): added

	* testStrategy.cc (decompose): make test with unbound variables in
	condition always fail

	* matchProcess.cc (run): fixed uninitialized success bug

2006-11-09  Steven Eker  <eker@goo.csl.sri.com>

	* rewriteTask.hh (class RewriteTask): update decl for ctor

	* matchProcess.cc (run): use transferCount() to keep track of any
	rewrites generated by solve

	* applicationProcess.cc (resolveRemainingConditionFragments): use
	transferCount() to keep track of rewrites from reduction in
	assignment case

	* rewriteTask.cc (RewriteTask): take searchObject; use it to add
	in rewrite counts from reduction

	* applicationProcess.cc (resolveRemainingConditionFragments): fix
	a bug where we were losing eager copies of variables made by
	solve()
	(resolveRemainingConditionFragments): pass searchObject to
	RewriteTask()

2006-11-08  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc: ignore rewrites where the number of
	rewrite condition fragments in the rule differs from the number of
	substrategies

	* testStrategy.hh (getPatternTerm, getDepth, getCondition): added

	* branchStrategy.cc (BranchStrategy): rearranged initializers

	* branchStrategy.hh (class BranchStrategy): rearranged data
	members for better storage on 64bit matchines
	(getInitialStrategy, getSuccessStrategy, getFailureStrategy) 
	(getSuccessAction, getFailureAction): added

2006-11-07  Steven Eker  <eker@goo.csl.sri.com>

	* unionStrategy.hh (getStrategies): added

	* iterationStrategy.hh (getStrategy): added
	(getZeroAllowed): added

	* concatenationStrategy.hh (getStrategies): added

	* strategyExpression.hh: added decl for operator<<

	* trivialStrategy.hh (getResult): added

2006-11-06  Steven Eker  <eker@goo.csl.sri.com>

	* strategyLanguage.hh: added classes MatchProcess and RewriteTask

	* rewriteTask.cc (executionSucceeded): use MatchProcess()

	* matchProcess.hh: created

	* matchProcess.cc: created

	* applicationProcess.cc (resolveRemainingConditionFragments):
	rewritten using MatchProcess

	* assignmentProcess.cc (run): new
	resolveRemainingConditionFragments() convention

	* applicationProcess.cc (run): new
	resolveRemainingConditionFragments() convention

	* assignmentProcess.hh (class AssignmentProcess): updated decl for
	one of the ctors

	* assignmentProcess.cc (AssignmentProcess): use substitutionSoFar
	instead of context

	* rewriteTask.cc (RewriteTask): use substitutionSoFar instead of
	context

	* rewriteTask.hh (class RewriteTask): updated decl for ctor

	* applicationProcess.hh (class ApplicationProcess): updated decl
	for resolveRemainingConditionFragments()

	* applicationProcess.cc (resolveRemainingConditionFragments) 
	(doRewrite): rootContext -> baseContext
	(resolveRemainingConditionFragments): context -> substitutionSoFar

2006-11-03  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc (run): pass searchObject to doRewrite()
	(doRewrite): take search object; context now becomes just a
	substitution
	(resolveRemainingConditionFragments): pass searchObject to
	doRewrite()
	(doRewrite): handle caching new dag in searchObject
	(resolveRemainingConditionFragments): create special context to
	pass to solve() so we have the correct substituion as well as the
	correct root term; this fixes a bug that we weren't taking into
	account bindings made by previous condition fragments

2006-11-02  Steven Eker  <eker@goo.csl.sri.com>

	* rewriteTask.cc (RewriteTask): fix bug where rcf was declared
	local

2006-10-31  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc (resolveRemainingConditionFragments): use
	RewriteTask()

	* assignmentProcess.hh (class AssignmentProcess): added decl for
	rewrite version of ctor

	* assignmentProcess.cc (AssignmentProcess): added rewrite version

2006-10-30  Steven Eker  <eker@goo.csl.sri.com>

	* rewriteTask.hh: created

	* rewriteTask.cc: created

2006-10-26  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc (doRewrite): use new rebuildDag()
	semantics to fix trace bug

2006-10-25  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc (doRewrite): create a tracingContext that
	has both the correct whole term and the correct substitution; get
	hold of the redex specified by redexIndex using the PositionIndex
	version of getDagNode()

	* strategicSearch.cc (findNextSolution): check for aborts

	* assignmentProcess.cc (run): rewritten to make sure we call
	finished() before we return DIE

	* applicationProcess.cc (run): make sure we call finished() before
	we return DIE

	* assignmentProcess.cc (AssignmentProcess): fixed bug where we
	were storing new context in a local variable
	(run): call finished() when done

2006-10-24  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc (doRewrite): use context rather than
	substitution since we need to be able to trace substitutions via a
	context call

	* assignmentProcess.cc (run): use new
	resolveRemainingConditionFragments() conventions
	(AssignmentProcess): handle null extension info

	* applicationProcess.cc (resolveRemainingConditionFragments):
	rewritten to be more general
	(resolveRemainingConditionFragments): use AssignmentProcess()

	* applicationProcess.hh (doRewrite): deleted
	(class ApplicationProcess): update decl for resolveRemainingConditionFragments()

	* applicationProcess.cc (run): use new
	resolveRemainingConditionFragments() and doRewrite() conventions

	* applicationProcess.hh (doRewrite): updated

	* applicationProcess.cc (doRewrite): rewritten to take a
	substitution rather than a context
	(run): use simplified doRewrite()

2006-10-23  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.hh (class ApplicationProcess): added decl for
	new doRewrite()
	(doRewrite): added

	* applicationProcess.cc (doRewrite): rewritten to handle
	redexIndex, extensionInfo, substitution and rule that may have be
	saved from an earlier state of rewriteState

	* applicationProcess.hh (class ApplicationProcess): make
	resolveRemainingConditionFragments() static

	* assignmentProcess.hh: rewritten

2006-10-20  Steven Eker  <eker@goo.csl.sri.com>

	* assignmentProcess.cc: rewritten from scratch

2006-10-18  Steven Eker  <eker@goo.csl.sri.com>

	* strategyLanguage.hh: added class SharedRewriteSearchState

2006-10-17  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc: use SharedRewriteSearchState
	(~ApplicationProcess): deleted

	* applicationProcess.hh (class ApplicationProcess): use
	SharedRewriteSearchState; deleted data member initial

	* sharedRewriteSearchState.hh: created

	* sharedRewriteSearchState.cc: created

2006-10-11  Steven Eker  <eker@goo.csl.sri.com>

	* testStrategy.cc (decompose): pass depth to MatchSearchState()

	* testStrategy.hh: anywhere data member becomes depth; update decl
	for ctor

	* testStrategy.cc (TestStrategy): take depth arg

===================================Maude88b===========================================

2006-09-29  Steven Eker  <eker@goo.csl.sri.com>

	* assignmentProcess.cc (AssignmentProcess): created

	* assignmentProcess.hh: created

	* applicationProcess.hh (class ApplicationProcess): updated decl
	for ctor

	* applicationProcess.cc (ApplicationProcess): take searchObject
	rather than context

	* applicationStrategy.cc (decompose): pass searchObject rather
	than context to ApplicationProcess()

	* applicationProcess.hh (class ApplicationProcess): updated decl
	for resolveRemainingConditionFragments(); delete data member
	context

	* applicationProcess.cc (ApplicationProcess): don't save context -
	just use it to make initial subcontext
	(resolveRemainingConditionFragments): don't take context; use
	getContext()
	(run): don't pass context to resolveRemainingConditionFragments();
	use getContext()

2006-09-28  Steven Eker  <eker@goo.csl.sri.com>

	* applicationProcess.cc (run): use
	resolveRemainingConditionFragments()

	* applicationProcess.hh (class ApplicationProcess): added decl for
	resolveRemainingConditionFragments()
	(class ApplicationProcess): added data member strategy

	* applicationProcess.cc (doRewrite): become static; take
	rewriteState and context arguments
	(run): new doRewrite() convention
	(resolveRemainingConditionFragments): added

	* applicationProcess.hh (class ApplicationProcess): removed decl
	for run2(); added decl for doRewrite()

	* applicationProcess.cc (run2): deleted
	(run): rewritten
	(doRewrite): added

2006-09-27  Steven Eker  <eker@goo.csl.sri.com>

	* applicationStrategy.cc (decompose): use new ApplicationProcess
	convention

	* applicationProcess.hh (class ApplicationProcess): updated decl
	for ApplicationProcess()

	* applicationProcess.cc (ApplicationProcess): rewritten using new
	convention for passing ApplicationStrategy info

	* applicationStrategy.hh (getTop, getLabel, getVariables) 
	(getValues, getStrategies): added

	* applicationProcess.cc (ApplicationProcess): pass
	IGNORE_CONDITION to rewriteState ctor

2006-09-15  Steven Eker  <eker@goo.csl.sri.com>

	* testStrategy.hh (class TestStrategy): withExtension becomes
	anywhere

	* testStrategy.cc (TestStrategy): withExtension becomes anywhere
	(decompose): withExtension becomes anywhere; allow unbounded depth
	in anywhere case

2006-09-14  Steven Eker  <eker@goo.csl.sri.com>

	* testStrategy.cc (decompose): implemented using class MatchSearchState

2006-09-13  Steven Eker  <eker@goo.csl.sri.com>

	* testStrategy.hh (class TestStrategy): need withExtension data
	member after all

	* testStrategy.cc (TestStrategy): check for unbound variables

	* testStrategy.hh (class TestStrategy): replace existing data
	members with pattern
	(class TestStrategy): update ctor decl

	* testStrategy.cc (TestStrategy): rewritten

	* strategyLanguage.hh: added class TestStrategy

	* testStrategy.cc: created

	* testStrategy.hh (class TestStrategy, class TestStrategy): update
	ctor decl; added data members condition and withExtension

2006-09-01  Steven Eker  <eker@goo.csl.sri.com>

	* testStrategy.hh (class TestStrategy): created

	* stateCache.hh: deleted

	* stateCache.cc: deleted

	* strategyLanguage.hh: rm class StateCache

	* branchStrategy.cc (decompose): use Survival data type

	* branchStrategy.hh (class BranchStrategy): update decl for decompose()

	* concatenationStrategy.cc (decompose): use Survival data type

	* concatenationStrategy.hh (class ConcatenationStrategy): update
	decl for decompose()

	* unionStrategy.cc (decompose): use Survival data type

	* unionStrategy.hh (class UnionStrategy): update decl for
	decompose()

	* iterationStrategy.cc (decompose): use Survival data type

	* iterationStrategy.hh (class IterationStrategy): update decl for
	decompose()

	* trivialStrategy.cc (decompose): rewritten

	* trivialStrategy.hh (class TrivialStrategy): update decl for
	decompose()

	* applicationStrategy.cc (decompose): use Survival data type

	* applicationStrategy.hh (class ApplicationStrategy): update decl
	for decompose()

	* strategicSearch.cc (findNextSolution): use Survival data type

	* strategyExpression.hh (class StrategyExpression): updated decl
	for decompose(); made pure virtual

	* strategicProcess.hh (class StrategicProcess): updated decl for
	run()

	* applicationProcess.hh (class ApplicationProcess): updated decl
	for run()

	* applicationProcess.cc (run): use Survival data type

	* decompositionProcess.hh (class DecompositionProcess): updated
	decl for run()

	* decompositionProcess.cc (run): use Survival data type

	* iterationStrategy.cc (decompose): remove normalForm Assert()
	(~IterationStrategy): simplified

	* iterationStrategy.hh (class IterationStrategy): rm zeroAllowed
	data member

	* iterationStrategy.cc (IterationStrategy): rewritten

	* iterationStrategy.hh (class IterationStrategy): rm normalForm
	data member; update ctor decl

	* strategyLanguage.hh: removed classes TrivialSetGenerator,
	ApplicationSetGenerator, SetGenerator, ConcatenationSetGenerator,
	IterationSetGenerator, BranchSetGenerator, UnionSetGenerator

	* setGenerator.hh: deleted

	* unionSetGenerator.cc: deleted

	* unionSetGenerator.hh: deleted

	* branchSetGenerator.cc: deleted

	* branchSetGenerator.hh: deleted

	* iterationSetGenerator.cc: deleted

	* iterationSetGenerator.hh: deleted

	* concatenationSetGenerator.cc: deleted

	* concatenationSetGenerator.hh: deleted

	* applicationSetGenerator.cc: deleted

	* applicationSetGenerator.hh: deleted

	* trivialSetGenerator.cc: deleted

	* trivialSetGenerator.hh: deleted

	* applicationStrategy.cc (execute): deleted

	* applicationStrategy.hh (class ApplicationStrategy): remove decl
	for execute()

	* trivialStrategy.cc (execute): deleted

	* trivialStrategy.hh (class TrivialStrategy): remove decl for
	execute()

	* iterationStrategy.hh (class IterationStrategy): remove decl for
	execute()

	* iterationStrategy.cc (execute): deleted

	* branchStrategy.cc (execute): deleted

	* branchStrategy.hh (class BranchStrategy): remove decl for
	execute()

	* concatenationStrategy.cc (execute): deleted

	* concatenationStrategy.hh (class ConcatenationStrategy): remove
	decl for execute()

	* unionStrategy.cc (execute): deleted

	* unionStrategy.hh (class UnionStrategy): remove decl for
	execute()

	* strategyExpression.hh (class StrategyExpression): remove decl
	for execute()

	* strategyLanguage.hh: removed class UnaryStrategy, class UnarySetGenerator

	* unarySetGenerator.cc: deleted

	* unarySetGenerator.hh (class UnarySetGenerator): deleted

	* unaryStrategy.hh: deleted

	* unaryStrategy.cc: deleted

2006-08-30  Steven Eker  <eker@goo.csl.sri.com>

	* branchStrategy.hh (class BranchStrategy): added ITERATE to enum
	Action

	* branchStrategy.cc (BranchStrategy): allow ITERATE

	* branchTask.cc (executionsExhausted): fixed bug where we were
	using successAction instead of failureAction
	(executionSucceeded): handle ITERATE case

	* branchStrategy.cc (BranchStrategy): rewritten
	(execute): rewritten
	(decompose): rewritten
	(BranchStrategy): added Assert()s
	(~BranchStrategy): updated

	* branchStrategy.hh (class BranchStrategy): added data members
	successAction and failureAction; renamed existing data members;
	updated ctor

2006-08-28  Steven Eker  <eker@goo.csl.sri.com>

	* strategicSearch.hh (class StrategicSearch): executionSucceeded()
	and executionsExhausted() now return Survival

	* strategicSearch.cc (executionSucceeded, executionsExhausted):
	now return Survival

	* branchTask.cc (executionsExhausted): rewritten
	(executionSucceeded): rewritten

	* branchTask.hh (class BranchTask): update decls for
	executionSucceeded() and executionsExhausted()

	* strategicExecution.cc (finished): handle return value from
	executionsExhausted()
	(succeeded): handle return values from executionSucceeded() and
	executionsExhausted()

	* strategicTask.hh (class StrategicTask): executionSucceeded() and
	executionsExhausted() now return survival flag

	* strategicExecution.hh (class StrategicExecution): added enum
	Survival

	* branchTask.hh (class BranchTask): remove enum Action

	* branchStrategy.hh (class BranchStrategy): added enum Action

	* branchStrategy.cc (decompose): new BranchTask() convention

	* branchTask.cc (executionSucceeded): make use of successAction
	(executionsExhausted): make use of failureAction

	* branchTask.hh (class BranchTask): added enum Action; added
	successAction and failureAction to ctor arg list
	(class BranchTask): added data members successAction and
	failureAction

	* strategicSearch.cc (StrategicSearch): disambig call to
	StrategicTask()

	* branchStrategy.cc (decompose): added

	* strategicTask.cc (StrategicTask): added sibling based ctor

	* strategicTask.hh (class StrategicTask): added decl for sibling
	based ctor

	* branchTask.hh (class BranchTask): updated decl for ctor

	* branchTask.cc (BranchTask): take sibling rather than master

	* branchStrategy.hh (class BranchStrategy): added decl for decompose()

	* branchTask.cc (executionsExhausted): use finished() rather than
	failed()

	* applicationProcess.cc (run): use finished() rather than failed()

	* decompositionProcess.cc (run): new convention for succeeded();
	use finished() rather than failed()

	* strategicExecution.cc (failed): becomes finished(); use new
	insertionPoint convention
	(succeeded): use new insertionPoint convention

	* strategicSearch.hh (class StrategicSearch): updated decls for
	executionSucceeded(), executionsExhausted()

	* strategicExecution.hh (class StrategicExecution): updated decl
	for succeeded(), failed() becomes finished()

	* strategicTask.hh (class StrategicTask): updated decls for
	executionSucceeded(), executionsExhausted()

	* branchTask.hh (class BranchTask): updated decls for
	executionSucceeded(), executionsExhausted()

	* branchTask.cc (executionSucceeded, executionsExhausted): take
	insertionPoint arg

2006-08-25  Steven Eker  <eker@goo.csl.sri.com>

	* strategyLanguage.hh: added class BranchTask

	* branchTask.cc: created

	* branchTask.hh: created

2006-08-24  Steven Eker  <eker@goo.csl.sri.com>

	* iterationStrategy.hh (class IterationStrategy): added data
	member star

	* iterationStrategy.cc (decompose): added
	(IterationStrategy): create * subexpression in + case
	(~IterationStrategy): handle * subexpression
	(decompose): handle + case

	* iterationStrategy.hh (class IterationStrategy): added decl for decompose()

	* unionStrategy.cc (decompose): added

	* unionStrategy.hh (class UnionStrategy): added decl for decompose()

	* trivialStrategy.cc (decompose): take StrategicSearch&; don't
	call failed()

	* trivialStrategy.hh (class TrivialStrategy): updated decl for
	decompose()

	* strategicSearch.cc (findNextSolution): fix bad assert - if del
	== false we haven't run out of processes

	* concatenationStrategy.cc (decompose): fix obiwan bug in loop
	start

	* decompositionProcess.cc (run): call failed to unlink ourself if
	we are requesting destruction

	* applicationProcess.hh (class ApplicationProcess): fixed nasty
	bug where we were storing a reference to pending rather than a
	copy

2006-08-15  Steven Eker  <eker@goo.csl.sri.com>

	* decompositionProcess.cc (DecompositionProcess): fixed dag/start
	bug

	* strategicSearch.cc (StrategicSearch): added Assert()s for
	arguments

	* decompositionProcess.cc (DecompositionProcess): (2 versions)
	added Assert()

	* decompositionProcess.hh (getDag): added Assert()

	* applicationStrategy.cc (decompose): updated

	* concatenationStrategy.cc (decompose): updated

	* applicationStrategy.hh (class ApplicationStrategy): updated decl
	for decompose()

	* concatenationStrategy.hh (class ConcatenationStrategy): updated
	decl for decompose()

	* strategyExpression.hh (class StrategyExpression): updated decl
	for decompose()

	* decompositionProcess.cc (run): updated

	* applicationProcess.cc (run): updated

	* applicationProcess.hh (class ApplicationProcess): updated decl
	for run()

	* decompositionProcess.hh (class DecompositionProcess): updated
	decl for run()

	* strategicProcess.hh (class StrategicProcess): updated decl for
	run()

	* strategicSearch.cc (StrategicSearch): added

	* strategicTask.hh (getDummyExecution): added

	* strategicTask.cc (~StrategicTask): make consistent

	* strategicTask.hh (class StrategicTask): slaveList is a
	StrategicExecution not a StrategicExecution*

	* strategicSearch.hh (class StrategicSearch): added decl for
	getContext(); added data member initial
	(getContext): added

2006-08-14  Steven Eker  <eker@goo.csl.sri.com>

	* decompositionProcess.hh (getDag): added

	* applicationStrategy.hh (class ApplicationStrategy): added decl
	for decompose()

	* strategyLanguage.hh: add class ApplicationProcess; rm class
	StrategicProcessLink

	* applicationProcess.hh: created

	* applicationProcess.cc: created

	* strategicExecution.hh (class StrategicExecution): added typedef
	StrategyStack

	* decompositionProcess.hh (getPending): added
	(class DecompositionProcess): added decl for new ctor
	(class DecompositionProcess): removed typedef StrategyStack

	* concatenationStrategy.cc (decompose): added

	* concatenationStrategy.hh (class ConcatenationStrategy): added
	decl for decompose()

2006-08-11  Steven Eker  <eker@goo.csl.sri.com>

	* trivialStrategy.hh (class TrivialStrategy): added decl for decompose()

	* trivialStrategy.cc (decompose): added

	* strategyLanguage.hh: added class DecompositionProcess

	* strategyExpression.hh (class StrategyExpression): added new
	member function decompose()

	* decompositionProcess.cc: created
	(DecompositionProcess): take pointer rather than const ref for
	copy version

	* decompositionProcess.hh (pushStrategy): added
	(class DecompositionProcess): use stack<> rather than list<>

2006-08-10  Steven Eker  <eker@goo.csl.sri.com>

	* decompositionProcess.hh: created

	* strategicSearch.cc (findNextSolution): rewritten without
	explicit process queue

	* strategicProcess.hh (class StrategicProcess): derive from
	Strategic execution

	* strategicProcessLink.cc: becomes strategicProcess.cc

	* strategicProcessLink.hh: becomes strategicProcess.hh

	* strategicSearch.cc: new conventions

	* strategicSearch.hh: rewritten

	* strategyLanguage.hh: added classes StrategicProcessLink and
	StrategicProcess

	* strategicProcessLink.cc: created

	* strategicProcessLink.hh: created

2006-08-09  Steven Eker  <eker@goo.csl.sri.com>

	* strategicExecution.cc (succeeded): need to report
	executionsExhausted()
	(StrategicExecution): we do need to initialize to this pointer
	after all
	(StrategicExecution): insert before rather than after
	(~StrategicExecution): added

	* strategicTask.cc: rewritten to new design

	* strategicExecution.hh (getNextSlave): added

	* strategicTask.hh: rewritten to new design

	* strategicExecution.cc (StrategicExecution): initializing prev
	and next to 0 is as good as anything and should ease debugging

2006-08-08  Steven Eker  <eker@goo.csl.sri.com>

	* strategicSearch.cc: created

	* strategyLanguage.hh: added classes StrategicExecution,
	StrategicTask, StrategicSearch

	* strategicExecution.hh: created

	* strategicTask.cc: created

	* strategicTask.hh: created

2006-08-07  Steven Eker  <eker@goo.csl.sri.com>

	* strategicSearch.hh: created
	
===================================Maude88a===========================================

2006-06-28  Steven Eker  <eker@goo.csl.sri.com>

	* iterationSetGenerator.cc (findNextSolution): fix new bug
	introduced by last fix
	(IterationSetGenerator): replace done with started
	(findNextSolution): use started hack rather that done

	* iterationSetGenerator.hh (class IterationSetGenerator): added
	data member done

	* iterationSetGenerator.cc (findNextSolution): fix bug where
	returning a normal form with an empty queue starts us over by
	using done flag
	(IterationSetGenerator): initialized done flag

2006-05-04  Steven Eker  <eker@goo.csl.sri.com>

	* strategyLanguage.hh: added class StateCache

	* stateCache.hh: created

	* stateCache.cc: created

2006-04-24  Steven Eker  <eker@goo.csl.sri.com>

	* strategyLanguage.hh: added classes UnaryStrategy and
	UnarySetGenerator

2006-04-21  Steven Eker  <eker@goo.csl.sri.com>

	* unarySetGenerator.cc: created

	* unaryStrategy.cc: created

	* unarySetGenerator.hh: created

	* unaryStrategy.hh: created

2006-04-18  Steven Eker  <eker@goo.csl.sri.com>

	* iterationStrategy.cc (IterationStrategy): set normalForm flag
	(execute): pass normalForm flag

	* iterationStrategy.hh (class IterationStrategy): added data
	member normalForm

2006-04-17  Steven Eker  <eker@goo.csl.sri.com>

	* iterationSetGenerator.hh (class IterationSetGenerator): updated
	decl for ctor

	* iterationSetGenerator.cc (IterationSetGenerator) 
	(findNextSolution): support normalForm flag
	(IterationSetGenerator): updated

	* branchSetGenerator.hh (class BranchSetGenerator): rewritten for
	fairness

	* branchSetGenerator.cc: rewritten for fairness

2006-04-13  Steven Eker  <eker@goo.csl.sri.com>

	* applicationSetGenerator.hh (class ApplicationSetGenerator):
	update ctor decl

	* applicationStrategy.cc (execute): pass top flag to ApplicationSetGenerator()

	* applicationSetGenerator.cc (ApplicationSetGenerator): take and
	handle top flag

2006-04-12  Steven Eker  <eker@goo.csl.sri.com>

	* strategyLanguage.hh: removed classes StrategySequence and
	SequenceSetGenerator

	* strategySequence.hh: deleted

	* sequenceSetGenerator.hh: deleted

	* strategySequence.cc: deleted

	* sequenceSetGenerator.cc: deleted

	* concatenationSetGenerator.cc: created

2006-04-11  Steven Eker  <eker@goo.csl.sri.com>

	* concatenationSetGenerator.hh: created

2006-04-06  Steven Eker  <eker@goo.csl.sri.com>

	* concatenationStrategy.cc: created

	* concatenationStrategy.hh (class ConcatenationStrategy): created

2006-04-05  Steven Eker  <eker@goo.csl.sri.com>

	* applicationSetGenerator.cc (ApplicationSetGenerator): pass min
	and max depth args to RewriteSeachState init to fix bug that
	defaults only allow rewriting at top without extension

===================================Maude87a===========================================

2006-03-24  Steven Eker  <eker@goo.csl.sri.com>

	* applicationStrategy.cc (ApplicationStrategy): need to call
	normalize() and prepare() on cached dags

	* unionSetGenerator.cc (findNextSolution): fix memory leak where
	we were not deleting failed set generators

2006-03-21  Steven Eker  <eker@goo.csl.sri.com>

	* unionSetGenerator.cc: created

	* unionSetGenerator.hh: created

	* strategyLanguage.hh: added decls for classes UnionStrategy and
	UnionSetGenerator

	* strategySequence.hh (class StrategySequence): made strategies const

2006-03-20  Steven Eker  <eker@goo.csl.sri.com>

	* applicationStrategy.hh (class ApplicationStrategy): fix ctor decl

	* applicationStrategy.cc (ApplicationStrategy): pass strategies by reference

	* unionStrategy.cc: created

	* unionStrategy.hh: created

	* strategyLanguage.hh: added decls for classes BranchStrategy and
	BranchSetGenerator

	* branchSetGenerator.hh: created

	* branchSetGenerator.cc: created

	* branchStrategy.hh: created

	* branchStrategy.cc: created

2006-03-17  Steven Eker  <eker@goo.csl.sri.com>

	* iterationStrategy.cc (~IterationStrategy): added

2006-03-07  Steven Eker  <eker@goo.csl.sri.com>

	* applicationStrategy.cc (execute): implemented

	* applicationSetGenerator.cc: created

	* strategyLanguage.hh: added class ApplicationSetGenerator

	* applicationSetGenerator.hh: created

2006-03-06  Steven Eker  <eker@goo.csl.sri.com>

	* iterationSetGenerator.cc: created

	* iterationSetGenerator.hh (class IterationSetGenerator):
	strategies -> strategy
	(class IterationSetGenerator): added data member start
	(class IterationSetGenerator): added data member zeroReturnable
	(class IterationSetGenerator): added typedef GenQueue

2006-02-27  Steven Eker  <eker@goo.csl.sri.com>

	* strategyLanguage.hh: added decls for IterationStrategy,
	IterationSetGenerator

	* iterationSetGenerator.hh: created

	* iterationStrategy.hh: created

	* iterationStrategy.cc: created

	* sequenceSetGenerator.cc (SequenceSetGenerator) 
	(findNextSolution): simplified on the assumption that execute()
	never returns 0
	(findNextSolution): change of variable

	* strategySequence.cc (execute): use SequenceSetGenerator()

	* strategyLanguage.hh: added decls for StrategySequence,
	TrivialSetGenerator, SequenceSetGenerator

	* sequenceSetGenerator.hh: updated

	* sequenceSetGenerator.cc: created

2006-02-15  Steven Eker  <eker@goo.csl.sri.com>

	* strategySequence.hh (StrategyExpression): created

	* trivialStrategy.cc (execute): use TrivialSetGenerator()

	* applicationStrategy.cc: was application.cc

	* applicationStrategy.hh: was application.hh

	* trivial.cc: becomes trivialStrategy.cc

	* trivial.hh: becomes trivialStrategy.hh

	* trivialSetGenerator.hh (class TrivialSetGenerator): created

	* trivialSetGenerator.cc: created

	* strategyLanguage.hh: created

	* application.cc (execute): updated

	* application.hh (StrategyExpression): update decl forexecute()

	* trivial.hh (StrategyExpression): update decl forexecute()

	* strategyExpression.hh (class StrategyExpression): update decl
	for execute()

	* setGenerator.hh (class SetGenerator): created

2006-02-13  Steven Eker  <eker@goo.csl.sri.com>

	* application.cc (Application): Assert() to check for label ==
	NONE case

	* application.hh (StrategyExpression): added data member top
	(setTop): added

2006-02-06  Steven Eker  <eker@goo.csl.sri.com>

	* trivial.cc (Trivial): added ctor

	* trivial.hh (StrategyExpression): decl for ctor

	* application.cc (Application): added Assert()

2006-02-02  Steven Eker  <eker@goo.csl.sri.com>

	* application.cc (Application, ~Application): added

2006-02-01  Steven Eker  <eker@goo.csl.sri.com>

	* application.cc: created

	* idle.cc: becomes trivial.cc

	* idle.hh: becomes trivial.hh; add data member result

	* application.hh: created

	* strategyExpression.hh: created

	* idle.hh: created

	* idle.cc: created
