---

MapperErrorHandler.cpp

//$Header: /home/ben/Mapper/c++/RCS/MapperErrorHandler.cpp,v 6.8 2002/07/09 22:50:53 ben Exp $
// Copyright Benedict Adamson 2002.
// This file is part of Mapper.

// Mapper is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.

// Mapper is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with Mapper; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#include <fstream>

#include <dom/DOM_DOMException.hpp>
#include <dom/DOM_Element.hpp>
#include <dom/DOM_Node.hpp>
#include <sax/ErrorHandler.hpp>
#include <sax/SAXParseException.hpp>
#include <util/PlatformUtils.hpp>
#include <util/XMLString.hpp>

#include "DOM_output.h"
#include "MapperErrorHandler.h"



MapperErrorHandler::MapperErrorHandler(
   const char *name
   )
   :
   errors( 0U ),
   my_name( name )
{
   //Do nothing
   {//Postoncditions:
      assert( this->errors == 0 );
      assert( this->my_name == name );
   };
}



MapperErrorHandler::~MapperErrorHandler(void)
{
   //Do nothing
}



void MapperErrorHandler::report(
   const string entity,
   const unsigned line,
   const unsigned column,
   const string &severity,
   const string &message
   ) const
{
   if( entity.length() ){
      cerr << entity << ':';
      if( line != (unsigned)(-1) ){//sic. line number available
         cerr << line << ':';
         if( column != (unsigned)(-1) )//sic. column number available
            cerr << column << ':';
         ;
      };
   };
   cerr << severity << ": " << message << "\n";
}



void MapperErrorHandler::report(
   const SAXParseException &ex,
   const string &severity
   ) const
{
   const XMLCh *entity_SAX = ex.getSystemId();
   const char *entity_c = XMLString::transcode( entity_SAX );
   string entity;
   if( entity_c )
      entity = entity_c;
   else
      entity = "";
   ;
   const unsigned line = ex.getLineNumber();
   const unsigned column = ex.getColumnNumber();
   const char *message = XMLString::transcode( ex.getMessage() );
   this->report( string(entity), line, column, severity, string(message) );
   if( entity_c ) delete entity_c;
   delete message;
}



void MapperErrorHandler::warning(
   const SAXParseException &exception
   )
{
   this->report( exception, "warning" );
}



void MapperErrorHandler::error(
   const SAXParseException &exception
   )
{
   this->report( exception, "error" );
   this->errors++;
}



void MapperErrorHandler::fatalError(
   const SAXParseException &exception
   )
{
   this->report( exception, "error: fatal error" );
   this->errors++;
}



void MapperErrorHandler::resetErrors(void)
{
   this->errors = 0U;
}



void MapperErrorHandler::fatalError(
   const DOM_DOMException &exception
   )
{
   const char *message = exception.msg.transcode();
   this->error( message );
   delete message;
}
      


void MapperErrorHandler::fatalError(
   const XMLException &exception
   )
{
   this->errors++;
   char *m = XMLString::transcode( exception.getMessage() );
   this->report(
      exception.getSrcFile(),
      exception.getSrcLine(), (unsigned)(-1),
      "error (fatal)", m
      );
   delete m;
}



void MapperErrorHandler::error(
   const error::element_error &e
   )
{
   this->errors++;
   cerr << "error: " << e.message << "\n";
   DOM_output::traceback( cerr, e.element );
}



void MapperErrorHandler::unexpectedError(void)
{
   this->error( "unexpected error" );
}
      


void MapperErrorHandler::error(
   const char *message
   )
{
   cerr << my_name << ":error: " << message << "\n";
   this->errors++;
}



void MapperErrorHandler::warning(
   const char *message
   )
{
   cerr << my_name << ":warning: " << message << "\n";
}



void MapperErrorHandler::badOptionArgument(
   const char option,
   const char *optarg
   )
{
   cerr << my_name << ":error: bad -" << option << " option: " << optarg << "\n";
   this->errors++;
}

---