summaryrefslogtreecommitdiff
path: root/Build/source/texk/kpathsea/lib.h
blob: 721c3b185e28c428ca286e9f29852959117717e4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
/* lib.h: declarations for common, low-level routines in kpathsea.

   Copyright 1999, 2000, 2003, 2005 Olaf Weber.
   Copyright 1992, 1993, 1994, 1995, 1996, 2008 Karl Berry.

   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, see <http://www.gnu.org/licenses/>.  */

#ifndef KPATHSEA_LIB_H
#define KPATHSEA_LIB_H

#include <kpathsea/c-proto.h>
#include <kpathsea/systypes.h>
#include <kpathsea/types.h>

/* Define common sorts of messages.  */

/* This should be called only after a system call fails.  Don't exit
   with status `errno', because that might be 256, which would mean
   success (exit statuses are truncated to eight bits).  */

#if defined (KPSE_COMPAT_API)
/* This branch works as expected also in programs that use the new interface,
   because kpathsea_set_program_name() sets up the kpse_def->invocation_name
   whenever it is available.
*/
#define FATAL_PERROR(str) do { \
  fprintf (stderr, "%s: ", kpse_def->invocation_name); \
  perror (str); exit (EXIT_FAILURE); } while (0)
#else
/* If there is no global variable available, just output the error */
#define FATAL_PERROR(str) do { \
  perror (str); exit (EXIT_FAILURE); } while (0)
#endif

#if defined (KPSE_COMPAT_API)
#define START_FATAL() do { \
  fprintf (stderr, "%s: fatal: ", kpse_def->invocation_name);
#else
#define START_FATAL() do { \
  fprintf (stderr, "fatal: ");
#endif 

#define END_FATAL() fputs (".\n", stderr); exit (1); } while (0)

#define FATAL(str)							\
  START_FATAL (); fputs (str, stderr); END_FATAL ()
#define FATAL1(str, e1)							\
  START_FATAL (); fprintf (stderr, str, e1); END_FATAL ()
#define FATAL2(str, e1, e2)                             \
   START_FATAL (); fprintf (stderr, str, e1, e2); END_FATAL ()
#define FATAL3(str, e1, e2, e3)                             \
   START_FATAL (); fprintf (stderr, str, e1, e2, e3); END_FATAL ()
#define FATAL4(str, e1, e2, e3, e4)                             \
   START_FATAL (); fprintf (stderr, str, e1, e2, e3, e4); END_FATAL ()
#define FATAL5(str, e1, e2, e3, e4, e5)                             \
   START_FATAL (); fprintf (stderr, str, e1, e2, e3, e4, e5); END_FATAL ()
#define FATAL6(str, e1, e2, e3, e4, e5, e6)                       \
   START_FATAL (); fprintf (stderr, str, e1, e2, e3, e4, e5, e6); END_FATAL ()

#define START_WARNING() do { fputs ("warning: ", stderr)
#define END_WARNING() fputs (".\n", stderr); fflush (stderr); } while (0)

#define WARNING(str)							\
  START_WARNING (); fputs (str, stderr); END_WARNING ()
#define WARNING1(str, e1)						\
  START_WARNING (); fprintf (stderr, str, e1); END_WARNING ()
#define WARNING2(str, e1, e2)						\
  START_WARNING (); fprintf (stderr, str, e1, e2); END_WARNING ()
#define WARNING3(str, e1, e2, e3)					\
  START_WARNING (); fprintf (stderr, str, e1, e2, e3); END_WARNING ()
#define WARNING4(str, e1, e2, e3, e4)					\
  START_WARNING (); fprintf (stderr, str, e1, e2, e3, e4); END_WARNING ()

#define LIB_START_FATAL() do { \
  fprintf (stderr, "%s: fatal: ", kpse->invocation_name);

#define LIB_FATAL(str)							\
  LIB_START_FATAL (); fputs (str, stderr); END_FATAL ()
#define LIB_FATAL1(str, e1)							\
  LIB_START_FATAL (); fprintf (stderr, str, e1); END_FATAL ()
#define LIB_FATAL2(str, e1, e2)						\
  LIB_START_FATAL (); fprintf (stderr, str, e1, e2); END_FATAL ()


/* I find this easier to read.  */
#define STREQ(s1, s2) ((s1) && (s2) && (strcmp (s1, s2) == 0))
#define STRNEQ(s1, s2, n) ((s1) && (s2) && (strncmp (s1, s2, n) == 0))
      
/* Support for FAT/ISO-9660 filesystems.  Theoretically this should be
   done at runtime, per filesystem, but that's painful to program.  */
#ifdef MONOCASE_FILENAMES
#define FILESTRCASEEQ(s1, s2) ((s1) && (s2) && (strcasecmp (s1, s2) == 0))
#define FILESTRNCASEEQ(s1, s2, l) ((s1) && (s2) && (strncasecmp (s1, s2, l) == 0))
#define FILECHARCASEEQ(c1, c2) (toupper (c1) == toupper (c2))
#else
#define FILESTRCASEEQ STREQ
#define FILESTRNCASEEQ STRNEQ
#define FILECHARCASEEQ(c1, c2) ((c1) == (c2))
#endif

/* This is the maximum number of numerals that result when a 64-bit
   integer is converted to a string, plus one for a trailing null byte,
   plus one for a sign.  */
#define MAX_INT_LENGTH 21

/* If the environment variable TEST is set, return it; otherwise,
   DEFAULT.  This is useful for paths that use more than one envvar.  */
#define ENVVAR(test, default) (getenv (test) ? (test) : (default))

/* Return a fresh copy of S1 followed by S2, et al.  */
extern KPSEDLL string concat (const_string s1, const_string s2);
extern KPSEDLL string concat3 (const_string, const_string, const_string);
/* `concatn' is declared in its own include file, to avoid pulling in
   all the varargs stuff.  */

/* A fresh copy of just S.  */
extern KPSEDLL string xstrdup (const_string s);

/* Convert all lowercase characters in S to uppercase.  */
extern KPSEDLL string uppercasify (const_string s);

/* Like `atoi', but disallow negative numbers.  */
extern KPSEDLL unsigned atou (const_string);

/* True if FILENAME1 and FILENAME2 are the same file.  If stat fails on
   either name, return false, no error message.
   Cf. `SAME_FILE_P' in xstat.h.  */
extern KPSEDLL boolean same_file_p (const_string filename1,
                                         const_string filename2);

/* Return NAME with any leading path stripped off.  This returns a
   pointer into NAME.  */
extern KPSEDLL const_string xbasename (const_string name);

/* Return directory part of NAME. This returns a new string. */
extern KPSEDLL string xdirname (const_string name);

#if !HAVE_DECL_STRSTR
extern string strstr (const_string haystack, const_string needle);
#endif

/* If NAME has a suffix, return a pointer to its first character (i.e.,
   the one after the `.'); otherwise, return NULL.  */
extern KPSEDLL string find_suffix (const_string name);

/* Return NAME with any suffix removed.  */
extern KPSEDLL string remove_suffix (const_string name);

/* Return S with the suffix SUFFIX, removing any suffix already present.
   For example, `make_suffix ("/foo/bar.baz", "quux")' returns
   `/foo/bar.quux'.  Returns a string allocated with malloc.  */
extern KPSEDLL string make_suffix (const_string s,  const_string suffix);

/* Return NAME with STEM_PREFIX prepended to the stem. For example,
   `make_prefix ("/foo/bar.baz", "x")' returns `/foo/xbar.baz'.
   Returns a string allocated with malloc.  */
extern KPSEDLL string make_prefix (string stem_prefix, string name);

/* If NAME has a suffix, simply return it; otherwise, return
   `NAME.SUFFIX'.  */
extern KPSEDLL string extend_filename (const_string name,
                                            const_string suffix);

/* Call putenv with the string `VAR=VALUE' and abort on error.  */
extern KPSEDLL void kpathsea_xputenv (kpathsea kpse, const_string var, const_string value);
extern KPSEDLL void kpathsea_xputenv_int (kpathsea kpse, const_string var, int value);
#if defined (KPSE_COMPAT_API)
extern KPSEDLL void xputenv (const_string var, const_string value);
extern KPSEDLL void xputenv_int (const_string var, int value);
#endif

/* Return the current working directory.  */
extern KPSEDLL string xgetcwd (void);

/* Returns true if FN is a directory or a symlink to a directory.  */
extern KPSEDLL boolean kpathsea_dir_p (kpathsea kpse, const_string fn);
#if defined (KPSE_COMPAT_API)
extern KPSEDLL boolean dir_p (const_string fn);
#endif

/* If FN is a readable directory, return the number of links it has.
   Otherwise, return -1.  The nlinks parameter is a dummy on UNIX. */
#if defined (KPSE_COMPAT_API)
extern KPSEDLL int dir_links (const_string fn, long nlinks);
#endif
extern KPSEDLL int kpathsea_dir_links (kpathsea kpse, const_string fn, long nlinks);

/* Like their stdio counterparts, but abort on error, after calling
   perror(3) with FILENAME as its argument.  */
extern KPSEDLL FILE *xfopen (const_string filename, const_string mode);
extern KPSEDLL void xfclose (FILE *, const_string filename);
extern KPSEDLL void xfseek (FILE *, long, int, string filename);
extern KPSEDLL void xfseeko (FILE *, off_t, int, string filename);
extern KPSEDLL unsigned long xftell (FILE *, string filename);
extern KPSEDLL off_t xftello (FILE *, string filename);

/* These call the corresponding function in the standard library, and
   abort if those routines fail.  Also, `xrealloc' calls `xmalloc' if
   OLD_ADDRESS is null.  */
extern KPSEDLL address xmalloc (unsigned size);
extern KPSEDLL address xrealloc (address old_address, unsigned new_size);
extern KPSEDLL address xcalloc (unsigned nelem, unsigned elsize);

/* (Re)Allocate N items of type T using xmalloc/xrealloc.  */
#define XTALLOC(n, t) ((t *) xmalloc ((n) * sizeof (t)))
#define XTALLOC1(t) XTALLOC (1, t)
#define XRETALLOC(addr, n, t) ((addr) = (t *) xrealloc (addr, (n) * sizeof(t)))

#endif /* not KPATHSEA_LIB_H */