#endif
#include <nl_types.h>
-#if defined(AFS_OSF_ENV) && !defined(AFS_OSF20_ENV)
-#include <fcntl.h>
-static nl_catd catopen1();
-nl_catd NLcatopen();
-static nl_catd _do1_open();
-static nl_catd cat_already_open();
-static int make_sets();
-static FILE *open1catfile();
-static void add_open_cat();
-static void cat_hard_close();
-extern char *strchr();
-
-static int catpid[NL_MAXOPEN];
-static CATD *catsopen[NL_MAXOPEN];
-#define PATH_FORMAT "/usr/lib/nls/msg/%L/%N:/etc/nls/msg/%L/%N"
-#define DEFAULT_LANG "C"
-#define TOO_MANY_HOLES(num_holes, num_non_holes) \
- (((num_holes) > 100) && ((num_holes) > (num_non_holes)))
-
-char *
-rmalloc(int n)
- /*---- n: the number of bytes to be malloc'ed ----*/
-{
- char *t;
-
- t = (char *)malloc(n);
- if (!t)
- printf("Failed to get mem\n");
- return (t);
-}
-
-#ifdef notdef
-#endif
-nl_catd
-catopen1(char *cat, int dummy)
- /*---- char *cat: the name of the cat to be opened ----*/
- /*---- int dummy: dummy variable ----*/
-
-{
- int errno_save;
- nl_catd _do_open(); /*---- routine that actually opens
- the catalog ---- */
- CATD *catd;
-
- errno_save = errno;
-
-/*
- if (catd = cat_already_open(cat)) {
- catd->_count = catd->_count + 1;
- return(catd);
- }
-*/
- catd = (CATD *) rmalloc(sizeof(CATD));
- if (catd == NULL)
- return (CATD_ERR);
- catd->_name = (char *)rmalloc(strlen(cat) + 1);
- if (catd->_name == NULL)
- return (CATD_ERR);
- strcpy(catd->_name, cat);
- catd->_fd = FALSE;
- catd->_magic = CAT_MAGIC;
- catd->_mem = FALSE;
-#ifndef AFS_OSF20_ENV
- catd->_pid = getpid();
-#endif
- catd->_count = 1;
- if (_do1_open(catd) != CATD_ERR)
- return (catd);
- else {
- free(catd->_name);
- free(catd);
- return (CATD_ERR);
- }
-}
-
-
-
-nl_catd
-_do1_open(nl_catd catd)
- /*---- pointer to the partially set up cat descriptor ----*/
-{
- int make_sets(); /*---- routine to unpack the sets into
- fast acccess mode ----*/
- void add_open_cat(); /*---- routine to keep a list of
- opened cats ----*/
- /*long */ int magic;
- int i; /*---- Misc counter(s) used for loop */
- struct _catset cs;
- int errno_save;
- int num_holes;
-
- errno_save = errno;
-
- catd->_fd = open1catfile(catd->_name);
- if (!catd->_fd) {
- return (CATD_ERR);
- }
- fread((void *)&magic, (size_t) 4, (size_t) 1, catd->_fd);
- if (magic != CAT_MAGIC) {
- printf("Magic was %x instead of %x -> %x\n", magic, CAT_MAGIC,
- CATD_ERR);
-/*
- fclose(catd->_fd);
- catd->_fd = NULL;
- return( CATD_ERR );
-*/
- }
-/* if ((catd->_mem = shmat((int)fileno(catd->_fd), NULL, SHM_MAP | SHM_RDONLY))
- == (char * )ERR ) { */
-
- if (1) { /* disable the shmat, share memory segemnt */
-
-/*______________________________________________________________________
- If the file can not be mapped then simulate mapping for the index
- table so that make_sets cat set things up. (rmalloc an area big
- enough for the index table and read the whole thing in)
- ______________________________________________________________________*/
-
- /* reset the file pointer to the beginning of catalog */
- fseek(catd->_fd, (long)0, 0);
-
- /* malloc the header, if fails return error */
- catd->_hd = (struct _header *)rmalloc(sizeof(struct _header));
- if (catd->_hd == NULL)
- return (CATD_ERR);
-
- /* read in the whole header */
- fread((void *)catd->_hd, (size_t) sizeof(struct _header), (size_t) 1,
- catd->_fd);
-
- /* cs is a dummpy to hold a set temperorily. The purpose of */
- /* this for loop is to fread the whole catalog so that the */
- /* file pointer will be moved to the end of the catalog. */
- for (i = 0; i < catd->_hd->_n_sets; i++) {
- fread((void *)&cs, (size_t) 4, (size_t) 1, catd->_fd);
- fseek(catd->_fd, (long)(cs._n_msgs * sizeof(struct _msgptr)), 1);
- }
-
- /* after the for loop, ftell returns the byte offset of the */
- /* end of the catalog relative to the begining of the file. */
- /* i.e. i contains the byte offset of the whole catalog. */
- i = ftell(catd->_fd);
-
- /* malloc _mem as a temp pointer to hold the entire catalog. */
- catd->_mem = (char *)rmalloc(i);
- if (catd->_mem == NULL)
- return (CATD_ERR);
-
- /* reset the file pointer to the begining. */
- fseek(catd->_fd, (long)0, 0);
-
- /* read in the whole catalog into _mem */
- fread((void *)catd->_mem, (size_t) i, (size_t) 1, catd->_fd);
-
- /*
- * If there aren't many holes in the set numbers,
- * fully expand the compacted set array from the
- * catalog. Then in catgets(), we'll be able to use
- * the set number to index directly into the expanded
- * array.
- *
- * If there are a lot of holes, leave the set array
- * compacted. In catgets(), we'll search through it
- * for the requested set.
- */
-
- num_holes = catd->_hd->_setmax - catd->_hd->_n_sets;
- if (!TOO_MANY_HOLES(num_holes, catd->_hd->_n_sets)) {
- catd->_sets_expanded = TRUE;
- catd->_n_sets = catd->_hd->_setmax;
- } else {
- catd->_sets_expanded = FALSE;
- catd->_n_sets = catd->_hd->_n_sets - 1;
- }
-
- /* malloc one extra set more than the max. set index */
- catd->_set =
- (struct _catset *)rmalloc((catd->_n_sets + 1) *
- sizeof(struct _catset));
- if (catd->_set == NULL)
- return (CATD_ERR);
-
- /* save the max. set number in catd->_setmax */
- catd->_setmax = catd->_hd->_setmax;
- /* call make_set to malloc memory for every message */
- if (make_sets(catd) == -1)
- return (CATD_ERR);
- free(catd->_mem);
- catd->_mem = FALSE;
- add_open_cat(catd);
- return (catd);
- } else {
-
-/*______________________________________________________________________
- Normal mapping has occurred, set a few things up and call make_sets
- ______________________________________________________________________*/
-
- catd->_hd = (struct _header *)(catd->_mem);
- catd->_setmax = catd->_hd->_setmax;
- catd->_set =
- (struct _catset *)rmalloc((catd->_hd->_setmax + 1) *
- sizeof(struct _catset));
- if (catd->_set == NULL)
- return (CATD_ERR);
- if (make_sets(catd) == -1)
- return (CATD_ERR);
- add_open_cat(catd);
- return (catd);
- }
-}
-
-
-static void
-add_open_cat(nl_catd catd)
- /*---- catd to be added to the list of catalogs ----*/
-{
- int i = 0; /*---- Misc counter(s) used for loops ----*/
- while (i < NL_MAXOPEN && catsopen[i]) {
- if (!strcmp(catd->_name, catsopen[i]->_name)
-#ifndef AFS_OSF20_ENV
- && getpid() == catsopen[i]->_pid)
-#else
- )
-#endif
- return; /*---- The catalog is already here ----*/
- i++;
- }
-
- if (i < NL_MAXOPEN) {
- catsopen[i] = catd;
- catpid[i] = getpid();
- }
-}
-
-
-/*
- *
- * NAME: make_sets
- *
- * FUNCTION: Expands the compacted version of the catalog index table into
- * the fast access memory version.
- *
- * EXECUTION ENVIRONMENT:
- *
- * Make_set executes under a process.
- *
- * RETURNS: int
- */
-
-
-static int
-make_sets(nl_catd catd)
-{
- struct _catset *cset;
- char *base = catd->_mem;
- int n_sets = catd->_hd->_n_sets;
- int i; /*---- Misc counter(s) used for loops ----*/
- int j; /*---- Misc counter(s) used for loops ----*/
- int msgmax; /*---- The maximum number of _messages in a set ----*/
- char *cmpct_set_ptr; /*---- pointer into the index table ----*/
- struct _catset cs; /*---- used to look at the sets in the table -*/
- int num_holes;
-
- cmpct_set_ptr = base + sizeof(struct _header);
-
- for (i = 0; i < n_sets; i++) {
- /* loop through each compacted set */
-
- cs = *(struct _catset *)cmpct_set_ptr;
- /* set the _catset ptr to the base of the current
- * compacted set. */
-
- cs._mp =
- (struct _msgptr *)(cmpct_set_ptr + 2 * sizeof(unsigned short));
- /* set the ms array ptr to the base of
- * compacted array of _msgptr's */
-
- cset =
- (catd->_sets_expanded) ? &catd->_set[cs._setno] : &catd->_set[i];
-
- /*
- * If there aren't many holes in the message numbers,
- * fully expand the compacted message array from the
- * catalog. Then in catgets(), we'll be able to use
- * the message number to index directly into the
- * expanded array.
- *
- * If there are many holes, leave the message array
- * compacted. In catgets(), we'll search through it
- * for the requested message.
- */
-
- msgmax = cs._mp[cs._n_msgs - 1]._msgno;
- num_holes = msgmax - cs._n_msgs;
- if (!TOO_MANY_HOLES(num_holes, cs._n_msgs)) {
- cset->_msgs_expanded = TRUE;
- cset->_n_msgs = msgmax;
- } else {
- cset->_msgs_expanded = FALSE;
- cset->_n_msgs = cs._n_msgs - 1;
- }
-
- cset->_mp =
- (struct _msgptr *)rmalloc((1 + cset->_n_msgs) *
- sizeof(struct _msgptr));
- if (cset->_mp == NULL)
- return (-1);
-
- cset->_msgtxt =
- (char **)rmalloc((1 + cset->_n_msgs) * sizeof(char *));
- if (cset->_msgtxt == NULL)
- return (-1);
-
- if (cset->_msgs_expanded) {
- for (j = 0; j < cs._n_msgs; j++) {
- cset->_mp[cs._mp[j]._msgno] = cs._mp[j];
- }
- } else {
- for (j = 0; j < cs._n_msgs; j++) {
- cset->_mp[j] = cs._mp[j];
- }
- }
-
- cset->_setno = cs._setno;
- /* Superfluous but should have the correct data. Increment
- * the base of the set pointer. */
-
- cmpct_set_ptr +=
- 2 * sizeof(unsigned short) + cs._n_msgs * sizeof(struct _msgptr);
- }
- return (0);
-}
-
-
-
-/*
- *
- * NAME: opencatfile
- *
- * FUNCTION: Opens a catalog file, looking in the language path first (if
- * there is no slash) and returns a pointer to the file stream.
- *
- * EXECUTION ENVIRONMENT:
- *
- * Opencatfile executes under a process.
- *
- * RETURNS: Returns a pointer to the file stream, and a NULL pointer on
- * failure.
- */
-
-static FILE *
-open1catfile(char *file)
-{
- extern char *getenv();
- char fl[PATH_MAX]; /*---- place to hold full path ----*/
- char *nlspath; /*---- pointer to the nlspath val ----*/
- FILE *fp; /*---- file pointer ----*/
- char cpth[PATH_MAX]; /*---- current value of nlspath ----*/
- char *p, *np;
- char *fulllang; /* %L language value */
- char lang[PATH_MAX]; /* %l language value */
- char *territory; /* %t language value */
- char *codeset; /* %c language value */
- char *ptr; /* for decompose of $LANG */
- char *str;
- char *optr;
- int nchars;
- int lenstr;
- char outptr[PATH_MAX];
- int valid;
-
- if (strchr(file, '/')) {
- if ((fp = fopen(file, "r"))) {
- fcntl(fileno(fp), F_SETFD, 1);
- /* set the close-on-exec flag for
- * child process */
- return (fp);
- }
- } else {
- if (!(nlspath = getenv("NLSPATH")))
- nlspath = PATH_FORMAT;
- if (!(fulllang = getenv("LANG")))
- fulllang = DEFAULT_LANG;
- if (fulllang == DEFAULT_LANG)
- nlspath = PATH_FORMAT; /* if fullang is C, use the
- * the default nlspath: */
-
- /*
- ** LANG is a composite of three fields:
- ** language_territory.codeset
- ** and we're going to break it into those
- ** three fields.
- */
-
- strcpy(lang, fulllang);
-
- territory = "";
- codeset = "";
-
- ptr = strchr(lang, '_');
- if (ptr != NULL) {
- territory = ptr + 1;
- *ptr = '\0';
- ptr = strchr(territory, '.');
- if (ptr != NULL) {
- codeset = ptr + 1;
- *ptr = '\0';
- }
- } else {
- ptr = strchr(lang, '.');
- if (ptr != NULL) {
- codeset = ptr + 1;
- *ptr = '\0';
- }
- }
-
- np = nlspath;
- while (*np) {
- p = cpth;
- while (*np && *np != ':')
- *p++ = *np++;
- *p = '\0';
- if (*np) /*---- iff on a colon then advance --*/
- np++;
- valid = 0;
- if (strlen(cpth)) {
- ptr = cpth;
- optr = outptr;
-
- nchars = 0;
- while (*ptr != '\0') {
- while ((*ptr != '\0') && (*ptr != '%')
- && (nchars < PATH_MAX)) {
- *(optr++) = *(ptr++);
- nchars++;
- }
- if (*ptr == '%') {
- switch (*(++ptr)) {
- case '%':
- str = "%";
- break;
- case 'L':
- str = fulllang;
- break;
- case 'N':
- valid = 1;
- str = file;
- break;
- case 'l':
- str = lang;
- break;
- case 't':
- str = territory;
- break;
- case 'c':
- str = codeset;
- break;
- default:
- str = "";
- break;
- }
- lenstr = strlen(str);
- nchars += lenstr;
- if (nchars < PATH_MAX) {
- strcpy(optr, str);
- optr += lenstr;
- } else {
- break;
- }
- ptr++;
- } else {
- if (nchars >= PATH_MAX) {
- break;
- }
- }
- }
- *optr = '\0';
- strcpy(cpth, outptr);
- } else { /*---- iff leading | trailing |
- adjacent colons ... --*/
- valid = 1;
- strcpy(cpth, file);
- }
- if (valid == 1 && (fp = fopen(cpth, "r"))) {
- fcntl(fileno(fp), F_SETFD, 1);
- /* set the close-on-exec flag for
- * child process */
- return (fp);
- }
- }
- if (fp = fopen(file, "r")) {
- fcntl(fileno(fp), F_SETFD, 1);
- /* set the close-on-exec flag for
- * child process */
- return (fp);
- }
- }
- return (NULL);
-}
-
-
-
-
-
-/*
- *
- * NAME: cat_already_open
- *
- * FUNCTION: Checkes to see if a specific cat has already been opened.
- *
- * EXECUTION ENVIRONMENT:
- *
- * Cat_already_open executes under a process.
- *
- * RETURNS: Returns a pointer to the existing CATD if one exists, and
- * a NULL pointer if no CATD exists.
- */
-
-static nl_catd
-cat_already_open(char *cat)
- /*---- name of the catalog to be opened ----*/
-{
- int i; /*---- Misc counter(s) used for loops ----*/
-
- for (i = 0; i < NL_MAXOPEN && catsopen[i]; i++) {
-#ifndef AFS_OSF20_ENV
- if (!strcmp(cat, catsopen[i]->_name) && getpid() == catsopen[i]->_pid) {
-#else
- if (!strcmp(cat, catsopen[i]->_name)) {
-#endif
- return (catsopen[i]);
- }
- }
- return (0);
-}
-
-
-int
-catclose1(nl_catd catd)
- /*---- the catd to be closed ----*/
-{
- int i;
-
-
- if (catd == CATD_ERR)
- return (-1);
- for (i = 0; i < NL_MAXOPEN && catsopen[i]; i++) {
-#ifndef AFS_OSF20_ENV
- if (catd == catsopen[i] && getpid() == catsopen[i]->_pid)
-#else
- if (catd == catsopen[i])
-#endif
- break;
- }
- if (i == NL_MAXOPEN || catsopen[i] == NULL)
- return (-1);
- if (catd->_fd == (FILE *) NULL)
- /*---- return if this is an extra open or
- a bad catalog discriptor ----*/
- return (-1);
- if (cat_already_open(catd->_name)) {
- if (catd->_count == 1) {
- cat_hard_close(catd);
- return (0); /*--- the last legal clsoe ---*/
- } else if (catd->_count > 1) {
- catd->_count = catd->_count - 1;
- return (0); /*--- a legal close ---*/
- } else
- return (-1); /*--- an extra illegal close ---*/
- } else {
- return (-1);
- }
-}
-
-static void
-cat_hard_close(nl_catd catd)
- /*---- the catd to be closed ----*/
-{
- int i; /*---- Misc counter(s) used for loops ----*/
- int j; /*---- Misc counter ----*/
-
- if (catd == CATD_ERR)
- return;
-
-/*______________________________________________________________________
- remove any entry for the catalog in the catsopen array
- ______________________________________________________________________*/
-
- for (i = 0; i < NL_MAXOPEN && catsopen[i]; i++) {
- if (catd == catsopen[i]) {
- for (; i < NL_MAXOPEN - 1; i++) {
- catsopen[i] = catsopen[i + 1];
- catpid[i] = catpid[i + 1];
- }
- catsopen[i] = NULL;
- catpid[i] = 0;
- }
- }
-
-/*______________________________________________________________________
- close the cat and free up the memory
- ______________________________________________________________________*/
- if (catd->_mem == FALSE) {
- for (i = 0; i <= catd->_n_sets; i++) {
- if (catd->_set[i]._mp)
- free(catd->_set[i]._mp);
- /*---- free the _message pointer arrays ----*/
-
- if (catd->_set[i]._msgtxt) {
- for (j = 0; j <= catd->_set[i]._n_msgs; j++) {
- if (catd->_set[i]._msgtxt[j]) {
-/* free(catd->_set[i]._msgtxt[j]);*/
- }
- }
- if (catd->_set[i]._msgtxt)
- free(catd->_set[i]._msgtxt);
- }
- }
- }
-
- if (catd->_fd)
- fclose(catd->_fd); /*---- close the ctatlog ----*/
- if (catd->_set)
- free(catd->_set); /*---- free the sets ----*/
- if (catd->_name)
- free(catd->_name); /*---- free the name ----*/
- if (catd->_hd)
- free(catd->_hd); /*---- free the header ----*/
- if (catd)
- free(catd); /*---- free the catd ----*/
-}
-
-static char *
-_do1_read_msg(nl_catd catd, int setno, int msgno)
- /*---- catd: the catd of the catalog to be read from ----*/
- /*---- setno: the set number of the message ----*/
- /*---- msgno: the msgno of the message ----*/
-{
- nl_catd catd1; /*--- catd for different process ----*/
- char *_read1_msg();
-
-#ifndef AFS_OSF20_ENV
- if (getpid() == catd->_pid)
-#else
- if (1)
-#endif
- return (_read1_msg(catd, setno, msgno));
- else {
- /*
- * Since our pid is different from the one in
- * catd, catd must have come from a catopen()
- * in our parent. We need a catd of our own.
- * The first time through here, the call to
- * catopen() creates a new catd and we try to
- * open its message catalog. After that, the
- * catopen() just retrieves the catd.
- */
- if (((catd1 = catopen1(catd->_name, 0)) != CATD_ERR)
- && ((catd1->_fd == NL_FILE_CLOSED && _do1_open(catd1) != CATD_ERR)
- || (catd1->_fd != NL_FILE_UNUSED)))
- return (_read1_msg(catd1, setno, msgno));
- else
- return (NULL);
- }
-}
-
-
-struct _catset *_cat1_get_catset();
-static struct _msgptr *_cat1_get_msgptr();
-static char *
-_read1_msg(nl_catd catd, int setno, int msgno)
-{
- struct _catset *set; /*--- ptr to set's _catset structure ---*/
- struct _msgptr *msg; /*--- ptr to msg's _msgptr structure ---*/
- char **msgtxt; /*--- temporary pointer to the message text
- for speed. ----*/
-
- set = _cat1_get_catset(catd, setno);
- if (set) {
- msg = _cat1_get_msgptr(set, msgno);
- if (msg) {
- msgtxt = &set->_msgtxt[msg - set->_mp];
- if (1 /*!*msgtxt */ ) {
- *msgtxt = (char *)malloc(msg->_msglen + 1);
- if (!*msgtxt)
- return (NULL);
-
- fseek(catd->_fd, (long)msg->_offset, 0);
- if (fread
- ((void *)*msgtxt, (size_t) (msg->_msglen + 1), (size_t) 1,
- catd->_fd) != 1)
- return (NULL);
- }
-
- return (*msgtxt);
- }
- }
- return (NULL);
-}
-
-/*
- * NAME: compare_sets
- *
- * FUNCTION: Compare function used by bsearch() in _cat_get_catset().
- *
- * ARGUMENTS:
- * key - pointer to set number we're searching for
- * element - pointer to current _catset structure
- *
- * RETURNS: Returns -1, 0, or 1, depending on whether the set number
- * is less than, equal to, or greater than the set number of
- * the _catset structure.
- *
- */
-
-static int
-compare_sets(const void *key, const void *element)
-{
- int *setno = (int *)key;
- struct _catset *set = (struct _catset *)element;
-
- if (*setno < set->_setno)
- return -1;
- if (*setno > set->_setno)
- return 1;
-
- return 0;
-}
-
-
-/*
- * NAME: _cat_get_catset
- *
- * FUNCTION: Find a set in the catd->_set array. Assumes that the
- * sets in the array are sorted by increasing set number.
- *
- * ARGUMENTS:
- * catd - catalog descripter obtained from catopen()
- * setno - message catalogue set number
- *
- * RETURNS: Returns a pointer to the set on success.
- * On any error, returns NULL.
- *
- */
-
-struct _catset *
-_cat1_get_catset(nl_catd catd, int setno)
-{
- struct _catset *set;
-
- if ((catd == (nl_catd) NULL) || (catd == CATD_ERR))
- return (struct _catset *)NULL;
-
- if (catd->_sets_expanded) {
- if ((setno < 0) || (setno > catd->_n_sets))
- return (struct _catset *)NULL;
-
- set = &catd->_set[setno];
-
- /*
- * Catch empty elements in the array. They aren't
- * real sets.
- */
-
- if (set->_mp == (struct _msgptr *)NULL)
- return (struct _catset *)NULL;
- } else {
- set =
- (struct _catset *)bsearch((void *)&setno, catd->_set,
- catd->_n_sets + 1,
- sizeof(struct _catset), compare_sets);
-
- /*
- * Since the sets are compacted, there aren't any
- * empty elements in the array to check for.
- */
- }
-
- return set;
-}
-
-
-/*
- * NAME: compare_msgs
- *
- * FUNCTION: Compare function used by bsearch() in _cat_get_msgptr().
- *
- * ARGUMENTS:
- * key - pointer to message number we're searching for
- * element - pointer to current _msgptr structure
- *
- * RETURNS: Returns -1, 0, or 1, depending on whether the message
- * number is less than, equal to, or greater than the message
- * number of the _msgptr structure.
- *
- */
-
-static int
-compare_msgs(const void *key, const void *element)
-{
- int *msgno = (int *)key;
- struct _msgptr *msg = (struct _msgptr *)element;
-
- if (*msgno < msg->_msgno)
- return -1;
- if (*msgno > msg->_msgno)
- return 1;
-
- return 0;
-}
-
-/*
- * NAME: _cat1_get_msgptr
- *
- * FUNCTION: Find a message in a set's set->_mp array. Assumes that
- * the messages in the array are sorted by increasing
- * message number.
- *
- * ARGUMENTS:
- * set - ptr to _catset structure
- * msgno - message catalogue message number
- *
- * RETURNS: Returns a pointer to the message on success.
- * On any error, returns NULL.
- *
- */
-static struct _msgptr *
-_cat1_get_msgptr(struct _catset *set, int msgno)
-{
- struct _msgptr *msg;
-
- if (set == (struct _catset *)NULL)
- return (struct _msgptr *)NULL;
-
- if (set->_mp == (struct _msgptr *)NULL) /* empty set */
- return (struct _msgptr *)NULL;
-
- if (set->_msgs_expanded) {
- if ((msgno < 0) || (msgno > set->_n_msgs))
- return (struct _msgptr *)NULL;
-
- msg = &set->_mp[msgno];
-
- /*
- * Catch empty elements in the array. They aren't
- * real messages.
- */
-
- if (!msg->_offset)
- return (struct _msgptr *)NULL;
- } else {
- msg =
- (struct _msgptr *)bsearch((void *)&msgno, set->_mp,
- set->_n_msgs + 1,
- sizeof(struct _msgptr), compare_msgs);
-
- /*
- * Since the messages are compacted, there aren't any
- * empty elements in the array to check for.
- */
- }
-
- return msg;
-}
-
-char *
-catgets1(nl_catd catd, int setno, int msgno, char *def)
- /*---- catd: the catd to get the message from ----*/
- /*---- setno: the set number of the message ----*/
- /*---- msgno: the message number of the message ----*/
- /*---- def: the default string to be returned ----*/
-{
- int errno_save;
- char *_do_read_msg();
- char *m;
- errno_save = errno;
-
- if (catd == NULL || catd == CATD_ERR || catd->_magic != CAT_MAGIC
- || catd->_fd == NL_FILE_UNUSED) {
- return (def);
- }
- if (catd->_fd == NL_FILE_CLOSED) {
- catd = _do1_open(catd);
- if (catd == CATD_ERR)
- return (def);
- }
-
- if (catd->_mem) { /*---- for mapped files ----*/
- if (setno <= catd->_hd->_setmax) {
- if (msgno < catd->_set[setno]._n_msgs) {
- if (catd->_set[setno]._mp[msgno]._offset) {
- return (catd->_mem +
- catd->_set[setno]._mp[msgno]._offset);
- }
- }
- }
- return (def);
- } else { /*---- for unmapped files ----*/
- m = _do1_read_msg(catd, setno, msgno);
- if (m == NULL)
- return (def);
- else
- return (m);
- }
-}
-
-#endif
-
#define FACILITY_CODE_MASK 0xF0000000
#define FACILITY_CODE_SHIFT 28
/*
* Open the message file
*/
-#if defined(AFS_OSF_ENV)
-#if defined(AFS_OSF20_ENV)
+#if defined(AFS_OSF20_ENV)
catd = (nl_catd) catopen(nls_filename, 0);
#else
- catd = (nl_catd) catopen1(nls_filename, 0);
-#endif
-#else
#if defined(AFS_64BITPOINTER_ENV)
J = (long)catopen(nls_filename, 0);
#else
sprintf(alt_filename, RPC_DEFAULT_NLSPATH, filename_prefix);
#endif
-#if defined(AFS_OSF_ENV)
-#if defined(AFS_OSF20_ENV)
+#if defined(AFS_OSF20_ENV)
catd = (nl_catd) catopen(alt_filename, 0);
#else
- catd = (nl_catd) catopen1(alt_filename, 0);
-#endif
-#else
#if defined(AFS_64BITPOINTER_ENV)
J = (long)catopen(alt_filename, 0);
#else
/*
* try to get the specified message from the file
*/
-#if defined(AFS_OSF_ENV) && !defined(AFS_OSF20_ENV)
- message = (char *)catgets1(catd, 1, status_code, NO_MESSAGE);
-#else
message = (char *)catgets(catd, 1, status_code, NO_MESSAGE);
-#endif
/*
* if everything went well, return the resulting message
*/
} else {
if (!failed) {
failed = 1;
-#if defined(AFS_OSF_ENV) && !defined(AFS_OSF20_ENV)
- catclose1(catd);
-#else
catclose(catd);
-#endif
goto tryagain;
}
sprintf((char *)error_text, "status %08x (%s / %s)",
status_to_convert, facility_name, component_name);
}
-#if defined(AFS_OSF_ENV) && !defined(AFS_OSF20_ENV)
- catclose1(catd);
-#else
catclose(catd);
-#endif
-
}
int
git://git.openafs.org / openafs.git / blobdiff