Subversion Repositories SvarDOS

/* Functions that emulate UNIX catgets */

/* Copyright (C) 1999,2000,2001 Jim Hall <jhall@freedos.org> */

/* Kitten version 2003 by Tom Ehlert, heavily modified by Eric Auer 2003 */

/*

  This library is free software; you can redistribute it and/or

  modify it under the terms of the GNU Lesser General Public

  License as published by the Free Software Foundation; either

  version 2.1 of the License, or (at your option) any later version.

  This library 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

  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public

  License along with this library; if not, write to the Free Software

  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#ifndef NO_KITTEN

#include <stdio.h>		/* sprintf */

#ifndef _MICROC_

#include <stdlib.h>		/* getenv  */

#include <string.h>		/* strchr */

#include <dos.h>

#ifndef __PACIFIC__

#include <fcntl.h>

#else

#define O_RDONLY 0

#define O_TEXT 0

#endif

#else

#include <intr.h>

#include <file.h>

#define O_RDONLY READONLY

#define O_TEXT 0

#endif

/* assert we are running in small model */

/* else pointer below has to be done correctly */

/* char verify_small_pointers[sizeof(void*) == 2 ? 1 : -1]; */

#include "kitten.h"

char catcontents[8192];

struct catstring

{

  char key1;

  char key2;

  char *text;

};

/* Micro-C does not support typedef */

#define catstring_t struct catstring

catstring_t catpoints[128];

/* Local prototypes */

int catread (char *catfile);	/* Reads a catfile into the hash */

char *processEscChars (char *line);	/* Converts c escape sequences to chars */

int get_char (int file);	/* not meant for external use    */

/* external use would cause consistency problems if */

/* value or related file of the file handle changes */

int mystrtoul (char *src, int base, int size);

/* Globals */

nl_catd _kitten_catalog = 0;	/* _kitten_catalog descriptor or 0 */

char catfile[128];		/* full path to _kitten_catalog */

char getlbuf[8192];		/* read buffer for better speed  */

char *getlp;			/* current point in buffer       */

int getlrem = -1;		/* remaining bytes in buffer     */

char lastcr = 0;		/* for 2byte CR LF sequences     */

#ifndef _MICROC_

#ifndef __DJGPP__

/* DOS handle based file usage */

int

dos_open (char *filename, int mode)

{

  union REGS r;

  struct SREGS s;

#ifndef __WATCOMC__

  if (mode);			/* mode ignored - readonly supported */

#endif

  r.h.ah = 0x3d;

  r.h.al = 0;			/* read mode only supoported now !! */

  r.x.dx = FP_OFF (filename);

  s.ds = FP_SEG (filename);

  intdosx (&r, &r, &s);

  return ((r.x.cflag) ? -1 : (int) r.x.ax);

}

int

dos_read (int file, void *ptr, unsigned count)

{

  union REGS r;

  struct SREGS s;

  r.h.ah = 0x3f;

  r.x.bx = file;

  r.x.cx = count;

  r.x.dx = FP_OFF (ptr);

  s.ds = FP_SEG (ptr);

  intdosx (&r, &r, &s);

  return ((r.x.cflag) ? 0 : r.x.ax);

}

int

dos_write (int file, void *ptr, unsigned count)

{

  union REGS r;

  struct SREGS s;

  r.h.ah = 0x40;

  r.x.bx = file;

  r.x.cx = count;

  r.x.dx = FP_OFF (ptr);

  s.ds = FP_SEG (ptr);

  intdosx (&r, &r, &s);

  return ((r.x.cflag) ? 0 : r.x.ax);

}

void

dos_close (int file)

{

  union REGS r;

  r.h.ah = 0x3e;

  r.x.bx = file;

  intdos (&r, &r);

}

#endif /*DJGPP*/

#endif /*Micro-C */

/* Functions */

/**

 * On success, catgets() returns a pointer to an internal

 * buffer area containing the null-terminated message string.

 * On failure, catgets() returns the value 'message'.

 */

char *

kittengets (int setnum, int msgnum, char *message)

{

/* In Micro-C, variables must be defined at the start of the

 * function and may not be immediately assigned a value

 */

#ifdef _MICROC_

  int i;

  i = 0;

#else

  int i = 0;

#endif

  while ((catpoints[i].key1 != setnum) || (catpoints[i].key2 != msgnum))

    {

      if ((catpoints[i].text == NULL) || (i > 127))	/* at EOF */

	return message;

      i++;

    }

  if (catpoints[i].text == NULL)

    return message;

  else

    return (catpoints[i].text);

}

/**

 * Initialize kitten for program (name).

 */

nl_catd

kittenopen (char *name)

{

  /* catopen() returns a message _kitten_catalog descriptor  *

   * of type nl_catd on success.  On failure, it returns -1. */

  char catlang[3];		/* from LANG environment var. */

  char *nlsptr;			/* ptr to NLSPATH */

  char *lang;			/* ptr to LANG */

  int i;

#ifdef _MICROC_

  char *tok;

  int toklen;

#endif

  /* Open the _kitten_catalog file */

  /* The value of `_kitten_catalog' will be set based on catread */

  if (_kitten_catalog)

    {				/* Already one open */

      write (1, "cat already open\r\n", strlen ("cat already open\r\n"));

      return (-1);

    }

  for (i = 0; i < 128; i++)

    catpoints[i].text = NULL;

  if (strchr (name, '\\'))

    {

      /* unusual case: 'name' is a filename */

      write (1, "found \\\r\n", 9);

      _kitten_catalog = catread (name);

      if (_kitten_catalog)

	return (_kitten_catalog);

    }

  /* If the message _kitten_catalog file name does not contain a directory *

   * separator, then we need to try to locate the message _kitten_catalog. */

  /* We will need the value of LANG, and may need a 2-letter abbrev of

     LANG later on, so get it now. */

  lang = getenv ("LANG");

  if (lang == NULL)

    {

      /* printf("no lang= found\n"); *//* not fatal, though */

      /* Return failure - we won't be able to locate the cat file */

      return (-1);

    }

  if ((strlen (lang) < 2) || ((strlen (lang) > 2) && (lang[2] != '-')))

    {

      /* Return failure - we won't be able to locate the cat file */

      return (-1);

    }

  memcpy (catlang, lang, 2);

  /* we copy the full LANG value or the part before "-" if "-" found */

  catlang[2] = '\0';

  /* step through NLSPATH */

  nlsptr = getenv ("NLSPATH");

  if (nlsptr == NULL)

    {

      /* printf("no NLSPATH= found\n"); *//* not fatal either */

      /* Return failure - we won't be able to locate the cat file */

      return (-1);

    }

  catfile[0] = '\0';

  while (nlsptr && nlsptr[0])

    {

#ifdef _MICROC_

      tok = strchr (nlsptr, ';');

#else

      char *tok = strchr (nlsptr, ';');

      int toklen;

#endif

      if (tok == NULL)

	toklen = strlen (nlsptr);	/* last segment */

      else

	toklen = tok - nlsptr;	/* segment terminated by ';' */

      /* catfile = malloc(toklen+1+strlen(name)+1+strlen(lang)+1); */

      /* Try to find the _kitten_catalog file in each path from NLSPATH */

      if ((toklen + 6 + strlen (name)) > sizeof (catfile))

	{

	  write (1, "NLSPATH overflow\r\n", strlen ("NLSPATH overflow\r\n"));

	  return 0;		/* overflow in NLSPATH, should never happen */

	}

      /* Rule #1: %NLSPATH%\%LANG%\cat */

      memcpy (catfile, nlsptr, toklen);

      strcpy (catfile + toklen, "\\");

      strcat (catfile, catlang);

      strcat (catfile, "\\");

      strcat (catfile, name);

      _kitten_catalog = catread (catfile);

      if (_kitten_catalog)

	return (_kitten_catalog);

      /* Rule #2: %NLSPATH%\cat.%LANG% */

      /* memcpy(catfile, nlsptr, toklen); */

      strcpy (catfile + toklen, "\\");

      strcat (catfile, name);

      strcat (catfile, ".");

      strcat (catfile, catlang);

      _kitten_catalog = catread (catfile);

      if (_kitten_catalog)

	return (_kitten_catalog);

      /* Grab next tok for the next while iteration */

      nlsptr = tok;

      if (nlsptr)

	nlsptr++;

    }				/* while tok */

  /* We could not find it.  Return failure. */

  return (-1);

}

/**

 * Load a message catalog into memory.

 */

int

catread (char *catfile)

{

  int file;			/* pointer to the catfile */

  int i;

  char *where;

  char *tok;

#ifdef _MICROC_

  char *msg;

  char *key;

  int key1;

  int key2;

#endif

  /* Get the whole catfile into a buffer and parse it */

  file = open (catfile, O_RDONLY | O_TEXT);

  if (file < 0)

    /* Cannot open the file.  Return failure */

    return 0;

  for (i = 0; i < 128; i++)

    catpoints[i].text = NULL;

  for (i = 0; (unsigned int) i < sizeof (catcontents); i++)

    catcontents[i] = '\0';

  /* Read the file into memory */

  i = read (file, catcontents, sizeof (catcontents) - 1);

  if ((i == sizeof (catcontents) - 1) || (i < 1))

    return 0;			/* file was too big or too small */

  where = catcontents;

  i = 0;			/* catpoints entry */

  do

    {

#ifndef _MICROC_

      char *msg;

      char *key;

      int key1 = 0;

      int key2 = 0;

#else

      key1 = 0;

      key2 = 0;

#endif

      tok = strchr (where, '\n');

      if (tok == NULL)

	{			/* done? */

	  close (file);

	  return 1;		/* success */

	}

      tok[0] = '\0';		/* terminate here */

      tok--;			/* guess: \r before \n */

      if (tok[0] != '\r')

	tok++;			/* if not, go back */

      else

	{

	  tok[0] = '\0';	/* terminate here already */

	  tok++;

	}

      tok++;			/* this is where the next line starts */

      if ((where[0] >= '0') && (where[0] <= '9') &&

	  ((msg = strchr (where, ':')) != NULL))

	{

	  /* Skip everything which starts with # or with no digit */

	  /* Entries look like "1.2:This is a message" */

	  msg[0] = '\0';	/* remove : */

	  msg++;		/* go past the : */

	  if ((key = strchr (where, '.')) != NULL)

	    {

	      key[0] = '\0';	/* turn . into terminator */

	      key++;		/* go past the . */

	      key1 = mystrtoul (where, 10, strlen (where));

	      key2 = mystrtoul (key, 10, strlen (key));

	      if ((key1 >= 0) && (key2 >= 0))

		{

		  catpoints[i].key1 = key1;

		  catpoints[i].key2 = key2;

		  catpoints[i].text = processEscChars (msg);

		  if (catpoints[i].text == NULL)	/* ESC parse error */

		    catpoints[i].text = msg;

		  i++;		/* next entry! */

		}		/* valid keys */

	    }			/* . found */

	}			/* : and digit found */

      where = tok;		/* go to next line */

    }

  while (1);

#ifdef __PACIFIC__

  return 0;

#endif

}

void

kittenclose (void)

{

  /* close a message _kitten_catalog */

  _kitten_catalog = 0;

}

/**

 * Parse a string that represents an unsigned integer.

 * Returns -1 if an error is found. The first size

 * chars of the string are parsed.

 */

int

mystrtoul (char *src, int base, int size)

{

#ifdef _MICROC_

  int ret;

  int digit;

  int ch;

  ret = 0;

#else

  int ret = 0;

#endif

  for (; size > 0; size--)

    {

#ifdef _MICROC_

      ch = *src;

#else

      int digit;

      int ch = *src;

#endif

      src++;

      if (ch >= '0' && ch <= '9')

	digit = ch - '0';

      else if (ch >= 'A' && ch <= 'Z')

	digit = ch - 'A' + 10;

      else if (ch >= 'a' && ch <= 'z')

	digit = ch - 'a' + 10;

      else

	return -1;

      if (digit >= base)

	return -1;

      ret = ret * base + digit;

    }				/* for */

  return ret;

}

/**

 * Process strings, converting \n, \t, \v, \b, \r, \f, \\,

 * \ddd, \xdd and \x0dd to actual chars.

 * (Note: \x is an extension to support hexadecimal)

 * This is used to allow the messages to use c escape sequences.

 * Modifies the line in-place (always same size or shorter).

 * Returns a pointer to input string.

 */

char *

processEscChars (char *line)

{

  /* used when converting \xdd and \ddd (hex or octal) characters */

  char ch;

#ifdef _MICROC_

  char *src;

  char *dst;

  int chx;

  src = line;

  dst = line;

#else

  char *src = line;

  char *dst = line;		/* possible as dst is shorter than src */

#endif

  if (line == NULL)

    return line;

  /* cycle through copying characters, except when a \ is encountered. */

  while (*src != '\0')

    {

      ch = *src;

      src++;

      if (ch == '\\')

	{

	  ch = *src;		/* what follows slash? */

	  src++;

	  switch (ch)

	    {

	    case '\\':		/* a single slash */

	      *dst = '\\';

	      dst++;

	      break;

	    case 'n':		/* a newline (linefeed) */

	      *dst = '\n';

	      dst++;

	      break;

	    case 'r':		/* a carriage return */

	      *dst = '\r';

	      dst++;

	      break;

	    case 't':		/* a horizontal tab */

	      *dst = '\t';

	      dst++;

	      break;

	    case 'v':		/* a vertical tab */

	      *dst = '\v';

	      dst++;

	      break;

	    case 'b':		/* a backspace */

	      *dst = '\b';

	      dst++;

	      break;

	    case 'a':		/* alert */

	      *dst = '\a';

	      dst++;

	      break;

	    case 'f':		/* formfeed */

	      *dst = '\f';

	      dst++;

	      break;

	    case 'x':		/* extension supporting hex numbers \xdd or \x0dd */

	      {

#ifdef _MICROC_

		chx = mystrtoul (src, 16, 2);	/* get value */

#else

		int chx = mystrtoul (src, 16, 2);	/* get value */

#endif

		if (chx >= 0)

		  {		/* store character */

		    *dst = chx;

		    dst++;

		    src += 2;

		  }

		else		/* error so just store x (loose slash) */

		  {

		    *dst = *src;

		    dst++;

		  }

	      }

	      break;

	    default:		/* just store letter (loose slash) or handle octal */

	      {

#ifdef _MICROC_

		chx = mystrtoul (src, 8, 3);	/* get value */

#else

		int chx = mystrtoul (src, 8, 3);	/* get value */

#endif

		if (chx >= 0)

		  {		/* store character */

		    *dst = chx;

		    dst++;

		    src += 3;

		  }

		else

		  {

		    *dst = *src;

		    dst++;

		  }

	      }

	      break;

	    }			/* switch */

	}			/* if backslash */

      else

	{

	  *dst = ch;

	  dst++;

	}

    }				/* while */

  /* ensure '\0' terminated */

  *dst = '\0';

  return line;

}

int

get_char (int file)

{

#ifdef _MICROC_

  int rval;

  rval = -1;

#else

  int rval = -1;

#endif

  if (getlrem <= 0)

    {				/* (re)init buffer */

      getlrem = read (file, getlbuf, sizeof (getlbuf));

      if (getlrem <= 0)

	return -1;		/* fail: read error / EOF */

      getlp = getlbuf;		/* init pointer */

    }

  if (getlrem > 0)

    {				/* consume byte from buffer */

      rval = getlp[0];

      getlp++;

      getlrem--;

    }

  return rval;

}

/**

 * Read a line of text from file. You must call this with

 * a null buffer or null size to flush buffers when you are

 * done with a file before using it on the next file. Cannot

 * be used for 2 files at the same time.

 */

int

get_line (int file, char *str, int size)

{

  int ch;

#ifdef _MICROC_

  int success;

  success = 0;

#else

  int success = 0;

#endif

  if ((size == 0) || (str == NULL))

    {				/* re-init get_line buffers */

      getlp = getlbuf;

      getlrem = -1;

      lastcr = 0;

      return 0;

    }

  str[0] = '\0';

  while ((size > 0) && (success == 0))

    {

      ch = get_char (file);

      if (ch < 0)

	break;			/* (can cause fail if no \n found yet) */

      if (ch == '\r')

	ch = get_char (file);	/* ignore \r */

      str[0] = ch;

      if ((ch == '\n') || (ch == '\r'))

	{			/* done? */

	  str[0] = '\0';

	  return 1;		/* success */

	}

      str++;

      size--;

    }				/* while */

  str[0] = '\0';		/* terminate buffer */

  return success;

}

#endif /*NO_KITTEN */