Esempio n. 1
12
nl_catd (catopen) (const char *name, int oflag)
{
  _CAT_CATALOG_T *_kitten_catalog = 0;
  static STRING_T *catfile = 0;
  static STRING_T *nlspath = 0;
  size_t pos;

  /* According to the Posix definition, if name has a '/', the name is the
     entire path to the file. Expand that to include ':' and '\\' for 
     FreeDOS.  */
  if (strpbrk (name, ":/\\") != 0)
    _kitten_catalog = catread (name);
  else
    {
      /* Open the catalog file. */
      catfile = DScreate ();
      nlspath = DScreate ();
      get_name_from_nlspath (nlspath, (char *) name);
      while (_kitten_catalog == 0 && DSlength (nlspath) != 0)
	{
	  pos = DSfind (nlspath, ";", 0, 1);
	  DSassign (catfile, nlspath, 0, pos);
	  if (DSlength (catfile) == 0)
	    DSassigncstr (catfile, (char *) name, NPOS);
	  _kitten_catalog = catread (DScstr (catfile));
	  DSremove (nlspath, 0, (pos == NPOS) ? NPOS : pos + 1);
	}
      DSdestroy (nlspath);
      DSdestroy (catfile);
    }
  /* If we could not find it, return failure. Otherwise, install the
     catalog and return a cookie.  */
  return _kitten_catalog ? install_catalog (_kitten_catalog) : (nl_catd) (-1);
}
Esempio n. 2
0
/*
  NAME

    catgets - read a program message

  SYNOPSIS

    #include <nl_types.h>

    char *catgets(nl_catd catd, int set_id, int msg_id, const char *s);

  DESCRIPTION

    The catgets() function shall attempt to read message msg_id, in set
    set_id, from the message catalog identified by catd. The catd argument is
    a message catalog descriptor returned from an earlier call to catopen().
    The s argument points to a default message string which shall be returned
    by catgets() if it cannot retrieve the identified message.

    The catgets() function need not be reentrant. A function that is not
    required to be reentrant is not required to be thread-safe.

  RETURN VALUE

    If the identified message is retrieved successfully, catgets() shall
    return a pointer to an internal buffer area containing the null-terminated
    message string. If the call is unsuccessful for any reason, s shall be
    returned and errno may be set to indicate the error.

  ERRORS

    The catgets() function may fail if:

    [EBADF]
        The catd argument is not a valid message catalog descriptor open for
        reading.
    [EBADMSG]
        The message identified by set_id and msg_id in the specified message
        catalog did not satisfy implementation-defined security criteria.
    [EINTR]
        The read operation was terminated due to the receipt of a signal, and
        no data was transferred.
    [EINVAL]
        The message catalog identified by catd is corrupted.
    [ENOMSG]
        The message identified by set_id and msg_id is not in the message 
        catalog.

*/
char *(catgets) (nl_catd catd, int set_id, int msg_id, const char *s)
{
  _CAT_CATALOG_T *cat;
  static _CAT_MESSAGE_T keymsg = { 0, 0, 0 };
  _CAT_MESSAGE_T *msgptr = 0;

  if (theCatalogues == 0 || _CATCAT_length (theCatalogues) <= catd
      || (cat = _CATCAT_get_at (theCatalogues, catd))->is_opened == 0)
    {
      errno = EBADF;
      return (char *) s;
    }
  keymsg.set_id = set_id;
  keymsg.msg_id = msg_id;
  msgptr =
    bsearch (&keymsg, _CATMSG_base (cat->msgs), _CATMSG_length (cat->msgs),
	     sizeof (_CAT_MESSAGE_T), catmsg_cmp);
  if (msgptr == 0)
    {
#ifdef ENOMSG
      errno = ENOMSG;
#endif
      return (char *) s;
    }
  return DScstr (msgptr->msg);
}
Esempio n. 3
0
/* read a line from stdin */
char *
read_line (char *prompt)
{
  static STRING_T *ds = 0;
  int c;
#ifdef SHIFT_JIS
  size_t ds_length = 0;
#endif

  if (ds == 0)
    ds = DScreate ();
  DSresize (ds, 0, 0);
  fputs (prompt, stdout);
  fflush (stdout);
#ifndef SHIFT_JIS
  /* Normal terminal input. Assumes that I don't have to handle control 
     characters here.  */
  while ((c = getchar ()) != EOF && c != '\n')
    DSappendchar (ds, c, 1);
#else /* SHIFT_JIS */
  /* Rolling our own getchar loop here. The thing to watch out for is that a
     backspace has to destroy BOTH characters of a Shift-JIS code and that a
     carriage return is equivalent to a newline.  */
  do
    {
      while (!kbhit_f ())
        ;                       /* key wait */
      c = getch ();
      if (c == '\r')
        c = '\n';
      if (c == '\b')
        {
          /* handle backspace */
          ds_length = DSlength (ds);
          if (ds_length >= 2 && iskanji (DSgetat (ds, ds_length - 2)))
            {
              DSresize (ds, ds_length - 2, 0);
              fputs ("\b \b\b \b", stdout);
            }
          else if (ds_length > 0)
            {
              DSresize (ds, ds_length - 1, 0);
              fputs ("\b \b", stdout);
            }
        }
      else
        {
          /* normal character */
          putchar (c);
          DSappendchar (ds, c, 1);
        }
      fflush (stdout);
    }
  while (c != EOF && c != '\n');
#endif /* SHIFT_JIS */
  return DScstr (ds);
}
Esempio n. 4
0
/* display a block of text */
void
display_block (unsigned long first_line,
               unsigned long last_line,
               unsigned long current_line, size_t page_size)
{
  unsigned long i;
  size_t lines_written;
  for (i = first_line, lines_written = 0;
       i <= last_line && i < DAS_length (buffer); i++)
    {
      printf (G00008, i + 1, i == current_line ? '*' : ' ',
              DScstr (DAS_get_at (buffer, i)));
      lines_written++;
      if (lines_written == page_size && i != last_line)
        {
          read_line (G00009);
          lines_written = 0;
        }
    }
}
Esempio n. 5
0
/* make_bakfile - make a backup file */
static void
make_bakfile (char *filename)
{
  STRING_T *s = 0;
  size_t pos, dotpos;
  static char dot[2] = { '.', '\0' };   /* to foil cstrings */
  static char bak[5] = { '.', 'b', 'a', 'k', '\0' };

  if (!file_exists (filename))
    return;
  s = DScreate ();
  DSassigncstr (s, filename, NPOS);
  pos = DSfind_last_of (s, FILENAME_DELIMITERS, NPOS, NPOS);
  dotpos = DSfind (s, dot, pos + 1, NPOS);
  if (dotpos != NPOS)
    DSresize (s, dotpos, 0);
  DSappendcstr (s, bak, NPOS);
  rename (filename, DScstr (s));
  DSdestroy (s);
}
Esempio n. 6
0
/* write X number of lines to a file */
void
write_file (unsigned long lines, char *filename)
{
  FILE *f;
  size_t i;

  make_bakfile (filename);
  if ((f = fopen (filename, "w")))
    {
      i = DAS_length (buffer);
      if (lines >= i)
        lines = i;
      for (i = 0; i < lines; i++)
        {
          fputs ((const char *) DScstr (DAS_get_at (buffer, i)), f);
          fputc ('\n', f);
        }
      fclose (f);
      printf ((i == 1) ? G00006 : G00007, filename, (unsigned long) i);
    }
}
Esempio n. 7
0
/* search_buffer - search a buffer for a string */
unsigned long
search_buffer (unsigned long current_line,
               unsigned long line1, unsigned long line2, int verify, char *s)
{
  unsigned long line;
  STRING_T *ds;
  int q = 0;
  char *yn;
  size_t numlines = DAS_length (buffer);

  if (line1 > numlines || line2 > numlines)
    {
      puts (G00003);
      return current_line;
    }
  while (isspace ((unsigned char) *s))
    s++;
  if (*s == '\'' || *s == '\"')
    q = *s++;
  ds = translate_string (s, q);
  if (DSlength (ds) != 0)
    for (line = line1; line <= line2; line++)
      {
        if (DSfind (DAS_get_at (buffer, (size_t) line), DScstr (ds), 0,
                    DSlength (ds)) != NPOS)
          {
            display_block (line, line, line, 1);
            if (verify)
              {
                yn = read_line (G00002);
                if (*yn == 0 || strchr (YES, *yn) != 0)
                  return line + 1;
              }
            else
              return line + 1;
          }
      }
  puts (G00011);
  return current_line;
}
Esempio n. 8
0
/* replace_buffer - search the buffer for a string, then replace it with
   another string. */
unsigned long
replace_buffer (unsigned long current_line,
                unsigned long line1, unsigned long line2, int verify, char *s)
{
  unsigned long line;
  STRING_T *ds, *ds1, *dc;
  int q = 0;
  char *yn;
  size_t origpos;

  while (isspace ((unsigned char) *s))
    s++;
  if (*s == '\'' || *s == '\"')
    q = *s++;
  else
    q = ',';
  ds = DScreate ();
  DSassign (ds, translate_string (s, q), 0, NPOS);
  /* pick off second string */
  while (*s != q && *s)
    s += (*s == '\\' ? 2 : 1);
  while (*s != ',')
    s++;
  s++;
  while (isspace ((unsigned char) *s))
    s++;
  if (*s == '\'' || *s == '\"')
    q = *s++;
  else
    q = 0;
  ds1 = DScreate ();
  DSassign (ds1, translate_string (s, q), 0, NPOS);
  if (DSlength (ds) != 0 && DScompare (ds, ds1, 0, NPOS) != 0)
    for (line = line1; line <= line2; line++)
      {
        origpos = 0;
        while ((origpos = DSfind (DAS_get_at (buffer, (size_t) line),
                                  DScstr (ds), origpos, DSlength (ds)))
               != NPOS)
          {
            dc = DScreate ();
            DSassign (dc, DAS_get_at (buffer, line), 0, NPOS);
            DSreplace (dc, origpos, DSlength (ds), ds1, 0, NPOS);
            printf (G00012, line + 1, DScstr (dc));
            if (verify)
              yn = read_line (G00002);
            if (!verify || (*yn == 0 || strchr (YES, *yn) != 0))
              {
                current_line = line + 1;
                origpos += DSlength (ds1);
                DAS_put_at (buffer, line, dc);
              }
            else
              origpos++;
            DSdestroy (dc);
          }
      }
  DSdestroy (ds);
  DSdestroy (ds1);
  return current_line;
}