12016-03-17 Steven Eker <eker@install.csl.sri.com> 2 3 * freeSymbol.hh (Symbol): added decl for computeGeneralizedSort2() 4 5 * freeSymbol.cc (computeGeneralizedSort2): replaces outputIterator 6 version of computeGeneralizedSort() 7 82016-03-16 Steven Eker <eker@install.csl.sri.com> 9 10 * freeSymbol.cc (computeGeneralizedSort): added outputIterator 11 version 12 13===================================Maude110=========================================== 14 152015-12-23 Steven Eker <eker@ape.csl.sri.com> 16 17 * freeDagArgumentIterator.hh (_freeDagArgumentIterator_hh_): fixed 18 type in guard #define 19 20===================================Maude108=========================================== 21 222015-09-18 Steven Eker <eker@ape.csl.sri.com> 23 24 * freeArgumentIterator.hh (_freeArgumentIterator_hh_): fixed 25 define guard 26 272015-08-07 Steven Eker <eker@ape.csl.sri.com> 28 29 * freeSymbol.hh (Symbol): added dec for unificationPriority() 30 31 * freeSymbol.cc (unificationPriority): added 32 33===================================Maude108=========================================== 34 352014-02-13 Steven Eker <eker@ape.csl.sri.com> 36 37 * freeRhsAutomaton.cc (recordInfo): don't pass needContiguous 38 argument to recordFunctionEval() 39 40===================================Maude101=========================================== 41 422014-01-31 Steven Eker <eker@ape.csl.sri.com> 43 44 * freeSymbol.cc (generateFinalInstruction, generateInstruction): 45 check for fast handling and use most general case if not 46 47 * freeNet.hh (fastHandling): added 48 49 * freeNet.cc (FreeNet): added 50 51 * freeNet.hh (F): declare ctor 52 53 * freeNet.cc (buildRemainders): compute value for fast data member 54 55 * freeRemainder.hh (fastCheckAndBind): added Assert() that we 56 really don't require slow case processing 57 (fastCheckAndBind, generalCheckAndBind): better commenting 58 (fastHandling): added 59 602013-12-20 Steven Eker <eker@ape.csl.sri.com> 61 62 * freeGeneralExtorFinal.cc (execute): use generalCheckAndBind() 63 64 * freeGeneralExtor.cc (execute): use generalCheckAndBind() 65 66 * freeRemainder.cc (slowCheckAndBind): added 67 68 * freeRemainder.hh (generalCheckAndBind): added 69 (FreeLhsStructs): added decl for slowCheckAndBind 70 712013-11-21 Steven Eker <eker@ape.csl.sri.com> 72 73 * freeInstruction.cc (execute): refactored, so that ctor cases 74 always preload symbol since this seems to give better code 75 76 * freeRemainder.cc (FreeRemainder): rearranged "fast" and 77 "super-fast" determination; use fastGeqSufficient() 78 79 * freeRemainder.hh (fastMatchReplace, fastCheckAndBind): use 80 fastLeq() 81 82===================================Maude100a=========================================== 83 842013-10-27 Steven Eker <eker@ape.csl.sri.com> 85 86 * freeTheory.hh: added classes FreeGeneralExtor and 87 FreeGeneralExtorFinal 88 89 * freeSymbol.cc (generateFinalInstruction): use 90 FreeGeneralExtorFinal() 91 92 * freeGeneralExtorFinal.hh: created 93 94 * freeGeneralExtorFinal.cc: created 95 96 * freeDagNode.hh (DagNode): new friends FreeGeneralExtor and 97 FreeGeneralExtorFinal 98 99 * freeNet.hh (F): new friends FreeGeneralExtor and 100 FreeGeneralExtorFinal 101 102 * freeSymbol.cc (generateInstruction): use FreeGeneralExtor() 103 104 * freeGeneralExtor.hh: created 105 106 * freeGeneralExtor.cc: created 107 108 * freeNetExec.cc (applyReplaceNoOwise2, applyReplaceFast2) 109 (applyReplace2): make diff long to take advantage of long 110 symbolIndex in new TestNode 111 112 * freeNet.hh (F): new TestNode layout 113 114 * freeNetExec.hh (findRemainderListIndex): change diff to long 115 116 * freeNet.hh (F): undo "quick hack" from 2013/5/11 117 118 * freeInstruction.cc (execute): reverted to pre scratchpad code 119 120 * freeRemainder.hh (fastCheckAndBind): reverted to pre scratchpad 121 code 122 123 * freeNetExec.hh (findRemainderListIndex): reverted to pre 124 scratchpad code 125 1262013-10-26 Steven Eker <eker@ape.csl.sri.com> 127 128 * freeInstruction.cc (execute): try storing pointer to 129 localArgList in scratchpad at the outset 130 (execute): fails - free net code craps on this pointer when it 131 reuses the 0 slot 132 133 * freeNetExec.hh (findRemainderListIndex): take argList as well 134 135 * freeInstruction.cc (execute): rewritten use use rawScratchPad 136 137 * freeRemainder.hh (fastCheckAndBind): take stackBase argument 138 139 * freeNet.hh (F): updated decl for findRemainderListIndex() 140 141 * freeNetExec.hh (findRemainderListIndex): use negation cheat on 142 non-unrolled version 143 (findRemainderListIndex): same cheat on unrolled loop 144 (findRemainderListIndex): take stackBase argument 145 1462013-10-25 Steven Eker <eker@ape.csl.sri.com> 147 148 * freeDagNode.hh (DagNode): new friends: FreeGeneralCtor, 149 FreeGeneralCtorFinal 150 151 * freeSymbol.cc (generateFinalInstruction): use 152 FreeGeneralCtorFinal 153 (generateInstruction): use FreeGeneralCtor 154 155 * freeGeneralCtorFinal.cc: created 156 157 * freeGeneralCtorFinal.hh: created 158 159 * freeGeneralCtor.cc: created 160 161 * freeGeneralCtor.hh: created 162 163 * freeSymbol.cc (generateFinalInstruction, generateInstruction): 164 use FreeGeneralInstruction 165 166 * freeInstruction.cc (execute): added generalCtor code 167 168 * freeGeneralInstruction.hh: created 169 170 * freeGeneralInstruction.cc: created 171 172 * freeInstruction.cc (FreeInstruction): don't set op code 173 (execute): use FastInstruction 174 175 * freeSymbol.cc (generateFinalInstruction, generateInstruction): 176 use FreeFastInstruction 177 178 * freeFastInstruction.cc: created 179 180 * freeFastInstruction.hh: created 181 182 * freeNullaryInstruction.cc: created 183 184 * freeNullaryInstruction.hh: created 185 186 * freeSymbol.cc (generateFinalInstruction, generateInstruction): 187 use FreeNullaryInstruction 188 1892013-10-24 Steven Eker <eker@ape.csl.sri.com> 190 191 * freeInstruction.cc (execute): use arg specific instruction 192 classes 193 (FreeInstruction): deleted argumentSlots version 194 195 * freeSymbol.cc (generateFinalInstruction, generateInstruction): 196 copied arg specific instruction versions from Alpha99 tree 197 198 * freeInstruction.hh (NonFinalExtor): delete argIndex, and decl 199 for argumentSlots version ctor 200 201 * freeInstruction.cc (FreeInstruction): added version without argumentSlots 202 203 * freeInstruction.hh (NonFinalExtor): added decl for ctor without 204 argumentSlots 205 * freePreNet.hh (F): remove FreeNet2 stuff 206 207 * freeDagNode.hh (DagNode): FreeNet2 is no longer a friend 208 209 * freeTheory.hh: removed all extor/ctor classes; FreeNet2 210 211 * freeSymbol.cc (compileEquations): removed all FreeNet2 stuff 212 213 * freeSymbol.hh: removed all FreeNet2 stuff 214 215 * freeSymbol.cc (generateInstruction, generateFinalInstruction): 216 fix bugs by returning 0 for arity > 3 217 218===================================Maude100=========================================== 219 220 2013-10-17 Steven Eker <eker@ape.csl.sri.com> 221 222 * freeInstruction.cc (OK_TO_COLLECT_GARBAGE): call setTopFrame() 223 (TRY_REMAINDERS): use fastPushFrame() 224 (OK_TO_COLLECT_GARBAGE2): added 225 (TRY_REMAINDERS): don't call popToFrame() 226 (END_FRAME): use fastPop() in place of popFrame() and 227 getTopFrame() 228 (END_FRAME): use OK_TO_COLLECT_GARBAGE2() rather than 229 okToCollectGarbage() 230 (END_FRAME_NO_GC): use fastPop() in place of popFrame() and 231 getTopFrame() 232 (execute): use fastPushFrame() 233 (execute): use setTopFrame(frame) before returning 234 (WIN): increment local rewriteCount variable 235 (TRY_REMAINDERS_FINAL): increment local rewriteCount variable 236 (execute): increment local rewriteCount variable 237 (execute): add local rewriteCount to machine rewrite count 238 2392013-10-16 Steven Eker <eker@ape.csl.sri.com> 240 241 * freeInstruction.cc (execute): fixed bugs in ternaryCtorFinal and 242 ternaryFastCtorFinal 243 244 * freeRemainder.cc (dump): make sure fast is printed out as an 245 integer 246 247 * freeRemainder.hh (fastCheckAndBind): handle "super-fast" case 248 249 * freeInstruction.cc (FreeInstruction): remove fall thru's in the 250 hope of removing constraints on fallen into code 251 (OK_TO_COLLECT_GARBAGE): added 252 (WIN): call OK_TO_COLLECT_GARBAGE() 253 (TRY_REMAINDERS_FINAL): call OK_TO_COLLECT_GARBAGE() 254 (END_FRAME): call MemoryCell::okToCollectGarbage() 255 (FreeInstruction): don't call MemoryCell::okToCollectGarbage() 256 (NEXT): call OK_TO_COLLECT_GARBAGE() 257 (WIN, TRY_REMAINDERS_FINAL): removed OK_TO_COLLECT_GARBAGE() 258 (execute): rewritten using label pointers 259 (execute): implement returnInstruction 260 (END_FRAME_NO_GC): added 261 (execute): no gc for nullary final ctor and return instruction 262 (NEXT_NO_GC): added 263 (execute): no gc for nullay nonfinal ctor 264 (execute): use localArgList for fail case of binaryExtor and 265 ternaryExtor 266 2672013-10-15 Steven Eker <eker@ape.csl.sri.com> 268 269 * freeInsruction.hh: created 270 271 * freeInstruction.cc: created 272 2732013-10-11 Steven Eker <eker@ape.csl.sri.com> 274 275 * freeBinaryFastCtorFinal.cc (execute): don't pass getUniqueSortIndex() 276 277 * freeBinaryFastCtor.cc (execute): don't pass getUniqueSortIndex() 278 279 * freeUnaryFastCtorFinal.cc (execute): don't pass getUniqueSortIndex() 280 281 * freeTernaryFastCtor.cc (execute): don't pass getUniqueSortIndex() 282 283 * freeTernaryFastCtorFinal.cc (execute): don't pass getUniqueSortIndex() 284 285 * freeUnaryFastCtor.cc (execute): don't pass getUniqueSortIndex() 286 287 * freeDagNode.hh (FreeDagNode): (3 new ctors) sortIndex becomes 288 dummy since we want to do the getUniqueSortIndex() after memory 289 cell allocation to avoid register pressure 290 291 * freeSymbol.cc (generateFinalInstruction, generateInstruction): 292 utilize fast ctors 293 294 * freeTheory.hh: added classes FreeUnaryFastCtor, 295 FreeUnaryFastCtorFinal, FreeBinaryFastCtor, 296 FreeBinaryFastCtorFinal, FreeTernaryFastCtor, 297 FreeTernaryFastCtorFinal 298 299 * freeTernaryFastCtorFinal.cc: created 300 301 * freeTernaryFastCtorFinal.hh: created 302 303 * freeTernaryFastCtor.cc: created 304 305 * freeTernaryFastCtor.hh: created 306 307 * freeBinaryFastCtorFinal.cc: created 308 309 * freeBinaryFastCtorFinal.hh: created 310 311 * freeBinaryFastCtor.cc: created 312 313 * freeBinaryFastCtor.hh: created 314 315 * freeUnaryFastCtorFinal.cc: created 316 317 * freeUnaryFastCtorFinal.hh: created 318 319 * freeUnaryFastCtor.cc: created 320 321 * freeUnaryFastCtor.hh: created 322 323 * freeDagNode.hh (FreeDagNode): added 3 ctors that take a sortIndex 324 3252013-10-10 Steven Eker <eker@ape.csl.sri.com> 326 327 * freeNullaryCtor.cc (execute): don't load frame ptr until we need 328 it 329 330 * freeNullaryCtorFinal.cc (execute): don't load frame ptr until we 331 need it 332 333 * freeNullaryCtor.cc (execute): use getNode() optimization 334 335 * freeNullaryCtorFinal.cc (execute): use getNode() optimization 336 337 * freeNullaryCtor.cc (FreeNullaryCtor): cast symbol 338 339 * freeNullaryCtorFinal.cc (FreeNullaryCtorFinal): cast symbol 340 341 * freeNullaryCtorFinal.hh (FinalInstruction): symbol is now a 342 FreeNullarySymbol* 343 344 * freeTheory.hh: added classes FreeNullarySymbol, FreeUnarySymbol, 345 FreeBinarySymbol, FreeTernarySymbol 346 347 * freeNullaryCtor.hh (NonFinalCtor): symbol is now a 348 FreeNullarySymbol* 349 350 * freeSymbol.cc (newFreeSymbol): use freeNullarySymbol 351 352 * freeNullarySymbol.hh: created 353 354 * freeNullarySymbol.cc: created 355 356 * freeNet2Exec.hh (findRemainderListIndex): rearrange loads 357 (findRemainderListIndex): try unrolling 358 359 * freeSymbol.hh: added macros GET_NET, FREE_NET, DISC_NET 360 361 * freeNullaryFastExtorFinal.cc (execute): use FREE_NET/GET_NET 362 363 * freeNullaryFastExtor.cc (execute): use FREE_NET/GET_NET 364 365 * freeTernaryFastExtorFinal.cc (execute): use FREE_NET/GET_NET 366 367 * freeTernaryFastExtor.cc (execute): use FREE_NET/GET_NET 368 369 * freeBinaryFastExtorFinal.cc (execute): use FREE_NET/GET_NET 370 371 * freeBinaryFastExtor.cc (execute): use FREE_NET/GET_NET 372 373 * freeUnaryFastExtorFinal.cc (execute): use FREE_NET/GET_NET 374 375 * freeUnaryFastExtor.cc (execute): use FREE_NET/GET_NET 376 377 * freeTernarySymbol.cc (eqRewrite): use DISC_NET 378 379 * freeUnarySymbol.cc (eqRewrite): use DISC_NET 380 381 * freeSymbol.cc (memoStrategy): use DISC_NET (2 places) 382 383 * freeBinarySymbol.cc (eqRewrite): use DISC_NET 384 385 * freeSymbol.cc (makeDagNode): use DISC_NET macro 386 (complexStrategy): use DISC_NET (2 places) 387 388 * freeNet2Exec.cc (applyReplace2, applyReplaceNoOwise2): must set 389 stack[0] to top arg array 390 391 * freeNet2.cc (dump): added 392 3932013-10-09 Steven Eker <eker@ape.csl.sri.com> 394 395 * freeNet2Exec.cc (applyReplace2, applyReplaceFast2) 396 (applyReplaceNoOwise2): need to deal with the i == 0 failure case 397 398 * freePreNetSemiCompiler2.cc (semiCompile): clear slots and conflicts 399 400 * freeSymbol.cc (compileEquations): call new semiCompile() 401 402 * freeSymbol.hh (Symbol): added data member discriminationNet2 403 (getNet2): added 404 405 * freePreNet.hh (F): added decls for FreeNet2 versions of 406 semiCompile() and semiCompileNode(); commented out struct Node 407 since it doesn't seem to be used 408 409 * freeNet2.cc (allocateNode): added 410 (fillOutNode): added 411 (addRemainderList): added 412 (translateSlots): added 413 (buildRemainders): added 414 415 * freeNet2Exec.cc (applyReplace2): symmetric change 416 (applyReplaceNoOwise2): symmetric change 417 (applyReplaceFast2): symmetric change 418 419 * freeNet2Exec.hh (findRemainderListIndex): can't do relative 420 addressing for net node, since we may need to move backwards 421 4222013-10-08 Steven Eker <eker@ape.csl.sri.com> 423 424 * freeDagNode.hh (DagNode): FreeeNet2 becomes a friend 425 426 * freeNet2Exec.cc: created 427 428 * freeNet2.cc: created 429 430 * freeNet2Exec.hh: created 431 432 * freeTheory.hh: added class FreeNet2 433 434 * freeNet2.hh (F): created 435 4362013-10-03 Steven Eker <eker@ape.csl.sri.com> 437 438 * freeTerm.hh (Term): adde decl for computeMatchIndices 439 440 * freeTerm.cc (computeMatchIndices): added 441 4422013-10-02 Steven Eker <eker@ape.csl.sri.com> 443 444 * freeUnaryFastExtorFinal.cc (execute): rewrote ctor part; fix 445 minor bug that we were using an array of size 2 446 447 * freeTernaryFastExtorFinal.cc (execute): rewrote ctor part 448 449 * freeBinaryFastExtorFinal.cc (execute): rewrote ctor part 450 451 * freeUnaryFastExtor.cc (execute): rewrote ctor part 452 453 * freeTernaryFastExtor.cc (execute): rewrote ctor part 454 455 * freeBinaryFastExtor.cc (execute): rewrote ctor part 456 457 * freeNullaryCtorFinal.cc (execute): rewritten using new scheme 458 459 * freeNullaryCtor.cc (execute): rewritten using new scheme 460 461 * freeDagNode.hh (FreeDagNode): (nullary, unary and ternary 462 versions) fill out sort information 463 464 * freeUnaryCtor.cc (execute): rewritten using new scheme 465 466 * freeUnaryCtorFinal.cc (execute): rewritten using new scheme 467 468 * freeTernaryCtorFinal.cc (execute): rewritten using new scheme 469 470 * freeTernaryCtor.cc (execute): rewritten using new scheme 471 472 * freeBinaryCtor.cc (execute): clean up 473 474 * freeBinaryCtorFinal.cc (execute): clean up 475 476 * freeBinaryCtor.cc (execute): use new(NONE) to call reduced flag 477 setting version of new() 478 479 * freeBinaryCtorFinal.cc (execute): use new(NONE) to call reduced 480 flag setting version of new() 481 4822013-10-01 Steven Eker <eker@ape.csl.sri.com> 483 484 * freeDagNode.hh (FreeDagNode): try moving setReduced() to first 485 statement to see if flag optimization can be recovered 486 487 * freeBinaryCtor.cc (execute): try passing expressions rather than 488 using local variables 489 490 * freeBinaryCtorFinal.cc (execute): rely on FreeDagNode ctor to 491 set reduced flag 492 (execute): try passing expressions rather than using local 493 variables 494 495 * freeBinaryCtor.cc (execute): rely on FreeDagNode ctor to set 496 reduced flag 497 498 * freeDagNode.hh (FreeDagNode): (2 arg version) do sort 499 computation here 500 (FreeDagNode): (2 arg version) set reduced flag here 501 502 * freeBinaryCtor.cc (execute): rely on sort index being computed 503 in FreeDagNode ctor 504 505 * freeBinaryCtorFinal.cc (execute): try passing sort index through 506 FreeDagNode ctor 507 (execute): rely on sort index being computed in FreeDagNode ctor 508 5092013-09-26 Steven Eker <eker@ape.csl.sri.com> 510 511 * freeBinaryCtor.cc (execute): try passing sortIndex to FreeDagNode 512 513 * freeDagNode.hh (FreeDagNode): (2 arg version) take and pass sortIndex 514 515 * freeBinaryCtor.cc (execute): temporary hack avoiding the use of 516 saveResultAndContinue() because of worse register usage 517 5182013-09-25 Steven Eker <eker@ape.csl.sri.com> 519 520 * freeTernaryCtorFinal.cc (execute): rewritten using 521 returnResultAndContinue() 522 523 * freeNullaryCtorFinal.cc (execute): rewritten using 524 returnResultAndContinue() 525 526 * freeUnaryCtorFinal.cc (execute): rewritten using 527 returnResultAndContinue() 528 529 * freeBinaryCtorFinal.cc (execute): rewritten using 530 returnResultAndContinue() 531 5322013-09-24 Steven Eker <eker@ape.csl.sri.com> 533 534 * freeNullaryCtor.hh (NonFinalCtor): derive from NonFinalCtor; 535 deleted data member destIndex 536 537 * freeNullaryCtor.cc (FreeNullaryCtor): use new ctor convention 538 (execute): rewritten using saveResultAndContinue() 539 (dump): use getDestinationIndex() 540 541 * freeUnaryCtor.hh (NonFinalCtor): derive from NonFinalCtor; 542 deleted data member destIndex 543 544 * freeUnaryCtor.cc (FreeUnaryCtor): use new ctor convention 545 (execute): rewritten using saveResultAndContinue() 546 (dump): use getDestinationIndex() 547 548 * freeBinaryCtor.hh (NonFinalCtor): derive from NonFinalCtor; 549 deleted data member destIndex 550 551 * freeBinaryCtor.cc (FreeBinaryCtor): use new ctor convention 552 (execute): rewritten using saveResultAndContinue() 553 (dump): use getDestinationIndex() 554 555 * freeTernaryCtor.cc (FreeTernaryCtor): use new ctor convention 556 (dump): use getDestinationIndex() 557 (execute): rewritten using saveResultAndContinue() 558 559 * freeTernaryCtor.hh (NonFinalCtor): derive from NonFinalCtor 560 (NonFinalCtor): remove data member destIndex 561 562 * freeTheory.hh: remove all contig instruction classes 563 564===================================Maude98=========================================== 565 5662013-09-18 Steven Eker <eker@ape.csl.sri.com> 567 568 * freeBinaryFastExtor.cc (execute): fix oversized localArgList 569 5702013-09-13 Steven Eker <eker@ape.csl.sri.com> 571 572 * freeTernaryFastExtorFinal.hh: rewritten to use non-contig convention 573 574 * freeTernaryFastExtorFinal.cc: rewritten to use non-contig convention 575 576 * freeBinaryFastExtorFinal.cc: rewritten to use non-contig convention 577 578 * freeBinaryFastExtor.cc: rewritten to use non-contig convention 579 580 * freeBinaryFastExtor.hh: rewritten to use non-contig convention 581 582 * freeTernaryFastExtor.cc: rewritten to use non-contig convention 583 584 * freeTernaryFastExtor.hh: rewritten to use non-contig convention 585 586 * freeTernaryCtorFinal.hh: rewritten to use non-contig convention 587 588 * freeTernaryCtorFinal.cc: rewritten to use non-contig convention 589 590 * freeTernaryCtor.cc: rewritten to use non-contig convention 591 592 * freeTernaryCtor.hh: rewritten to use non-contig convention 593 594 * freeBinaryCtorFinal.cc: rewritten to use non-contig convention 595 596 * freeBinaryCtorFinal.hh: rewritten to use non-contig convention 597 598 * freeBinaryCtor.cc: rewritten to use non-contig convention 599 600 * freeBinaryCtor.hh: rewritten to use non-contig convention 601 602 * freeSymbol.cc (generateFinalInstruction): use new ctor 603 conventions 604 (generateInstruction): use new ctor conventions 605 606 * freeNet.hh: added friend declarations for classes 607 FreeBinaryFastExtorContig, FreeBinaryFastExtorContigFinal, 608 FreeTernaryFastExtorContig and FreeTernaryFastExtorContigFinal 609 610 * freeTheory.hh: added classes FreeBinaryFastExtorContig, 611 FreeBinaryFastExtorContigFinal, FreeTernaryFastExtorContig and 612 FreeTernaryFastExtorContigFinal 613 614 * freeTernaryFastExtorContigFinal.cc: created 615 616 * freeTernaryFastExtorContigFinal.hh: created 617 618 * freeTernaryFastExtorContig.cc: created 619 620 * freeTernaryFastExtorContig.hh: created 621 622 * freeBinaryFastExtorContigFinal.cc: created 623 624 * freeBinaryFastExtorContigFinal.hh: created 625 626 * freeBinaryFastExtorContig.cc: created 627 628 * freeBinaryFastExtorContig.hh: created 629 630 * freeTheory.hh: added classes FreeBinaryCtorContig, 631 FreeBinaryCtorContigFinal, FreeTernaryCtorContig, 632 FreeTernaryCtorContigFinal 633 634 * freeTernaryCtorContigFinal.cc: created 635 636 * freeTernaryCtorContigFinal.hh: cteaed 637 638 * freeTernaryCtorContig.cc: created 639 640 * freeTernaryCtorContig.hh: created 641 642 * freeBinaryCtorContigFinal.hh: created 643 644 * freeBinaryCtorContigFinal.cc: created 645 646 * freeBinaryCtorContig.cc: created 647 648 * freeBinaryCtorContig.hh: created 649 6502013-08-22 Steven Eker <eker@ape.csl.sri.com> 651 652 * freeNullaryCtorFinal.cc (execute): use finishUp() 653 654 * freeUnaryCtorFinal.cc (execute): use finishUp() 655 656 * freeTernaryCtorFinal.cc (execute): use finishUp() 657 658 * freeBinaryCtorFinal.cc (execute): use finishUp() 659 6602013-08-21 Steven Eker <eker@ape.csl.sri.com> 661 662 * freeNetExec.hh (findRemainderListIndex): try unrolling loop 663 6642013-08-20 Steven Eker <eker@ape.csl.sri.com> 665 666 * freeTernaryCtor.cc (execute): use handleNextInstruction() 667 668 * freeNullaryCtor.cc (execute): use handleNextInstruction() 669 670 * freeUnaryCtor.cc (execute): use handleNextInstruction() 671 672 * freeBinaryCtor.cc (execute): use handleNextInstruction() 673 674 * freeNullaryCtor.cc (execute): removed hack 675 6762013-08-16 Steven Eker <eker@ape.csl.sri.com> 677 678 * freeNullaryCtor.cc (execute): tried execute() hack 679 6802013-08-15 Steven Eker <eker@ape.csl.sri.com> 681 682 * freeNullaryFastExtor.cc (FreeNullaryFastExtor): pass destIndex to 683 NonFinalExtor 684 (execute, dump): use getDestinationIndex() 685 686 * freeTernaryFastExtor.cc (FreeTernaryFastExtor): pass destIndex to 687 NonFinalExtor 688 (execute, dump): use getDestinationIndex() 689 690 * freeUnaryFastExtor.cc (FreeUnaryFastExtor): pass destIndex to 691 NonFinalExtor 692 (execute, dump): use getDestinationIndex() 693 694 * freeBinaryFastExtor.cc (FreeBinaryFastExtor): pass destIndex to 695 NonFinalExtor 696 (execute, dump): use getDestinationIndex() 697 698 * freeNullaryFastExtor.hh (NonFinalExtor): deleted data member 699 destIndex 700 701 * freeTernaryFastExtor.hh (NonFinalExtor): deleted data member 702 destIndex 703 704 * freeUnaryFastExtor.hh (NonFinalExtor): deleted data member 705 destIndex 706 707 * freeBinaryFastExtor.hh (NonFinalExtor): deleted data member 708 destIndex 709 710 * freeNullaryFastExtor.cc (FreeNullaryFastExtor): pass 711 nextInstruction to NonFinalExtor 712 (execute): use pushFrame() rather than newFrame() 713 714 * freeUnaryFastExtor.cc (FreeUnaryFastExtor): pass 715 nextInstruction to NonFinalExtor 716 (execute): use pushFrame() rather than newFrame() 717 718 * freeTernaryFastExtor.cc (FreeTernaryFastExtor): pass 719 nextInstruction to NonFinalExtor 720 (execute): use pushFrame() rather than newFrame() 721 722 * freeTernaryFastExtor.hh (NonFinalExtor): derive from Nonfinal 723 Extor 724 725 * freeNullaryFastExtor.hh (NonFinalExtor): derive from Nonfinal 726 Extor 727 728 * freeUnaryFastExtor.hh (NonFinalExtor): derive from Nonfinal 729 Extor 730 731 * freeBinaryFastExtor.cc (FreeBinaryFastExtor): pass 732 nextInstruction to NonFinalExtor 733 (execute): use pushFrame() rather than newFrame() 734 735 * freeBinaryFastExtor.hh (NonFinalExtor): derive from Nonfinal 736 Extor 737 7382013-08-14 Steven Eker <eker@ape.csl.sri.com> 739 740 * freeUnaryFastExtorFinal.cc (execute): fix symmetric bug 741 742 * freeTernaryFastExtorFinal.cc (execute): fix bug where we passing 743 old arg list rather than copy 744 745 * freeNullaryFastExtorFinal.cc (execute): symmetric changes 746 747 * freeTernaryFastExtorFinal.cc (execute): symmetric changes 748 749 * freeUnaryFastExtorFinal.cc (execute): symmetric changes 750 751 * freeBinaryFastExtorFinal.cc (execute): implement local argument 752 list copy and stack frame reuse 753 754 * freeTernaryFastExtorFinal.hh (FinalInstruction): derive from 755 FinalInstruction; deleted nextInstruction data member; use 756 SlotIndex type 757 758 * freeNullaryFastExtorFinal.hh (FinalInstruction): derive from 759 FinalInstruction 760 761 * freeUnaryFastExtorFinal.hh (FinalInstruction): derive from 762 FinalInstruction; deleted nextInstruction data member; use 763 SlotIndex type 764 765 * freeBinaryFastExtorFinal.hh (FinalInstruction): derive from 766 FinalInstruction; deleted nextInstruction data member; use 767 SlotIndex type 768 769 * freeTernaryFastExtor.cc (FreeTernaryFastExtor): pass 770 nextInstruction to base class ctor 771 (execute): use getNextInstruction(); use SlotIndex type 772 (dump): use getNextInstruction() 773 774 * freeUnaryFastExtor.cc (FreeUnaryFastExtor): pass 775 nextInstruction to base class ctor 776 (execute): use getNextInstruction(); use SlotIndex type 777 (dump): use getNextInstruction() 778 779 * freeNullaryFastExtor.cc (FreeNullaryFastExtor): pass 780 nextInstruction to base class ctor 781 (execute): use getNextInstruction() 782 (dump): use getNextInstruction() 783 784 * freeNullaryFastExtor.hh (NonFinalInstruction): derive from 785 NonFinalInstruction; deleted nextInstruction data member 786 787 * freeTernaryFastExtor.hh (NonFinalInstruction): derive from 788 NonFinalInstruction; deleted nextInstruction data member; use 789 SlotIndex type 790 791 * freeUnaryFastExtor.hh (NonFinalInstruction): derive from 792 NonFinalInstruction; deleted nextInstruction data member; use 793 SlotIndex type 794 795 * freeBinaryFastExtor.cc (execute): use getNextInstruction(); use 796 SlotIndex type 797 (FreeBinaryFastExtor): pass nextInstruction to base class ctor 798 (dump): use getNextInstruction() 799 800 * freeBinaryFastExtor.hh (NonFinalInstruction): derive from 801 NonFinalInstruction; deleted nextInstruction data member; use 802 SlotIndex type 803 804 * freeTernaryCtorFinal.hh (FinalInstruction): derive from 805 FinalInstruction; use SlotIndex type 806 807 * freeNullaryCtorFinal.hh (FinalInstruction): derive from 808 FinalInstruction 809 810 * freeUnaryCtorFinal.hh (FinalInstruction): derive from 811 FinalInstruction; use SlotIndex type 812 813 * freeBinaryCtorFinal.hh (FinalInstruction): derive from 814 FinalInstruction; use SlotIndex type 815 816 * freeNullaryCtor.cc (FreeNullaryCtor): pass nextInstruction to 817 base class ctor 818 (execute): use getNextInstruction(); use SlotIndex type 819 820 * freeUnaryCtor.cc (FreeUnaryCtor): pass nextInstruction to base 821 class ctor 822 (execute): use getNextInstruction(); use SlotIndex type 823 824 * freeTernaryCtor.cc (FreeTernaryCtor): pass nextInstruction to 825 base class ctor 826 (execute): use getNextInstruction(); use SlotIndex type 827 (dump): use getNextInstruction() 828 829 * freeTernaryCtor.hh (NonFinalInstruction): derive from 830 NonFinalInstruction; deleted nextInstruction data member; use 831 SlotIndex type 832 833 * freeNullaryCtor.hh (NonFinalInstruction): derive from 834 NonFinalInstruction; deleted nextInstruction data member; use 835 SlotIndex type 836 837 * freeUnaryCtor.hh (NonFinalInstruction): derive from 838 NonFinalInstruction; deleted nextInstruction data member; use 839 SlotIndex type 840 8412013-08-13 Steven Eker <eker@ape.csl.sri.com> 842 843 * freeBinaryCtor.cc (execute): use SlotIndex type 844 845 * freeBinaryCtor.hh (NonFinalInstruction): use SlotIndex type 846 847 * freeBinaryCtor.cc (execute): use getNextInstruction() 848 (FreeBinaryCtor): pass nextInstruction to base class ctor 849 (dump): use getNextInstruction() 850 851 * freeBinaryCtor.hh (NonFinalInstruction): derive from 852 NonFinalInstruction; deleted nextInstruction data member 853 8542013-08-09 Steven Eker <eker@ape.csl.sri.com> 855 856 * freeBinaryFastExtorFinal.cc (execute): use newUnderFrame() 857 8582013-08-01 Steven Eker <eker@ape.csl.sri.com> 859 860 * freeTernaryFastExtorFinal.cc (execute): use newUnderFrame()p 861 8622013-07-30 Steven Eker <eker@ape.csl.sri.com> 863 864 * freeRemainder.hh (FreeLhsStructs): commented out 865 firstInstruction data member for the moment 866 (getFirstInstruction): use getInstructionSequence() for the moment 867 868 * freeNullaryCtorFinal.cc (dump): fix 869 870 * freeNullaryCtor.cc (dump): fix 871 872 * freeTernaryFastExtorFinal.cc (dump): fix 873 874 * freeTernaryFastExtor.cc (dump): fix 875 876 * freeTernaryCtorFinal.cc (dump): fix 877 878 * freeTernaryCtor.cc (dump): fix 879 880 * freeBinaryFastExtorFinal.cc (dump): fix 881 882 * freeBinaryFastExtor.cc (dump): fix 883 884 * freeBinaryCtorFinal.cc (dump): fix 885 886 * freeBinaryCtor.cc (dump): fix 887 888 * freeUnaryFastExtorFinal.cc (dump): fix 889 890 * freeUnaryFastExtor.cc (dump): fix 891 892 * freeUnaryCtor.cc (dump): fix 893 894 * freeUnaryCtorFinal.cc (dump): fix 895 896 * freeSymbol.cc (generateInstruction): use 897 FreeNullaryCtor/FreeNullaryExtor intructions 898 8992013-07-12 Steven Eker <eker@ape.csl.sri.com> 900 901 * freeTheory.hh: added classes FreeNullaryCtor, 902 FreeNullaryCtorFinal, FreeNullaryFastExtor, 903 FreeNullaryFastExtorFinal 904 905 * freeNullaryFastExtorFinal.cc: created 906 907 * freeNullaryFastExtorFinal.hh: created 908 909 * freeNet.hh (F): added classes FreeNullaryFastExtor and 910 FreeNullaryFastExtorFinal as friends 911 912 * freeNullaryFastExtor.cc: created 913 914 * freeNullaryCtorFinal.cc: created 915 916 * freeNullaryCtorFinal.hh: created 917 918 * freeNullaryFastExtor.hh: created 919 920 * freeDagNode.hh (FreeDagNode): added 0 argument version with 921 dummy int argument to distinguish it from general case. 922 923 * freeNullaryCtor.hh: created 924 925 * freeNullaryCtor.cc: created 926 927 * freeNet.hh (F): made classes FreeUnaryFastExtor, 928 FreeUnaryFastExtorFinal, FreeTernaryFastExtor, 929 FreeTernaryFastExtorFinal friends 930 931 * freeTheory.hh: added classes FreeUnaryCtor, FreeUnaryCtorFinal, 932 FreeUnaryFastExtor, FreeUnaryFastExtorFinal, FreeTernaryCtor, 933 FreeTernaryCtorFinal, FreeTernaryFastExtor, 934 FreeTernaryFastExtorFinal 935 936 * freeTernaryFastExtorFinal.cc: created 937 938 * freeTernaryFastExtorFinal.hh: created 939 940 * freeTernaryFastExtor.cc: created 941 942 * freeTernaryFastExtor.hh: created 943 944 * freeTernaryCtorFinal.hh: created 945 946 * freeTernaryCtorFinal.cc: created 947 948 * freeTernaryCtor.cc: created 949 950 * freeTernaryCtor.hh: created 951 9522013-07-11 Steven Eker <eker@ape.csl.sri.com> 953 954 * freeUnaryFastExtorFinal.cc: created 955 956 * freeUnaryFastExtorFinal.hh: created 957 958 * freeDagNode.hh (FreeDagNode): added 1 and 3 argument versions 959 960 * freeUnaryFastExtor.cc: created 961 962 * freeUnaryFastExtor.hh: created 963 964 * freeUnaryCtorFinal.hh: created 965 966 * freeUnaryCtorFinal.cc: created 967 968 * freeUnaryCtor.hh: created 969 970 * freeUnaryCtor.cc: created 971 972 * freeBinaryFastExtorFinal.cc (execute): use getNet() 973 974 * freeBinaryFastExtorFinal.hh (Instruction): added decl for ctor; 975 deleted data member net; made data const 976 977 * freeBinaryFastExtorFinal.cc (FreeBinaryFastExtorFinal): added 978 979 * freeBinaryCtorFinal.hh (Instruction): added decl for ctor; made 980 data const 981 982 * freeBinaryCtorFinal.cc (FreeBinaryCtorFinal): added 983 984 * freeBinaryFastExtor.hh (Instruction): added decl for ctor; made 985 data const 986 987 * freeBinaryFastExtor.cc (FreeBinaryFastExtor): added 988 989 * freeBinaryFastExtor.hh (Instruction): deleted data member net 990 991 * freeBinaryFastExtor.cc (execute): use getNet() 992 993 * freeSymbol.hh (getNet): added 994 995 * freeBinaryCtor.hh (Instruction): added decl for ctor; made data 996 const to allow compiler optimization possibilities 997 998 * freeBinaryCtor.cc (FreeBinaryCtor): added 999 1000 * freeSymbol.hh (Symbol): added decls for 1001 generateFinalInstruction() and generateInstruction() 1002 1003 * freeSymbol.cc (generateFinalInstruction): added 1004 (generateInstruction): added 1005 10062013-07-10 Steven Eker <eker@ape.csl.sri.com> 1007 1008 * freeBinaryFastExtorFinal.cc (dump): added 1009 1010 * freeBinaryFastExtor.cc (dump): added 1011 1012 * freeBinaryCtorFinal.cc (dump): added 1013 1014 * freeBinaryCtor.cc (dump): added 1015 1016 * freeBinaryFastExtorFinal.hh (Instruction): added decl for dump() 1017 1018 * freeBinaryFastExtor.hh (Instruction): added decl for dump() 1019 1020 * freeBinaryCtorFinal.hh (Instruction): added decl for dump() 1021 1022 * freeBinaryCtor.hh (Instruction): added decl for dump() 1023 10242013-06-28 Steven Eker <eker@ape.csl.sri.com> 1025 1026 * freeRhsAutomaton.hh (RhsAutomaton): added decl for recordInfo() 1027 1028 * freeRhsAutomaton.cc (recordInfo): added 1029 10302013-06-07 Steven Eker <eker@ape.csl.sri.com> 1031 1032 * freeNet.hh (F): made class FreeBinaryFastExtorFinal a friend 1033 1034 * freeTheory.hh: added class FreeBinaryFastExtorFinal 1035 1036 * freeBinaryFastExtorFinal.hh: created 1037 1038 * freeBinaryFastExtorFinal.cc: created 1039 10402013-05-11 Steven Eker <eker@ape.csl.sri.com> 1041 1042 * freeNet.hh (F): quick hack to check for position and slot in 1043 TestNode overflowing the 16-bit ints 1044 1045===================================Maude97=========================================== 1046 10472013-03-07 Steven Eker <eker@ape.csl.sri.com> 1048 1049 * freeSymbol.cc (compileEquations): call resetSlotIndices(), and 1050 then call setSlotIndex() to avoid using bad slot indices if the 1051 lhs gets compiled for variant equation reducibility purposes 1052 1053 * freeTerm.hh (Term): added decl for resetSlotIndices() 1054 1055 * freeTerm.cc (resetSlotIndices): added 1056 1057 * freePreNet.hh (F): added call to NO_COPYING() macro 1058 10592013-01-18 Steven Eker <eker@ape.csl.sri.com> 1060 1061 * freeRemainder.hh (fastCheckAndBind, getFirstInstruction): added 1062 (FreeLhsStructs): added data member firstInstruction 1063 1064 * freeNet.hh (F): added decl for findRemainderListIndex() 1065 1066 * freeNetExec.hh: created 1067 1068 * freeBinaryCtor.cc (execute): code cleaning 1069 1070 * freeBinaryCtor.hh (Instruction): FreeBinarySymbol* becomes 1071 FreeSymbol 1072 1073 * freeBinaryCtorFinal.cc (execute): code cleaning 1074 1075 * freeBinaryCtorFinal.hh (Instruction): FreeBinarySymbol* becomes 1076 FreeSymbol since we will eventually obsolete these subclasses 1077 10782013-01-09 Steven Eker <eker@ape.csl.sri.com> 1079 1080 * freeBinaryCtorFinal.cc: created 1081 1082 * freeBinaryCtorFinal.hh: created 1083 1084 * freeTheory.hh: added forward decl for freeBinaryCtorFinal 1085 10862013-01-08 Steven Eker <eker@ape.csl.sri.com> 1087 1088 * freeBinaryCtor.cc (execute): use traverse() instead of sortTable 1089 1090 * freeBinaryCtor.hh (Instruction): deleted data member sortTable 1091 10922013-01-07 Steven Eker <eker@ape.csl.sri.com> 1093 1094 * freeDagNode.hh (FreeDagNode): added binary ctor 1095 1096 * freeBinaryCtor.cc: created 1097 1098 * freeBinaryCtor.hh: created 1099 1100===================================Maude96c=========================================== 1101 11022012-04-13 Steven Eker <eker@ape.csl.sri.com> 1103 1104 * freeDagNode.hh (DagNode): updated decl for 1105 instantiateWithReplacement(); added decl for instantiateWithCopies2() 1106 1107 * freeDagNode.cc (instantiateWithCopies2): added 1108 (instantiateWithReplacement): rewritten to handle eager positions correctly 1109 11102012-03-30 Steven Eker <eker@ape.csl.sri.com> 1111 1112 * freeSymbol.cc (termify): code cleaning 1113 11142012-03-29 Steven Eker <eker@ape.csl.sri.com> 1115 1116 * freeSymbol.hh (Symbol): added decl for termify() 1117 1118 * freeSymbol.cc (termify): added 1119 1120===================================Maude96=========================================== 1121 11222010-10-19 Steven Eker <eker@rho> 1123 1124 * freeSymbol.hh (class FreeSymbol): 1125 makeCanonicalCopyEagerUptoReduced() -> makeCanonicalCopy() 1126 1127 * freeSymbol.cc (FreeSymbol::makeCanonicalCopyEagerUptoReduced): 1128 becomes makeCanonicalCopy(); semantics change 1129 1130===================================Maude95a=========================================== 1131 11322010-09-29 Steven Eker <eker@rho> 1133 1134 * freeSymbol.cc (FreeSymbol::makeCanonicalCopyEagerUptoReduced): 1135 code cleaning 1136 (FreeSymbol::makeCanonicalCopyEagerUptoReduced): simplified now 1137 that we are only passed unreduced originals; use 1138 getCanonicalCopyEagerUptoReduced() 1139 11402010-09-28 Steven Eker <eker@rho> 1141 1142 * freeSymbol.hh (class FreeSymbol): added decl for makeCanonicalCopyEagerUptoReduced() 1143 1144 * freeSymbol.cc (FreeSymbol::makeCanonicalCopyEagerUptoReduced): added 1145 11462010-08-18 Steven Eker <eker@rho> 1147 1148 * freeDagNode.hh (class FreeDagNode): deleted decl for 1149 1150 * freeDagNode.cc (FreeDagNode::nonVariableSize): deleted 1151 1152===================================Maude95=========================================== 1153 11542010-08-12 Steven Eker <eker@rho> 1155 1156 * freeDagNode.hh (class FreeDagNode): updated decl for 1157 purifyAndOccurCheck() 1158 1159 * freeDagNode.cc (FreeDagNode::purifyAndOccurCheck): take pending 1160 argument; use computeSolvedForm() rather than bind() to avoid 1161 binding the abstraction variable to an impure term that might 1162 cause nontermination 1163 (FreeDagNode::computeSolvedForm2): pass pending to 1164 purifyAndOccurCheck() 1165 11662010-08-11 Steven Eker <eker@rho> 1167 1168 * freeDagNode.cc (FreeDagNode::computeSolvedForm2): call 1169 computeSolvedForm() rather than computeSolvedForm2() since we may 1170 get constant vs constant by looking at variables binding 1171 11722010-08-10 Steven Eker <eker@rho> 1173 1174 * freeDagNode.cc (FreeDagNode::computeSolvedForm2): code cleaning 1175 11762010-08-03 Steven Eker <eker@rho> 1177 1178 * freeDagNode.hh (class FreeDagNode): added enum 1179 PurificationStatus; added decl for purifyAndOccurCheck() 1180 1181 * freeDagNode.cc (FreeDagNode::purifyAndOccurCheck): added 1182 (FreeDagNode::computeSolvedForm2): rewritten using 1183 purifyAndOccurCheck() 1184 1185===================================Maude94a=========================================== 1186 11872010-06-30 Steven Eker <eker@rho> 1188 1189 * freeDagNode.cc (FreeDagNode::computeSolvedForm2): use 1190 resolveTheoryClash() 1191 11922010-06-04 Steven Eker <eker@rho> 1193 1194 * freeSymbol.cc (FreeSymbol::isStable): added 1195 1196 * freeSymbol.hh (class FreeSymbol): added decl for isStable() 1197 1198===================================Maude94=========================================== 1199 12002010-04-16 Steven Eker <eker@rho> 1201 1202 * freeLhsCompiler.cc 1203 (FreeTerm::findConstraintPropagationSequence): remove const (both 1204 versions) 1205 1206 * freeTerm.hh (class FreeTerm): make both versions of 1207 findConstraintPropagationSequence() static 1208 1209 * freeLhsCompiler.cc 1210 (FreeTerm::findConstraintPropagationSequence): rewritten to save 1211 results of first pass, and avoid searching once we detect we can 1212 propagate any more bound uniquely variables 1213 12142010-04-15 Steven Eker <eker@rho> 1215 1216 * freeTerm.hh (class FreeTerm): added decl for 1217 remainingAliensContain() 1218 1219 * freeLhsCompiler.cc 1220 (FreeTerm::findConstraintPropagationSequence): rewritten to reduce 1221 likelihood of exponential blow up 1222 (FreeTerm::remainingAliensContain): added 1223 (FreeTerm::findConstraintPropagationSequence): simplified using 1224 remainingAliensContain() 1225 1226===================================Maude93a=========================================== 1227 12282010-03-18 Steven Eker <eker@rho> 1229 1230 * freeRemainder.cc (FreeRemainder::FreeRemainder): don't set 1231 nrFreeVariables 1232 1233 * freeRemainder.hh (FreeRemainder::fastMatchReplace): retrench to 1234 original version 1235 (FreeRemainder::fastMatchReplace): code cleaning 1236 (class FreeRemainder): delete data member nrFreeVariables 1237 1238 * freeRemainder.cc (FreeRemainder::slowMatchReplace2): code cleaning 1239 12402010-03-12 Steven Eker <eker@rho> 1241 1242 * freeTerm.cc (FreeTerm::compileRhs3): clean up code 1243 12442010-03-11 Steven Eker <eker@rho> 1245 1246 * freeRhsAutomaton.cc (FreeRhsAutomaton::fillOutArgs): tried 1247 turning loop into a count down to 0 loop 1248 (FreeRhsAutomaton::construct, FreeRhsAutomaton::replace): use 1249 count down to 0 loops; eliminate temporary 1250 (FreeRhsAutomaton::construct, FreeRhsAutomaton::replace): code cleaning 1251 12522010-03-10 Steven Eker <eker@rho> 1253 1254 * freeRemainder.hh (FreeRemainder::fastMatchReplace): rewritten 1255 after looking at asm output 1256 1257 * freeRemainder.cc (FreeRemainder::FreeRemainder): don't store 1258 nrFreeVariables until we have processed pseudo variables which 1259 might change the value 1260 1261 * freeNet.cc (FreeNet::buildRemainders): fix critical bug where we 1262 were resize rems twice 1263 1264 * freeRemainder.cc (FreeRemainder::FreeRemainder): init foreign, 1265 nrFreeVariables, equation 1266 1267 * freeRemainder.hh (class FreeRemainder): added data member 1268 nrFreeVariables; made foreign const 1269 1270 * freeLhsStructs.hh (class FreeLhsStructs): made position and 1271 argIndex short in all structs 1272 1273===================================Maude93=========================================== 1274 12752010-03-05 Steven Eker <eker@rho> 1276 1277 * freeNet.cc (FreeNet::buildRemainders): try not zero terminating 1278 1279 * freeTerm.cc (FreeTerm::compareArguments): (DagNode* version) use 1280 iterator to access Term args 1281 (FreeTerm::compareArguments): fix bug in optimized version 1282 (FreeTerm::compareArguments): try early loop termination 1283 optimization 1284 (FreeTerm::compareArguments): revert early loop termination 1285 (FreeTerm::compareArguments): try getting nrArgs from 1286 other->symbol() 1287 (FreeTerm::compareArguments): do early loop termination properly 1288 this time 1289 (FreeTerm::compareArguments): use nrArgs to count down - saves a 1290 register copy 1291 1292 * freeDagNode.cc (FreeDagNode::compareArguments): load symbol 1293 into temporary; check symbols for equality before doing a symbol 1294 comparison 1295 12962010-03-04 Steven Eker <eker@rho> 1297 1298 * freeDagNode.cc (FreeDagNode::compareArguments): rewrite using 1299 tail recursion 1300 (FreeDagNode::compareArguments): fix bug where we were comparing 1301 the wrong nodes for equality (they were never equal so we failed 1302 safe) 1303 (FreeDagNode::compareArguments): fix bug where we were checking 1304 the symbols of the wrong nodes 1305 1306 * freeRhsAutomaton.cc (FreeRhsAutomaton::fillOutArgs): delete 1307 nrArgs arg 1308 (FreeRhsAutomaton::replace): simplify 1309 (FreeRhsAutomaton::construct): simplify 1310 13112010-03-02 Steven Eker <eker@rho> 1312 1313 * freeNetExec.cc (FreeNet::applyReplaceNoOwise2): fix bug where we 1314 were checking p for equality rather than < 0 as it should be 1315 de-pointerized code; make i long; load n->slot into long before 1316 testing to get free sign extension 1317 (FreeNet::applyReplace2): make i long; load n->slot into long 1318 before testing to get free sign extension 1319 13202010-02-26 Steven Eker <eker@rho> 1321 1322 * freeNet.cc (FreeNet::addRemainderList): remove "too cute" 1323 calculation of 1's complement in favor of explicit code since is 1324 non-time critical 1325 13262010-02-10 Steven Eker <eker@goo.csl.sri.com> 1327 1328 * freeNetExec.cc (applyReplace2, applyReplaceFast2) 1329 (applyReplaceNoOwise2): made p long to avoid extension on 64 bit 1330 machines 1331 (applyReplace2): use ~i 1332 (applyReplaceNoOwise2): use ~i 1333 (applyReplaceFast2): use ~i 1334 (applyReplace2, applyReplaceFast2, applyReplaceNoOwise2): pull 1335 common i = ~i to end of loop - compiler already does this 1336 opimization but it makes the code eaiser to read 1337 1338 * freeNet.hh (class FreeNet): reorganized struct TestNode to avoid 1339 32bit->64bit extension for position on 64bit machines, and to put 1340 field in likely order of use for cache friendliness 1341 13422010-02-09 Steven Eker <eker@goo.csl.sri.com> 1343 1344 * freeNet.hh (class FreeNet): rework TestNode to avoid pointers 1345 into stack data structure 1346 1347 * freeNetExec.cc (applyReplaceNoOwise2): fix missing symbolIndex 1348 update bug 1349 (applyReplace2, applyReplaceFast2, applyReplaceNoOwise2): 1350 depointerize stack acccess and use stackBase instead 1351 1352 * freeNet.cc (translateSlots): removed pointerization 1353 1354 * freeNet.hh (class FreeNet): fix longstanding TestNode 1355 optimization bug on 64-bit machines 1356 1357 * freeNetExec.cc (applyReplaceFast2, applyReplace2) 1358 (applyReplaceNoOwise2): use diff < 0 rather than getSignBit(diff) 1359 to let g++ do the logical shift trick 1360 13612010-01-28 Steven Eker <eker@goo.csl.sri.com> 1362 1363 * freeTernarySymbol.hh (class FreeTernarySymbol): added 1364 NO_COPYING() in the hope of cutting down the amount of ctor code 1365 gcc generates in the assembler file 1366 13672010-01-22 Steven Eker <eker@goo.csl.sri.com> 1368 1369 * freeTernarySymbol.cc (eqRewrite): use applyReplaceFast() 1370 1371 * freeBinarySymbol.cc (eqRewrite): use applyReplaceFast() 1372 1373 * freeUnarySymbol.cc (eqRewrite): use applyReplaceFast() 1374 1375 * freeNet.hh (applyReplaceFast): added 1376 (class FreeNet): added decls for applyReplaceFast(), 1377 applyReplaceFast2() 1378 1379 * freeNetExec.cc (applyReplaceFast2): added 1380 13812010-01-07 Steven Eker <eker@goo.csl.sri.com> 1382 1383 * freeNetExec.cc: rewritten using symbolIndex optimization 1384 1385 * freeNet.cc: rewritten to store symbolIndex rather than symbol 1386 within TestNodes; added comments 1387 1388 * freeNet.hh (class FreeNet): replaced symbol field with 1389 symbolIndex field in struct TestNode 1390 1391===================================Maude92c=========================================== 1392 13932009-12-01 Steven Eker <eker@goo.csl.sri.com> 1394 1395 * freeTerm.cc (normalize): revert hash function 1396 1397 * freeDagNode.cc (getHashValue): revert hash function 1398 13992009-11-30 Steven Eker <eker@goo.csl.sri.com> 1400 1401 * freeTerm.cc (normalize): modify hash function 1402 1403 * freeDagNode.cc (getHashValue): modify hash function 1404 14052009-11-24 Steven Eker <eker@goo.csl.sri.com> 1406 1407 * freeSymbol.cc (makeCanonical): added 1408 1409 * freeSymbol.hh (class FreeSymbol): added decl for makeCanonical() 1410 1411===================================Maude92b=========================================== 1412 14132009-11-06 Steven Eker <eker@goo.csl.sri.com> 1414 1415 * freeTerm.hh (class FreeTerm): made both 1416 findConstraintPropagationSequence() const 1417 1418 * freeLhsCompiler.cc (findConstraintPropagationSequence): made 1419 const (both versions) 1420 1421 * freeTerm.hh (class FreeTerm): deleted decl for 1422 insertGroundOutAliens(); made both 1423 findConstraintPropagationSequence() decls non-static 1424 (class FreeTerm): currentSequence no longer const in 1425 findConstraintPropagationSequence() decl 1426 1427 * freeLhsCompiler.cc (analyseConstraintPropagation): code cleaning 1428 (compileRemainder): code cleaning 1429 (findConstraintPropagationSequence): (top level version) don't 1430 call insertGroundOutAliens() 1431 (findConstraintPropagationSequence): (lower level version) 1432 rewritten to do insertGroundOutAliens() stuff internally; avoid 1433 making copies of currentSequence where possible 1434 (insertGroundOutAliens): deleted 1435 (scanFreeSkeleton): code cleaing 1436 14372009-11-04 Steven Eker <eker@goo.csl.sri.com> 1438 1439 * freeLhsCompiler.cc (findConstraintPropagationSequence): added 1440 early terminate once we find a branch that binds uniquely all 1441 variables occuring below us. 1442 14432009-11-02 Steven Eker <eker@goo.csl.sri.com> 1444 1445 * freeLhsCompiler.cc (analyseConstraintPropagation): added 1446 DebugAdvisory() to investigate performance problem 1447 14482009-09-23 Steven Eker <eker@goo.csl.sri.com> 1449 1450 * freeSymbol.cc (computeGeneralizedSort): fix nasty bug that we 1451 were getting the sort function until after we've generated the 1452 argMap we want to compose it with - but the generation of the sort 1453 function may increase the number of bdd variables, and we need 1454 those to make the argMap 1455 1456===================================Maude92a=========================================== 1457 14582008-12-22 Steven Eker <eker@goo.csl.sri.com> 1459 1460 * freeSymbol.cc (computeGeneralizedSort): new getSortFunction() 1461 convention 1462 1463===================================Maude92=========================================== 1464 14652008-09-11 Steven Eker <eker@goo.csl.sri.com> 1466 1467 * freeDagNode.cc (computeBaseSortForGroundSubterms): added default 1468 case to avoid compiler warning 1469 1470 * freePreNet.cc (buildNet): fix bug where we were not updating 1471 potentialSubsumers 1472 1473 * freePreNetSubsumption.cc (subsumesWrtReducedFringe): pull 1474 assignment out of if statement of avoid compiler warning about 1475 unused variable 1476 1477===================================Maude91a=========================================== 1478 14792008-03-23 Steven Eker <eker@goo.csl.sri.com> 1480 1481 * freeDagNode.hh (class FreeDagNode): removed commented out 1482 declaration for old version of computeSolvedForm2() 1483 1484 * freePreNetFullCompiler.cc (allocateVariables, slotMapUnion) 1485 (generateNode): use NetMap 1486 (generateCode): use net.empty() 1487 1488 * freePreNetSemiCompiler.cc (semiCompile, semiCompileNode): use NetMap 1489 1490 * freePreNet.cc (dump): updated 1491 1492 * freePreNet.hh (class FreePreNet): updated decl for 1493 findBestPosition(); added data member netVec 1494 1495 * freePreNet.cc (findBestPosition): updated 1496 (makeNode): use NodeMap 1497 1498 * freePreNet.hh (operator<): added 1499 (class FreePreNet): added structs NodeIndex and NodeBody; added 1500 typedef NodeMap 1501 15022008-03-21 Steven Eker <eker@goo.csl.sri.com> 1503 1504 * freePreNet.cc (makeNode): make use of sets return by 1505 partitionLiveSet() to speed up generation of new live sets 1506 (buildNet): added potentialSubsumers optimization 1507 1508 * freePreNet.hh (class FreePreNet): findLiveSets() -> 1509 partitionLiveSet() 1510 1511 * freePreNet.cc (partitionLiveSet): converted from findLiveSets() 1512 1513 * freePreNetSubsumption.cc (subsumesWrtReducedFringe): added 1514 comments to both versions 1515 15162008-03-19 Steven Eker <eker@goo.csl.sri.com> 1517 1518 * freePreNet.cc (findLiveSets): added 1519 15202008-03-14 Steven Eker <eker@goo.csl.sri.com> 1521 1522 * freeNet.cc (addRemainderList, buildRemainders): update with new 1523 PatternSet data structure 1524 (dump): update with new PatternSet data structure 1525 1526 * freeNet.hh (class FreeNet): added typedef PatternSet; updated 1527 decls 1528 1529 * freePreNet.hh (class FreePreNet): pattternsUsed becomes a 1530 LiveSet 1531 1532 * freePreNetSemiCompiler.cc (semiCompileNode, setVisitedFlags) 1533 (allocateSlot): update with new LiveSet data structure 1534 1535 * freePreNet.cc (buildNet, makeNode, reduceFringe, findLiveSet) 1536 (partiallySubsumed, findBestPosition): update with new LiveSet 1537 data structure 1538 (dumpLiveSet): added 1539 1540 * freePreNet.hh (class FreePreNet): addeded typedef LiveSet; 1541 updated other decls 1542 15432008-03-12 Steven Eker <eker@goo.csl.sri.com> 1544 1545 * freeTerm.cc (compileRhs3): compile subterms in the order largest first 1546 1547===================================Maude90a=========================================== 1548 15492008-02-08 Steven Eker <eker@goo.csl.sri.com> 1550 1551 * freeDagNode.cc (computeSolvedForm2): Substitution -> 1552 UnificationContext 1553 1554 * freeDagNode.hh (class FreeDagNode): updated decl for 1555 computeSolvedForm2() 1556 15572008-02-05 Steven Eker <eker@goo.csl.sri.com> 1558 1559 * freeDagNode.cc (computeSolvedForm2): rewritten 1560 1561 * freeDagNode.hh (class FreeDagNode): updated decl for computeSolvedForm2() 1562 15632008-01-14 Steven Eker <eker@goo.csl.sri.com> 1564 1565 * freeDagNode.cc (instantiateWithReplacement): code cleaning 1566 1567===================================Maude90=========================================== 1568 15692007-11-01 Steven Eker <eker@goo.csl.sri.com> 1570 1571 * freeDagNode.cc (instantiateWithReplacement): handle the case 1572 where instantiate() return 0 because dag is unchanged under 1573 substitution 1574 1575 * freeTerm.cc (findAvailableTerms, compileRhsAliens, compileRhs3): 1576 cast cleaning 1577 1578 * freeDagNode.cc (instantiate2, instantiateWithReplacement): 1579 updated 1580 1581 * freeDagNode.hh (class FreeDagNode): updated decls for 1582 instantiate2() and instantiateWithReplacement() 1583 15842007-10-26 Steven Eker <eker@goo.csl.sri.com> 1585 1586 * freeDagNode.cc (copyEagerUptoReduced2, copyWithReplacement) 1587 (instantiateWithReplacement): remove casts to FreeSymbol* 1588 1589 * freeDagNode.hh (symbol): added 1590 1591 * freeDagNode.cc (computeBaseSortForGroundSubterms): call 1592 setGround() on ground terms 1593 (instantiate2): removed temporary hack to handle ground terms 1594 1595 * freeDagNode.hh (class FreeDagNode): decl for indexVariables() 1596 becomes indexVariables2() 1597 1598 * freeDagNode.cc (indexVariables): handle testing and setting of 1599 ground flags 1600 (indexVariables): becomes indexVariables2(); return bool 1601 16022007-10-25 Steven Eker <eker@goo.csl.sri.com> 1603 1604 * freeDagNode.cc (instantiateWithReplacement): added 1605 (instantiate2): temporary hack to allow it to work on constants 1606 (instantiate2): use isGround()/setGround() 1607 1608 * freeDagNode.hh (class FreeDagNode): added decl for 1609 instantiateWithReplacement() 1610 16112007-10-15 Steven Eker <eker@goo.csl.sri.com> 1612 1613 * freeDagNode.hh (class FreeDagNode): adde decl for 1614 indexVariables() 1615 (class FreeDagNode): added decl for indexVariables() 1616 1617 * freeDagNode.cc (indexVariables): added 1618 1619===================================Maude89h=========================================== 1620 16212007-08-24 Steven Eker <eker@goo.csl.sri.com> 1622 1623 * freeDagNode.cc (computeBaseSortForGroundSubterms): rewritten 1624 1625 * freeDagNode.hh (class FreeDagNode): updated decl for 1626 computeBaseSortForGroundSubterms() 1627 16282007-08-23 Steven Eker <eker@goo.csl.sri.com> 1629 1630 * freeDagNode.cc (computeSolvedForm): becomes computeSolvedForm2() 1631 (computeSolvedForm2): simplified now that we should be called on 1632 ground terms, e.g. constants 1633 1634 * freeDagNode.hh (class FreeDagNode): computeSolvedForm() -> 1635 computeSolvedForm2() 1636 1637===================================Maude89g=========================================== 1638 16392007-06-28 Steven Eker <eker@goo.csl.sri.com> 1640 1641 * freeDagNode.hh (class FreeDagNode): updated decl for 1642 computeSolvedForm() 1643 1644 * freeDagNode.cc (computeSolvedForm): added extensionInfo arg 1645 1646===================================Maude89c=========================================== 1647 16482007-03-16 Steven Eker <eker@goo.csl.sri.com> 1649 1650 * freeDagNode.cc (unify, occurs2): deleted 1651 1652 * freeDagNode.hh (class FreeDagNode): deleted decls for unify() 1653 and occurs2() 1654 16552007-03-15 Steven Eker <eker@goo.csl.sri.com> 1656 1657 * freeSymbol.cc (computeGeneralizedSort): pass realToBdd by ref 1658 1659 * freeSymbol.hh (class FreeSymbol): fix decl for 1660 computeGeneralizedSort() 1661 1662===================================Maude89a=========================================== 1663 16642007-03-05 Steven Eker <eker@goo.csl.sri.com> 1665 1666 * freeDagNode.cc (nonVariableSize): return mpz_class 1667 1668 * freeDagNode.hh (class FreeDagNode): nonVariableSize() now 1669 returns mpz_class 1670 16712007-02-27 Steven Eker <eker@goo.csl.sri.com> 1672 1673 * freeDagNode.cc (insertVariables2): added 1674 1675 * freeDagNode.hh (class FreeDagNode): added decl for 1676 insertVariables2() 1677 16782007-02-26 Steven Eker <eker@goo.csl.sri.com> 1679 1680 * freeDagNode.cc (nonVariableSize): added 1681 1682 * freeDagNode.hh (class FreeDagNode): added decl for 1683 computeSolvedForm() 1684 (class FreeDagNode): added decl for nonVariableSize(); 1685 1686 * freeDagNode.cc (computeSolvedForm): added 1687 1688===================================Maude89=========================================== 1689 16902007-02-09 Steven Eker <eker@goo.csl.sri.com> 1691 1692 * freeDagNode.cc (instantiate2): fixed bug where we were using 1693 wrong index to copy already looked at arguments 1694 16952007-01-31 Steven Eker <eker@goo.csl.sri.com> 1696 1697 * freeDagNode.cc (unify): clean up 1698 (unify): handle subproblems; zero extensionInfo on recursive calls 1699 17002007-01-30 Steven Eker <eker@goo.csl.sri.com> 1701 1702 * freeSymbol.cc (computeGeneralizedSort): use DagNode version of 1703 computeGeneralizedSort() 1704 1705 * freeDagNode.hh (class FreeDagNode): instantiate() -> 1706 instantiate2(); occurs() -> occurs2() 1707 1708 * freeDagNode.cc (computeBaseSortForGroundSubterms): added 1709 (instantiate): becomes instantiate2() 1710 (instantiate2): handle the computation of the base sort of a newly 1711 dagnode if it turns out to be ground 1712 (occurs): becomes occurs2() 1713 1714 * freeDagNode.hh (class FreeDagNode): added decl for 1715 computeBaseSortForGroundSubterms() 1716 1717===================================Maude88e=========================================== 1718 17192007-01-05 Steven Eker <eker@goo.csl.sri.com> 1720 1721 * freeSymbol.cc (computeGeneralizedSort): added 1722 1723 * freeSymbol.hh (class FreeSymbol): added decl for 1724 computeGeneralizedSort() 1725 17262006-12-11 Steven Eker <eker@goo.csl.sri.com> 1727 1728 * freeDagNode.hh (class FreeDagNode): added decls for 1729 instantiate() and occurs() 1730 1731 * freeDagNode.cc (instantiate): added 1732 (occurs): added 1733 17342006-12-08 Steven Eker <eker@goo.csl.sri.com> 1735 1736 * freeDagNode.cc (unify): added 1737 1738 * freeDagNode.hh (class FreeDagNode): added decl for unify() 1739 1740===================================Maude88d=========================================== 1741 17422006-10-18 Steven Eker <eker@goo.csl.sri.com> 1743 1744 * freeRemainder.cc (dump): dump equation 1745 17462006-10-10 Steven Eker <eker@goo.csl.sri.com> 1747 1748 * freeNet.hh (class FreeNet): removed extraneous quantifier to 1749 appease gcc 4.1 1750 1751===================================Maude88b=========================================== 1752 17532005-07-28 Steven Eker <eker@goo.csl.sri.com> 1754 1755 * freeTerm.cc (findEagerVariables, markEagerArguments): removed 1756 unnecessay static_cast 1757 1758 * freeTerm.hh (class FreeTerm): updated decls for SymbolMap* 1759 version of ctor 1760 (symbol): added 1761 1762 * freeTerm.cc (FreeTerm): SymbolMap* version: insist that symbol 1763 is a FreeSymbol 1764 (deepCopy2): handle translation to non-FreeSymbol 1765 17662005-06-24 Steven Eker <eker@goo.csl.sri.com> 1767 1768 * freeTerm.hh (class FreeTerm): updated decls for SymbolMap* 1769 version of ctor and deepCopy2() 1770 1771 * freeTerm.cc (FreeTerm): rewrote SymbolMap* version 1772 (deepCopy2): rewritten 1773 1774===================================Maude86b=========================================== 1775 17762004-10-07 Steven Eker <eker@goo.csl.sri.com> 1777 1778 * freeDagNode.hh (FreeDagNode): removed parens from DagNode* to 1779 appease g++ 2.4.2 1780 17812003-09-02 Steven Eker <eker@goo.csl.sri.com> 1782 1783 * freeSymbol.cc (complexStrategy): use applyReplaceNoOwise() 1784 (memoStrategy): use applyReplaceNoOwise() 1785 1786 * freeRemainder.hh (isOwise): added 1787 1788 * freeNetExec.cc (applyReplaceNoOwise2): added 1789 1790 * freeNet.hh (applyReplaceNoOwise): added 1791 1792 * freeNetExec.cc (applyReplace2): removed non-SPEED_HACKS version 1793 1794 * freeNet.cc (translateSlots): removed SPEED_HACKS #ifndef and the 1795 non-SPEED_HACKS code 1796 (buildRemainders): removed SPEED_HACKS #ifdef 1797 (dump): removed SPEED_HACKS #ifndefs and the non-SPEED_HACKS code 1798 1799 * freeNet.hh (class FreeNet): removed SPEED_HACKS #ifdef 1800 1801===================================Maude82=========================================== 1802 18032003-07-14 Steven Eker <eker@goo.csl.sri.com> 1804 1805 * freeNet.hh (class FreeNet): test SIZEOF_VOID_P and SIZEOF_SHORT 1806 when deciding on layout 1807 1808===================================Maude81=========================================== 1809 18102003-05-28 Steven Eker <eker@goo.csl.sri.com> 1811 1812 * freeRemainder.hh (fastMatchReplace): use 1813 MemoryCell::okToCollectGarbage() 1814 1815 * freeRemainder.cc (slowMatchReplace): use 1816 MemoryCell::okToCollectGarbage() 1817 1818===================================Maude80b=========================================== 1819 18202003-05-06 Steven Eker <eker@goo.csl.sri.com> 1821 1822 * freeTerm.cc (partialCompareArguments): use FOR_EACH_CONST() 1823 (partialCompareArguments): use safeCast() 1824 18252003-05-01 Steven Eker <eker@goo.csl.sri.com> 1826 1827 * freeDagNode.cc (overwriteWithClone): use copySetRewritingFlags() 1828 (makeClone): use copySetRewritingFlags() 1829 1830===================================Maude79=========================================== 1831 18322003-03-03 Steven Eker <eker@goo.csl.sri.com> 1833 1834 * freeNet.cc (buildTernaryTree): use notEqual[] in place of less 1835 and greater 1836 (dump): use notEqual[] in place of less and greater 1837 (tripleLt): removed pointer comparison SPEED_HACK 1838 1839 * freeNetExec.cc (applyReplace2): use notEqual[] and getSignBit() 1840 to do branch-free choice in discrimination net 1841 1842 * freeNet.hh (class FreeNet): notEqual array replaces less and 1843 greater in struct TestNode 1844 (class FreeNet): added enum SpecialValues 1845 18462003-02-25 Steven Eker <eker@goo.csl.sri.com> 1847 1848 * freePreNetSubsumption.cc (subsumesWrtReducedFringe): removed 1849 unused variable sf 1850 1851 * freeUnarySymbol.cc: removed #pragma 1852 1853 * freeUnarySymbol.hh: removed #pragma 1854 1855 * freeTheory.cc: deleted 1856 1857 * freeTernarySymbol.cc: removed #pragma 1858 1859 * freeTernarySymbol.hh: removed #pragma 1860 1861 * freeTerm.cc: removed #pragma 1862 (FreeTerm): updated Assert() 1863 (compareArguments): updated Assert() (both versions) 1864 (partialCompareArguments): updated Assert() 1865 (findActiveSlots): updated Assert() 1866 1867 * freeTerm.hh: removed #pragma 1868 1869 * freeSymbol.cc: removed #pragma 1870 (eqRewrite): updated Assert() 1871 (computeBaseSort): updated Assert()s 1872 (normalizeAndComputeTrueSort): updated Assert() 1873 1874 * freeSymbol.hh: removed #pragma 1875 1876 * freeSubterm.hh: removed #pragma 1877 1878 * freeRhsAutomaton.cc: removed #pragma 1879 1880 * freeRhsAutomaton.hh: removed #pragma 1881 1882 * freeRemainder.hh (fastMatchReplace): updated Assert()s 1883 1884 * freeRemainder.cc: removed #pragma 1885 (FreeRemainder): updated Assert()s 1886 (slowMatchReplace2): updated Assert() 1887 1888 * freeRemainder.hh: removed #pragma 1889 1890 * freePreNetSubsumption.cc (subsumesWrtReducedFringe): updated 1891 Assert() 1892 1893 * freePreNetSemiCompiler.cc (semiCompileNode): updated Assert()s 1894 (allocateSlot): updated Assert() 1895 (buildSlotTranslation): updated Assert()s 1896 1897 * freePreNetFullCompiler.cc (allocateVariables): updated Assert() 1898 1899 * freePreNet.cc: removed #pragma 1900 (buildNet): DebugAdvisoryCheck() -> DebugAdvisory() 1901 (makeNode): updated Assert() 1902 (partiallySubsumed): updated Assert() 1903 1904 * freePreNet.hh: removed #pragma 1905 1906 * freePositionTable.cc: removed #pragma 1907 1908 * freePositionTable.hh: removed #pragma 1909 1910 * freeOccurrence.hh: removed #pragma 1911 1912 * freeNet.cc: removed #pragma 1913 (fillOutNode): updated Assert() 1914 1915 * freeNet.hh: removed #pragma 1916 1917 * freeLhsStructs.hh: removed #pragma 1918 1919 * freeLhsCompiler.cc (compileRemainder): updated Assert() 1920 (compileLhs2): updated Assert() 1921 (findConstraintPropagationSequence): updated Assert() 1922 1923 * freeLhsAutomaton.cc: removed #pragma 1924 (match): updated Assert()s 1925 1926 * freeLhsAutomaton.hh: removed #pragma 1927 1928 * freeDagNode.cc: removed #pragma 1929 (compareArguments): updated Assert() 1930 (copyWithReplacement): updated Assert() 1931 (copyWithReplacement): updated Assert()s 1932 1933 * freeDagNode.hh: removed #pragma 1934 (getArgument): updated Assert()s 1935 1936 * freeDagArgumentIterator.cc: removed #pragma 1937 (argument): updated Assert() 1938 (next): updated Assert() 1939 1940 * freeDagArgumentIterator.hh: removed #pragma 1941 1942 * freeBinarySymbol.cc: removed #pragma 1943 1944 * freeBinarySymbol.hh: removed #pragma 1945 1946 * freeArgumentIterator.cc: removed #pragma 1947 (argument): updated Assert() 1948 (next): updated Assert() 1949 1950 * freeArgumentIterator.hh: removed #pragma 1951 1952===================================Maude79=========================================== 1953 19542003-01-07 Steven Eker <eker@goo.csl.sri.com> 1955 1956 * freeTerm.hh (class FreeTerm): added decl for 1957 partialCompareArguments() 1958 1959 * freeTerm.cc (partialCompareArguments): added 1960 1961===================================Maude78================================================== 1962 19632002-11-25 Steven Eker <eker@goo.csl.sri.com> 1964 1965 * freeDagNode.hh (class FreeDagNode): added hack to get around the 1966 invisibility of MemoryCell::Word 1967 19682002-11-20 Steven Eker <eker@goo.csl.sri.com> 1969 1970 * freeNet.cc (dump): use &(stack[0]) in place of 1971 stack.rawBasePointer() 1972 1973 * freeNetExec.cc: replaced rawBasePointer() call with 1974 const_iterators 1975 (applyReplace2): reordering the initial assignments restored 1976 performance accounding to quantify 1977 1978===================================Maude77================================================== 1979 19802002-11-13 Steven Eker <eker@goo.csl.sri.com> 1981 1982 * freeSymbol.cc (compileEquations): pass false to FreePreNet ctor 1983 (generateCode): pass true to FreePreNet ctor 1984 1985 * freePreNet.cc (FreePreNet): added 1986 (dump): only dump patternIndex and nextPattern for remainder nodes 1987 if expandRemainderNodes is true; in the false case these fields 1988 won't be set 1989 (makeNode): only expand remainder nodes if expandRemainderNodes == 1990 true 1991 1992 * freePreNet.hh (class FreePreNet): added data member 1993 expandRemainderNodes 1994 (class FreePreNet): added decl for FreePreNet() 1995 19962002-10-07 Steven Eker <eker@goo.csl.sri.com> 1997 1998 * freeDagNode.cc (copyWithReplacement): simple version: added 1999 Assert(), removed test for nrArgs != 0 2000 (copyWithReplacement): complex version: added Assert()s, removed 2001 test for nrArgs != 0 2002 20032002-10-04 Steven Eker <eker@goo.csl.sri.com> 2004 2005 * freeDagNode.hh (class FreeDagNode): updated decl for complex 2006 version of copyWithReplacement() 2007 2008 * freeDagNode.cc (copyWithReplacement): complex version: rewritten 2009 to handle case where not all arguments have been stacked 2010 2011 * freeSymbol.cc (stackArguments): rewritten to stack only those 2012 args that are not frozen and not unstackable 2013 20142002-10-03 Steven Eker <eker@goo.csl.sri.com> 2015 2016 * freeDagNode.hh (class FreeDagNode): updated decl for 2017 stackArguments() 2018 2019 * freeDagNode.cc (stackArguments): take and handle respectFrozen 2020 flag 2021 2022===================================Maude76================================================== 2023 20242002-08-02 Steven Eker <eker@goo.csl.sri.com> 2025 2026 * freeTerm.cc (compileRhs3): call useIndex() on source obtained by 2027 recursive call; this fixes a bug with new constrcution index 2028 coloring scheme; may also fix a potential bug with fragments 2029 (compileRhs3): fix bug properly this time - we need to flag last 2030 use of each source after all the sources have been compiled 2031 2032 * freePreNetSubsumption.cc (subsumesWrtReducedFringe): fixed bug 2033 where we weren't calling subsumerArgs.next() and were running of 2034 the end of domainSorts[] 2035 20362002-07-26 Steven Eker <eker@goo.csl.sri.com> 2037 2038 * freeDagNode.hh (class FreeDagNode): added class 2039 FreeTernarySymbol to friends 2040 2041 * freeSymbol.cc (newFreeSymbol): use FreeTernarySymbol 2042 2043 * freeTernarySymbol.cc: created 2044 2045 * freeTernarySymbol.hh: created 2046 2047 * freeNetExec.cc (applyReplace2): added pointer comparison trick 2048 for SPEED_HACKS case 2049 2050 * freeNet.cc (buildRemainders): fixed bug in SPEED_HACKS version 2051 (tripleLt): added pointer comparison trick for SPEED_HACKS case 2052 20532002-07-25 Steven Eker <eker@goo.csl.sri.com> 2054 2055 * freeNet.hh (class FreeNet): added decl for moreImportant() 2056 2057 * freeNet.cc: moved all the freeNetAlt.cc stuff here since is now 2058 the only way rather than an alternative way to build FreeNets 2059 (moreImportant): added 2060 (buildTernaryTree): use moreImportant() to bias selection of 2061 test symbols 2062 2063 * freePreNetSemiCompiler.cc (buildSlotTranslation): use new 2064 conflicts structure 2065 2066 * freePreNet.hh (class FreePreNet): conflicts becomes Vector<NatSet> 2067 2068 * freeTerm.hh (class FreeTerm): updated decl for findActiveSlots() 2069 2070 * freeTerm.cc (findActiveSlots): changed arg to NatSet& 2071 2072 * freeNet.cc (dump): handle new applicable strcuture 2073 2074 * freeNetExec.cc (applyReplace2): simplified slow case 2075 2076 * freeNetAlt.cc (addRemainderList): simplified 2077 (buildRemainders): rewritten 2078 2079 * freeNet.hh (class FreeNet): reorganized struct TestNode 2080 (class FreeNet): applicable changed to Vector<natSet> from 2081 Vector<Vector<int> > 2082 20832002-07-24 Steven Eker <eker@goo.csl.sri.com> 2084 2085 * freeNet.hh (class FreeNet): deleted struct Position 2086 2087 * freeSymbol.cc (compileEquations): deleted commented out call to 2088 discriminationNet.compileEquations() 2089 2090 * freeNet.hh (class FreeNet): deleted decls for 2091 conservativePartialSubsumptionApproximation(), 2092 buildSlotTranslation(), findBestPosition(), setVisitedFlags(), 2093 allocateSlot(), buildPatternVector(), buildFringe(), buildNet(), 2094 buildApplicable(), isSubsumed(), compileEquations(), 2095 generateCode() 2096 2097 * freeNet.cc (compileEquations): deleted 2098 (buildSlotTranslation): deleted 2099 (findBestPosition): deleted 2100 (buildNet): deleted 2101 (buildApplicable): deleted 2102 (setVisitedFlags): deleted 2103 (allocateSlot): deleted 2104 (buildPatternVector): deleted 2105 (buildFringe): deleted 2106 2107 * freePreNetSubsumption.cc (subsumesWrtReducedFringe): same as 2108 below 2109 2110 * freePreNet.cc (buildNet): pass sameVariableSet = false to 2111 subsumes() since patterns are from different universally 2112 quantified equations 2113 2114 * freeTerm.cc (subsumes): handle sameVariableSet arg 2115 2116 * freeTerm.hh (class FreeTerm): updated decl for subsumes() 2117 2118 * freePreNetSubsumption.cc: updated comments to make them less 2119 obscure 2120 21212002-07-22 Steven Eker <eker@goo.csl.sri.com> 2122 2123 * freePreNetSemiCompiler.cc (semiCompile): don't do precompilation 2124 stuff here because it is too late 2125 2126 * freeSymbol.cc (compileEquations): need to do precompilation 2127 stuff here before we create the FreePreNet so that 2128 Term::contextSet is set up correctly in each subterm and 2129 subsumption can take account of nonlinear variables 2130 2131 * freePreNet.cc (buildNet): added DebugAdvisoryCheck() for 2132 subsumption 2133 2134 * freePreNetSubsumption.cc (subsumesWrtReducedFringe): fix bug 2135 where we weren't dealing with the possibility that subsumes() 2136 could return UNDECIDED 2137 2138 * freeNet.cc (dump): handle null remainder pointers 2139 2140 * freeNet.hh (class FreeNet): updated decl for buildRemainders() 2141 2142 * freeNetAlt.cc (buildRemainders): handle patternsUsed arg 2143 2144 * freePreNetSemiCompiler.cc (semiCompile): pass patternsUsed to 2145 buildRemainders() 2146 2147 * freePreNet.hh (class FreePreNet): added data member patternsUsed 2148 2149 * freePreNetSemiCompiler.cc (semiCompileNode): update patternsUsed 2150 2151 * freeRemainder.cc (dump): fixed bug where we were calling 2152 index2Variable() on indices of pseudo variables 2153 (FreeRemainder): added Assert() for parent slots 2154 (FreeRemainder): static_cast<>() -> safeCast() 2155 2156 * freePreNetSemiCompiler.cc (semiCompileNode): fixed bug where we 2157 passing NONE (-1) rather than 0 to fillOutNode() for the fail case 2158 21592002-07-19 Steven Eker <eker@goo.csl.sri.com> 2160 2161 * freePreNetSemiCompiler.cc (semiCompile): need to compile 2162 equations and set term root slots 2163 2164 * freeTerm.cc (findActiveSlots): adde Assert() to check for 2165 missing slot index in active FreeTerm 2166 2167 * freePreNetSemiCompiler.cc (semiCompile): handle empty net case 2168 (semiCompileNode): fig bug where we weren't filling out symbols[] 2169 (semiCompileNode): on both branches! 2170 (semiCompileNode): passing wrong live set to allocateSlot() 2171 resulting in NULLs in conflicts 2172 2173 * freeSymbol.cc (compileEquations): use FreePreNet 2174 2175 * freePreNetSemiCompiler.cc (semiCompile): call buildRemainders() 2176 2177 * freeNetAlt.cc: created 2178 2179 * freeNet.hh (class FreeNet): added decl for buildRemainders() 2180 21812002-07-18 Steven Eker <eker@goo.csl.sri.com> 2182 2183 * freePreNetSemiCompiler.cc (semiCompileNode): created 2184 2185 * freeNet.hh (class FreeNet): added decls for allocateNode(), 2186 fillOutNode(), addRemainderList() 2187 (class FreeNet): added decl for translateSlots() 2188 2189 * freePreNet.hh (class FreePreNet): added freeNetIndex to struct 2190 Node 2191 (class FreePreNet): added data member conflicts 2192 (class FreePreNet): added typedef for SlotMap 2193 21942002-07-16 Steven Eker <eker@goo.csl.sri.com> 2195 2196 * freePreNetFullCompiler.cc (generateNode): use generatePointer() 2197 rather than generatePointer2() in the testing of bound variables 2198 part so we take advantage of the case where the pointer to the 2199 dagnode matching the nonlinear occurrence is already in an 'r' 2200 variables as a result of previous test nodes (generated for the 2201 benefit of other patterns) 2202 22032002-07-12 Steven Eker <eker@goo.csl.sri.com> 2204 2205 * freePreNetFullCompiler.cc (generateCode): move call to 2206 allocateVariables here from FreePreNet::buildNet() 2207 2208 * freePreNet.cc (findBestPosition): modify heuristic to prefer 2209 positions that are stable in early subsumers so they get to 2210 discard later patterns by partial subsumption more quickly 2211 22122002-07-11 Steven Eker <eker@goo.csl.sri.com> 2213 2214 * freePreNet.cc (partiallySubsumed): fixed bug where we we 2215 iterating off the end of liveSet 2216 2217===================================Maude74================================================== 2218 22192002-05-03 Steven Eker <eker@goo.csl.sri.com> 2220 2221 * freeBinarySymbol.cc (FreeBinarySymbol): don't pass eagerStrategy 2222 to FreeSymbol 2223 2224 * freeBinarySymbol.hh (class FreeBinarySymbol): deleted static 2225 data member eagerStrategy 2226 2227 * freeUnarySymbol.cc (FreeUnarySymbol): don't pass eagerStrategy 2228 to FreeSymbol 2229 2230 * freeUnarySymbol.hh (class FreeUnarySymbol): deleted static data 2231 member eagerStrategy 2232 2233===================================Maude72================================================== 2234 22352002-03-21 Steven Eker <eker@goo.csl.sri.com> 2236 2237 * freePreNet.cc (makeNode): fixed potential bug where calling 2238 makeNode() could invalidate the reference net[nrNodes].sons[i].target 2239 (findLiveSet): fix potential bug where psition reference could be 2240 evaluated by a call to partiallySubsumed() since whis in turn 2241 calls subsumesWrtReducedFringe() which adds new positions to table 2242 22432002-03-19 Steven Eker <eker@goo.csl.sri.com> 2244 2245 * freePreNet.cc (partiallySubsumed): fixed bug where we weren't 2246 handling empty liveSet 2247 (makeNode): fixed subtle bug: now that reallocation of a vector 2248 causes vectors contents to be copied, pointers and references into 2249 vectors within vectors become invalid when the outer vector is 2250 resized since the inner vectors are copied. We were storing an 2251 Arc& ref across a call to makeNode() which resizes the outer vector 2252 2253 * freePreNet.hh (class FreePreNet): updated decls for makeNode(), 2254 reduceFringe(), findLiveSet(); delete decl for FreeTerm* version 2255 of partiallySubsumed() 2256 2257 * freePreNet.cc (buildNet): removed all mention of difficult sets 2258 (makeNode): removed all mention of difficult sets 2259 (reduceFringe): removed all mention of difficult sets 2260 (findLiveSet): removed all mention of difficult sets 2261 (partiallySubsumed): deleted FreeTerm* version 2262 2263 * freePreNet.hh (class FreePreNet): added data member topPositionIndex 2264 2265 * freePreNet.cc (partiallySubsumed): rewritten 2266 2267 * freePreNet.hh (class FreePreNet): updated decls for 2268 subsumesWrtReducedFringe() (both versions) 2269 2270 * freePreNetSubsumption.cc (subsumesWrtReducedFringe): moved here 2271 (both versions) 2272 (subsumesWrtReducedFringe): rewritten to avoid calling 2273 locateSubterm() (both versions) 2274 22752002-03-15 Steven Eker <eker@goo.csl.sri.com> 2276 2277 * freePreNet.hh (class FreePreNet): added decls for 2278 subsumesWrtReducedFringe() (both versions) 2279 2280 * freePreNet.cc (subsumesWrtReducedFringe): added FreeTerm* 2281 version 2282 (subsumesWrtReducedFringe): added const NatSet& version 2283 22842002-03-14 Steven Eker <eker@goo.csl.sri.com> 2285 2286 * freePreNet.hh (class FreePreNet): deleted decl for 2287 isDomainMaximalLinearVariable() 2288 2289 * freePreNet.cc (isDomainMaximalLinearVariable): delete; it was 2290 based on domainSortAlwaysLeqThan() which is now unsound since mbs 2291 can drag a term out of the kind (error sort) into a regular sort. 2292 (reduceFringe): don't call isDomainMaximalLinearVariable() - 2293 assume false 2294 (findLiveSet): don't call isDomainMaximalLinearVariable() - assume 2295 false; NatSet::const_iter clean up 2296 (partiallySubsumed): (FreeTerm* version) don't call 2297 isDomainMaximalLinearVariable() - assume false; NatSet::const_iter 2298 clean up 2299 23002002-03-12 Steven Eker <eker@goo.csl.sri.com> 2301 2302 * freePreNet.hh (class FreePreNet): updated decl for 2303 isDomainMaximalLinearVariable() 2304 2305 * freePreNet.cc (findBestPosition): simplified using 2306 NatSet::const_iterators and PointerSet::swap() 2307 (reduceFringe): simplified using NatSet::const_iterators 2308 (isDomainMaximalLinearVariable): take FreeTerm*; Assert() that 2309 subterm exists since it is an error to try and dynamic_cast a null 2310 pointer (this was an almost bug in previous version) 2311 (reduceFringe): added safeCast to FreeTerm* 2312 2313 * freePositionTable.cc: added comments to explain not so obvious 2314 digital search tree implementation 2315 23162002-03-11 Steven Eker <eker@goo.csl.sri.com> 2317 2318 * freeLhsAutomaton.cc: deleted explicit template instantiations 2319 2320 * freeNet.cc: deleted explicit template instantiations 2321 2322 * freePositionTable.cc: deleted explicit template instantiation 2323 2324 * freePreNet.cc: deleted explicit template instantiations 2325 2326 * freeRhsAutomaton.cc: deleted explicit template instantiation 2327 2328 * freeTheory.cc: deleted explicit template instantiations 2329 2330===================================Maude71================================================== 2331 23322002-03-08 Steven Eker <eker@goo.csl.sri.com> 2333 2334 * freeRemainder.cc (slowMatchReplace2): turn for loops into 2335 do-while loops for speed 2336 2337 * freeLhsAutomaton.cc (match): turn for loops into do-while loops 2338 for speed 2339 23402002-03-07 Steven Eker <eker@goo.csl.sri.com> 2341 2342 * freeLhsAutomaton.cc (match): use iterators for stack access 2343 (match): use const_iterators for loops 2344 2345 * freeRhsAutomaton.cc (fillOutArgs): rewritten using 2346 const_iterators in place of CONST_VECTOR_HACKs 2347 (construct): rewritten using const_iterators in place of 2348 CONST_VECTOR_HACKs 2349 (replace): rewritten using const_iterators in place of 2350 CONST_VECTOR_HACKs 2351 2352 * freeRemainder.hh (fastMatchReplace): fixed stupid begin()/end() 2353 wrong-way-around bug 2354 2355 * freeRemainder.cc (slowMatchReplace2): rewrote using 2356 const_iterators for loops 2357 2358 * freeTheory.cc: provide implementation for FreeLhsStructs 2359 2360 * freeTheory.hh: added fwd decl for FreeLhsStructs 2361 2362 * freeRemainder.cc (slowMatchReplace2): remove FreeLhsAutomaton::'s 2363 2364 * freeRemainder.hh (class FreeRemainder): derive from 2365 FreeLhsStructs 2366 (fastMatchReplace): remove FreeLhsAutomaton::'s 2367 2368 * freeLhsAutomaton.hh (class FreeLhsAutomaton): derive from 2369 FreeLhsStructs 2370 2371 * freeLhsStructs.hh: created 2372 2373 * freeRemainder.hh (fastMatchReplace): rewritten using 2374 const_iterators in place of CONST_VECTOR_HACKs 2375 (fastMatchReplace): use const_cast<> to add constness and get the 2376 correct iterator 2377 23782002-02-05 Steven Eker <eker@goo.csl.sri.com> 2379 2380 * freeSymbol.hh (class FreeSymbol): added strategy = standard 2381 default argument to both ctor and newFreeSymbol() 2382 2383===================================Maude70================================================== 2384 23852001-12-10 Steven Eker <eker@goo.csl.sri.com> 2386 2387 * freeSymbol.cc (newFreeSymbol): replaced ?: with if-then-else to 2388 avoid g++ 3.0 complaints abount distinct pointer types 2389 2390===================================Maude69================================================== 2391 23922001-04-03 Steven Eker <eker@goo.csl.sri.com> 2393 2394 * freeDagNode.hh (class FreeDagNode): added dec for 2395 Vector<RedexPosition> verison of copyWithReplacement() 2396 2397 * freeDagNode.cc (copyWithReplacement): added 2398 (Vector<RedexPosition> verison) 2399 2400===================================Engine66================================================== 2401 24022001-03-16 Steven Eker <eker@goo.csl.sri.com> 2403 2404 * freeRemainder.cc (slowMatchReplace2): incrementCount() -> 2405 incrementEqCount() 2406 2407 * freeRemainder.hh (fastMatchReplace): incrementCount() -> 2408 incrementEqCount() 2409 24102001-03-07 Steven Eker <eker@goo.csl.sri.com> 2411 2412 * freeSymbol.cc (stackArguments): added 2413 2414 * freeSymbol.hh (class FreeSymbol): added decl for 2415 stackArguments() 2416 2417===================================Engine65================================================== 2418 24192001-01-26 Steven Eker <eker@goo.csl.sri.com> 2420 2421 * freeDagNode.hh (class FreeDagNode): updated decl for 2422 markArguments and made it private 2423 2424 * freeDagNode.cc (markArguments): code cleaning 2425 (markArguments): rewritten with new semantics 2426 24272001-01-24 Steven Eker <eker@goo.csl.sri.com> 2428 2429 * freeRemainder.hh (class FreeRemainder): deleted decl for 2430 generateRemainder() 2431 2432 * freeRemainder.cc (generateRemainder): deleted 2433 2434 * freeNet.hh (class FreeNet): deleted decls for 2435 calculateLivePatterns(), generateNode(), generateBranch(), 2436 gatherAlternatives(), gatherAlternatives2() 2437 2438 * freeNet.cc (calculateLivePatterns): deleted 2439 (generateCode): deleted 2440 (generateNode): deleted 2441 (gatherAlternatives): deleted 2442 (gatherAlternatives2): deleted 2443 (generateBranch): deleted 2444 2445===================================Engine64================================================== 2446 24472000-10-20 Steven Eker <eker@goo.csl.sri.com> 2448 2449 * freeTerm.cc (compileRhsAliens): fixed bug where we were using 2450 eagerContext rather than argEager in call to findTerm() 2451 (compileRhs3): fixed bug where we were using eagerContext rather 2452 than argEager in calls to findTerm() and insertBuiltTerm() 2453 24542000-10-11 Steven Eker <eker@goo.csl.sri.com> 2455 2456 * freeTerm.cc (compileRhs2): call compileRhsAliens(); the idea is 2457 that we need a completely seperate pass over the free skeleton to 2458 comple all the aliens first otherwise we can end up with common 2459 subexpressions being used by an alien subterm before they are 2460 built by the FreeRhsAutomaton; we still need to clean up 2461 compileRhs3() now that some of the work is done in this seperate 2462 pass 2463 2464 * freeTerm.hh (class FreeTerm): added decl for compileRhsAliens() 2465 2466 * freeTerm.cc (compileRhsAliens): added 2467 2468===================================Engine63================================================== 2469 24702000-08-02 Steven Eker <eker@goo.csl.sri.com> 2471 2472 * freeRemainder.cc (slowMatchReplace): no longer call 2473 inErrorSort() when pattern is in the error sort 2474 (FreeRemainder): no care if pattern is in error sort when deciding 2475 if we're suitable for "fast" treatment 2476 2477 * freeSymbol.cc (complexStrategy): removed special handling for 2478 last 0 of a user defined strategy 2479 (memoStrategy): ditto 2480 24812000-07-31 Steven Eker <eker@goo.csl.sri.com> 2482 2483 * freeSymbol.cc (computeBaseSort): don't handle union sorts 2484 2485===================================Engine61================================================== 2486 24872000-07-28 Steven Eker <eker@goo.csl.sri.com> 2488 2489 * freeRhsAutomaton.cc (remapIndices): added 2490 2491 * freeRhsAutomaton.hh (class FreeRhsAutomaton): added decl for 2492 remapIndices() 2493 24942000-07-26 Steven Eker <eker@goo.csl.sri.com> 2495 2496 * freeRemainder.cc (slowMatchReplace): use 2497 getNrProtectedVariables() instead of nrVariables() 2498 2499 * freePreNetFullCompiler.cc (generateNode): use 2500 getNrRealVariables() instead of nrVariables() 2501 2502 * freeTerm.cc (compileRhs3): use makeConstructionIndex() instead 2503 of allocateIndex() 2504 25052000-07-25 Steven Eker <eker@goo.csl.sri.com> 2506 2507 * freeTerm.cc (findAvailableTerms): don't insert ground terms into 2508 availableTerms since we can't do left->right sharing on them 2509 2510 * freeRhsAutomaton.cc (construct): don't call buildAliens() 2511 (replace): don't call buildAliens() 2512 (dump): don't call RhsAutomaton::dump() 2513 2514 * freeTerm.hh (class FreeTerm): deleted decl for compileRhs() 2515 2516 * freeTerm.cc (compileRhs): deleted 2517 2518===================================Engine60================================================== 2519 25202000-07-19 Steven Eker <eker@goo.csl.sri.com> 2521 2522 * freeTerm.cc (compileRhsAliens): deleted 2523 (compileRhsFree): deleted 2524 25252000-07-18 Steven Eker <eker@goo.csl.sri.com> 2526 2527 * freeTerm.hh (class FreeTerm): deleted decl for compileRhs() 2528 (class FreeTerm): deleted decls for compileRhsAliens() and 2529 compileRhsFree() 2530 2531 * freeTerm.cc (compileRhs3): call self on subterm, not on own object 2532 (compileRhs3): need to check if free subterm in availableTerms and 2533 insert free subterm into availableTerms after we compile it - not 2534 self 2535 (compileRhs): deleted 2536 2537 * freeRemainder.cc (FreeRemainder): use freeSymbols not freeVars 2538 when adding pseudo variables 2539 2540 * freeNet.hh (class FreeNet): removed extraneous dump() decl 2541 25422000-07-12 Steven Eker <eker@goo.csl.sri.com> 2543 2544 * freeRemainder.cc (FreeRemainder): use getLhs() instead of lhs() 2545 (slowMatchReplace): use getLhs() instead of lhs() 2546 (generateRemainder): use getRhs() instead of rhs() 2547 (FreeRemainder): don't check for problem variables 2548 (slowMatchReplace2): don't call copyProblemBindings() 2549 (slowMatchReplace2): use getLhsAutomaton() instead of 2550 lhsAutomaton() 2551 2552 * freePreNet.cc (buildNet): use getConditionVariables() instead of 2553 condLhs() and condRhs() 2554 (buildNet): use getRhs() instead of rhs() 2555 (buildNet): use getLhs() instead of lhs() 2556 2557 * freePreNetFullCompiler.cc (generateNode): use getRhs() instead 2558 of rhs() 2559 2560 * freeNet.cc (compileEquations): use getLhs() instead of lhs() 2561 2562 * freeRemainder.cc (slowMatchReplace2): use getRhsBuilder() 2563 instead of rhsAutomaton() 2564 2565 * freeRemainder.hh (fastMatchReplace): use getRhsBuilder() instead 2566 of rhsAutomaton() 2567 2568 * freeTerm.cc (compileRhs2): need to call addRhsAutomaton() 2569 25702000-07-11 Steven Eker <eker@goo.csl.sri.com> 2571 2572 * freeTerm.hh (class FreeTerm): added decl for compileRhs3() 2573 2574 * freeTerm.cc (findAvailableTerms): added 2575 (compileRhs2): added 2576 (compileRhs3): added 2577 2578 * freeTerm.hh (class FreeTerm): added decls for 2579 findAvailableTerms() and compileRhs2() 2580 2581 * freeRemainder.cc (dump): dump pseudo variables correctly 2582 2583 * freeLhsAutomaton.cc (dump): dump saveIndex for free subterms 2584 2585 * freeTerm.cc (findActiveSlots): the slots of free terms which 2586 have a free term arg that is needed for left -> right sharing are 2587 now added to active slots 2588 2589 * freeRemainder.cc: added code to create extra free variables for 2590 left -> right sharing 2591 2592 * freeNet.cc: removed old commented out conservative partial 2593 suubsumption code 2594 2595===================================Engine58================================================== 2596 25972000-07-05 Steven Eker <eker@goo.csl.sri.com> 2598 2599 * freeLhsAutomaton.cc (match): bind pseudo-variable for 2600 FreeSubterms with saveIndex != NONE 2601 (freeSubterms): set freeSubterms[].saveIndex 2602 2603 * freeLhsAutomaton.hh (class FreeLhsAutomaton): added saveIndex 2604 data member to struct FreeSubterm 2605 2606 * freeLhsCompiler.cc (compileLhs): becomes compileLhs2() 2607 2608 * freeTerm.hh (class FreeTerm): compileLhs() -> compileLhs2() 2609 26102000-06-23 Steven Eker <eker@goo.csl.sri.com> 2611 2612 * freeRemainder.cc (FreeRemainder): lookupSort() -> getSort() 2613 (FreeRemainder): index() -> getIndex() 2614 2615 * freePreNet.cc (isDomainMaximalLinearVariable): lookupSort() -> 2616 getSort() 2617 2618 * freePreNetFullCompiler.cc (generateNode): index() -> getIndex() 2619 (generateNode): lookupSort() -> getSort() 2620 2621 * freePreNet.cc (isDomainMaximalLinearVariable): index() -> 2622 getIndex() 2623 2624 * freeLhsAutomaton.cc (freeSubterms): lookupSort() -> getSort(); 2625 index() -> getIndex() 2626 2627 * freeTermFullCompiler.cc (scanFreeSkeleton): lookupSort() -> getSort() 2628 2629 * freeTerm.cc (compileRhsFree): modifiedIndex() -> getModifiedIndex() 2630 2631 * freeTermFullCompiler.cc (scanFreeSkeleton): index() -> 2632 getIndex() 2633 2634 * freeLhsCompiler.cc (analyseConstraintPropagation): index() -> 2635 getIndex() 2636 (compileRemainder): index() -> getIndex() 2637 (compileLhs): index() -> getIndex() 2638 2639 * freeRemainder.cc (FreeRemainder): use safeCast() macro in 2640 place of VariableTerm::downCast() (2 places) 2641 2642 * freeLhsAutomaton.cc (freeSubterms): use safeCast() macro in 2643 place of VariableTerm::downCast() (2 places) 2644 2645===================================Engine58================================================== 2646 26472000-03-30 Steven Eker <eker@goo.csl.sri.com> 2648 2649 * freeNet.cc (isSubsumed): commented out 2650 (conservativePartialSubsumptionApproximation): commented out 2651 (calculateLivePatterns): commented out 2652 2653 * freeTheory.cc: ifdef'd #pragma implementation "freeSubterm.hh" 2654 26552000-03-29 Steven Eker <eker@goo.csl.sri.com> 2656 2657 * freeLhsAutomaton.cc (match): made Assert() message more detailed 2658 26592000-03-17 Steven Eker <eker@goo.csl.sri.com> 2660 2661 * freeLhsAutomaton.cc (dump): ifdef'd 2662 2663 * freeRhsAutomaton.cc (dump): ifdef'd 2664 2665 * freeLhsAutomaton.hh (class FreeLhsAutomaton): used NO_COPYING() 2666 macro; ifdef'd dump() decl 2667 2668 * freeRhsAutomaton.hh (class FreeRhsAutomaton): ifdef'd dump() decl 2669 2670 * freeRemainder.hh (class FreeRemainder): used NO_COPYING() macro; 2671 ifdef'd dump() decl 2672 2673 * freeRemainder.cc (dump): ifdef'd 2674 2675 * freeSymbol.hh (class FreeSymbol): used NO_COPYING() macro; 2676 ifdef'd dump() decl 2677 2678 * freeSymbol.cc (dump): ifdef'd 2679 2680 * freePreNet.cc (dump): ifdef'd 2681 (dumpSlotMap): ifdef'd 2682 (dumpPath): ifdef'd 2683 (dumpPositionSet): ifdef'd 2684 (dumpNatSet): ifdef'd 2685 2686 * freePreNet.hh (class FreePreNet): ifdef'd dump routine decls 2687 2688 * freeNet.cc (dump): ifdef'd 2689 2690 * freeNet.hh (class FreeNet): ifdef'd dump() decl 2691 2692 * freeSymbol.cc (complexStrategy): standardized IssueAdvisory() 2693 (memoStrategy): standardized IssueAdvisory() 2694 26952000-03-15 Steven Eker <eker@goo.csl.sri.com> 2696 2697 * freeNet.hh (class FreeNet): added version of struct TestNode 2698 optimized for 64bit pts and #ifdef'd on ALPHA 2699 27002000-02-25 Steven Eker <eker@goo.csl.sri.com> 2701 2702 * freeNet.hh (class FreeNet): updated decls for isSubsumed() and 2703 calculateLivePatterns() 2704 2705 * freeNet.cc (isSubsumed): fixed bug where we weren't passing 2706 Vector arg by ref 2707 (calculateLivePatterns): fixed bug where we weren't passing 2708 Vector arg by ref 2709 2710===================================Engine56================================================== 2711 27122000-02-15 Steven Eker <eker@goo.csl.sri.com> 2713 2714 * freeDagNode.cc (FreeDagNode): delete Assert() since we are now 2715 forbidden to access symbol and hence cannot find our arity 2716 2717===================================Engine55================================================== 2718 27192000-01-31 Steven Eker <eker@goo.csl.sri.com> 2720 2721 * freeSymbol.cc (generateCons): generate code to fill out 2722 all flags including sort index in one step 2723 2724 * freePreNetFullCompiler.cc (generateNode): use struct Flags 2725 2726===================================Engine54================================================== 2727 27282000-01-28 Steven Eker <eker@goo.csl.sri.com> 2729 2730 * freePreNetFullCompiler.cc (allocateVariables): use flags field 2731 instead of unfailing 2732 (generateNode): use flags field instead of unfailing 2733 2734 * freePreNet.cc (partiallySubsumed): use flags field instead of 2735 subsumers 2736 (dump): use flags field instead of subsumers; print unfailing flag 2737 as well 2738 2739 * freePreNet.hh (class FreePreNet): added enum Flags; replaced 2740 unflailing field with flags field in struct Pattern; deleted 2741 subsumers data member 2742 2743 * freePreNetFullCompiler.cc (generateNode): call usedSort() 2744 27452000-01-27 Steven Eker <eker@goo.csl.sri.com> 2746 2747 * freeTermFullCompiler.cc (scanFreeSkeleton): must insert index if 2748 free variables into boundVariables! 2749 2750 * freePreNetFullCompiler.cc (generateNode): added special handling 2751 for next remainder; need to avoid generating goto in shared case 2752 and force generation of label in last parent case 2753 (generateCode): new calling convention for generateNode() 2754 (generateNode): generate code for comparing binding to nonlinear variables 2755 27562000-01-26 Steven Eker <eker@goo.csl.sri.com> 2757 2758 * freePreNetFullCompiler.cc (allocateVariables): increment 2759 nrFailParents for nextPattern arcs where there is no next pattern 2760 and the cirrent pattern is not unfailing 2761 (generateNode): now generate code to test sort of a node bound to 2762 a variable 2763 2764 * freePreNet.hh (class FreePreNet): added unfailing flag to struct pattern 2765 2766 * freeTerm.hh (class FreeTerm): updated decl for 2767 scanFreeSkeleton() 2768 2769 * freeTermFullCompiler.cc (scanFreeSkeleton): added unfailing 2770 calculation and result; a pattern is unfailing iff it is 2771 guarenteed to matching any instance of its free skeleton: 2772 all variables must be linear and have sorts at the top of 2773 error-free components. No aliens are allowed. 2774 27752000-01-24 Steven Eker <eker@goo.csl.sri.com> 2776 2777 * freeSymbol.cc (generateCode): only generate call 2778 generateSortDiagram() if we are not single sorted 2779 (generateCons): generate full sort look up if we can produce error 2780 sort 2781 27822000-01-19 Steven Eker <eker@goo.csl.sri.com> 2783 2784 * freeSymbol.cc (generateCons): rewritten to simplify code in 2785 normal case 2786 (generateCode): call generateSortDiagram() 2787 (generateCons): generate code to do sort calculation in naive case 2788 (generateCons): handle single non-error sort case 2789 27901999-12-21 Steven Eker <eker@goo.csl.sri.com> 2791 2792 * freePreNet.cc (partiallySubsumed): in the case that a fringe 2793 position exists in subsumer but not in victim, don't automatically 2794 return false; instead see if the subterm in the subsumer is domain 2795 maximal linear variable 2796 (findLiveSet): use f rather than patterns[i].term in call to 2797 isDomainMaximalLinearVariable() 2798 27991999-12-17 Steven Eker <eker@goo.csl.sri.com> 2800 2801 * freePreNet.cc (generateNode): call generateRhs() 2802 (generateNode): 'p' -> 'r' for generated variables 2803 (generatePointer): 'p' -> 'r' for generated variables 2804 (generateCode): 'p' -> 'r' for generated variables 2805 2806 * freeSymbol.hh (class FreeSymbol): updated decl for 2807 generateCode() 2808 2809 * freeSymbol.cc (generateCode): updated for new calling 2810 conventions 2811 28121999-12-16 Steven Eker <eker@goo.csl.sri.com> 2813 2814 * freeSymbol.cc (generateCons): added 2815 2816 * freePreNet.cc (buildNet): clear nrFailParents and nrFailVisits 2817 (allocateVariables): increment nrFailParents 2818 2819 * freePreNet.hh (class FreePreNet): added data member topSymbol 2820 (class FreePreNet): added data members nrFailParents and nrFailVisits 2821 2822 * freePreNet.cc (generateNode): added 2823 (generatePointer2): added 2824 (generatePointer): added 2825 (generateCode): added 2826 (makeNode): clear nrParents and nrVisits 2827 (allocateVariables): increment and test nrParents 2828 (buildNet): set topSymbol 2829 2830 * freePreNet.hh (class FreePreNet): added data members nrParents 2831 and nrVisits to struct Node; deleted data member pass2 2832 28331999-12-15 Steven Eker <eker@goo.csl.sri.com> 2834 2835 * freePreNet.hh (class FreePreNet): added data member slotTranslation 2836 2837 * freePreNet.cc (buildNet): call allocateVariables() 2838 2839 * freePreNet.hh (class FreePreNet): aded decl for dumpSlotMap() 2840 2841 * freePreNet.cc (dumpSlotMap): added 2842 (dump): call dumpSlotMap() 2843 2844===================================Engine54================================================== 2845 28461999-12-03 Steven Eker <eker@goo.csl.sri.com> 2847 2848 * freePreNet.cc2 (makeNode): clear pass2 flag 2849 (allocateVariables): set pass2 flag 2850 28511999-12-02 Steven Eker <eker@goo.csl.sri.com> 2852 2853 * freeTermFullCompiler.cc (scanFreeSkeleton): rewritten 2854 2855 * freeSubterm.hh: created 2856 2857 * freePreNet.hh (class FreePreNet): deleted saveSlot from struct 2858 Node; deleted decl for deleteSlot(); updated decl for slotMapUnion() 2859 2860 * freePreNet.cc (slotMapUnion): added avoidIndex arg 2861 (allocateVariables): don't delete testPositionIndex from local 2862 slot map, instead we rely on not passing it up; this way we avoid 2863 having to keep a copy in saveSlot 2864 (slotMapUnion): rewritten, now take fromNodeNr 2865 28661999-12-01 Steven Eker <eker@goo.csl.sri.com> 2867 2868 * freePreNet.hh (class FreePreNet): added decl for deleteSlot() 2869 2870 * freePreNet.cc (findSlot): added 2871 (slotMapInsert): added 2872 (slotMapUnion): added 2873 (allocateVariables): added 2874 2875 * freePreNet.hh (class FreePreNet): added struct Pair; add slotMap 2876 and pass2 members to struct Node; added decls for 2877 allocateVariables(), slotMapUnion(), slotMapInsert(), findSlot() 2878 2879 * freePositionTable.cc (parentIndex): added 2880 2881 * freePositionTable.hh (class FreePositionTable): added decl for parentIndex() 2882 2883 * freePreNet.hh (class FreePreNet): updated decl for makeNode() 2884 (class FreePreNet): added positionsTested member to struct Node 2885 (class FreePreNet): added slots data member 2886 2887 * freePreNet.cc (makeNode): fill out nextPattern and patternIndex 2888 if reducedFringe empty 2889 (dump): dump nextPattern and patternIndex 2890 (makeNode): keep track of positions tested 2891 (dump): dump positionsTested 2892 2893 * freePreNet.hh (class FreePreNet): added nextPattern and 2894 patternIndex members to struct Node 2895 2896 * freeTheory.hh: added forward decl for class FreePositionTable 2897 2898 * freeTerm.hh (class FreeTerm): added decl for full compiler 2899 version of scanFreeSkeleton() 2900 2901 * freeRemainder.cc (FreeRemainder): use errorFreeMaximal 2902 29031999-11-30 Steven Eker <eker@goo.csl.sri.com> 2904 2905 * freePreNet.cc (findBestPosition): must increment nrLive for each 2906 live pattern 2907 29081999-11-29 Steven Eker <eker@goo.csl.sri.com> 2909 2910 * freePreNet.cc (makeNode): set testPositionIndex 2911 (dump): dump testPositionIndex 2912 (dumpPositionSet): added 2913 (dumpNatSet): added 2914 (dump): use dumpPositionSet() and dumpNatSet() 2915 (makeNode): fixed nasty stale ref bug on n.sons; set n.neqTarget = 2916 UNBOUNDED in the not test position case to distinguish it from 2917 fail case 2918 (makeNode): inserted temporary to force evaluation of 2919 makeNode(newLiveSet, newFringe, newDifficultSets) before 2920 net[nrNodes].neqTarget (but should this be necessary?) 2921 (buildNet): need to eliminate patterns via subsumption at very top 2922 because our future elimination through partial subsumption is 2923 incremental 2924 2925 * freePreNet.hh (class FreePreNet): added decls for dump() and 2926 dumpPath() 2927 (class FreePreNet): added testPositionIndex to struct Node 2928 2929 * freePreNet.cc (dump): added 2930 (dumpPath): added 2931 29321999-11-24 Steven Eker <eker@goo.csl.sri.com> 2933 2934 * freePreNet.hh (class FreePreNet): added decls for 2935 expandFringe(), reduceFringe(), findLiveSet(), partiallySubsumed() 2936 (both versions) 2937 2938 * freePreNet.cc (expandFringe): added 2939 (reduceFringe): added 2940 (findLiveSet): added 2941 (partiallySubsumed): added (2 versions) 2942 2943 * freePreNet.hh (class FreePreNet): added decl for 2944 isDomainMaximalLinearVariable() 2945 2946 * freePreNet.cc (isDomainMaximalLinearVariable): added 2947 2948 * freeTerm.cc (locateSubterm): handle backup arg 2949 2950 * freeTerm.hh (class FreeTerm): added backup arg to locateSubterm() 2951 29521999-11-22 Steven Eker <eker@goo.csl.sri.com> 2953 2954 * freePreNet.cc (addPosition): deleted 2955 (buildNet): use FreePositionTable 2956 (findBestPosition): use FreePositionTable 2957 2958 * freePreNet.hh (class FreePreNet): use FreePositionTable 2959 2960 * freePositionTable.cc (position2Int): code cleaning 2961 29621999-11-19 Steven Eker <eker@goo.csl.sri.com> 2963 2964 * freePositionTable.cc: created 2965 2966 * freePositionTable.hh: created 2967 29681999-11-17 Steven Eker <eker@goo.csl.sri.com> 2969 2970 * freeNet.hh (class FreeNet): added decls for isSubsumed() and 2971 calculateLivePatterns() 2972 29731999-11-15 Steven Eker <eker@goo.csl.sri.com> 2974 2975 * freeNet.cc (isSubsumed): added 2976 (calculateLivePatterns): added 2977 29781999-11-12 Steven Eker <eker@goo.csl.sri.com> 2979 2980 * freeTerm.hh (class FreeTerm): added decl for locateSubterm2() 2981 2982 * freeTerm.cc (locateSubterm2): added 2983 2984 * freeNet.hh (class FreeNet): added decl for 2985 conservativePartialSubsumptionApproximation() 2986 2987 * freeNet.cc (conservativePartialSubsumptionApproximation): added 2988 29891999-11-10 Steven Eker <eker@goo.csl.sri.com> 2990 2991 * freeNet.cc: Reverted; partial subsumption is much more subtle 2992 than expected 2993 2994 * freeNet.hh (class FreeNet): updated decl for buildNet() 2995 Reverted 2996 2997 * freeNet.cc (compileEquations): compute subsuming; pass extra args 2998 to buildNet() 2999 (buildNet): build a new unknownPositions where and pass it on 3000 default arc and on arcs labelled with alien symbols 3001 30021999-11-09 Steven Eker <eker@goo.csl.sri.com> 3003 3004 * freeRemainder.cc (generateRemainder): updated 3005 30061999-11-08 Steven Eker <eker@goo.csl.sri.com> 3007 3008 * freeNet.hh (class FreeNet): decl for generateBody() replaced by 3009 decl for generateCode(); updated decls for generateNode() and 3010 generateBranch() 3011 3012 * freeRemainder.hh (class FreeRemainder): updated decl for 3013 generateRemainder() 3014 3015 * freeNet.cc (generateCode): added; replaces generateBody() 3016 (generateNode): updated to use CompilationContext 3017 (generateBranch): updated to use CompilationContext 3018 3019 * freeSymbol.hh (class FreeSymbol): decl for generateCode() 3020 replaces that for generateBody() 3021 3022 * freeSymbol.cc (generateCode): added; replaces generateBody() 3023 30241999-11-03 Steven Eker <eker@goo.csl.sri.com> 3025 3026 * freeSymbol.hh (class FreeSymbol): updated decl for 3027 memoStrategy() 3028 3029 * freeSymbol.cc (complexStrategy): simplified using revised 3030 MemoTable 3031 (memoStrategy): simplified using revised MemoTable 3032 30331999-11-02 Steven Eker <eker@goo.csl.sri.com> 3034 3035 * freeSymbol.cc (complexStrategy): no longer try the memo table 3036 before reducing arguments; this departs from the OBJ3 practice but 3037 avoids difficulties regarding whether to normalize before trying 3038 the memo table 3039 (memoStrategy): try memo table before each rewrite at top attempt 3040 rather than after each argument reduction 3041 30421999-10-29 Steven Eker <eker@goo.csl.sri.com> 3043 3044 * freeSymbol.cc (FreeSymbol): init Symbol 3045 3046 * freeSymbol.hh (class FreeSymbol): revert to base Symbol 3047 3048 * freeSymbol.cc (FreeSymbol): init StandardSymbol rather than Symbol 3049 3050 * freeSymbol.hh (class FreeSymbol): derive from StandardSymbol 3051 rather than Symbol and Strategy 3052 30531999-10-27 Steven Eker <eker@goo.csl.sri.com> 3054 3055 * freeTerm.cc (markEagerArguments): added static_cast<FreeSymbol*>() 3056 3057 * freeSymbol.cc (FreeSymbol): don't pass theory arg, pass memoFlag 3058 arg to Symbol 3059 deleted freeTheoryString 3060 3061 * freeSymbol.hh (class FreeSymbol): derive from Strategy (now that 3062 this is no longer a base of Symbol) 3063 (class FreeSymbol): deleted decl for static data member 3064 freeTheoryString 3065 3066===================================Engine53================================================== 3067 30681999-10-26 Steven Eker <eker@goo.csl.sri.com> 3069 3070 * freeLhsCompiler.cc (analyseConstraintPropagation): 3071 VariableTerm::dynamicCast() -> dynamic_cast<VariableTerm*>() 3072 (compileRemainder): VariableTerm::dynamicCast() -> 3073 dynamic_cast<VariableTerm*>() 3074 (compileLhs): VariableTerm::dynamicCast() -> 3075 dynamic_cast<VariableTerm*>() 3076 (scanFreeSkeleton): FreeTerm::dynamicCast() -> 3077 dynamic_cast<FreeTerm*>() 3078 3079 * freeNet.cc (compileEquations): FreeTerm::dynamicCast() -> 3080 dynamic_cast<FreeTerm*>() (*2) 3081 (findBestPosition): FreeTerm::dynamicCast() -> 3082 dynamic_cast<FreeTerm*>() 3083 (buildNet): FreeSymbol::dynamicCast() -> 3084 dynamic_cast<FreeSymbol*>() 3085 (setVisitedFlags): FreeTerm::dynamicCast() -> 3086 dynamic_cast<FreeTerm*>() (*2) 3087 (allocateSlot): FreeTerm::dynamicCast() -> 3088 dynamic_cast<FreeTerm*>() 3089 (buildPatternVector): FreeTerm::dynamicCast() -> 3090 dynamic_cast<FreeTerm*>() 3091 3092 * freeTerm.cc (locateSubterm): FreeTerm::dynamicCast() -> 3093 dynamic_cast<FreeTerm*>() 3094 (findActiveSlots): FreeTerm::dynamicCast() -> 3095 dynamic_cast<FreeTerm*>() 3096 (compileRhsAliens): FreeTerm::dynamicCast() -> 3097 dynamic_cast<FreeTerm*>() 3098 (compileRhsAliens): VariableTerm::dynamicCast() -> 3099 dynamic_cast<VariableTerm*>() 3100 (compileRhsFree): FreeTerm::dynamicCast() -> 3101 dynamic_cast<FreeTerm*>() 3102 (compileRhsFree): VariableTerm::dynamicCast() -> 3103 dynamic_cast<VariableTerm*>() 3104 3105 * freeTerm.hh (dynamicCast): deleted 3106 (class FreeTerm): deleted decl for dynamicCast() 3107 3108 * freeSymbol.hh (dynamicCast): deleted 3109 (class FreeSymbol): deleted decl for dynamicCast() 3110 3111 * freeSymbol.cc (complexStrategy): AdvisoryCheck() -> 3112 IssueAdvisory() 3113 (memoStrategy): AdvisoryCheck() -> IssueAdvisory() 3114 31151999-10-25 Steven Eker <eker@goo.csl.sri.com> 3116 3117 * freeRemainder.cc (slowMatchReplace2): updated call to 3118 tracePreEqRewrite() 3119 3120 * freeSymbol.hh (class FreeSymbol): added decl for memoStrategy() 3121 3122 * freeSymbol.cc (complexStrategy): no longer do memo stuff here 3123 (memoStrategy): added 3124 31251999-10-22 Steven Eker <eker@goo.csl.sri.com> 3126 3127 * freeSymbol.cc (FreeSymbol): take memoFlag arg 3128 (complexStrategy): handle memoization 3129 (newFreeSymbol): have to take memoFlag onto account when deciding 3130 when to check for non-standard strategy 3131 3132 * freeSymbol.hh (class FreeSymbol): updated decls for FreeSymbol() 3133 and newFreeSymbol() 3134 3135 * freeSymbol.cc (newFreeSymbol): take memoFlag arg 3136 31371999-10-19 Steven Eker <eker@goo.csl.sri.com> 3138 3139 * freeDagNode.cc (getHashValue): 3140 31411999-10-18 Steven Eker <eker@goo.csl.sri.com> 3142 3143 * freeDagNode.hh (class FreeDagNode): added hashCache array to 3144 data member union 3145 3146===================================Engine52================================================== 3147 31481999-08-26 Steven Eker <eker@goo.csl.sri.com> 3149 3150 * freeDagNode.cc (markArguments): try using typeid() as 3151 dynamic_cast is painfully slow 3152 (markArguments): unmade change as typeid() causes more reg window 3153 traps 3154 31551999-08-02 Steven Eker <eker@goo.csl.sri.com> 3156 3157 * freeNet.hh (class FreeNet): tripleLeq() -> tripleLt() 3158 3159 * freeNet.cc (buildNet): tripleLeq() -> tripleLt() 3160 (tripleLeq): -> tripleLt() 3161 31621999-07-30 Steven Eker <eker@goo.csl.sri.com> 3163 3164 * freeNet.hh (class FreeNet): replaced decl for tripleCompare() 3165 with decl for tripleLeq() 3166 3167 * freeNet.cc (buildNet): use STL sort function 3168 (tripleCompare): becomes tripleLeq() 3169 31701999-07-28 Steven Eker <eker@goo.csl.sri.com> 3171 3172 * freeDagNode.cc (markArguments): use dynamic_cast rather than 3173 comparison of pointers to member functions to figure out if we can 3174 tail recurse 3175 3176 * freeDagNode.hh (class FreeDagNode): made FreeUnarySymbol and 3177 FreeBinarySymbol friends 3178 3179===================================Engine51================================================== 3180 31811999-07-19 Steven Eker <eker@goo.csl.sri.com> 3182 3183 * freeNet.cc (generateBody): handle the case where we have an 3184 empty net but nonzero applicables - eg k = f(a) or f(X) = k 3185 31861999-07-15 Steven Eker <eker@goo.csl.sri.com> 3187 3188 * freeSymbol.cc (generateBody): void* -> char* in generated code 3189 (generateBody): added needed casts in generated code 3190 31911999-06-29 Steven Eker <eker@goo.csl.sri.com> 3192 3193 * freeNet.hh (class FreeNet): upadted decl for generateBody() 3194 3195 * freeRemainder.hh (class FreeRemainder): updated decl for 3196 generateRemainder() 3197 3198 * freeRemainder.cc (generateRemainder): return number of safe 3199 slots needed 3200 3201 * freeNet.cc (generateBody): return maxSafe 3202 3203 * freeSymbol.hh (class FreeSymbol): updates decl for generateBody() 3204 3205 * freeSymbol.cc (generateBody): print maxSafe define to hfile 3206 32071999-06-28 Steven Eker <eker@goo.csl.sri.com> 3208 3209 * freeRemainder.hh (class FreeRemainder): updated decl for generateRemainder() 3210 3211 * freeRemainder.cc (generateRemainder): take useArgList arg 3212 3213 * freeNet.hh (class FreeNet): upaded decls of generateNode() and 3214 generateBranch() 3215 3216 * freeNet.cc (generateBranch): keep track of which ap lists use 3217 arg list and which consider slot 0 to have been reused 3218 (generateNode): carry aps arg arround 3219 (generateBody): pass useArgList flag to generateRemainder() 3220 3221 * freeSymbol.cc (generateBody): reorganized fail case to to handle 3222 GC case properly 3223 32241999-06-25 Steven Eker <eker@goo.csl.sri.com> 3225 3226 * freeRemainder.cc (generateRemainder): pass lhs top symbol to 3227 generateRhs() to enable tail recursion elimination 3228 3229 * freeSymbol.cc (generateBody): use g.memNext and g.memEnd 3230 32311999-06-24 Steven Eker <eker@goo.csl.sri.com> 3232 3233 * freeSymbol.cc (generateBody): generate code to allocate new dag 3234 node 3235 32361999-06-22 Steven Eker <eker@goo.csl.sri.com> 3237 3238 * freeRemainder.cc (generateRemainder): call generateRhs(); 3239 32401999-06-18 Steven Eker <eker@goo.csl.sri.com> 3241 3242 * freeNet.cc (buildApplicable): rewritten to check existing 3243 applicable lists and avoid generating duplicates 3244 3245 * freeRemainder.cc (generateRemainder): added 3246 3247 * freeNet.cc (generateBody): use generateRemainder() 3248 3249 * freeRemainder.hh (class FreeRemainder): added decl for 3250 generateRemainder() 3251 32521999-06-15 Steven Eker <eker@goo.csl.sri.com> 3253 3254 * freeNet.hh (class FreeNet): added decls for gatherAlternatives() 3255 and gatherAlternatives2(); deleted decl for isSimple() 3256 3257 * freeNet.cc (isSimple): deleted 3258 (generateNode): rewriting to generate switch statements 3259 (gatherAlternatives): added 3260 (gatherAlternatives2): added 3261 32621999-06-14 Steven Eker <eker@goo.csl.sri.com> 3263 3264 * freeNet.cc (generateNode): optimize case where both fail 3265 branches are simple 3266 (isSimple): allow fail branches in simple node to be a remainder 3267 rather than just a fail 3268 3269 * freeNet.hh (class FreeNet): added decl for isSimple() 3270 3271 * freeNet.cc (generateNode): optimize code in fail vs simple 3272 equality branch case using isSimple() 3273 (isSimple): added 3274 32751999-06-11 Steven Eker <eker@goo.csl.sri.com> 3276 3277 * freeNet.cc (generateNode): added 3278 (generateBranch): added 3279 (generateBody): added 3280 3281 * freeSymbol.hh (class FreeSymbol): added decl for generateBody() 3282 3283 * freeSymbol.cc (generateBody): added 3284 3285===================================Maude 1.0.3 released======================================= 3286 32871999-06-01 Steven Eker <eker@goo.csl.sri.com> 3288 3289 * freeRhsAutomaton.hh (class FreeRhsAutomaton): updated decl for 3290 fillOutArgs() 3291 3292 * freeRhsAutomaton.cc (fillOutArgs): replaced SPEED_HACK with 3293 CONST_VECTOR_HACK 3294 (construct): replaced SPEED_HACK with CONST_VECTOR_HACK 3295 (fillOutArgs): made 2nd arg const 3296 (replace): replaced SPEED_HACK with CONST_VECTOR_HACK 3297 3298 * freeRemainder.hh (fastMatchReplace): replaced SPEED_HACKs with 3299 CONST_VECTOR_HACKs 3300 33011999-05-12 Steven Eker <eker@goo.csl.sri.com> 3302 3303 * freeSymbol.hh (class FreeSymbol): computeTrueSort() -> 3304 normalizeAndComputeTrueSort() 3305 3306 * freeSymbol.cc (computeTrueSort): becomes 3307 normalizeAndComputeTrueSort() 3308 (normalizeAndComputeTrueSort): use fastComputeTrueSort() 3309 33101999-05-11 Steven Eker <eker@goo.csl.sri.com> 3311 3312 * freeNetExec.cc (applyReplace2): try reversing symbol test 3313 if-then-else 3314 (applyReplace2): unmade change; test was the best way around originally 3315 3316 * freeSymbol.hh (class FreeSymbol): added decl for newFreeSymbol() 3317 33181999-05-10 Steven Eker <eker@goo.csl.sri.com> 3319 3320 * freeBinarySymbol.cc: created 3321 3322 * freeBinarySymbol.hh: created 3323 3324 * freeUnarySymbol.cc: created 3325 3326 * freeUnarySymbol.hh: created 3327 3328 * freeSymbol.cc (eqRewrite): added test for nrArgs > 0 and 3329 replaced for loop with do-while loop 3330 (eqRewrite): unmade change as it appeas to lose 3331 (newFreeSymbol): added 3332 3333===================================Engine48================================================== 3334 33351999-05-07 Steven Eker <eker@goo.csl.sri.com> 3336 3337 * freeNet.hh (applyReplace): reverse test; this apparently has an 3338 impact on performance; put most important branch first for ?: and 3339 if-then-else 3340 3341 * freeSymbol.cc (eqRewrite): use normal applyReplace() which is 3342 (once again) an inlined wrapper for an outlined version 3343 3344 * freeNet.cc: revert 3345 3346 * freeNet.hh: revert 3347 3348 * freeNet.cc (outlineApplyReplace): added 3349 3350 * freeSymbol.cc (complexStrategy): deleted 3351 (eqRewrite): reverted 3352 (eqRewrite): use outlineApplyReplace() in complex strat case 3353 3354 * freeNet2.hh: resurected 3355 3356 * freeNet.cc: implement freeNet2.hh again 3357 3358 * freeNet.hh (class FreeNet): deleted applyReplace() wrapper and 3359 decl; inserted decl for outlineApplyReplace() 3360 33611999-05-06 Steven Eker <eker@goo.csl.sri.com> 3362 3363 * freeSymbol.cc (complexStrategy): created to outline complex 3364 strategy case and reduce eqRewrite stack frame size for non-reg 3365 window machines 3366 (eqRewrite): use complexStrategy() 3367 3368 * freeNet.cc: no longer implement freeNet2.hh 3369 3370 * freeNet.hh (applyReplace): moved here; now jsut a wrapper for 3371 applyReplace2() 3372 3373 * freeNet2.hh: deleted 3374 3375 * freeNetExec.cc: created to contain outlined applyReplace2() 3376 3377 * freeSymbol.cc (eqRewrite): try outlining call to applyReplace() 3378 since this makes stackframe big (144bytes vs 112bytes on sparc) on what can 3379 be a higly recursive function 3380 33811999-05-05 Steven Eker <eker@goo.csl.sri.com> 3382 3383 * freeRemainder.cc (FreeRemainder): check to see if variables 3384 sort component is error-free and revoke superfast treatment if not 3385 3386 * freeRemainder.hh (fastMatchReplace): remove check for arg in 3387 error sort in superfast case; we now assume component is error-free 3388 33891999-04-28 Steven Eker <eker@goo.csl.sri.com> 3390 3391 * freeDagNode.cc (markArguments): try new tail recursion 3392 elimination scheme that does highly dubious comparison on pointers 3393 to virtual functions 3394 (markArguments): use markArgument() rather than mark() on last arg 3395 in != case inorder to share cose with == case. 3396 33971999-04-27 Steven Eker <eker@goo.csl.sri.com> 3398 3399 * freeDagNode.cc (markArguments): added tail recursion 3400 eliminiation hack for 1 and 2 arg cases 3401 3402 * freeNet2.hh (applyReplace): (SPEED_HACKS version) experimentally 3403 merged the "no patterns have free symbols" with the start of the 3404 "at least one pattern has free symbols" to simplify control flow 3405 (applyReplace): unmade change as quantify shows that it loses ever 3406 so slightly 3407 3408===================================Engine48================================================== 3409===================================Maude 1.0.2 released======================================= 3410===================================Maude 1.0.1 released======================================= 3411 34121999-02-25 Steven Eker <eker@goo.csl.sri.com> 3413 3414 * freeNet.hh: removed extreme pointerization SPEED_HACK due to 3415 slowness 3416 3417 * freeNet2.hh: removed extreme pointerization SPEED_HACK due to 3418 slowness 3419 3420 * freeNet.cc: removed extreme pointerization SPEED_HACK due to 3421 slowness 3422 3423 * freeNet2.hh (applyReplace): optimized using extreme 3424 pointerization SPEED_HACK for TestNode arcs 3425 3426 * freeNet.hh (class FreeNet): deleted dummy field from TestNode 3427 3428 * freeNet.cc (compileEquations): extreme pointerization SPEED_HACK 3429 for TestNode arcs 3430 3431 * freeRemainder.cc (slowMatchReplace2): made const 3432 (slowMatchReplace): made const 3433 3434 * freeRemainder.hh (fastMatchReplace): added consts 3435 (class FreeRemainder): added consts decl 3436 3437 * freeNet.cc (compileEquations): fill out fastApplicable in 3438 SPEED_HACKS case 3439 3440 * freeNet2.hh (applyReplace): use fastApplicable in SPEED_HACKS 3441 case and revert to old code in debug case 3442 3443 * freeNet.hh (class FreeNet): have fastApplicable for SPEED_HACKS 3444 case but keep applicable for net construction 3445 34461999-02-23 Steven Eker <eker@goo.csl.sri.com> 3447 3448 * freeNet2.hh (applyReplace): rewrote both versions to use new 3449 applicable vector 3450 3451 * freeNet.hh (class FreeNet): applicable becomes a 3452 Vector<Vector<FreeRemainder*> > 3453 34541999-02-19 Steven Eker <eker@goo.csl.sri.com> 3455 3456 * freeNet2.hh (applyReplace): unmade previous change as quantify 3457 shows no change in # of cycles 3458 34591999-02-18 Steven Eker <eker@goo.csl.sri.com> 3460 3461 * freeNet2.hh (applyReplace): added eqIndices SPEED_HACK to share 3462 lookup on eqIndicespyt between length() and operator [] 3463 3464 * freeLhsAutomaton.cc (match): use isNull() (5 places) 3465 3466 * freeRemainder.cc (slowMatchReplace2): use isNull() (4 places) 3467 3468===================================VectorExperiment========================================== 3469 34701999-01-16 Steven Eker <eker@goo.csl.sri.com> 3471 3472 * freeTerm.hh (class FreeTerm): made slotIndex a short and 3473 visitedFlag a Bool to save memory 3474 3475===========================Engine46=========================================================== 3476 3477Wed Nov 25 10:59:26 1998 Steven Eker <eker@lilac.csl.sri.com> 3478 3479 * freeRemainder.cc (slowMatchReplace2): first attempt at using 3480 traceAbort(); we have introduced a suble bug that we will worry 3481 about later 3482 (slowMatchReplace2): do tracePreEqRewrite() before traceAbort() 3483 and copyProblemBindings() after tracing stuff 3484 (slowMatchReplace2): reorg of control structures using gotos (ugly 3485 but effective) 3486 (slowMatchReplace2): fix afore-mentioned bug in brute force way - 3487 always restore the stack after a checkCondition() because we may 3488 end up aborting 3489 (slowMatchReplace2): removed gotos and put back deletes 3490 3491Tue Nov 24 18:09:00 1998 Steven Eker <eker@lilac.csl.sri.com> 3492 3493 * freeRemainder.cc (slowMatchReplace2): fix longstanding and very 3494 nasty re-entrancy bug by saving stack before evaluating a 3495 condition and restoring it if we fail 3496 3497Mon Nov 16 10:00:50 1998 Steven Eker <eker@lilac.csl.sri.com> 3498 3499 * freeRemainder.cc (slowMatchReplace2): use getTraceStatus() in 3500 place of traceStatus() 3501 3502 * freeRemainder.hh (fastMatchReplace): use getTraceStatus() in 3503 place of traceStatus() 3504 3505Fri Nov 6 15:13:05 1998 Steven Eker <eker@lilac.csl.sri.com> 3506 3507 * freeTerm.hh (class FreeTerm): deepCopy() decl -> deepCopy2() 3508 3509 * freeTerm.cc (deepCopy): -> deepCopy2() 3510 3511===========================Engine43=========================================================== 3512 3513Thu Oct 8 11:08:18 1998 Steven Eker <eker@lilac.csl.sri.com> 3514 3515 * freeLhsCompiler.cc (analyseConstraintPropagation): static_cast 3516 -> const_cast 3517 3518 * freeTerm.cc (compareArguments): inserted const_cast 3519 (subsumes): inserted const_cast 3520 (earlyMatchFailOnInstanceOf): inserted const_cast 3521 3522 * freeDagNode.hh (argArray): replaced static_cast with const_cast 3523 3524 * freeSymbol.hh (class FreeSymbol): deleted static data member 3525 sortIndexBuffer 3526 3527 * freeSymbol.cc: deleted sortIndexBuffer 3528 (FreeSymbol): don't expand sortIndexBuffer 3529 3530===========================Engine41=========================================================== 3531 3532Fri Sep 25 10:30:44 1998 Steven Eker <eker@lilac.csl.sri.com> 3533 3534 * freeNet2.hh (applyReplace): don't check context.traceStatus() 3535 here 3536 (applyReplace): Reason for counter-intuitive speed up when moving 3537 test into loop is that loop (almost) always executes exactly 1 3538 iteration. Make use of the fast that loop never executes 0 3539 iterations by turning it into do-while loop 3540 3541 * freeRemainder.hh (fastMatchReplace): try checking 3542 context.traceStatus() here 3543 3544 * freeNet2.hh (applyReplace): highly speculative reorganization 3545 aimed at improving performance in non-constant case 3546 (applyReplace): Slower! - proabably extra branch around else case; 3547 Try hoisting code after branch and specializing - since after 3548 suceessfully matching a symbol we never go strait to failure. 3549 (applyReplace): Faster! - try horrible goto hack to simplify main 3550 loop 3551 (applyReplace): Slower; try simplified goto trick 3552 (applyReplace): Much slower; reverted to hoisted code version 3553 (applyReplace): Try rearrange the 6 assignments at the top of main 3554 loop to maximize paralleism on superscalars (and make use of load 3555 delay stots on processors that have them) 3556 (applyReplace): Slower! assume that the write in to memory via a 3557 pointer messes up the compilers data flow analysis; revert 3558 (applyReplace): Try hack to avoid checking net.length() 3559 3560 * freeRemainder.hh (fastMatchReplace): reversed previous hack 3561 because it makes things every so slightly slower; try combining 3562 rather than duplicating code. 3563 (fastMatchReplace): even slower! revert to Wednesdays version 3564 (fastMatchReplace): try reversing then and else parts inside loop 3565 3566Thu Sep 24 20:47:48 1998 Steven Eker <eker@lilac.csl.sri.com> 3567 3568 * freeRemainder.hh (fastMatchReplace): very experimental speed 3569 hack duplicating code in the hope of reducing branching 3570 3571Wed Sep 23 10:16:56 1998 Steven Eker <eker@lilac.csl.sri.com> 3572 3573 * freeRemainder.hh (fastMatchReplace): made slowMatchReplace() 3574 public so that we can call in from FreeNet::applyReplace() 3575 3576 * freeRemainder.cc (FreeRemainder): added test for super-fast status 3577 (slowMatchReplace2): reorganized sort test 3578 (dump): dump fast and foreign flags 3579 3580 * freeNet2.hh (applyReplace): (both versions) split equations loop 3581 into slowMatchReplace() and fastMatchReplace() versions 3582 3583 * freeRemainder.hh (fastMatchReplace): implemented "super-fast: 3584 mode; no longer check context.traceStatus(); fast flag now an int 3585 3586Mon Sep 21 10:09:44 1998 Steven Eker <eker@lilac.csl.sri.com> 3587 3588 * freeSymbol.cc (computeBaseSort): remember to return after nrArgs 3589 == 0 hack! 3590 3591Fri Sep 18 16:53:25 1998 Steven Eker <eker@lilac.csl.sri.com> 3592 3593 * freeSymbol.cc (computeBaseSort): hack for nrArgs == 0 case; 3594 eventually this should be dealt with by uniqueSort mechanism and 3595 we will just have an Assert that nrArgs > 0 3596 3597Thu Sep 17 17:41:51 1998 Steven Eker <eker@lilac.csl.sri.com> 3598 3599 * freeDagNode.cc (overwriteWithClone): setSortInfo() -> 3600 setSortIndex() 3601 (makeClone): setSortInfo() -> setSortIndex() 3602 3603 * freeSymbol.cc (computeBaseSort): rewritten using traverse(), 3604 setSortIndex() and lookupSortIndex() 3605 3606 * freeLhsAutomaton.cc (match): use DagNode::leq() 3607 3608 * freeRemainder.cc (slowMatchReplace2): use DagNode::leq() 3609 3610 * freeRemainder.hh (fastMatchReplace): use DagNode::leq() 3611 3612Fri Sep 11 16:35:41 1998 Steven Eker <eker@lilac.csl.sri.com> 3613 3614 * freeLhsAutomaton.cc (freeSubterms): set sort rather than 3615 sortCode 3616 (match): use <= on (DagNode*, Sort&) instead of sortCode 3617 (dump): sort rather than sortCode 3618 3619 * freeRemainder.cc (FreeRemainder): set sort rather than sortCode 3620 (slowMatchReplace2): use <= on (DagNode*, Sort&) instead of 3621 sortCode 3622 (dump): sort rather than sortCode 3623 3624 * freeRemainder.hh (fastMatchReplace): use <= on (DagNode*, Sort&) 3625 instead of sortCode 3626 3627 * freeLhsAutomaton.hh (class FreeLhsAutomaton): 3628 FreeVariable::sortCode becomes FreeVariable::sort 3629 3630===========================Engine40=========================================================== 3631 3632Mon Jul 20 19:16:50 1998 Steven Eker <eker@lilac.csl.sri.com> 3633 3634 * freeTerm.cc (FreeTerm): added new ctor 3635 (deepCopy): added 3636 3637 * freeTerm.hh (class FreeTerm): added decl for deepCopy() 3638 (class FreeTerm): delete bad initializer from arguments arg of 3639 FreeTerm() (g++ should not have accepted this!) 3640 3641===========================Engine39=========================================================== 3642 3643Wed Jun 10 11:24:06 1998 Steven Eker <eker@lilac.csl.sri.com> 3644 3645 * freeTerm.hh (class FreeTerm): updated normalize() decl 3646 3647 * freeTerm.cc: IntSet -> NatSet 3648 (normalize): compute changed flag 3649 3650 * freeLhsCompiler.cc: IntSet -> NatSet 3651 3652 * freeDagNode.cc: deleted #include "intSet.hh" 3653 3654 * freeTerm.hh: IntSet -> NatSet 3655 3656===========================Engine38=========================================================== 3657 3658Fri Feb 20 16:18:38 1998 Steven Eker <eker@lilac.csl.sri.com> 3659 3660 * freeDagNode.cc (stackArguments): only stack arguments that have 3661 not been flagged as unstackable 3662 (stackArguments): simplified & optimized 3663 3664===========================Engine36=========================================================== 3665 3666Wed Feb 18 10:23:12 1998 Steven Eker <eker@lilac.csl.sri.com> 3667 3668 * freeNet.cc (compileEquations): added code to pointerize slots 3669 and positions in SPEED_HACKS case 3670 (dump): dump pointerized slots and positions correctly 3671 3672 * freeNet2.hh (applyReplace): revert to reorganized loop; although 3673 this is very slightly slower on dec example in wins in fibo 3674 example; the partially optimized loop is the same as the 3675 reorganized loop but uglier 3676 (applyReplace): split into two versions; a super-fast, 3677 super-hairy, partly pointerized version for optimized builds 3678 and a more or less straight-forward version for debugging 3679 3680Sat Feb 14 19:56:53 1998 Steven Eker <eker@lilac.csl.sri.com> 3681 3682 * freeNet2.hh (applyReplace): reorganized loop using new variables 3683 ds to store d->symbol() and p to store n->position in the hope of 3684 avoiding reloading d->symbol() after the d->symbol() != n->symbol case 3685 (applyReplace): partly reversed previous change since things got 3686 slower - maybe due to messing up branch delay slots 3687 3688Fri Feb 13 09:50:45 1998 Steven Eker <eker@lilac.csl.sri.com> 3689 3690 * freeRemainder.cc (~FreeRemainder): added 3691 3692 * freeRemainder.hh (class FreeRemainder): added decl for ~FreeRemainder() 3693 3694 * freeNet.hh (class FreeNet): delete ctor decl as default will do 3695 (class FreeNet): added anon unions to struct TestNode for future 3696 position/slot pointerization 3697 3698 * freeNet.cc (~FreeNet): implemented 3699 3700Thu Feb 12 18:24:52 1998 Steven Eker <eker@lilac.csl.sri.com> 3701 3702 * freeLhsAutomaton.cc (~FreeLhsAutomaton): implemented 3703 3704Wed Feb 11 17:07:55 1998 Steven Eker <eker@lilac.csl.sri.com> 3705 3706 * freeRemainder.cc (slowMatchReplace2): compare() != 0 replaced by 3707 !equal() (2 places) 3708 3709 * freeLhsAutomaton.cc (match): compare() != 0 replaced by !equal() 3710 (3 places) 3711 3712 * freeRemainder.cc (slowMatchReplace2): use delete rather than 3713 calling deepSelfDestruct() (4 places) 3714 3715===========================Engine35=========================================================== 3716 3717Thu Dec 4 12:50:37 1997 Steven Eker <eker@lilac.csl.sri.com> 3718 3719 * freeSymbol.cc (FreeSymbol): deleted inert arg 3720 3721 * freeSymbol.hh (class FreeSymbol): deleted inert 3722 arg from ctor decl 3723 3724Tue Dec 2 16:35:13 1997 Steven Eker <eker@lilac.csl.sri.com> 3725 3726 * freeSymbol.cc (eqRewrite): use copyAndReduce() 3727 (eqRewrite): call repudiateSortInfo() after copying and reducing 3728 in the case where we abandon the users strategy 3729 3730Wed Nov 26 17:59:06 1997 Steven Eker <eker@lilac.csl.sri.com> 3731 3732 * freeDagNode.cc (copyEagerUptoReduced2): use class Strategy stuff 3733 3734 * freeTerm.cc (findEagerVariables): use class Strategy stuff 3735 (markEagerArguments): use class Strategy stuff 3736 3737 * freeSymbol.cc: (eqRewrite): rewritten to use class Strategy stuff 3738 3739 * freeSymbol.hh (class FreeSymbol): deleted decl for ~FreeSymbol() 3740 3741 * freeSymbol.cc (FreeSymbol): use Strategy::setStrategy(); this 3742 eliminates most of the code. 3743 (~FreeSymbol): deleted 3744 3745 * freeSymbol.hh (class FreeSymbol): delete decls for eagerSet(), 3746 evaluatedSet() and data members strat, eager, evaluated. 3747 (eagerSet): deleted 3748 (evaluatedSet): deleted 3749 3750Mon Nov 24 19:51:34 1997 Steven Eker <eker@lilac.csl.sri.com> 3751 3752 * freeRhsAutomaton.cc (construct): use rhsAutomaton::buildAliens() 3753 (replace): use rhsAutomaton::buildAliens() 3754 (dump): use RhsAutomaton::dump() 3755 3756 * freeRhsAutomaton.hh (addAlien): deleted 3757 (class FreeRhsAutomaton): deleted aliens data member and 3758 addAlien() decl 3759 3760Sun Nov 23 16:47:42 1997 Steven Eker <eker@lilac.csl.sri.com> 3761 3762 * freeRemainder.cc (dump): use new LhsAutomaton::dump() convention 3763 3764 * freeLhsAutomaton.cc (dump): rewritten 3765 3766 * freeRhsAutomaton.cc (dump): rewritten 3767 3768 * freeRhsAutomaton.hh (class FreeRhsAutomaton): updated dump() 3769 decl 3770 3771 * freeLhsAutomaton.hh (class FreeLhsAutomaton): updated dump() 3772 decl 3773 3774===========================Engine33=========================================================== 3775 3776Tue Oct 21 11:56:14 1997 Steven Eker <eker@lilac.csl.sri.com> 3777 3778 * freeTerm.cc (dagify2): switch to new convention 3779 3780 * freeTerm.hh (class FreeTerm): witch dagify2() decl to 3781 new convention 3782 3783Thu Oct 16 12:19:41 1997 Steven Eker <eker@lilac.csl.sri.com> 3784 3785 * freeSymbol.hh (class FreeSymbol): freeTheoryString changed from 3786 array to pointer 3787 3788 * freeSymbol.cc: freeTheoryString changed from array to pointer 3789 3790Wed Oct 15 10:03:24 1997 Steven Eker <eker@lilac.csl.sri.com> 3791 3792 * freeNet.hh (class FreeNet): deleted decl for isFreeTerm() 3793 3794 * freeNet.cc (isFreeTerm): use FreeTerm::dynamicCast() 3795 (buildNet): use FreeSymbol::dynamicCast() 3796 (compileEquations): use FreeTerm::dynamicCast() (2 places) 3797 (findBestPosition): use FreeTerm::dynamicCast() 3798 (setVisitedFlags): use FreeTerm::dynamicCast() (2 places) 3799 (allocateSlot): use FreeTerm::dynamicCast() 3800 (buildPatternVector): use FreeTerm::dynamicCast() 3801 (isFreeTerm): deleted 3802 3803 * freeLhsCompiler.cc (analyseConstraintPropagation): use 3804 VariableTerm::dynamicCast() 3805 (compileRemainder): use VariableTerm::dynamicCast() 3806 (compileLhs): use VariableTerm::dynamicCast() 3807 (scanFreeSkeleton): use VariableTerm::dynamicCast() 3808 3809 * freeTerm.cc (compileRhsFree): rewritten using 3810 VariableTerm::dynamicCast() and FreeTerm::dynamicCast() 3811 (compileRhsAliens): rewritten using 3812 VariableTerm::dynamicCast() and FreeTerm::dynamicCast() 3813 3814 * freeTerm.hh (class FreeTerm): added decl for dynamicCast() 3815 (dynamicCast): added 3816 3817 * freeSymbol.hh (class FreeSymbol): added decl for dynamicCast() 3818 (dynamicCast): added 3819 3820 * freeTerm.cc (locateSubterm): use FreeTerm::dynamicCast() 3821 (findActiveSlots): simplified using FreeTerm::dynamicCast() 3822 3823 * freeSymbol.cc (computeTrueSort): replaced old style cast 3824 (eqRewrite): replaced old style cast 3825 (computeBaseSort): replaced old style cast 3826 3827 * freeDagNode.hh (argArray): replaced old style cast 3828 3829 * freeSymbol.cc (FreeSymbol): use new Symbol ctor; expand static 3830 sortIndexBuffer if too small for current arity 3831 3832 * freeSymbol.hh (class FreeSymbol): added static data member freeTheoryString 3833 (class FreeSymbol): drop constructor flag from ctor arg list 3834 (class FreeSymbol): make sortIndexBuffer static 3835 3836Fri Oct 10 18:22:39 1997 Steven Eker <eker@lilac.csl.sri.com> 3837 3838 * freeRemainder.cc (dump): index2Symbol -> index2Variable 3839 (slowMatchReplace2): symbolCount() -> nrVariables() 3840 3841 * freeLhsAutomaton.cc (dump): VariableIndex -> VariableInfo 3842 (dump): index2Symbol -> index2Variable 3843 3844 * freeLhsAutomaton.hh (class FreeLhsAutomaton): VariableIndex -> 3845 VariableInfo 3846 3847===========================Engine30=========================================================== 3848 3849Thu Oct 9 11:48:31 1997 Steven Eker <eker@lilac.csl.sri.com> 3850 3851 * freeRhsAutomaton.cc (fillOutArgs): optimized the nrArgs = 0 case 3852 (construct): use fillOutArgs() 3853 3854 * freeRhsAutomaton.hh (class FreeRhsAutomaton): added decl for fillOutArgs() 3855 3856 * freeRhsAutomaton.cc (replace): for some strange reason splitting 3857 off final iteration made things much slower! try rearranging loop 3858 (replace): revert to original version: original loop is eather 3859 careful to utilize branch slots I think! 3860 (replace): Added more SPEED_HACKS 3861 (fillOutArgs): added 3862 (replace): use fillOutArgs() 3863 3864 * freeDagNode.cc (FreeDagNode): elminated test since destructor 3865 should only be called on free dag nodes with external storage; 3866 added Assert to check this. 3867 3868 * freeRhsAutomaton.cc (replace): split off final iteration for efficiency 3869 3870 * freeDagNode.hh (class FreeDagNode): external changed to ArgVec<DagNode*> 3871 (FreeDagNode): call initialize() on external 3872 (class FreeDagNode): unmade change; Because free matcher keeps 3873 stack of pointers to raw argument arrays we can't safely use 3874 ArgVec as the position of the raw argument array will move 3875 during a garbage collect; 3876 (FreeDagNode): unmade change 3877 3878Tue Oct 7 15:20:02 1997 Steven Eker <eker@lilac.csl.sri.com> 3879 3880 * freeSymbol.cc (makeDagNode): added 3881 3882 * freeSymbol.hh (class FreeSymbol): added decl for makeDagNode() 3883 3884Fri Oct 3 19:13:01 1997 Steven Eker <eker@lilac.csl.sri.com> 3885 3886 * freeTerm.cc (compileRhs): DataSet -> TermSet 3887 (compileRhsAliens): DataSet -> TermSet 3888 (compileRhsFree): DataSet -> TermSet 3889 (dagify2): DataSet -> TermSet 3890 3891 * freeTerm.hh (class FreeTerm): DataSet -> TermSet 3892 3893===========================Engine29=========================================================== 3894 3895Thu Oct 2 17:02:57 1997 Steven Eker <eker@lilac.csl.sri.com> 3896 3897 * freeTerm.hh (class FreeTerm): updated compileRhsAliens() decl 3898 (class FreeTerm): updated compileRhsFree() decl 3899 3900 * freeTerm.cc (compileRhs): modified to use DataSet& 3901 (compileRhsAliens): modified to use DataSet& 3902 (compileRhsFree): modified to use DataSet&; const removed; cast removed 3903 3904 * freeTerm.hh (class FreeTerm): updated compileRhs() decl 3905 3906Tue Sep 30 11:03:03 1997 Steven Eker <eker@lilac.csl.sri.com> 3907 3908 * freeTerm.cc (dagify2): adapted from dagify() 3909 3910 * freeTerm.hh (class FreeTerm): dagify() decl changed to dagify2() 3911 3912 * freeTerm.cc (normalize): now compute hash value 3913 3914Thu Sep 25 16:29:56 1997 Steven Eker <eker@lilac.csl.sri.com> 3915 3916 * freeNet.cc (compileEquations): use getEquations() 3917 3918===========================Engine28=========================================================== 3919 3920Sat Aug 30 15:10:32 1997 Steven Eker <eker@lilac.csl.sri.com> 3921 3922 * freeSymbol.cc (computeBaseSort): rewrote union case to use 3923 Vector<SortCode> version of lookupUnionSort() 3924 3925===========================Engine27=========================================================== 3926 3927Tue Aug 5 14:06:08 1997 Steven Eker <eker@lilac.csl.sri.com> 3928 3929 * freeDagNode.cc (copyWithReplacement): removed extraneous "eager" 3930 variable left over from previous changes 3931 3932 * freeDagNode.hh (getArgument): added; this provides fast access 3933 to arguments without exposing raw pointer to arg vector (internal 3934 or external). It is intended for use by classes that treat free 3935 theory as special; e.g. classes that are derived from FreeDagNode 3936 or FreeSymbol. 3937 (class FreeDagNode): changed argArray() back to private; added 3938 public decl for getArgument() 3939 3940Thu Jul 31 16:23:49 1997 Steven Eker <eker@lilac.csl.sri.com> 3941 3942 * freeDagNode.hh (class FreeDagNode): changed argArray() from 3943 private to protected 3944 (class FreeDagNode): changed argArray() to public. this is a gross 3945 hack to get machine integers working; we want to provide a safe 3946 hook into FreeDagNode a.s.a.p. 3947 3948Wed Jul 23 11:39:51 1997 Steven Eker <eker@lilac.csl.sri.com> 3949 3950 * freeTerm.cc (normalize): added full flag 3951 3952 * freeTerm.hh (class FreeTerm): added full flag to normalize() 3953 3954Mon Jul 21 19:15:27 1997 Steven Eker <eker@lilac.csl.sri.com> 3955 3956 * freeDagNode.hh (class FreeDagNode): deleted 3957 normalizeEagerUptoReduced2() decl 3958 3959 * freeDagNode.cc (normalizeEagerUptoReduced2): deleted 3960 (copyWithReplacement): don't call normalizeEagerUptoReduced() 3961 3962===========================Engine26b=========================================================== 3963 3964Fri Jul 18 15:59:29 1997 Steven Eker <eker@lilac.csl.sri.com> 3965 3966 * freeDagNode.cc (normalizeEagerUpToReduced2): added 3967 (copyWithReplacement): normalize replacement if it is to be put in 3968 an eager position 3969 3970 * freeDagNode.hh (class FreeDagNode): added decl for 3971 normalizeEagerUpToReduced2() 3972 3973Tue Jul 15 14:53:04 1997 Steven Eker <eker@lilac.csl.sri.com> 3974 3975 * freeSymbol.cc (FreeSymbol): added inert arg 3976 3977 * freeSymbol.hh (class FreeSymbol): added inert arg to ctor 3978 3979 * freeDagNode.cc (markArguments): optimized 3980 (compareArguments): optimized 3981 3982===============================Engine26======================================================== 3983 3984Mon Jun 30 11:18:25 1997 Steven Eker <eker@lilac.csl.sri.com> 3985 3986 * freeTerm.cc (FreeTerm): print symbol name in assert message 3987 3988Fri Jun 27 16:18:03 1997 Steven Eker <eker@lilac.csl.sri.com> 3989 3990 * freeDagNode.hh (class FreeDagNode): clearCopyPointers2() and 3991 DagNode* copyEagerUptoReduced2() made private 3992 3993 3994 * freeSymbol.cc (eqRewrite): copyEagerUptoReduced() and 3995 clearCopyPointers() replaced by copyReducible() (twice) 3996 3997Wed Jun 25 15:12:55 1997 Steven Eker <eker@lilac.csl.sri.com> 3998 3999 * freeNet.cc: added #include "variable.hh" 4000 4001 * freeSymbol.cc: added #include "variable.hh" 4002 4003Tue Jun 24 14:57:38 1997 Steven Eker <eker@lilac.csl.sri.com> 4004 4005 * freeRemainder.cc: changed #include "variable.hh" to #include "variableTerm.hh" 4006 (slowMatchReplace2): need to find first solution to subproblem if 4007 it exists in "foreign" case 4008 4009 * freeLhsAutomaton.cc: added #include "variable.hh" 4010 4011 * freeLhsCompiler.cc (compileRemainder): use VariableTerm::downCast() 4012 (compileLhs): se VariableTerm::downCast() 4013 4014 * freeTerm.cc: added #include "variable.hh" 4015 4016 * freeRemainder.cc (FreeRemainder): use VariableTerm::downCast() 4017 4018 * freeTerm.cc (compileRhsFree): use VariableTerm::downCast() 4019 changed #include "variable.hh" to #include "variableTerm.hh" 4020 4021 * freeLhsAutomaton.cc (freeSubterms): use VariableTerm::downCast() 4022 changed #include "variable.hh" to #include "variableTerm.hh" 4023 4024Tue Jun 17 16:36:42 1997 Steven Eker <eker@lilac.csl.sri.com> 4025 4026 * freeSymbol.cc (eqRewrite): deleted call to foreignApplyReplace() 4027 (eqRewrite): changed comment; a call to 4028 discriminationNet.applyReplace() can now compute a top sort if we 4029 match a foreign remainder against the whole subject and the 4030 foreign matcher decides to compute the sort of its subjects 4031 (e.g. for a variable pattern or a collapse to a variable). 4032 4033 * freeNet.cc (compileEquations): use new Equation::compile conventions 4034 4035Thu Jun 12 11:36:04 1997 Steven Eker <eker@lilac.csl.sri.com> 4036 4037 * freeNet.cc (isFreeTerm): moved here and made local_inline to 4038 avoid header file problems 4039 4040 * freeSymbol.cc (eqRewrite): don't call foreignApplyReplace() 4041 4042 * freeRemainder.cc (slowMatchReplace2): local_inline it 4043 (slowMatchReplace2): handle foreign case 4044 4045 * freeRemainder.hh (class FreeRemainder): added foreign flag; 4046 removed fast flag from main ctor decl; added "foreign" ctor decl 4047 4048 * freeRemainder.cc (FreeRemainder): move decision on whether 4049 "fast" or not inside ctor 4050 (FreeRemainder): added ctor for "foreign" case 4051 4052Wed Jun 11 10:31:24 1997 Steven Eker <eker@lilac.csl.sri.com> 4053 4054 * freeNet.hh (isFreeTerm): added 4055 4056 * freeNet.cc (buildSlotTranslation): take reference rather than 4057 make copy of conflicts vector; this was a long standing bug 4058 that caused loss of compilation speed 4059 replaced -1 with NONE throughout 4060 (compileEquations): We are now going to allow patterns that don't 4061 have our symbol on top but that could match a subject headed by 4062 our term anyway: 4063 (1) We only setSlotIndex(0) for patterns that have a FreeTerm at 4064 their root; since free symbols don't ever collapse ths implicitly 4065 menas it is our symbol. 4066 (2) We only use compileRemainder() for patterns that have a 4067 FreeTerm at their root; for other patterns we use a special 4068 FreeRemainder ctor 4069 (findBestPosition): only try to locateSubterm() in those patterns 4070 that have a FreeTerm at their root. 4071 (setVisitedFlags): only try to locateSubterm() in those patterns 4072 that have a FreeTerm at their root. 4073 (allocateSlot): only try to locateSubterm() and findActiveSlots() 4074 in those patterns that have a FreeTerm at their root. 4075 (buildPatternVector): only try to locateSubterm() in those patterns 4076 that have a FreeTerm at their root. 4077 4078 * freeTerm.hh (class FreeTerm): delete findBestSequence() decl 4079 4080 * freeLhsCompiler.cc (insertGroundOutAliens): use willGroundOutMatch() 4081 (findBestSequence): deleted 4082 (analyseConstraintPropagation): use 4083 findConstraintPropagationSequence() rather than findBestSequence() 4084 (compileRemainder): use findConstraintPropagationSequence() rather 4085 than findBestSequence() 4086 (compileLhs): use findConstraintPropagationSequence() rather 4087 than findBestSequence() 4088 4089Tue Jun 10 10:50:03 1997 Steven Eker <eker@lilac.csl.sri.com> 4090 4091 * freeLhsCompiler.cc (findConstraintPropagationSequence): added 4092 (insertGroundOutAliens): added 4093 4094Thu Jun 5 11:34:41 1997 Steven Eker <eker@lilac.csl.sri.com> 4095 4096 * freeDagNode.hh (class FreeDagNode): decls for 4097 clearCopyPointers() and copyEagerUptoReduced() changed 4098 4099 * freeDagNode.cc (clearCopyPointers2): adapted from old 4100 clearCopyPointers() 4101 (copyEagerUptoReduced2): adapted from old copyEagerUptoReduced() 4102 4103 * freeSymbol.cc (FreeSymbol): don't pass stable arg to Symbol 4104 4105==============================Engine24==================================== 4106 4107Fri May 16 10:58:25 1997 Steven Eker <eker@lilac.csl.sri.com> 4108 4109 * freeTerm.cc (earlyMatchFailOnInstanceOf): use Term::stable() rather than 4110 testing for collapseSymbols and checking for variable 4111 4112 * freeNet.cc (findBestPosition): use Term::stable() rather than 4113 testing for collapseSymbols and checking for variable 4114 (buildPatternVector): use Term::stable() rather than 4115 testing for collapseSymbols and checking for variable 4116 4117Thu May 15 16:25:46 1997 Steven Eker <eker@lilac.csl.sri.com> 4118 4119 * freeNet.cc (buildPatternVector): change condition for pattern to 4120 survive; instead of "subterm !Symbol::stable()" we use "subterm is a variable 4121 or subterm could collapse at its top". We could have a much more 4122 sophisticated test: We could check to see if subterm could 4123 collapse to a variable or the required symbol. But this would be 4124 dangerous since the subterm could also collapse to some other 4125 symbol that does not have a branch and would miss being on the 4126 default branch. We could build the branches differently but this 4127 would be complicated and we would run in to problems extending the 4128 unexplored fringe if this other symbol that now got its own branch 4129 happened to be free. So we adopt a suboptimal solution that will 4130 occassionally try a remainder (which will contain at least one 4131 collapsing alien) that is bound to fail. 4132 (findBestPosition): now consider a subterm to be stable if it is 4133 not a variable and cannot collapse at its top. We use 4134 collapseSymbols() rather than stable() 4135 (findBestPosition): corrected sizeSum formula; this is a 4136 longstanding bug that doesn't manifest any symptoms except for 4137 occasional tiny performance deficit. 4138 (findBestPosition): use PointerSet rather that Vector<Symbol*> for 4139 simpler code 4140 4141 * freeTerm.cc (earlyMatchFailOnInstanceOf): use collapseSymbols() 4142 rather than stable() 4143 4144Mon Apr 7 19:27:23 1997 Steven Eker <eker@lilac.csl.sri.com> 4145 4146 * freeRemainder.cc (slowMatchReplace2): call to checkCondition() 4147 now takes subject 4148 4149Fri Apr 4 17:48:20 1997 Steven Eker <eker@lilac.csl.sri.com> 4150 4151 * freeRemainder.cc (slowMatchReplace2): use tracePreEqRewrite() 4152 and tracePostEqRewrite() 4153 4154 * freeRemainder.hh (fastMatchReplace): check for traceStatus() 4155 4156Wed Feb 12 19:15:10 1997 Steven Eker <eker@lilac.csl.sri.com> 4157 4158 * freeNet.cc (compileEquations): zero lhsAutomaton for equation to 4159 make sure dump works correctly 4160 4161Thu Jan 9 15:47:32 1997 Steven Eker <eker@lilac.csl.sri.com> 4162 4163 * freeDagNode.cc (overwriteWithClone): fixed serious bug 4164 where we were copying sort of overwritten node rather than 4165 overwriting node 4166 4167Tue Jan 7 11:52:25 1997 Steven Eker <eker@lilac.csl.sri.com> 4168 4169 * freeRemainder.cc (slowMatchReplace): replaced call to 4170 computeBaseSort() call to inErrorSort() 4171 4172 * freeSymbol.cc (eqRewrite): semiEager -> seenZero 4173 (eqRewrite): use inErrorSort() rather than computeBaseSort() 4174 (eqRewrite): remove now redundant repudiateSortInfo() call 4175 4176Thu Jan 2 17:36:24 1997 Steven Eker <eker@lilac.csl.sri.com> 4177 4178 * freeSymbol.cc (eqRewrite): fixed bug where when processing final 4179 0, if it was the only 0 then arguments that have not been 4180 evaluated will not have a valid sort when we call computeBaseSort(subject) 4181 4182Tue Dec 24 14:10:34 1996 Steven Eker <eker@lilac.csl.sri.com> 4183 4184 * freeRemainder.cc (slowMatchReplace): modified to use computeBaseSort() 4185 4186 * freeSymbol.cc (eqRewrite): adapted from rewrite(); computeSort() 4187 call replaced by computeTrueSort() call 4188 (eqRewrite): final 0 case computeSort() call replaced by 4189 computeBaseSort() call 4190 (computeBaseSort): adapted from computeSort() 4191 (computeTrueSort): added 4192 4193 * freeSymbol.hh (class FreeSymbol): rewrite() -> eqRewrite(); 4194 computeSort() replaced by computeBaseSort() and computeTrueSort() 4195 4196Thu Dec 19 13:21:57 1996 Steven Eker <eker@lilac.csl.sri.com> 4197 4198 * freeDagNode.cc (overwriteWithClone): simplified by not treating 4199 0 args as special case 4200 (makeClone): simplified by not treating 4201 0 args as special case; copy sort information 4202 4203Thu Dec 12 17:39:47 1996 Steven Eker <eker@lilac.csl.sri.com> 4204 4205 * freeDagNode.cc (overwriteWithClone): copy sort information; this 4206 is needed so then when we rewrite with a collapse equation we do 4207 not lose sort infomation with the possibility of infinite looping 4208 on foreign sort constraints 4209 4210Mon Dec 9 15:22:45 1996 Steven Eker <eker@lilac.csl.sri.com> 4211 4212 * freeSymbol.cc (computeSort): modified to use new 4213 constrainToSmallerSort() calling convention 4214 4215Mon Nov 25 19:04:25 1996 Steven Eker <eker@lilac.csl.sri.com> 4216 4217 * freeSymbol.cc (Symbol): added constructor arg 4218 4219Thu Nov 14 17:51:18 1996 Steven Eker <eker@lilac.csl.sri.com> 4220 4221 * freeDagNode.cc (makeClone): added 4222 4223Wed Oct 30 12:07:15 1996 Steven Eker <eker@lilac.csl.sri.com> 4224 4225 * freeSymbol.cc (rewrite): hacked to use Symbol::foreignApplyReplace() 4226 4227 * freeNet2.hh (applyReplace): minor rewrite 4228 4229Thu Oct 17 16:03:50 1996 Steven Eker <eker@lilac.csl.sri.com> 4230 4231 * freeNet2.hh (applyReplace): stack argArray only when slot >= 0 4232 4233 * freeNet.cc (findBestPosition): stability used rather than 4234 freeness to determine if a symbol can be tested during match of 4235 free skeleton 4236 (buildPatternVector): treat stable aliens as constants 4237 (buildNet): treat stable aliens as constants 4238 4239 * freeTerm.cc (FreeTerm): set visitedFlag = false 4240 4241 * freeNet.cc (buildNet): use setVisitedFlags() 4242 (setVisitedFlags): used to be setUtilityFlags() 4243 4244 * freeTerm.hh (class FreeTerm): visitedFlag added 4245 (setVisitedFlag): added 4246 4247 * freeTerm.cc (findActiveSlots): rewritten to use visited flag 4248 4249Wed Oct 16 11:21:54 1996 Steven Eker <eker@lilac.csl.sri.com> 4250 4251 * freeNet.cc (dump): hacked to do indentation 4252 4253Tue Oct 15 18:27:45 1996 Steven Eker <eker@lilac.csl.sri.com> 4254 4255 * freeRemainder.cc (dump): rewritten to do indentation 4256 4257 * freeRhsAutomaton.cc (dump): indentLevel arg added but not yet used 4258 4259 * freeLhsAutomaton.cc (dump): rewritten to do indentation 4260 4261Fri Aug 30 13:50:50 1996 Steven Eker <eker@nmos.csl.sri.com> 4262 4263 * freeTerm.cc (subsumes): much simplified not that subsumtion on 4264 variables handles non-linearities correctly 4265 4266Fri Aug 9 15:53:39 1996 Steven Eker <eker@nmos.csl.sri.com> 4267 4268 * freeDagNode.cc (stackArguments): added 4269 (copyWithReplacement): added 4270 4271 * freeSymbol.cc: ruleRewrite() stripped 4272 4273 * freeSymbol.hh (class FreeSymbol): ruleRewrite() stripped 4274 4275Thu Aug 8 16:29:21 1996 Steven Eker <eker@nmos.csl.sri.com> 4276 4277 * freeSymbol.cc (ruleRewrite): added 4278 4279Tue Aug 6 14:45:37 1996 Steven Eker <eker@nmos.csl.sri.com> 4280 4281 * freeLhsAutomaton.cc (freeSubterms): freeVars parameter and code 4282 to fill out freeVariables vector deleted 4283 (match): code to bind free variables removed 4284 (dump): code to dump free variables removed 4285 4286 * freeLhsAutomaton.hh (class FreeLhsAutomaton): freeVars rag 4287 removed from constructor 4288 (class FreeLhsAutomaton): freeVariables vector removed 4289 4290 * freeLhsCompiler.cc: created by extraacting compiler code from freeTerm.cc 4291 (analyseConstraintPropagation): matchAtTop arg removed 4292 (compileRemainder): no longer pass boundAbove 4293 (compileLhs): boundAbove arg removed, no longer update and pass 4294 this set 4295 4296 * freeTerm.hh (class FreeTerm): boundAbove arg removed from 4297 compileLhs(); matchAtTop arg removed from analyseConstraintPropagation() 4298 4299Fri Aug 2 17:21:28 1996 Steven Eker <eker@nmos.csl.sri.com> 4300 4301 * freeSymbol.cc (Symbol): take strategy has a reference rather 4302 than a pointer to a constant Vector<int> for consistancy with 4303 other theories 4304 4305Thu Aug 1 17:10:13 1996 Steven Eker <eker@nmos.csl.sri.com> 4306 4307 * freeSymbol.cc (FreeSymbol): hacked to handle empty strategy list correctly 4308 4309Wed Jul 31 17:17:47 1996 Steven Eker <eker@nmos.csl.sri.com> 4310 4311 * freeSymbol.cc (makeTerm): added 4312 4313Fri Jun 28 17:34:01 1996 Steven Eker <eker@ponder.csl.sri.com> 4314 4315 * freeTerm.cc (earlyMatchFailOnInstanceOf): added 4316 4317Fri Jun 21 18:53:39 1996 Steven Eker <eker@ponder.csl.sri.com> 4318 4319 * freeTerm.cc (compileLhs): new arg list; handle subproblem likely 4320 flag 4321 (compileRemainder): use new compileLhs() 4322 4323 * freeTerm.hh (class FreeTerm): changed compileLhs() args 4324 4325Thu Jun 13 16:26:44 1996 Steven Eker <eker@ponder.csl.sri.com> 4326 4327 * freeLhsAutomaton.cc (match): use SubproblemAccumulator 4328 4329 * freeRemainder.cc (slowMatchReplace2): use SubproblemAccumulator 4330 4331Wed Jun 12 10:49:40 1996 Steven Eker <eker@ponder.csl.sri.com> 4332 4333 * freeTerm.cc (compileLhs): added nrVariables arg 4334 (compileRemainder): pass nrVariables 4335 4336Fri Jun 7 16:51:41 1996 Steven Eker <eker@ponder.csl.sri.com> 4337 4338 * freeRemainder.cc (slowMatchReplace2): use new SubproblemSequence 4339 constructor and semantics 4340 4341 * freeLhsAutomaton.cc: use new SubproblemSequence constructor and semantics 4342 4343 * freeTheory.cc: Sequence's removed throughout module 4344 4345Wed May 29 16:36:53 1996 Steven Eker <eker@ponder.csl.sri.com> 4346 4347 * freeRemainder.cc (dump): multi-character character constant removed 4348 4349Tue May 28 17:03:58 1996 Steven Eker <eker@ponder.csl.sri.com> 4350 4351 * freeTerm.cc (findBestSequence): top level version: modified to 4352 use Term::findBestSequence() 4353 (findBestSequence): recursive version: deleted 4354 4355Thu May 23 11:38:51 1996 Steven Eker <eker@ponder.csl.sri.com> 4356 4357 * freeNet.cc (dump): now dump remainders 4358 (dump): fixed bug where we assumed net to be empty if there were 4359 no test nodes 4360 4361 * freeRemainder.cc (dump): added 4362 4363Sun May 19 18:29:36 1996 Steven Eker <eker@ponder.csl.sri.com> 4364 4365 * freeRemainder.cc (slowMatchReplace2): added 4366 (slowMatchReplace): call slowMatchReplace2() to actually do the 4367 work; we acll finished() to unprotect DAG nodes in the 4368 substitution and call DagNode::okToCollectGarbage() even if match 4369 failed as matching can created garbage (eg in assoc or AC theories) 4370 4371Sat May 18 15:55:30 1996 Steven Eker <eker@ponder.csl.sri.com> 4372 4373 * freeSymbol.cc (rewrite): print Advisory if users strategy is abandoned 4374 4375Fri May 17 16:20:38 1996 Steven Eker <eker@ponder.csl.sri.com> 4376 4377 * freeDagNode.cc: deleted #include "dumpContext.hh" 4378 4379 * freeNet.cc (dump): use streams 4380 4381 * freeLhsAutomaton.cc (dump): use streams 4382 4383 * freeRhsAutomaton.cc (dump): use streams 4384 4385 * freeSymbol.cc (dump): use streams 4386 4387Sat May 11 16:31:39 1996 Steven Eker <eker@ponder.csl.sri.com> 4388 4389 * freeSymbol.cc (FreeSymbol): pass stable = true 4390 4391Fri Apr 12 17:22:59 1996 Steven Eker <eker@ponder.csl.sri.com> 4392 4393 * freeTerm.cc (analyseConstraintPropagation): added atTop parameter 4394 (findBestSequence): call analyseConstraintPropagation() with atTop 4395 = false 4396 4397 * freeTerm.hh: added atTop parameter to analyseConstraintPropagation() 4398 4399Wed Apr 10 12:04:46 1996 Steven Eker <eker@ponder.csl.sri.com> 4400 4401 * freeDagNode.cc (markArguments): Asserts removed (placed in 4402 DagNode::mark() instead) 4403 4404 * freeTerm.cc (markEagerArguments): use argArray.length() in place 4405 of sym->arity() 4406 (markEagerArguments): replaced old style cast with static_cast and 4407 removed local variable that was only used once 4408 (findEagerVariables): replaced old style cast with static_cast 4409 4410Wed Mar 27 11:28:10 1996 Steven Eker <eker@ponder.csl.sri.com> 4411 4412 * freeTheory.cc: template class 4413 Sequence<FreeRhsAutomaton::Instruction> removed 4414 4415 * freeTerm.cc (compileRhs): rewritten to use revised 4416 FreeRhsAutomaton class 4417 (compileRhsAliens): rewritten to use revised FreeRhsAutomaton class 4418 (compileRhsFree): rewritten to use revised FreeRhsAutomaton class 4419 4420 * freeRhsAutomaton.hh (addAlien): added 4421 4422 * freeRhsAutomaton.cc (construct): rewritten 4423 (replace): rewritten 4424 (dump): rewritten 4425 (addFree): added 4426 4427 * freeTheory.cc: template instantiation for Vector<FreeRemainder*> 4428 moved here 4429 4430 * freeNet.hh: data members slots and conflicts removed; function 4431 declarations updated; many functions that don't need to access 4432 class data members declared static 4433 4434 * freeNet.cc (buildPatternVector): greatly simplified by removing 4435 slot handling code 4436 (allocateSlot): created 4437 (buildPatternVector): further simplified by not counting and 4438 returning number of live patterns 4439 (buildPatternVector): previous simplification reversed - we need 4440 count after all for default case 4441 (buildNet): simplified by moving slot code into allocateSlot() 4442 (compileEquations): slots and conflicts are now local data 4443 structure rather than being data members of class 4444 (buildSlotTranslation): take slots and conflicts as arguments; 4445 obscure variable names changed 4446 4447Tue Mar 26 13:56:39 1996 Steven Eker <eker@ponder.csl.sri.com> 4448 4449 * freeNet.cc (buildNet): call findActiveSlots on each live pattern 4450 to find conflicts with newly created slot 4451 (setUtilityFlags): created, to mark and unmark those terms that 4452 have been matched during construction of the discrimination net 4453 (compileEquations): expand conflict vector to keep it in sync with 4454 slots data structure 4455 (compileEquations): code to use graph coloring added to 4456 slotTranslation code 4457 (buildSlotTranslation): created 4458 (compileEquations): rearranged to use buildSlotTranslation() 4459 (buildNet): don't allocate slots for symbols with zero arity 4460 (buildPatternVector): don't try to union slot where non has been allocated 4461 4462 * freeTerm.cc (findActiveSlots): infinite recursion bug fixed 4463 4464Mon Mar 25 09:56:49 1996 Steven Eker <eker@ponder.csl.sri.com> 4465 4466 * freeTerm.cc (findActiveSlots): added 4467 4468 * freeNet.cc (findBestPosition): return symbols via Vector<Triple> 4469 (buildNet): modified to use new findBestPosition() 4470 (findBestPosition): now check that bestSymbols exists before 4471 taking it length; don't bother treating length 0 as a special case 4472 as Vector<T>::expandTo(0) now works OK 4473 4474Sat Mar 23 14:12:33 1996 Steven Eker <eker@ponder.csl.sri.com> 4475 4476 * freeNet.cc (findBestPosition): ExtSequence removed because of 4477 instatiation problems 4478 (compileEquations): long standing bug wherein position were not 4479 translated to match slots fixed 4480 (compileEquations): bug introduced by previous bugfix fixed; don't 4481 try to translate -1 as a slot or position member 4482 (buildApplicable): added 4483 4484 * freeNet.hh: UnionFind data member added 4485 4486 * freeNet.cc: routines changed to use UnionFind class 4487 4488Thu Mar 21 10:12:05 1996 Steven Eker <eker@ponder.csl.sri.com> 4489 4490 * freeSymbol.cc (computeSort): rewritten to treat uniform sort 4491 case as special case 4492 (computeSort): hacked uniform case to try to improve performance 4493 (computeSort): fancy uniform sort sort code stripped 4494 4495 * freeRemainder.hh (fastMatchReplace): #ifdef'd raw access to 4496 Vector<> arrays added 4497 4498 * freeNet2.hh (applyReplace): #ifdef'd raw access to Vector<> arrays 4499 4500Fri Mar 15 14:00:46 1996 Steven Eker <eker@ponder.csl.sri.com> 4501 4502 * freeNet2.hh (applyReplace): more loop reorganization 4503 (applyReplace): gross hacks involving raw access of Vector<> arrays 4504 (applyReplace): more hacking: netBase moved inwards, if statement 4505 reversed 4506 4507 * freeNet.cc (buildTernaryTree): continuation subtree now 4508 propogate -1 for position and argIndex to enable detection of case 4509 where subject node does note change 4510 make sure implementation of freeNet2.hh included 4511 4512 * freeNet2.hh (applyReplace): loop reorganized to avoid reloaded 4513 pointer to dag node in case when we know it won't change 4514 4515Thu Mar 14 11:01:27 1996 Steven Eker <eker@ponder.csl.sri.com> 4516 4517 * freeNet.cc (buildFringe): now take slot arg; all routines 4518 updated to use Position rather than Sequence<int> 4519 (dump): added 4520 4521 * freeNet.hh: added struct Position to carry slot index for parent 4522 node along with path 4523ec 4524Wed Mar 13 15:38:42 1996 Steven Eker <eker@ponder.csl.sri.com> 4525 4526 * freeNet.cc (buildPatternVector): now return number of live patterns 4527 (tripleCompare): args changed from refs to pointers 4528 4529 * freeDagNode.hh: FreeNet is now a friend 4530 4531 * freeNet.cc: Pair->Triple throughout 4532 (buildNet): allocateSlot for each symbol at chosen position 4533 (buildPatternVector): set slot index for each pattern with 4534 appropriate symbol at chosen position 4535 (findSlot): added 4536 (unionSlots): addded 4537 (allocateSlot): added 4538 (compileEquations): added crude slot resolution code 4539 4540 * freeNet.hh (applyReplace): check for no equations; check for top 4541 symbol being a constant (0 size stack); use static_casts; check 4542 d->symbol()-arity() rather than n.symbol.arity() to let gcc do 4543 common subexpression elimination with inlined argArray() body. 4544 Pair -> Triple 4545 4546Tue Mar 12 17:03:36 1996 Steven Eker <eker@ponder.csl.sri.com> 4547 4548 * freeTerm.cc (compileRemainder): variable set parameters removed 4549 (compileRemainder): removed fast arg; fast determination now done 4550 completely inside this function 4551 4552 * freeSymbol.cc: old applyReplace removed 4553 template instatiations removed 4554 (compileEquations): added (but commented out until freeNet ready) 4555 4556 * freeSymbol.hh: old discrimination net struct and data members removed 4557 strategy() removed 4558 4559 * freeNet.hh (applyReplace): equation arg dropped from call to 4560 fastMatchReplace(); code changed for new applicable data structure 4561 (applyReplace): code changed back; we need to avoid a chicken and 4562 egg situation with applicable and net 4563 4564 * freeTerm.cc (compileRemainder): now take equation arg 4565 4566 * freeRemainder.hh (fastMatchReplace): no longer take equation arg 4567 pointer to the equation that we're the remainder of is now stored 4568 as a data member 4569 4570 * freeRemainder.cc (slowMatchReplace): no longer take equation arg 4571 (freeVariables): take and store equation arg 4572 4573Mon Mar 11 09:56:04 1996 Steven Eker <eker@ponder.csl.sri.com> 4574 4575 * freeRemainder.cc (slowMatchReplace): Sequence accesses changed 4576 to Vector accesses 4577 4578 * freeRemainder.hh: construct decl added, Sequence<>s changed to 4579 Vector<>s, local structs chendd to FreeLhsAutomaton structs 4580 4581 * freeTerm.cc (compileRemainder): added 4582 4583 * freeTerm.hh: public version of findBestSequence() privatized 4584 compileRemainder() added 4585 4586 * freeSymbol.cc (rewrite): make sure we compute sorts of subterms 4587 before applying at top with user strategy - subtle bug removed, 4588 Assert() added 4589 4590 * freeLhsAutomaton.cc (match): Assert()s added to check for 4591 missing sort info 4592 4593Sun Mar 10 14:58:39 1996 Steven Eker <eker@ponder.csl.sri.com> 4594 4595 * freeLhsAutomaton.hh: build() -> match() 4596 4597 * freeLhsAutomaton.cc (match): build() -> match() 4598 4599 * freeRemainder.cc (slowMatchReplace): build() -> match() 4600 4601 * freeLhsAutomaton.cc: completely rewritten, using Vector<>s 4602 4603Sat Mar 9 16:20:28 1996 Steven Eker <eker@ponder.csl.sri.com> 4604 4605 * freeTerm.cc (analyseConstraintPropagation): nrPos removed from 4606 call to scanFreeSkeleton() 4607 (compileLhs): nrPos removed from call to scanFreeSkeleton(); 4608 (compileLhs): much simplification 4609 (scanFreeSkeleton): heavily rewritten; semantics have changed: top 4610 free term now gets placed in freeSymbols; also positions stored in 4611 FreeOccurrence now refer to freeSymbols index of parent rather 4612 than stack position under compilation; this make this function 4613 more generally useful but means that extra works has to be done 4614 else where to compute stack positions for compilation 4615 4616 * freeTerm.hh: removed "position" parameter from scanFreeSkeleton() 4617 4618 * freeTerm.cc (compileLhs): "simple" argument removed 4619 4620Fri Mar 8 10:37:33 1996 Steven Eker <eker@ponder.csl.sri.com> 4621 4622 * freeTerm.cc (Term): set slotIndex to -1 4623 (findBestSequence): split into two functions, a private recursive 4624 function that does most of the work and a public wrapper that 4625 initializes the search variables. Callers changed to call wrapper 4626 4627 * freeArgumentIterator.cc (valid): changed to Vector<> representation 4628 (argument): changed to Vector<> representation 4629 (next): changed to Vector<> representation 4630 4631 * freeArgumentIterator.hh: changed to Vector<> representation 4632 4633 * freeTerm.cc (Term): now take reference to arg list; code 4634 considerably simplified 4635 (arguments): recoded using Vector<>s 4636 (FreeTerm): now empty function 4637 (deepSelfDestruct): recoded using Vector<>s 4638 (normalize): recoded using Vector<>s 4639 (compareArguments): recoded using Vector<>s 4640 (compareArguments): recoded using Vector<>s, still treat 0 args as 4641 special case and walk pointer over dagNode args 4642 4643 * freeTerm.hh: slotIndex added. argument put in Vector<Term*> 4644 4645Thu Mar 7 17:09:14 1996 Steven Eker <eker@ponder.csl.sri.com> 4646 4647 * freeLhsAutomaton.cc (FreeLhsAutomaton): args changed to use Vector<>s 4648 4649 * freeLhsAutomaton.hh: ctor args changed to use Vector<>s 4650 4651 * freeTerm.cc (compileLhs): use Vector for subAutomata 4652 4653 * freeTerm.hh: findBestSequence() params changed 4654 4655 * freeTerm.cc (findBestSequence): IntSet::copy() -> IntSet::operator= 4656 (findBestSequence): changed to use Vector<int> to hold current 4657 sequence; callers changed; "Best" struct changed 4658 4659Wed Mar 6 17:53:27 1996 Steven Eker <eker@ponder.csl.sri.com> 4660 4661 * freeNet.cc (buildFringe): expand() -> expandTo() 4662 (buildNet): expand() -> expandBy() 4663 4664Mon Mar 4 09:59:56 1996 Steven Eker <eker@ponder.csl.sri.com> 4665 4666 * freeNet.hh (applyReplace): created from idea.cc and code moved 4667 out of freeSymbol.* 4668 4669Fri Mar 1 10:09:40 1996 Steven Eker <eker@ponder.csl.sri.com> 4670 4671 * freeTerm.hh: added locateSubterm() 4672 4673 * freeTerm.cc (locateSubterm): added 4674 4675Thu Feb 22 11:38:28 1996 Steven Eker <eker@ponder.csl.sri.com> 4676 4677 * freeRemainder.cc: template instantiations added 4678 4679 * freeSymbol.cc (applyReplace): rewritten to use fastMatchReplace() 4680 4681 * freeRemainder.cc (slowMatchReplace): added (made from old slowMatchRemainder()) 4682 4683 * freeRemainder.hh (fastMatchReplace): added (made from old fastMatchRemainder()) 4684 4685 * freeSymbol.cc (applyReplace): added 4686 4687Thu Feb 15 10:50:16 1996 Steven Eker <eker@ponder.csl.sri.com> 4688 4689 * freeTerm.cc (findEagerVariables): simplified, making use of the 4690 fact that Variable::findEagerVariables() is now usable 4691 4692Wed Feb 14 11:39:29 1996 Steven Eker <eker@ponder.csl.sri.com> 4693 4694 * freeSymbol.cc (rewrite): rewritten yet again! Now we trust user 4695 strategy upto but not including final zero. Just before final zero 4696 we check to see if the top operator is in the error sort and if so 4697 copy and evaluate all unevaluated arguments in an attempt to bring 4698 it down. 4699 (rewrite): evaluated set has arg positions that start from 1 4700 rather than 0 4701 4702Tue Feb 13 14:55:02 1996 Steven Eker <eker@ponder.csl.sri.com> 4703 4704 * freeSymbol.cc (rewrite): rewritten so than when when current 4705 symbol has a custom strategy we find the sort and if it is a error 4706 sort we use default strategy, making copies of any non-eager subterms. 4707 (rewrite): need to invalidate stale sort info 4708 (rewrite): rewritten again; for custom strategy: 4709 (1) evaluate eager args 4710 (2) each time we hit 0 in strategy, force top sort to be 4711 computed; if error sort, copy and evaluate all non-eager 4712 subterms and invalidate the sort we just computed. Then 4713 rewrite at top if possible and exit 4714 (3) otherwise rewrite at top if possible 4715 (4) otherwise continue with custom strategy, copying and 4716 evaluating semi-eager arguments until we hit 0; in that 4717 case goto (2) 4718 Since all strategies end in 0 we know that the last sort that we 4719 computed in (2) will be valid if we finish strategy without having 4720 been able to rewrite at top 4721 4722Thu Feb 8 17:26:08 1996 Steven Eker <eker@ponder.csl.sri.com> 4723 4724 * freeSymbol.cc (computeSort): removed test for UNKNOWN_SORT (this 4725 is now done in dagNode::computeSort() 4726 (rewrite): use dagNode::computeSort() 4727 4728Tue Feb 6 16:59:29 1996 Steven Eker <eker@ponder.csl.sri.com> 4729 4730 * freeSymbol.cc (computeSort): use constrainToSmallerSort() 4731 4732Thu Feb 1 14:06:10 1996 Steven Eker <eker@ponder.csl.sri.com> 4733 4734 * freeSymbol.cc: parse() deleted 4735 4736 * freeSymbol.hh: parse() deleted 4737 4738 * freeTerm.hh: FreeSymbol friendship revoked 4739 4740 * freeSymbol.cc (parse): added 4741 4742 * freeTerm.hh: FreeSymbol is now a friend 4743 4744 * freeSymbol.hh: parse() added 4745 4746Wed Jan 31 10:21:36 1996 Steven Eker <eker@ponder.csl.sri.com> 4747 4748 * freeSymbol.cc (rewrite): use new applyReplace() 4749 4750 * freeFastLhsAutomaton.cc (FreeFastLhsAutomaton): call to 4751 Symbol::lookupSort() replaced by Variable::lookupSort() 4752 4753 * freeLhsAutomaton.cc (makeVariableOccurVector): call to 4754 Symbol::lookupSort() replaced by Variable::lookupSort() 4755 4756Fri Jan 12 11:21:55 1996 Steven Eker <eker@ponder.csl.sri.com> 4757 4758 * freeDagNode.hh: tests show that gcc is capable of reusing results 4759 of inlined symbol() and arity() calls, so passing arity to 4760 argArray() to avoid multiple such calls is unnecessarily 4761 ugly. Thus the arity parameter is removed throughout freeTheory code. 4762 4763Thu Jan 11 18:09:02 1996 Steven Eker <eker@ponder.csl.sri.com> 4764 4765 * freeSymbol.cc (computeSort): DagNode::SORT_UNKOWN -> 4766 Sort::SORT_UNKOWN, DagNode::MULTISORT -> Sort UNION_SORT 4767 4768 4769Wed Jan 10 16:53:36 1996 Steven Eker <eker@ponder.csl.sri.com> 4770 4771 * freeFastLhsAutomaton.cc (FreeFastLhsAutomaton): added dummy 4772 vector so we can get the sort of a variable 4773 4774 * freeLhsAutomaton.cc (makeVariableOccurVector): added dummy 4775 vector so we can get the sort of a variable 4776 4777 * freeSymbol.cc (Symbol): deleted sharable, initialize sortIndexBuffer 4778 (computeSort): use Vectors 4779 4780 * freeSymbol.hh: don't have sharable arg for constructor; use 4781 Vector for sortIndexBuffer 4782 4783Thu Dec 21 17:12:23 1995 Steven Eker <eker@ponder.csl.sri.com> 4784 4785 * freeFastLhsAutomaton.cc (build): fixed subtle bug where we were 4786 modifying automatons nrArgs field! 4787 4788Fri Dec 15 11:43:51 1995 Steven Eker <eker@ponder.csl.sri.com> 4789 4790 * freeSymbol.cc (computeSort): added code to deal with union sorts 4791 (computeSort): commented out the delete in case this is the cause 4792 of heap corruption 4793 (computeSort): changed delete to delete[] 4794 4795 * freeLhsAutomaton.cc (build): added code to check sorts 4796 (makeVariableOccurVector): added code to store sort codes 4797 4798 * freeFastLhsAutomaton.cc (FreeFastLhsAutomaton): added code to 4799 store sort code in unboundVariableOccur[] 4800 (build) added code to check sorts 4801 4802Tue Dec 12 11:05:55 1995 Steven Eker <eker@ponder.csl.sri.com> 4803 4804 * freeSymbol.cc (computeSort): fixed bug where we were making a 4805 (possibly) recursive virtual call based on the current symbol 4806 rather than the subjects subterm symbol 4807 4808 * freeSymbol.hh: addded sortIndexBuffer 4809 4810 * freeSymbol.cc (rewrite): added code to determine sorts for 4811 non-eager arguments before matching at top, and to reduce any 4812 arguments that wind up in error sort. 4813 (FreeSymbol): addded sortIndexBuffer initialization 4814 (computeSort): added 4815 4816 * freeSymbol.hh: added computeSort() 4817 4818Fri Dec 8 18:05:26 1995 Steven Eker <eker@ponder.csl.sri.com> 4819 4820 * freeDagNode.cc: deleted normalize() and rewrite() 4821 4822 * freeDagNode.hh: deleted normalize() and rewrite() 4823 4824Thu Dec 7 18:00:16 1995 Steven Eker <eker@ponder.csl.sri.com> 4825 4826 * freeDagNode.cc: commented out normalize() and rewrite() 4827 4828 * freeDagNode.hh: commented out normalize() and rewrite() 4829 4830 * freeSymbol.cc (rewrite): added 4831 4832 * freeSymbol.hh: added bool rewrite() 4833 commented out strategy() 4834 4835Tue Nov 7 11:18:02 1995 Steven Eker <eker@ponder.csl.sri.com> 4836 4837 * freeTerm.cc (compileLhs): added "simple" argument 4838 4839 * freeDagNode.cc (rewrite): rule->equation names changed 4840 4841Thu Oct 26 11:23:34 1995 Steven Eker <eker@ponder.csl.sri.com> 4842 4843 * freeTheory.hh: added FreeFastLhsAutomaton 4844 4845 * freeDagNode.hh: made FreeFastLhsAutomaton a friend 4846 4847 * freeTerm.cc (compileLhs): added code to use FreeFastLhsAutomaton 4848 4849 * freeFastLhsAutomaton.hh: created 4850 4851 * freeFastLhsAutomaton.cc: created 4852 4853 * freeLhsAutomaton.cc (build): fix bug where we failed to set 4854 returnedSubproblem = 0 when matching a constant 4855 4856Mon Oct 23 18:01:26 1995 Steven Eker <eker@ponder.csl.sri.com> 4857 4858 * freeRhsAutomaton.cc (dump): removed symbol2String() usage 4859 4860 * freeLhsAutomaton.cc (dump): removed symbol2String() usage 4861 4862Tue Oct 17 11:24:58 1995 Steven Eker <eker@ponder.csl.sri.com> 4863 4864 * freeRhsAutomaton.cc (dump): updated to use dump context 4865 4866 * freeRhsAutomaton.hh: updated to use dump context 4867 4868 * freeLhsAutomaton.cc (dump): updated to use dump context 4869 4870 * freeLhsAutomaton.hh: updated to use dump context 4871 4872 * freeDagNode.cc (rewrite): modified reduction loop in default 4873 strategy case to see if it speeds this up 4874 (rewrite): now use reduce() member function to reduce arguments; 4875 don't call setReduced(); 4876 4877 * freeRhsAutomaton.cc (replace): treat replacement node as a 4878 special case 4879 4880Fri Oct 13 17:45:10 1995 Steven Eker <eker@ponder.csl.sri.com> 4881 4882 * freeRhsAutomaton.cc (dump): removed CHECK_SHARABILITY 4883 4884 * freeTerm.cc (compileLhs): removed getVariable() 4885 4886 (analyseConstraintPropagation): removed getVariable() 4887 replaced all (Variable*)s with downCast()s 4888