home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / uucp / Uucp.framework / uucp.h < prev    next >
C/C++ Source or Header  |  1995-08-20  |  11KB  |  399 lines
  1. /* uucp.h
  2.    Header file for the UUCP package.
  3.  
  4.    Copyright (C) 1991, 1992, 1993, 1994, 1995 Ian Lance Taylor
  5.  
  6.    This file is part of the Taylor UUCP package.
  7.  
  8.    This program is free software; you can redistribute it and/or
  9.    modify it under the terms of the GNU General Public License as
  10.    published by the Free Software Foundation; either version 2 of the
  11.    License, or (at your option) any later version.
  12.  
  13.    This program is distributed in the hope that it will be useful, but
  14.    WITHOUT ANY WARRANTY; without even the implied warranty of
  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.    General Public License for more details.
  17.  
  18.    You should have received a copy of the GNU General Public License
  19.    along with this program; if not, write to the Free Software
  20.    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21.  
  22.    The author of the program may be contacted at ian@airs.com or
  23.    c/o Cygnus Support, 48 Grove Street, Somerville, MA 02144.
  24.    */
  25.  
  26. /* Get the system configuration parameters.  */
  27. #include "config.h"
  28. #include "policy.h"
  29.  
  30. /* Get a definition for ANSI_C if we weren't given one.  */
  31. #ifndef ANSI_C
  32. #ifdef __STDC__
  33. #define ANSI_C 1
  34. #else /* ! defined (__STDC__) */
  35. #define ANSI_C 0
  36. #endif /* ! defined (__STDC__) */
  37. #endif /* ! defined (ANSI_C) */
  38.  
  39. /* Pass this definition into uuconf.h.  */
  40. #define UUCONF_ANSI_C ANSI_C
  41.  
  42. /* We always include some standard header files.  We need <signal.h>
  43.    to define sig_atomic_t.  */
  44. #include <stdio.h>
  45. #include <signal.h>
  46. #if HAVE_STDDEF_H
  47. #include <stddef.h>
  48. #endif
  49.  
  50. /* On some systems we need <sys/types.h> to get sig_atomic_t or
  51.    size_t or time_t.  */
  52. #if ! HAVE_SIG_ATOMIC_T_IN_SIGNAL_H && HAVE_SIG_ATOMIC_T_IN_TYPES_H
  53. #define USE_TYPES_H 1
  54. #else
  55. #if ! HAVE_SIZE_T_IN_STDDEF_H && HAVE_SIZE_T_IN_TYPES_H
  56. #define USE_TYPES_H 1
  57. #else
  58. #if ! HAVE_TIME_T_IN_TIME_H && HAVE_TIME_T_IN_TYPES_H
  59. #define USE_TYPES_H 1
  60. #endif
  61. #endif
  62. #endif
  63.  
  64. #ifndef USE_TYPES_H
  65. #define USE_TYPES_H 0
  66. #endif
  67.  
  68. #if USE_TYPES_H
  69. #include <sys/types.h>
  70. #endif
  71.  
  72. /* Make sure we have sig_atomic_t.  */
  73. #if ! HAVE_SIG_ATOMIC_T_IN_SIGNAL_H && ! HAVE_SIG_ATOMIC_T_IN_TYPES_H
  74. #ifndef SIG_ATOMIC_T
  75. /* There is no portable definition for sig_atomic_t.  */
  76. #define SIG_ATOMIC_T char
  77. #endif /* ! defined (SIG_ATOMIC_T) */
  78. typedef SIG_ATOMIC_T sig_atomic_t;
  79. #endif /* ! HAVE_SIG_ATOMIC_T_IN_SIGNAL_H && ! HAVE_SIG_ATOMIC_T_IN_TYPES_H */
  80.  
  81. /* Make sure we have size_t.  */
  82. #if ! HAVE_SIZE_T_IN_STDDEF_H && ! HAVE_SIZE_T_IN_TYPES_H
  83. #ifndef SIZE_T
  84. #define SIZE_T unsigned
  85. #endif /* ! defined (SIZE_T) */
  86. typedef SIZE_T size_t;
  87. #endif /* ! HAVE_SIZE_T_IN_STDDEF_H && ! HAVE_SIZE_T_IN_TYPES_H */
  88.  
  89. /* Make sure we have time_t.  We use long as the default.  We don't
  90.    bother to let conf.h override this, since on a system which doesn't
  91.    define time_t long must be correct.  */
  92. #if ! HAVE_TIME_T_IN_TIME_H && ! HAVE_TIME_T_IN_TYPES_H
  93. typedef long time_t;
  94. #endif
  95.  
  96. /* Set up some definitions for both ANSI C and Classic C.
  97.  
  98.    P() -- for function prototypes (e.g. extern int foo P((int)) ).
  99.    pointer -- for a generic pointer (i.e. void *).
  100.    constpointer -- for a generic pointer to constant data.
  101.    BUCHAR -- to convert a character to unsigned.  */
  102. #if ANSI_C
  103. #if ! HAVE_VOID || ! HAVE_UNSIGNED_CHAR || ! HAVE_PROTOTYPES
  104.  #error ANSI C compiler without void or unsigned char or prototypes
  105. #endif
  106. #define P(x) x
  107. typedef void *pointer;
  108. typedef const void *constpointer;
  109. #define BUCHAR(b) ((unsigned char) (b))
  110. #else /* ! ANSI_C */
  111. /* Handle uses of volatile and void in Classic C.  */
  112. #define volatile
  113. #if ! HAVE_VOID
  114. #define void int
  115. #endif
  116. #if HAVE_PROTOTYPES
  117. #define P(x) x
  118. #else
  119. #define P(x) ()
  120. #endif
  121. typedef char *pointer;
  122. typedef const char *constpointer;
  123. #if HAVE_UNSIGNED_CHAR
  124. #define BUCHAR(b) ((unsigned char) (b))
  125. #else /* ! HAVE_UNSIGNED_CHAR */
  126. /* This should work on most systems, but not necessarily all.  */
  127. #define BUCHAR(b) ((b) & 0xff)
  128. #endif /* ! HAVE_UNSIGNED_CHAR */
  129. #endif /* ! ANSI_C */
  130.  
  131. /* Make sure we have a definition for offsetof.  */
  132. #ifndef offsetof
  133. #define offsetof(type, field) \
  134.   ((size_t) ((char *) &(((type *) 0)->field) - (char *) (type *) 0))
  135. #endif
  136.  
  137. /* Only use inline with gcc.  */
  138. #ifndef __GNUC__
  139. #define __inline__
  140. #endif
  141.  
  142. /* Get the string functions, which are used throughout the code.  */
  143. #if HAVE_MEMORY_H
  144. #include <memory.h>
  145. #else
  146. /* We really need a definition for memchr, and this should not
  147.    conflict with anything in <string.h>.  I hope.  */
  148. extern pointer memchr ();
  149. #endif
  150.  
  151. #if HAVE_STRING_H
  152. #include <string.h>
  153. #else /* ! HAVE_STRING_H */
  154. #if HAVE_STRINGS_H
  155. #include <strings.h>
  156. #else /* ! HAVE_STRINGS_H */
  157. extern char *strcpy (), *strncpy (), *strchr (), *strrchr (), *strtok ();
  158. extern char *strcat (), *strerror (), *strstr ();
  159. extern size_t strlen (), strspn (), strcspn ();
  160. #if ! HAVE_MEMORY_H
  161. extern pointer memcpy (), memchr ();
  162. #endif /* ! HAVE_MEMORY_H */
  163. #endif /* ! HAVE_STRINGS_H */
  164. #endif /* ! HAVE_STRING_H */
  165.  
  166. /* Get what we need from <stdlib.h>.  */
  167. #if HAVE_STDLIB_H
  168. #include <stdlib.h>
  169. #else /* ! HAVE_STDLIB_H */
  170. extern pointer malloc (), realloc (), bsearch ();
  171. extern long strtol ();
  172. extern unsigned long strtoul ();
  173. extern char *getenv ();
  174. #endif /* ! HAVE_STDLIB_H */
  175.  
  176. /* NeXT uses <libc.h> to declare a bunch of functions.  */
  177. #if HAVE_LIBC_H
  178. #include <libc.h>
  179. #endif
  180.  
  181. /* Make sure we have the EXIT_ macros.  */
  182. #ifndef EXIT_SUCCESS
  183. #define EXIT_SUCCESS (0)
  184. #endif
  185. #ifndef EXIT_FAILURE
  186. #define EXIT_FAILURE (1)
  187. #endif
  188.  
  189. /* If we need to declare errno, do so.  I don't want to always do
  190.    this, because some system might theoretically have a different
  191.    declaration for errno.  On a POSIX system this is sure to work.  */
  192. #if ! HAVE_ERRNO_DECLARATION
  193. extern int errno;
  194. #endif
  195.  
  196. /* If the system has the socket call, guess that we can compile the
  197.    TCP code.  */
  198. #define HAVE_TCP HAVE_SOCKET
  199.  
  200. /* If the system has the t_open call, guess that we can compile the
  201.    TLI code.  */
  202. #define HAVE_TLI HAVE_T_OPEN
  203.  
  204. /* The boolean type holds boolean values.  */
  205. typedef int boolean;
  206. #undef TRUE
  207. #undef FALSE
  208. #define TRUE (1)
  209. #define FALSE (0)
  210.  
  211. /* The openfile_t type holds an open file.  This depends on whether we
  212.    are using stdio or not.  */
  213. #if USE_STDIO
  214.  
  215. typedef FILE *openfile_t;
  216. #define EFILECLOSED ((FILE *) NULL)
  217. #define ffileisopen(e) ((e) != NULL)
  218. #define ffileeof(e) feof (e)
  219. #define cfileread(e, z, c) fread ((z), 1, (c), (e))
  220. #define cfilewrite(e, z, c) fwrite ((z), 1, (c), (e))
  221. #define ffileioerror(e, c) ferror (e)
  222. #ifdef SEEK_SET
  223. #define ffileseek(e, i) (fseek ((e), (long) (i), SEEK_SET) == 0)
  224. #define ffilerewind(e) (fseek ((e), (long) 0, SEEK_SET) == 0)
  225. #else
  226. #define ffileseek(e, i) (fseek ((e), (long) (i), 0) == 0)
  227. #define ffilerewind(e) (fseek ((e), (long) 0, 0) == 0)
  228. #endif
  229. #ifdef SEEK_END
  230. #define ffileseekend(e) (fseek ((e), (long) 0, SEEK_END) == 0)
  231. #else
  232. #define ffileseekend(e) (fseek ((e), (long) 0, 2) == 0)
  233. #endif
  234. #define ffileclose(e) (fclose (e) == 0)
  235.  
  236. #define fstdiosync(e, z) (fsysdep_sync (e, z))
  237.  
  238. #else /* ! USE_STDIO */
  239.  
  240. #if ! USE_TYPES_H
  241. #undef USE_TYPES_H
  242. #define USE_TYPES_H 1
  243. #include <sys/types.h>
  244. #endif
  245.  
  246. #if HAVE_UNISTD_H
  247. #include <unistd.h>
  248. #endif
  249.  
  250. #ifdef OFF_T
  251. typedef OFF_T off_t;
  252. #undef OFF_T
  253. #endif
  254.  
  255. typedef int openfile_t;
  256. #define EFILECLOSED (-1)
  257. #define ffileisopen(e) ((e) >= 0)
  258. #define ffileeof(e) (FALSE)
  259. #define cfileread(e, z, c) read ((e), (z), (c))
  260. #define cfilewrite(e, z, c) write ((e), (z), (c))
  261. #define ffileioerror(e, c) ((c) < 0)
  262. #ifdef SEEK_SET
  263. #define ffileseek(e, i) (lseek ((e), (off_t) i, SEEK_SET) >= 0)
  264. #define ffilerewind(e) (lseek ((e), (off_t) 0, SEEK_SET) >= 0)
  265. #else
  266. #define ffileseek(e, i) (lseek ((e), (off_t) i, 0) >= 0)
  267. #define ffilerewind(e) (lseek ((e), (off_t) 0, 0) >= 0)
  268. #endif
  269. #ifdef SEEK_END
  270. #define ffileseekend(e) (lseek ((e), (off_t) 0, SEEK_END) >= 0)
  271. #else
  272. #define ffileseekend(e) (lseek ((e), (off_t) 0, 2) >= 0)
  273. #endif
  274. #define ffileclose(e) (close (e) >= 0)
  275.  
  276. #define fstdiosync(e, z) (fsysdep_sync (fileno (e), z))
  277.  
  278. #endif /* ! USE_STDIO */
  279.  
  280. /* A prototype for main to avoid warnings from gcc 2.0
  281.    -Wmissing-prototype option.  */
  282. extern int main P((int argc, char **argv));
  283.  
  284. /* Some standard routines which we only define if they are not present
  285.    on the system we are compiling on.  */
  286.  
  287. #if ! HAVE_GETLINE
  288. /* Read a line from a file.  */
  289. extern int getline P((char **pz, size_t *pc, FILE *e));
  290. #endif
  291.  
  292. #if ! HAVE_REMOVE
  293. /* Erase a file.  */
  294. #undef remove
  295. extern int remove P((const char *zfile));
  296. #endif
  297.  
  298. #if ! HAVE_STRDUP
  299. /* Copy a string into memory.  */
  300. extern char *strdup P((const char *z));
  301. #endif
  302.  
  303. #if ! HAVE_STRSTR
  304. /* Look for one string within another.  */
  305. extern char *strstr P((const char *zouter, const char *zinner));
  306. #endif
  307.  
  308. #if ! HAVE_STRCASECMP
  309. #if HAVE_STRICMP
  310. #define strcasecmp stricmp
  311. #else /* ! HAVE_STRICMP */
  312. /* Rename strcasecmp to avoid ANSI C name space.  */
  313. #define strcasecmp xstrcasecmp
  314. extern int strcasecmp P((const char *z1, const char *z2));
  315. #endif /* ! HAVE_STRICMP */
  316. #endif /* ! HAVE_STRCASECMP */
  317.  
  318. #if ! HAVE_STRNCASECMP
  319. #if HAVE_STRNICMP
  320. #define strncasecmp strnicmp
  321. #else /* ! HAVE_STRNICMP */
  322. /* Rename strncasecmp to avoid ANSI C name space.  */
  323. #define strncasecmp xstrncasecmp
  324. extern int strncasecmp P((const char *z1, const char *z2, size_t clen));
  325. #endif /* ! HAVE_STRNICMP */
  326. #endif /* ! HAVE_STRNCASECMP */
  327.  
  328. #if ! HAVE_STRERROR
  329. /* Get a string corresponding to an error message.  */
  330. #undef strerror
  331. extern char *strerror P((int ierr));
  332. #endif
  333.  
  334. /* Get the appropriate definitions for memcmp, memcpy, memchr and
  335.    bzero.  */
  336. #if ! HAVE_MEMCMP
  337. #if HAVE_BCMP
  338. #define memcmp(p1, p2, c) bcmp ((p1), (p2), (c))
  339. #else /* ! HAVE_BCMP */
  340. extern int memcmp P((constpointer p1, constpointer p2, size_t c));
  341. #endif /* ! HAVE_BCMP */
  342. #endif /* ! HAVE_MEMCMP */
  343.  
  344. #if ! HAVE_MEMCPY
  345. #if HAVE_BCOPY
  346. #define memcpy(pto, pfrom, c) bcopy ((pfrom), (pto), (c))
  347. #else /* ! HAVE_BCOPY */
  348. extern pointer memcpy P((pointer pto, constpointer pfrom, size_t c));
  349. #endif /* ! HAVE_BCOPY */
  350. #endif /* ! HAVE_MEMCPY */
  351.  
  352. #if ! HAVE_MEMCHR
  353. extern pointer memchr P((constpointer p, int b, size_t c));
  354. #endif
  355.  
  356. #if ! HAVE_BZERO
  357. #if HAVE_MEMSET
  358. #define bzero(p, c) memset ((p), 0, (c))
  359. #else /* ! HAVE_MEMSET */
  360. extern void bzero P((pointer p, int c));
  361. #endif /* ! HAVE_MEMSET */
  362. #endif /* ! HAVE_BZERO */
  363.  
  364. /* Look up a character in a string.  */
  365. #if ! HAVE_STRCHR
  366. #if HAVE_INDEX
  367. #define strchr index
  368. extern char *index ();
  369. #else /* ! HAVE_INDEX */
  370. extern char *strchr P((const char *z, int b));
  371. #endif /* ! HAVE_INDEX */
  372. #endif /* ! HAVE_STRCHR */
  373.  
  374. #if ! HAVE_STRRCHR
  375. #if HAVE_RINDEX
  376. #define strrchr rindex
  377. extern char *rindex ();
  378. #else /* ! HAVE_RINDEX */
  379. extern char *strrchr P((const char *z, int b));
  380. #endif /* ! HAVE_RINDEX */
  381. #endif /* ! HAVE_STRRCHR */
  382.  
  383. /* Turn a string into a long integer.  */
  384. #if ! HAVE_STRTOL
  385. extern long strtol P((const char *, char **, int));
  386. #endif
  387.  
  388. /* Turn a string into a long unsigned integer.  */
  389. #if ! HAVE_STRTOUL
  390. extern unsigned long strtoul P((const char *, char **, int));
  391. #endif
  392.  
  393. /* Lookup a key in a sorted array.  */
  394. #if ! HAVE_BSEARCH
  395. extern pointer bsearch P((constpointer pkey, constpointer parray,
  396.               size_t celes, size_t cbytes,
  397.               int (*pficmp) P((constpointer, constpointer))));
  398. #endif
  399.