/* * Copyright 1995, 1996 Perforce Software. All rights reserved. * * This file is part of Perforce - the FAST SCM System. */ # include # include # include # include # include # include # include # include # include # include # include "clientuser.h" # include "clientmerge.h" # include "clientmerge3.h" static const char *const mergeHelp[] = { "Three-way merge options:", "", " Accept:", " at Keep only changes to their file.", " ay Keep only changes to your file.", " am Keep merged file.", " ae Keep merged and edited file.", " a Keep autoselected file.", "", " Diff:", " dt See their changes alone.", " dy See your changes alone.", " dm See merged changes.", " d Diff your file against merged file.", "", " Edit:", " et Edit their file (read only).", " ey Edit your file (read/write).", " e Edit merged file (read/write).", "", " Misc:", " m Run '$P4MERGE base theirs yours merged'.", " s Skip this file.", " h Print this help message.", " ^C Quit the resolve operation.", "", "The autoselected 'accept' option is shown in []'s on the prompt.", "", 0 }; ClientMerge3::ClientMerge3( ClientUser *ui, FileSysType type, FileSysType resType, FileSysType theirType, FileSysType baseType ) { // Save UI for future use this->ui = ui; // Set up files. yours = ui->File( type ); result = ui->File( resType ); theirs = ui->File( theirType ); base = ui->File( baseType ); // make base,theirs,result temp base->SetDeleteOnClose(); theirs->SetDeleteOnClose(); result->SetDeleteOnClose(); // Digests for seeing if edited result matches inputs yoursMD5 = new MD5; theirsMD5 = new MD5; resultMD5 = new MD5; showAll = 0; theirs_cvt = NULL; result_cvt = NULL; } ClientMerge3::~ClientMerge3() { delete yours; delete base; delete theirs; delete result; delete yoursMD5; delete theirsMD5; delete resultMD5; delete theirs_cvt; delete result_cvt; } void ClientMerge3::SetNames( StrPtr *b, StrPtr *t, StrPtr *y ) { int i; StrPtr n = StrRef::Null(); if( !b ) b = &n; if( !t ) t = &n; if( !y ) y = &n; for( i = 0; i < MarkerLast; i++ ) markertab[i].Clear(); markertab[ MarkerOriginal ] << ">>>> ORIGINAL " << b; markertab[ MarkerTheirs ] << "==== THEIRS " << t; markertab[ MarkerYours ] << "==== YOURS " << y; markertab[ MarkerBoth ] << "==== BOTH " << t << " " << y; markertab[ MarkerEnd ] << "<<<<"; } void ClientMerge3::Open( StrPtr *name, Error *e, CharSetCvt *cvt, int charset ) { // No names? if( !markertab[0].Length() ) SetNames( 0, 0, 0 ); // Open the various temps for writing. // Figure if the first one succeeds then the others // probably will, too. yours->Set( *name ); if( charset ) { base->SetContentCharSetPriv( charset ); theirs->SetContentCharSetPriv( charset ); yours->SetContentCharSetPriv( charset ); result->SetContentCharSetPriv( charset ); } base->MakeLocalTemp( name->Text() ); theirs->MakeLocalTemp( name->Text() ); result->MakeLocalTemp( name->Text() ); base->Open( FOM_WRITE, e ); if( e->Test() ) return; result->Perms( FPM_RW ); theirs->Open( FOM_WRITE, e ); result->Open( FOM_WRITE, e ); if( cvt ) { theirs_cvt = cvt->Clone(); result_cvt = cvt->Clone(); base->Translator( cvt ); theirs->Translator( theirs_cvt ); result->Translator( result_cvt ); } // And zonk counters for chunks chunksYours = chunksTheirs = chunksConflict = chunksBoth = 0; oldBits = 0; markersInFile = 0; needNl = 0; } void ClientMerge3::Write( StrPtr *buf, StrPtr *bits, Error *e ) { Marker3 marker = MarkerOriginal; int b = bits ? bits->Atoi() : 0; if( oldBits && oldBits != b ) { switch( b ) { case SEL_BASE|SEL_CONF: ++chunksConflict; default: case SEL_BASE: case SEL_BASE|SEL_LEG1: case SEL_BASE|SEL_LEG2: marker = MarkerOriginal; break; case SEL_LEG1|SEL_RSLT: ++chunksTheirs; case SEL_LEG1|SEL_RSLT|SEL_CONF: marker = MarkerTheirs; break; case SEL_LEG2|SEL_RSLT: ++chunksYours; case SEL_LEG2|SEL_RSLT|SEL_CONF: marker = MarkerYours; break; case SEL_LEG1|SEL_LEG2|SEL_RSLT: marker = MarkerBoth; ++chunksBoth; break; case SEL_ALL: marker = MarkerEnd; break; } if( showAll || b & SEL_CONF || b == SEL_ALL && oldBits & SEL_CONF ) { if( needNl ) result->Write( "\n", 1, e ); result->Write( &markertab[ marker ], e ); result->Write( "\n", 1, e ); ++markersInFile; } } oldBits = b; // Just a shortcut - we get back empty buffers as marker placeholders. if( !buf->Length() ) return; // Write to each file, according to the bits. // We don't need to write 'yours', because that is what is // already on the client. // We compute the md5 digest of each file at this point. // We'll use that later to provide a default for 'accept'. // The extra check in writing result is that we want to write // out the original version (the base) for any conflicts. If // a chunk is only in the base, then leg1 and leg2 must be in // conflict for that chunk. if( b & SEL_BASE ) { base->Write( buf, e ); // no base digest -- can't accept it } if( b & SEL_LEG1 ) { theirs->Write( buf, e ); theirsMD5->Update( *buf ); } if( b & SEL_LEG2 ) { // no writing yours -- already there! yoursMD5->Update( *buf ); } if( b & SEL_RSLT ) { resultMD5->Update( *buf ); } if( ( b & SEL_RSLT ) || showAll || b == ( SEL_BASE | SEL_CONF ) ) { result->Write( buf, e ); } // If this block didn't end in a linefeed, we may need to add // one before putting out the next marker. This can happen if // some yoyo has a conflict on the last line of a file, and that // line has no newline. needNl = buf->Text()[ buf->Length() - 1 ] != '\n'; } void ClientMerge3::Close( Error *e ) { base->Close( e ); theirs->Close( e ); result->Close( e ); theirsMD5->Final( theirsDigest ); yoursMD5->Final( yoursDigest ); resultMD5->Final( resultDigest ); } void ClientMerge3::Chmod( const char *perms, Error *e ) { yours->Chmod2( perms, e ); } MergeStatus ClientMerge3::AutoResolve( MergeForce force ) { /* * Automatic logic: */ /* If showing all markers, always merge */ /* If conflict -- skip or merge (if forced) */ /* If we have no unique changes, accept theirs */ /* If they have no unique changes, take ours */ /* If we both have changes -- merge or skip (if safe). */ Error e; e.Set( MsgClient::MergeMsg3 ) << chunksYours << chunksTheirs << chunksBoth << chunksConflict; ui->Message( &e ); if( showAll && force == CMF_FORCE ) return CMS_EDIT; if( chunksConflict ) return force == CMF_FORCE ? CMS_EDIT : CMS_SKIP; /* Now we know there are no conflicts. */ if( !chunksYours ) return CMS_THEIRS; if( !chunksTheirs ) return CMS_YOURS; // There can be markers in the file without conflicts if // showAll (resolve -v) was selected. if( markersInFile ) return force == CMF_FORCE ? CMS_EDIT : CMS_SKIP; /* We both have changes. */ switch( force ) { case CMF_AUTO: return CMS_MERGED; case CMF_SAFE: return CMS_SKIP; case CMF_FORCE: return CMS_MERGED; } /* not reached */ return CMS_SKIP; } MergeStatus ClientMerge32::AutoResolve( MergeForce force ) { /* * It's just a two-way diff, so we accept theirs if forced * to or if there are no differences. */ Error e; e.Set( MsgClient::MergeMsg32 ) << chunksTheirs; ui->Message( &e ); /* Hmmm. showAll for 32? I don't think so. */ /* But just in case. */ if( showAll && force == CMF_FORCE ) return CMS_EDIT; /* No changes -- better to take theirs */ if( !chunksTheirs ) return CMS_THEIRS; /* Some changes */ switch( force ) { case CMF_AUTO: return CMS_SKIP; case CMF_SAFE: return CMS_SKIP; case CMF_FORCE: return CMS_THEIRS; } /* not reached */ return CMS_SKIP; } MergeStatus ClientMerge3::Resolve( Error *e ) { /* If the files are identical, autoaccept theirs */ /* We prefer theirs over ours, because then integration history */ /* marks it as a "copy" and we know the files are now identical. */ /* Note that this silently swallows chunksBoth... */ /* get autoresolve's suggestion */ MergeStatus autoStat = AutoResolve( CMF_FORCE ); /* Iteratively prompt the user for what to do. */ StrBuf buf; for(;;) { const char *autoSuggest; int resultEdited = 0; // default action: edit if conflict, else accept suggestion // made by autoResolve. switch( autoStat ) { default: case CMS_SKIP: autoSuggest = "s" ; break; case CMS_THEIRS: autoSuggest = "at" ; break; case CMS_YOURS: autoSuggest = "ay" ; break; case CMS_MERGED: autoSuggest = "am" ; break; case CMS_EDIT: autoSuggest = markersInFile ? "e" : "ae"; break; } // Prompt. If no response, use auto buf.Clear(); e->Clear(); e->Set( MsgClient::MergePrompt ) << autoSuggest; e->Fmt( buf, EF_PLAIN ); e->Clear(); ui->Prompt( buf, buf, 0, e ); if( e->Test() ) return CMS_QUIT; if( !buf[0] ) buf = autoSuggest; // Do the user-requested operation # define pair( a, b ) ( (a) << 8 | (b) ) switch( pair( buf[0], buf[1] ) ) { case pair( 'a', 0 ): // take suggestion // But if merged, check for conflicts. if( autoStat != CMS_EDIT ) return autoStat; // fall through case pair( 'a', 'e' ): // accept edited result if( markersInFile ) { e->Set( MsgClient::ConfirmMarkers ); if ( !Verify( e, e ) ) break; } return CMS_EDIT; case pair( 'a', 'm' ): // accept result if( autoStat == CMS_EDIT ) { e->Set( MsgClient::ConfirmEdit ); if ( !Verify( e, e ) ) break; } return CMS_MERGED; case pair( 'a', 't' ): // accept theirs if( chunksYours + chunksConflict ) { e->Set( MsgClient::Confirm ); if ( !Verify( e, e ) ) break; } return CMS_THEIRS; case pair( 'a', 'y' ): // accept yours return CMS_YOURS; case pair( 'e', 't' ): // edit theirs ui->Edit( theirs, e ); break; case pair( 'e', 'y' ): // edit yours ui->Edit( yours, e ); break; case pair( 'e', 0 ): // edit the merged result // If no markers are left in the file, zero the // conflict count. Once edited, the default becomes // to accept the merge. ui->Edit( result, e ); resultEdited = 1; break; case pair( 'd', 't' ): // diff theirs ui->Diff( base, theirs, 1, flags.Text(), e ); break; case pair( 'd', 'y' ): // diff yours ui->Diff( base, yours, 1, flags.Text(), e ); break; case pair( 'd', 'm' ): // diff merge ui->Diff( base, result, 1, flags.Text(), e ); break; case pair( 'd', 0 ): // diff result ui->Diff( yours, result, 1, flags.Text(), e ); break; case pair( 'm', 0 ): // merge ui->Merge( base, theirs, yours, result, e ); resultEdited = 1; break; case pair( 's', 0 ): // skip return CMS_SKIP; case pair( '?', 0 ): case pair( 'h', 0 ): // help ui->Help( mergeHelp ); break; default: e->Set( MsgClient::BadFlag ); break; } // If the result was edited, we're going to have to // try to pick a new result. We have the digest of // yours/theirs/result, so we just compute the digest // of the current result and see which it matches. // If none match, it's an original edit. if( !e->Test() && resultEdited ) { autoStat = DetectResolve(); // Edited result has markers if (a) it // isn't theirs/yours/merged, (b) it had markers before, // and (c) CheckForMarkers() finds some. markersInFile = markersInFile && autoStat == CMS_EDIT && CheckForMarkers( result, e ); // If the edited result equals yours, suggest edit instead. // In most cases if the user has picked out the yours diff // in an editor, they will want to reverse-integrate it. if( autoStat == CMS_YOURS ) autoStat = CMS_EDIT; } // Report Errors if( e->Test() ) { ui->Message( e ); e->Clear(); } } } void ClientMerge3::Select( MergeStatus stat, Error *e ) { // Given the automatic or manual selection, now move the proper // file into place. Usually it is already in place. switch( stat ) { case CMS_THEIRS: // accept theirs theirs->Chmod( FPM_RW, e ); theirs->Rename( yours, e ); if( e->Test() ) return; // in case the file type has changed, move the filesys objects // around to leave the yours object with a result file type theirs->Set( yours->Name() ); delete yours; yours = theirs; theirs = NULL; return; case CMS_MERGED: case CMS_EDIT: // accept result result->Rename( yours, e ); if( e->Test() ) return; // in case the file type has changed, move the filesys objects // around to leave the yours object with a result file type result->Set( yours->Name() ); delete yours; yours = result; result = NULL; return; default: return; } } int ClientMerge3::CheckForMarkers( FileSys *f, Error *e ) const { StrBuf l1; int markers = 0; f->Open( FOM_READ, e ); if( e->Test() ) return 0; while( !markers ) { if( !f->ReadLine( &l1, e ) ) break; if( !l1.Length() || !strchr( "<>==", l1.Text()[0] ) ) continue; for( int i = 0; i < MarkerLast; i++ ) if( l1 == markertab[ i ] ) ++markers; } f->Close( e ); return markers > 0; } int ClientMerge3::IsAcceptable() const { // For the GUI: no error; we'll assume a missing // result will be seen downstream! Error e; return !markersInFile || !CheckForMarkers( result, &e ); } MergeStatus ClientMerge3::DetectResolve() const { StrBuf d; Error e[1]; CharSetCvt *icvt = 0; if( result_cvt ) { icvt = result_cvt->ReverseCvt(); result->Translator( icvt ); } // Get & Compare digest of result against various legs // Blow off errors -- if we can't get to the result we'll // find out sooner or later. result->Digest( &d, e ); delete icvt; if( d == theirsDigest ) return CMS_THEIRS; else if( d == yoursDigest ) return CMS_YOURS; else if( d == resultDigest ) return CMS_MERGED; else return CMS_EDIT; } const StrPtr * ClientMerge3::GetMergeDigest() const { // If the file has conflicts, do not report merge digest if( markersInFile || chunksConflict ) return NULL; return &resultDigest; } const StrPtr * ClientMerge3::GetYourDigest() const { return &yoursDigest; } const StrPtr * ClientMerge3::GetTheirDigest() const { return &theirsDigest; }