error.cc #1

/*
 * Copyright 1995, 2002 Perforce Software.  All rights reserved.
 */

/*
 * Error.cc - accumulate and report layered errors
 *
 * This module containts the manipulation of Error, mostly wrappers
 * of methods to the private ErrorPrivate, which are are managed in 
 * erroritms.cc.
 */

# include <stdhdrs.h>
# include <strbuf.h>
# include <strdict.h>
# include <strtable.h>
# include <strops.h>
# include <error.h>
# include <errorpvt.h>

const char *
Error::severityText[] = { "empty", "info", "warning", "error", "error" };

/*
 * Error::Error() - cheaply initialize error struct 
 *
 * Note that setting severity = E_EMPTY is all that is needed
 * to indicate no error.  Things get initialized when severity
 * gets upgraded.
 */

Error::~Error()
{
	delete ep;
}

/*
 * Error::=() - copy an Error struct, piece by piece

 * Note that this makes a shallow copy.  Use Snap() if you need a deep copy.
 */

void
Error::operator =( const Error &s )
{
	// Only severity needed if empty

	severity = s.severity;

	if( severity == E_EMPTY )
	    return;

	// Copy underbelly.

	if( !ep )
	    ep = new ErrorPrivate;

	genericCode = s.genericCode;
	if( s.ep )
	    *ep = *s.ep;
}

/*
 * Error::Set() - add an error message into an Error struct
 */

Error &		
Error::Set( const ErrorId &id )
{ 
	/* First access?  Set private. */

	if( !ep )
	    ep = new ErrorPrivate;

	/* First error?  Clear things out */

	if( severity == E_EMPTY )
	    ep->Clear();

	/* If error more severe that previous, save severity & generic */

	ErrorSeverity s = (ErrorSeverity)id.Severity();

	if( s >= severity )
	{
	    severity = s;
	    genericCode = id.Generic();
	}

	/* Now prepare the error message for formatting. */

	ep->Set( id );

	return *this;
}

Error &
Error::operator <<( const StrPtr &arg )
{
	ep->SetArg( arg );
	return *this;
}

Error &
Error::operator <<( const char *arg )
{
	ep->SetArg( StrRef( arg ) );
	return *this;
}

Error &
Error::operator <<( const StrPtr *arg )
{
	ep->SetArg( *arg );
	return *this;
}

Error &
Error::operator <<( int arg )
{
	ep->SetArg( StrNum( arg ) );
	return *this;
}

/*
 * Error::Get() - get an individual Error item
 */

ErrorId *
Error::GetId( int i ) const
{
	return !ep || i < 0 || i >= ep->errorCount ? 0 : &ep->ids[i];
}

int
Error::GetErrorCount() const
{
	return ep ? ep->errorCount : 0;
}

void
Error::LimitErrorCount()
{
	if( ep && ep->errorCount > OldErrorMax )
	    ep->errorCount = OldErrorMax;
}

/*
 * Error::GetDict() - get StrDict of error parameters
 */

StrDict *
Error::GetDict()
{
	return ep ? ep->whichDict : 0;
}

/*
 * Error::Fmt() - format an error message
 *
 * Error messages are already formatted by Set() and <<.
 */

void
Error::Fmt( StrBuf &buf, int opts ) const
{
	Fmt( -1, buf, opts );
}
void
Error::Fmt( int eno, StrBuf &buf, int opts ) const
{
	if( !severity )
	    return;

	if( !IsInfo() ) 
	    buf.Clear();

	StrBuf lfmt;
	StrPtr *l = 0;

	if( !( opts & EF_NOXLATE ) )
	{
	    lfmt.Set( "lfmt" );
	    l = &lfmt;
	}

	for( int i = ep->errorCount; i-- > 0; )
	{
	    if( eno != -1 && eno != (i+1) )
		continue;

	    if( opts & EF_CODE )
	    {
		buf << StrNum( ep->ids[ i ].UniqueCode() );
		buf.Extend( ':' );
	    }

	    if( opts & EF_INDENT ) buf.Append( "\t", 1 );

	    StrPtr *s;
	    StrRef fmt;

	    if( !l || !( s = ep->whichDict->GetVar( *l, i ) ) )
	    {
		fmt.Set( (char *)ep->ids[i].fmt );
		s = &fmt;
	    }

	    StrOps::Expand2( buf, *s, *ep->whichDict ); 

	    // Always insert; sometimes append

	    if( eno == -1 && ( i || opts & EF_NEWLINE ) )
		buf.Append( "\n", 1 );
	}
}

/*
 * Error::Snap() - after UnMarshall1, copy all data into Error
 *
 * Resulting data is local:
 *
 *	whichDict is ErrorPrivate::errorDict
 *	ids[].fmt in ErrorPrivate::marshall
 */

void
Error::Snap()
{
	// ErrorPrivate::operator = handles snapping.
	if (ep)
	    *ep = *ep;
}

const ErrorId *
Error::MapError( const struct ErrorIdMap map[] )
{
	// shortcut if there are no ErrorIds to lookup
	if( !ep ) {
	    return NULL;
	}

	for(int i = 0; map[i].incomingError.UniqueCode() != 0; i++)
	{
	    for( int j=0; j < ep->errorCount; j++)
	    {
		if (map[i].incomingError.code == ep->ids[j].code )
		{
		    return &(map[i].outgoingError);
		}
	    }
	}
	return NULL;
}


/*
 * Errorpvt.cc - private data for Error object
 */

void
ErrorPrivate::operator =( const ErrorPrivate &s )
{
	// Handle self-assign as a way of snapping data.

	int isSelf = this == &s;

	// Simple parts

	walk = 0;
	errorCount = s.errorCount;
	fmtSource = s.fmtSource;

	// Dictionary.
	// It's a little faster to use BufferDict::operator =
	// than CopyVars(), so take that shortcut if we can.

	if( s.whichDict != &s.errorDict )
	    errorDict.CopyVars( *s.whichDict );
	else if( !isSelf )
	    errorDict = s.errorDict;

	whichDict = &errorDict;

	// Copy ids over.

	if( !isSelf )
	    for( int i = 0; i < errorCount; i++ )
		ids[i] = s.ids[i];

	// Snap ids[].fmt.
	// If self-assign, we skip this if they are already in the fmtBuf.
	// Otherwise, we skip only if they are constants (via Error::Set())
	// and thus global.

	if( isSelf ? ( fmtSource != isFmtBuf ) : ( fmtSource != isConst ) )
	{
	    int i;

	    fmtbuf.Clear();

	    for( i = 0; i < errorCount; i++ )
	    {
		fmtbuf.Append( ids[i].fmt );
		fmtbuf.Extend( 0 );
	    }

	    char *p = fmtbuf.Text();

	    for( i = 0; i < errorCount; i++ )
	    {
		ids[i].fmt = p;
		p += strlen( p ) + 1;
	    }

	    fmtSource = isFmtBuf;
	}

	// Copy arg walk state as offset from last id's fmt.

	if ( s.walk )
	    walk = ids[errorCount-1].fmt + (s.walk - s.ids[errorCount-1].fmt);
}

/*
 * ErrorPrivate::SetArg() - provide formatting parameters
 */

void
ErrorPrivate::SetArg( const StrPtr &arg )
{
	/* If we've already finished walking the fmt string */
	/* we can't really format any more parameters. */

	if( !walk )
	    return;

	/* Loop past %%'s looing for %param% */

	while( ( walk = strchr( walk, '%' ) ) && *++walk == '%' )
	    ++walk;

	// No more %?s

	if( !walk )
	    return;

	/* The %parameter% name is in the fmt string. */
	/* Just bail if there is no ending %. */

	const char *p;
	if( !( p = strchr( walk, '%' ) ) )
	    return;

	// %var% - set variable to arg
	// %!var% - ignore arg (leave variable unset)

	if( *walk != '!' )
	    whichDict->SetVar( StrRef( walk, p - walk ), arg );

	walk = p + 1;
}

/*
 * Error::Dump()
 * ErrorPrivate::Dump() - debugging
 */

void
Error::Dump( const char *trace )
{
	printf( "Error %s %p\n", trace, this );
	printf( "\tSeverity %d (%s)\n", severity, FmtSeverity() );

	if( severity == E_EMPTY )
	    return;

	printf( "\tGeneric %d\n", genericCode );

	ep->Dump();
}

void
ErrorPrivate::Dump()
{
	int i;
	StrRef r, l;

	printf( "\tCount %d\n", errorCount );

	for( i = 0; i < errorCount; i++ )
	{
	    printf( "\t\t%d: %d (sub %d sys %d gen %d args %d sev %d code %d)\n",
		i,
		ids[i].code,
		ids[i].SubCode(),
		ids[i].Subsystem(),
		ids[i].Generic(),
		ids[i].ArgCount(),
		ids[i].Severity(),
		ids[i].UniqueCode() );
	    printf( "\t\t%d: %s\n", i, ids[i].fmt );
	}

	for( i = 0; whichDict->GetVar( i, r, l ); i++ )
	{
	    // For null termination
	    StrBuf r1, l1;
	    r1 = r; l1 = l;
	    printf( "\t\t%s = %s\n", r1.Text(), l1.Text() );
	}
}