/*
  ArtToSpr Artworks/Draw to Sprite convertor
  Copyright (c) 1998 Tony Houghton

  This source is distributed under the GPL. Please see the file
  "COPYING" for details.
*/

#include <ctype.h>
#include <stdlib.h>
#include <string.h>

#include "messagetra.h"

#include "CRstring.h"

#include "err.h"
#include "msgtrans.h"

MessagesFD msgs_descriptor;

const char *msgtrans_qlookup(const MessagesFD *desc, const char *token)
{
  char *result;
  if (xmessagetrans_lookup((const messagetrans_control_block *) desc,
  	token, 0, 0, 0, 0, 0, 0, &result, 0))
    result = 0;
  return result;
}

const char *msgtrans_plookup(const MessagesFD *desc, const char *token,
	const char *p0, const char *p1, const char *p2, const char *p3)
{
  static char *buffer = 0;
  static int buf_size = 0;
  int msglen;
  const char *s;

  s = msgtrans_qlookup(desc, token);
  if (!s)
    return 0;

#ifdef MemCheck_MEMCHECK
  /* Don't want to cause false alarm with MemCheck when using default msgs
     which is in unknown buffer allocated by Toolbox */
  if (desc == &msgs_descriptor)
    MemCheck_SetReadChecking(0);
#endif
  msglen = CRstrlen(s) + 1 +
  	CRstrlen(p0)+CRstrlen(p1)+CRstrlen(p2)+CRstrlen(p3);
#ifdef MemCheck_MEMCHECK
  if (desc == &msgs_descriptor)
    MemCheck_SetReadChecking(1);
#endif
  /* msglen not very accurate because doesn't discount unsubstituted parameters
     but at least it always errs on the large side */
  if (msglen > buf_size)
  {
    buffer = buffer ? realloc(buffer, msglen) : malloc(msglen);
    if (!buffer)
    {
      E(msgs_nomem());
      return 0;
    }
    buf_size = msglen;
  }

  if (E(xmessagetrans_lookup((const messagetrans_control_block *) desc,
  	token, buffer, buf_size,
  	p0, p1, p2, p3,
  	0, &msglen)))
    return 0;
  buffer[msglen] = 0;

  return buffer;
}

_kernel_oserror *msgtrans_load(const char *filename, MessagesFD *descriptor,
	char **bufferout)
{
  int size;
  char *buffer;
  _kernel_oserror *result;
  result = xmessagetrans_file_info(filename, 0, &size);
  if (result)
    return result;
  buffer = malloc(size);
  if (!buffer)
    return msgs_nomem();
  if (!buffer)
    return 0;
  if (bufferout)
    *bufferout = buffer;
  memset(descriptor, 0, sizeof(MessagesFD));
  return xmessagetrans_open_file((messagetrans_control_block *) descriptor,
  	filename, buffer);
}

_kernel_oserror *msgtrans_close(MessagesFD *cb)
{
  return xmessagetrans_close_file((const messagetrans_control_block *) cb);
}

_kernel_oserror *msgtrans_error(MessagesFD *descriptor, const char *token)
{
  static _kernel_oserror err;
  err.errnum = 0;
  CRstrncpy(err.errmess, msgtrans_qlookup(descriptor, token), 252);
  return &err;
}
