make.h@ 1885

Last change on this file since 1885 was 1885, checked in by bird, 16 years ago
kmk: strcache2_add_file macro for wrapping case sensitive/insenstive hashing, avoiding a couple of checks a lots of inlined code in strcache2.
Property svn:eol-style set to `native`
File size: 26.6 KB

Line
1	/* Miscellaneous global declarations and portability cruft for GNU Make.
2	Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3	1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
4	Foundation, Inc.
5	This file is part of GNU Make.
6
7	GNU Make is free software; you can redistribute it and/or modify it under the
8	terms of the GNU General Public License as published by the Free Software
9	Foundation; either version 2, or (at your option) any later version.
10
11	GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
12	WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13	A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License along with
16	GNU Make; see the file COPYING. If not, write to the Free Software
17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. */
18
19	/* We use <config.h> instead of "config.h" so that a compilation
20	using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
21	(which it would do because make.h was found in $srcdir). */
22	#include <config.h>
23	#undef HAVE_CONFIG_H
24	#define HAVE_CONFIG_H 1
25
26	/* AIX requires this to be the first thing in the file. */
27	#ifndef __GNUC__
28	# if HAVE_ALLOCA_H
29	# include <alloca.h>
30	# else
31	# ifdef _AIX
32	#pragma alloca
33	# else
34	# ifndef alloca /* predefined by HP cc +Olibcalls */
35	char *alloca ();
36	# endif
37	# endif
38	# endif
39	#endif
40
41
42	/* Specify we want GNU source code. This must be defined before any
43	system headers are included. */
44
45	#define _GNU_SOURCE 1
46
47
48	#ifdef CRAY
49	/* This must happen before #include <signal.h> so
50	that the declaration therein is changed. */
51	# define signal bsdsignal
52	#endif
53
54	/* If we're compiling for the dmalloc debugger, turn off string inlining. */
55	#if defined(HAVE_DMALLOC_H) && defined(__GNUC__)
56	# define __NO_STRING_INLINES
57	#endif
58
59	#include <sys/types.h>
60	#include <sys/stat.h>
61	#include <signal.h>
62	#include <stdio.h>
63	#include <ctype.h>
64	#ifdef HAVE_SYS_TIMEB_H
65	/* SCO 3.2 "devsys 4.2" has a prototype for `ftime' in <time.h> that bombs
66	unless <sys/timeb.h> has been included first. Does every system have a
67	<sys/timeb.h>? If any does not, configure should check for it. */
68	# include <sys/timeb.h>
69	#endif
70
71	#if TIME_WITH_SYS_TIME
72	# include <sys/time.h>
73	# include <time.h>
74	#else
75	# if HAVE_SYS_TIME_H
76	# include <sys/time.h>
77	# else
78	# include <time.h>
79	# endif
80	#endif
81
82	#include <errno.h>
83
84	#ifndef errno
85	extern int errno;
86	#endif
87
88	#ifndef isblank
89	# define isblank(c) ((c) == ' ' \|\| (c) == '\t')
90	#endif
91
92	#ifdef HAVE_UNISTD_H
93	# include <unistd.h>
94	/* Ultrix's unistd.h always defines _POSIX_VERSION, but you only get
95	POSIX.1 behavior with `cc -YPOSIX', which predefines POSIX itself! */
96	# if defined (_POSIX_VERSION) && !defined (ultrix) && !defined (VMS)
97	# define POSIX 1
98	# endif
99	#endif
100
101	/* Some systems define _POSIX_VERSION but are not really POSIX.1. */
102	#if (defined (butterfly) \|\| defined (__arm) \|\| (defined (__mips) && defined (_SYSTYPE_SVR3)) \|\| (defined (sequent) && defined (i386)))
103	# undef POSIX
104	#endif
105
106	#if !defined (POSIX) && defined (_AIX) && defined (_POSIX_SOURCE)
107	# define POSIX 1
108	#endif
109
110	#ifndef RETSIGTYPE
111	# define RETSIGTYPE void
112	#endif
113
114	#ifndef sigmask
115	# define sigmask(sig) (1 << ((sig) - 1))
116	#endif
117
118	#ifndef HAVE_SA_RESTART
119	# define SA_RESTART 0
120	#endif
121
122	#ifdef HAVE_LIMITS_H
123	# include <limits.h>
124	#endif
125	#ifdef HAVE_SYS_PARAM_H
126	# include <sys/param.h>
127	#endif
128
129	#ifndef PATH_MAX
130	# ifndef POSIX
131	# define PATH_MAX MAXPATHLEN
132	# endif
133	#endif
134	#ifndef MAXPATHLEN
135	# define MAXPATHLEN 1024
136	#endif
137
138	#ifdef PATH_MAX
139	# define GET_PATH_MAX PATH_MAX
140	# define PATH_VAR(var) char var[PATH_MAX]
141	#else
142	# define NEED_GET_PATH_MAX 1
143	# define GET_PATH_MAX (get_path_max ())
144	# define PATH_VAR(var) char *var = alloca (GET_PATH_MAX)
145	unsigned int get_path_max (void);
146	#endif
147
148	#ifndef CHAR_BIT
149	# define CHAR_BIT 8
150	#endif
151
152	#if defined(KMK) \|\| defined(CONFIG_WITH_VALUE_LENGTH) \|\| defined (VARIABLE_HASH)
153	# ifdef _MSC_VER
154	# define MY_INLINE _inline static
155	# define MY_DBGBREAK __debugbreak()
156	# elif defined(__GNUC__)
157	# define MY_INLINE static __inline__
158	# if defined(__i386__) \|\| defined(__x86_64__)
159	# define MY_DBGBREAK __asm__ __volatile__ ("int3")
160	#else
161	# define MY_DBGBREAK assert(0)
162	# endif
163	# else
164	# define MY_INLINE static
165	# define MY_DBGBREAK assert(0)
166	# endif
167	# ifndef NDEBUG
168	# define MY_ASSERT_MSG(expr, printfargs) \
169	do { if (!(expr)) { printf printfargs; MY_DBGBREAK; } } while (0)
170	# else
171	# define MY_ASSERT_MSG(expr, printfargs) do { } while (0)
172	# endif
173
174	# ifdef __GNUC__
175	# define MY_PREDICT_TRUE(expr) __builtin_expect(!!(expr), 1)
176	# define MY_PREDICT_FALSE(expr) __builtin_expect(!!(expr), 0)
177	# else
178	# define MY_PREDICT_TRUE(expr) (expr)
179	# define MY_PREDICT_FALSE(expr) (expr)
180	# endif
181	#endif
182
183	#ifdef KMK
184	# include <ctype.h>
185	# if 1 /* See if this speeds things up (Windows is doing this anyway, so,
186	we might as well try be consistent in speed + features). */
187	# if 1
188	# define MY_IS_BLANK(ch) ((ch) == ' ' \|\| (ch) == '\t')
189	# define MY_IS_BLANK_OR_EOS(ch) ((ch) == ' ' \|\| (ch) == '\t' \|\| (ch) == '\0')
190	# else
191	# define MY_IS_BLANK(ch) (((ch) == ' ') \| ((ch) == '\t'))
192	# define MY_IS_BLANK_OR_EOS(ch) (((ch) == ' ') \| ((ch) == '\t') \| ((ch) == '\0'))
193	# endif
194	# undef isblank
195	# define isblank(ch) MY_IS_BLANK(ch)
196	# else
197	# define MY_IS_BLANK(ch) isblank ((unsigned char)(ch))
198	# define MY_IS_BLANK_OR_EOS(ch) (isblank ((unsigned char)(ch)) \|\| (ch) == '\0')
199	# endif
200	#endif
201
202	/* Nonzero if the integer type T is signed. */
203	#define INTEGER_TYPE_SIGNED(t) ((t) -1 < 0)
204
205	/* The minimum and maximum values for the integer type T.
206	Use ~ (t) 0, not -1, for portability to 1's complement hosts. */
207	#define INTEGER_TYPE_MINIMUM(t) \
208	(! INTEGER_TYPE_SIGNED (t) ? (t) 0 : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))
209	#define INTEGER_TYPE_MAXIMUM(t) (~ (t) 0 - INTEGER_TYPE_MINIMUM (t))
210
211	#ifndef CHAR_MAX
212	# define CHAR_MAX INTEGER_TYPE_MAXIMUM (char)
213	#endif
214
215	#ifdef STAT_MACROS_BROKEN
216	# ifdef S_ISREG
217	# undef S_ISREG
218	# endif
219	# ifdef S_ISDIR
220	# undef S_ISDIR
221	# endif
222	#endif /* STAT_MACROS_BROKEN. */
223
224	#ifndef S_ISREG
225	# define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG)
226	#endif
227	#ifndef S_ISDIR
228	# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
229	#endif
230
231	#ifdef VMS
232	# include <types.h>
233	# include <unixlib.h>
234	# include <unixio.h>
235	# include <perror.h>
236	/* Needed to use alloca on VMS. */
237	# include <builtins.h>
238	#endif
239
240	#ifndef __attribute__
241	/* This feature is available in gcc versions 2.5 and later. */
242	# if __GNUC__ < 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 5) \|\| __STRICT_ANSI__
243	# define __attribute__(x)
244	# endif
245	/* The __-protected variants of `format' and `printf' attributes
246	are accepted by gcc versions 2.6.4 (effectively 2.7) and later. */
247	# if __GNUC__ < 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
248	# define __format__ format
249	# define __printf__ printf
250	# endif
251	#endif
252	#define UNUSED __attribute__ ((unused))
253
254	#if defined (STDC_HEADERS) \|\| defined (__GNU_LIBRARY__)
255	# include <stdlib.h>
256	# include <string.h>
257	# define ANSI_STRING 1
258	#else /* No standard headers. */
259	# ifdef HAVE_STRING_H
260	# include <string.h>
261	# define ANSI_STRING 1
262	# else
263	# include <strings.h>
264	# endif
265	# ifdef HAVE_MEMORY_H
266	# include <memory.h>
267	# endif
268	# ifdef HAVE_STDLIB_H
269	# include <stdlib.h>
270	# else
271	void *malloc (int);
272	void realloc (void , int);
273	void free (void *);
274
275	void abort (void) __attribute__ ((noreturn));
276	void exit (int) __attribute__ ((noreturn));
277	# endif /* HAVE_STDLIB_H. */
278
279	#endif /* Standard headers. */
280
281	/* These should be in stdlib.h. Make sure we have them. */
282	#ifndef EXIT_SUCCESS
283	# define EXIT_SUCCESS 0
284	#endif
285	#ifndef EXIT_FAILURE
286	# define EXIT_FAILURE 1
287	#endif
288
289	#ifndef ANSI_STRING
290
291	/* SCO Xenix has a buggy macro definition in <string.h>. */
292	#undef strerror
293	#if !defined(__DECC)
294	char *strerror (int errnum);
295	#endif
296
297	#endif /* !ANSI_STRING. */
298	#undef ANSI_STRING
299
300	#if HAVE_INTTYPES_H
301	# include <inttypes.h>
302	#endif
303	#define FILE_TIMESTAMP uintmax_t
304
305	#if !defined(HAVE_STRSIGNAL)
306	char *strsignal (int signum);
307	#endif
308
309	/* ISDIGIT offers the following features:
310	- Its arg may be any int or unsigned int; it need not be an unsigned char.
311	- It's guaranteed to evaluate its argument exactly once.
312	NOTE! Make relies on this behavior, don't change it!
313	- It's typically faster.
314	POSIX 1003.2-1992 section 2.5.2.1 page 50 lines 1556-1558 says that
315	only '0' through '9' are digits. Prefer ISDIGIT to isdigit() unless
316	it's important to use the locale's definition of `digit' even when the
317	host does not conform to POSIX. */
318	#define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
319
320	#ifndef iAPX286
321	# define streq(a, b) \
322	((a) == (b) \|\| \
323	((a) == (b) && (*(a) == '\0' \|\| !strcmp ((a) + 1, (b) + 1))))
324	# ifdef HAVE_CASE_INSENSITIVE_FS
325	# define strieq(a, b) \
326	((a) == (b) \
327	\|\| (tolower((unsigned char)(a)) == tolower((unsigned char)(b)) \
328	&& (*(a) == '\0' \|\| !strcasecmp ((a) + 1, (b) + 1))))
329	# else
330	# define strieq(a, b) streq(a, b)
331	# endif
332	#else
333	/* Buggy compiler can't handle this. */
334	# define streq(a, b) (strcmp ((a), (b)) == 0)
335	# define strieq(a, b) (strcmp ((a), (b)) == 0)
336	#endif
337	#define strneq(a, b, l) (strncmp ((a), (b), (l)) == 0)
338
339	#if (defined(__GNUC__) \|\| defined(ENUM_BITFIELDS)) && !defined(NO_ENUM_BITFIELDS)
340	# define ENUM_BITFIELD(bits) :bits
341	#else
342	# define ENUM_BITFIELD(bits)
343	#endif
344
345	/* Handle gettext and locales. */
346
347	#if HAVE_LOCALE_H
348	# include <locale.h>
349	#else
350	# define setlocale(category, locale)
351	#endif
352
353	#include <gettext.h>
354
355	#define _(msgid) gettext (msgid)
356	#define N_(msgid) gettext_noop (msgid)
357	#define S_(msg1,msg2,num) ngettext (msg1,msg2,num)
358
359	/* Handle other OSs. */
360	#ifndef PATH_SEPARATOR_CHAR
361	# if defined(HAVE_DOS_PATHS)
362	# define PATH_SEPARATOR_CHAR ';'
363	# elif defined(VMS)
364	# define PATH_SEPARATOR_CHAR ','
365	# else
366	# define PATH_SEPARATOR_CHAR ':'
367	# endif
368	#endif
369
370	/* This is needed for getcwd() and chdir(), on some W32 systems. */
371	#if defined(HAVE_DIRECT_H)
372	# include <direct.h>
373	#endif
374
375	#ifdef WINDOWS32
376	# include <fcntl.h>
377	# include <malloc.h>
378	# define pipe(_p) _pipe((_p), 512, O_BINARY)
379	# define kill(_pid,_sig) w32_kill((_pid),(_sig))
380
381	void sync_Path_environment (void);
382	int w32_kill (int pid, int sig); /* bird kill -> w32_kill - macro acquired () on the args. */
383	char end_of_token_w32 (const char s, char stopchar);
384	int find_and_set_default_shell (const char *token);
385
386	/* indicates whether or not we have Bourne shell */
387	extern int no_default_sh_exe;
388
389	/* is default_shell unixy? */
390	extern int unixy_shell;
391	#endif /* WINDOWS32 */
392
393	struct floc
394	{
395	const char *filenm;
396	unsigned long lineno;
397	};
398	#define NILF ((struct floc *)0)
399
400	#define STRING_SIZE_TUPLE(_s) (_s), (sizeof (_s)-1)
401
402
403
404	/* We have to have stdarg.h or varargs.h AND v*printf or doprnt to use
405	variadic versions of these functions. */
406
407	#if HAVE_STDARG_H \|\| HAVE_VARARGS_H
408	# if HAVE_VPRINTF \|\| HAVE_DOPRNT
409	# define USE_VARIADIC 1
410	# endif
411	#endif
412
413	#if HAVE_ANSI_COMPILER && USE_VARIADIC && HAVE_STDARG_H
414	void message (int prefix, const char *fmt, ...)
415	__attribute__ ((__format__ (__printf__, 2, 3)));
416	void error (const struct floc flocp, const char fmt, ...)
417	__attribute__ ((__format__ (__printf__, 2, 3)));
418	void fatal (const struct floc flocp, const char fmt, ...)
419	__attribute__ ((noreturn, __format__ (__printf__, 2, 3)));
420	#else
421	void message ();
422	void error ();
423	void fatal ();
424	#endif
425
426	void die (int) __attribute__ ((noreturn));
427	void log_working_directory (int);
428	void pfatal_with_name (const char *) __attribute__ ((noreturn));
429	void perror_with_name (const char , const char );
430	char savestring (const char , unsigned int);
431	char concat (const char , const char , const char );
432	void *xmalloc (unsigned int);
433	void xrealloc (void , unsigned int);
434	char xstrdup (const char );
435	char find_next_token (const char , unsigned int );
436	char next_token (const char );
437	char end_of_token (const char );
438	#ifndef CONFIG_WITH_VALUE_LENGTH
439	void collapse_continuations (char *);
440	#else
441	char collapse_continuations (char , unsigned int);
442	#endif
443	#ifdef CONFIG_WITH_OPTIMIZATION_HACKS /* memchr is usually compiler intrinsic, thus faster. */
444	# define lindex(s, limit, c) ((char *)memchr((s), (c), (limit) - (s)))
445	#else
446	char lindex (const char , const char *, int);
447	#endif
448	int alpha_compare (const void , const void );
449	void print_spaces (unsigned int);
450	char find_percent (char );
451	const char find_percent_cached (const char *);
452	FILE open_tmpfile (char , const char );
453
454	#ifndef NO_ARCHIVES
455	int ar_name (const char *);
456	void ar_parse_name (const char , char , char *);
457	int ar_touch (const char *);
458	time_t ar_member_date (const char *);
459
460	typedef long int (ar_member_func_t) (int desc, const char mem, int truncated,
461	long int hdrpos, long int datapos,
462	long int size, long int date, int uid,
463	int gid, int mode, const void *arg);
464
465	long int ar_scan (const char archive, ar_member_func_t function, const void arg);
466	int ar_name_equal (const char name, const char mem, int truncated);
467	#ifndef VMS
468	int ar_member_touch (const char arname, const char memname);
469	#endif
470	#endif
471
472	int dir_file_exists_p (const char , const char );
473	int file_exists_p (const char *);
474	int file_impossible_p (const char *);
475	void file_impossible (const char *);
476	const char dir_name (const char );
477	void hash_init_directories (void);
478
479	void define_default_variables (void);
480	void set_default_suffixes (void);
481	void install_default_suffix_rules (void);
482	void install_default_implicit_rules (void);
483
484	void build_vpath_lists (void);
485	void construct_vpath_list (char pattern, char dirpath);
486	const char vpath_search (const char file, FILE_TIMESTAMP *mtime_ptr);
487	int gpath_search (const char *file, unsigned int len);
488
489	void construct_include_path (const char **arg_dirs);
490
491	void user_access (void);
492	void make_access (void);
493	void child_access (void);
494
495	void close_stdout (void);
496
497	char strip_whitespace (const char begpp, const char *endpp);
498
499	#ifdef CONFIG_WITH_ALLOC_CACHES
500	/* alloccache (misc.c) */
501
502	struct alloccache_free_ent
503	{
504	struct alloccache_free_ent *next;
505	};
506
507	struct alloccache
508	{
509	char *free_start;
510	char *free_end;
511	struct alloccache_free_ent *free_head;
512	unsigned int size;
513	unsigned int alloc_count;
514	unsigned int total_count;
515	const char *name;
516	struct alloccache *next;
517	void *grow_arg;
518	void (grow_alloc)(void *grow_arg, unsigned int size);
519	};
520
521	void alloccache_init (struct alloccache cache, unsigned int size, const char name,
522	void (grow_alloc)(void grow_arg, unsigned int size), void grow_arg);
523	void alloccache_term (struct alloccache *cache,
524	void (term_free)(void term_arg, void ptr, unsigned int size), void term_arg);
525	void alloccache_join (struct alloccache cache, struct alloccache eat);
526	void alloccache_print (struct alloccache *cache);
527	void alloccache_print_all (void);
528	struct alloccache_free_ent alloccache_alloc_grow (struct alloccache cache);
529
530	/* Allocate an item. */
531	MY_INLINE void *
532	alloccache_alloc (struct alloccache *cache)
533	{
534	struct alloccache_free_ent *f = cache->free_head;
535	if (f)
536	cache->free_head = f->next;
537	else if (cache->free_start != cache->free_end)
538	{
539	f = (struct alloccache_free_ent *)cache->free_start;
540	cache->free_start += cache->size;
541	}
542	else
543	f = alloccache_alloc_grow (cache);
544	cache->alloc_count++;
545	return f;
546	}
547
548	/* Allocate a cleared item. */
549	MY_INLINE void *
550	alloccache_calloc (struct alloccache *cache)
551	{
552	void *item = alloccache_alloc (cache);
553	memset (item, '\0', cache->size);
554	return item;
555	}
556
557	/* Free an item. */
558	MY_INLINE void
559	alloccache_free (struct alloccache cache, void item)
560	{
561	struct alloccache_free_ent f = (struct alloccache_free_ent )item;
562	#if 0 /ndef NDEBUG/
563	struct alloccache_free_ent *c;
564	unsigned int i = 0;
565	for (c = cache->free_head; c != NULL; c = c->next, i++)
566	MY_ASSERT_MSG (c != f && i < 0x10000000,
567	("i=%u total_count=%u\n", i, cache->total_count));
568	#endif
569
570	f->next = cache->free_head;
571	cache->free_head = f;
572	cache->alloc_count--;
573	}
574
575	/* the alloc caches */
576	extern struct alloccache dep_cache;
577	extern struct alloccache file_cache;
578	extern struct alloccache commands_cache;
579	extern struct alloccache nameseq_cache;
580	extern struct alloccache variable_cache;
581	extern struct alloccache variable_set_cache;
582	extern struct alloccache variable_set_list_cache;
583
584	#endif /* CONFIG_WITH_ALLOC_CACHES */
585
586
587	/* String caching */
588	void strcache_init (void);
589	void strcache_print_stats (const char *prefix);
590	#ifndef CONFIG_WITH_STRCACHE2
591	int strcache_iscached (const char *str);
592	const char strcache_add (const char str);
593	const char strcache_add_len (const char str, int len);
594	int strcache_setbufsize (int size);
595	# ifdef CONFIG_WITH_INCLUDEDEP
596	const char strcache_add_prehashed (const char str, int len,
597	unsigned long hash1, unsigned long hash2);
598	void strcache_prehash_str (const char str, unsigned int len, unsigned long hash1p,
599	unsigned long *hash2p);
600	#endif
601	#ifdef CONFIG_WITH_VALUE_LENGTH
602	struct strcache_pref
603	{
604	unsigned long hash1;
605	unsigned long hash2;
606	unsigned int len;
607	};
608
609	int strcache_check_sanity (const char *str);
610	unsigned long strcache_get_hash2_fallback (const char *str);
611
612	MY_INLINE unsigned int strcache_get_len (const char *str)
613	{
614	struct strcache_pref const prefix = (struct strcache_pref const )str - 1;
615	unsigned int len = prefix->len;
616	MY_ASSERT_MSG (strcache_check_sanity (str) == 0, ("!\n"));
617	return len;
618	}
619
620	MY_INLINE unsigned int strcache_get_hash1 (const char *str)
621	{
622	struct strcache_pref const prefix = (struct strcache_pref const )str - 1;
623	unsigned long hash1 = prefix->hash1;
624	MY_ASSERT_MSG (strcache_check_sanity (str) == 0, ("!\n"));
625	return hash1;
626	}
627
628	MY_INLINE unsigned long strcache_get_hash2 (const char *str)
629	{
630	struct strcache_pref const prefix = (struct strcache_pref const )str - 1;
631	unsigned long hash2 = prefix->hash2;
632	MY_ASSERT_MSG (strcache_check_sanity (str) == 0, ("!\n"));
633	if (!hash2)
634	return strcache_get_hash2_fallback (str);
635	return hash2;
636	}
637
638	# endif /* CONFIG_WITH_VALUE_LENGTH*/
639
640	#else /* CONFIG_WITH_STRCACHE2 */
641
642	# include "strcache2.h"
643	extern struct strcache2 file_strcache;
644
645	# define strcache_iscached(str) strcache2_is_cached(&file_strcache, str)
646	# define strcache_add(str) strcache2_add_file(&file_strcache, str, strlen (str))
647	# define strcache_add_len(str, len) strcache2_add_file(&file_strcache, str, len)
648	# ifdef CONFIG_WITH_INCLUDEDEP
649	# define strcache_add_prehashed(str, len, hash1, hash2) \
650	strcache2_add_hashed(&file_strcache, str, len, hash1, hash2)
651	# ifdef HAVE_CASE_INSENSITIVE_FS
652	# define strcache_prehash_str(str, length, hash1p, hash2p) \
653	do { *(hash1p) = strcache2_hash_istr (str, length, (hash2p)); } while (0)
654	# else
655	# define strcache_prehash_str(str, length, hash1p, hash2p) \
656	do { *(hash1p) = strcache2_hash_str (str, length, (hash2p)); } while (0)
657	# endif
658	# endif /* CONFIG_WITH_INCLUDEDEP */
659	# ifdef CONFIG_WITH_VALUE_LENGTH
660	# define strcache_get_len(str) strcache2_get_len(&file_strcache, str)
661	# define strcache_get_hash1(str) strcache2_get_hash1(&file_strcache, str)
662	# define strcache_get_hash2(str) strcache2_get_hash2(&file_strcache, str)
663	# endif /* CONFIG_WITH_VALUE_LENGTH */
664
665	#endif /* CONFIG_WITH_STRCACHE2 */
666
667	#ifdef HAVE_VFORK_H
668	# include <vfork.h>
669	#endif
670
671	/* We omit these declarations on non-POSIX systems which define _POSIX_VERSION,
672	because such systems often declare them in header files anyway. */
673
674	#if !defined (__GNU_LIBRARY__) && !defined (POSIX) && !defined (_POSIX_VERSION) && !defined(WINDOWS32)
675
676	long int atol ();
677	# ifndef VMS
678	long int lseek ();
679	# endif
680
681	#endif /* Not GNU C library or POSIX. */
682
683	#ifdef HAVE_GETCWD
684	# if !defined(VMS) && !defined(__DECC) && !defined(_MSC_VER) /* bird: MSC */
685	char *getcwd ();
686	# endif
687	#else
688	char *getwd ();
689	# define getcwd(buf, len) getwd (buf)
690	#endif
691
692	#if !HAVE_STRCASECMP
693	# if HAVE_STRICMP
694	# define strcasecmp stricmp
695	# elif HAVE_STRCMPI
696	# define strcasecmp strcmpi
697	# else
698	/* Create our own, in misc.c */
699	int strcasecmp (const char s1, const char s2);
700	# endif
701	#endif
702
703	extern const struct floc *reading_file;
704	extern const struct floc **expanding_var;
705
706	#if !defined(_MSC_VER) /* bird */
707	extern char **environ;
708	#endif
709
710	extern int just_print_flag, silent_flag, ignore_errors_flag, keep_going_flag;
711	extern int print_data_base_flag, question_flag, touch_flag, always_make_flag;
712	extern int env_overrides, no_builtin_rules_flag, no_builtin_variables_flag;
713	extern int print_version_flag, print_directory_flag, check_symlink_flag;
714	extern int warn_undefined_variables_flag, posix_pedantic, not_parallel;
715	extern int second_expansion, clock_skew_detected, rebuilding_makefiles;
716	#ifdef CONFIG_WITH_2ND_TARGET_EXPANSION
717	extern int second_target_expansion;
718	#endif
719	#ifdef CONFIG_PRETTY_COMMAND_PRINTING
720	extern int pretty_command_printing;
721	#endif
722	#ifdef CONFIG_WITH_MAKE_STATS
723	extern int make_expensive_statistics;
724	#endif
725
726
727	/* can we run commands via 'sh -c xxx' or must we use batch files? */
728	extern int batch_mode_shell;
729
730	extern char cmd_prefix;
731
732	extern unsigned int job_slots;
733	extern int job_fds[2];
734	extern int job_rfd;
735	#ifndef NO_FLOAT
736	extern double max_load_average;
737	#else
738	extern int max_load_average;
739	#endif
740
741	extern char *program;
742	extern char *starting_directory;
743	extern unsigned int makelevel;
744	extern char version_string, remote_description, *make_host;
745
746	extern unsigned int commands_started;
747
748	extern int handling_fatal_signal;
749
750
751	#ifndef MIN
752	#define MIN(_a,_b) ((_a)<(_b)?(_a):(_b))
753	#endif
754	#ifndef MAX
755	#define MAX(_a,_b) ((_a)>(_b)?(_a):(_b))
756	#endif
757
758	#ifdef VMS
759	# define MAKE_SUCCESS 1
760	# define MAKE_TROUBLE 2
761	# define MAKE_FAILURE 3
762	#else
763	# define MAKE_SUCCESS 0
764	# define MAKE_TROUBLE 1
765	# define MAKE_FAILURE 2
766	#endif
767
768	/* Set up heap debugging library dmalloc. */
769
770	#ifdef HAVE_DMALLOC_H
771	#include <dmalloc.h>
772	#endif
773
774	#ifndef initialize_main
775	# ifdef __EMX__
776	# define initialize_main(pargc, pargv) \
777	{ _wildcard(pargc, pargv); _response(pargc, pargv); }
778	# else
779	# define initialize_main(pargc, pargv)
780	# endif
781	#endif
782
783	#ifdef __EMX__
784	# if !defined chdir
785	# define chdir _chdir2
786	# endif
787	# if !defined getcwd
788	# define getcwd _getcwd2
789	# endif
790
791	/* NO_CHDIR2 causes make not to use _chdir2() and _getcwd2() instead of
792	chdir() and getcwd(). This avoids some error messages for the
793	make testsuite but restricts the drive letter support. */
794	# ifdef NO_CHDIR2
795	# warning NO_CHDIR2: usage of drive letters restricted
796	# undef chdir
797	# undef getcwd
798	# endif
799	#endif
800
801	#ifndef initialize_main
802	# define initialize_main(pargc, pargv)
803	#endif
804
805
806	/* Some systems (like Solaris, PTX, etc.) do not support the SA_RESTART flag
807	properly according to POSIX. So, we try to wrap common system calls with
808	checks for EINTR. Note that there are still plenty of system calls that
809	can fail with EINTR but this, reportedly, gets the vast majority of
810	failure cases. If you still experience failures you'll need to either get
811	a system where SA_RESTART works, or you need to avoid -j. */
812
813	#define EINTRLOOP(_v,_c) while (((_v)=_c)==-1 && errno==EINTR)
814
815	/* While system calls that return integers are pretty consistent about
816	returning -1 on failure and setting errno in that case, functions that
817	return pointers are not always so well behaved. Sometimes they return
818	NULL for expected behavior: one good example is readdir() which returns
819	NULL at the end of the directory--and _doesn't_ reset errno. So, we have
820	to do it ourselves here. */
821
822	#define ENULLLOOP(_v,_c) do { errno = 0; (_v) = _c; } \
823	while((_v)==0 && errno==EINTR)
824
825
826	#if defined(__EMX__) && defined(CONFIG_WITH_OPTIMIZATION_HACKS) /* bird: saves 40-100ms on libc. */
827	static inline void __my_rawmemchr (const void __s, int __c);
828	#undef strchr
829	#define strchr(s, c) \
830	(__extension__ (__builtin_constant_p (c) \
831	? ((c) == '\0' \
832	? (char *) __my_rawmemchr ((s), (c)) \
833	: __my_strchr_c ((s), ((c) & 0xff) << 8)) \
834	: __my_strchr_g ((s), (c))))
835	static inline char __my_strchr_c (const char __s, int __c)
836	{
837	register unsigned long int __d0;
838	register char *__res;
839	__asm__ __volatile__
840	("1:\n\t"
841	"movb (%0),%%al\n\t"
842	"cmpb %%ah,%%al\n\t"
843	"je 2f\n\t"
844	"leal 1(%0),%0\n\t"
845	"testb %%al,%%al\n\t"
846	"jne 1b\n\t"
847	"xorl %0,%0\n"
848	"2:"
849	: "=r" (__res), "=&a" (__d0)
850	: "0" (__s), "1" (__c),
851	"m" ( (struct { char __x[0xfffffff]; } )__s)
852	: "cc");
853	return __res;
854	}
855
856	static inline char __my_strchr_g (__const char __s, int __c)
857	{
858	register unsigned long int __d0;
859	register char *__res;
860	__asm__ __volatile__
861	("movb %%al,%%ah\n"
862	"1:\n\t"
863	"movb (%0),%%al\n\t"
864	"cmpb %%ah,%%al\n\t"
865	"je 2f\n\t"
866	"leal 1(%0),%0\n\t"
867	"testb %%al,%%al\n\t"
868	"jne 1b\n\t"
869	"xorl %0,%0\n"
870	"2:"
871	: "=r" (__res), "=&a" (__d0)
872	: "0" (__s), "1" (__c),
873	"m" ( (struct { char __x[0xfffffff]; } )__s)
874	: "cc");
875	return __res;
876	}
877
878	static inline void __my_rawmemchr (const void __s, int __c)
879	{
880	register unsigned long int __d0;
881	register unsigned char *__res;
882	__asm__ __volatile__
883	("cld\n\t"
884	"repne; scasb\n\t"
885	: "=D" (__res), "=&c" (__d0)
886	: "a" (__c), "0" (__s), "1" (0xffffffff),
887	"m" ( (struct { char __x[0xfffffff]; } )__s)
888	: "cc");
889	return __res - 1;
890	}
891
892	#undef memchr
893	#define memchr(a,b,c) __my_memchr((a),(b),(c))
894	static inline void __my_memchr (__const void __s, int __c, size_t __n)
895	{
896	register unsigned long int __d0;
897	register unsigned char *__res;
898	if (__n == 0)
899	return NULL;
900	__asm__ __volatile__
901	("repne; scasb\n\t"
902	"je 1f\n\t"
903	"movl $1,%0\n"
904	"1:"
905	: "=D" (__res), "=&c" (__d0)
906	: "a" (__c), "0" (__s), "1" (__n),
907	"m" ( (struct { __extension__ char __x[__n]; } )__s)
908	: "cc");
909	return __res - 1;
910	}
911
912	#endif /* __EMX__ (bird) */
913
914	#ifdef CONFIG_WITH_MAKE_STATS
915	extern long make_stats_allocations;
916	extern unsigned long make_stats_allocated;
917	extern unsigned long make_stats_allocated_sum;
918	extern unsigned long make_stats_ht_lookups;
919	extern unsigned long make_stats_ht_collisions;
920
921	# ifdef __APPLE__
922	# include <malloc/malloc.h>
923	# define SIZE_OF_HEAP_BLOCK(ptr) malloc_size(ptr)
924
925	# elif defined(__linux__) /* glibc */
926	# include <malloc.h>
927	# define SIZE_OF_HEAP_BLOCK(ptr) malloc_usable_size(ptr)
928
929	# elif defined(_MSC_VER) \|\| defined(__OS2__)
930	# define SIZE_OF_HEAP_BLOCK(ptr) _msize(ptr)
931
932	# else
933	# include <stdlib.h>
934	# define SIZE_OF_HEAP_BLOCK(ptr) 0
935	#endif
936
937	# if defined(CONFIG_WITH_MAKE_STATS) && !defined(ELECTRIC_HEAP)
938	# define free xfree
939	extern void xfree (void *);
940	# endif
941
942	#endif
943
944	#ifdef CONFIG_WITH_IF_CONDITIONALS
945	extern int expr_eval_if_conditionals(char line, const struct floc flocp);
946	extern char expr_eval_to_string(char o, char *expr);
947	#endif
948
949	#ifdef KMK
950	extern char abspath(const char name, char *apath);
951	extern char func_breakpoint(char o, char *argv, const char funcname);
952	#endif

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/kmk/make.h@ 1885

Download in other formats: