WebSVN – SvarDOS – Diff – /pkg/kitten/kitten.c


/* 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 */
 

Rev 244	Rev 269
1	`/* Functions that emulate UNIX catgets */`	1	`/* Functions that emulate UNIX catgets */`
2		2
3	`/* Copyright (C) 1999,2000,2001 Jim Hall <jhall@freedos.org> */`	3	`/* Copyright (C) 1999,2000,2001 Jim Hall <jhall@freedos.org> */`
4	`/* Kitten version 2003 by Tom Ehlert, heavily modified by Eric Auer 2003 */`	4	`/* Kitten version 2003 by Tom Ehlert, heavily modified by Eric Auer 2003 */`
5		5
6	`/*`	6	`/*`
7	`This library is free software; you can redistribute it and/or`	7	`This library is free software; you can redistribute it and/or`
8	`modify it under the terms of the GNU Lesser General Public`	8	`modify it under the terms of the GNU Lesser General Public`
9	`License as published by the Free Software Foundation; either`	9	`License as published by the Free Software Foundation; either`
10	`version 2.1 of the License, or (at your option) any later version.`	10	`version 2.1 of the License, or (at your option) any later version.`
11		11
12	`This library is distributed in the hope that it will be useful,`	12	`This library is distributed in the hope that it will be useful,`
13	`but WITHOUT ANY WARRANTY; without even the implied warranty of`	13	`but WITHOUT ANY WARRANTY; without even the implied warranty of`
14	`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`	14	`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
15	`Lesser General Public License for more details.`	15	`Lesser General Public License for more details.`
16		16
17	`You should have received a copy of the GNU Lesser General Public`	17	`You should have received a copy of the GNU Lesser General Public`
18	`License along with this library; if not, write to the Free Software`	18	`License along with this library; if not, write to the Free Software`
19	`Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`	19	`Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`
20	`*/`	20	`*/`
21		21
22	`#ifndef NO_KITTEN`	22	`#ifndef NO_KITTEN`
23		23
24	`#include <stdio.h> /* sprintf */`	24	`#include <stdio.h> /* sprintf */`
25	`#ifndef _MICROC_`	25	`#ifndef _MICROC_`
26	`#include <stdlib.h> /* getenv */`	26	`#include <stdlib.h> /* getenv */`
27	`#include <string.h> /* strchr */`	27	`#include <string.h> /* strchr */`
28	`#include <dos.h>`	28	`#include <dos.h>`
29	`#ifndef __PACIFIC__`	29	`#ifndef __PACIFIC__`
30	`#include <fcntl.h>`	30	`#include <fcntl.h>`
31	`#else`	31	`#else`
32	`#define O_RDONLY 0`	32	`#define O_RDONLY 0`
33	`#define O_TEXT 0`	33	`#define O_TEXT 0`
34	`#endif`	34	`#endif`
35	`#else`	35	`#else`
36	`#include <intr.h>`	36	`#include <intr.h>`
37	`#include <file.h>`	37	`#include <file.h>`
38	`#define O_RDONLY READONLY`	38	`#define O_RDONLY READONLY`
39	`#define O_TEXT 0`	39	`#define O_TEXT 0`
40	`#endif`	40	`#endif`
41	`/* assert we are running in small model */`	41	`/* assert we are running in small model */`
42	`/* else pointer below has to be done correctly */`	42	`/* else pointer below has to be done correctly */`
43	`/* char verify_small_pointers[sizeof(void) == 2 ? 1 : -1]; /`	43	`/* char verify_small_pointers[sizeof(void) == 2 ? 1 : -1]; /`
44		44
45	`#include "kitten.h"`	45	`#include "kitten.h"`
46		46
47	`char catcontents[8192];`	47	`char catcontents[8192];`
48		48
49	`struct catstring`	49	`struct catstring`
50	`{`	50	`{`
51	`char key1;`	51	`char key1;`
52	`char key2;`	52	`char key2;`
53	`char *text;`	53	`char *text;`
54	`};`	54	`};`
55		55
56	`/* Micro-C does not support typedef */`	56	`/* Micro-C does not support typedef */`
57	`#define catstring_t struct catstring`	57	`#define catstring_t struct catstring`
58		58
59	`catstring_t catpoints[128];`	59	`catstring_t catpoints[128];`
60		60
61		61
62	`/* Local prototypes */`	62	`/* Local prototypes */`
63		63
64	`int catread (char catfile); / Reads a catfile into the hash */`	64	`int catread (char catfile); / Reads a catfile into the hash */`
65	`char processEscChars (char line); /* Converts c escape sequences to chars */`	65	`char processEscChars (char line); /* Converts c escape sequences to chars */`
66		66
67	`int get_char (int file); /* not meant for external use */`	67	`int get_char (int file); /* not meant for external use */`
68	`/* external use would cause consistency problems if */`	68	`/* external use would cause consistency problems if */`
69	`/* value or related file of the file handle changes */`	69	`/* value or related file of the file handle changes */`
70		70
71	`int mystrtoul (char *src, int base, int size);`	71	`int mystrtoul (char *src, int base, int size);`
72		72
73		73
74	`/* Globals */`	74	`/* Globals */`
75		75
76	`nl_catd _kitten_catalog = 0; /* _kitten_catalog descriptor or 0 */`	76	`nl_catd _kitten_catalog = 0; /* _kitten_catalog descriptor or 0 */`
77	`char catfile[128]; /* full path to _kitten_catalog */`	77	`char catfile[128]; /* full path to _kitten_catalog */`
78		78
79	`char getlbuf[8192]; /* read buffer for better speed */`	79	`char getlbuf[8192]; /* read buffer for better speed */`
80	`char getlp; / current point in buffer */`	80	`char getlp; / current point in buffer */`
81	`int getlrem = -1; /* remaining bytes in buffer */`	81	`int getlrem = -1; /* remaining bytes in buffer */`
82	`char lastcr = 0; /* for 2byte CR LF sequences */`	82	`char lastcr = 0; /* for 2byte CR LF sequences */`
83		83
84		84
85	`#ifndef _MICROC_`	85	`#ifndef _MICROC_`
86	`#ifndef __DJGPP__`	86	`#ifndef __DJGPP__`
87		87
88	`/* DOS handle based file usage */`	88	`/* DOS handle based file usage */`
89		89
90	`int`	90	`int`
91	`dos_open (char *filename, int mode)`	91	`dos_open (char *filename, int mode)`
92	`{`	92	`{`
93	`union REGS r;`	93	`union REGS r;`
94	`struct SREGS s;`	94	`struct SREGS s;`
95	`#ifndef __WATCOMC__`	95	`#ifndef __WATCOMC__`
96	`if (mode); /* mode ignored - readonly supported */`	96	`if (mode); /* mode ignored - readonly supported */`
97	`#endif`	97	`#endif`
98	`r.h.ah = 0x3d;`	98	`r.h.ah = 0x3d;`
99	`r.h.al = 0; /* read mode only supoported now !! */`	99	`r.h.al = 0; /* read mode only supoported now !! */`
100	`r.x.dx = FP_OFF (filename);`	100	`r.x.dx = FP_OFF (filename);`
101	`s.ds = FP_SEG (filename);`	101	`s.ds = FP_SEG (filename);`
102	`intdosx (&r, &r, &s);`	102	`intdosx (&r, &r, &s);`
103	`return ((r.x.cflag) ? -1 : (int) r.x.ax);`	103	`return ((r.x.cflag) ? -1 : (int) r.x.ax);`
104	`}`	104	`}`
105		105
106		106
107	`int`	107	`int`
108	`dos_read (int file, void *ptr, unsigned count)`	108	`dos_read (int file, void *ptr, unsigned count)`
109	`{`	109	`{`
110	`union REGS r;`	110	`union REGS r;`
111	`struct SREGS s;`	111	`struct SREGS s;`
112	`r.h.ah = 0x3f;`	112	`r.h.ah = 0x3f;`
113	`r.x.bx = file;`	113	`r.x.bx = file;`
114	`r.x.cx = count;`	114	`r.x.cx = count;`
115	`r.x.dx = FP_OFF (ptr);`	115	`r.x.dx = FP_OFF (ptr);`
116	`s.ds = FP_SEG (ptr);`	116	`s.ds = FP_SEG (ptr);`
117	`intdosx (&r, &r, &s);`	117	`intdosx (&r, &r, &s);`
118	`return ((r.x.cflag) ? 0 : r.x.ax);`	118	`return ((r.x.cflag) ? 0 : r.x.ax);`
119	`}`	119	`}`
120		120
121		121
122	`int`	122	`int`
123	`dos_write (int file, void *ptr, unsigned count)`	123	`dos_write (int file, void *ptr, unsigned count)`
124	`{`	124	`{`
125	`union REGS r;`	125	`union REGS r;`
126	`struct SREGS s;`	126	`struct SREGS s;`
127	`r.h.ah = 0x40;`	127	`r.h.ah = 0x40;`
128	`r.x.bx = file;`	128	`r.x.bx = file;`
129	`r.x.cx = count;`	129	`r.x.cx = count;`
130	`r.x.dx = FP_OFF (ptr);`	130	`r.x.dx = FP_OFF (ptr);`
131	`s.ds = FP_SEG (ptr);`	131	`s.ds = FP_SEG (ptr);`
132	`intdosx (&r, &r, &s);`	132	`intdosx (&r, &r, &s);`
133	`return ((r.x.cflag) ? 0 : r.x.ax);`	133	`return ((r.x.cflag) ? 0 : r.x.ax);`
134	`}`	134	`}`
135		135
136		136
137	`void`	137	`void`
138	`dos_close (int file)`	138	`dos_close (int file)`
139	`{`	139	`{`
140	`union REGS r;`	140	`union REGS r;`
141	`r.h.ah = 0x3e;`	141	`r.h.ah = 0x3e;`
142	`r.x.bx = file;`	142	`r.x.bx = file;`
143	`intdos (&r, &r);`	143	`intdos (&r, &r);`
144	`}`	144	`}`
145		145
146	`#endif /DJGPP/`	146	`#endif /DJGPP/`
147	`#endif /Micro-C /`	147	`#endif /Micro-C /`
148	`/* Functions */`	148	`/* Functions */`
149	`/**`	149	`/**`
150	`* On success, catgets() returns a pointer to an internal`	150	`* On success, catgets() returns a pointer to an internal`
151	`* buffer area containing the null-terminated message string.`	151	`* buffer area containing the null-terminated message string.`
152	`* On failure, catgets() returns the value 'message'.`	152	`* On failure, catgets() returns the value 'message'.`
153	`*/`	153	`*/`
154	`char *`	154	`char *`
155	`kittengets (int setnum, int msgnum, char *message)`	155	`kittengets (int setnum, int msgnum, char *message)`
156	`{`	156	`{`
157	`/* In Micro-C, variables must be defined at the start of the`	157	`/* In Micro-C, variables must be defined at the start of the`
158	`* function and may not be immediately assigned a value`	158	`* function and may not be immediately assigned a value`
159	`*/`	159	`*/`
160	`#ifdef _MICROC_`	160	`#ifdef _MICROC_`
161	`int i;`	161	`int i;`
162	`i = 0;`	162	`i = 0;`
163	`#else`	163	`#else`
164	`int i = 0;`	164	`int i = 0;`
165	`#endif`	165	`#endif`
166		166
167	`while ((catpoints[i].key1 != setnum) \|\| (catpoints[i].key2 != msgnum))`	167	`while ((catpoints[i].key1 != setnum) \|\| (catpoints[i].key2 != msgnum))`
168	`{`	168	`{`
169	`if ((catpoints[i].text == NULL) \|\| (i > 127)) /* at EOF */`	169	`if ((catpoints[i].text == NULL) \|\| (i > 127)) /* at EOF */`
170	`return message;`	170	`return message;`
171	`i++;`	171	`i++;`
172	`}`	172	`}`
173		173
174	`if (catpoints[i].text == NULL)`	174	`if (catpoints[i].text == NULL)`
175	`return message;`	175	`return message;`
176	`else`	176	`else`
177	`return (catpoints[i].text);`	177	`return (catpoints[i].text);`
178	`}`	178	`}`
179		179
180		180
181	`/**`	181	`/**`
182	`* Initialize kitten for program (name).`	182	`* Initialize kitten for program (name).`
183	`*/`	183	`*/`
184		184
185	`nl_catd`	185	`nl_catd`
186	`kittenopen (char *name)`	186	`kittenopen (char *name)`
187	`{`	187	`{`
188	`/* catopen() returns a message _kitten_catalog descriptor *`	188	`/* catopen() returns a message _kitten_catalog descriptor *`
189	`* of type nl_catd on success. On failure, it returns -1. */`	189	`* of type nl_catd on success. On failure, it returns -1. */`
190		190
191	`char catlang[3]; /* from LANG environment var. */`	191	`char catlang[3]; /* from LANG environment var. */`
192	`char nlsptr; / ptr to NLSPATH */`	192	`char nlsptr; / ptr to NLSPATH */`
193	`char lang; / ptr to LANG */`	193	`char lang; / ptr to LANG */`
194	`int i;`	194	`int i;`
195	`#ifdef _MICROC_`	195	`#ifdef _MICROC_`
196	`char *tok;`	196	`char *tok;`
197	`int toklen;`	197	`int toklen;`
198	`#endif`	198	`#endif`
199		199
200	`/* Open the _kitten_catalog file */`	200	`/* Open the _kitten_catalog file */`
201	/* The value of `_kitten_catalog' will be set based on catread */	201	/* The value of `_kitten_catalog' will be set based on catread */
202		202
203	`if (_kitten_catalog)`	203	`if (_kitten_catalog)`
204	`{ /* Already one open */`	204	`{ /* Already one open */`
205	`write (1, "cat already open\r\n", strlen ("cat already open\r\n"));`	205	`write (1, "cat already open\r\n", strlen ("cat already open\r\n"));`
206	`return (-1);`	206	`return (-1);`
207	`}`	207	`}`
208		208
209	`for (i = 0; i < 128; i++)`	209	`for (i = 0; i < 128; i++)`
210	`catpoints[i].text = NULL;`	210	`catpoints[i].text = NULL;`
211		211
212	`if (strchr (name, '\\'))`	212	`if (strchr (name, '\\'))`
213	`{`	213	`{`
214	`/* unusual case: 'name' is a filename */`	214	`/* unusual case: 'name' is a filename */`
215	`write (1, "found \\\r\n", 9);`	215	`write (1, "found \\\r\n", 9);`
216	`_kitten_catalog = catread (name);`	216	`_kitten_catalog = catread (name);`
217	`if (_kitten_catalog)`	217	`if (_kitten_catalog)`
218	`return (_kitten_catalog);`	218	`return (_kitten_catalog);`
219	`}`	219	`}`
220		220
221	`/* If the message _kitten_catalog file name does not contain a directory *`	221	`/* If the message _kitten_catalog file name does not contain a directory *`
222	`* separator, then we need to try to locate the message _kitten_catalog. */`	222	`* separator, then we need to try to locate the message _kitten_catalog. */`
223		223
224	`/* We will need the value of LANG, and may need a 2-letter abbrev of`	224	`/* We will need the value of LANG, and may need a 2-letter abbrev of`
225	`LANG later on, so get it now. */`	225	`LANG later on, so get it now. */`
226		226
227	`lang = getenv ("LANG");`	227	`lang = getenv ("LANG");`
228		228
229	`if (lang == NULL)`	229	`if (lang == NULL)`
230	`{`	230	`{`
231	`/* printf("no lang= found\n"); // not fatal, though */`	231	`/* printf("no lang= found\n"); // not fatal, though */`
232	`/* Return failure - we won't be able to locate the cat file */`	232	`/* Return failure - we won't be able to locate the cat file */`
233	`return (-1);`	233	`return (-1);`
234	`}`	234	`}`
235		235
236	`if ((strlen (lang) < 2) \|\| ((strlen (lang) > 2) && (lang[2] != '-')))`	236	`if ((strlen (lang) < 2) \|\| ((strlen (lang) > 2) && (lang[2] != '-')))`
237	`{`	237	`{`
238	`/* Return failure - we won't be able to locate the cat file */`	238	`/* Return failure - we won't be able to locate the cat file */`
239	`return (-1);`	239	`return (-1);`
240	`}`	240	`}`
241		241
242	`memcpy (catlang, lang, 2);`	242	`memcpy (catlang, lang, 2);`
243	`/* we copy the full LANG value or the part before "-" if "-" found */`	243	`/* we copy the full LANG value or the part before "-" if "-" found */`
244	`catlang[2] = '\0';`	244	`catlang[2] = '\0';`
245		245
246	`/* step through NLSPATH */`	246	`/* step through NLSPATH */`
247		247
248	`nlsptr = getenv ("NLSPATH");`	248	`nlsptr = getenv ("NLSPATH");`
249		249
250	`if (nlsptr == NULL)`	250	`if (nlsptr == NULL)`
251	`{`	251	`{`
252	`/* printf("no NLSPATH= found\n"); // not fatal either */`	252	`/* printf("no NLSPATH= found\n"); // not fatal either */`
253	`/* Return failure - we won't be able to locate the cat file */`	253	`/* Return failure - we won't be able to locate the cat file */`
254	`return (-1);`	254	`return (-1);`
255	`}`	255	`}`
256		256
257	`catfile[0] = '\0';`	257	`catfile[0] = '\0';`
258		258
259	`while (nlsptr && nlsptr[0])`	259	`while (nlsptr && nlsptr[0])`
260	`{`	260	`{`
261	`#ifdef _MICROC_`	261	`#ifdef _MICROC_`
262	`tok = strchr (nlsptr, ';');`	262	`tok = strchr (nlsptr, ';');`
263	`#else`	263	`#else`
264	`char *tok = strchr (nlsptr, ';');`	264	`char *tok = strchr (nlsptr, ';');`
265	`int toklen;`	265	`int toklen;`
266	`#endif`	266	`#endif`
267		267
268	`if (tok == NULL)`	268	`if (tok == NULL)`
269	`toklen = strlen (nlsptr); /* last segment */`	269	`toklen = strlen (nlsptr); /* last segment */`
270	`else`	270	`else`
271	`toklen = tok - nlsptr; /* segment terminated by ';' */`	271	`toklen = tok - nlsptr; /* segment terminated by ';' */`
272		272
273	`/* catfile = malloc(toklen+1+strlen(name)+1+strlen(lang)+1); */`	273	`/* catfile = malloc(toklen+1+strlen(name)+1+strlen(lang)+1); */`
274	`/* Try to find the _kitten_catalog file in each path from NLSPATH */`	274	`/* Try to find the _kitten_catalog file in each path from NLSPATH */`
275		275
276	`if ((toklen + 6 + strlen (name)) > sizeof (catfile))`	276	`if ((toklen + 6 + strlen (name)) > sizeof (catfile))`
277	`{`	277	`{`
278	`write (1, "NLSPATH overflow\r\n", strlen ("NLSPATH overflow\r\n"));`	278	`write (1, "NLSPATH overflow\r\n", strlen ("NLSPATH overflow\r\n"));`
279	`return 0; /* overflow in NLSPATH, should never happen */`	279	`return 0; /* overflow in NLSPATH, should never happen */`
280	`}`	280	`}`
281		281
282	`/* Rule #1: %NLSPATH%\%LANG%\cat */`	282	`/* Rule #1: %NLSPATH%\%LANG%\cat */`
283		283
284	`memcpy (catfile, nlsptr, toklen);`	284	`memcpy (catfile, nlsptr, toklen);`
285	`strcpy (catfile + toklen, "\\");`	285	`strcpy (catfile + toklen, "\\");`
286	`strcat (catfile, catlang);`	286	`strcat (catfile, catlang);`
287	`strcat (catfile, "\\");`	287	`strcat (catfile, "\\");`
288	`strcat (catfile, name);`	288	`strcat (catfile, name);`
289	`_kitten_catalog = catread (catfile);`	289	`_kitten_catalog = catread (catfile);`
290	`if (_kitten_catalog)`	290	`if (_kitten_catalog)`
291	`return (_kitten_catalog);`	291	`return (_kitten_catalog);`
292		292
293	`/* Rule #2: %NLSPATH%\cat.%LANG% */`	293	`/* Rule #2: %NLSPATH%\cat.%LANG% */`
294		294
295	`/* memcpy(catfile, nlsptr, toklen); */`	295	`/* memcpy(catfile, nlsptr, toklen); */`
296	`strcpy (catfile + toklen, "\\");`	296	`strcpy (catfile + toklen, "\\");`
297	`strcat (catfile, name);`	297	`strcat (catfile, name);`
298	`strcat (catfile, ".");`	298	`strcat (catfile, ".");`
299	`strcat (catfile, catlang);`	299	`strcat (catfile, catlang);`
300	`_kitten_catalog = catread (catfile);`	300	`_kitten_catalog = catread (catfile);`
301	`if (_kitten_catalog)`	301	`if (_kitten_catalog)`
302	`return (_kitten_catalog);`	302	`return (_kitten_catalog);`
303		303
304	`/* Grab next tok for the next while iteration */`	304	`/* Grab next tok for the next while iteration */`
305		305
306	`nlsptr = tok;`	306	`nlsptr = tok;`
307	`if (nlsptr)`	307	`if (nlsptr)`
308	`nlsptr++;`	308	`nlsptr++;`
309		309
310	`} /* while tok */`	310	`} /* while tok */`
311		311
312	`/* We could not find it. Return failure. */`	312	`/* We could not find it. Return failure. */`
313		313
314	`return (-1);`	314	`return (-1);`
315	`}`	315	`}`
316		316
317		317
318	`/**`	318	`/**`
319	`* Load a message catalog into memory.`	319	`* Load a message catalog into memory.`
320	`*/`	320	`*/`
321		321
322	`int`	322	`int`
323	`catread (char *catfile)`	323	`catread (char *catfile)`
324	`{`	324	`{`
325	`int file; /* pointer to the catfile */`	325	`int file; /* pointer to the catfile */`
326	`int i;`	326	`int i;`
327	`char *where;`	327	`char *where;`
328	`char *tok;`	328	`char *tok;`
329	`#ifdef _MICROC_`	329	`#ifdef _MICROC_`
330	`char *msg;`	330	`char *msg;`
331	`char *key;`	331	`char *key;`
332	`int key1;`	332	`int key1;`
333	`int key2;`	333	`int key2;`
334	`#endif`	334	`#endif`
335		335
336	`/* Get the whole catfile into a buffer and parse it */`	336	`/* Get the whole catfile into a buffer and parse it */`
337		337
338	`file = open (catfile, O_RDONLY \| O_TEXT);`	338	`file = open (catfile, O_RDONLY \| O_TEXT);`
339	`if (file < 0)`	339	`if (file < 0)`
340	`/* Cannot open the file. Return failure */`	340	`/* Cannot open the file. Return failure */`
341	`return 0;`	341	`return 0;`
342		342
343	`for (i = 0; i < 128; i++)`	343	`for (i = 0; i < 128; i++)`
344	`catpoints[i].text = NULL;`	344	`catpoints[i].text = NULL;`
345		345
346	`for (i = 0; (unsigned int) i < sizeof (catcontents); i++)`	346	`for (i = 0; (unsigned int) i < sizeof (catcontents); i++)`
347	`catcontents[i] = '\0';`	347	`catcontents[i] = '\0';`
348		348
349	`/* Read the file into memory */`	349	`/* Read the file into memory */`
350	`i = read (file, catcontents, sizeof (catcontents) - 1);`	350	`i = read (file, catcontents, sizeof (catcontents) - 1);`
351		351
352	`if ((i == sizeof (catcontents) - 1) \|\| (i < 1))`	352	`if ((i == sizeof (catcontents) - 1) \|\| (i < 1))`
353	`return 0; /* file was too big or too small */`	353	`return 0; /* file was too big or too small */`
354		354
355	`where = catcontents;`	355	`where = catcontents;`
356	`i = 0; /* catpoints entry */`	356	`i = 0; /* catpoints entry */`
357		357
358	`do`	358	`do`
359	`{`	359	`{`
360	`#ifndef _MICROC_`	360	`#ifndef _MICROC_`
361	`char *msg;`	361	`char *msg;`
362	`char *key;`	362	`char *key;`
363	`int key1 = 0;`	363	`int key1 = 0;`
364	`int key2 = 0;`	364	`int key2 = 0;`
365	`#else`	365	`#else`
366	`key1 = 0;`	366	`key1 = 0;`
367	`key2 = 0;`	367	`key2 = 0;`
368	`#endif`	368	`#endif`
369		369
370	`tok = strchr (where, '\n');`	370	`tok = strchr (where, '\n');`
371		371
372	`if (tok == NULL)`	372	`if (tok == NULL)`
373	`{ /* done? */`	373	`{ /* done? */`
374	`close (file);`	374	`close (file);`
375	`return 1; /* success */`	375	`return 1; /* success */`
376	`}`	376	`}`
377		377
378	`tok[0] = '\0'; /* terminate here */`	378	`tok[0] = '\0'; /* terminate here */`
379	`tok--; /* guess: \r before \n */`	379	`tok--; /* guess: \r before \n */`
380	`if (tok[0] != '\r')`	380	`if (tok[0] != '\r')`
381	`tok++; /* if not, go back */`	381	`tok++; /* if not, go back */`
382	`else`	382	`else`
383	`{`	383	`{`
384	`tok[0] = '\0'; /* terminate here already */`	384	`tok[0] = '\0'; /* terminate here already */`
385	`tok++;`	385	`tok++;`
386	`}`	386	`}`
387	`tok++; /* this is where the next line starts */`	387	`tok++; /* this is where the next line starts */`
388		388
389	`if ((where[0] >= '0') && (where[0] <= '9') &&`	389	`if ((where[0] >= '0') && (where[0] <= '9') &&`
390	`((msg = strchr (where, ':')) != NULL))`	390	`((msg = strchr (where, ':')) != NULL))`
391	`{`	391	`{`
392	`/* Skip everything which starts with # or with no digit */`	392	`/* Skip everything which starts with # or with no digit */`
393	`/* Entries look like "1.2:This is a message" */`	393	`/* Entries look like "1.2:This is a message" */`
394		394
395	`msg[0] = '\0'; /* remove : */`	395	`msg[0] = '\0'; /* remove : */`
396	`msg++; /* go past the : */`	396	`msg++; /* go past the : */`
397		397
398	`if ((key = strchr (where, '.')) != NULL)`	398	`if ((key = strchr (where, '.')) != NULL)`
399	`{`	399	`{`
400	`key[0] = '\0'; /* turn . into terminator */`	400	`key[0] = '\0'; /* turn . into terminator */`
401	`key++; /* go past the . */`	401	`key++; /* go past the . */`
402	`key1 = mystrtoul (where, 10, strlen (where));`	402	`key1 = mystrtoul (where, 10, strlen (where));`
403	`key2 = mystrtoul (key, 10, strlen (key));`	403	`key2 = mystrtoul (key, 10, strlen (key));`
404		404
405	`if ((key1 >= 0) && (key2 >= 0))`	405	`if ((key1 >= 0) && (key2 >= 0))`
406	`{`	406	`{`
407	`catpoints[i].key1 = key1;`	407	`catpoints[i].key1 = key1;`
408	`catpoints[i].key2 = key2;`	408	`catpoints[i].key2 = key2;`
409	`catpoints[i].text = processEscChars (msg);`	409	`catpoints[i].text = processEscChars (msg);`
410	`if (catpoints[i].text == NULL) /* ESC parse error */`	410	`if (catpoints[i].text == NULL) /* ESC parse error */`
411	`catpoints[i].text = msg;`	411	`catpoints[i].text = msg;`
412	`i++; /* next entry! */`	412	`i++; /* next entry! */`
413	`} /* valid keys */`	413	`} /* valid keys */`
414		414
415	`} /* . found */`	415	`} /* . found */`
416		416
417	`} /* : and digit found */`	417	`} /* : and digit found */`
418		418
419	`where = tok; /* go to next line */`	419	`where = tok; /* go to next line */`
420		420
421	`}`	421	`}`
422	`while (1);`	422	`while (1);`
423	`#ifdef __PACIFIC__`	423	`#ifdef __PACIFIC__`
424	`return 0;`	424	`return 0;`
425	`#endif`	425	`#endif`
426	`}`	426	`}`
427		427
428		428
429	`void`	429	`void`
430	`kittenclose (void)`	430	`kittenclose (void)`
431	`{`	431	`{`
432	`/* close a message _kitten_catalog */`	432	`/* close a message _kitten_catalog */`
433	`_kitten_catalog = 0;`	433	`_kitten_catalog = 0;`
434	`}`	434	`}`
435		435
436		436
437	`/**`	437	`/**`
438	`* Parse a string that represents an unsigned integer.`	438	`* Parse a string that represents an unsigned integer.`
439	`* Returns -1 if an error is found. The first size`	439	`* Returns -1 if an error is found. The first size`
440	`* chars of the string are parsed.`	440	`* chars of the string are parsed.`
441	`*/`	441	`*/`
442		442
443	`int`	443	`int`
444	`mystrtoul (char *src, int base, int size)`	444	`mystrtoul (char *src, int base, int size)`
445	`{`	445	`{`
446	`#ifdef _MICROC_`	446	`#ifdef _MICROC_`
447	`int ret;`	447	`int ret;`
448	`int digit;`	448	`int digit;`
449	`int ch;`	449	`int ch;`
450	`ret = 0;`	450	`ret = 0;`
451	`#else`	451	`#else`
452	`int ret = 0;`	452	`int ret = 0;`
453	`#endif`	453	`#endif`
454		454
455	`for (; size > 0; size--)`	455	`for (; size > 0; size--)`
456	`{`	456	`{`
457	`#ifdef _MICROC_`	457	`#ifdef _MICROC_`
458	`ch = *src;`	458	`ch = *src;`
459	`#else`	459	`#else`
460	`int digit;`	460	`int digit;`
461	`int ch = *src;`	461	`int ch = *src;`
462	`#endif`	462	`#endif`
463	`src++;`	463	`src++;`
464		464
465	`if (ch >= '0' && ch <= '9')`	465	`if (ch >= '0' && ch <= '9')`
466	`digit = ch - '0';`	466	`digit = ch - '0';`
467	`else if (ch >= 'A' && ch <= 'Z')`	467	`else if (ch >= 'A' && ch <= 'Z')`
468	`digit = ch - 'A' + 10;`	468	`digit = ch - 'A' + 10;`
469	`else if (ch >= 'a' && ch <= 'z')`	469	`else if (ch >= 'a' && ch <= 'z')`
470	`digit = ch - 'a' + 10;`	470	`digit = ch - 'a' + 10;`
471	`else`	471	`else`
472	`return -1;`	472	`return -1;`
473		473
474	`if (digit >= base)`	474	`if (digit >= base)`
475	`return -1;`	475	`return -1;`
476		476
477	`ret = ret * base + digit;`	477	`ret = ret * base + digit;`
478	`} /* for */`	478	`} /* for */`
479		479
480	`return ret;`	480	`return ret;`
481	`}`	481	`}`
482		482
483		483
484	`/**`	484	`/**`
485	`* Process strings, converting \n, \t, \v, \b, \r, \f, \\,`	485	`* Process strings, converting \n, \t, \v, \b, \r, \f, \\,`
486	`* \ddd, \xdd and \x0dd to actual chars.`	486	`* \ddd, \xdd and \x0dd to actual chars.`
487	`* (Note: \x is an extension to support hexadecimal)`	487	`* (Note: \x is an extension to support hexadecimal)`
488	`* This is used to allow the messages to use c escape sequences.`	488	`* This is used to allow the messages to use c escape sequences.`
489	`* Modifies the line in-place (always same size or shorter).`	489	`* Modifies the line in-place (always same size or shorter).`
490	`* Returns a pointer to input string.`	490	`* Returns a pointer to input string.`
491	`*/`	491	`*/`
492		492
493	`char *`	493	`char *`
494	`processEscChars (char *line)`	494	`processEscChars (char *line)`
495	`{`	495	`{`
496	`/* used when converting \xdd and \ddd (hex or octal) characters */`	496	`/* used when converting \xdd and \ddd (hex or octal) characters */`
497	`char ch;`	497	`char ch;`
498	`#ifdef _MICROC_`	498	`#ifdef _MICROC_`
499	`char *src;`	499	`char *src;`
500	`char *dst;`	500	`char *dst;`

Subversion Repositories SvarDOS

(root)/pkg/kitten/kitten.c @ 436 – Rev 244 → 269