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
