![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to compitem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff|
Return to compitem.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff |
1.1 ! root 1: ! 2: /******************************************************************************\ ! 3: * This is a part of the Microsoft Source Code Samples. ! 4: * Copyright (C) 1993 Microsoft Corporation. ! 5: * All rights reserved. ! 6: * This source code is only intended as a supplement to ! 7: * Microsoft Development Tools and/or WinHelp documentation. ! 8: * See these sources for detailed information regarding the ! 9: * Microsoft samples programs. ! 10: \******************************************************************************/ ! 11: ! 12: /****************************** Module Header ******************************* ! 13: * Module Name: COMPITEM.C ! 14: * ! 15: * Module which does the comparison between two files. ! 16: * ! 17: * Functions: ! 18: * ! 19: * ci_copytext() ! 20: * ci_makecomposite() ! 21: * ci_compare() ! 22: * ci_onesection() ! 23: * compitem_new() ! 24: * compitem_delete() ! 25: * compitem_discardsections() ! 26: * compitem_getcomposite() ! 27: * compitem_getleftsections() ! 28: * compitem_getrightsections() ! 29: * compitem_getleftfile() ! 30: * compitem_getrightfile() ! 31: * compitem_getstate() ! 32: * compitem_gettext_tag() ! 33: * compitem_gettext_result() ! 34: * compitem_getfilename() ! 35: * compitem_frefilename() ! 36: * ! 37: * Comments: ! 38: * ! 39: * This module uses the structure compitem which is a data type that knows ! 40: * about two files, and can compare them. The result of the comparison ! 41: * is a list of sections for each file, and a composite list of sections ! 42: * representing the comparison of the two files. ! 43: * ! 44: * A compitem has a state (one of the integer values defined in state.h) ! 45: * representing the result of the comparison. It can also be ! 46: * queried for the text result (text equivalent of the state) as well ! 47: * as the tag - or title for this compitem (usually a text string containing ! 48: * the name(s) of the files being compared). ! 49: * ! 50: * A compitem will supply a composite section list even if the files are ! 51: * the same, or if there is only one file. The composite section list will ! 52: * only be built (and the files read in) when the compitem_getcomposite() ! 53: * call is made (and not at compitem_new time). ! 54: * ! 55: * ! 56: ****************************************************************************/ ! 57: ! 58: #include <windows.h> ! 59: #include <stdlib.h> ! 60: #include <string.h> ! 61: ! 62: #include "gutils.h" ! 63: #include "state.h" ! 64: #include "windiff.h" ! 65: #include "wdiffrc.h" ! 66: #include "list.h" ! 67: #include "line.h" ! 68: #include "scandir.h" ! 69: #include "file.h" ! 70: #include "section.h" ! 71: #include "compitem.h" ! 72: ! 73: ! 74: struct compitem { ! 75: ! 76: FILEDATA left; /* handle for left-hand file */ ! 77: FILEDATA right; /* handle for right-hand file */ ! 78: ! 79: LIST secs_composite; /* list of sections (composite file)*/ ! 80: LIST secs_left; /* list of sections (left file) */ ! 81: LIST secs_right; /* list of sections (right file) */ ! 82: ! 83: int state; /* compitem state - result of compare */ ! 84: BOOL bDiscard; /* true if not alloc-ed on list */ ! 85: LPSTR tag; /* text for tag (title of compitem) */ ! 86: LPSTR result; /* text equivalent of state */ ! 87: ! 88: }; ! 89: ! 90: ! 91: LPSTR ci_copytext(LPSTR in); ! 92: void ci_makecomposite(COMPITEM ci); ! 93: void ci_compare(COMPITEM ci); ! 94: ! 95: ! 96: /*************************************************************************** ! 97: * Function: compitem_new ! 98: * ! 99: * Purpose: ! 100: * ! 101: * Returns a handle to a new compitem - given the filenames for the ! 102: * left and right files to be compared. Either left or right or neither ! 103: * (but not both) may be null. In this case we set the state accordingly. ! 104: * ! 105: * The parameters are handles to DIRITEM objects: these allow us to get the ! 106: * the name of the file relative to the compare roots (needed for the tag) ! 107: * and the absolute name of the file (needed for opening the file). ! 108: * ! 109: * Comments: ! 110: * ! 111: * If the list parameter is not null, the List_New* functions are used to ! 112: * allocate memory for the compitem. We remember this (in the bDiscard flag) ! 113: * so we do not delete the compitem if it was allocated on the list. ! 114: * ! 115: * If the list parameter is null, the memory ! 116: * for the compitem is allocated from the gmem_* heap initialised by the app. ! 117: * ! 118: ****************************************************************************/ ! 119: COMPITEM ! 120: compitem_new(DIRITEM leftname, DIRITEM rightname, LIST list, BOOL fExact) ! 121: { ! 122: COMPITEM ci; ! 123: LPSTR str1, str2; ! 124: char buf[2*MAX_PATH+20]; ! 125: ! 126: ! 127: /* ! 128: * Allocate the memory for the compitem, either at the end of the ! 129: * list or in the gmem_* heap. ! 130: */ ! 131: if (list == NULL) { ! 132: /* no list passed */ ! 133: ci = (COMPITEM) gmem_get(hHeap, sizeof(struct compitem)); ! 134: memset(ci, 0, sizeof(struct compitem)); ! 135: ci->bDiscard = TRUE; ! 136: } else { ! 137: /* add to end of list */ ! 138: ci = (COMPITEM) List_NewLast(list, sizeof(struct compitem)); ! 139: ci->bDiscard = FALSE; ! 140: } ! 141: ! 142: ci->secs_composite = NULL; ! 143: ci->secs_left = NULL; ! 144: ci->secs_right = NULL; ! 145: ! 146: /* ! 147: * Make a filedata for each of the files that are non-null. ! 148: * Filedata objects are responsible for reading the file and ! 149: * accessing the lines in it. Don't read in the files until we need to. ! 150: */ ! 151: if (leftname != NULL) { ! 152: ci->left = file_new(leftname, FALSE); ! 153: if (ci->left == NULL) { ! 154: return(NULL); ! 155: } ! 156: } else { ! 157: ci->left = NULL; ! 158: } ! 159: if ( rightname != NULL) { ! 160: ci->right = file_new(rightname, FALSE); ! 161: if (ci->right == NULL) { ! 162: return(NULL); ! 163: } ! 164: } else { ! 165: ci->right = NULL; ! 166: } ! 167: ! 168: ! 169: /* ! 170: * See if we have one or two files, and set the state accordingly ! 171: */ ! 172: if ( ! ci->left && !ci->right) { ! 173: /* two NULL files - this is wrong */ ! 174: return(NULL); ! 175: } ! 176: ! 177: ! 178: /* Set the tag (title field) for this item. If the ! 179: * two files have names that match, we use just that name - ! 180: * otherwise we use both names separated by a colon 'left : right'. ! 181: * ! 182: * In both cases, use the names relative to compare root (the ! 183: * names will certainly be different if we compare the abs paths) ! 184: */ ! 185: str1 = dir_getrelname(leftname); ! 186: str2 = dir_getrelname(rightname); ! 187: ! 188: /* If only one file - set name to that */ ! 189: if (ci->left == NULL) { ! 190: ci->tag = ci_copytext(str2); ! 191: } else if (ci->right == NULL) { ! 192: ci->tag = ci_copytext(str1); ! 193: } else { ! 194: if (lstrcmpi(str1, str2) == 0) { ! 195: ci->tag = ci_copytext(str2); ! 196: } else { ! 197: wsprintf(buf, "%s : %s", str1, str2); ! 198: ci->tag = ci_copytext(buf); ! 199: } ! 200: } ! 201: ! 202: dir_freerelname(leftname, str1); ! 203: dir_freerelname(leftname, str2); ! 204: ! 205: ! 206: if (ci->left == NULL) { ! 207: str1 = dir_getroot_item(rightname); ! 208: wsprintf(buf, "only in %s", str1); ! 209: dir_freeroot_item(rightname, str1); ! 210: ! 211: ci->result = ci_copytext(buf); ! 212: ci->state = STATE_FILERIGHTONLY; ! 213: } else if (ci->right == NULL) { ! 214: str1 = dir_getroot_item(leftname); ! 215: wsprintf(buf, "only in %s", str1); ! 216: dir_freeroot_item(leftname, str1); ! 217: ! 218: ci->result = ci_copytext(buf); ! 219: ci->state = STATE_FILELEFTONLY; ! 220: } else { ! 221: /* two files - are they the same ? compare ! 222: * the file sizes ! 223: */ ! 224: ! 225: ! 226: if (dir_getfilesize(leftname) != dir_getfilesize(rightname)) ! 227: { ! 228: ci->state = STATE_DIFFER; ! 229: ci->result = ci_copytext("different sizes"); ! 230: } else if (!fExact){ ! 231: ci->result = ci_copytext("same size"); ! 232: ci->state = STATE_SAME; ! 233: } else { ! 234: ci->result = ci_copytext("identical"); ! 235: ci->state = STATE_SAME; ! 236: } ! 237: } ! 238: ! 239: ! 240: #if FALSE ! 241: if (dir_getfilesize(leftname) == dir_getfilesize(rightname)) { ! 242: if ( !fExact ) ! 243: { ! 244: ci->result = ci_copytext("same size etc."); ! 245: ci->state = STATE_SAME; ! 246: } else { ! 247: ci->result = ci_copytext("files differ"); ! 248: ci->state = STATE_DIFFER; ! 249: ci->result = ci_copytext("files differ"); ! 250: } ! 251: } else { ! 252: ci->result = ci_copytext("files differ"); ! 253: ci->state = STATE_DIFFER; ! 254: } ! 255: } ! 256: #endif ! 257: ! 258: /* ! 259: * Building the section lists and composite lists can wait ! 260: * until needed. ! 261: */ ! 262: return(ci); ! 263: } /* compitem_new */ ! 264: ! 265: /*************************************************************************** ! 266: * Function: compitem_delete ! 267: * ! 268: * Purpose: ! 269: * ! 270: * Deletes a compitem and free all associated data. ! 271: * ! 272: * Comments: ! 273: * ! 274: * If the ci->bDiscard flag is set, the compitem was alloc-ed on a list, ! 275: * and should not be discarded (the list itself will be deleted). ! 276: * ! 277: * The DIRDATA we were passed are not deleted. the filedata, lines ! 278: * and sections are. ! 279: ***************************************************************************/ ! 280: void ! 281: compitem_delete(COMPITEM ci) ! 282: { ! 283: if (ci == NULL) { ! 284: return; ! 285: } ! 286: ! 287: compitem_discardsections(ci); ! 288: ! 289: /* Delete the two filedatas (and associated line lists) */ ! 290: file_delete(ci->left); ! 291: file_delete(ci->right); ! 292: ! 293: /* text we allocated */ ! 294: gmem_free(hHeap, ci->tag, lstrlen(ci->tag) + 1); ! 295: gmem_free(hHeap, ci->result, lstrlen(ci->result) + 1); ! 296: ! 297: /* Free the compitem struct itself if not alloced on a list */ ! 298: if (ci->bDiscard) { ! 299: gmem_free(hHeap, (LPSTR) ci, sizeof(struct compitem)); ! 300: } ! 301: } ! 302: ! 303: ! 304: /* ! 305: /*************************************************************************** ! 306: * Function: compitem_discardsections ! 307: * ! 308: * Purpose: ! 309: * ! 310: * To discard sections - throw away cached information relating to the ! 311: * comparison (but not the files if they are read into memory). This ! 312: * is used to force a re-compare if changes in the comparison options ! 313: * are made ! 314: * ! 315: ***************************************************************************/ ! 316: void ! 317: compitem_discardsections(COMPITEM ci) ! 318: { ! 319: /* delete the lists of sections we built */ ! 320: if (ci == NULL) { ! 321: return; ! 322: } ! 323: if (ci->secs_composite) { ! 324: section_deletelist(ci->secs_composite); ! 325: ci->secs_composite = NULL; ! 326: } ! 327: if (ci->secs_left) { ! 328: section_deletelist(ci->secs_left); ! 329: ci->secs_left = NULL; ! 330: } ! 331: if (ci->secs_right) { ! 332: section_deletelist(ci->secs_right); ! 333: ci->secs_right = NULL; ! 334: } ! 335: ! 336: /* reset the line lists to throw away cached hash codes and links */ ! 337: if (ci->left != NULL) { ! 338: file_reset(ci->left); ! 339: } ! 340: if (ci->right != NULL) { ! 341: file_reset(ci->right); ! 342: } ! 343: ! 344: } ! 345: ! 346: /*************************************************************************** ! 347: * Function: compitem_getcomposite ! 348: * ! 349: * Purpose: ! 350: * ! 351: * To get the handle for the composite section list ! 352: * ! 353: ***************************************************************************/ ! 354: LIST ! 355: compitem_getcomposite(COMPITEM ci) ! 356: { ! 357: if (ci == NULL) { ! 358: return NULL; ! 359: } ! 360: /* ! 361: * do the comparison if we haven't already done it ! 362: */ ! 363: if (ci->secs_composite == NULL) { ! 364: ci_makecomposite(ci); ! 365: } ! 366: ! 367: return(ci->secs_composite); ! 368: } ! 369: ! 370: /*************************************************************************** ! 371: * Function: compitem_getleftsections ! 372: * ! 373: * Purpose: ! 374: * ! 375: * To get the handle for the list of sections in the left file ! 376: * ! 377: ***************************************************************************/ ! 378: LIST ! 379: compitem_getleftsections(COMPITEM ci) ! 380: { ! 381: if (ci == NULL) { ! 382: return NULL; ! 383: } ! 384: /* ! 385: * do the comparison if we haven't already done it ! 386: */ ! 387: if (ci->secs_composite == NULL) { ! 388: ci_makecomposite(ci); ! 389: } ! 390: ! 391: return(ci->secs_left); ! 392: } ! 393: ! 394: /*************************************************************************** ! 395: * Function: compitem_getrightsections ! 396: * ! 397: * Purpose: ! 398: * ! 399: * To get the handle for the list of sections in the right file ! 400: * ! 401: ***************************************************************************/ ! 402: LIST ! 403: compitem_getrightsections(COMPITEM ci) ! 404: { ! 405: if (ci == NULL) { ! 406: return NULL; ! 407: } ! 408: /* ! 409: * do the comparison if we haven't already done it ! 410: */ ! 411: if (ci->secs_composite == NULL) { ! 412: ci_makecomposite(ci); ! 413: } ! 414: ! 415: return(ci->secs_right); ! 416: } ! 417: ! 418: /*************************************************************************** ! 419: * Function: compitem_getleftfile ! 420: * ! 421: * Purpose: ! 422: * ! 423: * To get the handle to the left file itself ! 424: * ! 425: ***************************************************************************/ ! 426: FILEDATA ! 427: compitem_getleftfile(COMPITEM ci) ! 428: { ! 429: if (ci == NULL) { ! 430: return(NULL); ! 431: } ! 432: return(ci->left); ! 433: } ! 434: ! 435: /*************************************************************************** ! 436: * Function: compitem_getrightfile ! 437: * ! 438: * Purpose: ! 439: * ! 440: * To get the handle to the right file itself ! 441: * ! 442: ***************************************************************************/ ! 443: FILEDATA ! 444: compitem_getrightfile(COMPITEM ci) ! 445: { ! 446: if (ci == NULL) { ! 447: return(NULL); ! 448: } ! 449: return(ci->right); ! 450: } ! 451: ! 452: /*************************************************************************** ! 453: * Function: compitem_getstate ! 454: * ! 455: * Purpose: ! 456: * ! 457: * To get the state (compare result) of this compitem ! 458: * ! 459: ***************************************************************************/ ! 460: int ! 461: compitem_getstate(COMPITEM ci) ! 462: { ! 463: if (ci == NULL) { ! 464: return(0); ! 465: } ! 466: return(ci->state); ! 467: } ! 468: ! 469: /*************************************************************************** ! 470: * Function: compitem_gettext_tag ! 471: * ! 472: * Purpose: ! 473: * ! 474: * To get the tag (text for the compitem title) ! 475: * ! 476: ***************************************************************************/ ! 477: LPSTR ! 478: compitem_gettext_tag(COMPITEM ci) ! 479: { ! 480: if (ci == NULL) { ! 481: return(NULL); ! 482: } ! 483: return(ci->tag); ! 484: } ! 485: ! 486: /*************************************************************************** ! 487: * Function: compitem_gettext_result ! 488: * ! 489: * Purpose: ! 490: * ! 491: * To get the result text (text equiv of state) ! 492: * ! 493: ***************************************************************************/ ! 494: LPSTR ! 495: compitem_gettext_result(COMPITEM ci) ! 496: { ! 497: if (ci == NULL) { ! 498: return(NULL); ! 499: } ! 500: return(ci->result); ! 501: } ! 502: ! 503: /*************************************************************************** ! 504: * Function: compitem_getfilename ! 505: * ! 506: * Purpose: ! 507: * ! 508: * To return the name of the file associated with this compitem. The option ! 509: * argument (one of CI_LEFT, CI_RIGHT, CI_COMP) indicates which file ! 510: * is required. ! 511: * ! 512: * Comments: ! 513: * ! 514: * CI_LEFT and CI_RIGHT just result in calls to dir_getopenname to get ! 515: * an open-able filename. ! 516: * ! 517: * For CI_COMP, we create a temporary file, write out all the text in the ! 518: * composite section list to this file, and then pass the name of the ! 519: * temporary file to the caller. This file will be deleted on ! 520: * the call to compitem_freefilename(). ! 521: * ! 522: ***************************************************************************/ ! 523: LPSTR ! 524: compitem_getfilename(COMPITEM item, int option) ! 525: { ! 526: LPSTR fname; ! 527: LINE line; ! 528: LPSTR tag, text; ! 529: SECTION sec; ! 530: OFSTRUCT os; ! 531: int fh; ! 532: ! 533: if (item == NULL) { ! 534: return(NULL); ! 535: } ! 536: ! 537: switch(option) { ! 538: case CI_LEFT: ! 539: if (item->left != NULL) { ! 540: return(dir_getopenname(file_getdiritem(item->left))); ! 541: } else { ! 542: return(NULL); ! 543: } ! 544: ! 545: case CI_RIGHT: ! 546: if (item->right != NULL) { ! 547: return(dir_getopenname(file_getdiritem(item->right))); ! 548: } else { ! 549: return(NULL); ! 550: } ! 551: ! 552: case CI_COMP: ! 553: ! 554: /* caller has asked for the filename of the composite file. ! 555: * we need to create a temporary file and write the ! 556: * lines in the composite section list out to it. ! 557: */ ! 558: fname = gmem_get(hHeap, MAX_PATH); ! 559: GetTempPath(MAX_PATH, fname); ! 560: GetTempFileName(fname, "wdf", 0, fname); ! 561: ! 562: fh = OpenFile(fname, &os, OF_READWRITE|OF_SHARE_DENY_NONE); ! 563: if (fh < 0) { ! 564: MessageBox(NULL, "Cannot open temp file", "Error", MB_OK | MB_ICONSTOP); ! 565: return(NULL); ! 566: } ! 567: ! 568: /* make sure the composite list has been built */ ! 569: ! 570: if (item->secs_composite == NULL) { ! 571: ci_makecomposite(item); ! 572: } ! 573: ! 574: /* write out every line in every section on the composite ! 575: * list to the temp file. ! 576: */ ! 577: List_TRAVERSE(item->secs_composite, sec) { ! 578: ! 579: /* get the tag field based on the section state*/ ! 580: switch(section_getstate(sec)) { ! 581: case STATE_SAME: ! 582: tag = " "; ! 583: break; ! 584: ! 585: case STATE_LEFTONLY: ! 586: tag = " <! "; ! 587: break; ! 588: case STATE_RIGHTONLY: ! 589: tag = " !> "; ! 590: break; ! 591: ! 592: case STATE_MOVEDLEFT: ! 593: tag = " <- "; ! 594: break; ! 595: ! 596: case STATE_MOVEDRIGHT: ! 597: tag = " -> "; ! 598: break; ! 599: } ! 600: ! 601: /* write out each line in this section. ! 602: * non-standard traverse of list as we only ! 603: * want to go from section first to section last ! 604: * inclusive. ! 605: */ ! 606: for (line = section_getfirstline(sec); ! 607: line != NULL; ! 608: line = List_Next(line) ) { ! 609: ! 610: text = line_gettext(line); ! 611: ! 612: /* write out to file */ ! 613: _lwrite(fh, tag, lstrlen(tag)); ! 614: _lwrite(fh, text, lstrlen(text)); ! 615: ! 616: if (line == section_getlastline(sec)) { ! 617: break; ! 618: } ! 619: } ! 620: } ! 621: ! 622: /* now close the file and return its name */ ! 623: _lclose(fh); ! 624: return(fname); ! 625: ! 626: ! 627: default: ! 628: MessageBox(NULL, "Bad argument", "Error", MB_OK | MB_ICONSTOP); ! 629: return(NULL); ! 630: } ! 631: } ! 632: ! 633: /*************************************************************************** ! 634: * Function: compitem_freefilename ! 635: * ! 636: * Purpose: ! 637: * ! 638: * Free memory created by a call to compitem_getfilename. If a temporary ! 639: * file was created, this may cause it to be deleted. The option argument must ! 640: * be the same as passed to the original compitem_getfilename call. ! 641: * ! 642: * If we created a temporary file for CI_COMP, then delete it; otherwise, ! 643: * just pass the name to dir_freeopenname. ! 644: * ! 645: ***************************************************************************/ ! 646: void ! 647: compitem_freefilename(COMPITEM item, int option, LPSTR filename) ! 648: { ! 649: OFSTRUCT os; ! 650: ! 651: ! 652: if ((item == NULL) || (filename == NULL)) { ! 653: return; ! 654: } ! 655: ! 656: switch(option) { ! 657: ! 658: case CI_LEFT: ! 659: dir_freeopenname(file_getdiritem(item->left), filename); ! 660: break; ! 661: ! 662: case CI_RIGHT: ! 663: dir_freeopenname(file_getdiritem(item->right), filename); ! 664: break; ! 665: ! 666: case CI_COMP: ! 667: ! 668: /* this is a temporary file we created. Delete it. */ ! 669: OpenFile(filename, &os, OF_DELETE); ! 670: ! 671: gmem_free(hHeap, filename, MAX_PATH); ! 672: break; ! 673: } ! 674: } ! 675: ! 676: ! 677: /*************************************************************************** ! 678: * Function: ci_copytext ! 679: * ! 680: * Purpose: ! 681: * ! 682: * To alloc a buffer large enough for the text string and copy the text into ! 683: * it and return a pointer to the string. ! 684: * ! 685: ***************************************************************************/ ! 686: LPSTR ! 687: ci_copytext(LPSTR in) ! 688: { ! 689: LPSTR out; ! 690: ! 691: if (in == NULL) { ! 692: out = gmem_get(hHeap, 1); ! 693: out[0] = '\0'; ! 694: } else { ! 695: out = gmem_get(hHeap, lstrlen(in) + 1); ! 696: lstrcpy(out, in); ! 697: } ! 698: return(out); ! 699: } ! 700: ! 701: /*************************************************************************** ! 702: * Function: ci_onesection ! 703: * ! 704: * Purpose: ! 705: * ! 706: * To make a list containing a single section from the whole list of lines ! 707: * ! 708: ***************************************************************************/ ! 709: LIST ! 710: ci_onesection(FILEDATA file) ! 711: { ! 712: LIST lines; ! 713: LIST sections; ! 714: SECTION section; ! 715: ! 716: lines = file_getlinelist(file); ! 717: ! 718: /* create a null list */ ! 719: sections = List_Create(); ! 720: ! 721: /* tell the section to create itself on the end of this list. */ ! 722: section = section_new(List_First(lines), List_Last(lines), sections); ! 723: section_setstate(section, STATE_SAME); ! 724: ! 725: ! 726: return(sections); ! 727: } ! 728: ! 729: ! 730: ! 731: /*************************************************************************** ! 732: * Function: ci_makecomposite ! 733: * ! 734: * Purpose: ! 735: * ! 736: * Compare the two files and build the composite list. This function is ! 737: * called whenever we need one of the section lists and only does the ! 738: * comparison if the composite list does not already exist. ! 739: * ! 740: ***************************************************************************/ ! 741: void ! 742: ci_makecomposite(COMPITEM ci) ! 743: { ! 744: if (ci->secs_composite != NULL) { ! 745: return; ! 746: } ! 747: ! 748: /* if there is only one file, make a single item list ! 749: * of sections ! 750: */ ! 751: if (ci->left == NULL) { ! 752: ci->secs_left = NULL; ! 753: ci->secs_right = ci_onesection(ci->right); ! 754: ! 755: /* make a second list, not a pointer to the first ! 756: * or we will get confused when deleting ! 757: */ ! 758: ci->secs_composite = ci_onesection(ci->right); ! 759: return; ! 760: } else if (ci->right == NULL) { ! 761: ci->secs_right = NULL; ! 762: ci->secs_left = ci_onesection(ci->left); ! 763: ! 764: /* make a second list, not a pointer to the first ! 765: * or we will get confused when deleting ! 766: */ ! 767: ci->secs_composite = ci_onesection(ci->left); ! 768: return; ! 769: } ! 770: ! 771: /* we have two files - we need to compare them fully */ ! 772: ci_compare(ci); ! 773: } ! 774: ! 775: /*************************************************************************** ! 776: * Function: ci_compare ! 777: * ! 778: * Purpose: ! 779: * ! 780: * Compare files and build a composite list. ! 781: * ! 782: * Comments: ! 783: * ! 784: * Comparison method: ! 785: * ! 786: * 0 Break each file into lines and hash each line. Lines which ! 787: * don't match can be rapidly eliminated by comparing the hash code. ! 788: * ! 789: * Store the hash codes in a binary search tree that ! 790: * will give for each hash code the number of times that it ! 791: * occurred in each file and one of the lines where it occurred ! 792: * in each file. The tree is used to rapidly find the partner ! 793: * of a line which occurs exactly once in each file. ! 794: * ! 795: * 1 Make a section covering the whole file (for both) ! 796: * and link unique lines between these sections (i.e. link lines ! 797: * which occur exactly once in each file as they must match each other). ! 798: * These are referred to as anchor points. ! 799: * ! 800: * 2 Build section lists for both files by traversing line lists and ! 801: * making a section for each set of adjacent lines that are unmatched ! 802: * and for each set of adjacent lines that match a set of adjacent ! 803: * lines in the other file. In making a section we start from a ! 804: * known matching line and work both forwards and backwards through ! 805: * the file including lines which match, whether they are unique or not. ! 806: * ! 807: * 3 Establish links between sections that match ! 808: * and also between sections that don't match but do ! 809: * correspond (by position in file between matching sections) ! 810: * ! 811: * 4 For each section pair that don't match but do correspond, ! 812: * link up matching lines unique within that section. (i.e. do ! 813: * the whole algorithm again on just this section). ! 814: * ! 815: * There may be some lines which occur many times over in each file. ! 816: * As these occurrences are matched up, so the number left to match ! 817: * reduces, and may reach one in each file. At this point these two ! 818: * can be matched. Therefore we... ! 819: * ! 820: * Repeat steps 0-4 until no more new links are added, but (especially ! 821: * in step 0) we only bother with lines which have not yet been matched. ! 822: * This means that a line which has only one unmatched instance in each ! 823: * file gets a count of one and so is a new anchor point. ! 824: * ! 825: * Finally build a composite list from the two lists of sections. ! 826: * ! 827: ***************************************************************************/ ! 828: void ! 829: ci_compare(COMPITEM ci) ! 830: { ! 831: LIST lines_left, lines_right; ! 832: SECTION whole_left, whole_right; ! 833: BOOL bChanges; ! 834: ! 835: /* get the list of lines for each file */ ! 836: lines_left = file_getlinelist(ci->left); ! 837: lines_right = file_getlinelist(ci->right); ! 838: ! 839: if ((lines_left == NULL) || (lines_right == NULL)) { ! 840: ci->secs_left = NULL; ! 841: ci->secs_right = NULL; ! 842: ci->secs_composite = NULL; ! 843: return; ! 844: } ! 845: ! 846: do { ! 847: ! 848: /* we have made no changes so far this time round the ! 849: * loop ! 850: */ ! 851: bChanges = FALSE; ! 852: ! 853: /* make a section covering the whole file */ ! 854: whole_left = section_new(List_First(lines_left), ! 855: List_Last(lines_left), NULL); ! 856: ! 857: whole_right = section_new(List_First(lines_right), ! 858: List_Last(lines_right), NULL); ! 859: ! 860: /* link up matching unique lines between these sections */ ! 861: if (section_match(whole_left, whole_right)) { ! 862: bChanges = TRUE; ! 863: } ! 864: ! 865: /* delete the two temp sections */ ! 866: section_delete(whole_left); ! 867: section_delete(whole_right); ! 868: ! 869: /* discard previous section lists if made */ ! 870: if (ci->secs_left) { ! 871: section_deletelist(ci->secs_left); ! 872: ci->secs_left = NULL; ! 873: } ! 874: if (ci->secs_right) { ! 875: section_deletelist(ci->secs_right); ! 876: ci->secs_right = NULL; ! 877: } ! 878: /* build new section lists for both files */ ! 879: ci->secs_left = section_makelist(lines_left, TRUE); ! 880: ci->secs_right = section_makelist(lines_right, FALSE); ! 881: ! 882: /* match up sections - make links and corresponds between ! 883: * sections. Attempts to section_match corresponding ! 884: * sections that are not matched. returns true if any ! 885: * further links were made ! 886: */ ! 887: if (section_matchlists(ci->secs_left, ci->secs_right)) { ! 888: bChanges = TRUE; ! 889: } ! 890: ! 891: /* repeat as long as we keep adding new links */ ! 892: ! 893: } while (bChanges); ! 894: ! 895: /* all possible lines linked, and section lists made . ! 896: * combine the two section lists to get a view of the ! 897: * whole comparison - the composite section list. This also ! 898: * sets the state of each section in the composite list. ! 899: */ ! 900: ci->secs_composite = section_makecomposite(ci->secs_left, ci->secs_right); ! 901: ! 902: } ! 903: ! 904: ! 905: ! 906: ! 907: ! 908: ! 909: ! 910: ! 911:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.