diff.cc #1

/*
 * Copyright 1997 Perforce Software.  All rights reserved.
 *
 * This file is part of Perforce - the FAST SCM System.
 *
 * Diff code written by James Strickland, May 1997.
 */

/*
 * Diff output generators.
 */

#define NEED_TYPES
#define NEED_SLEEP
#define NEED_FILE

#include <stdhdrs.h>
#include <error.h>
#include <strbuf.h>
#include <readfile.h>
#include <filesys.h>
#include <charset.h>
#include <i18napi.h>
#include <charcvt.h>

#include "diffsp.h"
#include "diffan.h"
#include "diff.h"

// NT CRLF handling -- out output files are raw (binary) because our
// input files were raw (according to ReadFile).  So we have to handle
// the proper CR when we print our lines.

Diff::Diff()
{
	out = 0;
	spx = 0;
	spy = 0;
	diff = 0;
	flags = 0;
	lineType = LineTypeRaw;
	closeOut = 0;
	fastMaxD = 0;
	chunkCnt = 0;

# ifdef USE_CRLF
	newLines = "\r\n";
# else
	newLines = "\n";
# endif
}

Diff::~Diff()
{
	delete diff;
	delete spx;
	delete spy;
	if( closeOut ) fclose( out );
}



void
Diff::DiffUnifiedDeleteFile( FileSys *f, Error *e )
{
    StrBuf buf;

    int lineCount = 0;
    while( f->ReadLine( &buf, e ) )
        lineCount++;

    // ignore errors when diffing deleted files.
    if( e->Test() )
    {
        e->Clear();
        return;
    } 

    f->Seek( 0, e );
    fprintf( out, "@@ -1,%d +1,0 @@\n", lineCount );

    while( f->ReadLine( &buf, e ) )
        fprintf( out, "-%s\n", buf.Text() );

}
  

void
Diff::SetInput( FileSys *fx, FileSys *fy, const DiffFlags &flags, Error *e )
{
	// diff -h does it by word; see DiffWithFlags below.

	spx = new Sequence( fx, flags, e );
	this->flags = &flags;
	if( !e->Test() )
	    spy = new Sequence( fy, flags, e );

	if( e->Test() )
	    return;

	diff = new DiffAnalyze( spx, spy, fastMaxD );
}

void
Diff::SetOutput( const char *fout, Error *e )
{
	// NT CRLF handling: raw writes

#ifdef OS_NT
	// XXX Hate to have Windows specific code here but there is
	// no easy fix short of using FileSys here...
	if( CharSetApi::isUnicode((CharSetApi::CharSet)GlobalCharSet::Get()) )
	{
	    CharSetCvtUTF816 cvt;
	    int newlen = 0;

	    const char *wname = cvt.FastCvt( fout, strlen( fout ), &newlen );

	    if( newlen > ( MAX_PATH * 2 ) )
	    {
		SetLastError( ERROR_BUFFER_OVERFLOW );
		goto errorout;
	    }

	    if( cvt.LastErr() == CharSetCvt::NONE &&
		( out = _wfopen( (const wchar_t *)wname, L"wb" ) ) )
	        goto done;
	}
#endif
	// If wfopen() fails, we intentionally fall through.
	if( !( out = fopen( fout, "wb" ) ) )
	{
	errorout:
	    e->Sys( "write", fout );
	    return;
	}
done:

#ifdef OS_NT
	SetHandleInformation( (HANDLE)_get_osfhandle( fileno(out) ), 
		HANDLE_FLAG_INHERIT, 0 );
#endif

	closeOut = 1;
}

void
Diff::SetOutput( FILE *fout )
{
	out = fout;
	lineType = LineTypeLocal;
	newLines = "\n";
}

void
Diff::CloseOutput( Error *e )
{
	// If SetInput never opened a file, CloseOutput won't
	// touch it.  Normally, that means 'out' is stdout, but
	// if not, caveat caller.

	if( !closeOut )
	    return;

	// Flush and check for output error.
	// Don't stack this error against others.

	if( fflush( out ) < 0 || ferror( out ) )
	    if( !e->Test() )
		e->Sys( "write", "diff" );

	fclose( out );
	closeOut = 0;
}

void
Diff::Walker(
	const char *flags,
	Sequence *sp,
	LineNo sx, LineNo ex )
{
	sp->SeekLine( sx );

	bool lineEnd = true;

	for( ; sx < ex; ++sx ) {
	    fputs( flags, out );
	    lineEnd = sp->Dump( out, sx, sx + 1, lineType );
	}

	if( lineEnd == false && this->flags->type == DiffFlags::Unified ) 
	    fprintf(out, "\n\\ No newline at end of file\n" );
}

void
Diff::DiffWithFlags( const DiffFlags &flags )
{
	// allow 'c' and 'u' (as well as 'C' and 'U') to take a count.
	// if it breaks, it defaults to 0 (which is then treated as 3).

	switch( flags.type )
	{
	case DiffFlags::Normal:	 DiffNorm(); break;
	case DiffFlags::Context: DiffContext( flags.contextCount ); break;
	case DiffFlags::Unified: DiffUnified( flags.contextCount ); break;
	case DiffFlags::Summary: DiffSummary(); break;
	case DiffFlags::HTML: 	 DiffHTML(); break;
	case DiffFlags::Rcs:	 DiffRcs(); break;
	}
}

void		
Diff::DiffNorm()
{
	Snake *s = diff->GetSnake();
	Snake *t;

	for( ; t = s->next; s = t )
	{
	    /* Print edit operator */

	    char c;
	    LineNo nx = s->u, ny = s->v;

	    if( s->u < t->x && s->v < t->y )	c = 'c', ++nx, ++ny;
	    else if( s->u < t->x ) 		c = 'd', ++nx;
	    else if( s->v < t->y ) 		c = 'a', ++ny;
	    else				continue;

				    	fprintf( out, "%d", nx );
	    if( t->x > nx )		fprintf( out, ",%d", t->x );
				    	fprintf( out, "%c%d", c, ny );
	    if( t->y > ny )		fprintf( out, ",%d", t->y );
	    				fprintf( out, "%s", newLines );

	    /* Line lines that differ */

	    Walker( "< ", spx, s->u, t->x );

	    if( c == 'c' ) 		fprintf( out, "---%s", newLines );

	    Walker( "> ", spy, s->v, t->y );
	}
}

void
Diff::DiffRcs()
{
	Snake *s = diff->GetSnake();
	Snake *t;

	for( ; t = s->next; s = t )
	{
	    if( s->u < t->x )
	    {
		fprintf( out, "d%d %d%s", s->u + 1, t->x - s->u, newLines );
		chunkCnt++;
	    }
	    if( s->v < t->y )
	    {
		fprintf( out, "a%d %d%s", t->x, t->y - s->v, newLines );
		chunkCnt++;
		spy->SeekLine( s->v );
		spy->Dump( out, s->v, t->y, lineType );
	    }
	}
}

void
Diff::DiffHTML()
{
	Snake *s = diff->GetSnake();
	Snake *t;

	for( ; t = s->next; s = t )
	{
	    // Dump the common stuff

	    spx->SeekLine( s->x );
	    spy->SeekLine( s->v );
	    spx->Dump( out, s->x, s->u, lineType );

	    // Dump spx

	    fprintf( out, "<font color=red>" );
	    spx->Dump( out, s->u, t->x, lineType );

	    // dump spy

	    fprintf( out, "</font><font color=blue>" );
	    spy->Dump( out, s->v, t->y, lineType );

	    // Done

	    fprintf( out, "</font>" );
	}
}

/*
 * DiffUnified
 */

void
Diff::DiffUnified( int c )
{
	// s,t bound the diffs being displayed.
	// First we move t forward until the snake is bigger than
	// 2 * CONTEXT, then we display [s,t], then iterate for [t,...].

	// Remember: a snake is a matching chunk.  Diffs are inbetween
	// snakes, before the first snake, or after the last snake.

	if( c < 0 ) c = 3;
	Snake *s = diff->GetSnake();
	Snake *t;

	while( t = s->next )
	{
	    // Look for snake > 2 * CONTEXT

	    while( t->next && t->x + 2 * c >= t->u )
		t = t->next;

	    // Compute first/last lines of diff block

	    LineNo sx = s->u - c > 0 ? s->u - c : 0;
	    LineNo sy = s->v - c > 0 ? s->v - c : 0;
	    LineNo ex = t->x + c < spx->Lines() ? t->x + c : spx->Lines();
	    LineNo ey = t->y + c < spy->Lines() ? t->y + c : spy->Lines();

	    // Display [s,t]

	    fprintf( out, "@@ -%d,%d +%d,%d @@%s",
		 sx+1, ex-sx, sy+1, ey-sy, newLines );

	    // Now walk the snake between s,t, displaying the diffs

	    do
	    {
		LineNo nx = s->u;
		LineNo ny = s->v;

		Walker( " ", spx, sx, nx );

		s = s->next;
		sx = s->x;
		sy = s->y;

		Walker( "-", spx, nx, sx );
		Walker( "+", spy, ny, sy );
	    }
	    while( s != t );

	    // Display the tail of the chunk

	    Walker( " ", spx, sx, ex );
	}
}

/*
 * DiffContext
 */

void
Diff::DiffContext( int c )
{
	// s,t bound the diffs being displayed.
	// First we move t forward until the snake is bigger than
	// 2 * CONTEXT, then we display [s,t], then iterate for [t,...].

	// Remember: a snake is a matching chunk.  Diffs are inbetween
	// snakes, before the first snake, or after the last snake.

	if( c < 0 ) c = 3;
	Snake *s = diff->GetSnake();
	Snake *t;

	for( ; t = s->next; s = t )
	{
	    // Look for snake > 2 * CONTEXT

	    while( t->next && t->x + 2 * c >= t->u )
		t = t->next;

	    // Compute first/last lines of diff block

	    LineNo sx = s->u - c > 0 ? s->u - c : 0;
	    LineNo sy = s->v - c > 0 ? s->v - c : 0;
	    LineNo ex = t->x + c < spx->Lines() ? t->x + c : spx->Lines();
	    LineNo ey = t->y + c < spy->Lines() ? t->y + c : spy->Lines();

	    // Display [s,t]

	    fprintf( out, "***************%s", newLines );

	    // File 1

	    fprintf( out, "*** %d,%d ****%s", sx+1, ex, newLines );

	    // Now walk the snake between s,t, displaying the diffs

	    Snake *ss, *tt;

	    for( ss = s; ss != t; ss = tt )
	    {
		tt = ss->next;

		if( ss->u < tt->x )
		{
		    Walker( "  ", spx, sx, ss->u );
		    const char *mark = ss->v < tt->y ? "! " : "- ";
		    Walker( mark, spx, ss->u, tt->x );
		    sx = tt->x;
		}
	    }

	    if( s->u < sx )
		Walker( "  ", spx, sx, ex );

	    // File 2

	    fprintf( out, "--- %d,%d ----%s", sy+1, ey, newLines );

	    // Now walk the snake between s,t, displaying the diffs

	    for( ss = s; ss != t; ss = tt )
	    {
		tt = ss->next;

		if( ss->v < tt->y )
		{
		    Walker( "  ", spy, sy, ss->v );
		    const char *mark = ss->u < tt->x ? "! " : "+ ";
		    Walker( mark, spy, ss->v, tt->y );
		    sy = tt->y;
		}
	    }

	    if( s->v < sy )
		Walker( "  ", spy, sy, ey );
	}
}

/*
 * DiffSummary
 */

void
Diff::DiffSummary()
{
	Snake *s = diff->GetSnake();
	Snake *t;

	LineNo l_deleted = 0;
	LineNo l_added = 0;
	LineNo l_edited_in = 0;
	LineNo l_edited_out = 0;

	LineNo c_deleted = 0;
	LineNo c_added = 0;
	LineNo c_edited = 0;

	for( ; t = s->next; s = t )
	{
	    /* Print edit operator */

	    if( s->u < t->x && s->v < t->y ) 
	    {
		l_edited_in += (t->x - s->u);
		l_edited_out += (t->y - s->v);
		++c_edited;
	    } 
	    else if (s->v < t->y) 
	    {
	    	l_added += (t->y - s->v);
		++c_added;
	    } 
	    else if( s->u < t->x )
	    {
	    	l_deleted += (t->x - s->u);
		++c_deleted;
	    }
	}

	fprintf( out, 
		"add %d chunks %d lines\n"
		"deleted %d chunks %d lines\n"
		"changed %d chunks %d / %d lines\n",
			c_added, l_added,
			c_deleted, l_deleted,
			c_edited, l_edited_in, l_edited_out );
}