error.c

spiht的压缩解压缩c编写的

#include "spiht.h"
#include "spihtdecode.h"

static QccErrorStruct QccError;

void QccErrorInit(void)
{
  QccError.current_message[0] = '\0';
  QccError.num_messages = 0;
  QccError.error_messages = NULL;
  QccError.errcode = 0;
}

static void QccErrorPrint(QccString message)
{
  QccString message_line;
  QccString tmp;
  int line_length;
  int message_line_length = 0;
  char *ptr;
  char *current_message_line;
  int first_line;

  line_length = QCCERROR_OUTPUTLINELENGTH;
  first_line = 1;
  QccStringSprintf(message_line, "%s", (char *)message);
  current_message_line = (char *)message_line;
  if ((int)strlen(current_message_line) > line_length)
    do
      {
        QccStringCopy(tmp, current_message_line);
        do
          {
            ptr = strrchr((char *)tmp, ' ');
            if (ptr == NULL)
              {
                if (first_line)
                  {
                    fprintf(stderr, "%s\n", (char *)current_message_line);
                    first_line = 0;
                    line_length -= QCCERROR_OUTPUTTABLENGTH;
                  }
                else
                  fprintf(stderr, "\t%s\n", (char *)current_message_line);
                current_message_line = 
                  (&current_message_line[strlen(current_message_line)]);
                break;
              }
            message_line_length = 
              (int)(ptr - (char *)tmp) + 1;
            ptr[0] = '\0';
          }
        while (message_line_length >= line_length);
        if (strlen(tmp))
          {
            if (first_line)
              {
                fprintf(stderr, "%s\n", tmp);
                first_line = 0;
                line_length -= QCCERROR_OUTPUTTABLENGTH;
              }
            else
              fprintf(stderr, "\t%s\n", tmp);
            current_message_line = 
              (char *)(&current_message_line[message_line_length]);
          }
      }
    while ((int)strlen(current_message_line) > line_length);
  if (strlen(current_message_line))
    {
      if (first_line)
        {
          fprintf(stderr, "%s\n", (char *)current_message_line);
          first_line = 0;
          line_length -= QCCERROR_OUTPUTTABLENGTH;
        }
      else
        fprintf(stderr, "\t%s\n", (char *)current_message_line);
    }
}

void QccErrorAddMessageVA(const char *format, va_list ap)
{
  QccString error_message;

  vsprintf(error_message, format, ap);

  error_message[QCCSTRINGLEN] = '\0';

  QccStringSprintf(QccError.current_message, "*ERROR* %s",
                   error_message);
  QccError.current_message[QCCSTRINGLEN] = '\0';

  if (QccError.num_messages == 0)
    {
      if ((QccError.error_messages = 
           (QccString *)malloc(sizeof(QccString))) == NULL)
        {
          fprintf(stderr, "(QccErrorAddMessageVA): Error allocating memory while processing message:\n");
          fprintf(stderr, "'%s'\n", QccError.current_message);
          goto Error;
        }
      QccStringCopy(QccError.error_messages[0], QccError.current_message);
      QccError.num_messages = 1;
    }
  else
    {
      QccError.num_messages++;
      if ((QccError.error_messages =
           (QccString *)realloc(QccError.error_messages,
                                sizeof(QccString)*QccError.num_messages)) == NULL)
        {
          fprintf(stderr, "(QccErrorAddMessageVA): Error reallocating memory while processing message:\n");
          fprintf(stderr, "'%s'\n", QccError.current_message);
          goto Error;
        }
      QccStringCopy(QccError.error_messages[QccError.num_messages-1], 
             QccError.current_message);
    }

  return;

Error:
  exit(1);
}

void QccErrorAddMessage(const char *format, ...)
{
  va_list ap;

  va_start(ap, format);

  QccErrorAddMessageVA(format, ap);

  va_end(ap);
}

void QccErrorPrintMessages(void)
{
  int error;

  for (error = 0; error < QccError.num_messages; error++)
    QccErrorPrint(QccError.error_messages[error]);

  QccErrorClearMessages();
}

void QccErrorClearMessages(void)
{
  if (QccError.error_messages != NULL)
    free(QccError.error_messages);

  QccError.current_message[0] = '\0';
  QccError.num_messages = 0;
  QccError.error_messages = NULL;
  QccError.errcode = 0;
}

void QccErrorExit(void)
{
  QccErrorPrintMessages();
  exit(QCCEXIT_ERROR);
}