#include "system.H"

#include "internal.H"

extern char *strdup(const char *);

#if HOST_SYS_FAMILY == SYS_UNIX

#define _BSD_SOURCE 1

#include <unistd.h> /* For getcwd(), readlink() */

ssize_t readlink(const char *pathname, char *buf, size_t bufsiz);

#elif HOST_COMPILER == MSC || HOST_COMPILER == LCC

#include "direct.h"

#define getcwd( buf, size) _getcwd( buf, size)

#elif HOST_COMPILER == BORLANDC

#include "dir.h"

#include "sys/types.h"

#include "sys/stat.h" /* For stat() */

#if ! defined( S_ISREG)

#define S_ISREG( mode) (mode & S_IFREG)

#define S_ISDIR( mode) (mode & S_IFDIR)

#if HOST_COMPILER == MSC

#define S_IFREG _S_IFREG

#define S_IFDIR _S_IFDIR

#define stat( path, stbuf) _stat( path, stbuf)

#if FNAME_FOLD

#if HOST_COMPILER == GNUC /* CYGWIN, MINGW, MAC */

#include <strings.h> /* POSIX 1, 2001 */

#define str_case_eq( str1, str2) (strcasecmp( str1, str2) == 0)

#else /* MSC, BORLANDC, LCC */

#if HOST_COMPILER == MSC

#define stricmp( str1, str2) _stricmp( str1, str2)

#define str_case_eq( str1, str2) (stricmp( str1, str2) == 0)

#else /* ! FNAME_FOLD */

#define str_case_eq( str1, str2) (strcmp( str1, str2) == 0)

#if SYS_FAMILY == SYS_UNIX || SYS_FAMILY == SYS_WIN || SYSTEM == SYS_UNKNOWN

#define PATH_DELIM '/'

#define SPECIAL_PATH_DELIM FALSE

#else /* Any other path-delimiter, define PATH_DELIM by yourself */

#define SPECIAL_PATH_DELIM TRUE /* Any path-delimiter other than '/' */

#ifndef OBJEXT

#if SYS_FAMILY == SYS_UNIX || HOST_COMPILER == GNUC

#define OBJEXT "o"

#elif SYS_FAMILY == SYS_WIN

#define OBJEXT "obj"

#elif 1

static void version( void);

/* Print version message */

static void usage( int opt);

/* Putout usage of MCPP */

static void set_opt_list( char * optlist);

/* Set list of legal option chars */

static void def_a_macro( int opt, char * def);

/* Do a -D option */

static void chk_opts( int sflag, int trad);

/* Check consistency of options */

static void init_predefines( void);

/* Set and unset predefined macros */

static void init_std_defines( void);

/* Predefine Standard macros */

static void set_limit( void);

/* Set minimum translation limits */

static void put_info( FILEINFO * sharp_file);

/* Print compiler-specific-inf */

static char * set_files( int argc, char ** argv, char ** in_pp

, char ** out_pp);

/* Set input, output, diagnostic */

static void set_sys_dirs( int set_cplus_dir);

/* Set system-specific include dirs */

static void set_env_dirs( void);

/* Set user-defined include dirs */

static void parse_env( const char * env);

/* Parse environment variables */

static void set_a_dir( const char * dirname);

/* Append an include directory */

static char * norm_dir( const char * dirname, int framework);

/* Normalize include directory path */

static char * norm_path( const char * dir, const char * fname, int inf

, int hmap); /* Normalize pathname to compare */

#if SYS_FAMILY == SYS_UNIX

static void deref_syml( char * slbuf1, char * slbuf2, char * chk_start);

/* Dereference symbolic linked directory and file */

static void def_macros( void);

/* Define macros specified by -D */

static void undef_macros( void);

/* Undefine macros specified by -U */

static char * md_init( const char * filename, char * output);

/* Initialize makefile dependency */

static char * md_quote( char * output);

/* 'Quote' special characters */

static int open_include( char * filename, int searchlocal, int next);

/* Open the file to include */

static int has_directory( const char * source, char * directory);

/* Get directory part of fname */

static int is_full_path( const char * path);

/* The path is absolute path list ? */

static int search_dir( char * filename, int searchlocal, int next);

/* Search the include directories */

static int open_file( const char ** dirp, const char * src_dir

, const char * filename, int local, int include_opt, int sys_frame);

/* Open a source file */

static const char * set_fname( const char * filename);

/* Remember the source filename */

#if 0 /* This function is only for debugging use */

static int chk_dirp( const char ** dirp);

/* Check validity of dirp arg for open_file() */

static void cur_file( FILEINFO * file, FILEINFO * sharp_file, int marker);

/* Output current source file name */

#if SYS_FAMILY == SYS_WIN

static char * bsl2sl( char * filename);

/* Convert \ to / in path-list */

static int is_junk( void);

/* The directive has trailing junk? */

static void do_once( const char * fullname);

/* Process #pragma once */

static int included( const char * fullname);

/* The file has been once included? */

static void push_or_pop( int direction);

/* Push or pop a macro definition */

static void do_preprocessed( void);

/* Process preprocessed file */

static int do_debug( int set);

/* #pragma MCPP debug, #debug */

static void dump_path( void);

/* Print include search path */

static int mcpp_getopt( int argc, char * const * argv, const char * opts);

/* getopt() to prevent linking of glibc getopt */

static int mcpp_optind = 1;

static int mcpp_opterr = 1;

static int mcpp_optopt;

static char * mcpp_optarg;

static int mb_changed = FALSE; /* Flag of -e option */

static char cur_work_dir[ PATHMAX + 1]; /* Current working directory*/

static const char ** incdir; /* Include directories */

static const char ** incend; /* -> active end of incdir */

static int max_inc; /* Number of incdir[] */

typedef struct inc_list { /* List of directories or files */

char *name; /* Filename or directory-name */

size_t len; /* Length of 'name' */

} INC_LIST;

static INC_LIST * fnamelist; /* Source file names */

static INC_LIST * fname_end; /* -> active end of fnamelist */

static int max_fnamelist; /* Number of fnamelist[] */

static INC_LIST * once_list; /* Once opened file */

static INC_LIST * once_end; /* -> active end of once_list */

static int max_once; /* Number of once_list[] */

#define INIT_NUM_INCLUDE 32 /* Initial number of incdir[] */

#define INIT_NUM_FNAMELIST 256 /* Initial number of fnamelist[] */

#define INIT_NUM_ONCE 64 /* Initial number of once_list[] */

static int search_rule = SEARCH_INIT; /* Rule to search include file */

static int nflag = FALSE; /* Flag of -N (-undef) option */

static long std_val = -1L; /* Value of __STDC_VERSION__ or __cplusplus */

#define MAX_DEF 256

#define MAX_UNDEF (MAX_DEF/4)

static char * def_list[ MAX_DEF]; /* Macros to be defined */

static char * undef_list[ MAX_UNDEF]; /* Macros to be undefined */

static int def_cnt; /* Count of def_list */

static int undef_cnt; /* Count of undef_list */

#define MD_MKDEP 1 /* Output source file dependency line */

#define MD_SYSHEADER 2 /* Print also system-header names */

#define MD_FILE 4 /* Output to the file named *.d */

#define MD_PHONY 8 /* Print also phony targets for each header */

#define MD_QUOTE 16 /* 'Quote' $ and space in target name */

static FILE * mkdep_fp; /* For -Mx option */

static char * mkdep_target;

/* For -MT TARGET option and for GCC's queer environment variables. */

static char * mkdep_mf; /* Argument of -MF option */

static char * mkdep_md; /* Argument of -MD option */

static char * mkdep_mq; /* Argument of -MQ option */

static char * mkdep_mt; /* Argument of -MT option */

static char * sharp_filename = NULL;

static char * argv0; /* argv[ 0] for usage() and version() */

static int compat_mode;

/* "Compatible" mode of recursive macro expansion */

#if SYSTEM == SYS_CYGWIN

static int no_cygwin = FALSE; /* -mno-cygwin */

#define NO_DIR FALSE

#if NO_DIR

static int no_dir;

void init_system( void)

{

if (sharp_filename)

free( sharp_filename);

sharp_filename = NULL;

incend = incdir = NULL;

fnamelist = once_list = NULL;

search_rule = SEARCH_INIT;

mb_changed = nflag = FALSE;

compat_mode = TRUE; /* for flexc */

mkdep_fp = NULL;

mkdep_target = mkdep_mf = mkdep_md = mkdep_mq = mkdep_mt = NULL;

std_val = -1L;

def_cnt = undef_cnt = 0;

mcpp_optind = mcpp_opterr = 1;

#if SYSTEM == SYS_CYGWIN

no_cygwin = FALSE;

#if NO_DIR

no_dir = FALSE;

}

#define OPTLISTLEN 80

void do_options(

)

{

char optlist[ OPTLISTLEN]; /* List of option letter*/

int opt;

int unset_sys_dirs;

/* Unset system-specific and site-specific include directories ? */

int set_cplus_dir; /* Set C++ include directory ? (for GCC)*/

int show_path; /* Show include directory list */

int sflag; /* -S option or similar */

int trad; /* -traditional */

int i;

argv0 = argv[ 0];

nflag = unset_sys_dirs = show_path = sflag = trad = FALSE;

set_cplus_dir = TRUE;

/* Get current directory for -I option and #pragma once */

(void)getcwd( cur_work_dir, PATHMAX);

#if SYS_FAMILY == SYS_WIN

bsl2sl( cur_work_dir);

sprintf( cur_work_dir + strlen( cur_work_dir), "%c%c", PATH_DELIM, EOS);

/* Append trailing path-delimiter */

set_opt_list( optlist);

opt_search: ;

while (mcpp_optind < argc

&& (opt = mcpp_getopt( argc, argv, optlist)) != EOF) {

switch (opt) { /* Command line option character */

case 'C': /* Keep comments */

option_flags.c = TRUE;

break;

case 'D': /* Define symbol */

if (def_cnt >= MAX_DEF) {

mcpp_fputs( "Too many -D options.\n", ERR);

longjmp( error_exit, -1);

}

def_list[ def_cnt++] = mcpp_optarg;

break;

case 'e':

// We support this option, but it does nothing.

break;

case 'I': /* Include directory */

if (str_eq( mcpp_optarg, "-")) { /* -I- */

unset_sys_dirs = TRUE;

/* Unset pre-specified include directories */

} else if (*(mcpp_optarg + 1) == EOS && isdigit( *mcpp_optarg)

&& (i = *mcpp_optarg - '0') != 0

&& (i & ~(CURRENT | SOURCE)) == 0) {

search_rule = i; /* -I1, -I2 or -I3 */

} else { /* Not '-' nor a digit */

set_a_dir( mcpp_optarg); /* User-defined dir */

}

break;

case 'M': /* Output source file dependency line */

if (argv[ mcpp_optind - 1] == mcpp_optarg) { /* -M */

mkdep |= MD_SYSHEADER;

mcpp_optind--;

} else {

usage( opt);

}

mkdep |= MD_MKDEP;

break;

case 'U': /* Undefine macro */

if (undef_cnt >= MAX_UNDEF) {

mcpp_fputs( "Too many -U options.\n", ERR);

longjmp( error_exit, -1);

}

undef_list[ undef_cnt++] = mcpp_optarg;

break;

default: /* What is this one? */

usage( opt);

break;

} /* Switch on all options */

} /* For all arguments */

if (mcpp_optind < argc && set_files( argc, argv, in_pp, out_pp) != NULL)

goto opt_search; /* More options after the filename */

/* Check consistency of specified options, set some variables */

chk_opts( sflag, trad);

if (warn_level == -1) /* No -W option */

warn_level = 1; /* Default warning level */

else if (warn_level == 0xFF)

warn_level = 0; /* -W0 has high precedence */

set_env_dirs();

if (! unset_sys_dirs)

set_sys_dirs( set_cplus_dir);

if (mkdep_mf) { /* -MF overrides -MD */

mkdep_fp = mcpp_fopen( mkdep_mf, "w");

} else if (mkdep_md) {

mkdep_fp = mcpp_fopen( mkdep_md, "w");

}

if (mkdep_mq) /* -MQ overrides -MT */

mkdep_target = mkdep_mq;

else if (mkdep_mt)

mkdep_target = mkdep_mt;

/* Normalize the path-list */

if (*in_pp && ! str_eq( *in_pp, "-")) {

char * tmp = norm_path( null, *in_pp, FALSE, FALSE);

if (tmp) /* The file exists */

*in_pp = tmp;

/* Else mcpp_main() will diagnose *in_pp and exit */

}

if (! (mcpp_debug & MACRO_CALL)) {

if (show_path) {

fp_debug = stderr;

dump_path();

fp_debug = stdout;

}

}

}

static void version( void)

{

const char * mes[] = {

"MCPP V.2.7.2 (2008/11)"

, "https://github.com/zeroc-ice/mcpp"

, "compiler-independent-build "

, NULL

};

const char ** mpp = mes;

while (*mpp)

mcpp_fputs( *mpp++, ERR);

}

static void usage(

int opt

)

{

const char * mes[] = {

"Usage: ",

"mcpp",

" [-<opts> [-<opts>]] [<infile> [-<opts>] [<outfile>] [-<opts>]]\n",

" <infile> defaults to stdin and <outfile> defaults to stdout.\n",

"\nCommonly used options:\n",

"-C Output also comments.\n",

"-D <macro>[=<value>] Define <macro> as <value> (default:1).\n",

"-D <macro(args)>[=<replace>] Define <macro(args)> as <replace>.\n",

"-e <encoding> Change the default multi-byte character encoding to one of:\n",

" euc_jp, gb2312, ksc5601, big5, sjis, iso2022_jp, utf8.\n",

"-I <directory> Add <directory> to the #include search list.\n",

"-I- Unset system or site specific include directories.\n",

"-M file\n",

" Output source file dependency line for makefile.\n",

"-U <macro> Undefine <macro>.\n",

"\nFor further details see mcpp-manual.html.\n",

NULL,

};

const char * illegopt = "Incorrect option -%c%s\n";

const char * const * mpp = mes;

if (opt != '?')

mcpp_fprintf( ERR, illegopt, opt, mcpp_optarg ? mcpp_optarg : null);

version();

mes[ 1] = argv0;

while (*mpp)

mcpp_fputs( *mpp++, ERR);

longjmp( error_exit, -1);

}

static void set_opt_list(

char * optlist

)

{

const char * list[] = {

#if ! STD_LINE_PREFIX

"b",

#if SYS_FAMILY == SYS_UNIX

"m:",

"a",

NULL

};

const char * const * lp = & list[ 0];

strcpy( optlist, "e:CD:I:M:U:");

/* Default options */

while (*lp)

strcat( optlist, *lp++);

if (strlen( optlist) >= OPTLISTLEN)

cfatal( "Bug: Too long option list", NULL, 0L, NULL); /* _F_ */

}

static void def_a_macro(

int opt, /* 'D' */

char * def /* Argument of -D option */

)

{

DEFBUF * defp;

char * definition; /* Argument of -D option */

char * cp;

int i;

definition = xmalloc( strlen( def) + 4);

strcpy( definition, def);

if ((cp = strchr( definition, '=')) != NULL) {

*cp = ' '; /* Remove the '=' */

cp = "\n"; /* Append <newline> */

} else {

cp = " 1\n"; /* With definition "1" */

}

strcat( definition, cp);

cp = definition;

while ((char_type[ *cp & UCHARMAX] & SPA) == 0)

cp++;

i = *cp;

*cp = EOS;

if ((defp = look_id( definition)) != NULL) /* Pre-defined */

undefine( definition);

*cp = i;

/* Now, save the definition. */

unget_string( definition, NULL);

if (do_define( FALSE, 0) == NULL) /* Define a macro */

usage( opt);

*cp = EOS;

if (str_eq( definition, "__STDC__")) {

defp = look_id( definition);

defp->nargs = DEF_NOARGS_STANDARD;

/* Restore Standard-predefinedness */

}

free( definition);

skip_nl(); /* Clear the appended <newline> */

}

static void chk_opts(

int sflag, /* Flag of Standard or post-Standard mode */

int trad /* -traditional (GCC only) */

)

{

extern int mcpp_mode;

int incompat = FALSE;

if (trad)

incompat = TRUE;

if (! stdc_val)

stdc_val = STDC;

if (compat_mode && mcpp_mode == POST_STD)

incompat = TRUE;

if ((mcpp_debug & MACRO_CALL)

&& option_flags.c) {

mcpp_fputs( "Disabled -K option.\n", ERR);

mcpp_debug &= ~MACRO_CALL;

/* -a and -C options do not co-exist with -K */

}

if (incompat) {

mcpp_fputs( "Incompatible options are specified.\n", ERR);

usage( '?');

}

expand_init( compat_mode);

/* Set function pointer to macro expansion routine */

}

static void init_predefines( void)

{

char tmp[ 16];

stdc_ver = stdc_val ? STDC_VERSION : 0L;

if (nflag) {

un_predefine( TRUE);

} else if (stdc_val) {

un_predefine( FALSE); /* Undefine "unix" or so */

}

sprintf( tmp, "%ldL", stdc_ver);

if (stdc_ver)

look_and_install( "__STDC_VERSION__", DEF_NOARGS_STANDARD, null

, tmp);

#ifdef COMPILER_CPLUS

if (! nflag) /* Undefine pre-defined macro for C++ */

undefine( COMPILER_CPLUS);

set_limit();

init_std_defines();

}

static void init_std_defines( void)

{

char tmp[ 16];

char timestr[ 14];

time_t tvec;

char * tstring;

look_and_install( "__LINE__", DEF_NOARGS_DYNAMIC - 1, null, "-1234567890");

/* Room for 11 chars (10 for long and 1 for '-' in case of wrap round. */

look_and_install( "__FILE__", DEF_NOARGS_DYNAMIC - 2, null, null);

/* Should be stuffed */

/* Define __DATE__, __TIME__ as present date and time. */

time( &tvec);

tstring = ctime( &tvec);

sprintf( timestr, "\"%.3s %c%c %.4s\"",

tstring + 4,

*(tstring + 8) == '0' ? ' ' : *(tstring + 8),

*(tstring + 9),

tstring + 20);

look_and_install( "__DATE__", DEF_NOARGS_DYNAMIC, null, timestr);

sprintf( timestr, "\"%.8s\"", tstring + 11);

look_and_install( "__TIME__", DEF_NOARGS_DYNAMIC, null, timestr);

if (! look_id( "__STDC_HOSTED__")) {

/*

sprintf( tmp, "%d", STDC_HOSTED);

look_and_install( "__STDC_HOSTED__", DEF_NOARGS_PREDEF, null, tmp);

}

/* Define __STDC__ as 1 or such for Standard conforming compiler. */

if (! look_id( "__STDC__")) {

sprintf( tmp, "%d", stdc_val);

look_and_install( "__STDC__", DEF_NOARGS_STANDARD, null, tmp);

}

}

#define LINE90LIMIT 32767

#define LINE_CPLUS_LIMIT 32767

static void set_limit( void)

{

/* Specified by C 1990 Standard */

std_limits.str_len = SLEN90MIN;

std_limits.id_len = IDLEN90MIN;

std_limits.n_mac_pars = NMACPARS90MIN;

std_limits.exp_nest = EXP_NEST90MIN;

std_limits.blk_nest = BLK_NEST90MIN;

std_limits.inc_nest = INCLUDE_NEST90MIN;

std_limits.n_macro = NMACRO90MIN;

std_limits.line_num = LINE90LIMIT;

}

void init_sys_macro( void)

{

/* This order is important. */

def_macros(); /* Define macros specified by -D */

init_predefines(); /* Define predefined macros */

undef_macros(); /* Undefine macros specified by -U */

if (mcpp_debug & MACRO_CALL)

dump_def( FALSE, TRUE); /* Finally putout current macro names */

}

void at_start( void)

{

FILEINFO * file_saved = infile;

// We don't support changing the encodings.

put_info( file_saved);

}

static void put_info(

FILEINFO * sharp_file

)

{

if (no_output)

return;

sharp_file->line++;

sharp( sharp_file, 0);

sharp_file->line--;

}

static char * set_files(

)

{

char * cp;

if (*in_pp == NULL) { /* Input file */

cp = argv[ mcpp_optind++];

#if SYS_FAMILY == SYS_WIN

cp = bsl2sl( cp);

*in_pp = cp;

}

if (mcpp_optind < argc && argv[ mcpp_optind][ 0] != '-'

&& *out_pp == NULL) {

cp = argv[ mcpp_optind++];

#if SYS_FAMILY == SYS_WIN

cp = bsl2sl( cp);

*out_pp = cp; /* Output file */

}

if (mcpp_optind >= argc)

return NULL; /* Exhausted command line arguments */

if (argv[ mcpp_optind][ 0] == '-')

return argv[ mcpp_optind]; /* More options */

cfatal( "Excessive file argument \"%s\"", argv[ mcpp_optind], 0L , NULL);

return NULL;

}

static void set_env_dirs( void)

{

const char * env;

if ((env = getenv( ENV_C_INCLUDE_DIR)) != NULL)

parse_env( env);

}

static void parse_env(

const char * env

)

{

char * save;

char * save_start;

char * p;

int sep;

save = save_start = save_string( env);

while (*save) {

p = save;

while (*p && *p != ENV_SEP)

p++;

if (p != save) { /* Variable separator */

sep = *p;

*p = EOS;

set_a_dir( save);

if (sep == EOS)

break;

save = ++p;

}

while (*save == ENV_SEP)

++save;

}

free( save_start);

}

static void set_sys_dirs(

int set_cplus_dir /* Set C++ include-directory too */

)

{

#ifndef FLEXSPIN_BUILD

#if SYS_FAMILY == SYS_UNIX

set_a_dir( "/usr/local/include");

#ifdef C_INCLUDE_DIR1

set_a_dir( C_INCLUDE_DIR1);

#ifdef C_INCLUDE_DIR2

set_a_dir( C_INCLUDE_DIR2);

#if SYS_FAMILY == SYS_UNIX

#if SYSTEM == SYS_CYGWIN

if (no_cygwin) /* -mno-cygwin */

set_a_dir( "/usr/include/mingw");

else

set_a_dir( "/usr/include");

set_a_dir( "/usr/include"); /* Should be placed after C_INCLUDE_DIR? */

}

static void set_a_dir(

const char * dirname /* The path-name */

)

{

char * norm_name;

const char ** ip;

if (incdir == NULL) { /* Should be initialized */

max_inc = INIT_NUM_INCLUDE;

incdir = (const char **) xmalloc( sizeof (char *) * max_inc);

incend = &incdir[ 0];

} else if (incend - incdir >= max_inc) { /* Buffer full */

incdir = (const char **) xrealloc( (char *) incdir

, sizeof (char *) * max_inc * 2);

incend = &incdir[ max_inc];

max_inc *= 2;

}

if (dirname == NULL)

return; /* Only to initialize incdir[] */

norm_name = norm_dir( dirname, FALSE);

if (! norm_name) /* Non-existent */

return;

for (ip = incdir; ip < incend; ip++) {

if (str_case_eq( *ip, norm_name)) {

free( norm_name); /* Already registered */

return;

}

}

/* Register new directory */

*incend++ = norm_name;

}

char *NormalizePath(const char *path)

{

char curpath[PATHMAX];

if (is_full_path(path)) {

return strdup(path);

}

(void)getcwd(curpath, PATHMAX);

return norm_path(curpath, path, FALSE, FALSE);

}

static char * norm_dir(

const char * dirname, /* Directory path to normalize */

int framework /* Setting a framework directory*/

)

{

char * norm_name;

{

norm_name = norm_path( dirname, NULL, FALSE, FALSE);

/* Normalize the pathname to compare */

}

return norm_name;

}

static char * norm_path(

)

{

char * norm_name; /* The path-list converted */

char * start;

char * cp1;

char * cp2;

char * abs_path;

int len; /* Should not be size_t */

size_t start_pos = 0;

char slbuf1[ PATHMAX+1]; /* Working buffer */

#if SYS_FAMILY == SYS_UNIX

char slbuf2[ PATHMAX+1]; /* Working buffer for dereferencing */

#if SYSTEM == SYS_CYGWIN || SYSTEM == SYS_MINGW

static char * root_dir;

/* System's root directory in Windows file system */

static size_t root_dir_len;

#if SYSTEM == SYS_CYGWIN

static char * cygdrive = "/cygdrive/"; /* Prefix for drive letter */

static char * mingw_dir; /* "/mingw" dir in Windows */

static size_t mingw_dir_len;

#if HOST_COMPILER == MSC

struct _stat st_buf;

struct stat st_buf;

if (! dir || (*dir && is_full_path( fname)))

cfatal( "Bug: Wrong argument to norm_path()" /* _F_ */

, NULL, 0L, NULL);

inf = inf && (mcpp_debug & PATH); /* Output information */

strcpy( slbuf1, dir); /* Include directory */

len = strlen( slbuf1);

if (fname && len && slbuf1[ len - 1] != PATH_DELIM) {

slbuf1[ len] = PATH_DELIM; /* Append PATH_DELIM */

slbuf1[ ++len] = EOS;

} else if (! fname && len && slbuf1[ len - 1] == PATH_DELIM) {

/* stat() of some systems do not like trailing '/' */

slbuf1[ --len] = EOS;