From 30d4ebf51dce20df03409dc57be8f0fe75bf39b0 Mon Sep 17 00:00:00 2001 From: ahodgkinson Date: Mon, 6 Feb 2006 19:58:18 +0000 Subject: [PATCH] Updated w32 external tools, including source code and build scripts. git-svn-id: https://svn.code.sf.net/p/flaim/code/trunk@62 0109f412-320b-0410-ab79-c3e0c5ffbbe6 --- flaim/Makefile | 3 +- flaim/external/w32/make/VERSION | 1 + flaim/external/w32/make/alloca.c | 504 ++++ flaim/external/w32/make/amiga.h | 22 + flaim/external/w32/make/ar.c | 329 +++ flaim/external/w32/make/arscan.c | 861 +++++++ flaim/external/w32/make/build.bat | 33 + flaim/external/w32/make/commands.c | 584 +++++ flaim/external/w32/make/commands.h | 42 + flaim/external/w32/make/config.h | 399 ++++ flaim/external/w32/make/debug.h | 41 + flaim/external/w32/make/default.c | 585 +++++ flaim/external/w32/make/dep.h | 78 + flaim/external/w32/make/dir.c | 1212 ++++++++++ flaim/external/w32/make/dirent.c | 188 ++ flaim/external/w32/make/dirent.h | 37 + flaim/external/w32/make/expand.c | 566 +++++ flaim/external/w32/make/file.c | 827 +++++++ flaim/external/w32/make/filedef.h | 199 ++ flaim/external/w32/make/fnmatch.c | 488 ++++ flaim/external/w32/make/fnmatch.h | 84 + flaim/external/w32/make/function.c | 2076 +++++++++++++++++ flaim/external/w32/make/getloadavg.c | 1034 ++++++++ flaim/external/w32/make/getopt.c | 1047 +++++++++ flaim/external/w32/make/getopt.h | 133 ++ flaim/external/w32/make/getopt1.c | 190 ++ flaim/external/w32/make/gettext.h | 59 + flaim/external/w32/make/glob.c | 1425 +++++++++++ flaim/external/w32/make/glob.h | 205 ++ flaim/external/w32/make/hash.c | 369 +++ flaim/external/w32/make/hash.h | 233 ++ flaim/external/w32/make/implicit.c | 635 +++++ flaim/external/w32/make/job.c | 3110 +++++++++++++++++++++++++ flaim/external/w32/make/job.h | 83 + flaim/external/w32/make/main.c | 2813 ++++++++++++++++++++++ flaim/external/w32/make/make.h | 562 +++++ flaim/external/w32/make/misc.c | 893 +++++++ flaim/external/w32/make/misc_w32.c | 65 + flaim/external/w32/make/pathstuff.c | 238 ++ flaim/external/w32/make/pathstuff.h | 9 + flaim/external/w32/make/proc.h | 13 + flaim/external/w32/make/read.c | 3105 ++++++++++++++++++++++++ flaim/external/w32/make/remake.c | 1420 +++++++++++ flaim/external/w32/make/remote-stub.c | 109 + flaim/external/w32/make/rule.c | 717 ++++++ flaim/external/w32/make/rule.h | 72 + flaim/external/w32/make/signame.c | 255 ++ flaim/external/w32/make/sub_proc.c | 1207 ++++++++++ flaim/external/w32/make/sub_proc.h | 47 + flaim/external/w32/make/variable.c | 1263 ++++++++++ flaim/external/w32/make/variable.h | 183 ++ flaim/external/w32/make/version.c | 17 + flaim/external/w32/make/vpath.c | 587 +++++ flaim/external/w32/make/w32err.c | 51 + flaim/external/w32/make/w32err.h | 10 + flaim/external/w32/printf/build.bat | 33 + flaim/external/w32/printf/printf.cpp | 716 ++++++ flaim/gnumake.tar | Bin 2938062 -> 0 bytes flaim/gprintf.gnu | 207 -- flaim/make.exe | Bin 180224 -> 241664 bytes flaim/printf.exe | Bin 53248 -> 49152 bytes 61 files changed, 32065 insertions(+), 209 deletions(-) create mode 100644 flaim/external/w32/make/VERSION create mode 100644 flaim/external/w32/make/alloca.c create mode 100644 flaim/external/w32/make/amiga.h create mode 100644 flaim/external/w32/make/ar.c create mode 100644 flaim/external/w32/make/arscan.c create mode 100644 flaim/external/w32/make/build.bat create mode 100644 flaim/external/w32/make/commands.c create mode 100644 flaim/external/w32/make/commands.h create mode 100644 flaim/external/w32/make/config.h create mode 100644 flaim/external/w32/make/debug.h create mode 100644 flaim/external/w32/make/default.c create mode 100644 flaim/external/w32/make/dep.h create mode 100644 flaim/external/w32/make/dir.c create mode 100644 flaim/external/w32/make/dirent.c create mode 100644 flaim/external/w32/make/dirent.h create mode 100644 flaim/external/w32/make/expand.c create mode 100644 flaim/external/w32/make/file.c create mode 100644 flaim/external/w32/make/filedef.h create mode 100644 flaim/external/w32/make/fnmatch.c create mode 100644 flaim/external/w32/make/fnmatch.h create mode 100644 flaim/external/w32/make/function.c create mode 100644 flaim/external/w32/make/getloadavg.c create mode 100644 flaim/external/w32/make/getopt.c create mode 100644 flaim/external/w32/make/getopt.h create mode 100644 flaim/external/w32/make/getopt1.c create mode 100644 flaim/external/w32/make/gettext.h create mode 100644 flaim/external/w32/make/glob.c create mode 100644 flaim/external/w32/make/glob.h create mode 100644 flaim/external/w32/make/hash.c create mode 100644 flaim/external/w32/make/hash.h create mode 100644 flaim/external/w32/make/implicit.c create mode 100644 flaim/external/w32/make/job.c create mode 100644 flaim/external/w32/make/job.h create mode 100644 flaim/external/w32/make/main.c create mode 100644 flaim/external/w32/make/make.h create mode 100644 flaim/external/w32/make/misc.c create mode 100644 flaim/external/w32/make/misc_w32.c create mode 100644 flaim/external/w32/make/pathstuff.c create mode 100644 flaim/external/w32/make/pathstuff.h create mode 100644 flaim/external/w32/make/proc.h create mode 100644 flaim/external/w32/make/read.c create mode 100644 flaim/external/w32/make/remake.c create mode 100644 flaim/external/w32/make/remote-stub.c create mode 100644 flaim/external/w32/make/rule.c create mode 100644 flaim/external/w32/make/rule.h create mode 100644 flaim/external/w32/make/signame.c create mode 100644 flaim/external/w32/make/sub_proc.c create mode 100644 flaim/external/w32/make/sub_proc.h create mode 100644 flaim/external/w32/make/variable.c create mode 100644 flaim/external/w32/make/variable.h create mode 100644 flaim/external/w32/make/version.c create mode 100644 flaim/external/w32/make/vpath.c create mode 100644 flaim/external/w32/make/w32err.c create mode 100644 flaim/external/w32/make/w32err.h create mode 100644 flaim/external/w32/printf/build.bat create mode 100644 flaim/external/w32/printf/printf.cpp delete mode 100644 flaim/gnumake.tar delete mode 100644 flaim/gprintf.gnu diff --git a/flaim/Makefile b/flaim/Makefile index 930504b..5b814e2 100644 --- a/flaim/Makefile +++ b/flaim/Makefile @@ -22,7 +22,6 @@ # $Id: Makefile 3105 2006-01-11 11:14:10 -0700 (Wed, 11 Jan 2006) ahodgkinson $ #------------------------------------------------------------------------- - ############################################################################# # # Sample Usage: @@ -377,7 +376,7 @@ ifeq ($(host_os_family),win) allprereqs = $(subst /,\,$+) copycmd = copy /Y $(subst /,\,$(1)) $(subst /,\,$(2)) >NUL rmcmd = del /Q $(subst /,\,$(1)) - rmdircmd = cmd /C "rmdir /q /s $(subst /,\,$(1))" + rmdircmd = if exist $(subst /,\,$(1)) rmdir /q /s $(subst /,\,$(1)) mkdircmd = -if not exist $(subst /,\,$(1)) mkdir $(subst /,\,$(1)) >NUL runtest = cmd /C "cd $(subst /,\,$(test_dir)) && $(1) -d" else diff --git a/flaim/external/w32/make/VERSION b/flaim/external/w32/make/VERSION new file mode 100644 index 0000000..9b8a23c --- /dev/null +++ b/flaim/external/w32/make/VERSION @@ -0,0 +1 @@ +3.80 diff --git a/flaim/external/w32/make/alloca.c b/flaim/external/w32/make/alloca.c new file mode 100644 index 0000000..8f98b73 --- /dev/null +++ b/flaim/external/w32/make/alloca.c @@ -0,0 +1,504 @@ +/* alloca.c -- allocate automatically reclaimed memory + (Mostly) portable public-domain implementation -- D A Gwyn + + This implementation of the PWB library alloca function, + which is used to allocate space off the run-time stack so + that it is automatically reclaimed upon procedure exit, + was inspired by discussions with J. Q. Johnson of Cornell. + J.Otto Tennant contributed the Cray support. + + There are some preprocessor constants that can + be defined when compiling for your specific system, for + improved efficiency; however, the defaults should be okay. + + The general concept of this implementation is to keep + track of all alloca-allocated blocks, and reclaim any + that are found to be deeper in the stack than the current + invocation. This heuristic does not reclaim storage as + soon as it becomes invalid, but it will do so eventually. + + As a special case, alloca(0) reclaims storage without + allocating any. It is a good idea to use alloca(0) in + your main control loop, etc. to force garbage collection. */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#ifdef HAVE_STRING_H +#include +#endif +#ifdef HAVE_STDLIB_H +#include +#endif + +#ifdef emacs +#include "blockinput.h" +#endif + +/* If compiling with GCC 2, this file's not needed. */ +#if !defined (__GNUC__) || __GNUC__ < 2 + +/* If someone has defined alloca as a macro, + there must be some other way alloca is supposed to work. */ +#ifndef alloca + +#ifdef emacs +#ifdef static +/* actually, only want this if static is defined as "" + -- this is for usg, in which emacs must undefine static + in order to make unexec workable + */ +#ifndef STACK_DIRECTION +you +lose +-- must know STACK_DIRECTION at compile-time +#endif /* STACK_DIRECTION undefined */ +#endif /* static */ +#endif /* emacs */ + +/* If your stack is a linked list of frames, you have to + provide an "address metric" ADDRESS_FUNCTION macro. */ + +#if defined (CRAY) && defined (CRAY_STACKSEG_END) +long i00afunc (); +#define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg)) +#else +#define ADDRESS_FUNCTION(arg) &(arg) +#endif + +#if __STDC__ +typedef void *pointer; +#else +typedef char *pointer; +#endif + +#ifndef NULL +#define NULL 0 +#endif + +/* Different portions of Emacs need to call different versions of + malloc. The Emacs executable needs alloca to call xmalloc, because + ordinary malloc isn't protected from input signals. On the other + hand, the utilities in lib-src need alloca to call malloc; some of + them are very simple, and don't have an xmalloc routine. + + Non-Emacs programs expect this to call use xmalloc. + + Callers below should use malloc. */ + +#ifndef emacs +#define malloc xmalloc +#endif +extern pointer malloc (); + +/* Define STACK_DIRECTION if you know the direction of stack + growth for your system; otherwise it will be automatically + deduced at run-time. + + STACK_DIRECTION > 0 => grows toward higher addresses + STACK_DIRECTION < 0 => grows toward lower addresses + STACK_DIRECTION = 0 => direction of growth unknown */ + +#ifndef STACK_DIRECTION +#define STACK_DIRECTION 0 /* Direction unknown. */ +#endif + +#if STACK_DIRECTION != 0 + +#define STACK_DIR STACK_DIRECTION /* Known at compile-time. */ + +#else /* STACK_DIRECTION == 0; need run-time code. */ + +static int stack_dir; /* 1 or -1 once known. */ +#define STACK_DIR stack_dir + +static void +find_stack_direction () +{ + static char *addr = NULL; /* Address of first `dummy', once known. */ + auto char dummy; /* To get stack address. */ + + if (addr == NULL) + { /* Initial entry. */ + addr = ADDRESS_FUNCTION (dummy); + + find_stack_direction (); /* Recurse once. */ + } + else + { + /* Second entry. */ + if (ADDRESS_FUNCTION (dummy) > addr) + stack_dir = 1; /* Stack grew upward. */ + else + stack_dir = -1; /* Stack grew downward. */ + } +} + +#endif /* STACK_DIRECTION == 0 */ + +/* An "alloca header" is used to: + (a) chain together all alloca'ed blocks; + (b) keep track of stack depth. + + It is very important that sizeof(header) agree with malloc + alignment chunk size. The following default should work okay. */ + +#ifndef ALIGN_SIZE +#define ALIGN_SIZE sizeof(double) +#endif + +typedef union hdr +{ + char align[ALIGN_SIZE]; /* To force sizeof(header). */ + struct + { + union hdr *next; /* For chaining headers. */ + char *deep; /* For stack depth measure. */ + } h; +} header; + +static header *last_alloca_header = NULL; /* -> last alloca header. */ + +/* Return a pointer to at least SIZE bytes of storage, + which will be automatically reclaimed upon exit from + the procedure that called alloca. Originally, this space + was supposed to be taken from the current stack frame of the + caller, but that method cannot be made to work for some + implementations of C, for example under Gould's UTX/32. */ + +pointer +alloca (size) + unsigned size; +{ + auto char probe; /* Probes stack depth: */ + register char *depth = ADDRESS_FUNCTION (probe); + +#if STACK_DIRECTION == 0 + if (STACK_DIR == 0) /* Unknown growth direction. */ + find_stack_direction (); +#endif + + /* Reclaim garbage, defined as all alloca'd storage that + was allocated from deeper in the stack than currently. */ + + { + register header *hp; /* Traverses linked list. */ + +#ifdef emacs + BLOCK_INPUT; +#endif + + for (hp = last_alloca_header; hp != NULL;) + if ((STACK_DIR > 0 && hp->h.deep > depth) + || (STACK_DIR < 0 && hp->h.deep < depth)) + { + register header *np = hp->h.next; + + free ((pointer) hp); /* Collect garbage. */ + + hp = np; /* -> next header. */ + } + else + break; /* Rest are not deeper. */ + + last_alloca_header = hp; /* -> last valid storage. */ + +#ifdef emacs + UNBLOCK_INPUT; +#endif + } + + if (size == 0) + return NULL; /* No allocation required. */ + + /* Allocate combined header + user data storage. */ + + { + register pointer new = malloc (sizeof (header) + size); + /* Address of header. */ + + if (new == 0) + abort(); + + ((header *) new)->h.next = last_alloca_header; + ((header *) new)->h.deep = depth; + + last_alloca_header = (header *) new; + + /* User storage begins just after header. */ + + return (pointer) ((char *) new + sizeof (header)); + } +} + +#if defined (CRAY) && defined (CRAY_STACKSEG_END) + +#ifdef DEBUG_I00AFUNC +#include +#endif + +#ifndef CRAY_STACK +#define CRAY_STACK +#ifndef CRAY2 +/* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */ +struct stack_control_header + { + long shgrow:32; /* Number of times stack has grown. */ + long shaseg:32; /* Size of increments to stack. */ + long shhwm:32; /* High water mark of stack. */ + long shsize:32; /* Current size of stack (all segments). */ + }; + +/* The stack segment linkage control information occurs at + the high-address end of a stack segment. (The stack + grows from low addresses to high addresses.) The initial + part of the stack segment linkage control information is + 0200 (octal) words. This provides for register storage + for the routine which overflows the stack. */ + +struct stack_segment_linkage + { + long ss[0200]; /* 0200 overflow words. */ + long sssize:32; /* Number of words in this segment. */ + long ssbase:32; /* Offset to stack base. */ + long:32; + long sspseg:32; /* Offset to linkage control of previous + segment of stack. */ + long:32; + long sstcpt:32; /* Pointer to task common address block. */ + long sscsnm; /* Private control structure number for + microtasking. */ + long ssusr1; /* Reserved for user. */ + long ssusr2; /* Reserved for user. */ + long sstpid; /* Process ID for pid based multi-tasking. */ + long ssgvup; /* Pointer to multitasking thread giveup. */ + long sscray[7]; /* Reserved for Cray Research. */ + long ssa0; + long ssa1; + long ssa2; + long ssa3; + long ssa4; + long ssa5; + long ssa6; + long ssa7; + long sss0; + long sss1; + long sss2; + long sss3; + long sss4; + long sss5; + long sss6; + long sss7; + }; + +#else /* CRAY2 */ +/* The following structure defines the vector of words + returned by the STKSTAT library routine. */ +struct stk_stat + { + long now; /* Current total stack size. */ + long maxc; /* Amount of contiguous space which would + be required to satisfy the maximum + stack demand to date. */ + long high_water; /* Stack high-water mark. */ + long overflows; /* Number of stack overflow ($STKOFEN) calls. */ + long hits; /* Number of internal buffer hits. */ + long extends; /* Number of block extensions. */ + long stko_mallocs; /* Block allocations by $STKOFEN. */ + long underflows; /* Number of stack underflow calls ($STKRETN). */ + long stko_free; /* Number of deallocations by $STKRETN. */ + long stkm_free; /* Number of deallocations by $STKMRET. */ + long segments; /* Current number of stack segments. */ + long maxs; /* Maximum number of stack segments so far. */ + long pad_size; /* Stack pad size. */ + long current_address; /* Current stack segment address. */ + long current_size; /* Current stack segment size. This + number is actually corrupted by STKSTAT to + include the fifteen word trailer area. */ + long initial_address; /* Address of initial segment. */ + long initial_size; /* Size of initial segment. */ + }; + +/* The following structure describes the data structure which trails + any stack segment. I think that the description in 'asdef' is + out of date. I only describe the parts that I am sure about. */ + +struct stk_trailer + { + long this_address; /* Address of this block. */ + long this_size; /* Size of this block (does not include + this trailer). */ + long unknown2; + long unknown3; + long link; /* Address of trailer block of previous + segment. */ + long unknown5; + long unknown6; + long unknown7; + long unknown8; + long unknown9; + long unknown10; + long unknown11; + long unknown12; + long unknown13; + long unknown14; + }; + +#endif /* CRAY2 */ +#endif /* not CRAY_STACK */ + +#ifdef CRAY2 +/* Determine a "stack measure" for an arbitrary ADDRESS. + I doubt that "lint" will like this much. */ + +static long +i00afunc (long *address) +{ + struct stk_stat status; + struct stk_trailer *trailer; + long *block, size; + long result = 0; + + /* We want to iterate through all of the segments. The first + step is to get the stack status structure. We could do this + more quickly and more directly, perhaps, by referencing the + $LM00 common block, but I know that this works. */ + + STKSTAT (&status); + + /* Set up the iteration. */ + + trailer = (struct stk_trailer *) (status.current_address + + status.current_size + - 15); + + /* There must be at least one stack segment. Therefore it is + a fatal error if "trailer" is null. */ + + if (trailer == 0) + abort (); + + /* Discard segments that do not contain our argument address. */ + + while (trailer != 0) + { + block = (long *) trailer->this_address; + size = trailer->this_size; + if (block == 0 || size == 0) + abort (); + trailer = (struct stk_trailer *) trailer->link; + if ((block <= address) && (address < (block + size))) + break; + } + + /* Set the result to the offset in this segment and add the sizes + of all predecessor segments. */ + + result = address - block; + + if (trailer == 0) + { + return result; + } + + do + { + if (trailer->this_size <= 0) + abort (); + result += trailer->this_size; + trailer = (struct stk_trailer *) trailer->link; + } + while (trailer != 0); + + /* We are done. Note that if you present a bogus address (one + not in any segment), you will get a different number back, formed + from subtracting the address of the first block. This is probably + not what you want. */ + + return (result); +} + +#else /* not CRAY2 */ +/* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP. + Determine the number of the cell within the stack, + given the address of the cell. The purpose of this + routine is to linearize, in some sense, stack addresses + for alloca. */ + +static long +i00afunc (long address) +{ + long stkl = 0; + + long size, pseg, this_segment, stack; + long result = 0; + + struct stack_segment_linkage *ssptr; + + /* Register B67 contains the address of the end of the + current stack segment. If you (as a subprogram) store + your registers on the stack and find that you are past + the contents of B67, you have overflowed the segment. + + B67 also points to the stack segment linkage control + area, which is what we are really interested in. */ + + stkl = CRAY_STACKSEG_END (); + ssptr = (struct stack_segment_linkage *) stkl; + + /* If one subtracts 'size' from the end of the segment, + one has the address of the first word of the segment. + + If this is not the first segment, 'pseg' will be + nonzero. */ + + pseg = ssptr->sspseg; + size = ssptr->sssize; + + this_segment = stkl - size; + + /* It is possible that calling this routine itself caused + a stack overflow. Discard stack segments which do not + contain the target address. */ + + while (!(this_segment <= address && address <= stkl)) + { +#ifdef DEBUG_I00AFUNC + fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl); +#endif + if (pseg == 0) + break; + stkl = stkl - pseg; + ssptr = (struct stack_segment_linkage *) stkl; + size = ssptr->sssize; + pseg = ssptr->sspseg; + this_segment = stkl - size; + } + + result = address - this_segment; + + /* If you subtract pseg from the current end of the stack, + you get the address of the previous stack segment's end. + This seems a little convoluted to me, but I'll bet you save + a cycle somewhere. */ + + while (pseg != 0) + { +#ifdef DEBUG_I00AFUNC + fprintf (stderr, "%011o %011o\n", pseg, size); +#endif + stkl = stkl - pseg; + ssptr = (struct stack_segment_linkage *) stkl; + size = ssptr->sssize; + pseg = ssptr->sspseg; + result += size; + } + return (result); +} + +#endif /* not CRAY2 */ +#endif /* CRAY */ + +#endif /* no alloca */ +#endif /* not GCC version 2 */ diff --git a/flaim/external/w32/make/amiga.h b/flaim/external/w32/make/amiga.h new file mode 100644 index 0000000..99a1c59 --- /dev/null +++ b/flaim/external/w32/make/amiga.h @@ -0,0 +1,22 @@ +/* Definitions for amiga specific things +Copyright (C) 1995, 1996 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, +MA 02111-1307, USA. */ + +extern int MyExecute PARAMS ((char ** argv)); +extern char * wildcard_expansion PARAMS ((char * wc, char * o)); + diff --git a/flaim/external/w32/make/ar.c b/flaim/external/w32/make/ar.c new file mode 100644 index 0000000..286be55 --- /dev/null +++ b/flaim/external/w32/make/ar.c @@ -0,0 +1,329 @@ +/* Interface to `ar' archives for GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1997, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" + +#ifndef NO_ARCHIVES + +#include "filedef.h" +#include "dep.h" +#include + +/* Defined in arscan.c. */ +extern long int ar_scan PARAMS ((char *archive, long int (*function) (), long int arg)); +extern int ar_name_equal PARAMS ((char *name, char *mem, int truncated)); +#ifndef VMS +extern int ar_member_touch PARAMS ((char *arname, char *memname)); +#endif + +/* Return nonzero if NAME is an archive-member reference, zero if not. + An archive-member reference is a name like `lib(member)'. + If a name like `lib((entry))' is used, a fatal error is signaled at + the attempt to use this unsupported feature. */ + +int +ar_name (name) + char *name; +{ + char *p = strchr (name, '('); + char *end; + + if (p == 0 || p == name) + return 0; + + end = p + strlen (p) - 1; + if (*end != ')') + return 0; + + if (p[1] == '(' && end[-1] == ')') + fatal (NILF, _("attempt to use unsupported feature: `%s'"), name); + + return 1; +} + + +/* Parse the archive-member reference NAME into the archive and member names. + Put the malloc'd archive name in *ARNAME_P if ARNAME_P is non-nil; + put the malloc'd member name in *MEMNAME_P if MEMNAME_P is non-nil. */ + +void +ar_parse_name (name, arname_p, memname_p) + char *name, **arname_p, **memname_p; +{ + char *p = strchr (name, '('), *end = name + strlen (name) - 1; + + if (arname_p != 0) + *arname_p = savestring (name, p - name); + + if (memname_p != 0) + *memname_p = savestring (p + 1, end - (p + 1)); +} + +static long int ar_member_date_1 PARAMS ((int desc, char *mem, int truncated, long int hdrpos, + long int datapos, long int size, long int date, int uid, int gid, int mode, char *name)); + +/* Return the modtime of NAME. */ + +time_t +ar_member_date (name) + char *name; +{ + char *arname; + int arname_used = 0; + char *memname; + long int val; + + ar_parse_name (name, &arname, &memname); + + /* Make sure we know the modtime of the archive itself because we are + likely to be called just before commands to remake a member are run, + and they will change the archive itself. + + But we must be careful not to enter_file the archive itself if it does + not exist, because pattern_search assumes that files found in the data + base exist or can be made. */ + { + struct file *arfile; + arfile = lookup_file (arname); + if (arfile == 0 && file_exists_p (arname)) + { + arfile = enter_file (arname); + arname_used = 1; + } + + if (arfile != 0) + (void) f_mtime (arfile, 0); + } + + val = ar_scan (arname, ar_member_date_1, (long int) memname); + + if (!arname_used) + free (arname); + free (memname); + + return (val <= 0 ? (time_t) -1 : (time_t) val); +} + +/* This function is called by `ar_scan' to find which member to look at. */ + +/* ARGSUSED */ +static long int +ar_member_date_1 (desc, mem, truncated, + hdrpos, datapos, size, date, uid, gid, mode, name) + int desc; + char *mem; + int truncated; + long int hdrpos, datapos, size, date; + int uid, gid, mode; + char *name; +{ + return ar_name_equal (name, mem, truncated) ? date : 0; +} + +/* Set the archive-member NAME's modtime to now. */ + +#ifdef VMS +int +ar_touch (name) + char *name; +{ + error (NILF, _("touch archive member is not available on VMS")); + return -1; +} +#else +int +ar_touch (name) + char *name; +{ + char *arname, *memname; + int arname_used = 0; + register int val; + + ar_parse_name (name, &arname, &memname); + + /* Make sure we know the modtime of the archive itself before we + touch the member, since this will change the archive itself. */ + { + struct file *arfile; + arfile = lookup_file (arname); + if (arfile == 0) + { + arfile = enter_file (arname); + arname_used = 1; + } + + (void) f_mtime (arfile, 0); + } + + val = 1; + switch (ar_member_touch (arname, memname)) + { + case -1: + error (NILF, _("touch: Archive `%s' does not exist"), arname); + break; + case -2: + error (NILF, _("touch: `%s' is not a valid archive"), arname); + break; + case -3: + perror_with_name ("touch: ", arname); + break; + case 1: + error (NILF, + _("touch: Member `%s' does not exist in `%s'"), memname, arname); + break; + case 0: + val = 0; + break; + default: + error (NILF, + _("touch: Bad return code from ar_member_touch on `%s'"), name); + } + + if (!arname_used) + free (arname); + free (memname); + + return val; +} +#endif /* !VMS */ + +/* State of an `ar_glob' run, passed to `ar_glob_match'. */ + +struct ar_glob_state + { + char *arname; + char *pattern; + unsigned int size; + struct nameseq *chain; + unsigned int n; + }; + +/* This function is called by `ar_scan' to match one archive + element against the pattern in STATE. */ + +static long int +ar_glob_match (desc, mem, truncated, + hdrpos, datapos, size, date, uid, gid, mode, + state) + int desc; + char *mem; + int truncated; + long int hdrpos, datapos, size, date; + int uid, gid, mode; + struct ar_glob_state *state; +{ + if (fnmatch (state->pattern, mem, FNM_PATHNAME|FNM_PERIOD) == 0) + { + /* We have a match. Add it to the chain. */ + struct nameseq *new = (struct nameseq *) xmalloc (state->size); + new->name = concat (state->arname, mem, ")"); + new->next = state->chain; + state->chain = new; + ++state->n; + } + + return 0L; +} + +/* Return nonzero if PATTERN contains any metacharacters. + Metacharacters can be quoted with backslashes if QUOTE is nonzero. */ +static int +glob_pattern_p (pattern, quote) + const char *pattern; + const int quote; +{ + register const char *p; + int open = 0; + + for (p = pattern; *p != '\0'; ++p) + switch (*p) + { + case '?': + case '*': + return 1; + + case '\\': + if (quote) + ++p; + break; + + case '[': + open = 1; + break; + + case ']': + if (open) + return 1; + break; + } + + return 0; +} + +/* Glob for MEMBER_PATTERN in archive ARNAME. + Return a malloc'd chain of matching elements (or nil if none). */ + +struct nameseq * +ar_glob (arname, member_pattern, size) + char *arname, *member_pattern; + unsigned int size; +{ + struct ar_glob_state state; + char **names; + struct nameseq *n; + unsigned int i; + + if (! glob_pattern_p (member_pattern, 1)) + return 0; + + /* Scan the archive for matches. + ar_glob_match will accumulate them in STATE.chain. */ + i = strlen (arname); + state.arname = (char *) alloca (i + 2); + bcopy (arname, state.arname, i); + state.arname[i] = '('; + state.arname[i + 1] = '\0'; + state.pattern = member_pattern; + state.size = size; + state.chain = 0; + state.n = 0; + (void) ar_scan (arname, ar_glob_match, (long int) &state); + + if (state.chain == 0) + return 0; + + /* Now put the names into a vector for sorting. */ + names = (char **) alloca (state.n * sizeof (char *)); + i = 0; + for (n = state.chain; n != 0; n = n->next) + names[i++] = n->name; + + /* Sort them alphabetically. */ + qsort ((char *) names, i, sizeof (*names), alpha_compare); + + /* Put them back into the chain in the sorted order. */ + i = 0; + for (n = state.chain; n != 0; n = n->next) + n->name = names[i++]; + + return state.chain; +} + +#endif /* Not NO_ARCHIVES. */ diff --git a/flaim/external/w32/make/arscan.c b/flaim/external/w32/make/arscan.c new file mode 100644 index 0000000..fc003e9 --- /dev/null +++ b/flaim/external/w32/make/arscan.c @@ -0,0 +1,861 @@ +/* Library function for scanning an archive file. +Copyright (C) 1987,89,91,92,93,94,95,97 Free Software Foundation, Inc. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +This program 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, +USA. */ + +#include "make.h" + +#ifdef HAVE_FCNTL_H +#include +#else +#include +#endif + +#ifndef NO_ARCHIVES + +#ifdef VMS +#include +#include +#include +#include +#include +#if __DECC +#include +#include +#endif + +static void *VMS_lib_idx; + +static char *VMS_saved_memname; + +static time_t VMS_member_date; + +static long int (*VMS_function) (); + +static int +VMS_get_member_info (module, rfa) + struct dsc$descriptor_s *module; + unsigned long *rfa; +{ + int status, i; + long int fnval; + + time_t val; + + static struct dsc$descriptor_s bufdesc = + { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL }; + + struct mhddef *mhd; + char filename[128]; + + bufdesc.dsc$a_pointer = filename; + bufdesc.dsc$w_length = sizeof (filename); + + status = lbr$set_module (&VMS_lib_idx, rfa, &bufdesc, + &bufdesc.dsc$w_length, 0); + if (! (status & 1)) + { + error (NILF, _("lbr$set_module failed to extract module info, status = %d"), + status); + + lbr$close (&VMS_lib_idx); + + return 0; + } + + mhd = (struct mhddef *) filename; + +#ifdef __DECC + /* John Fowler writes this is needed in his environment, + * but that decc$fix_time() isn't documented to work this way. Let me + * know if this causes problems in other VMS environments. + */ + val = decc$fix_time (&mhd->mhd$l_datim) + timezone - daylight*3600; +#endif + + for (i = 0; i < module->dsc$w_length; i++) + filename[i] = _tolower ((unsigned char)module->dsc$a_pointer[i]); + + filename[i] = '\0'; + + VMS_member_date = (time_t) -1; + + fnval = + (*VMS_function) (-1, filename, 0, 0, 0, 0, val, 0, 0, 0, + VMS_saved_memname); + + if (fnval) + { + VMS_member_date = fnval; + return 0; + } + else + return 1; +} + +/* Takes three arguments ARCHIVE, FUNCTION and ARG. + + Open the archive named ARCHIVE, find its members one by one, + and for each one call FUNCTION with the following arguments: + archive file descriptor for reading the data, + member name, + member name might be truncated flag, + member header position in file, + member data position in file, + member data size, + member date, + member uid, + member gid, + member protection mode, + ARG. + + NOTE: on VMS systems, only name, date, and arg are meaningful! + + The descriptor is poised to read the data of the member + when FUNCTION is called. It does not matter how much + data FUNCTION reads. + + If FUNCTION returns nonzero, we immediately return + what FUNCTION returned. + + Returns -1 if archive does not exist, + Returns -2 if archive has invalid format. + Returns 0 if have scanned successfully. */ + +long int +ar_scan (archive, function, arg) + char *archive; + long int (*function) (); + long int arg; +{ + char *p; + + static struct dsc$descriptor_s libdesc = + { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL }; + + unsigned long func = LBR$C_READ; + unsigned long type = LBR$C_TYP_UNK; + unsigned long index = 1; + + int status; + + status = lbr$ini_control (&VMS_lib_idx, &func, &type, 0); + + if (! (status & 1)) + { + error (NILF, _("lbr$ini_control failed with status = %d"),status); + return -2; + } + + libdesc.dsc$a_pointer = archive; + libdesc.dsc$w_length = strlen (archive); + + status = lbr$open (&VMS_lib_idx, &libdesc, 0, 0, 0, 0, 0); + + if (! (status & 1)) + { + error (NILF, _("unable to open library `%s' to lookup member `%s'"), + archive, (char *)arg); + return -1; + } + + VMS_saved_memname = (char *)arg; + + /* For comparison, delete .obj from arg name. */ + + p = strrchr (VMS_saved_memname, '.'); + if (p) + *p = '\0'; + + VMS_function = function; + + VMS_member_date = (time_t) -1; + lbr$get_index (&VMS_lib_idx, &index, VMS_get_member_info, 0); + + /* Undo the damage. */ + if (p) + *p = '.'; + + lbr$close (&VMS_lib_idx); + + return VMS_member_date > 0 ? VMS_member_date : 0; +} + +#else /* !VMS */ + +/* SCO Unix's compiler defines both of these. */ +#ifdef M_UNIX +#undef M_XENIX +#endif + +/* On the sun386i and in System V rel 3, ar.h defines two different archive + formats depending upon whether you have defined PORTAR (normal) or PORT5AR + (System V Release 1). There is no default, one or the other must be defined + to have a nonzero value. */ + +#if (!defined (PORTAR) || PORTAR == 0) && (!defined (PORT5AR) || PORT5AR == 0) +#undef PORTAR +#ifdef M_XENIX +/* According to Jim Sievert , for SCO XENIX defining + PORTAR to 1 gets the wrong archive format, and defining it to 0 gets the + right one. */ +#define PORTAR 0 +#else +#define PORTAR 1 +#endif +#endif + +/* On AIX, define these symbols to be sure to get both archive formats. + AIX 4.3 introduced the "big" archive format to support 64-bit object + files, so on AIX 4.3 systems we need to support both the "normal" and + "big" archive formats. An archive's format is indicated in the + "fl_magic" field of the "FL_HDR" structure. For a normal archive, + this field will be the string defined by the AIAMAG symbol. For a + "big" archive, it will be the string defined by the AIAMAGBIG symbol + (at least on AIX it works this way). + + Note: we'll define these symbols regardless of which AIX version + we're compiling on, but this is okay since we'll use the new symbols + only if they're present. */ +#ifdef _AIX +# define __AR_SMALL__ +# define __AR_BIG__ +#endif + +#ifndef WINDOWS32 +# ifndef __BEOS__ +# include +# else + /* BeOS 5 doesn't have but has archives in the same format + * as many other Unices. This was taken from GNU binutils for BeOS. + */ +# define ARMAG "!\n" /* String that begins an archive file. */ +# define SARMAG 8 /* Size of that string. */ +# define ARFMAG "`\n" /* String in ar_fmag at end of each header. */ +struct ar_hdr + { + char ar_name[16]; /* Member file name, sometimes / terminated. */ + char ar_date[12]; /* File date, decimal seconds since Epoch. */ + char ar_uid[6], ar_gid[6]; /* User and group IDs, in ASCII decimal. */ + char ar_mode[8]; /* File mode, in ASCII octal. */ + char ar_size[10]; /* File size, in ASCII decimal. */ + char ar_fmag[2]; /* Always contains ARFMAG. */ + }; +# endif +#else +/* These should allow us to read Windows (VC++) libraries (according to Frank + * Libbrecht ) + */ +# include +# include +# include +# define ARMAG IMAGE_ARCHIVE_START +# define SARMAG IMAGE_ARCHIVE_START_SIZE +# define ar_hdr _IMAGE_ARCHIVE_MEMBER_HEADER +# define ar_name Name +# define ar_mode Mode +# define ar_size Size +# define ar_date Date +# define ar_uid UserID +# define ar_gid GroupID +#endif + +/* Cray's apparently defines this. */ +#ifndef AR_HDR_SIZE +# define AR_HDR_SIZE (sizeof (struct ar_hdr)) +#endif + +/* Takes three arguments ARCHIVE, FUNCTION and ARG. + + Open the archive named ARCHIVE, find its members one by one, + and for each one call FUNCTION with the following arguments: + archive file descriptor for reading the data, + member name, + member name might be truncated flag, + member header position in file, + member data position in file, + member data size, + member date, + member uid, + member gid, + member protection mode, + ARG. + + The descriptor is poised to read the data of the member + when FUNCTION is called. It does not matter how much + data FUNCTION reads. + + If FUNCTION returns nonzero, we immediately return + what FUNCTION returned. + + Returns -1 if archive does not exist, + Returns -2 if archive has invalid format. + Returns 0 if have scanned successfully. */ + +long int +ar_scan (archive, function, arg) + char *archive; + long int (*function) (); + long int arg; +{ +#ifdef AIAMAG + FL_HDR fl_header; +#ifdef AIAMAGBIG + int big_archive = 0; + FL_HDR_BIG fl_header_big; +#endif +#else + int long_name = 0; +#endif + char *namemap = 0; + register int desc = open (archive, O_RDONLY, 0); + if (desc < 0) + return -1; +#ifdef SARMAG + { + char buf[SARMAG]; + register int nread = read (desc, buf, SARMAG); + if (nread != SARMAG || bcmp (buf, ARMAG, SARMAG)) + { + (void) close (desc); + return -2; + } + } +#else +#ifdef AIAMAG + { + register int nread = read (desc, (char *) &fl_header, FL_HSZ); + + if (nread != FL_HSZ) + { + (void) close (desc); + return -2; + } +#ifdef AIAMAGBIG + /* If this is a "big" archive, then set the flag and + re-read the header into the "big" structure. */ + if (!bcmp (fl_header.fl_magic, AIAMAGBIG, SAIAMAG)) + { + big_archive = 1; + + /* seek back to beginning of archive */ + if (lseek (desc, 0, 0) < 0) + { + (void) close (desc); + return -2; + } + + /* re-read the header into the "big" structure */ + nread = read (desc, (char *) &fl_header_big, FL_HSZ_BIG); + if (nread != FL_HSZ_BIG) + { + (void) close (desc); + return -2; + } + } + else +#endif + /* Check to make sure this is a "normal" archive. */ + if (bcmp (fl_header.fl_magic, AIAMAG, SAIAMAG)) + { + (void) close (desc); + return -2; + } + } +#else + { +#ifndef M_XENIX + int buf; +#else + unsigned short int buf; +#endif + register int nread = read(desc, &buf, sizeof (buf)); + if (nread != sizeof (buf) || buf != ARMAG) + { + (void) close (desc); + return -2; + } + } +#endif +#endif + + /* Now find the members one by one. */ + { +#ifdef SARMAG + register long int member_offset = SARMAG; +#else +#ifdef AIAMAG + long int member_offset; + long int last_member_offset; + +#ifdef AIAMAGBIG + if ( big_archive ) + { + sscanf (fl_header_big.fl_fstmoff, "%20ld", &member_offset); + sscanf (fl_header_big.fl_lstmoff, "%20ld", &last_member_offset); + } + else +#endif + { + sscanf (fl_header.fl_fstmoff, "%12ld", &member_offset); + sscanf (fl_header.fl_lstmoff, "%12ld", &last_member_offset); + } + + if (member_offset == 0) + { + /* Empty archive. */ + close (desc); + return 0; + } +#else +#ifndef M_XENIX + register long int member_offset = sizeof (int); +#else /* Xenix. */ + register long int member_offset = sizeof (unsigned short int); +#endif /* Not Xenix. */ +#endif +#endif + + while (1) + { + register int nread; + struct ar_hdr member_header; +#ifdef AIAMAGBIG + struct ar_hdr_big member_header_big; +#endif +#ifdef AIAMAG + char name[256]; + int name_len; + long int dateval; + int uidval, gidval; + long int data_offset; +#else + char namebuf[sizeof member_header.ar_name + 1]; + char *name; + int is_namemap; /* Nonzero if this entry maps long names. */ +#endif + long int eltsize; + int eltmode; + long int fnval; + + if (lseek (desc, member_offset, 0) < 0) + { + (void) close (desc); + return -2; + } + +#ifdef AIAMAG +#define AR_MEMHDR_SZ(x) (sizeof(x) - sizeof (x._ar_name)) + +#ifdef AIAMAGBIG + if (big_archive) + { + nread = read (desc, (char *) &member_header_big, + AR_MEMHDR_SZ(member_header_big) ); + + if (nread != AR_MEMHDR_SZ(member_header_big)) + { + (void) close (desc); + return -2; + } + + sscanf (member_header_big.ar_namlen, "%4d", &name_len); + nread = read (desc, name, name_len); + + if (nread != name_len) + { + (void) close (desc); + return -2; + } + + name[name_len] = 0; + + sscanf (member_header_big.ar_date, "%12ld", &dateval); + sscanf (member_header_big.ar_uid, "%12d", &uidval); + sscanf (member_header_big.ar_gid, "%12d", &gidval); + sscanf (member_header_big.ar_mode, "%12o", &eltmode); + sscanf (member_header_big.ar_size, "%20ld", &eltsize); + + data_offset = (member_offset + AR_MEMHDR_SZ(member_header_big) + + name_len + 2); + } + else +#endif + { + nread = read (desc, (char *) &member_header, + AR_MEMHDR_SZ(member_header) ); + + if (nread != AR_MEMHDR_SZ(member_header)) + { + (void) close (desc); + return -2; + } + + sscanf (member_header.ar_namlen, "%4d", &name_len); + nread = read (desc, name, name_len); + + if (nread != name_len) + { + (void) close (desc); + return -2; + } + + name[name_len] = 0; + + sscanf (member_header.ar_date, "%12ld", &dateval); + sscanf (member_header.ar_uid, "%12d", &uidval); + sscanf (member_header.ar_gid, "%12d", &gidval); + sscanf (member_header.ar_mode, "%12o", &eltmode); + sscanf (member_header.ar_size, "%12ld", &eltsize); + + data_offset = (member_offset + AR_MEMHDR_SZ(member_header) + + name_len + 2); + } + data_offset += data_offset % 2; + + fnval = + (*function) (desc, name, 0, + member_offset, data_offset, eltsize, + dateval, uidval, gidval, + eltmode, arg); + +#else /* Not AIAMAG. */ + nread = read (desc, (char *) &member_header, AR_HDR_SIZE); + if (nread == 0) + /* No data left means end of file; that is OK. */ + break; + + if (nread != AR_HDR_SIZE +#if defined(ARFMAG) || defined(ARFZMAG) + || ( +# ifdef ARFMAG + bcmp (member_header.ar_fmag, ARFMAG, 2) +# else + 1 +# endif + && +# ifdef ARFZMAG + bcmp (member_header.ar_fmag, ARFZMAG, 2) +# else + 1 +# endif + ) +#endif + ) + { + (void) close (desc); + return -2; + } + + name = namebuf; + bcopy (member_header.ar_name, name, sizeof member_header.ar_name); + { + register char *p = name + sizeof member_header.ar_name; + do + *p = '\0'; + while (p > name && *--p == ' '); + +#ifndef AIAMAG + /* If the member name is "//" or "ARFILENAMES/" this may be + a list of file name mappings. The maximum file name + length supported by the standard archive format is 14 + characters. This member will actually always be the + first or second entry in the archive, but we don't check + that. */ + is_namemap = (!strcmp (name, "//") + || !strcmp (name, "ARFILENAMES/")); +#endif /* Not AIAMAG. */ + /* On some systems, there is a slash after each member name. */ + if (*p == '/') + *p = '\0'; + +#ifndef AIAMAG + /* If the member name starts with a space or a slash, this + is an index into the file name mappings (used by GNU ar). + Otherwise if the member name looks like #1/NUMBER the + real member name appears in the element data (used by + 4.4BSD). */ + if (! is_namemap + && (name[0] == ' ' || name[0] == '/') + && namemap != 0) + { + name = namemap + atoi (name + 1); + long_name = 1; + } + else if (name[0] == '#' + && name[1] == '1' + && name[2] == '/') + { + int namesize = atoi (name + 3); + + name = (char *) alloca (namesize + 1); + nread = read (desc, name, namesize); + if (nread != namesize) + { + close (desc); + return -2; + } + name[namesize] = '\0'; + + long_name = 1; + } +#endif /* Not AIAMAG. */ + } + +#ifndef M_XENIX + sscanf (member_header.ar_mode, "%o", &eltmode); + eltsize = atol (member_header.ar_size); +#else /* Xenix. */ + eltmode = (unsigned short int) member_header.ar_mode; + eltsize = member_header.ar_size; +#endif /* Not Xenix. */ + + fnval = + (*function) (desc, name, ! long_name, member_offset, + member_offset + AR_HDR_SIZE, eltsize, +#ifndef M_XENIX + atol (member_header.ar_date), + atoi (member_header.ar_uid), + atoi (member_header.ar_gid), +#else /* Xenix. */ + member_header.ar_date, + member_header.ar_uid, + member_header.ar_gid, +#endif /* Not Xenix. */ + eltmode, arg); + +#endif /* AIAMAG. */ + + if (fnval) + { + (void) close (desc); + return fnval; + } + +#ifdef AIAMAG + if (member_offset == last_member_offset) + /* End of the chain. */ + break; + +#ifdef AIAMAGBIG + if (big_archive) + sscanf (member_header_big.ar_nxtmem, "%20ld", &member_offset); + else +#endif + sscanf (member_header.ar_nxtmem, "%12ld", &member_offset); + + if (lseek (desc, member_offset, 0) != member_offset) + { + (void) close (desc); + return -2; + } +#else + + /* If this member maps archive names, we must read it in. The + name map will always precede any members whose names must + be mapped. */ + if (is_namemap) + { + char *clear; + char *limit; + + namemap = (char *) alloca (eltsize); + nread = read (desc, namemap, eltsize); + if (nread != eltsize) + { + (void) close (desc); + return -2; + } + + /* The names are separated by newlines. Some formats have + a trailing slash. Null terminate the strings for + convenience. */ + limit = namemap + eltsize; + for (clear = namemap; clear < limit; clear++) + { + if (*clear == '\n') + { + *clear = '\0'; + if (clear[-1] == '/') + clear[-1] = '\0'; + } + } + + is_namemap = 0; + } + + member_offset += AR_HDR_SIZE + eltsize; + if (member_offset % 2 != 0) + member_offset++; +#endif + } + } + + close (desc); + return 0; +} +#endif /* !VMS */ + +/* Return nonzero iff NAME matches MEM. + If TRUNCATED is nonzero, MEM may be truncated to + sizeof (struct ar_hdr.ar_name) - 1. */ + +int +ar_name_equal (name, mem, truncated) + char *name, *mem; + int truncated; +{ + char *p; + + p = strrchr (name, '/'); + if (p != 0) + name = p + 1; + +#ifndef VMS + if (truncated) + { +#ifdef AIAMAG + /* TRUNCATED should never be set on this system. */ + abort (); +#else + struct ar_hdr hdr; +#if !defined (__hpux) && !defined (cray) + return strneq (name, mem, sizeof(hdr.ar_name) - 1); +#else + return strneq (name, mem, sizeof(hdr.ar_name) - 2); +#endif /* !__hpux && !cray */ +#endif /* !AIAMAG */ + } +#endif /* !VMS */ + + return !strcmp (name, mem); +} + +#ifndef VMS +/* ARGSUSED */ +static long int +ar_member_pos (desc, mem, truncated, + hdrpos, datapos, size, date, uid, gid, mode, name) + int desc; + char *mem; + int truncated; + long int hdrpos, datapos, size, date; + int uid, gid, mode; + char *name; +{ + if (!ar_name_equal (name, mem, truncated)) + return 0; + return hdrpos; +} + +/* Set date of member MEMNAME in archive ARNAME to current time. + Returns 0 if successful, + -1 if file ARNAME does not exist, + -2 if not a valid archive, + -3 if other random system call error (including file read-only), + 1 if valid but member MEMNAME does not exist. */ + +int +ar_member_touch (arname, memname) + char *arname, *memname; +{ + register long int pos = ar_scan (arname, ar_member_pos, (long int) memname); + register int fd; + struct ar_hdr ar_hdr; + register int i; + struct stat statbuf; + + if (pos < 0) + return (int) pos; + if (!pos) + return 1; + + fd = open (arname, O_RDWR, 0666); + if (fd < 0) + return -3; + /* Read in this member's header */ + if (lseek (fd, pos, 0) < 0) + goto lose; + if (AR_HDR_SIZE != read (fd, (char *) &ar_hdr, AR_HDR_SIZE)) + goto lose; + /* Write back the header, thus touching the archive file. */ + if (lseek (fd, pos, 0) < 0) + goto lose; + if (AR_HDR_SIZE != write (fd, (char *) &ar_hdr, AR_HDR_SIZE)) + goto lose; + /* The file's mtime is the time we we want. */ + if (fstat (fd, &statbuf) < 0) + goto lose; +#if defined(ARFMAG) || defined(ARFZMAG) || defined(AIAMAG) || defined(WINDOWS32) + /* Advance member's time to that time */ + for (i = 0; i < sizeof ar_hdr.ar_date; i++) + ar_hdr.ar_date[i] = ' '; + sprintf (ar_hdr.ar_date, "%ld", (long int) statbuf.st_mtime); +#ifdef AIAMAG + ar_hdr.ar_date[strlen(ar_hdr.ar_date)] = ' '; +#endif +#else + ar_hdr.ar_date = statbuf.st_mtime; +#endif + /* Write back this member's header */ + if (lseek (fd, pos, 0) < 0) + goto lose; + if (AR_HDR_SIZE != write (fd, (char *) &ar_hdr, AR_HDR_SIZE)) + goto lose; + close (fd); + return 0; + + lose: + i = errno; + close (fd); + errno = i; + return -3; +} +#endif + +#ifdef TEST + +long int +describe_member (desc, name, truncated, + hdrpos, datapos, size, date, uid, gid, mode) + int desc; + char *name; + int truncated; + long int hdrpos, datapos, size, date; + int uid, gid, mode; +{ + extern char *ctime (); + + printf (_("Member `%s'%s: %ld bytes at %ld (%ld).\n"), + name, truncated ? _(" (name might be truncated)") : "", + size, hdrpos, datapos); + printf (_(" Date %s"), ctime (&date)); + printf (_(" uid = %d, gid = %d, mode = 0%o.\n"), uid, gid, mode); + + return 0; +} + +main (argc, argv) + int argc; + char **argv; +{ + ar_scan (argv[1], describe_member); + return 0; +} + +#endif /* TEST. */ + +#endif /* NO_ARCHIVES. */ diff --git a/flaim/external/w32/make/build.bat b/flaim/external/w32/make/build.bat new file mode 100644 index 0000000..3ef9711 --- /dev/null +++ b/flaim/external/w32/make/build.bat @@ -0,0 +1,33 @@ +@echo off + +REM ------------------------------------------------------------------------- +REM Desc: Batch file for building GNU make on Windows platforms +REM Tabs: 3 +REM +REM Copyright (c) 2006 Novell, Inc. All Rights Reserved. +REM +REM This program is free software; you can redistribute it and/or +REM modify it under the terms of version 2 of the GNU General Public +REM License as published by the Free Software Foundation. +REM +REM This program is distributed in the hope that it will be useful, +REM but WITHOUT ANY WARRANTY; without even the implied warranty of +REM MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +REM GNU General Public License for more details. +REM +REM You should have received a copy of the GNU General Public License +REM along with this program; if not, contact Novell, Inc. +REM +REM To contact Novell about this file by physical or electronic mail, +REM you may find current contact information at www.novell.com +REM +REM $Id$ +REM ------------------------------------------------------------------------- + +setlocal +if exist build-dir rd /s /q build-dir +mkdir build-dir +cd build-dir +cl /nologo /W0 /MT -I. -DWINDOWS32 -DHAVE_STRING_H -DHAVE_DIRENT_H -DHAVE_FCNTL_H -I.. advapi32.lib user32.lib ../*.c /Femake.exe +cd .. +endlocal diff --git a/flaim/external/w32/make/commands.c b/flaim/external/w32/make/commands.c new file mode 100644 index 0000000..84b58de --- /dev/null +++ b/flaim/external/w32/make/commands.c @@ -0,0 +1,584 @@ +/* Command processing for GNU Make. +Copyright (C) 1988,89,91,92,93,94,95,96,97 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "dep.h" +#include "filedef.h" +#include "variable.h" +#include "job.h" +#include "commands.h" + +#if VMS +# define FILE_LIST_SEPARATOR ',' +#else +# define FILE_LIST_SEPARATOR ' ' +#endif + +extern int remote_kill PARAMS ((int id, int sig)); + +#ifndef HAVE_UNISTD_H +extern int getpid (); +#endif + +/* Set FILE's automatic variables up. */ + +static void +set_file_variables (file) + register struct file *file; +{ + char *at, *percent, *star, *less; + +#ifndef NO_ARCHIVES + /* If the target is an archive member `lib(member)', + then $@ is `lib' and $% is `member'. */ + + if (ar_name (file->name)) + { + unsigned int len; + char *p; + + p = strchr (file->name, '('); + at = (char *) alloca (p - file->name + 1); + bcopy (file->name, at, p - file->name); + at[p - file->name] = '\0'; + len = strlen (p + 1); + percent = (char *) alloca (len); + bcopy (p + 1, percent, len - 1); + percent[len - 1] = '\0'; + } + else +#endif /* NO_ARCHIVES. */ + { + at = file->name; + percent = ""; + } + + /* $* is the stem from an implicit or static pattern rule. */ + if (file->stem == 0) + { + /* In Unix make, $* is set to the target name with + any suffix in the .SUFFIXES list stripped off for + explicit rules. We store this in the `stem' member. */ + register struct dep *d; + char *name; + unsigned int len; + +#ifndef NO_ARCHIVES + if (ar_name (file->name)) + { + name = strchr (file->name, '(') + 1; + len = strlen (name) - 1; + } + else +#endif + { + name = file->name; + len = strlen (name); + } + + for (d = enter_file (".SUFFIXES")->deps; d != 0; d = d->next) + { + unsigned int slen = strlen (dep_name (d)); + if (len > slen && strneq (dep_name (d), name + (len - slen), slen)) + { + file->stem = savestring (name, len - slen); + break; + } + } + if (d == 0) + file->stem = ""; + } + star = file->stem; + + /* $< is the first dependency. */ + less = file->deps != 0 ? dep_name (file->deps) : ""; + + if (file->cmds == default_file->cmds) + /* This file got its commands from .DEFAULT. + In this case $< is the same as $@. */ + less = at; + +#define DEFINE_VARIABLE(name, len, value) \ + (void) define_variable_for_file (name,len,value,o_automatic,0,file) + + /* Define the variables. */ + + DEFINE_VARIABLE ("<", 1, less); + DEFINE_VARIABLE ("*", 1, star); + DEFINE_VARIABLE ("@", 1, at); + DEFINE_VARIABLE ("%", 1, percent); + + /* Compute the values for $^, $+, $?, and $|. */ + + { + unsigned int qmark_len, plus_len, bar_len; + char *caret_value, *plus_value; + char *cp; + char *qmark_value; + char *bar_value; + char *qp; + char *bp; + struct dep *d; + unsigned int len; + + /* Compute first the value for $+, which is supposed to contain + duplicate dependencies as they were listed in the makefile. */ + + plus_len = 0; + for (d = file->deps; d != 0; d = d->next) + if (! d->ignore_mtime) + plus_len += strlen (dep_name (d)) + 1; + if (plus_len == 0) + plus_len++; + + cp = plus_value = (char *) alloca (plus_len); + + qmark_len = plus_len + 1; /* Will be this or less. */ + for (d = file->deps; d != 0; d = d->next) + if (! d->ignore_mtime) + { + char *c = dep_name (d); + +#ifndef NO_ARCHIVES + if (ar_name (c)) + { + c = strchr (c, '(') + 1; + len = strlen (c) - 1; + } + else +#endif + len = strlen (c); + + bcopy (c, cp, len); + cp += len; + *cp++ = FILE_LIST_SEPARATOR; + if (! d->changed) + qmark_len -= len + 1; /* Don't space in $? for this one. */ + } + + /* Kill the last space and define the variable. */ + + cp[cp > plus_value ? -1 : 0] = '\0'; + DEFINE_VARIABLE ("+", 1, plus_value); + + /* Make sure that no dependencies are repeated. This does not + really matter for the purpose of updating targets, but it + might make some names be listed twice for $^ and $?. */ + + uniquize_deps (file->deps); + + bar_len = 0; + for (d = file->deps; d != 0; d = d->next) + if (d->ignore_mtime) + bar_len += strlen (dep_name (d)) + 1; + if (bar_len == 0) + bar_len++; + + /* Compute the values for $^, $?, and $|. */ + + cp = caret_value = plus_value; /* Reuse the buffer; it's big enough. */ + qp = qmark_value = (char *) alloca (qmark_len); + bp = bar_value = (char *) alloca (bar_len); + + for (d = file->deps; d != 0; d = d->next) + { + char *c = dep_name (d); + +#ifndef NO_ARCHIVES + if (ar_name (c)) + { + c = strchr (c, '(') + 1; + len = strlen (c) - 1; + } + else +#endif + len = strlen (c); + + if (d->ignore_mtime) + { + bcopy (c, bp, len); + bp += len; + *bp++ = FILE_LIST_SEPARATOR; + } + else + { + bcopy (c, cp, len); + cp += len; + *cp++ = FILE_LIST_SEPARATOR; + if (d->changed) + { + bcopy (c, qp, len); + qp += len; + *qp++ = FILE_LIST_SEPARATOR; + } + } + } + + /* Kill the last spaces and define the variables. */ + + cp[cp > caret_value ? -1 : 0] = '\0'; + DEFINE_VARIABLE ("^", 1, caret_value); + + qp[qp > qmark_value ? -1 : 0] = '\0'; + DEFINE_VARIABLE ("?", 1, qmark_value); + + bp[bp > bar_value ? -1 : 0] = '\0'; + DEFINE_VARIABLE ("|", 1, bar_value); + } + +#undef DEFINE_VARIABLE +} + +/* Chop CMDS up into individual command lines if necessary. + Also set the `lines_flags' and `any_recurse' members. */ + +void +chop_commands (cmds) + register struct commands *cmds; +{ + register char *p; + unsigned int nlines, idx; + char **lines; + + /* If we don't have any commands, + or we already parsed them, never mind. */ + + if (!cmds || cmds->command_lines != 0) + return; + + /* Chop CMDS->commands up into lines in CMDS->command_lines. + Also set the corresponding CMDS->lines_flags elements, + and the CMDS->any_recurse flag. */ + + nlines = 5; + lines = (char **) xmalloc (5 * sizeof (char *)); + idx = 0; + p = cmds->commands; + while (*p != '\0') + { + char *end = p; + find_end:; + end = strchr (end, '\n'); + if (end == 0) + end = p + strlen (p); + else if (end > p && end[-1] == '\\') + { + int backslash = 1; + register char *b; + for (b = end - 2; b >= p && *b == '\\'; --b) + backslash = !backslash; + if (backslash) + { + ++end; + goto find_end; + } + } + + if (idx == nlines) + { + nlines += 2; + lines = (char **) xrealloc ((char *) lines, + nlines * sizeof (char *)); + } + lines[idx++] = savestring (p, end - p); + p = end; + if (*p != '\0') + ++p; + } + + if (idx != nlines) + { + nlines = idx; + lines = (char **) xrealloc ((char *) lines, + nlines * sizeof (char *)); + } + + cmds->ncommand_lines = nlines; + cmds->command_lines = lines; + + cmds->any_recurse = 0; + cmds->lines_flags = (char *) xmalloc (nlines); + for (idx = 0; idx < nlines; ++idx) + { + int flags = 0; + + for (p = lines[idx]; + isblank ((unsigned char)*p) || *p == '-' || *p == '@' || *p == '+'; + ++p) + switch (*p) + { + case '+': + flags |= COMMANDS_RECURSE; + break; + case '@': + flags |= COMMANDS_SILENT; + break; + case '-': + flags |= COMMANDS_NOERROR; + break; + } + if (!(flags & COMMANDS_RECURSE)) + { + unsigned int len = strlen (p); + if (sindex (p, len, "$(MAKE)", 7) != 0 + || sindex (p, len, "${MAKE}", 7) != 0) + flags |= COMMANDS_RECURSE; + } + + cmds->lines_flags[idx] = flags; + cmds->any_recurse |= flags & COMMANDS_RECURSE; + } +} + +/* Execute the commands to remake FILE. If they are currently executing, + return or have already finished executing, just return. Otherwise, + fork off a child process to run the first command line in the sequence. */ + +void +execute_file_commands (file) + struct file *file; +{ + register char *p; + + /* Don't go through all the preparations if + the commands are nothing but whitespace. */ + + for (p = file->cmds->commands; *p != '\0'; ++p) + if (!isspace ((unsigned char)*p) && *p != '-' && *p != '@') + break; + if (*p == '\0') + { + /* If there are no commands, assume everything worked. */ + set_command_state (file, cs_running); + file->update_status = 0; + notice_finished_file (file); + return; + } + + /* First set the automatic variables according to this file. */ + + initialize_file_variables (file, 0); + + set_file_variables (file); + + /* Start the commands running. */ + new_job (file); +} + +/* This is set while we are inside fatal_error_signal, + so things can avoid nonreentrant operations. */ + +int handling_fatal_signal = 0; + +/* Handle fatal signals. */ + +RETSIGTYPE +fatal_error_signal (sig) + int sig; +{ +#ifdef __MSDOS__ + extern int dos_status, dos_command_running; + + if (dos_command_running) + { + /* That was the child who got the signal, not us. */ + dos_status |= (sig << 8); + return; + } + remove_intermediates (1); + exit (EXIT_FAILURE); +#else /* not __MSDOS__ */ +#ifdef _AMIGA + remove_intermediates (1); + if (sig == SIGINT) + fputs (_("*** Break.\n"), stderr); + + exit (10); +#else /* not Amiga */ + handling_fatal_signal = 1; + + /* Set the handling for this signal to the default. + It is blocked now while we run this handler. */ + signal (sig, SIG_DFL); + + /* A termination signal won't be sent to the entire + process group, but it means we want to kill the children. */ + + if (sig == SIGTERM) + { + register struct child *c; + for (c = children; c != 0; c = c->next) + if (!c->remote) + (void) kill (c->pid, SIGTERM); + } + + /* If we got a signal that means the user + wanted to kill make, remove pending targets. */ + + if (sig == SIGTERM || sig == SIGINT +#ifdef SIGHUP + || sig == SIGHUP +#endif +#ifdef SIGQUIT + || sig == SIGQUIT +#endif + ) + { + register struct child *c; + + /* Remote children won't automatically get signals sent + to the process group, so we must send them. */ + for (c = children; c != 0; c = c->next) + if (c->remote) + (void) remote_kill (c->pid, sig); + + for (c = children; c != 0; c = c->next) + delete_child_targets (c); + + /* Clean up the children. We don't just use the call below because + we don't want to print the "Waiting for children" message. */ + while (job_slots_used > 0) + reap_children (1, 0); + } + else + /* Wait for our children to die. */ + while (job_slots_used > 0) + reap_children (1, 1); + + /* Delete any non-precious intermediate files that were made. */ + + remove_intermediates (1); + +#ifdef SIGQUIT + if (sig == SIGQUIT) + /* We don't want to send ourselves SIGQUIT, because it will + cause a core dump. Just exit instead. */ + exit (EXIT_FAILURE); +#endif + + /* Signal the same code; this time it will really be fatal. The signal + will be unblocked when we return and arrive then to kill us. */ + if (kill (getpid (), sig) < 0) + pfatal_with_name ("kill"); +#endif /* not Amiga */ +#endif /* not __MSDOS__ */ +} + +/* Delete FILE unless it's precious or not actually a file (phony), + and it has changed on disk since we last stat'd it. */ + +static void +delete_target (file, on_behalf_of) + struct file *file; + char *on_behalf_of; +{ + struct stat st; + + if (file->precious || file->phony) + return; + +#ifndef NO_ARCHIVES + if (ar_name (file->name)) + { + time_t file_date = (file->last_mtime == NONEXISTENT_MTIME + ? (time_t) -1 + : (time_t) FILE_TIMESTAMP_S (file->last_mtime)); + if (ar_member_date (file->name) != file_date) + { + if (on_behalf_of) + error (NILF, _("*** [%s] Archive member `%s' may be bogus; not deleted"), + on_behalf_of, file->name); + else + error (NILF, _("*** Archive member `%s' may be bogus; not deleted"), + file->name); + } + return; + } +#endif + + if (stat (file->name, &st) == 0 + && S_ISREG (st.st_mode) + && FILE_TIMESTAMP_STAT_MODTIME (file->name, st) != file->last_mtime) + { + if (on_behalf_of) + error (NILF, _("*** [%s] Deleting file `%s'"), on_behalf_of, file->name); + else + error (NILF, _("*** Deleting file `%s'"), file->name); + if (unlink (file->name) < 0 + && errno != ENOENT) /* It disappeared; so what. */ + perror_with_name ("unlink: ", file->name); + } +} + + +/* Delete all non-precious targets of CHILD unless they were already deleted. + Set the flag in CHILD to say they've been deleted. */ + +void +delete_child_targets (child) + struct child *child; +{ + struct dep *d; + + if (child->deleted) + return; + + /* Delete the target file if it changed. */ + delete_target (child->file, (char *) 0); + + /* Also remove any non-precious targets listed in the `also_make' member. */ + for (d = child->file->also_make; d != 0; d = d->next) + delete_target (d->file, child->file->name); + + child->deleted = 1; +} + +/* Print out the commands in CMDS. */ + +void +print_commands (cmds) + register struct commands *cmds; +{ + register char *s; + + fputs (_("# commands to execute"), stdout); + + if (cmds->fileinfo.filenm == 0) + puts (_(" (built-in):")); + else + printf (_(" (from `%s', line %lu):\n"), + cmds->fileinfo.filenm, cmds->fileinfo.lineno); + + s = cmds->commands; + while (*s != '\0') + { + char *end; + + while (isspace ((unsigned char)*s)) + ++s; + + end = strchr (s, '\n'); + if (end == 0) + end = s + strlen (s); + + printf ("\t%.*s\n", (int) (end - s), s); + + s = end; + } +} diff --git a/flaim/external/w32/make/commands.h b/flaim/external/w32/make/commands.h new file mode 100644 index 0000000..edec910 --- /dev/null +++ b/flaim/external/w32/make/commands.h @@ -0,0 +1,42 @@ +/* Definition of data structures describing shell commands for GNU Make. +Copyright (C) 1988, 1989, 1991, 1993 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* Structure that gives the commands to make a file + and information about where these commands came from. */ + +struct commands + { + struct floc fileinfo; /* Where commands were defined. */ + char *commands; /* Commands text. */ + unsigned int ncommand_lines;/* Number of command lines. */ + char **command_lines; /* Commands chopped up into lines. */ + char *lines_flags; /* One set of flag bits for each line. */ + int any_recurse; /* Nonzero if any `lines_recurse' elt has */ + /* the COMMANDS_RECURSE bit set. */ + }; + +/* Bits in `lines_flags'. */ +#define COMMANDS_RECURSE 1 /* Recurses: + or $(MAKE). */ +#define COMMANDS_SILENT 2 /* Silent: @. */ +#define COMMANDS_NOERROR 4 /* No errors: -. */ + +extern void execute_file_commands PARAMS ((struct file *file)); +extern void print_commands PARAMS ((struct commands *cmds)); +extern void delete_child_targets PARAMS ((struct child *child)); +extern void chop_commands PARAMS ((struct commands *cmds)); diff --git a/flaim/external/w32/make/config.h b/flaim/external/w32/make/config.h new file mode 100644 index 0000000..1ba9b87 --- /dev/null +++ b/flaim/external/w32/make/config.h @@ -0,0 +1,399 @@ +/* config.h.in. Generated automatically from configure.in by autoheader. */ + +/* Define if on AIX 3. + System headers sometimes define this. + We just want to avoid a redefinition error message. */ +#ifndef _ALL_SOURCE +/* #undef _ALL_SOURCE */ +#endif + +/* Define if using alloca.c. */ +/* #undef C_ALLOCA */ + +/* Define if the closedir function returns void instead of int. */ +/* #undef CLOSEDIR_VOID */ + +/* Define to empty if the keyword does not work. */ +/* #undef const */ + +/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems. + This function is required for alloca.c support on those systems. */ +/* #undef CRAY_STACKSEG_END */ + +/* Define for DGUX with . */ +/* #undef DGUX */ + +/* Define if the `getloadavg' function needs to be run setuid or setgid. */ +/* #undef GETLOADAVG_PRIVILEGED */ + +/* Define to `unsigned long' or `unsigned long long' + if doesn't define. */ +#define uintmax_t unsigned long + +/* Define to `int' if doesn't define. */ +#undef gid_t +#define gid_t int + +/* Define if you have alloca, as a function or macro. */ +#undef HAVE_ALLOCA +#define HAVE_ALLOCA 1 + +/* Define if you have and it should be used (not on Ultrix). */ +/* #undef HAVE_ALLOCA_H */ + +/* Define if you don't have vprintf but do have _doprnt. */ +/* #undef HAVE_DOPRNT */ + +/* Define if your system has a working fnmatch function. */ +/* #undef HAVE_FNMATCH */ + +/* Define if your system has its own `getloadavg' function. */ +/* #undef HAVE_GETLOADAVG */ + +/* Define if you have the getmntent function. */ +/* #undef HAVE_GETMNTENT */ + +/* Define if the `long double' type works. */ +/* #undef HAVE_LONG_DOUBLE */ + +/* Define if you support file names longer than 14 characters. */ +#undef HAVE_LONG_FILE_NAMES +#define HAVE_LONG_FILE_NAMES 1 + +/* Define if you have a working `mmap' system call. */ +/* #undef HAVE_MMAP */ + +/* Define if system calls automatically restart after interruption + by a signal. */ +/* #undef HAVE_RESTARTABLE_SYSCALLS */ + +/* Define if your struct stat has st_blksize. */ +/* #undef HAVE_ST_BLKSIZE */ + +/* Define if your struct stat has st_blocks. */ +/* #undef HAVE_ST_BLOCKS */ + +/* Define if you have the strcoll function and it is properly defined. */ +#undef HAVE_STRCOLL +#define HAVE_STRCOLL 1 + +/* Define if your struct stat has st_rdev. */ +#undef HAVE_ST_RDEV +#define HAVE_ST_RDEV 1 + +/* Define if you have the strftime function. */ +#undef HAVE_STRFTIME +#define HAVE_STRFTIME 1 + +/* Define if you have that is POSIX.1 compatible. */ +/* #undef HAVE_SYS_WAIT_H */ + +/* Define if your struct tm has tm_zone. */ +/* #undef HAVE_TM_ZONE */ + +/* Define if you don't have tm_zone but do have the external array + tzname. */ +#undef HAVE_TZNAME +#define HAVE_TZNAME 1 + +/* Define if you have . */ +/* #undef HAVE_UNISTD_H */ + +/* Define if utime(file, NULL) sets file's timestamp to the present. */ +#undef HAVE_UTIME_NULL +#define HAVE_UTIME_NULL 1 + +/* Define if you have . */ +/* #undef HAVE_VFORK_H */ + +/* Define if you have the vprintf function. */ +#undef HAVE_VPRINTF +#define HAVE_VPRINTF 1 + +/* Define if you have the wait3 system call. */ +/* #undef HAVE_WAIT3 */ + +/* Define if on MINIX. */ +/* #undef _MINIX */ + +/* Define if your struct nlist has an n_un member. */ +/* #undef NLIST_NAME_UNION */ + +/* Define if you have . */ +/* #undef NLIST_STRUCT */ + +/* Define if your C compiler doesn't accept -c and -o together. */ +/* #undef NO_MINUS_C_MINUS_O */ + +/* Define to `int' if doesn't define. */ +#undef pid_t +#define pid_t int + +/* Define if the system does not provide POSIX.1 features except + with this defined. */ +/* #undef _POSIX_1_SOURCE */ + +/* Define if you need to in order for stat and other things to work. */ +#undef _POSIX_SOURCE +#define _POSIX_SOURCE 1 + +/* Define as the return type of signal handlers (int or void). */ +#undef RETSIGTYPE +#define RETSIGTYPE void + +/* Define if the setvbuf function takes the buffering type as its second + argument and the buffer pointer as the third, as on System V + before release 3. */ +/* #undef SETVBUF_REVERSED */ + +/* If using the C implementation of alloca, define if you know the + direction of stack growth for your system; otherwise it will be + automatically deduced at run-time. + STACK_DIRECTION > 0 => grows toward higher addresses + STACK_DIRECTION < 0 => grows toward lower addresses + STACK_DIRECTION = 0 => direction of growth unknown + */ +/* #undef STACK_DIRECTION */ + +/* Define if the `S_IS*' macros in do not work properly. */ +/* #undef STAT_MACROS_BROKEN */ + +/* Define if you have the ANSI C header files. */ +#undef STDC_HEADERS +#define STDC_HEADERS 1 + +/* Define on System V Release 4. */ +/* #undef SVR4 */ + +/* Define if `sys_siglist' is declared by . */ +/* #undef SYS_SIGLIST_DECLARED */ + +/* Define to `int' if doesn't define. */ +#undef uid_t +#define uid_t int + +/* Define for Encore UMAX. */ +/* #undef UMAX */ + +/* Define for Encore UMAX 4.3 that has + instead of . */ +/* #undef UMAX4_3 */ + +/* Define vfork as fork if vfork does not work. */ +/* #undef vfork */ + +/* Name of this package (needed by automake) */ +#define PACKAGE "make" + +/* Version of this package (needed by automake) */ +#define VERSION "3.80" + +/* Define to the name of the SCCS `get' command. */ +#undef SCCS_GET +#define SCCS_GET "echo no sccs get" + +/* Define to 1 if NLS is requested. */ +/* #undef ENABLE_NLS */ + +/* Define as 1 if you have dcgettext. */ +/* #undef HAVE_DCGETTEXT */ + +/* Define as 1 if you have gettext and don't want to use GNU gettext. */ +/* #undef HAVE_GETTEXT */ + +/* Define if your locale.h file contains LC_MESSAGES. */ +/* #undef HAVE_LC_MESSAGES */ + +/* Define to the installation directory for locales. */ +#define LOCALEDIR "" + +/* Define this if the SCCS `get' command understands the `-G' option. */ +/* #undef SCCS_GET_MINUS_G */ + +/* Define this to enable job server support in GNU make. */ +/* #undef MAKE_JOBSERVER */ + +/* Define to be the nanoseconds member of struct stat's st_mtim, + if it exists. */ +/* #undef ST_MTIM_NSEC */ + +/* Define this if the C library defines the variable `sys_siglist'. */ +/* #undef HAVE_SYS_SIGLIST */ + +/* Define this if the C library defines the variable `_sys_siglist'. */ +/* #undef HAVE__SYS_SIGLIST */ + +/* Define this if you have the `union wait' type in . */ +/* #undef HAVE_UNION_WAIT */ + +/* Define if you have the dup2 function. */ +#undef HAVE_DUP2 +#define HAVE_DUP2 1 + +/* Define if you have the getcwd function. */ +#undef HAVE_GETCWD +#define HAVE_GETCWD 1 + +/* Define if you have the getgroups function. */ +/* #undef HAVE_GETGROUPS */ + +/* Define if you have the gethostbyname function. */ +/* #undef HAVE_GETHOSTBYNAME */ + +/* Define if you have the gethostname function. */ +/* #undef HAVE_GETHOSTNAME */ + +/* Define if you have the getloadavg function. */ +/* #undef HAVE_GETLOADAVG */ + +/* Define if you have the memmove function. */ +#undef HAVE_MEMMOVE +#define HAVE_MEMMOVE 1 + +/* Define if you have the mktemp function. */ +#undef HAVE_MKTEMP +#define HAVE_MKTEMP 1 + +/* Define if you have the psignal function. */ +/* #undef HAVE_PSIGNAL */ + +/* Define if you have the pstat_getdynamic function. */ +/* #undef HAVE_PSTAT_GETDYNAMIC */ + +/* Define if you have the setegid function. */ +/* #undef HAVE_SETEGID */ + +/* Define if you have the seteuid function. */ +/* #undef HAVE_SETEUID */ + +/* Define if you have the setlinebuf function. */ +/* #undef HAVE_SETLINEBUF */ + +/* Define if you have the setregid function. */ +/* #undef HAVE_SETREGID */ + +/* Define if you have the setreuid function. */ +/* #undef HAVE_SETREUID */ + +/* Define if you have the sigsetmask function. */ +/* #undef HAVE_SIGSETMASK */ + +/* Define if you have the socket function. */ +/* #undef HAVE_SOCKET */ + +/* Define if you have the strcasecmp function. */ +/* #undef HAVE_STRCASECMP */ + +/* Define if you have the strerror function. */ +#undef HAVE_STRERROR +#define HAVE_STRERROR 1 + +/* Define if you have the strsignal function. */ +/* #undef HAVE_STRSIGNAL */ + +/* Define if you have the wait3 function. */ +/* #undef HAVE_WAIT3 */ + +/* Define if you have the waitpid function. */ +/* #undef HAVE_WAITPID */ + +/* Define if you have the header file. */ +#undef HAVE_DIRENT_H +#define HAVE_DIRENT_H 1 + +/* Define if you have the header file. */ +#undef HAVE_FCNTL_H +#define HAVE_FCNTL_H 1 + +/* Define if you have the header file. */ +#undef HAVE_LIMITS_H +#define HAVE_LIMITS_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_MACH_MACH_H */ + +/* Define if you have the header file. */ +#undef HAVE_MEMORY_H +#define HAVE_MEMORY_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_NDIR_H */ + +/* Define if you have the header file. */ +#undef HAVE_STRING_H +#define HAVE_STRING_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_DIR_H */ + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_NDIR_H */ + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_PARAM_H */ + +/* Define if you have the header file. */ +#undef HAVE_SYS_TIMEB_H +#define HAVE_SYS_TIMEB_H 1 + +/* Define if you have the header file. */ +/* #undef HAVE_SYS_WAIT_H */ + +/* Define if you have the header file. */ +/* #undef HAVE_UNISTD_H */ + +/* Define if you have the dgc library (-ldgc). */ +/* #undef HAVE_LIBDGC */ + +/* Define if you have the kstat library (-lkstat). */ +/* #undef HAVE_LIBKSTAT */ + +/* Define if you have the sun library (-lsun). */ +/* #undef HAVE_LIBSUN */ + +/* Use high resolution file timestamps if nonzero. */ +#define FILE_TIMESTAMP_HI_RES 0 + +/* Build host information. */ +#define MAKE_HOST "Windows32" + +/* Grok DOS paths (drive specs and backslash path element separators) */ +#define HAVE_DOS_PATHS + +/* + * Refer to README.W32 for info on the following settings + */ + +/* + * If you have a shell that does not grok 'sh -c quoted-command-line' + * correctly, you need this setting. Please see below for specific + * shell support. + */ +#undef BATCH_MODE_ONLY_SHELL +#define BATCH_MODE_ONLY_SHELL 1 + +/* + * Define if you have the Cygnus "Cygwin" GNU Windows32 tool set. + * Do NOT define BATCH_MODE_ONLY_SHELL if you define HAVE_CYGWIN_SHELL + */ +#undef HAVE_CYGWIN_SHELL + +/* + * Define if you have the MKS tool set or shell. Do NOT define + * BATCH_MODE_ONLY_SHELL if you define HAVE_MKS_SHELL + */ +#undef HAVE_MKS_SHELL + +/* + * Enforce the mutual exclusivity restriction. + */ +#ifdef HAVE_MKS_SHELL +#undef BATCH_MODE_ONLY_SHELL +#endif + +#ifdef HAVE_CYGWIN_SHELL +#undef BATCH_MODE_ONLY_SHELL +#endif + +/* Define if you prefer Case Insensitive behavior */ +#undef HAVE_CASE_INSENSITIVE_FS diff --git a/flaim/external/w32/make/debug.h b/flaim/external/w32/make/debug.h new file mode 100644 index 0000000..30c2d62 --- /dev/null +++ b/flaim/external/w32/make/debug.h @@ -0,0 +1,41 @@ +/* Debugging macros and interface. +Copyright (C) 1999 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + + +#define DB_NONE (0x000) +#define DB_BASIC (0x001) +#define DB_VERBOSE (0x002) +#define DB_JOBS (0x004) +#define DB_IMPLICIT (0x008) +#define DB_MAKEFILES (0x100) + +#define DB_ALL (0xfff) + +extern int db_level; + +#define ISDB(_l) ((_l)&db_level) + +#define DBS(_l,_x) do{ if(ISDB(_l)) {print_spaces (depth); \ + printf _x; fflush (stdout);} }while(0) + +#define DBF(_l,_x) do{ if(ISDB(_l)) {print_spaces (depth); \ + printf (_x, file->name); \ + fflush (stdout);} }while(0) + +#define DB(_l,_x) do{ if(ISDB(_l)) {printf _x; fflush (stdout);} }while(0) diff --git a/flaim/external/w32/make/default.c b/flaim/external/w32/make/default.c new file mode 100644 index 0000000..5d981b9 --- /dev/null +++ b/flaim/external/w32/make/default.c @@ -0,0 +1,585 @@ +/* Data base of default implicit rules for GNU Make. +Copyright (C) 1988,89,90,91,92,93,94,95,96 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "rule.h" +#include "dep.h" +#include "filedef.h" +#include "job.h" +#include "commands.h" +#include "variable.h" + +/* Define GCC_IS_NATIVE if gcc is the native development environment on + your system (gcc/bison/flex vs cc/yacc/lex). */ +#ifdef __MSDOS__ +#define GCC_IS_NATIVE +#endif + + +/* This is the default list of suffixes for suffix rules. + `.s' must come last, so that a `.o' file will be made from + a `.c' or `.p' or ... file rather than from a .s file. */ + +static char default_suffixes[] +#ifdef VMS + = ".exe .olb .ln .obj .c .cxx .cc .pas .p .for .f .r .y .l .mar \ +.s .ss .i .ii .mod .sym .def .h .info .dvi .tex .texinfo .texi .txinfo \ +.w .ch .cweb .web .com .sh .elc .el"; +#else + = ".out .a .ln .o .c .cc .C .cpp .p .f .F .r .y .l .s .S \ +.mod .sym .def .h .info .dvi .tex .texinfo .texi .txinfo \ +.w .ch .web .sh .elc .el"; +#endif + +static struct pspec default_pattern_rules[] = + { + { "(%)", "%", + "$(AR) $(ARFLAGS) $@ $<" }, + + /* The X.out rules are only in BSD's default set because + BSD Make has no null-suffix rules, so `foo.out' and + `foo' are the same thing. */ +#ifdef VMS + { "%.exe", "%", + "copy $< $@" }, +#else + { "%.out", "%", + "@rm -f $@ \n cp $< $@" }, +#endif + /* Syntax is "ctangle foo.w foo.ch foo.c". */ + { "%.c", "%.w %.ch", + "$(CTANGLE) $^ $@" }, + { "%.tex", "%.w %.ch", + "$(CWEAVE) $^ $@" }, + + { 0, 0, 0 } + }; + +static struct pspec default_terminal_rules[] = + { +#ifdef VMS + /* RCS. */ + { "%", "%$$5lv", /* Multinet style */ + "if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" }, + { "%", "[.$$rcs]%$$5lv", /* Multinet style */ + "if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" }, + { "%", "%_v", /* Normal style */ + "if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" }, + { "%", "[.rcs]%_v", /* Normal style */ + "if f$$search($@) .nes. \"\" then +$(CHECKOUT,v)" }, + + /* SCCS. */ + /* ain't no SCCS on vms */ +#else + /* RCS. */ + { "%", "%,v", + "$(CHECKOUT,v)" }, + { "%", "RCS/%,v", + "$(CHECKOUT,v)" }, + { "%", "RCS/%", + "$(CHECKOUT,v)" }, + + /* SCCS. */ + { "%", "s.%", + "$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" }, + { "%", "SCCS/s.%", + "$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" }, +#endif /* !VMS */ + { 0, 0, 0 } + }; + +static char *default_suffix_rules[] = + { +#ifdef VMS + ".obj.exe", + "$(LINK.obj) $^ $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@", + ".mar.exe", + "$(COMPILE.mar) $^ \n $(LINK.obj) $(subst .mar,.obj,$^) $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@", + ".s.exe", + "$(COMPILE.s) $^ \n $(LINK.obj) $(subst .s,.obj,$^) $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@", + ".c.exe", + "$(COMPILE.c) $^ \n $(LINK.obj) $(subst .c,.obj,$^) $(LOADLIBES) $(LDLIBS) $(CRT0) /exe=$@", + ".cc.exe", +#ifdef GCC_IS_NATIVE + "$(COMPILE.cc) $^ \n $(LINK.obj) $(CXXSTARTUP),sys$$disk:[]$(subst .cc,.obj,$^) $(LOADLIBES) $(LXLIBS) $(LDLIBS) $(CXXRT0) /exe=$@", +#else + "$(COMPILE.cc) $^ \n $(CXXLINK.obj) $(subst .cc,.obj,$^) $(LOADLIBES) $(LXLIBS) $(LDLIBS) $(CXXRT0) /exe=$@", + ".cxx.exe", + "$(COMPILE.cxx) $^ \n $(CXXLINK.obj) $(subst .cxx,.obj,$^) $(LOADLIBES) $(LXLIBS) $(LDLIBS) $(CXXRT0) /exe=$@", +#endif + ".for.exe", + "$(COMPILE.for) $^ \n $(LINK.obj) $(subst .for,.obj,$^) $(LOADLIBES) $(LDLIBS) /exe=$@", + ".pas.exe", + "$(COMPILE.pas) $^ \n $(LINK.obj) $(subst .pas,.obj,$^) $(LOADLIBES) $(LDLIBS) /exe=$@", + + ".com", + "copy $< >$@", + + ".mar.obj", + "$(COMPILE.mar) /obj=$@ $<", + ".s.obj", + "$(COMPILE.s) /obj=$@ $<", + ".ss.obj", + "$(COMPILE.s) /obj=$@ $<", + ".c.i", + "$(COMPILE.c)/prep /list=$@ $<", + ".c.s", + "$(COMPILE.c)/noobj/machine /list=$@ $<", + ".i.s", + "$(COMPILE.c)/noprep/noobj/machine /list=$@ $<", + ".c.obj", + "$(COMPILE.c) /obj=$@ $<", + ".cc.ii", + "$(COMPILE.cc)/prep /list=$@ $<", + ".cc.ss", + "$(COMPILE.cc)/noobj/machine /list=$@ $<", + ".ii.ss", + "$(COMPILE.cc)/noprep/noobj/machine /list=$@ $<", + ".cc.obj", + "$(COMPILE.cc) /obj=$@ $<", + ".for.obj", + "$(COMPILE.for) /obj=$@ $<", + ".pas.obj", + "$(COMPILE.pas) /obj=$@ $<", + + ".y.c", + "$(YACC.y) $< \n rename y_tab.c $@", + ".l.c", + "$(LEX.l) $< \n rename lexyy.c $@", + + ".texinfo.info", + "$(MAKEINFO) $<", + + ".tex.dvi", + "$(TEX) $<", + +#else /* ! VMS */ + + ".o", + "$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".s", + "$(LINK.s) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".S", + "$(LINK.S) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".c", + "$(LINK.c) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".cc", + "$(LINK.cc) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".C", + "$(LINK.C) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".cpp", + "$(LINK.cpp) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".f", + "$(LINK.f) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".p", + "$(LINK.p) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".F", + "$(LINK.F) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".r", + "$(LINK.r) $^ $(LOADLIBES) $(LDLIBS) -o $@", + ".mod", + "$(COMPILE.mod) -o $@ -e $@ $^", + + ".def.sym", + "$(COMPILE.def) -o $@ $<", + + ".sh", + "cat $< >$@ \n chmod a+x $@", + + ".s.o", + "$(COMPILE.s) -o $@ $<", + ".S.o", + "$(COMPILE.S) -o $@ $<", + ".c.o", + "$(COMPILE.c) $(OUTPUT_OPTION) $<", + ".cc.o", + "$(COMPILE.cc) $(OUTPUT_OPTION) $<", + ".C.o", + "$(COMPILE.C) $(OUTPUT_OPTION) $<", + ".cpp.o", + "$(COMPILE.cpp) $(OUTPUT_OPTION) $<", + ".f.o", + "$(COMPILE.f) $(OUTPUT_OPTION) $<", + ".p.o", + "$(COMPILE.p) $(OUTPUT_OPTION) $<", + ".F.o", + "$(COMPILE.F) $(OUTPUT_OPTION) $<", + ".r.o", + "$(COMPILE.r) $(OUTPUT_OPTION) $<", + ".mod.o", + "$(COMPILE.mod) -o $@ $<", + + ".c.ln", + "$(LINT.c) -C$* $<", + ".y.ln", +#ifndef __MSDOS__ + "$(YACC.y) $< \n $(LINT.c) -C$* y.tab.c \n $(RM) y.tab.c", +#else + "$(YACC.y) $< \n $(LINT.c) -C$* y_tab.c \n $(RM) y_tab.c", +#endif + ".l.ln", + "@$(RM) $*.c\n $(LEX.l) $< > $*.c\n$(LINT.c) -i $*.c -o $@\n $(RM) $*.c", + + ".y.c", +#ifndef __MSDOS__ + "$(YACC.y) $< \n mv -f y.tab.c $@", +#else + "$(YACC.y) $< \n mv -f y_tab.c $@", +#endif + ".l.c", + "@$(RM) $@ \n $(LEX.l) $< > $@", + + ".F.f", + "$(PREPROCESS.F) $(OUTPUT_OPTION) $<", + ".r.f", + "$(PREPROCESS.r) $(OUTPUT_OPTION) $<", + + /* This might actually make lex.yy.c if there's no %R% + directive in $*.l, but in that case why were you + trying to make $*.r anyway? */ + ".l.r", + "$(LEX.l) $< > $@ \n mv -f lex.yy.r $@", + + ".S.s", + "$(PREPROCESS.S) $< > $@", + + ".texinfo.info", + "$(MAKEINFO) $(MAKEINFO_FLAGS) $< -o $@", + + ".texi.info", + "$(MAKEINFO) $(MAKEINFO_FLAGS) $< -o $@", + + ".txinfo.info", + "$(MAKEINFO) $(MAKEINFO_FLAGS) $< -o $@", + + ".tex.dvi", + "$(TEX) $<", + + ".texinfo.dvi", + "$(TEXI2DVI) $(TEXI2DVI_FLAGS) $<", + + ".texi.dvi", + "$(TEXI2DVI) $(TEXI2DVI_FLAGS) $<", + + ".txinfo.dvi", + "$(TEXI2DVI) $(TEXI2DVI_FLAGS) $<", + + ".w.c", + "$(CTANGLE) $< - $@", /* The `-' says there is no `.ch' file. */ + + ".web.p", + "$(TANGLE) $<", + + ".w.tex", + "$(CWEAVE) $< - $@", /* The `-' says there is no `.ch' file. */ + + ".web.tex", + "$(WEAVE) $<", + +#endif /* !VMS */ + + 0, 0, + }; + +static char *default_variables[] = + { +#ifdef VMS +#ifdef __ALPHA + "ARCH", "ALPHA", +#else + "ARCH", "VAX", +#endif + "AR", "library/obj", + "ARFLAGS", "/replace", + "AS", "macro", + "MACRO", "macro", +#ifdef GCC_IS_NATIVE + "CC", "gcc", +#else + "CC", "cc", +#endif + "CD", "builtin_cd", + "MAKE", "make", + "ECHO", "write sys$$output \"", +#ifdef GCC_IS_NATIVE + "C++", "gcc/plus", + "CXX", "gcc/plus", +#else + "C++", "cxx", + "CXX", "cxx", + "CXXLD", "cxxlink", +#endif + "CO", "co", + "CPP", "$(CC) /preprocess_only", + "FC", "fortran", + /* System V uses these, so explicit rules using them should work. + However, there is no way to make implicit rules use them and FC. */ + "F77", "$(FC)", + "F77FLAGS", "$(FFLAGS)", + "LD", "link", + "LEX", "lex", + "PC", "pascal", + "YACC", "bison/yacc", + "YFLAGS", "/Define/Verbose", + "BISON", "bison", + "MAKEINFO", "makeinfo", + "TEX", "tex", + "TEXINDEX", "texindex", + + "RM", "delete/nolog", + + "CSTARTUP", "", +#ifdef GCC_IS_NATIVE + "CRT0", ",sys$$library:vaxcrtl.olb/lib,gnu_cc_library:crt0.obj", + "CXXSTARTUP", "gnu_cc_library:crtbegin.obj", + "CXXRT0", ",sys$$library:vaxcrtl.olb/lib,gnu_cc_library:crtend.obj,gnu_cc_library:gxx_main.obj", + "LXLIBS", ",gnu_cc_library:libstdcxx.olb/lib,gnu_cc_library:libgccplus.olb/lib", + "LDLIBS", ",gnu_cc_library:libgcc.olb/lib", +#else + "CRT0", "", + "CXXSTARTUP", "", + "CXXRT0", "", + "LXLIBS", "", + "LDLIBS", "", +#endif + + "LINK.obj", "$(LD) $(LDFLAGS)", +#ifndef GCC_IS_NATIVE + "CXXLINK.obj", "$(CXXLD) $(LDFLAGS)", + "COMPILE.cxx", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH)", +#endif + "COMPILE.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH)", + "COMPILE.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH)", + "YACC.y", "$(YACC) $(YFLAGS)", + "LEX.l", "$(LEX) $(LFLAGS)", + "COMPILE.for", "$(FC) $(FFLAGS) $(TARGET_ARCH)", + "COMPILE.pas", "$(PC) $(PFLAGS) $(CPPFLAGS) $(TARGET_ARCH)", + "COMPILE.mar", "$(MACRO) $(MACROFLAGS)", + "COMPILE.s", "$(AS) $(ASFLAGS) $(TARGET_MACH)", + "LINT.c", "$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(TARGET_ARCH)", + + "MV", "rename/new_version", + "CP", "copy", + +#else /* !VMS */ + + "AR", "ar", + "ARFLAGS", "rv", + "AS", "as", +#ifdef GCC_IS_NATIVE + "CC", "gcc", +# ifdef __MSDOS__ + "CXX", "gpp", /* g++ is an invalid name on MSDOS */ +# else + "CXX", "gcc", +# endif /* __MSDOS__ */ +#else + "CC", "cc", + "CXX", "g++", +#endif + + /* This expands to $(CO) $(COFLAGS) $< $@ if $@ does not exist, + and to the empty string if $@ does exist. */ + "CHECKOUT,v", "+$(if $(wildcard $@),,$(CO) $(COFLAGS) $< $@)", + "CO", "co", + "COFLAGS", "", + + "CPP", "$(CC) -E", +#ifdef CRAY + "CF77PPFLAGS", "-P", + "CF77PP", "/lib/cpp", + "CFT", "cft77", + "CF", "cf77", + "FC", "$(CF)", +#else /* Not CRAY. */ +#ifdef _IBMR2 + "FC", "xlf", +#else +#ifdef __convex__ + "FC", "fc", +#else + "FC", "f77", +#endif /* __convex__ */ +#endif /* _IBMR2 */ + /* System V uses these, so explicit rules using them should work. + However, there is no way to make implicit rules use them and FC. */ + "F77", "$(FC)", + "F77FLAGS", "$(FFLAGS)", +#endif /* Cray. */ + "GET", SCCS_GET, + "LD", "ld", +#ifdef GCC_IS_NATIVE + "LEX", "flex", +#else + "LEX", "lex", +#endif + "LINT", "lint", + "M2C", "m2c", +#ifdef pyr + "PC", "pascal", +#else +#ifdef CRAY + "PC", "PASCAL", + "SEGLDR", "segldr", +#else + "PC", "pc", +#endif /* CRAY. */ +#endif /* pyr. */ +#ifdef GCC_IS_NATIVE + "YACC", "bison -y", +#else + "YACC", "yacc", /* Or "bison -y" */ +#endif + "MAKEINFO", "makeinfo", + "TEX", "tex", + "TEXI2DVI", "texi2dvi", + "WEAVE", "weave", + "CWEAVE", "cweave", + "TANGLE", "tangle", + "CTANGLE", "ctangle", + + "RM", "rm -f", + + "LINK.o", "$(CC) $(LDFLAGS) $(TARGET_ARCH)", + "COMPILE.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c", + "LINK.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)", + "COMPILE.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c", + "COMPILE.C", "$(COMPILE.cc)", + "COMPILE.cpp", "$(COMPILE.cc)", + "LINK.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)", + "LINK.C", "$(LINK.cc)", + "LINK.cpp", "$(LINK.cc)", + "YACC.y", "$(YACC) $(YFLAGS)", + "LEX.l", "$(LEX) $(LFLAGS) -t", + "COMPILE.f", "$(FC) $(FFLAGS) $(TARGET_ARCH) -c", + "LINK.f", "$(FC) $(FFLAGS) $(LDFLAGS) $(TARGET_ARCH)", + "COMPILE.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c", + "LINK.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)", + "COMPILE.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -c", + "LINK.r", "$(FC) $(FFLAGS) $(RFLAGS) $(LDFLAGS) $(TARGET_ARCH)", + "COMPILE.def", "$(M2C) $(M2FLAGS) $(DEFFLAGS) $(TARGET_ARCH)", + "COMPILE.mod", "$(M2C) $(M2FLAGS) $(MODFLAGS) $(TARGET_ARCH)", + "COMPILE.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c", + "LINK.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)", + "LINK.s", "$(CC) $(ASFLAGS) $(LDFLAGS) $(TARGET_MACH)", + "COMPILE.s", "$(AS) $(ASFLAGS) $(TARGET_MACH)", + "LINK.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_MACH)", + "COMPILE.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(TARGET_MACH) -c", + "PREPROCESS.S", "$(CC) -E $(CPPFLAGS)", + "PREPROCESS.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -F", + "PREPROCESS.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -F", + "LINT.c", "$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(TARGET_ARCH)", + +#ifndef NO_MINUS_C_MINUS_O + "OUTPUT_OPTION", "-o $@", +#endif + +#ifdef SCCS_GET_MINUS_G + "SCCS_OUTPUT_OPTION", "-G$@", +#endif + +#ifdef _AMIGA + ".LIBPATTERNS", "%.lib", +#else +#ifdef __MSDOS__ + ".LIBPATTERNS", "lib%.a $(DJDIR)/lib/lib%.a", +#else + ".LIBPATTERNS", "lib%.so lib%.a", +#endif +#endif + +#endif /* !VMS */ + 0, 0 + }; + +/* Set up the default .SUFFIXES list. */ + +void +set_default_suffixes () +{ + suffix_file = enter_file (".SUFFIXES"); + + if (no_builtin_rules_flag) + (void) define_variable ("SUFFIXES", 8, "", o_default, 0); + else + { + char *p = default_suffixes; + suffix_file->deps = (struct dep *) + multi_glob (parse_file_seq (&p, '\0', sizeof (struct dep), 1), + sizeof (struct dep)); + (void) define_variable ("SUFFIXES", 8, default_suffixes, o_default, 0); + } +} + +/* Enter the default suffix rules as file rules. This used to be done in + install_default_implicit_rules, but that loses because we want the + suffix rules installed before reading makefiles, and thee pattern rules + installed after. */ + +void +install_default_suffix_rules () +{ + register char **s; + + if (no_builtin_rules_flag) + return; + + for (s = default_suffix_rules; *s != 0; s += 2) + { + register struct file *f = enter_file (s[0]); + /* Don't clobber cmds given in a makefile if there were any. */ + if (f->cmds == 0) + { + f->cmds = (struct commands *) xmalloc (sizeof (struct commands)); + f->cmds->fileinfo.filenm = 0; + f->cmds->commands = s[1]; + f->cmds->command_lines = 0; + } + } +} + + +/* Install the default pattern rules. */ + +void +install_default_implicit_rules () +{ + register struct pspec *p; + + if (no_builtin_rules_flag) + return; + + for (p = default_pattern_rules; p->target != 0; ++p) + install_pattern_rule (p, 0); + + for (p = default_terminal_rules; p->target != 0; ++p) + install_pattern_rule (p, 1); +} + +void +define_default_variables () +{ + register char **s; + + if (no_builtin_variables_flag) + return; + + for (s = default_variables; *s != 0; s += 2) + (void) define_variable (s[0], strlen (s[0]), s[1], o_default, 1); +} diff --git a/flaim/external/w32/make/dep.h b/flaim/external/w32/make/dep.h new file mode 100644 index 0000000..7f4380b --- /dev/null +++ b/flaim/external/w32/make/dep.h @@ -0,0 +1,78 @@ +/* Definitions of dependency data structures for GNU Make. +Copyright (C) 1988, 1989, 1991, 1992, 1993, 1996 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* Flag bits for the second argument to `read_makefile'. + These flags are saved in the `changed' field of each + `struct dep' in the chain returned by `read_all_makefiles'. */ + +#define RM_NO_DEFAULT_GOAL (1 << 0) /* Do not set default goal. */ +#define RM_INCLUDED (1 << 1) /* Search makefile search path. */ +#define RM_DONTCARE (1 << 2) /* No error if it doesn't exist. */ +#define RM_NO_TILDE (1 << 3) /* Don't expand ~ in file name. */ +#define RM_NOFLAG 0 + +/* Structure representing one dependency of a file. + Each struct file's `deps' points to a chain of these, + chained through the `next'. + + Note that the first two words of this match a struct nameseq. */ + +struct dep + { + struct dep *next; + char *name; + struct file *file; + unsigned int changed : 8; + unsigned int ignore_mtime : 1; + }; + + +/* Structure used in chains of names, for parsing and globbing. */ + +struct nameseq + { + struct nameseq *next; + char *name; + }; + + +extern struct nameseq *multi_glob PARAMS ((struct nameseq *chain, unsigned int size)); +#ifdef VMS +extern struct nameseq *parse_file_seq (); +#else +extern struct nameseq *parse_file_seq PARAMS ((char **stringp, int stopchar, unsigned int size, int strip)); +#endif +extern char *tilde_expand PARAMS ((char *name)); + +#ifndef NO_ARCHIVES +extern struct nameseq *ar_glob PARAMS ((char *arname, char *member_pattern, unsigned int size)); +#endif + +#ifndef iAPX286 +#define dep_name(d) ((d)->name == 0 ? (d)->file->name : (d)->name) +#else +/* Buggy compiler can't hack this. */ +extern char *dep_name (); +#endif + +extern struct dep *copy_dep_chain PARAMS ((struct dep *d)); +extern struct dep *read_all_makefiles PARAMS ((char **makefiles)); +extern int eval_buffer PARAMS ((char *buffer)); +extern int update_goal_chain PARAMS ((struct dep *goals, int makefiles)); +extern void uniquize_deps PARAMS ((struct dep *)); diff --git a/flaim/external/w32/make/dir.c b/flaim/external/w32/make/dir.c new file mode 100644 index 0000000..e862b9d --- /dev/null +++ b/flaim/external/w32/make/dir.c @@ -0,0 +1,1212 @@ +/* Directory hashing for GNU Make. +Copyright (C) 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "hash.h" + +#ifdef HAVE_DIRENT_H +# include +# define NAMLEN(dirent) strlen((dirent)->d_name) +# ifdef VMS +extern char *vmsify PARAMS ((char *name, int type)); +# endif +#else +# define dirent direct +# define NAMLEN(dirent) (dirent)->d_namlen +# ifdef HAVE_SYS_NDIR_H +# include +# endif +# ifdef HAVE_SYS_DIR_H +# include +# endif +# ifdef HAVE_NDIR_H +# include +# endif +# ifdef HAVE_VMSDIR_H +# include "vmsdir.h" +# endif /* HAVE_VMSDIR_H */ +#endif + +/* In GNU systems, defines this macro for us. */ +#ifdef _D_NAMLEN +# undef NAMLEN +# define NAMLEN(d) _D_NAMLEN(d) +#endif + +#if (defined (POSIX) || defined (VMS) || defined (WINDOWS32)) && !defined (__GNU_LIBRARY__) +/* Posix does not require that the d_ino field be present, and some + systems do not provide it. */ +# define REAL_DIR_ENTRY(dp) 1 +# define FAKE_DIR_ENTRY(dp) +#else +# define REAL_DIR_ENTRY(dp) (dp->d_ino != 0) +# define FAKE_DIR_ENTRY(dp) (dp->d_ino = 1) +#endif /* POSIX */ + +#ifdef __MSDOS__ +#include +#include + +/* If it's MSDOS that doesn't have _USE_LFN, disable LFN support. */ +#ifndef _USE_LFN +#define _USE_LFN 0 +#endif + +static char * +dosify (filename) + char *filename; +{ + static char dos_filename[14]; + char *df; + int i; + + if (filename == 0 || _USE_LFN) + return filename; + + /* FIXME: what about filenames which violate + 8+3 constraints, like "config.h.in", or ".emacs"? */ + if (strpbrk (filename, "\"*+,;<=>?[\\]|") != 0) + return filename; + + df = dos_filename; + + /* First, transform the name part. */ + for (i = 0; *filename != '\0' && i < 8 && *filename != '.'; ++i) + *df++ = tolower ((unsigned char)*filename++); + + /* Now skip to the next dot. */ + while (*filename != '\0' && *filename != '.') + ++filename; + if (*filename != '\0') + { + *df++ = *filename++; + for (i = 0; *filename != '\0' && i < 3 && *filename != '.'; ++i) + *df++ = tolower ((unsigned char)*filename++); + } + + /* Look for more dots. */ + while (*filename != '\0' && *filename != '.') + ++filename; + if (*filename == '.') + return filename; + *df = 0; + return dos_filename; +} +#endif /* __MSDOS__ */ + +#ifdef WINDOWS32 +#include "pathstuff.h" +#endif + +#ifdef _AMIGA +#include +#endif + +#ifdef HAVE_CASE_INSENSITIVE_FS +static char * +downcase (filename) + char *filename; +{ +#ifdef _AMIGA + static char new_filename[136]; +#else + static char new_filename[PATH_MAX]; +#endif + char *df; + int i; + + if (filename == 0) + return 0; + + df = new_filename; + + /* First, transform the name part. */ + for (i = 0; *filename != '\0'; ++i) + { + *df++ = tolower ((unsigned char)*filename); + ++filename; + } + + *df = 0; + + return new_filename; +} +#endif /* HAVE_CASE_INSENSITIVE_FS */ + +#ifdef VMS + +static int +vms_hash (name) + char *name; +{ + int h = 0; + int g; + + while (*name) + { + unsigned char uc = *name; + h = (h << 4) + (isupper (uc) ? tolower (uc) : uc); + name++; + g = h & 0xf0000000; + if (g) + { + h = h ^ (g >> 24); + h = h ^ g; + } + } + return h; +} + +/* fake stat entry for a directory */ +static int +vmsstat_dir (name, st) + char *name; + struct stat *st; +{ + char *s; + int h; + DIR *dir; + + dir = opendir (name); + if (dir == 0) + return -1; + closedir (dir); + s = strchr (name, ':'); /* find device */ + if (s) + { + *s++ = 0; + st->st_dev = (char *)vms_hash (name); + h = vms_hash (s); + *(s-1) = ':'; + } + else + { + st->st_dev = 0; + s = name; + h = vms_hash (s); + } + + st->st_ino[0] = h & 0xff; + st->st_ino[1] = h & 0xff00; + st->st_ino[2] = h >> 16; + + return 0; +} +#endif /* VMS */ + +/* Hash table of directories. */ + +#ifndef DIRECTORY_BUCKETS +#define DIRECTORY_BUCKETS 199 +#endif + +struct directory_contents + { + dev_t dev; /* Device and inode numbers of this dir. */ +#ifdef WINDOWS32 + /* + * Inode means nothing on WINDOWS32. Even file key information is + * unreliable because it is random per file open and undefined + * for remote filesystems. The most unique attribute I can + * come up with is the fully qualified name of the directory. Beware + * though, this is also unreliable. I'm open to suggestion on a better + * way to emulate inode. + */ + char *path_key; + int ctime; + int mtime; /* controls check for stale directory cache */ + int fs_flags; /* FS_FAT, FS_NTFS, ... */ +#define FS_FAT 0x1 +#define FS_NTFS 0x2 +#define FS_UNKNOWN 0x4 +#else +#ifdef VMS + ino_t ino[3]; +#else + ino_t ino; +#endif +#endif /* WINDOWS32 */ + struct hash_table dirfiles; /* Files in this directory. */ + DIR *dirstream; /* Stream reading this directory. */ + }; + +static unsigned long +directory_contents_hash_1 (key_0) + const void *key_0; +{ + struct directory_contents const *key = (struct directory_contents const *) key_0; + unsigned long hash; + +#ifdef WINDOWS32 + ISTRING_HASH_1 (key->path_key, hash); + hash ^= ((unsigned int) key->dev << 4) ^ (unsigned int) key->ctime; +#else +# ifdef VMS + hash = (((unsigned int) key->dev << 4) + ^ ((unsigned int) key->ino[0] + + (unsigned int) key->ino[1] + + (unsigned int) key->ino[2])); +# else + hash = ((unsigned int) key->dev << 4) ^ (unsigned int) key->ino; +# endif +#endif /* WINDOWS32 */ + return hash; +} + +static unsigned long +directory_contents_hash_2 (key_0) + const void *key_0; +{ + struct directory_contents const *key = (struct directory_contents const *) key_0; + unsigned long hash; + +#ifdef WINDOWS32 + ISTRING_HASH_2 (key->path_key, hash); + hash ^= ((unsigned int) key->dev << 4) ^ (unsigned int) ~key->ctime; +#else +# ifdef VMS + hash = (((unsigned int) key->dev << 4) + ^ ~((unsigned int) key->ino[0] + + (unsigned int) key->ino[1] + + (unsigned int) key->ino[2])); +# else + hash = ((unsigned int) key->dev << 4) ^ (unsigned int) ~key->ino; +# endif +#endif /* WINDOWS32 */ + + return hash; +} + +static int +directory_contents_hash_cmp (xv, yv) + const void *xv; + const void *yv; +{ + struct directory_contents const *x = (struct directory_contents const *) xv; + struct directory_contents const *y = (struct directory_contents const *) yv; + int result; + +#ifdef WINDOWS32 + ISTRING_COMPARE (x->path_key, y->path_key, result); + if (result) + return result; + result = x->ctime - y->ctime; + if (result) + return result; +#else +# ifdef VMS + result = x->ino[0] - y->ino[0]; + if (result) + return result; + result = x->ino[1] - y->ino[1]; + if (result) + return result; + result = x->ino[2] - y->ino[2]; + if (result) + return result; +# else + result = x->ino - y->ino; + if (result) + return result; +# endif +#endif /* WINDOWS32 */ + + return x->dev - y->dev; +} + +/* Table of directory contents hashed by device and inode number. */ +static struct hash_table directory_contents; + +struct directory + { + char *name; /* Name of the directory. */ + + /* The directory's contents. This data may be shared by several + entries in the hash table, which refer to the same directory + (identified uniquely by `dev' and `ino') under different names. */ + struct directory_contents *contents; + }; + +static unsigned long +directory_hash_1 (key) + const void *key; +{ + return_ISTRING_HASH_1 (((struct directory const *) key)->name); +} + +static unsigned long +directory_hash_2 (key) + const void *key; +{ + return_ISTRING_HASH_2 (((struct directory const *) key)->name); +} + +static int +directory_hash_cmp (x, y) + const void *x; + const void *y; +{ + return_ISTRING_COMPARE (((struct directory const *) x)->name, + ((struct directory const *) y)->name); +} + +/* Table of directories hashed by name. */ +static struct hash_table directories; + +/* Never have more than this many directories open at once. */ + +#define MAX_OPEN_DIRECTORIES 10 + +static unsigned int open_directories = 0; + + +/* Hash table of files in each directory. */ + +struct dirfile + { + char *name; /* Name of the file. */ + short length; + short impossible; /* This file is impossible. */ + }; + +static unsigned long +dirfile_hash_1 (key) + const void *key; +{ + return_ISTRING_HASH_1 (((struct dirfile const *) key)->name); +} + +static unsigned long +dirfile_hash_2 (key) + const void *key; +{ + return_ISTRING_HASH_2 (((struct dirfile const *) key)->name); +} + +static int +dirfile_hash_cmp (xv, yv) + const void *xv; + const void *yv; +{ + struct dirfile const *x = ((struct dirfile const *) xv); + struct dirfile const *y = ((struct dirfile const *) yv); + int result = x->length - y->length; + if (result) + return result; + return_ISTRING_COMPARE (x->name, y->name); +} + +#ifndef DIRFILE_BUCKETS +#define DIRFILE_BUCKETS 107 +#endif + +static int dir_contents_file_exists_p PARAMS ((struct directory_contents *dir, char *filename)); +static struct directory *find_directory PARAMS ((char *name)); + +/* Find the directory named NAME and return its `struct directory'. */ + +static struct directory * +find_directory (name) + register char *name; +{ + register char *p; + register struct directory *dir; + register struct directory **dir_slot; + struct directory dir_key; + int r; +#ifdef WINDOWS32 + char* w32_path; + char fs_label[BUFSIZ]; + char fs_type[BUFSIZ]; + long fs_serno; + long fs_flags; + long fs_len; +#endif +#ifdef VMS + if ((*name == '.') && (*(name+1) == 0)) + name = "[]"; + else + name = vmsify (name,1); +#endif + + dir_key.name = name; + dir_slot = (struct directory **) hash_find_slot (&directories, &dir_key); + dir = *dir_slot; + + if (HASH_VACANT (dir)) + { + struct stat st; + + /* The directory was not found. Create a new entry for it. */ + + p = name + strlen (name); + dir = (struct directory *) xmalloc (sizeof (struct directory)); + dir->name = savestring (name, p - name); + hash_insert_at (&directories, dir, dir_slot); + /* The directory is not in the name hash table. + Find its device and inode numbers, and look it up by them. */ + +#ifdef WINDOWS32 + /* Remove any trailing '\'. Windows32 stat fails even on valid + directories if they end in '\'. */ + if (p[-1] == '\\') + p[-1] = '\0'; +#endif + +#ifdef VMS + r = vmsstat_dir (name, &st); +#else + r = stat (name, &st); +#endif + +#ifdef WINDOWS32 + /* Put back the trailing '\'. If we don't, we're permanently + truncating the value! */ + if (p[-1] == '\0') + p[-1] = '\\'; +#endif + + if (r < 0) + { + /* Couldn't stat the directory. Mark this by + setting the `contents' member to a nil pointer. */ + dir->contents = 0; + } + else + { + /* Search the contents hash table; device and inode are the key. */ + + struct directory_contents *dc; + struct directory_contents **dc_slot; + struct directory_contents dc_key; + + dc_key.dev = st.st_dev; +#ifdef WINDOWS32 + dc_key.path_key = w32_path = w32ify (name, 1); + dc_key.ctime = st.st_ctime; +#else +# ifdef VMS + dc_key.ino[0] = st.st_ino[0]; + dc_key.ino[1] = st.st_ino[1]; + dc_key.ino[2] = st.st_ino[2]; +# else + dc_key.ino = st.st_ino; +# endif +#endif + dc_slot = (struct directory_contents **) hash_find_slot (&directory_contents, &dc_key); + dc = *dc_slot; + + if (HASH_VACANT (dc)) + { + /* Nope; this really is a directory we haven't seen before. */ + + dc = (struct directory_contents *) + xmalloc (sizeof (struct directory_contents)); + + /* Enter it in the contents hash table. */ + dc->dev = st.st_dev; +#ifdef WINDOWS32 + dc->path_key = xstrdup (w32_path); + dc->ctime = st.st_ctime; + dc->mtime = st.st_mtime; + + /* + * NTFS is the only WINDOWS32 filesystem that bumps mtime + * on a directory when files are added/deleted from + * a directory. + */ + w32_path[3] = '\0'; + if (GetVolumeInformation(w32_path, + fs_label, sizeof (fs_label), + &fs_serno, &fs_len, + &fs_flags, fs_type, sizeof (fs_type)) == FALSE) + dc->fs_flags = FS_UNKNOWN; + else if (!strcmp(fs_type, "FAT")) + dc->fs_flags = FS_FAT; + else if (!strcmp(fs_type, "NTFS")) + dc->fs_flags = FS_NTFS; + else + dc->fs_flags = FS_UNKNOWN; +#else +# ifdef VMS + dc->ino[0] = st.st_ino[0]; + dc->ino[1] = st.st_ino[1]; + dc->ino[2] = st.st_ino[2]; +# else + dc->ino = st.st_ino; +# endif +#endif /* WINDOWS32 */ + hash_insert_at (&directory_contents, dc, dc_slot); + dc->dirstream = opendir (name); + if (dc->dirstream == 0) + /* Couldn't open the directory. Mark this by + setting the `files' member to a nil pointer. */ + dc->dirfiles.ht_vec = 0; + else + { + hash_init (&dc->dirfiles, DIRFILE_BUCKETS, + dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp); + /* Keep track of how many directories are open. */ + ++open_directories; + if (open_directories == MAX_OPEN_DIRECTORIES) + /* We have too many directories open already. + Read the entire directory and then close it. */ + (void) dir_contents_file_exists_p (dc, (char *) 0); + } + } + + /* Point the name-hashed entry for DIR at its contents data. */ + dir->contents = dc; + } + } + + return dir; +} + +/* Return 1 if the name FILENAME is entered in DIR's hash table. + FILENAME must contain no slashes. */ + +static int +dir_contents_file_exists_p (dir, filename) + register struct directory_contents *dir; + register char *filename; +{ + unsigned int hash; + struct dirfile *df; + struct dirent *d; +#ifdef WINDOWS32 + struct stat st; + int rehash = 0; +#endif + + if (dir == 0 || dir->dirfiles.ht_vec == 0) + { + /* The directory could not be stat'd or opened. */ + return 0; + } +#ifdef __MSDOS__ + filename = dosify (filename); +#endif + +#ifdef HAVE_CASE_INSENSITIVE_FS + filename = downcase (filename); +#endif + +#ifdef VMS + filename = vmsify (filename,0); +#endif + + hash = 0; + if (filename != 0) + { + struct dirfile dirfile_key; + + if (*filename == '\0') + { + /* Checking if the directory exists. */ + return 1; + } + dirfile_key.name = filename; + dirfile_key.length = strlen (filename); + df = (struct dirfile *) hash_find_item (&dir->dirfiles, &dirfile_key); + if (df) + { + return !df->impossible; + } + } + + /* The file was not found in the hashed list. + Try to read the directory further. */ + + if (dir->dirstream == 0) + { +#ifdef WINDOWS32 + /* + * Check to see if directory has changed since last read. FAT + * filesystems force a rehash always as mtime does not change + * on directories (ugh!). + */ + if (dir->path_key + && (dir->fs_flags & FS_FAT + || (stat(dir->path_key, &st) == 0 + && st.st_mtime > dir->mtime))) + { + /* reset date stamp to show most recent re-process */ + dir->mtime = st.st_mtime; + + /* make sure directory can still be opened */ + dir->dirstream = opendir(dir->path_key); + + if (dir->dirstream) + rehash = 1; + else + return 0; /* couldn't re-read - fail */ + } + else +#endif + /* The directory has been all read in. */ + return 0; + } + + while ((d = readdir (dir->dirstream)) != 0) + { + /* Enter the file in the hash table. */ + unsigned int len; + struct dirfile dirfile_key; + struct dirfile **dirfile_slot; + +#if defined(VMS) && defined(HAVE_DIRENT_H) + /* In VMS we get file versions too, which have to be stripped off */ + { + char *p = strrchr (d->d_name, ';'); + if (p) + *p = '\0'; + } +#endif + if (!REAL_DIR_ENTRY (d)) + continue; + + len = NAMLEN (d); + dirfile_key.name = d->d_name; + dirfile_key.length = len; + dirfile_slot = (struct dirfile **) hash_find_slot (&dir->dirfiles, &dirfile_key); +#ifdef WINDOWS32 + /* + * If re-reading a directory, don't cache files that have + * already been discovered. + */ + if (! rehash || HASH_VACANT (*dirfile_slot)) +#endif + { + df = (struct dirfile *) xmalloc (sizeof (struct dirfile)); + df->name = savestring (d->d_name, len); + df->length = len; + df->impossible = 0; + hash_insert_at (&dir->dirfiles, df, dirfile_slot); + } + /* Check if the name matches the one we're searching for. */ + if (filename != 0 && strieq (d->d_name, filename)) + { + return 1; + } + } + + /* If the directory has been completely read in, + close the stream and reset the pointer to nil. */ + if (d == 0) + { + --open_directories; + closedir (dir->dirstream); + dir->dirstream = 0; + } + return 0; +} + +/* Return 1 if the name FILENAME in directory DIRNAME + is entered in the dir hash table. + FILENAME must contain no slashes. */ + +int +dir_file_exists_p (dirname, filename) + register char *dirname; + register char *filename; +{ + return dir_contents_file_exists_p (find_directory (dirname)->contents, + filename); +} + +/* Return 1 if the file named NAME exists. */ + +int +file_exists_p (name) + register char *name; +{ + char *dirend; + char *dirname; + char *slash; + +#ifndef NO_ARCHIVES + if (ar_name (name)) + return ar_member_date (name) != (time_t) -1; +#endif + +#ifdef VMS + dirend = strrchr (name, ']'); + if (dirend == 0) + dirend = strrchr (name, ':'); + dirend++; + if (dirend == (char *)1) + return dir_file_exists_p ("[]", name); +#else /* !VMS */ + dirend = strrchr (name, '/'); +#ifdef HAVE_DOS_PATHS + /* Forward and backslashes might be mixed. We need the rightmost one. */ + { + char *bslash = strrchr(name, '\\'); + if (!dirend || bslash > dirend) + dirend = bslash; + /* The case of "d:file". */ + if (!dirend && name[0] && name[1] == ':') + dirend = name + 1; + } +#endif /* HAVE_DOS_PATHS */ + if (dirend == 0) +#ifndef _AMIGA + return dir_file_exists_p (".", name); +#else /* !VMS && !AMIGA */ + return dir_file_exists_p ("", name); +#endif /* AMIGA */ +#endif /* VMS */ + + slash = dirend; + if (dirend == name) + dirname = "/"; + else + { +#ifdef HAVE_DOS_PATHS + /* d:/ and d: are *very* different... */ + if (dirend < name + 3 && name[1] == ':' && + (*dirend == '/' || *dirend == '\\' || *dirend == ':')) + dirend++; +#endif + dirname = (char *) alloca (dirend - name + 1); + bcopy (name, dirname, dirend - name); + dirname[dirend - name] = '\0'; + } + return dir_file_exists_p (dirname, slash + 1); +} + +/* Mark FILENAME as `impossible' for `file_impossible_p'. + This means an attempt has been made to search for FILENAME + as an intermediate file, and it has failed. */ + +void +file_impossible (filename) + register char *filename; +{ + char *dirend; + register char *p = filename; + register struct directory *dir; + register struct dirfile *new; + +#ifdef VMS + dirend = strrchr (p, ']'); + if (dirend == 0) + dirend = strrchr (p, ':'); + dirend++; + if (dirend == (char *)1) + dir = find_directory ("[]"); +#else + dirend = strrchr (p, '/'); +# ifdef HAVE_DOS_PATHS + /* Forward and backslashes might be mixed. We need the rightmost one. */ + { + char *bslash = strrchr(p, '\\'); + if (!dirend || bslash > dirend) + dirend = bslash; + /* The case of "d:file". */ + if (!dirend && p[0] && p[1] == ':') + dirend = p + 1; + } +# endif /* HAVE_DOS_PATHS */ + if (dirend == 0) +# ifdef _AMIGA + dir = find_directory (""); +# else /* !VMS && !AMIGA */ + dir = find_directory ("."); +# endif /* AMIGA */ +#endif /* VMS */ + else + { + char *dirname; + char *slash = dirend; + if (dirend == p) + dirname = "/"; + else + { +#ifdef HAVE_DOS_PATHS + /* d:/ and d: are *very* different... */ + if (dirend < p + 3 && p[1] == ':' && + (*dirend == '/' || *dirend == '\\' || *dirend == ':')) + dirend++; +#endif + dirname = (char *) alloca (dirend - p + 1); + bcopy (p, dirname, dirend - p); + dirname[dirend - p] = '\0'; + } + dir = find_directory (dirname); + filename = p = slash + 1; + } + + if (dir->contents == 0) + { + /* The directory could not be stat'd. We allocate a contents + structure for it, but leave it out of the contents hash table. */ + dir->contents = (struct directory_contents *) + xmalloc (sizeof (struct directory_contents)); + bzero ((char *) dir->contents, sizeof (struct directory_contents)); + } + + if (dir->contents->dirfiles.ht_vec == 0) + { + hash_init (&dir->contents->dirfiles, DIRFILE_BUCKETS, + dirfile_hash_1, dirfile_hash_2, dirfile_hash_cmp); + } + + /* Make a new entry and put it in the table. */ + + new = (struct dirfile *) xmalloc (sizeof (struct dirfile)); + new->name = xstrdup (filename); + new->length = strlen (filename); + new->impossible = 1; + hash_insert (&dir->contents->dirfiles, new); +} + +/* Return nonzero if FILENAME has been marked impossible. */ + +int +file_impossible_p (filename) + char *filename; +{ + char *dirend; + register char *p = filename; + register struct directory_contents *dir; + register struct dirfile *dirfile; + struct dirfile dirfile_key; + +#ifdef VMS + dirend = strrchr (filename, ']'); + if (dirend == 0) + dir = find_directory ("[]")->contents; +#else + dirend = strrchr (filename, '/'); +#ifdef HAVE_DOS_PATHS + /* Forward and backslashes might be mixed. We need the rightmost one. */ + { + char *bslash = strrchr(filename, '\\'); + if (!dirend || bslash > dirend) + dirend = bslash; + /* The case of "d:file". */ + if (!dirend && filename[0] && filename[1] == ':') + dirend = filename + 1; + } +#endif /* HAVE_DOS_PATHS */ + if (dirend == 0) +#ifdef _AMIGA + dir = find_directory ("")->contents; +#else /* !VMS && !AMIGA */ + dir = find_directory (".")->contents; +#endif /* AMIGA */ +#endif /* VMS */ + else + { + char *dirname; + char *slash = dirend; + if (dirend == filename) + dirname = "/"; + else + { +#ifdef HAVE_DOS_PATHS + /* d:/ and d: are *very* different... */ + if (dirend < filename + 3 && filename[1] == ':' && + (*dirend == '/' || *dirend == '\\' || *dirend == ':')) + dirend++; +#endif + dirname = (char *) alloca (dirend - filename + 1); + bcopy (p, dirname, dirend - p); + dirname[dirend - p] = '\0'; + } + dir = find_directory (dirname)->contents; + p = filename = slash + 1; + } + + if (dir == 0 || dir->dirfiles.ht_vec == 0) + /* There are no files entered for this directory. */ + return 0; + +#ifdef __MSDOS__ + filename = dosify (p); +#endif +#ifdef HAVE_CASE_INSENSITIVE_FS + filename = downcase (p); +#endif +#ifdef VMS + filename = vmsify (p, 1); +#endif + + dirfile_key.name = filename; + dirfile_key.length = strlen (filename); + dirfile = (struct dirfile *) hash_find_item (&dir->dirfiles, &dirfile_key); + if (dirfile) + return dirfile->impossible; + + return 0; +} + +/* Return the already allocated name in the + directory hash table that matches DIR. */ + +char * +dir_name (dir) + char *dir; +{ + return find_directory (dir)->name; +} + +/* Print the data base of directories. */ + +void +print_dir_data_base () +{ + register unsigned int files; + register unsigned int impossible; + register struct directory **dir_slot; + register struct directory **dir_end; + + puts (_("\n# Directories\n")); + + files = impossible = 0; + + dir_slot = (struct directory **) directories.ht_vec; + dir_end = dir_slot + directories.ht_size; + for ( ; dir_slot < dir_end; dir_slot++) + { + register struct directory *dir = *dir_slot; + if (! HASH_VACANT (dir)) + { + if (dir->contents == 0) + printf (_("# %s: could not be stat'd.\n"), dir->name); + else if (dir->contents->dirfiles.ht_vec == 0) + { +#ifdef WINDOWS32 + printf (_("# %s (key %s, mtime %d): could not be opened.\n"), + dir->name, dir->contents->path_key,dir->contents->mtime); +#else /* WINDOWS32 */ +#ifdef VMS + printf (_("# %s (device %d, inode [%d,%d,%d]): could not be opened.\n"), + dir->name, dir->contents->dev, + dir->contents->ino[0], dir->contents->ino[1], + dir->contents->ino[2]); +#else + printf (_("# %s (device %ld, inode %ld): could not be opened.\n"), + dir->name, (long int) dir->contents->dev, + (long int) dir->contents->ino); +#endif +#endif /* WINDOWS32 */ + } + else + { + register unsigned int f = 0; + register unsigned int im = 0; + register struct dirfile **files_slot; + register struct dirfile **files_end; + + files_slot = (struct dirfile **) dir->contents->dirfiles.ht_vec; + files_end = files_slot + dir->contents->dirfiles.ht_size; + for ( ; files_slot < files_end; files_slot++) + { + register struct dirfile *df = *files_slot; + if (! HASH_VACANT (df)) + { + if (df->impossible) + ++im; + else + ++f; + } + } +#ifdef WINDOWS32 + printf (_("# %s (key %s, mtime %d): "), + dir->name, dir->contents->path_key, dir->contents->mtime); +#else /* WINDOWS32 */ +#ifdef VMS + printf (_("# %s (device %d, inode [%d,%d,%d]): "), + dir->name, dir->contents->dev, + dir->contents->ino[0], dir->contents->ino[1], + dir->contents->ino[2]); +#else + printf (_("# %s (device %ld, inode %ld): "), + dir->name, + (long)dir->contents->dev, (long)dir->contents->ino); +#endif +#endif /* WINDOWS32 */ + if (f == 0) + fputs (_("No"), stdout); + else + printf ("%u", f); + fputs (_(" files, "), stdout); + if (im == 0) + fputs (_("no"), stdout); + else + printf ("%u", im); + fputs (_(" impossibilities"), stdout); + if (dir->contents->dirstream == 0) + puts ("."); + else + puts (_(" so far.")); + files += f; + impossible += im; + } + } + } + + fputs ("\n# ", stdout); + if (files == 0) + fputs (_("No"), stdout); + else + printf ("%u", files); + fputs (_(" files, "), stdout); + if (impossible == 0) + fputs (_("no"), stdout); + else + printf ("%u", impossible); + printf (_(" impossibilities in %lu directories.\n"), directories.ht_fill); +} + +/* Hooks for globbing. */ + +#include + +/* Structure describing state of iterating through a directory hash table. */ + +struct dirstream + { + struct directory_contents *contents; /* The directory being read. */ + struct dirfile **dirfile_slot; /* Current slot in table. */ + }; + +/* Forward declarations. */ +static __ptr_t open_dirstream PARAMS ((const char *)); +static struct dirent *read_dirstream PARAMS ((__ptr_t)); + +static __ptr_t +open_dirstream (directory) + const char *directory; +{ + struct dirstream *new; + struct directory *dir = find_directory ((char *)directory); + + if (dir->contents == 0 || dir->contents->dirfiles.ht_vec == 0) + /* DIR->contents is nil if the directory could not be stat'd. + DIR->contents->dirfiles is nil if it could not be opened. */ + return 0; + + /* Read all the contents of the directory now. There is no benefit + in being lazy, since glob will want to see every file anyway. */ + + (void) dir_contents_file_exists_p (dir->contents, (char *) 0); + + new = (struct dirstream *) xmalloc (sizeof (struct dirstream)); + new->contents = dir->contents; + new->dirfile_slot = (struct dirfile **) new->contents->dirfiles.ht_vec; + + return (__ptr_t) new; +} + +static struct dirent * +read_dirstream (stream) + __ptr_t stream; +{ + struct dirstream *const ds = (struct dirstream *) stream; + struct directory_contents *dc = ds->contents; + struct dirfile **dirfile_end = (struct dirfile **) dc->dirfiles.ht_vec + dc->dirfiles.ht_size; + static char *buf; + static unsigned int bufsz; + + while (ds->dirfile_slot < dirfile_end) + { + register struct dirfile *df = *ds->dirfile_slot++; + if (! HASH_VACANT (df) && !df->impossible) + { + /* The glob interface wants a `struct dirent', + so mock one up. */ + struct dirent *d; + unsigned int len = df->length + 1; + if (sizeof *d - sizeof d->d_name + len > bufsz) + { + if (buf != 0) + free (buf); + bufsz *= 2; + if (sizeof *d - sizeof d->d_name + len > bufsz) + bufsz = sizeof *d - sizeof d->d_name + len; + buf = xmalloc (bufsz); + } + d = (struct dirent *) buf; + FAKE_DIR_ENTRY (d); +#ifdef _DIRENT_HAVE_D_NAMLEN + d->d_namlen = len - 1; +#endif +#ifdef _DIRENT_HAVE_D_TYPE + d->d_type = DT_UNKNOWN; +#endif + memcpy (d->d_name, df->name, len); + return d; + } + } + + return 0; +} + +static void +ansi_free(p) + void *p; +{ + if (p) + free(p); +} + +/* On 64 bit ReliantUNIX (5.44 and above) in LFS mode, stat() is actually a + * macro for stat64(). If stat is a macro, make a local wrapper function to + * invoke it. + */ +#ifndef stat +# ifndef VMS +extern int stat (); +# endif +# define local_stat stat +#else +static int local_stat (path, buf) + char *path; + struct stat *buf; +{ + return stat (path, buf); +} +#endif + +void +dir_setup_glob (gl) + glob_t *gl; +{ + /* Bogus sunos4 compiler complains (!) about & before functions. */ + gl->gl_opendir = open_dirstream; + gl->gl_readdir = read_dirstream; + gl->gl_closedir = ansi_free; + gl->gl_stat = local_stat; + /* We don't bother setting gl_lstat, since glob never calls it. + The slot is only there for compatibility with 4.4 BSD. */ +} + +void +hash_init_directories () +{ + hash_init (&directories, DIRECTORY_BUCKETS, + directory_hash_1, directory_hash_2, directory_hash_cmp); + hash_init (&directory_contents, DIRECTORY_BUCKETS, + directory_contents_hash_1, directory_contents_hash_2, directory_contents_hash_cmp); +} diff --git a/flaim/external/w32/make/dirent.c b/flaim/external/w32/make/dirent.c new file mode 100644 index 0000000..566fba9 --- /dev/null +++ b/flaim/external/w32/make/dirent.c @@ -0,0 +1,188 @@ +#include +#include +#include +#include +#include +#include "dirent.h" + + +DIR* +opendir(const char* pDirName) +{ + struct stat sb; + DIR* pDir; + char* pEndDirName; + int nBufferLen; + + /* sanity checks */ + if (!pDirName) { + errno = EINVAL; + return NULL; + } + if (stat(pDirName, &sb) != 0) { + errno = ENOENT; + return NULL; + } + if ((sb.st_mode & S_IFMT) != S_IFDIR) { + errno = ENOTDIR; + return NULL; + } + + /* allocate a DIR structure to return */ + pDir = (DIR *) malloc(sizeof (DIR)); + + if (!pDir) + return NULL; + + /* input directory name length */ + nBufferLen = strlen(pDirName); + + /* copy input directory name to DIR buffer */ + strcpy(pDir->dir_pDirectoryName, pDirName); + + /* point to end of the copied directory name */ + pEndDirName = &pDir->dir_pDirectoryName[nBufferLen - 1]; + + /* if directory name did not end in '/' or '\', add '/' */ + if ((*pEndDirName != '/') && (*pEndDirName != '\\')) { + pEndDirName++; + *pEndDirName = '/'; + } + + /* now append the wildcard character to the buffer */ + pEndDirName++; + *pEndDirName = '*'; + pEndDirName++; + *pEndDirName = '\0'; + + /* other values defaulted */ + pDir->dir_nNumFiles = 0; + pDir->dir_hDirHandle = INVALID_HANDLE_VALUE; + pDir->dir_ulCookie = __DIRENT_COOKIE; + + return pDir; +} + +void +closedir(DIR *pDir) +{ + /* got a valid pointer? */ + if (!pDir) { + errno = EINVAL; + return; + } + + /* sanity check that this is a DIR pointer */ + if (pDir->dir_ulCookie != __DIRENT_COOKIE) { + errno = EINVAL; + return; + } + + /* close the WINDOWS32 directory handle */ + if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE) + FindClose(pDir->dir_hDirHandle); + + free(pDir); + + return; +} + +struct dirent * +readdir(DIR* pDir) +{ + WIN32_FIND_DATA wfdFindData; + + if (!pDir) { + errno = EINVAL; + return NULL; + } + + /* sanity check that this is a DIR pointer */ + if (pDir->dir_ulCookie != __DIRENT_COOKIE) { + errno = EINVAL; + return NULL; + } + + if (pDir->dir_nNumFiles == 0) { + pDir->dir_hDirHandle = FindFirstFile(pDir->dir_pDirectoryName, &wfdFindData); + if (pDir->dir_hDirHandle == INVALID_HANDLE_VALUE) + return NULL; + } else if (!FindNextFile(pDir->dir_hDirHandle, &wfdFindData)) + return NULL; + + /* bump count for next call to readdir() or telldir() */ + pDir->dir_nNumFiles++; + + /* fill in struct dirent values */ + pDir->dir_sdReturn.d_ino = -1; + strcpy(pDir->dir_sdReturn.d_name, wfdFindData.cFileName); + + return &pDir->dir_sdReturn; +} + +void +rewinddir(DIR* pDir) +{ + if (!pDir) { + errno = EINVAL; + return; + } + + /* sanity check that this is a DIR pointer */ + if (pDir->dir_ulCookie != __DIRENT_COOKIE) { + errno = EINVAL; + return; + } + + /* close the WINDOWS32 directory handle */ + if (pDir->dir_hDirHandle != INVALID_HANDLE_VALUE) + if (!FindClose(pDir->dir_hDirHandle)) + errno = EBADF; + + /* reset members which control readdir() */ + pDir->dir_hDirHandle = INVALID_HANDLE_VALUE; + pDir->dir_nNumFiles = 0; + + return; +} + +int +telldir(DIR* pDir) +{ + if (!pDir) { + errno = EINVAL; + return -1; + } + + /* sanity check that this is a DIR pointer */ + if (pDir->dir_ulCookie != __DIRENT_COOKIE) { + errno = EINVAL; + return -1; + } + + /* return number of times readdir() called */ + return pDir->dir_nNumFiles; +} + +void +seekdir(DIR* pDir, long nPosition) +{ + if (!pDir) + return; + + /* sanity check that this is a DIR pointer */ + if (pDir->dir_ulCookie != __DIRENT_COOKIE) + return; + + /* go back to beginning of directory */ + rewinddir(pDir); + + /* loop until we have found position we care about */ + for (--nPosition; nPosition && readdir(pDir); nPosition--); + + /* flag invalid nPosition value */ + if (nPosition) + errno = EINVAL; + + return; +} diff --git a/flaim/external/w32/make/dirent.h b/flaim/external/w32/make/dirent.h new file mode 100644 index 0000000..4537b05 --- /dev/null +++ b/flaim/external/w32/make/dirent.h @@ -0,0 +1,37 @@ +#ifndef _DIRENT_H +#define _DIRENT_H + +#include +#include +#include +#include + +#ifndef NAME_MAX +#define NAME_MAX 255 +#endif + +#define __DIRENT_COOKIE 0xfefeabab + + +struct dirent +{ + ino_t d_ino; /* unused - no equivalent on WINDOWS32 */ + char d_name[NAME_MAX+1]; +}; + +typedef struct dir_struct { + ULONG dir_ulCookie; + HANDLE dir_hDirHandle; + DWORD dir_nNumFiles; + char dir_pDirectoryName[NAME_MAX+1]; + struct dirent dir_sdReturn; +} DIR; + +DIR *opendir(const char *); +struct dirent *readdir(DIR *); +void rewinddir(DIR *); +void closedir(DIR *); +int telldir(DIR *); +void seekdir(DIR *, long); + +#endif diff --git a/flaim/external/w32/make/expand.c b/flaim/external/w32/make/expand.c new file mode 100644 index 0000000..6722e1b --- /dev/null +++ b/flaim/external/w32/make/expand.c @@ -0,0 +1,566 @@ +/* Variable expansion functions for GNU Make. +Copyright (C) 1988, 89, 91, 92, 93, 95 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" + +#include + +#include "filedef.h" +#include "job.h" +#include "commands.h" +#include "variable.h" +#include "rule.h" + +/* The next two describe the variable output buffer. + This buffer is used to hold the variable-expansion of a line of the + makefile. It is made bigger with realloc whenever it is too small. + variable_buffer_length is the size currently allocated. + variable_buffer is the address of the buffer. + + For efficiency, it's guaranteed that the buffer will always have + VARIABLE_BUFFER_ZONE extra bytes allocated. This allows you to add a few + extra chars without having to call a function. Note you should never use + these bytes unless you're _sure_ you have room (you know when the buffer + length was last checked. */ + +#define VARIABLE_BUFFER_ZONE 5 + +static unsigned int variable_buffer_length; +char *variable_buffer; + +/* Subroutine of variable_expand and friends: + The text to add is LENGTH chars starting at STRING to the variable_buffer. + The text is added to the buffer at PTR, and the updated pointer into + the buffer is returned as the value. Thus, the value returned by + each call to variable_buffer_output should be the first argument to + the following call. */ + +char * +variable_buffer_output (ptr, string, length) + char *ptr, *string; + unsigned int length; +{ + register unsigned int newlen = length + (ptr - variable_buffer); + + if ((newlen + VARIABLE_BUFFER_ZONE) > variable_buffer_length) + { + unsigned int offset = ptr - variable_buffer; + variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length + ? newlen + 100 + : 2 * variable_buffer_length); + variable_buffer = (char *) xrealloc (variable_buffer, + variable_buffer_length); + ptr = variable_buffer + offset; + } + + bcopy (string, ptr, length); + return ptr + length; +} + +/* Return a pointer to the beginning of the variable buffer. */ + +static char * +initialize_variable_output () +{ + /* If we don't have a variable output buffer yet, get one. */ + + if (variable_buffer == 0) + { + variable_buffer_length = 200; + variable_buffer = (char *) xmalloc (variable_buffer_length); + variable_buffer[0] = '\0'; + } + + return variable_buffer; +} + +/* Recursively expand V. The returned string is malloc'd. */ + +static char *allocated_variable_append PARAMS ((const struct variable *v)); + +char * +recursively_expand_for_file (v, file) + struct variable *v; + struct file *file; +{ + char *value; + struct variable_set_list *save = 0; + + if (v->expanding) + { + if (!v->exp_count) + /* Expanding V causes infinite recursion. Lose. */ + fatal (reading_file, + _("Recursive variable `%s' references itself (eventually)"), + v->name); + --v->exp_count; + } + + if (file) + { + save = current_variable_set_list; + current_variable_set_list = file->variables; + } + + v->expanding = 1; + if (v->append) + value = allocated_variable_append (v); + else + value = allocated_variable_expand (v->value); + v->expanding = 0; + + if (file) + current_variable_set_list = save; + + return value; +} + +/* Expand a simple reference to variable NAME, which is LENGTH chars long. */ + +#ifdef __GNUC__ +__inline +#endif +static char * +reference_variable (o, name, length) + char *o; + char *name; + unsigned int length; +{ + register struct variable *v; + char *value; + + v = lookup_variable (name, length); + + if (v == 0) + warn_undefined (name, length); + + if (v == 0 || *v->value == '\0') + return o; + + value = (v->recursive ? recursively_expand (v) : v->value); + + o = variable_buffer_output (o, value, strlen (value)); + + if (v->recursive) + free (value); + + return o; +} + +/* Scan STRING for variable references and expansion-function calls. Only + LENGTH bytes of STRING are actually scanned. If LENGTH is -1, scan until + a null byte is found. + + Write the results to LINE, which must point into `variable_buffer'. If + LINE is NULL, start at the beginning of the buffer. + Return a pointer to LINE, or to the beginning of the buffer if LINE is + NULL. */ + +char * +variable_expand_string (line, string, length) + register char *line; + char *string; + long length; +{ + register struct variable *v; + register char *p, *o, *p1; + char save_char = '\0'; + unsigned int line_offset; + + if (!line) + line = initialize_variable_output(); + + p = string; + o = line; + line_offset = line - variable_buffer; + + if (length >= 0) + { + save_char = string[length]; + string[length] = '\0'; + } + + while (1) + { + /* Copy all following uninteresting chars all at once to the + variable output buffer, and skip them. Uninteresting chars end + at the next $ or the end of the input. */ + + p1 = strchr (p, '$'); + + o = variable_buffer_output (o, p, p1 != 0 ? p1 - p : strlen (p) + 1); + + if (p1 == 0) + break; + p = p1 + 1; + + /* Dispatch on the char that follows the $. */ + + switch (*p) + { + case '$': + /* $$ seen means output one $ to the variable output buffer. */ + o = variable_buffer_output (o, p, 1); + break; + + case '(': + case '{': + /* $(...) or ${...} is the general case of substitution. */ + { + char openparen = *p; + char closeparen = (openparen == '(') ? ')' : '}'; + register char *beg = p + 1; + int free_beg = 0; + char *op, *begp; + char *end, *colon; + + op = o; + begp = p; + if (handle_function (&op, &begp)) + { + o = op; + p = begp; + break; + } + + /* Is there a variable reference inside the parens or braces? + If so, expand it before expanding the entire reference. */ + + end = strchr (beg, closeparen); + if (end == 0) + /* Unterminated variable reference. */ + fatal (reading_file, _("unterminated variable reference")); + p1 = lindex (beg, end, '$'); + if (p1 != 0) + { + /* BEG now points past the opening paren or brace. + Count parens or braces until it is matched. */ + int count = 0; + for (p = beg; *p != '\0'; ++p) + { + if (*p == openparen) + ++count; + else if (*p == closeparen && --count < 0) + break; + } + /* If COUNT is >= 0, there were unmatched opening parens + or braces, so we go to the simple case of a variable name + such as `$($(a)'. */ + if (count < 0) + { + beg = expand_argument (beg, p); /* Expand the name. */ + free_beg = 1; /* Remember to free BEG when finished. */ + end = strchr (beg, '\0'); + } + } + else + /* Advance P to the end of this reference. After we are + finished expanding this one, P will be incremented to + continue the scan. */ + p = end; + + /* This is not a reference to a built-in function and + any variable references inside are now expanded. + Is the resultant text a substitution reference? */ + + colon = lindex (beg, end, ':'); + if (colon) + { + /* This looks like a substitution reference: $(FOO:A=B). */ + char *subst_beg, *subst_end, *replace_beg, *replace_end; + + subst_beg = colon + 1; + subst_end = strchr (subst_beg, '='); + if (subst_end == 0) + /* There is no = in sight. Punt on the substitution + reference and treat this as a variable name containing + a colon, in the code below. */ + colon = 0; + else + { + replace_beg = subst_end + 1; + replace_end = end; + + /* Extract the variable name before the colon + and look up that variable. */ + v = lookup_variable (beg, colon - beg); + if (v == 0) + warn_undefined (beg, colon - beg); + + if (v != 0 && *v->value != '\0') + { + char *value = (v->recursive ? recursively_expand (v) + : v->value); + char *pattern, *percent; + if (free_beg) + { + *subst_end = '\0'; + pattern = subst_beg; + } + else + { + pattern = (char *) alloca (subst_end - subst_beg + + 1); + bcopy (subst_beg, pattern, subst_end - subst_beg); + pattern[subst_end - subst_beg] = '\0'; + } + percent = find_percent (pattern); + if (percent != 0) + { + char *replace; + if (free_beg) + { + *replace_end = '\0'; + replace = replace_beg; + } + else + { + replace = (char *) alloca (replace_end + - replace_beg + + 1); + bcopy (replace_beg, replace, + replace_end - replace_beg); + replace[replace_end - replace_beg] = '\0'; + } + + o = patsubst_expand (o, value, pattern, replace, + percent, (char *) 0); + } + else + o = subst_expand (o, value, + pattern, replace_beg, + strlen (pattern), + end - replace_beg, + 0, 1); + if (v->recursive) + free (value); + } + } + } + + if (colon == 0) + /* This is an ordinary variable reference. + Look up the value of the variable. */ + o = reference_variable (o, beg, end - beg); + + if (free_beg) + free (beg); + } + break; + + case '\0': + break; + + default: + if (isblank ((unsigned char)p[-1])) + break; + + /* A $ followed by a random char is a variable reference: + $a is equivalent to $(a). */ + { + /* We could do the expanding here, but this way + avoids code repetition at a small performance cost. */ + char name[5]; + name[0] = '$'; + name[1] = '('; + name[2] = *p; + name[3] = ')'; + name[4] = '\0'; + p1 = allocated_variable_expand (name); + o = variable_buffer_output (o, p1, strlen (p1)); + free (p1); + } + + break; + } + + if (*p == '\0') + break; + else + ++p; + } + + if (save_char) + string[length] = save_char; + + (void)variable_buffer_output (o, "", 1); + return (variable_buffer + line_offset); +} + +/* Scan LINE for variable references and expansion-function calls. + Build in `variable_buffer' the result of expanding the references and calls. + Return the address of the resulting string, which is null-terminated + and is valid only until the next time this function is called. */ + +char * +variable_expand (line) + char *line; +{ + return variable_expand_string(NULL, line, (long)-1); +} + +/* Expand an argument for an expansion function. + The text starting at STR and ending at END is variable-expanded + into a null-terminated string that is returned as the value. + This is done without clobbering `variable_buffer' or the current + variable-expansion that is in progress. */ + +char * +expand_argument (str, end) + char *str, *end; +{ + char *tmp; + + if (str == end) + return xstrdup(""); + + if (!end || *end == '\0') + tmp = str; + else + { + tmp = (char *) alloca (end - str + 1); + bcopy (str, tmp, end - str); + tmp[end - str] = '\0'; + } + + return allocated_variable_expand (tmp); +} + +/* Expand LINE for FILE. Error messages refer to the file and line where + FILE's commands were found. Expansion uses FILE's variable set list. */ + +static char * +variable_expand_for_file (line, file) + char *line; + register struct file *file; +{ + char *result; + struct variable_set_list *save; + + if (file == 0) + return variable_expand (line); + + save = current_variable_set_list; + current_variable_set_list = file->variables; + if (file->cmds && file->cmds->fileinfo.filenm) + reading_file = &file->cmds->fileinfo; + else + reading_file = 0; + result = variable_expand (line); + current_variable_set_list = save; + reading_file = 0; + + return result; +} + +/* Like allocated_variable_expand, but for += target-specific variables. + First recursively construct the variable value from its appended parts in + any upper variable sets. Then expand the resulting value. */ + +static char * +variable_append (name, length, set) + const char *name; + unsigned int length; + const struct variable_set_list *set; +{ + const struct variable *v; + char *buf = 0; + + /* If there's nothing left to check, return the empty buffer. */ + if (!set) + return initialize_variable_output (); + + /* Try to find the variable in this variable set. */ + v = lookup_variable_in_set (name, length, set->set); + + /* If there isn't one, look to see if there's one in a set above us. */ + if (!v) + return variable_append (name, length, set->next); + + /* If this variable type is append, first get any upper values. + If not, initialize the buffer. */ + if (v->append) + buf = variable_append (name, length, set->next); + else + buf = initialize_variable_output (); + + /* Append this value to the buffer, and return it. + If we already have a value, first add a space. */ + if (buf > variable_buffer) + buf = variable_buffer_output (buf, " ", 1); + + return variable_buffer_output (buf, v->value, strlen (v->value)); +} + + +static char * +allocated_variable_append (v) + const struct variable *v; +{ + char *val, *retval; + + /* Construct the appended variable value. */ + + char *obuf = variable_buffer; + unsigned int olen = variable_buffer_length; + + variable_buffer = 0; + + val = variable_append (v->name, strlen (v->name), current_variable_set_list); + variable_buffer_output (val, "", 1); + val = variable_buffer; + + variable_buffer = obuf; + variable_buffer_length = olen; + + /* Now expand it and return that. */ + + retval = allocated_variable_expand (val); + + free (val); + return retval; +} + +/* Like variable_expand_for_file, but the returned string is malloc'd. + This function is called a lot. It wants to be efficient. */ + +char * +allocated_variable_expand_for_file (line, file) + char *line; + struct file *file; +{ + char *value; + + char *obuf = variable_buffer; + unsigned int olen = variable_buffer_length; + + variable_buffer = 0; + + value = variable_expand_for_file (line, file); + +#if 0 + /* Waste a little memory and save time. */ + value = xrealloc (value, strlen (value)) +#endif + + variable_buffer = obuf; + variable_buffer_length = olen; + + return value; +} diff --git a/flaim/external/w32/make/file.c b/flaim/external/w32/make/file.c new file mode 100644 index 0000000..ce1a0f9 --- /dev/null +++ b/flaim/external/w32/make/file.c @@ -0,0 +1,827 @@ +/* Target file hash table management for GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" + +#include + +#include "dep.h" +#include "filedef.h" +#include "job.h" +#include "commands.h" +#include "variable.h" +#include "debug.h" +#include "hash.h" + + +/* Hash table of files the makefile knows how to make. */ + +static unsigned long +file_hash_1 (key) + const void *key; +{ + return_ISTRING_HASH_1 (((struct file const *) key)->hname); +} + +static unsigned long +file_hash_2 (key) + const void *key; +{ + return_ISTRING_HASH_2 (((struct file const *) key)->hname); +} + +static int +file_hash_cmp (x, y) + const void *x; + const void *y; +{ + return_ISTRING_COMPARE (((struct file const *) x)->hname, + ((struct file const *) y)->hname); +} + +#ifndef FILE_BUCKETS +#define FILE_BUCKETS 1007 +#endif +static struct hash_table files; + +/* Whether or not .SECONDARY with no prerequisites was given. */ +static int all_secondary = 0; + +/* Access the hash table of all file records. + lookup_file given a name, return the struct file * for that name, + or nil if there is none. + enter_file similar, but create one if there is none. */ + +struct file * +lookup_file (name) + char *name; +{ + register struct file *f; + struct file file_key; +#if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS) + register char *lname, *ln; +#endif + + assert (*name != '\0'); + + /* This is also done in parse_file_seq, so this is redundant + for names read from makefiles. It is here for names passed + on the command line. */ +#ifdef VMS +# ifndef WANT_CASE_SENSITIVE_TARGETS + { + register char *n; + lname = (char *) malloc (strlen (name) + 1); + for (n = name, ln = lname; *n != '\0'; ++n, ++ln) + *ln = isupper ((unsigned char)*n) ? tolower ((unsigned char)*n) : *n; + *ln = '\0'; + name = lname; + } +# endif + + while (name[0] == '[' && name[1] == ']' && name[2] != '\0') + name += 2; +#endif + while (name[0] == '.' && name[1] == '/' && name[2] != '\0') + { + name += 2; + while (*name == '/') + /* Skip following slashes: ".//foo" is "foo", not "/foo". */ + ++name; + } + + if (*name == '\0') + /* It was all slashes after a dot. */ +#ifdef VMS + name = "[]"; +#else +#ifdef _AMIGA + name = ""; +#else + name = "./"; +#endif /* AMIGA */ +#endif /* VMS */ + + file_key.hname = name; + f = (struct file *) hash_find_item (&files, &file_key); +#if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS) + free (lname); +#endif + return f; +} + +struct file * +enter_file (name) + char *name; +{ + register struct file *f; + register struct file *new; + register struct file **file_slot; + struct file file_key; +#if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS) + char *lname, *ln; +#endif + + assert (*name != '\0'); + +#if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS) + { + register char *n; + lname = (char *) malloc (strlen (name) + 1); + for (n = name, ln = lname; *n != '\0'; ++n, ++ln) + { + if (isupper ((unsigned char)*n)) + *ln = tolower ((unsigned char)*n); + else + *ln = *n; + } + + *ln = 0; + /* Creates a possible leak, old value of name is unreachable, but I + currently don't know how to fix it. */ + name = lname; + } +#endif + + file_key.hname = name; + file_slot = (struct file **) hash_find_slot (&files, &file_key); + f = *file_slot; + if (! HASH_VACANT (f) && !f->double_colon) + { +#if defined(VMS) && !defined(WANT_CASE_SENSITIVE_TARGETS) + free(lname); +#endif + return f; + } + + new = (struct file *) xmalloc (sizeof (struct file)); + bzero ((char *) new, sizeof (struct file)); + new->name = new->hname = name; + new->update_status = -1; + + if (HASH_VACANT (f)) + hash_insert_at (&files, new, file_slot); + else + { + /* There is already a double-colon entry for this file. */ + new->double_colon = f; + while (f->prev != 0) + f = f->prev; + f->prev = new; + } + + return new; +} + +/* Rename FILE to NAME. This is not as simple as resetting + the `name' member, since it must be put in a new hash bucket, + and possibly merged with an existing file called NAME. */ + +void +rename_file (from_file, to_hname) + register struct file *from_file; + char *to_hname; +{ + rehash_file (from_file, to_hname); + while (from_file) + { + from_file->name = from_file->hname; + from_file = from_file->prev; + } +} + +/* Rehash FILE to NAME. This is not as simple as resetting + the `hname' member, since it must be put in a new hash bucket, + and possibly merged with an existing file called NAME. */ + +void +rehash_file (from_file, to_hname) + register struct file *from_file; + char *to_hname; +{ + struct file file_key; + struct file **file_slot; + struct file *to_file; + struct file *deleted_file; + struct file *f; + + file_key.hname = to_hname; + if (0 == file_hash_cmp (from_file, &file_key)) + return; + + file_key.hname = from_file->hname; + while (from_file->renamed != 0) + from_file = from_file->renamed; + if (file_hash_cmp (from_file, &file_key)) + /* hname changed unexpectedly */ + abort (); + + deleted_file = hash_delete (&files, from_file); + if (deleted_file != from_file) + /* from_file isn't the one stored in files */ + abort (); + + file_key.hname = to_hname; + file_slot = (struct file **) hash_find_slot (&files, &file_key); + to_file = *file_slot; + + from_file->hname = to_hname; + for (f = from_file->double_colon; f != 0; f = f->prev) + f->hname = to_hname; + + if (HASH_VACANT (to_file)) + hash_insert_at (&files, from_file, file_slot); + else + { + /* TO_FILE already exists under TO_HNAME. + We must retain TO_FILE and merge FROM_FILE into it. */ + + if (from_file->cmds != 0) + { + if (to_file->cmds == 0) + to_file->cmds = from_file->cmds; + else if (from_file->cmds != to_file->cmds) + { + /* We have two sets of commands. We will go with the + one given in the rule explicitly mentioning this name, + but give a message to let the user know what's going on. */ + if (to_file->cmds->fileinfo.filenm != 0) + error (&from_file->cmds->fileinfo, + _("Commands were specified for file `%s' at %s:%lu,"), + from_file->name, to_file->cmds->fileinfo.filenm, + to_file->cmds->fileinfo.lineno); + else + error (&from_file->cmds->fileinfo, + _("Commands for file `%s' were found by implicit rule search,"), + from_file->name); + error (&from_file->cmds->fileinfo, + _("but `%s' is now considered the same file as `%s'."), + from_file->name, to_hname); + error (&from_file->cmds->fileinfo, + _("Commands for `%s' will be ignored in favor of those for `%s'."), + to_hname, from_file->name); + } + } + + /* Merge the dependencies of the two files. */ + + if (to_file->deps == 0) + to_file->deps = from_file->deps; + else + { + register struct dep *deps = to_file->deps; + while (deps->next != 0) + deps = deps->next; + deps->next = from_file->deps; + } + + merge_variable_set_lists (&to_file->variables, from_file->variables); + + if (to_file->double_colon && from_file->is_target && !from_file->double_colon) + fatal (NILF, _("can't rename single-colon `%s' to double-colon `%s'"), + from_file->name, to_hname); + if (!to_file->double_colon && from_file->double_colon) + { + if (to_file->is_target) + fatal (NILF, _("can't rename double-colon `%s' to single-colon `%s'"), + from_file->name, to_hname); + else + to_file->double_colon = from_file->double_colon; + } + + if (from_file->last_mtime > to_file->last_mtime) + /* %%% Kludge so -W wins on a file that gets vpathized. */ + to_file->last_mtime = from_file->last_mtime; + + to_file->mtime_before_update = from_file->mtime_before_update; + +#define MERGE(field) to_file->field |= from_file->field + MERGE (precious); + MERGE (tried_implicit); + MERGE (updating); + MERGE (updated); + MERGE (is_target); + MERGE (cmd_target); + MERGE (phony); + MERGE (ignore_vpath); +#undef MERGE + + from_file->renamed = to_file; + } +} + +/* Remove all nonprecious intermediate files. + If SIG is nonzero, this was caused by a fatal signal, + meaning that a different message will be printed, and + the message will go to stderr rather than stdout. */ + +void +remove_intermediates (sig) + int sig; +{ + register struct file **file_slot; + register struct file **file_end; + int doneany = 0; + + /* If there's no way we will ever remove anything anyway, punt early. */ + if (question_flag || touch_flag || all_secondary) + return; + + if (sig && just_print_flag) + return; + + file_slot = (struct file **) files.ht_vec; + file_end = file_slot + files.ht_size; + for ( ; file_slot < file_end; file_slot++) + if (! HASH_VACANT (*file_slot)) + { + register struct file *f = *file_slot; + if (f->intermediate && (f->dontcare || !f->precious) + && !f->secondary && !f->cmd_target) + { + int status; + if (f->update_status == -1) + /* If nothing would have created this file yet, + don't print an "rm" command for it. */ + continue; + if (just_print_flag) + status = 0; + else + { + status = unlink (f->name); + if (status < 0 && errno == ENOENT) + continue; + } + if (!f->dontcare) + { + if (sig) + error (NILF, _("*** Deleting intermediate file `%s'"), f->name); + else + { + if (! doneany) + DB (DB_BASIC, (_("Removing intermediate files...\n"))); + if (!silent_flag) + { + if (! doneany) + { + fputs ("rm ", stdout); + doneany = 1; + } + else + putchar (' '); + fputs (f->name, stdout); + fflush (stdout); + } + } + if (status < 0) + perror_with_name ("unlink: ", f->name); + } + } + } + + if (doneany && !sig) + { + putchar ('\n'); + fflush (stdout); + } +} + +/* For each dependency of each file, make the `struct dep' point + at the appropriate `struct file' (which may have to be created). + + Also mark the files depended on by .PRECIOUS, .PHONY, .SILENT, + and various other special targets. */ + +void +snap_deps () +{ + register struct file *f; + register struct file *f2; + register struct dep *d; + register struct file **file_slot_0; + register struct file **file_slot; + register struct file **file_end; + + /* Enter each dependency name as a file. */ + /* We must use hash_dump (), because within this loop + we might add new files to the table, possibly causing + an in-situ table expansion. */ + file_slot_0 = (struct file **) hash_dump (&files, 0, 0); + file_end = file_slot_0 + files.ht_fill; + for (file_slot = file_slot_0; file_slot < file_end; file_slot++) + for (f2 = *file_slot; f2 != 0; f2 = f2->prev) + for (d = f2->deps; d != 0; d = d->next) + if (d->name != 0) + { + d->file = lookup_file (d->name); + if (d->file == 0) + d->file = enter_file (d->name); + else + free (d->name); + d->name = 0; + } + free (file_slot_0); + + for (f = lookup_file (".PRECIOUS"); f != 0; f = f->prev) + for (d = f->deps; d != 0; d = d->next) + for (f2 = d->file; f2 != 0; f2 = f2->prev) + f2->precious = 1; + + for (f = lookup_file (".LOW_RESOLUTION_TIME"); f != 0; f = f->prev) + for (d = f->deps; d != 0; d = d->next) + for (f2 = d->file; f2 != 0; f2 = f2->prev) + f2->low_resolution_time = 1; + + for (f = lookup_file (".PHONY"); f != 0; f = f->prev) + for (d = f->deps; d != 0; d = d->next) + for (f2 = d->file; f2 != 0; f2 = f2->prev) + { + /* Mark this file as phony and nonexistent. */ + f2->phony = 1; + f2->last_mtime = NONEXISTENT_MTIME; + f2->mtime_before_update = NONEXISTENT_MTIME; + } + + for (f = lookup_file (".INTERMEDIATE"); f != 0; f = f->prev) + { + /* .INTERMEDIATE with deps listed + marks those deps as intermediate files. */ + for (d = f->deps; d != 0; d = d->next) + for (f2 = d->file; f2 != 0; f2 = f2->prev) + f2->intermediate = 1; + /* .INTERMEDIATE with no deps does nothing. + Marking all files as intermediates is useless + since the goal targets would be deleted after they are built. */ + } + + for (f = lookup_file (".SECONDARY"); f != 0; f = f->prev) + { + /* .SECONDARY with deps listed + marks those deps as intermediate files + in that they don't get rebuilt if not actually needed; + but unlike real intermediate files, + these are not deleted after make finishes. */ + if (f->deps) + for (d = f->deps; d != 0; d = d->next) + for (f2 = d->file; f2 != 0; f2 = f2->prev) + f2->intermediate = f2->secondary = 1; + /* .SECONDARY with no deps listed marks *all* files that way. */ + else + all_secondary = 1; + } + + f = lookup_file (".EXPORT_ALL_VARIABLES"); + if (f != 0 && f->is_target) + export_all_variables = 1; + + f = lookup_file (".IGNORE"); + if (f != 0 && f->is_target) + { + if (f->deps == 0) + ignore_errors_flag = 1; + else + for (d = f->deps; d != 0; d = d->next) + for (f2 = d->file; f2 != 0; f2 = f2->prev) + f2->command_flags |= COMMANDS_NOERROR; + } + + f = lookup_file (".SILENT"); + if (f != 0 && f->is_target) + { + if (f->deps == 0) + silent_flag = 1; + else + for (d = f->deps; d != 0; d = d->next) + for (f2 = d->file; f2 != 0; f2 = f2->prev) + f2->command_flags |= COMMANDS_SILENT; + } + + f = lookup_file (".POSIX"); + if (f != 0 && f->is_target) + posix_pedantic = 1; + + f = lookup_file (".NOTPARALLEL"); + if (f != 0 && f->is_target) + not_parallel = 1; +} + +/* Set the `command_state' member of FILE and all its `also_make's. */ + +void +set_command_state (file, state) + struct file *file; + int state; +{ + struct dep *d; + + file->command_state = state; + + for (d = file->also_make; d != 0; d = d->next) + d->file->command_state = state; +} + +/* Convert an external file timestamp to internal form. */ + +FILE_TIMESTAMP +file_timestamp_cons (fname, s, ns) + char const *fname; + time_t s; + int ns; +{ + int offset = ORDINARY_MTIME_MIN + (FILE_TIMESTAMP_HI_RES ? ns : 0); + FILE_TIMESTAMP product = (FILE_TIMESTAMP) s << FILE_TIMESTAMP_LO_BITS; + FILE_TIMESTAMP ts = product + offset; + + if (! (s <= FILE_TIMESTAMP_S (ORDINARY_MTIME_MAX) + && product <= ts && ts <= ORDINARY_MTIME_MAX)) + { + char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1]; + ts = s <= OLD_MTIME ? ORDINARY_MTIME_MIN : ORDINARY_MTIME_MAX; + file_timestamp_sprintf (buf, ts); + error (NILF, _("%s: Timestamp out of range; substituting %s"), + fname ? fname : _("Current time"), buf); + } + + return ts; +} + +/* Return the current time as a file timestamp, setting *RESOLUTION to + its resolution. */ +FILE_TIMESTAMP +file_timestamp_now (resolution) + int *resolution; +{ + int r; + time_t s; + int ns; + + /* Don't bother with high-resolution clocks if file timestamps have + only one-second resolution. The code below should work, but it's + not worth the hassle of debugging it on hosts where it fails. */ +#if FILE_TIMESTAMP_HI_RES +# if HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME + { + struct timespec timespec; + if (clock_gettime (CLOCK_REALTIME, ×pec) == 0) + { + r = 1; + s = timespec.tv_sec; + ns = timespec.tv_nsec; + goto got_time; + } + } +# endif +# if HAVE_GETTIMEOFDAY + { + struct timeval timeval; + if (gettimeofday (&timeval, 0) == 0) + { + r = 1000; + s = timeval.tv_sec; + ns = timeval.tv_usec * 1000; + goto got_time; + } + } +# endif +#endif + + r = 1000000000; + s = time ((time_t *) 0); + ns = 0; + + got_time: + *resolution = r; + return file_timestamp_cons (0, s, ns); +} + +/* Place into the buffer P a printable representation of the file + timestamp TS. */ +void +file_timestamp_sprintf (p, ts) + char *p; + FILE_TIMESTAMP ts; +{ + time_t t = FILE_TIMESTAMP_S (ts); + struct tm *tm = localtime (&t); + + if (tm) + sprintf (p, "%04d-%02d-%02d %02d:%02d:%02d", + tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, + tm->tm_hour, tm->tm_min, tm->tm_sec); + else if (t < 0) + sprintf (p, "%ld", (long) t); + else + sprintf (p, "%lu", (unsigned long) t); + p += strlen (p); + + /* Append nanoseconds as a fraction, but remove trailing zeros. + We don't know the actual timestamp resolution, since clock_getres + applies only to local times, whereas this timestamp might come + from a remote filesystem. So removing trailing zeros is the + best guess that we can do. */ + sprintf (p, ".%09d", FILE_TIMESTAMP_NS (ts)); + p += strlen (p) - 1; + while (*p == '0') + p--; + p += *p != '.'; + + *p = '\0'; +} + +/* Print the data base of files. */ + +static void +print_file (f) + struct file *f; +{ + struct dep *d; + struct dep *ood = 0; + + putchar ('\n'); + if (!f->is_target) + puts (_("# Not a target:")); + printf ("%s:%s", f->name, f->double_colon ? ":" : ""); + + /* Print all normal dependencies; note any order-only deps. */ + for (d = f->deps; d != 0; d = d->next) + if (! d->ignore_mtime) + printf (" %s", dep_name (d)); + else if (! ood) + ood = d; + + /* Print order-only deps, if we have any. */ + if (ood) + { + printf (" | %s", dep_name (ood)); + for (d = ood->next; d != 0; d = d->next) + if (d->ignore_mtime) + printf (" %s", dep_name (d)); + } + + putchar ('\n'); + + if (f->precious) + puts (_("# Precious file (prerequisite of .PRECIOUS).")); + if (f->phony) + puts (_("# Phony target (prerequisite of .PHONY).")); + if (f->cmd_target) + puts (_("# Command-line target.")); + if (f->dontcare) + puts (_("# A default or MAKEFILES makefile.")); + puts (f->tried_implicit + ? _("# Implicit rule search has been done.") + : _("# Implicit rule search has not been done.")); + if (f->stem != 0) + printf (_("# Implicit/static pattern stem: `%s'\n"), f->stem); + if (f->intermediate) + puts (_("# File is an intermediate prerequisite.")); + if (f->also_make != 0) + { + fputs (_("# Also makes:"), stdout); + for (d = f->also_make; d != 0; d = d->next) + printf (" %s", dep_name (d)); + putchar ('\n'); + } + if (f->last_mtime == UNKNOWN_MTIME) + puts (_("# Modification time never checked.")); + else if (f->last_mtime == NONEXISTENT_MTIME) + puts (_("# File does not exist.")); + else if (f->last_mtime == OLD_MTIME) + puts (_("# File is very old.")); + else + { + char buf[FILE_TIMESTAMP_PRINT_LEN_BOUND + 1]; + file_timestamp_sprintf (buf, f->last_mtime); + printf (_("# Last modified %s\n"), buf); + } + puts (f->updated + ? _("# File has been updated.") : _("# File has not been updated.")); + switch (f->command_state) + { + case cs_running: + puts (_("# Commands currently running (THIS IS A BUG).")); + break; + case cs_deps_running: + puts (_("# Dependencies commands running (THIS IS A BUG).")); + break; + case cs_not_started: + case cs_finished: + switch (f->update_status) + { + case -1: + break; + case 0: + puts (_("# Successfully updated.")); + break; + case 1: + assert (question_flag); + puts (_("# Needs to be updated (-q is set).")); + break; + case 2: + puts (_("# Failed to be updated.")); + break; + default: + puts (_("# Invalid value in `update_status' member!")); + fflush (stdout); + fflush (stderr); + abort (); + } + break; + default: + puts (_("# Invalid value in `command_state' member!")); + fflush (stdout); + fflush (stderr); + abort (); + } + + if (f->variables != 0) + print_file_variables (f); + + if (f->cmds != 0) + print_commands (f->cmds); +} + +void +print_file_data_base () +{ + puts (_("\n# Files")); + + hash_map (&files, print_file); + + fputs (_("\n# files hash-table stats:\n# "), stdout); + hash_print_stats (&files, stdout); +} + +#define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500) + +char * +build_target_list (value) + char *value; +{ + static unsigned long last_targ_count = 0; + + if (files.ht_fill != last_targ_count) + { + unsigned long max = EXPANSION_INCREMENT (strlen (value)); + unsigned long len; + char *p; + struct file **fp = (struct file **) files.ht_vec; + struct file **end = &fp[files.ht_size]; + + /* Make sure we have at least MAX bytes in the allocated buffer. */ + value = xrealloc (value, max); + + p = value; + len = 0; + for (; fp < end; ++fp) + if (!HASH_VACANT (*fp) && (*fp)->is_target) + { + struct file *f = *fp; + int l = strlen (f->name); + + len += l + 1; + if (len > max) + { + unsigned long off = p - value; + + max += EXPANSION_INCREMENT (l + 1); + value = xrealloc (value, max); + p = &value[off]; + } + + bcopy (f->name, p, l); + p += l; + *(p++) = ' '; + } + *(p-1) = '\0'; + + last_targ_count = files.ht_fill; + } + + return value; +} + +void +init_hash_files () +{ + hash_init (&files, 1000, file_hash_1, file_hash_2, file_hash_cmp); +} + +/* EOF */ diff --git a/flaim/external/w32/make/filedef.h b/flaim/external/w32/make/filedef.h new file mode 100644 index 0000000..b7d6e67 --- /dev/null +++ b/flaim/external/w32/make/filedef.h @@ -0,0 +1,199 @@ +/* Definition of target file data structures for GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1997, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + + +/* Structure that represents the info on one file + that the makefile says how to make. + All of these are chained together through `next'. */ + +#include "hash.h" + +struct file + { + char *name; + char *hname; /* Hashed filename */ + char *vpath; /* VPATH/vpath pathname */ + struct dep *deps; /* all dependencies, including duplicates */ + struct commands *cmds; /* Commands to execute for this target. */ + int command_flags; /* Flags OR'd in for cmds; see commands.h. */ + char *stem; /* Implicit stem, if an implicit + rule has been used */ + struct dep *also_make; /* Targets that are made by making this. */ + FILE_TIMESTAMP last_mtime; /* File's modtime, if already known. */ + FILE_TIMESTAMP mtime_before_update; /* File's modtime before any updating + has been performed. */ + struct file *prev; /* Previous entry for same file name; + used when there are multiple double-colon + entries for the same file. */ + + /* File that this file was renamed to. After any time that a + file could be renamed, call `check_renamed' (below). */ + struct file *renamed; + + /* List of variable sets used for this file. */ + struct variable_set_list *variables; + + /* Pattern-specific variable reference for this target, or null if there + isn't one. Also see the pat_searched flag, below. */ + struct variable_set_list *pat_variables; + + /* Immediate dependent that caused this target to be remade, + or nil if there isn't one. */ + struct file *parent; + + /* For a double-colon entry, this is the first double-colon entry for + the same file. Otherwise this is null. */ + struct file *double_colon; + + short int update_status; /* Status of the last attempt to update, + or -1 if none has been made. */ + + enum /* State of the commands. */ + { /* Note: It is important that cs_not_started be zero. */ + cs_not_started, /* Not yet started. */ + cs_deps_running, /* Dep commands running. */ + cs_running, /* Commands running. */ + cs_finished /* Commands finished. */ + } command_state ENUM_BITFIELD (2); + + unsigned int precious:1; /* Non-0 means don't delete file on quit */ + unsigned int low_resolution_time:1; /* Nonzero if this file's time stamp + has only one-second resolution. */ + unsigned int tried_implicit:1; /* Nonzero if have searched + for implicit rule for making + this file; don't search again. */ + unsigned int updating:1; /* Nonzero while updating deps of this file */ + unsigned int updated:1; /* Nonzero if this file has been remade. */ + unsigned int is_target:1; /* Nonzero if file is described as target. */ + unsigned int cmd_target:1; /* Nonzero if file was given on cmd line. */ + unsigned int phony:1; /* Nonzero if this is a phony file + i.e., a dependency of .PHONY. */ + unsigned int intermediate:1;/* Nonzero if this is an intermediate file. */ + /* Nonzero, for an intermediate file, + means remove_intermediates should not delete it. */ + unsigned int secondary:1; + unsigned int dontcare:1; /* Nonzero if no complaint is to be made if + this target cannot be remade. */ + unsigned int ignore_vpath:1;/* Nonzero if we threw out VPATH name. */ + unsigned int pat_searched:1;/* Nonzero if we already searched for + pattern-specific variables. */ + unsigned int considered:1; /* equal to `considered' if file has been + considered on current scan of goal chain */ + }; + + +extern struct file *default_goal_file, *suffix_file, *default_file; + + +extern struct file *lookup_file PARAMS ((char *name)); +extern struct file *enter_file PARAMS ((char *name)); +extern void remove_intermediates PARAMS ((int sig)); +extern void snap_deps PARAMS ((void)); +extern void rename_file PARAMS ((struct file *file, char *name)); +extern void rehash_file PARAMS ((struct file *file, char *name)); +extern void set_command_state PARAMS ((struct file *file, int state)); +extern void notice_finished_file PARAMS ((struct file *file)); +extern void init_hash_files PARAMS ((void)); +extern char *build_target_list PARAMS ((char *old_list)); + +#if FILE_TIMESTAMP_HI_RES +# define FILE_TIMESTAMP_STAT_MODTIME(fname, st) \ + file_timestamp_cons (fname, (st).st_mtime, (st).st_mtim.ST_MTIM_NSEC) +#else +# define FILE_TIMESTAMP_STAT_MODTIME(fname, st) \ + file_timestamp_cons (fname, (st).st_mtime, 0) +#endif + +/* If FILE_TIMESTAMP is 64 bits (or more), use nanosecond resolution. + (Multiply by 2**30 instead of by 10**9 to save time at the cost of + slightly decreasing the number of available timestamps.) With + 64-bit FILE_TIMESTAMP, this stops working on 2514-05-30 01:53:04 + UTC, but by then uintmax_t should be larger than 64 bits. */ +#define FILE_TIMESTAMPS_PER_S (FILE_TIMESTAMP_HI_RES ? 1000000000 : 1) +#define FILE_TIMESTAMP_LO_BITS (FILE_TIMESTAMP_HI_RES ? 30 : 0) + +#define FILE_TIMESTAMP_S(ts) (((ts) - ORDINARY_MTIME_MIN) \ + >> FILE_TIMESTAMP_LO_BITS) +#define FILE_TIMESTAMP_NS(ts) ((int) (((ts) - ORDINARY_MTIME_MIN) \ + & ((1 << FILE_TIMESTAMP_LO_BITS) - 1))) + +/* Upper bound on length of string "YYYY-MM-DD HH:MM:SS.NNNNNNNNN" + representing a file timestamp. The upper bound is not necessarily 19, + since the year might be less than -999 or greater than 9999. + + Subtract one for the sign bit if in case file timestamps can be negative; + subtract FLOOR_LOG2_SECONDS_PER_YEAR to yield an upper bound on how many + file timestamp bits might affect the year; + 302 / 1000 is log10 (2) rounded up; + add one for integer division truncation; + add one more for a minus sign if file timestamps can be negative; + add 4 to allow for any 4-digit epoch year (e.g. 1970); + add 25 to allow for "-MM-DD HH:MM:SS.NNNNNNNNN". */ +#define FLOOR_LOG2_SECONDS_PER_YEAR 24 +#define FILE_TIMESTAMP_PRINT_LEN_BOUND \ + (((sizeof (FILE_TIMESTAMP) * CHAR_BIT - 1 - FLOOR_LOG2_SECONDS_PER_YEAR) \ + * 302 / 1000) \ + + 1 + 1 + 4 + 25) + +extern FILE_TIMESTAMP file_timestamp_cons PARAMS ((char const *, + time_t, int)); +extern FILE_TIMESTAMP file_timestamp_now PARAMS ((int *)); +extern void file_timestamp_sprintf PARAMS ((char *p, FILE_TIMESTAMP ts)); + +/* Return the mtime of file F (a struct file *), caching it. + The value is NONEXISTENT_MTIME if the file does not exist. */ +#define file_mtime(f) file_mtime_1 ((f), 1) +/* Return the mtime of file F (a struct file *), caching it. + Don't search using vpath for the file--if it doesn't actually exist, + we don't find it. + The value is NONEXISTENT_MTIME if the file does not exist. */ +#define file_mtime_no_search(f) file_mtime_1 ((f), 0) +extern FILE_TIMESTAMP f_mtime PARAMS ((struct file *file, int search)); +#define file_mtime_1(f, v) \ + ((f)->last_mtime == UNKNOWN_MTIME ? f_mtime ((f), v) : (f)->last_mtime) + +/* Special timestamp values. */ + +/* The file's timestamp is not yet known. */ +#define UNKNOWN_MTIME 0 + +/* The file does not exist. */ +#define NONEXISTENT_MTIME 1 + +/* The file does not exist, and we assume that it is older than any + actual file. */ +#define OLD_MTIME 2 + +/* The smallest and largest ordinary timestamps. */ +#define ORDINARY_MTIME_MIN (OLD_MTIME + 1) +#define ORDINARY_MTIME_MAX ((FILE_TIMESTAMP_S (NEW_MTIME) \ + << FILE_TIMESTAMP_LO_BITS) \ + + ORDINARY_MTIME_MIN + FILE_TIMESTAMPS_PER_S - 1) + +/* Modtime value to use for `infinitely new'. We used to get the current time + from the system and use that whenever we wanted `new'. But that causes + trouble when the machine running make and the machine holding a file have + different ideas about what time it is; and can also lose for `force' + targets, which need to be considered newer than anything that depends on + them, even if said dependents' modtimes are in the future. */ +#define NEW_MTIME INTEGER_TYPE_MAXIMUM (FILE_TIMESTAMP) + +#define check_renamed(file) \ + while ((file)->renamed != 0) (file) = (file)->renamed /* No ; here. */ diff --git a/flaim/external/w32/make/fnmatch.c b/flaim/external/w32/make/fnmatch.c new file mode 100644 index 0000000..1f4ead5 --- /dev/null +++ b/flaim/external/w32/make/fnmatch.c @@ -0,0 +1,488 @@ +/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#if HAVE_CONFIG_H +# include +#endif + +/* Enable GNU extensions in fnmatch.h. */ +#ifndef _GNU_SOURCE +# define _GNU_SOURCE 1 +#endif + +#include +#include +#include + +#if HAVE_STRING_H || defined _LIBC +# include +#else +# include +#endif + +#if defined STDC_HEADERS || defined _LIBC +# include +#endif + +/* For platform which support the ISO C amendement 1 functionality we + support user defined character classes. */ +#if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H) +/* Solaris 2.5 has a bug: must be included before . */ +# include +# include +#endif + +/* Comment out all this code if we are using the GNU C Library, and are not + actually compiling the library itself. This code is part of the GNU C + Library, but also included in many other GNU distributions. Compiling + and linking in this code is a waste when using the GNU C library + (especially if it is a shared library). Rather than having every GNU + program understand `configure --with-gnu-libc' and omit the object files, + it is simpler to just do this in the source for each such file. */ + +#if defined _LIBC || !defined __GNU_LIBRARY__ + + +# if defined STDC_HEADERS || !defined isascii +# define ISASCII(c) 1 +# else +# define ISASCII(c) isascii(c) +# endif + +# ifdef isblank +# define ISBLANK(c) (ISASCII (c) && isblank (c)) +# else +# define ISBLANK(c) ((c) == ' ' || (c) == '\t') +# endif +# ifdef isgraph +# define ISGRAPH(c) (ISASCII (c) && isgraph (c)) +# else +# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c)) +# endif + +# define ISPRINT(c) (ISASCII (c) && isprint (c)) +# define ISDIGIT(c) (ISASCII (c) && isdigit (c)) +# define ISALNUM(c) (ISASCII (c) && isalnum (c)) +# define ISALPHA(c) (ISASCII (c) && isalpha (c)) +# define ISCNTRL(c) (ISASCII (c) && iscntrl (c)) +# define ISLOWER(c) (ISASCII (c) && islower (c)) +# define ISPUNCT(c) (ISASCII (c) && ispunct (c)) +# define ISSPACE(c) (ISASCII (c) && isspace (c)) +# define ISUPPER(c) (ISASCII (c) && isupper (c)) +# define ISXDIGIT(c) (ISASCII (c) && isxdigit (c)) + +# define STREQ(s1, s2) ((strcmp (s1, s2) == 0)) + +# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H) +/* The GNU C library provides support for user-defined character classes + and the functions from ISO C amendement 1. */ +# ifdef CHARCLASS_NAME_MAX +# define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX +# else +/* This shouldn't happen but some implementation might still have this + problem. Use a reasonable default value. */ +# define CHAR_CLASS_MAX_LENGTH 256 +# endif + +# ifdef _LIBC +# define IS_CHAR_CLASS(string) __wctype (string) +# else +# define IS_CHAR_CLASS(string) wctype (string) +# endif +# else +# define CHAR_CLASS_MAX_LENGTH 6 /* Namely, `xdigit'. */ + +# define IS_CHAR_CLASS(string) \ + (STREQ (string, "alpha") || STREQ (string, "upper") \ + || STREQ (string, "lower") || STREQ (string, "digit") \ + || STREQ (string, "alnum") || STREQ (string, "xdigit") \ + || STREQ (string, "space") || STREQ (string, "print") \ + || STREQ (string, "punct") || STREQ (string, "graph") \ + || STREQ (string, "cntrl") || STREQ (string, "blank")) +# endif + +/* Avoid depending on library functions or files + whose names are inconsistent. */ + +# if !defined _LIBC && !defined getenv +extern char *getenv (); +# endif + +# ifndef errno +extern int errno; +# endif + +/* This function doesn't exist on most systems. */ + +# if !defined HAVE___STRCHRNUL && !defined _LIBC +static char * +__strchrnul (s, c) + const char *s; + int c; +{ + char *result = strchr (s, c); + if (result == NULL) + result = strchr (s, '\0'); + return result; +} +# endif + +# ifndef internal_function +/* Inside GNU libc we mark some function in a special way. In other + environments simply ignore the marking. */ +# define internal_function +# endif + +/* Match STRING against the filename pattern PATTERN, returning zero if + it matches, nonzero if not. */ +static int internal_fnmatch __P ((const char *pattern, const char *string, + int no_leading_period, int flags)) + internal_function; +static int +internal_function +internal_fnmatch (pattern, string, no_leading_period, flags) + const char *pattern; + const char *string; + int no_leading_period; + int flags; +{ + register const char *p = pattern, *n = string; + register unsigned char c; + +/* Note that this evaluates C many times. */ +# ifdef _LIBC +# define FOLD(c) ((flags & FNM_CASEFOLD) ? tolower (c) : (c)) +# else +# define FOLD(c) ((flags & FNM_CASEFOLD) && ISUPPER (c) ? tolower (c) : (c)) +# endif + + while ((c = *p++) != '\0') + { + c = FOLD (c); + + switch (c) + { + case '?': + if (*n == '\0') + return FNM_NOMATCH; + else if (*n == '/' && (flags & FNM_FILE_NAME)) + return FNM_NOMATCH; + else if (*n == '.' && no_leading_period + && (n == string + || (n[-1] == '/' && (flags & FNM_FILE_NAME)))) + return FNM_NOMATCH; + break; + + case '\\': + if (!(flags & FNM_NOESCAPE)) + { + c = *p++; + if (c == '\0') + /* Trailing \ loses. */ + return FNM_NOMATCH; + c = FOLD (c); + } + if (FOLD ((unsigned char) *n) != c) + return FNM_NOMATCH; + break; + + case '*': + if (*n == '.' && no_leading_period + && (n == string + || (n[-1] == '/' && (flags & FNM_FILE_NAME)))) + return FNM_NOMATCH; + + for (c = *p++; c == '?' || c == '*'; c = *p++) + { + if (*n == '/' && (flags & FNM_FILE_NAME)) + /* A slash does not match a wildcard under FNM_FILE_NAME. */ + return FNM_NOMATCH; + else if (c == '?') + { + /* A ? needs to match one character. */ + if (*n == '\0') + /* There isn't another character; no match. */ + return FNM_NOMATCH; + else + /* One character of the string is consumed in matching + this ? wildcard, so *??? won't match if there are + less than three characters. */ + ++n; + } + } + + if (c == '\0') + /* The wildcard(s) is/are the last element of the pattern. + If the name is a file name and contains another slash + this does mean it cannot match. */ + return ((flags & FNM_FILE_NAME) && strchr (n, '/') != NULL + ? FNM_NOMATCH : 0); + else + { + const char *endp; + + endp = __strchrnul (n, (flags & FNM_FILE_NAME) ? '/' : '\0'); + + if (c == '[') + { + int flags2 = ((flags & FNM_FILE_NAME) + ? flags : (flags & ~FNM_PERIOD)); + + for (--p; n < endp; ++n) + if (internal_fnmatch (p, n, + (no_leading_period + && (n == string + || (n[-1] == '/' + && (flags + & FNM_FILE_NAME)))), + flags2) + == 0) + return 0; + } + else if (c == '/' && (flags & FNM_FILE_NAME)) + { + while (*n != '\0' && *n != '/') + ++n; + if (*n == '/' + && (internal_fnmatch (p, n + 1, flags & FNM_PERIOD, + flags) == 0)) + return 0; + } + else + { + int flags2 = ((flags & FNM_FILE_NAME) + ? flags : (flags & ~FNM_PERIOD)); + + if (c == '\\' && !(flags & FNM_NOESCAPE)) + c = *p; + c = FOLD (c); + for (--p; n < endp; ++n) + if (FOLD ((unsigned char) *n) == c + && (internal_fnmatch (p, n, + (no_leading_period + && (n == string + || (n[-1] == '/' + && (flags + & FNM_FILE_NAME)))), + flags2) == 0)) + return 0; + } + } + + /* If we come here no match is possible with the wildcard. */ + return FNM_NOMATCH; + + case '[': + { + /* Nonzero if the sense of the character class is inverted. */ + static int posixly_correct; + register int not; + char cold; + + if (posixly_correct == 0) + posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1; + + if (*n == '\0') + return FNM_NOMATCH; + + if (*n == '.' && no_leading_period && (n == string + || (n[-1] == '/' + && (flags + & FNM_FILE_NAME)))) + return FNM_NOMATCH; + + if (*n == '/' && (flags & FNM_FILE_NAME)) + /* `/' cannot be matched. */ + return FNM_NOMATCH; + + not = (*p == '!' || (posixly_correct < 0 && *p == '^')); + if (not) + ++p; + + c = *p++; + for (;;) + { + unsigned char fn = FOLD ((unsigned char) *n); + + if (!(flags & FNM_NOESCAPE) && c == '\\') + { + if (*p == '\0') + return FNM_NOMATCH; + c = FOLD ((unsigned char) *p); + ++p; + + if (c == fn) + goto matched; + } + else if (c == '[' && *p == ':') + { + /* Leave room for the null. */ + char str[CHAR_CLASS_MAX_LENGTH + 1]; + size_t c1 = 0; +# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H) + wctype_t wt; +# endif + const char *startp = p; + + for (;;) + { + if (c1 == CHAR_CLASS_MAX_LENGTH) + /* The name is too long and therefore the pattern + is ill-formed. */ + return FNM_NOMATCH; + + c = *++p; + if (c == ':' && p[1] == ']') + { + p += 2; + break; + } + if (c < 'a' || c >= 'z') + { + /* This cannot possibly be a character class name. + Match it as a normal range. */ + p = startp; + c = '['; + goto normal_bracket; + } + str[c1++] = c; + } + str[c1] = '\0'; + +# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H) + wt = IS_CHAR_CLASS (str); + if (wt == 0) + /* Invalid character class name. */ + return FNM_NOMATCH; + + if (__iswctype (__btowc ((unsigned char) *n), wt)) + goto matched; +# else + if ((STREQ (str, "alnum") && ISALNUM ((unsigned char) *n)) + || (STREQ (str, "alpha") && ISALPHA ((unsigned char) *n)) + || (STREQ (str, "blank") && ISBLANK ((unsigned char) *n)) + || (STREQ (str, "cntrl") && ISCNTRL ((unsigned char) *n)) + || (STREQ (str, "digit") && ISDIGIT ((unsigned char) *n)) + || (STREQ (str, "graph") && ISGRAPH ((unsigned char) *n)) + || (STREQ (str, "lower") && ISLOWER ((unsigned char) *n)) + || (STREQ (str, "print") && ISPRINT ((unsigned char) *n)) + || (STREQ (str, "punct") && ISPUNCT ((unsigned char) *n)) + || (STREQ (str, "space") && ISSPACE ((unsigned char) *n)) + || (STREQ (str, "upper") && ISUPPER ((unsigned char) *n)) + || (STREQ (str, "xdigit") && ISXDIGIT ((unsigned char) *n))) + goto matched; +# endif + } + else if (c == '\0') + /* [ (unterminated) loses. */ + return FNM_NOMATCH; + else + { + normal_bracket: + if (FOLD (c) == fn) + goto matched; + + cold = c; + c = *p++; + + if (c == '-' && *p != ']') + { + /* It is a range. */ + unsigned char cend = *p++; + if (!(flags & FNM_NOESCAPE) && cend == '\\') + cend = *p++; + if (cend == '\0') + return FNM_NOMATCH; + + if (cold <= fn && fn <= FOLD (cend)) + goto matched; + + c = *p++; + } + } + + if (c == ']') + break; + } + + if (!not) + return FNM_NOMATCH; + break; + + matched: + /* Skip the rest of the [...] that already matched. */ + while (c != ']') + { + if (c == '\0') + /* [... (unterminated) loses. */ + return FNM_NOMATCH; + + c = *p++; + if (!(flags & FNM_NOESCAPE) && c == '\\') + { + if (*p == '\0') + return FNM_NOMATCH; + /* XXX 1003.2d11 is unclear if this is right. */ + ++p; + } + else if (c == '[' && *p == ':') + { + do + if (*++p == '\0') + return FNM_NOMATCH; + while (*p != ':' || p[1] == ']'); + p += 2; + c = *p; + } + } + if (not) + return FNM_NOMATCH; + } + break; + + default: + if (c != FOLD ((unsigned char) *n)) + return FNM_NOMATCH; + } + + ++n; + } + + if (*n == '\0') + return 0; + + if ((flags & FNM_LEADING_DIR) && *n == '/') + /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */ + return 0; + + return FNM_NOMATCH; + +# undef FOLD +} + + +int +fnmatch (pattern, string, flags) + const char *pattern; + const char *string; + int flags; +{ + return internal_fnmatch (pattern, string, flags & FNM_PERIOD, flags); +} + +#endif /* _LIBC or not __GNU_LIBRARY__. */ diff --git a/flaim/external/w32/make/fnmatch.h b/flaim/external/w32/make/fnmatch.h new file mode 100644 index 0000000..cc3ec37 --- /dev/null +++ b/flaim/external/w32/make/fnmatch.h @@ -0,0 +1,84 @@ +/* Copyright (C) 1991, 92, 93, 96, 97, 98, 99 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _FNMATCH_H +#define _FNMATCH_H 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32 +# if !defined __GLIBC__ || !defined __P +# undef __P +# define __P(protos) protos +# endif +#else /* Not C++ or ANSI C. */ +# undef __P +# define __P(protos) () +/* We can get away without defining `const' here only because in this file + it is used only inside the prototype for `fnmatch', which is elided in + non-ANSI C where `const' is problematical. */ +#endif /* C++ or ANSI C. */ + +#ifndef const +# if (defined __STDC__ && __STDC__) || defined __cplusplus +# define __const const +# else +# define __const +# endif +#endif + +/* We #undef these before defining them because some losing systems + (HP-UX A.08.07 for example) define these in . */ +#undef FNM_PATHNAME +#undef FNM_NOESCAPE +#undef FNM_PERIOD + +/* Bits set in the FLAGS argument to `fnmatch'. */ +#define FNM_PATHNAME (1 << 0) /* No wildcard can ever match `/'. */ +#define FNM_NOESCAPE (1 << 1) /* Backslashes don't quote special chars. */ +#define FNM_PERIOD (1 << 2) /* Leading `.' is matched only explicitly. */ + +#if !defined _POSIX_C_SOURCE || _POSIX_C_SOURCE < 2 || defined _GNU_SOURCE +# define FNM_FILE_NAME FNM_PATHNAME /* Preferred GNU name. */ +# define FNM_LEADING_DIR (1 << 3) /* Ignore `/...' after a match. */ +# define FNM_CASEFOLD (1 << 4) /* Compare without regard to case. */ +#endif + +/* Value returned by `fnmatch' if STRING does not match PATTERN. */ +#define FNM_NOMATCH 1 + +/* This value is returned if the implementation does not support + `fnmatch'. Since this is not the case here it will never be + returned but the conformance test suites still require the symbol + to be defined. */ +#ifdef _XOPEN_SOURCE +# define FNM_NOSYS (-1) +#endif + +/* Match NAME against the filename pattern PATTERN, + returning zero if it matches, FNM_NOMATCH if not. */ +extern int fnmatch __P ((__const char *__pattern, __const char *__name, + int __flags)); + +#ifdef __cplusplus +} +#endif + +#endif /* fnmatch.h */ diff --git a/flaim/external/w32/make/function.c b/flaim/external/w32/make/function.c new file mode 100644 index 0000000..cf646d6 --- /dev/null +++ b/flaim/external/w32/make/function.c @@ -0,0 +1,2076 @@ +/* Builtin function expansion for GNU Make. +Copyright (C) 1988, 1989, 1991-1997, 1999, 2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "filedef.h" +#include "variable.h" +#include "dep.h" +#include "job.h" +#include "commands.h" +#include "debug.h" + +#ifdef _AMIGA +#include "amiga.h" +#endif + + +struct function_table_entry + { + const char *name; + unsigned char len; + unsigned char minimum_args; + unsigned char maximum_args; + char expand_args; + char *(*func_ptr) PARAMS ((char *output, char **argv, const char *fname)); + }; + +static unsigned long +function_table_entry_hash_1 (keyv) + const void *keyv; +{ + struct function_table_entry const *key = (struct function_table_entry const *) keyv; + return_STRING_N_HASH_1 (key->name, key->len); +} + +static unsigned long +function_table_entry_hash_2 (keyv) + const void *keyv; +{ + struct function_table_entry const *key = (struct function_table_entry const *) keyv; + return_STRING_N_HASH_2 (key->name, key->len); +} + +static int +function_table_entry_hash_cmp (xv, yv) + const void *xv; + const void *yv; +{ + struct function_table_entry const *x = (struct function_table_entry const *) xv; + struct function_table_entry const *y = (struct function_table_entry const *) yv; + int result = x->len - y->len; + if (result) + return result; + return_STRING_N_COMPARE (x->name, y->name, x->len); +} + +static struct hash_table function_table; + + +/* Store into VARIABLE_BUFFER at O the result of scanning TEXT and replacing + each occurrence of SUBST with REPLACE. TEXT is null-terminated. SLEN is + the length of SUBST and RLEN is the length of REPLACE. If BY_WORD is + nonzero, substitutions are done only on matches which are complete + whitespace-delimited words. If SUFFIX_ONLY is nonzero, substitutions are + done only at the ends of whitespace-delimited words. */ + +char * +subst_expand (o, text, subst, replace, slen, rlen, by_word, suffix_only) + char *o; + char *text; + char *subst, *replace; + unsigned int slen, rlen; + int by_word, suffix_only; +{ + register char *t = text; + register char *p; + + if (slen == 0 && !by_word && !suffix_only) + { + /* The first occurrence of "" in any string is its end. */ + o = variable_buffer_output (o, t, strlen (t)); + if (rlen > 0) + o = variable_buffer_output (o, replace, rlen); + return o; + } + + do + { + if ((by_word | suffix_only) && slen == 0) + /* When matching by words, the empty string should match + the end of each word, rather than the end of the whole text. */ + p = end_of_token (next_token (t)); + else + { + p = sindex (t, 0, subst, slen); + if (p == 0) + { + /* No more matches. Output everything left on the end. */ + o = variable_buffer_output (o, t, strlen (t)); + return o; + } + } + + /* Output everything before this occurrence of the string to replace. */ + if (p > t) + o = variable_buffer_output (o, t, p - t); + + /* If we're substituting only by fully matched words, + or only at the ends of words, check that this case qualifies. */ + if ((by_word + && ((p > t && !isblank ((unsigned char)p[-1])) + || (p[slen] != '\0' && !isblank ((unsigned char)p[slen])))) + || (suffix_only + && (p[slen] != '\0' && !isblank ((unsigned char)p[slen])))) + /* Struck out. Output the rest of the string that is + no longer to be replaced. */ + o = variable_buffer_output (o, subst, slen); + else if (rlen > 0) + /* Output the replacement string. */ + o = variable_buffer_output (o, replace, rlen); + + /* Advance T past the string to be replaced. */ + t = p + slen; + } while (*t != '\0'); + + return o; +} + + +/* Store into VARIABLE_BUFFER at O the result of scanning TEXT + and replacing strings matching PATTERN with REPLACE. + If PATTERN_PERCENT is not nil, PATTERN has already been + run through find_percent, and PATTERN_PERCENT is the result. + If REPLACE_PERCENT is not nil, REPLACE has already been + run through find_percent, and REPLACE_PERCENT is the result. */ + +char * +patsubst_expand (o, text, pattern, replace, pattern_percent, replace_percent) + char *o; + char *text; + register char *pattern, *replace; + register char *pattern_percent, *replace_percent; +{ + unsigned int pattern_prepercent_len, pattern_postpercent_len; + unsigned int replace_prepercent_len, replace_postpercent_len = 0; + char *t; + unsigned int len; + int doneany = 0; + + /* We call find_percent on REPLACE before checking PATTERN so that REPLACE + will be collapsed before we call subst_expand if PATTERN has no %. */ + if (replace_percent == 0) + replace_percent = find_percent (replace); + if (replace_percent != 0) + { + /* Record the length of REPLACE before and after the % so + we don't have to compute these lengths more than once. */ + replace_prepercent_len = replace_percent - replace; + replace_postpercent_len = strlen (replace_percent + 1); + } + else + /* We store the length of the replacement + so we only need to compute it once. */ + replace_prepercent_len = strlen (replace); + + if (pattern_percent == 0) + pattern_percent = find_percent (pattern); + if (pattern_percent == 0) + /* With no % in the pattern, this is just a simple substitution. */ + return subst_expand (o, text, pattern, replace, + strlen (pattern), strlen (replace), 1, 0); + + /* Record the length of PATTERN before and after the % + so we don't have to compute it more than once. */ + pattern_prepercent_len = pattern_percent - pattern; + pattern_postpercent_len = strlen (pattern_percent + 1); + + while ((t = find_next_token (&text, &len)) != 0) + { + int fail = 0; + + /* Is it big enough to match? */ + if (len < pattern_prepercent_len + pattern_postpercent_len) + fail = 1; + + /* Does the prefix match? */ + if (!fail && pattern_prepercent_len > 0 + && (*t != *pattern + || t[pattern_prepercent_len - 1] != pattern_percent[-1] + || !strneq (t + 1, pattern + 1, pattern_prepercent_len - 1))) + fail = 1; + + /* Does the suffix match? */ + if (!fail && pattern_postpercent_len > 0 + && (t[len - 1] != pattern_percent[pattern_postpercent_len] + || t[len - pattern_postpercent_len] != pattern_percent[1] + || !strneq (&t[len - pattern_postpercent_len], + &pattern_percent[1], pattern_postpercent_len - 1))) + fail = 1; + + if (fail) + /* It didn't match. Output the string. */ + o = variable_buffer_output (o, t, len); + else + { + /* It matched. Output the replacement. */ + + /* Output the part of the replacement before the %. */ + o = variable_buffer_output (o, replace, replace_prepercent_len); + + if (replace_percent != 0) + { + /* Output the part of the matched string that + matched the % in the pattern. */ + o = variable_buffer_output (o, t + pattern_prepercent_len, + len - (pattern_prepercent_len + + pattern_postpercent_len)); + /* Output the part of the replacement after the %. */ + o = variable_buffer_output (o, replace_percent + 1, + replace_postpercent_len); + } + } + + /* Output a space, but not if the replacement is "". */ + if (fail || replace_prepercent_len > 0 + || (replace_percent != 0 && len + replace_postpercent_len > 0)) + { + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } + } + if (doneany) + /* Kill the last space. */ + --o; + + return o; +} + + +/* Look up a function by name. */ + +static const struct function_table_entry * +lookup_function (s) + const char *s; +{ + const char *e = s; + + while (*e && ( (*e >= 'a' && *e <= 'z') || *e == '-')) + e++; + if (*e == '\0' || isblank ((unsigned char) *e)) + { + struct function_table_entry function_table_entry_key; + function_table_entry_key.name = s; + function_table_entry_key.len = e - s; + + return hash_find_item (&function_table, &function_table_entry_key); + } + return 0; +} + + +/* Return 1 if PATTERN matches STR, 0 if not. */ + +int +pattern_matches (pattern, percent, str) + register char *pattern, *percent, *str; +{ + unsigned int sfxlen, strlength; + + if (percent == 0) + { + unsigned int len = strlen (pattern) + 1; + char *new_chars = (char *) alloca (len); + bcopy (pattern, new_chars, len); + pattern = new_chars; + percent = find_percent (pattern); + if (percent == 0) + return streq (pattern, str); + } + + sfxlen = strlen (percent + 1); + strlength = strlen (str); + + if (strlength < (percent - pattern) + sfxlen + || !strneq (pattern, str, percent - pattern)) + return 0; + + return !strcmp (percent + 1, str + (strlength - sfxlen)); +} + + +/* Find the next comma or ENDPAREN (counting nested STARTPAREN and + ENDPARENtheses), starting at PTR before END. Return a pointer to + next character. + + If no next argument is found, return NULL. +*/ + +static char * +find_next_argument (startparen, endparen, ptr, end) + char startparen; + char endparen; + const char *ptr; + const char *end; +{ + int count = 0; + + for (; ptr < end; ++ptr) + if (*ptr == startparen) + ++count; + + else if (*ptr == endparen) + { + --count; + if (count < 0) + return NULL; + } + + else if (*ptr == ',' && !count) + return (char *)ptr; + + /* We didn't find anything. */ + return NULL; +} + + +/* Glob-expand LINE. The returned pointer is + only good until the next call to string_glob. */ + +static char * +string_glob (line) + char *line; +{ + static char *result = 0; + static unsigned int length; + register struct nameseq *chain; + register unsigned int idx; + + chain = multi_glob (parse_file_seq + (&line, '\0', sizeof (struct nameseq), + /* We do not want parse_file_seq to strip `./'s. + That would break examples like: + $(patsubst ./%.c,obj/%.o,$(wildcard ./?*.c)). */ + 0), + sizeof (struct nameseq)); + + if (result == 0) + { + length = 100; + result = (char *) xmalloc (100); + } + + idx = 0; + while (chain != 0) + { + register char *name = chain->name; + unsigned int len = strlen (name); + + struct nameseq *next = chain->next; + free ((char *) chain); + chain = next; + + /* multi_glob will pass names without globbing metacharacters + through as is, but we want only files that actually exist. */ + if (file_exists_p (name)) + { + if (idx + len + 1 > length) + { + length += (len + 1) * 2; + result = (char *) xrealloc (result, length); + } + bcopy (name, &result[idx], len); + idx += len; + result[idx++] = ' '; + } + + free (name); + } + + /* Kill the last space and terminate the string. */ + if (idx == 0) + result[0] = '\0'; + else + result[idx - 1] = '\0'; + + return result; +} + +/* + Builtin functions + */ + +static char * +func_patsubst (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + o = patsubst_expand (o, argv[2], argv[0], argv[1], (char *) 0, (char *) 0); + return o; +} + + +static char * +func_join (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + int doneany = 0; + + /* Write each word of the first argument directly followed + by the corresponding word of the second argument. + If the two arguments have a different number of words, + the excess words are just output separated by blanks. */ + register char *tp; + register char *pp; + char *list1_iterator = argv[0]; + char *list2_iterator = argv[1]; + do + { + unsigned int len1, len2; + + tp = find_next_token (&list1_iterator, &len1); + if (tp != 0) + o = variable_buffer_output (o, tp, len1); + + pp = find_next_token (&list2_iterator, &len2); + if (pp != 0) + o = variable_buffer_output (o, pp, len2); + + if (tp != 0 || pp != 0) + { + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } + } + while (tp != 0 || pp != 0); + if (doneany) + /* Kill the last blank. */ + --o; + + return o; +} + + +static char * +func_origin (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* Expand the argument. */ + register struct variable *v = lookup_variable (argv[0], strlen (argv[0])); + if (v == 0) + o = variable_buffer_output (o, "undefined", 9); + else + switch (v->origin) + { + default: + case o_invalid: + abort (); + break; + case o_default: + o = variable_buffer_output (o, "default", 7); + break; + case o_env: + o = variable_buffer_output (o, "environment", 11); + break; + case o_file: + o = variable_buffer_output (o, "file", 4); + break; + case o_env_override: + o = variable_buffer_output (o, "environment override", 20); + break; + case o_command: + o = variable_buffer_output (o, "command line", 12); + break; + case o_override: + o = variable_buffer_output (o, "override", 8); + break; + case o_automatic: + o = variable_buffer_output (o, "automatic", 9); + break; + } + + return o; +} + +#ifdef VMS +# define IS_PATHSEP(c) ((c) == ']') +#else +# ifdef HAVE_DOS_PATHS +# define IS_PATHSEP(c) ((c) == '/' || (c) == '\\') +# else +# define IS_PATHSEP(c) ((c) == '/') +# endif +#endif + + +static char * +func_notdir_suffix (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* Expand the argument. */ + char *list_iterator = argv[0]; + char *p2 =0; + int doneany =0; + unsigned int len=0; + + int is_suffix = streq (funcname, "suffix"); + int is_notdir = !is_suffix; + while ((p2 = find_next_token (&list_iterator, &len)) != 0) + { + char *p = p2 + len; + + + while (p >= p2 && (!is_suffix || *p != '.')) + { + if (IS_PATHSEP (*p)) + break; + --p; + } + + if (p >= p2) + { + if (is_notdir) + ++p; + else if (*p != '.') + continue; + o = variable_buffer_output (o, p, len - (p - p2)); + } +#ifdef HAVE_DOS_PATHS + /* Handle the case of "d:foo/bar". */ + else if (streq (funcname, "notdir") && p2[0] && p2[1] == ':') + { + p = p2 + 2; + o = variable_buffer_output (o, p, len - (p - p2)); + } +#endif + else if (is_notdir) + o = variable_buffer_output (o, p2, len); + + if (is_notdir || p >= p2) + { + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } + } + if (doneany) + /* Kill last space. */ + --o; + + + return o; + +} + + +static char * +func_basename_dir (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* Expand the argument. */ + char *p3 = argv[0]; + char *p2=0; + int doneany=0; + unsigned int len=0; + char *p=0; + int is_basename= streq (funcname, "basename"); + int is_dir= !is_basename; + + while ((p2 = find_next_token (&p3, &len)) != 0) + { + p = p2 + len; + while (p >= p2 && (!is_basename || *p != '.')) + { + if (IS_PATHSEP (*p)) + break; + --p; + } + + if (p >= p2 && (is_dir)) + o = variable_buffer_output (o, p2, ++p - p2); + else if (p >= p2 && (*p == '.')) + o = variable_buffer_output (o, p2, p - p2); +#ifdef HAVE_DOS_PATHS + /* Handle the "d:foobar" case */ + else if (p2[0] && p2[1] == ':' && is_dir) + o = variable_buffer_output (o, p2, 2); +#endif + else if (is_dir) +#ifdef VMS + o = variable_buffer_output (o, "[]", 2); +#else +#ifndef _AMIGA + o = variable_buffer_output (o, "./", 2); +#else + ; /* Just a nop... */ +#endif /* AMIGA */ +#endif /* !VMS */ + else + /* The entire name is the basename. */ + o = variable_buffer_output (o, p2, len); + + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } + if (doneany) + /* Kill last space. */ + --o; + + + return o; +} + +static char * +func_addsuffix_addprefix (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + int fixlen = strlen (argv[0]); + char *list_iterator = argv[1]; + int is_addprefix = streq (funcname, "addprefix"); + int is_addsuffix = !is_addprefix; + + int doneany = 0; + char *p; + unsigned int len; + + while ((p = find_next_token (&list_iterator, &len)) != 0) + { + if (is_addprefix) + o = variable_buffer_output (o, argv[0], fixlen); + o = variable_buffer_output (o, p, len); + if (is_addsuffix) + o = variable_buffer_output (o, argv[0], fixlen); + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } + + if (doneany) + /* Kill last space. */ + --o; + + return o; +} + +static char * +func_subst (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + o = subst_expand (o, argv[2], argv[0], argv[1], strlen (argv[0]), + strlen (argv[1]), 0, 0); + + return o; +} + + +static char * +func_firstword (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + unsigned int i; + char *words = argv[0]; /* Use a temp variable for find_next_token */ + char *p = find_next_token (&words, &i); + + if (p != 0) + o = variable_buffer_output (o, p, i); + + return o; +} + + +static char * +func_words (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + int i = 0; + char *word_iterator = argv[0]; + char buf[20]; + + while (find_next_token (&word_iterator, (unsigned int *) 0) != 0) + ++i; + + sprintf (buf, "%d", i); + o = variable_buffer_output (o, buf, strlen (buf)); + + + return o; +} + +char * +strip_whitespace (begpp, endpp) + char **begpp; + char **endpp; +{ + while (isspace ((unsigned char)**begpp) && *begpp <= *endpp) + (*begpp) ++; + while (isspace ((unsigned char)**endpp) && *endpp >= *begpp) + (*endpp) --; + return *begpp; +} + +int +is_numeric (p) + char *p; +{ + char *end = p + strlen (p) - 1; + char *beg = p; + strip_whitespace (&p, &end); + + while (p <= end) + if (!ISDIGIT (*(p++))) /* ISDIGIT only evals its arg once: see make.h. */ + return 0; + + return (end - beg >= 0); +} + +void +check_numeric (s, message) + char *s; + char *message; +{ + if (!is_numeric (s)) + fatal (reading_file, message); +} + + + +static char * +func_word (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char *end_p=0; + int i=0; + char *p=0; + + /* Check the first argument. */ + check_numeric (argv[0], _("non-numeric first argument to `word' function")); + i = atoi (argv[0]); + + if (i == 0) + fatal (reading_file, _("first argument to `word' function must be greater than 0")); + + + end_p = argv[1]; + while ((p = find_next_token (&end_p, 0)) != 0) + if (--i == 0) + break; + + if (i == 0) + o = variable_buffer_output (o, p, end_p - p); + + return o; +} + +static char * +func_wordlist (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + int start, count; + + /* Check the arguments. */ + check_numeric (argv[0], + _("non-numeric first argument to `wordlist' function")); + check_numeric (argv[1], + _("non-numeric second argument to `wordlist' function")); + + start = atoi (argv[0]); + count = atoi (argv[1]) - start + 1; + + if (count > 0) + { + char *p; + char *end_p = argv[2]; + + /* Find the beginning of the "start"th word. */ + while (((p = find_next_token (&end_p, 0)) != 0) && --start) + ; + + if (p) + { + /* Find the end of the "count"th word from start. */ + while (--count && (find_next_token (&end_p, 0) != 0)) + ; + + /* Return the stuff in the middle. */ + o = variable_buffer_output (o, p, end_p - p); + } + } + + return o; +} + +static char* +func_findstring (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* Find the first occurrence of the first string in the second. */ + int i = strlen (argv[0]); + if (sindex (argv[1], 0, argv[0], i) != 0) + o = variable_buffer_output (o, argv[0], i); + + return o; +} + +static char * +func_foreach (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* expand only the first two. */ + char *varname = expand_argument (argv[0], NULL); + char *list = expand_argument (argv[1], NULL); + char *body = argv[2]; + + int doneany = 0; + char *list_iterator = list; + char *p; + unsigned int len; + register struct variable *var; + + push_new_variable_scope (); + var = define_variable (varname, strlen (varname), "", o_automatic, 0); + + /* loop through LIST, put the value in VAR and expand BODY */ + while ((p = find_next_token (&list_iterator, &len)) != 0) + { + char *result = 0; + + { + char save = p[len]; + + p[len] = '\0'; + free (var->value); + var->value = (char *) xstrdup ((char*) p); + p[len] = save; + } + + result = allocated_variable_expand (body); + + o = variable_buffer_output (o, result, strlen (result)); + o = variable_buffer_output (o, " ", 1); + doneany = 1; + free (result); + } + + if (doneany) + /* Kill the last space. */ + --o; + + pop_variable_scope (); + free (varname); + free (list); + + return o; +} + +struct a_word +{ + struct a_word *next; + struct a_word *chain; + char *str; + int length; + int matched; +}; + +static unsigned long +a_word_hash_1 (key) + const void *key; +{ + return_STRING_HASH_1 (((struct a_word const *) key)->str); +} + +static unsigned long +a_word_hash_2 (key) + const void *key; +{ + return_STRING_HASH_2 (((struct a_word const *) key)->str); +} + +static int +a_word_hash_cmp (x, y) + const void *x; + const void *y; +{ + int result = ((struct a_word const *) x)->length - ((struct a_word const *) y)->length; + if (result) + return result; + return_STRING_COMPARE (((struct a_word const *) x)->str, + ((struct a_word const *) y)->str); +} + +struct a_pattern +{ + struct a_pattern *next; + char *str; + char *percent; + int length; + int save_c; +}; + +static char * +func_filter_filterout (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + struct a_word *wordhead; + struct a_word **wordtail; + struct a_word *wp; + struct a_pattern *pathead; + struct a_pattern **pattail; + struct a_pattern *pp; + + struct hash_table a_word_table; + int is_filter = streq (funcname, "filter"); + char *pat_iterator = argv[0]; + char *word_iterator = argv[1]; + int literals = 0; + int words = 0; + int hashing = 0; + char *p; + unsigned int len; + + /* Chop ARGV[0] up into patterns to match against the words. */ + + pattail = &pathead; + while ((p = find_next_token (&pat_iterator, &len)) != 0) + { + struct a_pattern *pat = (struct a_pattern *) alloca (sizeof (struct a_pattern)); + + *pattail = pat; + pattail = &pat->next; + + if (*pat_iterator != '\0') + ++pat_iterator; + + pat->str = p; + pat->length = len; + pat->save_c = p[len]; + p[len] = '\0'; + pat->percent = find_percent (p); + if (pat->percent == 0) + literals++; + } + *pattail = 0; + + /* Chop ARGV[1] up into words to match against the patterns. */ + + wordtail = &wordhead; + while ((p = find_next_token (&word_iterator, &len)) != 0) + { + struct a_word *word = (struct a_word *) alloca (sizeof (struct a_word)); + + *wordtail = word; + wordtail = &word->next; + + if (*word_iterator != '\0') + ++word_iterator; + + p[len] = '\0'; + word->str = p; + word->length = len; + word->matched = 0; + word->chain = 0; + words++; + } + *wordtail = 0; + + /* Only use a hash table if arg list lengths justifies the cost. */ + hashing = (literals >= 2 && (literals * words) >= 10); + if (hashing) + { + hash_init (&a_word_table, words, a_word_hash_1, a_word_hash_2, a_word_hash_cmp); + for (wp = wordhead; wp != 0; wp = wp->next) + { + struct a_word *owp = hash_insert (&a_word_table, wp); + if (owp) + wp->chain = owp; + } + } + + if (words) + { + int doneany = 0; + + /* Run each pattern through the words, killing words. */ + for (pp = pathead; pp != 0; pp = pp->next) + { + if (pp->percent) + for (wp = wordhead; wp != 0; wp = wp->next) + wp->matched |= pattern_matches (pp->str, pp->percent, wp->str); + else if (hashing) + { + struct a_word a_word_key; + a_word_key.str = pp->str; + a_word_key.length = pp->length; + wp = (struct a_word *) hash_find_item (&a_word_table, &a_word_key); + while (wp) + { + wp->matched |= 1; + wp = wp->chain; + } + } + else + for (wp = wordhead; wp != 0; wp = wp->next) + wp->matched |= (wp->length == pp->length + && strneq (pp->str, wp->str, wp->length)); + } + + /* Output the words that matched (or didn't, for filter-out). */ + for (wp = wordhead; wp != 0; wp = wp->next) + if (is_filter ? wp->matched : !wp->matched) + { + o = variable_buffer_output (o, wp->str, strlen (wp->str)); + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } + + if (doneany) + /* Kill the last space. */ + --o; + } + + for (pp = pathead; pp != 0; pp = pp->next) + pp->str[pp->length] = pp->save_c; + + if (hashing) + hash_free (&a_word_table, 0); + + return o; +} + + +static char * +func_strip (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char *p = argv[0]; + int doneany =0; + + while (*p != '\0') + { + int i=0; + char *word_start=0; + + while (isspace ((unsigned char)*p)) + ++p; + word_start = p; + for (i=0; *p != '\0' && !isspace ((unsigned char)*p); ++p, ++i) + {} + if (!i) + break; + o = variable_buffer_output (o, word_start, i); + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } + + if (doneany) + /* Kill the last space. */ + --o; + return o; +} + +/* + Print a warning or fatal message. +*/ +static char * +func_error (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char **argvp; + char *msg, *p; + int len; + + /* The arguments will be broken on commas. Rather than create yet + another special case where function arguments aren't broken up, + just create a format string that puts them back together. */ + for (len=0, argvp=argv; *argvp != 0; ++argvp) + len += strlen (*argvp) + 2; + + p = msg = (char *) alloca (len + 1); + + for (argvp=argv; argvp[1] != 0; ++argvp) + { + strcpy (p, *argvp); + p += strlen (*argvp); + *(p++) = ','; + *(p++) = ' '; + } + strcpy (p, *argvp); + + if (*funcname == 'e') + fatal (reading_file, "%s", msg); + + /* The warning function expands to the empty string. */ + error (reading_file, "%s", msg); + + return o; +} + + +/* + chop argv[0] into words, and sort them. + */ +static char * +func_sort (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char **words = 0; + int nwords = 0; + register int wordi = 0; + + /* Chop ARGV[0] into words and put them in WORDS. */ + char *t = argv[0]; + char *p; + unsigned int len; + int i; + + while ((p = find_next_token (&t, &len)) != 0) + { + if (wordi >= nwords - 1) + { + nwords = (2 * nwords) + 5; + words = (char **) xrealloc ((char *) words, + nwords * sizeof (char *)); + } + words[wordi++] = savestring (p, len); + } + + if (!wordi) + return o; + + /* Now sort the list of words. */ + qsort ((char *) words, wordi, sizeof (char *), alpha_compare); + + /* Now write the sorted list. */ + for (i = 0; i < wordi; ++i) + { + len = strlen (words[i]); + if (i == wordi - 1 || strlen (words[i + 1]) != len + || strcmp (words[i], words[i + 1])) + { + o = variable_buffer_output (o, words[i], len); + o = variable_buffer_output (o, " ", 1); + } + free (words[i]); + } + /* Kill the last space. */ + --o; + + free (words); + + return o; +} + +/* + $(if condition,true-part[,false-part]) + + CONDITION is false iff it evaluates to an empty string. White + space before and after condition are stripped before evaluation. + + If CONDITION is true, then TRUE-PART is evaluated, otherwise FALSE-PART is + evaluated (if it exists). Because only one of the two PARTs is evaluated, + you can use $(if ...) to create side-effects (with $(shell ...), for + example). +*/ + +static char * +func_if (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char *begp = argv[0]; + char *endp = begp + strlen (argv[0]); + int result = 0; + + /* Find the result of the condition: if we have a value, and it's not + empty, the condition is true. If we don't have a value, or it's the + empty string, then it's false. */ + + strip_whitespace (&begp, &endp); + + if (begp < endp) + { + char *expansion = expand_argument (begp, NULL); + + result = strlen (expansion); + free (expansion); + } + + /* If the result is true (1) we want to eval the first argument, and if + it's false (0) we want to eval the second. If the argument doesn't + exist we do nothing, otherwise expand it and add to the buffer. */ + + argv += 1 + !result; + + if (argv[0]) + { + char *expansion; + + expansion = expand_argument (argv[0], NULL); + + o = variable_buffer_output (o, expansion, strlen (expansion)); + + free (expansion); + } + + return o; +} + +static char * +func_wildcard (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + +#ifdef _AMIGA + o = wildcard_expansion (argv[0], o); +#else + char *p = string_glob (argv[0]); + o = variable_buffer_output (o, p, strlen (p)); +#endif + return o; +} + +/* + $(eval ) + + Always resolves to the empty string. + + Treat the arguments as a segment of makefile, and parse them. +*/ + +static char * +func_eval (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + eval_buffer (argv[0]); + + return o; +} + + +static char * +func_value (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* Look up the variable. */ + struct variable *v = lookup_variable (argv[0], strlen (argv[0])); + + /* Copy its value into the output buffer without expanding it. */ + if (v) + o = variable_buffer_output (o, v->value, strlen(v->value)); + + return o; +} + +/* + \r is replaced on UNIX as well. Is this desirable? + */ +void +fold_newlines (buffer, length) + char *buffer; + int *length; +{ + char *dst = buffer; + char *src = buffer; + char *last_nonnl = buffer -1; + src[*length] = 0; + for (; *src != '\0'; ++src) + { + if (src[0] == '\r' && src[1] == '\n') + continue; + if (*src == '\n') + { + *dst++ = ' '; + } + else + { + last_nonnl = dst; + *dst++ = *src; + } + } + *(++last_nonnl) = '\0'; + *length = last_nonnl - buffer; +} + + + +int shell_function_pid = 0, shell_function_completed; + + +#ifdef WINDOWS32 +/*untested*/ + +#include +#include +#include "sub_proc.h" + + +void +windows32_openpipe (int *pipedes, int *pid_p, char **command_argv, char **envp) +{ + SECURITY_ATTRIBUTES saAttr; + HANDLE hIn; + HANDLE hErr; + HANDLE hChildOutRd; + HANDLE hChildOutWr; + HANDLE hProcess; + + + saAttr.nLength = sizeof (SECURITY_ATTRIBUTES); + saAttr.bInheritHandle = TRUE; + saAttr.lpSecurityDescriptor = NULL; + + if (DuplicateHandle (GetCurrentProcess(), + GetStdHandle(STD_INPUT_HANDLE), + GetCurrentProcess(), + &hIn, + 0, + TRUE, + DUPLICATE_SAME_ACCESS) == FALSE) { + fatal (NILF, _("create_child_process: DuplicateHandle(In) failed (e=%d)\n"), + GetLastError()); + + } + if (DuplicateHandle(GetCurrentProcess(), + GetStdHandle(STD_ERROR_HANDLE), + GetCurrentProcess(), + &hErr, + 0, + TRUE, + DUPLICATE_SAME_ACCESS) == FALSE) { + fatal (NILF, _("create_child_process: DuplicateHandle(Err) failed (e=%d)\n"), + GetLastError()); + } + + if (!CreatePipe(&hChildOutRd, &hChildOutWr, &saAttr, 0)) + fatal (NILF, _("CreatePipe() failed (e=%d)\n"), GetLastError()); + + hProcess = process_init_fd(hIn, hChildOutWr, hErr); + + if (!hProcess) + fatal (NILF, _("windows32_openpipe (): process_init_fd() failed\n")); + + /* make sure that CreateProcess() has Path it needs */ + sync_Path_environment(); + + if (!process_begin(hProcess, command_argv, envp, command_argv[0], NULL)) { + /* register process for wait */ + process_register(hProcess); + + /* set the pid for returning to caller */ + *pid_p = (int) hProcess; + + /* set up to read data from child */ + pipedes[0] = _open_osfhandle((long) hChildOutRd, O_RDONLY); + + /* this will be closed almost right away */ + pipedes[1] = _open_osfhandle((long) hChildOutWr, O_APPEND); + } else { + /* reap/cleanup the failed process */ + process_cleanup(hProcess); + + /* close handles which were duplicated, they weren't used */ + CloseHandle(hIn); + CloseHandle(hErr); + + /* close pipe handles, they won't be used */ + CloseHandle(hChildOutRd); + CloseHandle(hChildOutWr); + + /* set status for return */ + pipedes[0] = pipedes[1] = -1; + *pid_p = -1; + } +} +#endif + + +#ifdef __MSDOS__ +FILE * +msdos_openpipe (int* pipedes, int *pidp, char *text) +{ + FILE *fpipe=0; + /* MSDOS can't fork, but it has `popen'. */ + struct variable *sh = lookup_variable ("SHELL", 5); + int e; + extern int dos_command_running, dos_status; + + /* Make sure not to bother processing an empty line. */ + while (isblank ((unsigned char)*text)) + ++text; + if (*text == '\0') + return 0; + + if (sh) + { + char buf[PATH_MAX + 7]; + /* This makes sure $SHELL value is used by $(shell), even + though the target environment is not passed to it. */ + sprintf (buf, "SHELL=%s", sh->value); + putenv (buf); + } + + e = errno; + errno = 0; + dos_command_running = 1; + dos_status = 0; + /* If dos_status becomes non-zero, it means the child process + was interrupted by a signal, like SIGINT or SIGQUIT. See + fatal_error_signal in commands.c. */ + fpipe = popen (text, "rt"); + dos_command_running = 0; + if (!fpipe || dos_status) + { + pipedes[0] = -1; + *pidp = -1; + if (dos_status) + errno = EINTR; + else if (errno == 0) + errno = ENOMEM; + shell_function_completed = -1; + } + else + { + pipedes[0] = fileno (fpipe); + *pidp = 42; /* Yes, the Meaning of Life, the Universe, and Everything! */ + errno = e; + shell_function_completed = 1; + } + return fpipe; +} +#endif + +/* + Do shell spawning, with the naughty bits for different OSes. + */ + +#ifdef VMS + +/* VMS can't do $(shell ...) */ +#define func_shell 0 + +#else +#ifndef _AMIGA +static char * +func_shell (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char* batch_filename = NULL; + int i; + +#ifdef __MSDOS__ + FILE *fpipe; +#endif + char **command_argv; + char *error_prefix; + char **envp; + int pipedes[2]; + int pid; + +#ifndef __MSDOS__ + /* Construct the argument list. */ + command_argv = construct_command_argv (argv[0], + (char **) NULL, (struct file *) 0, + &batch_filename); + if (command_argv == 0) + return o; +#endif + + /* Using a target environment for `shell' loses in cases like: + export var = $(shell echo foobie) + because target_environment hits a loop trying to expand $(var) + to put it in the environment. This is even more confusing when + var was not explicitly exported, but just appeared in the + calling environment. */ + + envp = environ; + + /* For error messages. */ + if (reading_file != 0) + { + error_prefix = (char *) alloca (strlen (reading_file->filenm)+11+4); + sprintf (error_prefix, + "%s:%lu: ", reading_file->filenm, reading_file->lineno); + } + else + error_prefix = ""; + +#ifdef WINDOWS32 + windows32_openpipe (pipedes, &pid, command_argv, envp); + + if (pipedes[0] < 0) { + /* open of the pipe failed, mark as failed execution */ + shell_function_completed = -1; + + return o; + } else +#else /* WINDOWS32 */ + +# ifdef __MSDOS__ + fpipe = msdos_openpipe (pipedes, &pid, argv[0]); + if (pipedes[0] < 0) + { + perror_with_name (error_prefix, "pipe"); + return o; + } +# else + if (pipe (pipedes) < 0) + { + perror_with_name (error_prefix, "pipe"); + return o; + } + + pid = vfork (); + if (pid < 0) + perror_with_name (error_prefix, "fork"); + else if (pid == 0) + child_execute_job (0, pipedes[1], command_argv, envp); + else +# endif /* ! __MSDOS__ */ + +#endif /* WINDOWS32 */ + { + /* We are the parent. */ + + char *buffer; + unsigned int maxlen; + int cc; + + /* Record the PID for reap_children. */ + shell_function_pid = pid; +#ifndef __MSDOS__ + shell_function_completed = 0; + + /* Free the storage only the child needed. */ + free (command_argv[0]); + free ((char *) command_argv); + + /* Close the write side of the pipe. */ + (void) close (pipedes[1]); +#endif + + /* Set up and read from the pipe. */ + + maxlen = 200; + buffer = (char *) xmalloc (maxlen + 1); + + /* Read from the pipe until it gets EOF. */ + for (i = 0; ; i += cc) + { + if (i == maxlen) + { + maxlen += 512; + buffer = (char *) xrealloc (buffer, maxlen + 1); + } + + cc = read (pipedes[0], &buffer[i], maxlen - i); + if (cc <= 0) + break; + } + buffer[i] = '\0'; + + /* Close the read side of the pipe. */ +#ifdef __MSDOS__ + if (fpipe) + (void) pclose (fpipe); +#else + (void) close (pipedes[0]); +#endif + + /* Loop until child_handler sets shell_function_completed + to the status of our child shell. */ + while (shell_function_completed == 0) + reap_children (1, 0); + + if (batch_filename) { + DB (DB_VERBOSE, (_("Cleaning up temporary batch file %s\n"), + batch_filename)); + remove (batch_filename); + free (batch_filename); + } + shell_function_pid = 0; + + /* The child_handler function will set shell_function_completed + to 1 when the child dies normally, or to -1 if it + dies with status 127, which is most likely an exec fail. */ + + if (shell_function_completed == -1) + { + /* This most likely means that the execvp failed, + so we should just write out the error message + that came in over the pipe from the child. */ + fputs (buffer, stderr); + fflush (stderr); + } + else + { + /* The child finished normally. Replace all + newlines in its output with spaces, and put + that in the variable output buffer. */ + fold_newlines (buffer, &i); + o = variable_buffer_output (o, buffer, i); + } + + free (buffer); + } + + return o; +} + +#else /* _AMIGA */ + +/* Do the Amiga version of func_shell. */ + +static char * +func_shell (char *o, char **argv, const char *funcname) +{ + /* Amiga can't fork nor spawn, but I can start a program with + redirection of my choice. However, this means that we + don't have an opportunity to reopen stdout to trap it. Thus, + we save our own stdout onto a new descriptor and dup a temp + file's descriptor onto our stdout temporarily. After we + spawn the shell program, we dup our own stdout back to the + stdout descriptor. The buffer reading is the same as above, + except that we're now reading from a file. */ + +#include +#include + + BPTR child_stdout; + char tmp_output[FILENAME_MAX]; + unsigned int maxlen = 200; + int cc, i; + char * buffer, * ptr; + char ** aptr; + int len = 0; + char* batch_filename = NULL; + + /* Construct the argument list. */ + command_argv = construct_command_argv (argv[0], (char **) NULL, + (struct file *) 0, &batch_filename); + if (command_argv == 0) + return o; + + /* Note the mktemp() is a security hole, but this only runs on Amiga. + Ideally we would use main.c:open_tmpfile(), but this uses a special + Open(), not fopen(), and I'm not familiar enough with the code to mess + with it. */ + strcpy (tmp_output, "t:MakeshXXXXXXXX"); + mktemp (tmp_output); + child_stdout = Open (tmp_output, MODE_NEWFILE); + + for (aptr=command_argv; *aptr; aptr++) + len += strlen (*aptr) + 1; + + buffer = xmalloc (len + 1); + ptr = buffer; + + for (aptr=command_argv; *aptr; aptr++) + { + strcpy (ptr, *aptr); + ptr += strlen (ptr) + 1; + *ptr ++ = ' '; + *ptr = 0; + } + + ptr[-1] = '\n'; + + Execute (buffer, NULL, child_stdout); + free (buffer); + + Close (child_stdout); + + child_stdout = Open (tmp_output, MODE_OLDFILE); + + buffer = xmalloc (maxlen); + i = 0; + do + { + if (i == maxlen) + { + maxlen += 512; + buffer = (char *) xrealloc (buffer, maxlen + 1); + } + + cc = Read (child_stdout, &buffer[i], maxlen - i); + if (cc > 0) + i += cc; + } while (cc > 0); + + Close (child_stdout); + + fold_newlines (buffer, &i); + o = variable_buffer_output (o, buffer, i); + free (buffer); + return o; +} +#endif /* _AMIGA */ +#endif /* !VMS */ + +#ifdef EXPERIMENTAL + +/* + equality. Return is string-boolean, ie, the empty string is false. + */ +static char * +func_eq (char* o, char **argv, char *funcname) +{ + int result = ! strcmp (argv[0], argv[1]); + o = variable_buffer_output (o, result ? "1" : "", result); + return o; +} + + +/* + string-boolean not operator. + */ +static char * +func_not (char* o, char **argv, char *funcname) +{ + char * s = argv[0]; + int result = 0; + while (isspace ((unsigned char)*s)) + s++; + result = ! (*s); + o = variable_buffer_output (o, result ? "1" : "", result); + return o; +} +#endif + + +/* Lookup table for builtin functions. + + This doesn't have to be sorted; we use a straight lookup. We might gain + some efficiency by moving most often used functions to the start of the + table. + + If MAXIMUM_ARGS is 0, that means there is no maximum and all + comma-separated values are treated as arguments. + + EXPAND_ARGS means that all arguments should be expanded before invocation. + Functions that do namespace tricks (foreach) don't automatically expand. */ + +static char *func_call PARAMS ((char *o, char **argv, const char *funcname)); + + +static struct function_table_entry function_table_init[] = +{ + /* Name/size */ /* MIN MAX EXP? Function */ + { STRING_SIZE_TUPLE("addprefix"), 2, 2, 1, func_addsuffix_addprefix}, + { STRING_SIZE_TUPLE("addsuffix"), 2, 2, 1, func_addsuffix_addprefix}, + { STRING_SIZE_TUPLE("basename"), 0, 1, 1, func_basename_dir}, + { STRING_SIZE_TUPLE("dir"), 0, 1, 1, func_basename_dir}, + { STRING_SIZE_TUPLE("notdir"), 0, 1, 1, func_notdir_suffix}, + { STRING_SIZE_TUPLE("subst"), 3, 3, 1, func_subst}, + { STRING_SIZE_TUPLE("suffix"), 0, 1, 1, func_notdir_suffix}, + { STRING_SIZE_TUPLE("filter"), 2, 2, 1, func_filter_filterout}, + { STRING_SIZE_TUPLE("filter-out"), 2, 2, 1, func_filter_filterout}, + { STRING_SIZE_TUPLE("findstring"), 2, 2, 1, func_findstring}, + { STRING_SIZE_TUPLE("firstword"), 0, 1, 1, func_firstword}, + { STRING_SIZE_TUPLE("join"), 2, 2, 1, func_join}, + { STRING_SIZE_TUPLE("patsubst"), 3, 3, 1, func_patsubst}, + { STRING_SIZE_TUPLE("shell"), 0, 1, 1, func_shell}, + { STRING_SIZE_TUPLE("sort"), 0, 1, 1, func_sort}, + { STRING_SIZE_TUPLE("strip"), 0, 1, 1, func_strip}, + { STRING_SIZE_TUPLE("wildcard"), 0, 1, 1, func_wildcard}, + { STRING_SIZE_TUPLE("word"), 2, 2, 1, func_word}, + { STRING_SIZE_TUPLE("wordlist"), 3, 3, 1, func_wordlist}, + { STRING_SIZE_TUPLE("words"), 0, 1, 1, func_words}, + { STRING_SIZE_TUPLE("origin"), 0, 1, 1, func_origin}, + { STRING_SIZE_TUPLE("foreach"), 3, 3, 0, func_foreach}, + { STRING_SIZE_TUPLE("call"), 1, 0, 1, func_call}, + { STRING_SIZE_TUPLE("error"), 0, 1, 1, func_error}, + { STRING_SIZE_TUPLE("warning"), 0, 1, 1, func_error}, + { STRING_SIZE_TUPLE("if"), 2, 3, 0, func_if}, + { STRING_SIZE_TUPLE("value"), 0, 1, 1, func_value}, + { STRING_SIZE_TUPLE("eval"), 0, 1, 1, func_eval}, +#ifdef EXPERIMENTAL + { STRING_SIZE_TUPLE("eq"), 2, 2, 1, func_eq}, + { STRING_SIZE_TUPLE("not"), 0, 1, 1, func_not}, +#endif +}; + +#define FUNCTION_TABLE_ENTRIES (sizeof (function_table_init) / sizeof (struct function_table_entry)) + + +/* These must come after the definition of function_table. */ + +static char * +expand_builtin_function (o, argc, argv, entry_p) + char *o; + int argc; + char **argv; + struct function_table_entry *entry_p; +{ + if (argc < (int)entry_p->minimum_args) + fatal (reading_file, + _("Insufficient number of arguments (%d) to function `%s'"), + argc, entry_p->name); + + /* I suppose technically some function could do something with no + arguments, but so far none do, so just test it for all functions here + rather than in each one. We can change it later if necessary. */ + + if (!argc) + return o; + + if (!entry_p->func_ptr) + fatal (reading_file, _("Unimplemented on this platform: function `%s'"), + entry_p->name); + + return entry_p->func_ptr (o, argv, entry_p->name); +} + +/* Check for a function invocation in *STRINGP. *STRINGP points at the + opening ( or { and is not null-terminated. If a function invocation + is found, expand it into the buffer at *OP, updating *OP, incrementing + *STRINGP past the reference and returning nonzero. If not, return zero. */ + +int +handle_function (op, stringp) + char **op; + char **stringp; +{ + const struct function_table_entry *entry_p; + char openparen = (*stringp)[0]; + char closeparen = openparen == '(' ? ')' : '}'; + char *beg; + char *end; + int count = 0; + register char *p; + char **argv, **argvp; + int nargs; + + beg = *stringp + 1; + + entry_p = lookup_function (beg); + + if (!entry_p) + return 0; + + /* We found a builtin function. Find the beginning of its arguments (skip + whitespace after the name). */ + + beg = next_token (beg + entry_p->len); + + /* Find the end of the function invocation, counting nested use of + whichever kind of parens we use. Since we're looking, count commas + to get a rough estimate of how many arguments we might have. The + count might be high, but it'll never be low. */ + + for (nargs=1, end=beg; *end != '\0'; ++end) + if (*end == ',') + ++nargs; + else if (*end == openparen) + ++count; + else if (*end == closeparen && --count < 0) + break; + + if (count >= 0) + fatal (reading_file, + _("unterminated call to function `%s': missing `%c'"), + entry_p->name, closeparen); + + *stringp = end; + + /* Get some memory to store the arg pointers. */ + argvp = argv = (char **) alloca (sizeof (char *) * (nargs + 2)); + + /* Chop the string into arguments, then a nul. As soon as we hit + MAXIMUM_ARGS (if it's >0) assume the rest of the string is part of the + last argument. + + If we're expanding, store pointers to the expansion of each one. If + not, make a duplicate of the string and point into that, nul-terminating + each argument. */ + + if (!entry_p->expand_args) + { + int len = end - beg; + + p = xmalloc (len+1); + memcpy (p, beg, len); + p[len] = '\0'; + beg = p; + end = beg + len; + } + + for (p=beg, nargs=0; p <= end; ++argvp) + { + char *next; + + ++nargs; + + if (nargs == entry_p->maximum_args + || (! (next = find_next_argument (openparen, closeparen, p, end)))) + next = end; + + if (entry_p->expand_args) + *argvp = expand_argument (p, next); + else + { + *argvp = p; + *next = '\0'; + } + + p = next + 1; + } + *argvp = NULL; + + /* Finally! Run the function... */ + *op = expand_builtin_function (*op, nargs, argv, entry_p); + + /* Free memory. */ + if (entry_p->expand_args) + for (argvp=argv; *argvp != 0; ++argvp) + free (*argvp); + else + free (beg); + + return 1; +} + + +/* User-defined functions. Expand the first argument as either a builtin + function or a make variable, in the context of the rest of the arguments + assigned to $1, $2, ... $N. $0 is the name of the function. */ + +static char * +func_call (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char *fname; + char *cp; + char *body; + int flen; + int i; + const struct function_table_entry *entry_p; + struct variable *v; + + /* There is no way to define a variable with a space in the name, so strip + leading and trailing whitespace as a favor to the user. */ + fname = argv[0]; + while (*fname != '\0' && isspace ((unsigned char)*fname)) + ++fname; + + cp = fname + strlen (fname) - 1; + while (cp > fname && isspace ((unsigned char)*cp)) + --cp; + cp[1] = '\0'; + + /* Calling nothing is a no-op */ + if (*fname == '\0') + return o; + + /* Are we invoking a builtin function? */ + + entry_p = lookup_function (fname); + + if (entry_p) + { + /* How many arguments do we have? */ + for (i=0; argv[i+1]; ++i) + ; + + return expand_builtin_function (o, i, argv+1, entry_p); + } + + /* Not a builtin, so the first argument is the name of a variable to be + expanded and interpreted as a function. Find it. */ + flen = strlen (fname); + + v = lookup_variable (fname, flen); + + if (v == 0) + warn_undefined (fname, flen); + + if (v == 0 || *v->value == '\0') + return o; + + body = (char *) alloca (flen + 4); + body[0] = '$'; + body[1] = '('; + memcpy (body + 2, fname, flen); + body[flen+2] = ')'; + body[flen+3] = '\0'; + + /* Set up arguments $(1) .. $(N). $(0) is the function name. */ + + push_new_variable_scope (); + + for (i=0; *argv; ++i, ++argv) + { + char num[11]; + + sprintf (num, "%d", i); + define_variable (num, strlen (num), *argv, o_automatic, 0); + } + + /* Expand the body in the context of the arguments, adding the result to + the variable buffer. */ + + v->exp_count = EXP_COUNT_MAX; + + o = variable_expand_string (o, body, flen+3); + + v->exp_count = 0; + + pop_variable_scope (); + + return o + strlen (o); +} + +void +hash_init_function_table () +{ + hash_init (&function_table, FUNCTION_TABLE_ENTRIES * 2, + function_table_entry_hash_1, function_table_entry_hash_2, + function_table_entry_hash_cmp); + hash_load (&function_table, function_table_init, + FUNCTION_TABLE_ENTRIES, sizeof (struct function_table_entry)); +} diff --git a/flaim/external/w32/make/getloadavg.c b/flaim/external/w32/make/getloadavg.c new file mode 100644 index 0000000..7d575cd --- /dev/null +++ b/flaim/external/w32/make/getloadavg.c @@ -0,0 +1,1034 @@ +/* Get the system load averages. + Copyright (C) 1985, 86, 87, 88, 89, 91, 92, 93, 1994, 1995, 1997 + Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + USA. */ + +/* Compile-time symbols that this file uses: + + HAVE_PSTAT_GETDYNAMIC Define this if your system has the + pstat_getdynamic function. I think it + is unique to HPUX9. The best way to get the + definition is through the AC_FUNC_GETLOADAVG + macro that comes with autoconf 2.13 or newer. + If that isn't an option, then just put + AC_CHECK_FUNCS(pstat_getdynamic) in your + configure.in file. + FIXUP_KERNEL_SYMBOL_ADDR() Adjust address in returned struct nlist. + KERNEL_FILE Pathname of the kernel to nlist. + LDAV_CVT() Scale the load average from the kernel. + Returns a double. + LDAV_SYMBOL Name of kernel symbol giving load average. + LOAD_AVE_TYPE Type of the load average array in the kernel. + Must be defined unless one of + apollo, DGUX, NeXT, or UMAX is defined; + or we have libkstat; + otherwise, no load average is available. + NLIST_STRUCT Include nlist.h, not a.out.h, and + the nlist n_name element is a pointer, + not an array. + HAVE_STRUCT_NLIST_N_UN_N_NAME struct nlist has an n_un member, not n_name. + LINUX_LDAV_FILE [__linux__]: File containing load averages. + + Specific system predefines this file uses, aside from setting + default values if not emacs: + + apollo + BSD Real BSD, not just BSD-like. + convex + DGUX + eunice UNIX emulator under VMS. + hpux + __MSDOS__ No-op for MSDOS. + NeXT + sgi + sequent Sequent Dynix 3.x.x (BSD) + _SEQUENT_ Sequent DYNIX/ptx 1.x.x (SYSV) + sony_news NEWS-OS (works at least for 4.1C) + UMAX + UMAX4_3 + VMS + WINDOWS32 No-op for Windows95/NT. + __linux__ Linux: assumes /proc filesystem mounted. + Support from Michael K. Johnson. + __NetBSD__ NetBSD: assumes /kern filesystem mounted. + + In addition, to avoid nesting many #ifdefs, we internally set + LDAV_DONE to indicate that the load average has been computed. + + We also #define LDAV_PRIVILEGED if a program will require + special installation to be able to call getloadavg. */ + +/* This should always be first. */ +#ifdef HAVE_CONFIG_H +# include +#endif + +#include + +/* Both the Emacs and non-Emacs sections want this. Some + configuration files' definitions for the LOAD_AVE_CVT macro (like + sparc.h's) use macros like FSCALE, defined here. */ +#if defined (unix) || defined (__unix) +# include +#endif + + +/* Exclude all the code except the test program at the end + if the system has its own `getloadavg' function. + + The declaration of `errno' is needed by the test program + as well as the function itself, so it comes first. */ + +#include + +#ifndef errno +extern int errno; +#endif + +#if HAVE_LOCALE_H +# include +#endif +#if !HAVE_SETLOCALE +# define setlocale(Category, Locale) /* empty */ +#endif + +#ifndef HAVE_GETLOADAVG + + +/* The existing Emacs configuration files define a macro called + LOAD_AVE_CVT, which accepts a value of type LOAD_AVE_TYPE, and + returns the load average multiplied by 100. What we actually want + is a macro called LDAV_CVT, which returns the load average as an + unmultiplied double. + + For backwards compatibility, we'll define LDAV_CVT in terms of + LOAD_AVE_CVT, but future machine config files should just define + LDAV_CVT directly. */ + +# if !defined(LDAV_CVT) && defined(LOAD_AVE_CVT) +# define LDAV_CVT(n) (LOAD_AVE_CVT (n) / 100.0) +# endif + +# if !defined (BSD) && defined (ultrix) +/* Ultrix behaves like BSD on Vaxen. */ +# define BSD +# endif + +# ifdef NeXT +/* NeXT in the 2.{0,1,2} releases defines BSD in , which + conflicts with the definition understood in this file, that this + really is BSD. */ +# undef BSD + +/* NeXT defines FSCALE in . However, we take FSCALE being + defined to mean that the nlist method should be used, which is not true. */ +# undef FSCALE +# endif + +/* Same issues as for NeXT apply to the HURD-based GNU system. */ +# ifdef __GNU__ +# undef BSD +# undef FSCALE +# endif /* __GNU__ */ + +/* Set values that are different from the defaults, which are + set a little farther down with #ifndef. */ + + +/* Some shorthands. */ + +# if defined (HPUX) && !defined (hpux) +# define hpux +# endif + +# if defined (__hpux) && !defined (hpux) +# define hpux +# endif + +# if defined (__sun) && !defined (sun) +# define sun +# endif + +# if defined(hp300) && !defined(hpux) +# define MORE_BSD +# endif + +# if defined(ultrix) && defined(mips) +# define decstation +# endif + +# if defined (__SVR4) && !defined (SVR4) +# define SVR4 +# endif + +# if (defined(sun) && defined(SVR4)) || defined (SOLARIS2) +# define SUNOS_5 +# endif + +# if defined (__osf__) && (defined (__alpha) || defined (__alpha__)) +# define OSF_ALPHA +# include +# include +# include +# include +# endif + +# if defined (__osf__) && (defined (mips) || defined (__mips__)) +# define OSF_MIPS +# include +# endif + +/* UTek's /bin/cc on the 4300 has no architecture specific cpp define by + default, but _MACH_IND_SYS_TYPES is defined in . Combine + that with a couple of other things and we'll have a unique match. */ +# if !defined (tek4300) && defined (unix) && defined (m68k) && defined (mc68000) && defined (mc68020) && defined (_MACH_IND_SYS_TYPES) +# define tek4300 /* Define by emacs, but not by other users. */ +# endif + +/* AC_FUNC_GETLOADAVG thinks QNX is SVR4, but it isn't. */ +# if defined(__QNX__) +# undef SVR4 +# endif + +/* VAX C can't handle multi-line #ifs, or lines longer than 256 chars. */ +# ifndef LOAD_AVE_TYPE + +# ifdef MORE_BSD +# define LOAD_AVE_TYPE long +# endif + +# ifdef sun +# define LOAD_AVE_TYPE long +# endif + +# ifdef decstation +# define LOAD_AVE_TYPE long +# endif + +# ifdef _SEQUENT_ +# define LOAD_AVE_TYPE long +# endif + +# ifdef sgi +# define LOAD_AVE_TYPE long +# endif + +# ifdef SVR4 +# define LOAD_AVE_TYPE long +# endif + +# ifdef sony_news +# define LOAD_AVE_TYPE long +# endif + +# ifdef sequent +# define LOAD_AVE_TYPE long +# endif + +# ifdef OSF_ALPHA +# define LOAD_AVE_TYPE long +# endif + +# if defined (ardent) && defined (titan) +# define LOAD_AVE_TYPE long +# endif + +# ifdef tek4300 +# define LOAD_AVE_TYPE long +# endif + +# if defined(alliant) && defined(i860) /* Alliant FX/2800 */ +# define LOAD_AVE_TYPE long +# endif + +# ifdef _AIX +# define LOAD_AVE_TYPE long +# endif + +# ifdef convex +# define LOAD_AVE_TYPE double +# ifndef LDAV_CVT +# define LDAV_CVT(n) (n) +# endif +# endif + +# endif /* No LOAD_AVE_TYPE. */ + +# ifdef OSF_ALPHA +/* defines an incorrect value for FSCALE on Alpha OSF/1, + according to ghazi@noc.rutgers.edu. */ +# undef FSCALE +# define FSCALE 1024.0 +# endif + +# if defined(alliant) && defined(i860) /* Alliant FX/2800 */ +/* defines an incorrect value for FSCALE on an + Alliant FX/2800 Concentrix 2.2, according to ghazi@noc.rutgers.edu. */ +# undef FSCALE +# define FSCALE 100.0 +# endif + + +# ifndef FSCALE + +/* SunOS and some others define FSCALE in sys/param.h. */ + +# ifdef MORE_BSD +# define FSCALE 2048.0 +# endif + +# if defined(MIPS) || defined(SVR4) || defined(decstation) +# define FSCALE 256 +# endif + +# if defined (sgi) || defined (sequent) +/* Sometimes both MIPS and sgi are defined, so FSCALE was just defined + above under #ifdef MIPS. But we want the sgi value. */ +# undef FSCALE +# define FSCALE 1000.0 +# endif + +# if defined (ardent) && defined (titan) +# define FSCALE 65536.0 +# endif + +# ifdef tek4300 +# define FSCALE 100.0 +# endif + +# ifdef _AIX +# define FSCALE 65536.0 +# endif + +# endif /* Not FSCALE. */ + +# if !defined (LDAV_CVT) && defined (FSCALE) +# define LDAV_CVT(n) (((double) (n)) / FSCALE) +# endif + + +# if defined(sgi) || (defined(mips) && !defined(BSD)) +# define FIXUP_KERNEL_SYMBOL_ADDR(nl) ((nl)[0].n_value &= ~(1 << 31)) +# endif + + +# if !defined (KERNEL_FILE) && defined (sequent) +# define KERNEL_FILE "/dynix" +# endif + +# if !defined (KERNEL_FILE) && defined (hpux) +# define KERNEL_FILE "/hp-ux" +# endif + +# if !defined(KERNEL_FILE) && (defined(_SEQUENT_) || defined(MIPS) || defined(SVR4) || defined(ISC) || defined (sgi) || (defined (ardent) && defined (titan))) +# define KERNEL_FILE "/unix" +# endif + + +# if !defined (LDAV_SYMBOL) && defined (alliant) +# define LDAV_SYMBOL "_Loadavg" +# endif + +# if !defined(LDAV_SYMBOL) && ((defined(hpux) && !defined(hp9000s300)) || defined(_SEQUENT_) || defined(SVR4) || defined(ISC) || defined(sgi) || (defined (ardent) && defined (titan)) || defined (_AIX)) +# define LDAV_SYMBOL "avenrun" +# endif + +# ifdef HAVE_UNISTD_H +# include +# endif + +# include + +/* LOAD_AVE_TYPE should only get defined if we're going to use the + nlist method. */ +# if !defined(LOAD_AVE_TYPE) && (defined(BSD) || defined(LDAV_CVT) || defined(KERNEL_FILE) || defined(LDAV_SYMBOL)) +# define LOAD_AVE_TYPE double +# endif + +# ifdef LOAD_AVE_TYPE + +# ifndef VMS +# ifndef __linux__ +# ifdef HAVE_NLIST_H +# include +# else +# include +# endif + +# ifdef SUNOS_5 +# include +# include +# include +# endif + +# if defined (hpux) && defined (HAVE_PSTAT_GETDYNAMIC) +# include +# endif + +# ifndef KERNEL_FILE +# define KERNEL_FILE "/vmunix" +# endif /* KERNEL_FILE */ + +# ifndef LDAV_SYMBOL +# define LDAV_SYMBOL "_avenrun" +# endif /* LDAV_SYMBOL */ +# endif /* __linux__ */ + +# else /* VMS */ + +# ifndef eunice +# include +# include +# else /* eunice */ +# include +# endif /* eunice */ +# endif /* VMS */ + +# ifndef LDAV_CVT +# define LDAV_CVT(n) ((double) (n)) +# endif /* !LDAV_CVT */ + +# endif /* LOAD_AVE_TYPE */ + +# if defined(__GNU__) && !defined (NeXT) +/* Note that NeXT Openstep defines __GNU__ even though it should not. */ +/* GNU system acts much like NeXT, for load average purposes, + but not exactly. */ +# define NeXT +# define host_self mach_host_self +# endif + +# ifdef NeXT +# ifdef HAVE_MACH_MACH_H +# include +# else +# include +# endif +# endif /* NeXT */ + +# ifdef sgi +# include +# endif /* sgi */ + +# ifdef UMAX +# include +# include +# include +# include +# include + +# ifdef UMAX_43 +# include +# include +# include +# include +# include +# else /* Not UMAX_43. */ +# include +# include +# include +# include +# include +# include +# endif /* Not UMAX_43. */ +# endif /* UMAX */ + +# ifdef DGUX +# include +# endif + +# if defined(HAVE_FCNTL_H) || defined(_POSIX_VERSION) +# include +# else +# include +# endif + + +/* Avoid static vars inside a function since in HPUX they dump as pure. */ + +# ifdef NeXT +static processor_set_t default_set; +static int getloadavg_initialized; +# endif /* NeXT */ + +# ifdef UMAX +static unsigned int cpus = 0; +static unsigned int samples; +# endif /* UMAX */ + +# ifdef DGUX +static struct dg_sys_info_load_info load_info; /* what-a-mouthful! */ +# endif /* DGUX */ + +#if !defined(HAVE_LIBKSTAT) && defined(LOAD_AVE_TYPE) +/* File descriptor open to /dev/kmem or VMS load ave driver. */ +static int channel; +/* Nonzero iff channel is valid. */ +static int getloadavg_initialized; +/* Offset in kmem to seek to read load average, or 0 means invalid. */ +static long offset; + +#if !defined(VMS) && !defined(sgi) && !defined(__linux__) +static struct nlist nl[2]; +#endif /* Not VMS or sgi */ + +#ifdef SUNOS_5 +static kvm_t *kd; +#endif /* SUNOS_5 */ + +#endif /* LOAD_AVE_TYPE && !HAVE_LIBKSTAT */ + +/* Put the 1 minute, 5 minute and 15 minute load averages + into the first NELEM elements of LOADAVG. + Return the number written (never more than 3, but may be less than NELEM), + or -1 if an error occurred. */ + +int +getloadavg (loadavg, nelem) + double loadavg[]; + int nelem; +{ + int elem = 0; /* Return value. */ + +# ifdef NO_GET_LOAD_AVG +# define LDAV_DONE + /* Set errno to zero to indicate that there was no particular error; + this function just can't work at all on this system. */ + errno = 0; + elem = -1; +# endif + +# if !defined (LDAV_DONE) && defined (HAVE_LIBKSTAT) +/* Use libkstat because we don't have to be root. */ +# define LDAV_DONE + kstat_ctl_t *kc; + kstat_t *ksp; + kstat_named_t *kn; + + kc = kstat_open (); + if (kc == 0) + return -1; + ksp = kstat_lookup (kc, "unix", 0, "system_misc"); + if (ksp == 0 ) + return -1; + if (kstat_read (kc, ksp, 0) == -1) + return -1; + + + kn = kstat_data_lookup (ksp, "avenrun_1min"); + if (kn == 0) + { + /* Return -1 if no load average information is available. */ + nelem = 0; + elem = -1; + } + + if (nelem >= 1) + loadavg[elem++] = (double) kn->value.ul/FSCALE; + + if (nelem >= 2) + { + kn = kstat_data_lookup (ksp, "avenrun_5min"); + if (kn != 0) + { + loadavg[elem++] = (double) kn->value.ul/FSCALE; + + if (nelem >= 3) + { + kn = kstat_data_lookup (ksp, "avenrun_15min"); + if (kn != 0) + loadavg[elem++] = (double) kn->value.ul/FSCALE; + } + } + } + + kstat_close (kc); +# endif /* HAVE_LIBKSTAT */ + +# if !defined (LDAV_DONE) && defined (hpux) && defined (HAVE_PSTAT_GETDYNAMIC) +/* Use pstat_getdynamic() because we don't have to be root. */ +# define LDAV_DONE +# undef LOAD_AVE_TYPE + + struct pst_dynamic dyn_info; + if (pstat_getdynamic (&dyn_info, sizeof (dyn_info), 0, 0) < 0) + return -1; + if (nelem > 0) + loadavg[elem++] = dyn_info.psd_avg_1_min; + if (nelem > 1) + loadavg[elem++] = dyn_info.psd_avg_5_min; + if (nelem > 2) + loadavg[elem++] = dyn_info.psd_avg_15_min; + +# endif /* hpux && HAVE_PSTAT_GETDYNAMIC */ + +# if !defined (LDAV_DONE) && defined (__linux__) +# define LDAV_DONE +# undef LOAD_AVE_TYPE + +# ifndef LINUX_LDAV_FILE +# define LINUX_LDAV_FILE "/proc/loadavg" +# endif + + char ldavgbuf[40]; + double load_ave[3]; + int fd, count; + + fd = open (LINUX_LDAV_FILE, O_RDONLY); + if (fd == -1) + return -1; + count = read (fd, ldavgbuf, 40); + (void) close (fd); + if (count <= 0) + return -1; + + /* The following sscanf must use the C locale. */ + setlocale (LC_NUMERIC, "C"); + count = sscanf (ldavgbuf, "%lf %lf %lf", + &load_ave[0], &load_ave[1], &load_ave[2]); + setlocale (LC_NUMERIC, ""); + if (count < 1) + return -1; + + for (elem = 0; elem < nelem && elem < count; elem++) + loadavg[elem] = load_ave[elem]; + + return elem; + +# endif /* __linux__ */ + +# if !defined (LDAV_DONE) && defined (__NetBSD__) +# define LDAV_DONE +# undef LOAD_AVE_TYPE + +# ifndef NETBSD_LDAV_FILE +# define NETBSD_LDAV_FILE "/kern/loadavg" +# endif + + unsigned long int load_ave[3], scale; + int count; + FILE *fp; + + fp = fopen (NETBSD_LDAV_FILE, "r"); + if (fp == NULL) + return -1; + count = fscanf (fp, "%lu %lu %lu %lu\n", + &load_ave[0], &load_ave[1], &load_ave[2], + &scale); + (void) fclose (fp); + if (count != 4) + return -1; + + for (elem = 0; elem < nelem; elem++) + loadavg[elem] = (double) load_ave[elem] / (double) scale; + + return elem; + +# endif /* __NetBSD__ */ + +# if !defined (LDAV_DONE) && defined (NeXT) +# define LDAV_DONE + /* The NeXT code was adapted from iscreen 3.2. */ + + host_t host; + struct processor_set_basic_info info; + unsigned info_count; + + /* We only know how to get the 1-minute average for this system, + so even if the caller asks for more than 1, we only return 1. */ + + if (!getloadavg_initialized) + { + if (processor_set_default (host_self (), &default_set) == KERN_SUCCESS) + getloadavg_initialized = 1; + } + + if (getloadavg_initialized) + { + info_count = PROCESSOR_SET_BASIC_INFO_COUNT; + if (processor_set_info (default_set, PROCESSOR_SET_BASIC_INFO, &host, + (processor_set_info_t) &info, &info_count) + != KERN_SUCCESS) + getloadavg_initialized = 0; + else + { + if (nelem > 0) + loadavg[elem++] = (double) info.load_average / LOAD_SCALE; + } + } + + if (!getloadavg_initialized) + return -1; +# endif /* NeXT */ + +# if !defined (LDAV_DONE) && defined (UMAX) +# define LDAV_DONE +/* UMAX 4.2, which runs on the Encore Multimax multiprocessor, does not + have a /dev/kmem. Information about the workings of the running kernel + can be gathered with inq_stats system calls. + We only know how to get the 1-minute average for this system. */ + + struct proc_summary proc_sum_data; + struct stat_descr proc_info; + double load; + register unsigned int i, j; + + if (cpus == 0) + { + register unsigned int c, i; + struct cpu_config conf; + struct stat_descr desc; + + desc.sd_next = 0; + desc.sd_subsys = SUBSYS_CPU; + desc.sd_type = CPUTYPE_CONFIG; + desc.sd_addr = (char *) &conf; + desc.sd_size = sizeof conf; + + if (inq_stats (1, &desc)) + return -1; + + c = 0; + for (i = 0; i < conf.config_maxclass; ++i) + { + struct class_stats stats; + bzero ((char *) &stats, sizeof stats); + + desc.sd_type = CPUTYPE_CLASS; + desc.sd_objid = i; + desc.sd_addr = (char *) &stats; + desc.sd_size = sizeof stats; + + if (inq_stats (1, &desc)) + return -1; + + c += stats.class_numcpus; + } + cpus = c; + samples = cpus < 2 ? 3 : (2 * cpus / 3); + } + + proc_info.sd_next = 0; + proc_info.sd_subsys = SUBSYS_PROC; + proc_info.sd_type = PROCTYPE_SUMMARY; + proc_info.sd_addr = (char *) &proc_sum_data; + proc_info.sd_size = sizeof (struct proc_summary); + proc_info.sd_sizeused = 0; + + if (inq_stats (1, &proc_info) != 0) + return -1; + + load = proc_sum_data.ps_nrunnable; + j = 0; + for (i = samples - 1; i > 0; --i) + { + load += proc_sum_data.ps_nrun[j]; + if (j++ == PS_NRUNSIZE) + j = 0; + } + + if (nelem > 0) + loadavg[elem++] = load / samples / cpus; +# endif /* UMAX */ + +# if !defined (LDAV_DONE) && defined (DGUX) +# define LDAV_DONE + /* This call can return -1 for an error, but with good args + it's not supposed to fail. The first argument is for no + apparent reason of type `long int *'. */ + dg_sys_info ((long int *) &load_info, + DG_SYS_INFO_LOAD_INFO_TYPE, + DG_SYS_INFO_LOAD_VERSION_0); + + if (nelem > 0) + loadavg[elem++] = load_info.one_minute; + if (nelem > 1) + loadavg[elem++] = load_info.five_minute; + if (nelem > 2) + loadavg[elem++] = load_info.fifteen_minute; +# endif /* DGUX */ + +# if !defined (LDAV_DONE) && defined (apollo) +# define LDAV_DONE +/* Apollo code from lisch@mentorg.com (Ray Lischner). + + This system call is not documented. The load average is obtained as + three long integers, for the load average over the past minute, + five minutes, and fifteen minutes. Each value is a scaled integer, + with 16 bits of integer part and 16 bits of fraction part. + + I'm not sure which operating system first supported this system call, + but I know that SR10.2 supports it. */ + + extern void proc1_$get_loadav (); + unsigned long load_ave[3]; + + proc1_$get_loadav (load_ave); + + if (nelem > 0) + loadavg[elem++] = load_ave[0] / 65536.0; + if (nelem > 1) + loadavg[elem++] = load_ave[1] / 65536.0; + if (nelem > 2) + loadavg[elem++] = load_ave[2] / 65536.0; +# endif /* apollo */ + +# if !defined (LDAV_DONE) && defined (OSF_MIPS) +# define LDAV_DONE + + struct tbl_loadavg load_ave; + table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave)); + loadavg[elem++] + = (load_ave.tl_lscale == 0 + ? load_ave.tl_avenrun.d[0] + : (load_ave.tl_avenrun.l[0] / (double) load_ave.tl_lscale)); +# endif /* OSF_MIPS */ + +# if !defined (LDAV_DONE) && (defined (__MSDOS__) || defined (WINDOWS32)) +# define LDAV_DONE + + /* A faithful emulation is going to have to be saved for a rainy day. */ + for ( ; elem < nelem; elem++) + { + loadavg[elem] = 0.0; + } +# endif /* __MSDOS__ || WINDOWS32 */ + +# if !defined (LDAV_DONE) && defined (OSF_ALPHA) +# define LDAV_DONE + + struct tbl_loadavg load_ave; + table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave)); + for (elem = 0; elem < nelem; elem++) + loadavg[elem] + = (load_ave.tl_lscale == 0 + ? load_ave.tl_avenrun.d[elem] + : (load_ave.tl_avenrun.l[elem] / (double) load_ave.tl_lscale)); +# endif /* OSF_ALPHA */ + +# if !defined (LDAV_DONE) && defined (VMS) + /* VMS specific code -- read from the Load Ave driver. */ + + LOAD_AVE_TYPE load_ave[3]; + static int getloadavg_initialized = 0; +# ifdef eunice + struct + { + int dsc$w_length; + char *dsc$a_pointer; + } descriptor; +# endif + + /* Ensure that there is a channel open to the load ave device. */ + if (!getloadavg_initialized) + { + /* Attempt to open the channel. */ +# ifdef eunice + descriptor.dsc$w_length = 18; + descriptor.dsc$a_pointer = "$$VMS_LOAD_AVERAGE"; +# else + $DESCRIPTOR (descriptor, "LAV0:"); +# endif + if (sys$assign (&descriptor, &channel, 0, 0) & 1) + getloadavg_initialized = 1; + } + + /* Read the load average vector. */ + if (getloadavg_initialized + && !(sys$qiow (0, channel, IO$_READVBLK, 0, 0, 0, + load_ave, 12, 0, 0, 0, 0) & 1)) + { + sys$dassgn (channel); + getloadavg_initialized = 0; + } + + if (!getloadavg_initialized) + return -1; +# endif /* VMS */ + +# if !defined (LDAV_DONE) && defined(LOAD_AVE_TYPE) && !defined(VMS) + + /* UNIX-specific code -- read the average from /dev/kmem. */ + +# define LDAV_PRIVILEGED /* This code requires special installation. */ + + LOAD_AVE_TYPE load_ave[3]; + + /* Get the address of LDAV_SYMBOL. */ + if (offset == 0) + { +# ifndef sgi +# ifndef NLIST_STRUCT + strcpy (nl[0].n_name, LDAV_SYMBOL); + strcpy (nl[1].n_name, ""); +# else /* NLIST_STRUCT */ +# ifdef HAVE_STRUCT_NLIST_N_UN_N_NAME + nl[0].n_un.n_name = LDAV_SYMBOL; + nl[1].n_un.n_name = 0; +# else /* not HAVE_STRUCT_NLIST_N_UN_N_NAME */ + nl[0].n_name = LDAV_SYMBOL; + nl[1].n_name = 0; +# endif /* not HAVE_STRUCT_NLIST_N_UN_N_NAME */ +# endif /* NLIST_STRUCT */ + +# ifndef SUNOS_5 + if ( +# if !(defined (_AIX) && !defined (ps2)) + nlist (KERNEL_FILE, nl) +# else /* _AIX */ + knlist (nl, 1, sizeof (nl[0])) +# endif + >= 0) + /* Omit "&& nl[0].n_type != 0 " -- it breaks on Sun386i. */ + { +# ifdef FIXUP_KERNEL_SYMBOL_ADDR + FIXUP_KERNEL_SYMBOL_ADDR (nl); +# endif + offset = nl[0].n_value; + } +# endif /* !SUNOS_5 */ +# else /* sgi */ + int ldav_off; + + ldav_off = sysmp (MP_KERNADDR, MPKA_AVENRUN); + if (ldav_off != -1) + offset = (long) ldav_off & 0x7fffffff; +# endif /* sgi */ + } + + /* Make sure we have /dev/kmem open. */ + if (!getloadavg_initialized) + { +# ifndef SUNOS_5 + channel = open ("/dev/kmem", 0); + if (channel >= 0) + { + /* Set the channel to close on exec, so it does not + litter any child's descriptor table. */ +# ifdef F_SETFD +# ifndef FD_CLOEXEC +# define FD_CLOEXEC 1 +# endif + (void) fcntl (channel, F_SETFD, FD_CLOEXEC); +# endif + getloadavg_initialized = 1; + } +# else /* SUNOS_5 */ + /* We pass 0 for the kernel, corefile, and swapfile names + to use the currently running kernel. */ + kd = kvm_open (0, 0, 0, O_RDONLY, 0); + if (kd != 0) + { + /* nlist the currently running kernel. */ + kvm_nlist (kd, nl); + offset = nl[0].n_value; + getloadavg_initialized = 1; + } +# endif /* SUNOS_5 */ + } + + /* If we can, get the load average values. */ + if (offset && getloadavg_initialized) + { + /* Try to read the load. */ +# ifndef SUNOS_5 + if (lseek (channel, offset, 0) == -1L + || read (channel, (char *) load_ave, sizeof (load_ave)) + != sizeof (load_ave)) + { + close (channel); + getloadavg_initialized = 0; + } +# else /* SUNOS_5 */ + if (kvm_read (kd, offset, (char *) load_ave, sizeof (load_ave)) + != sizeof (load_ave)) + { + kvm_close (kd); + getloadavg_initialized = 0; + } +# endif /* SUNOS_5 */ + } + + if (offset == 0 || !getloadavg_initialized) + return -1; +# endif /* LOAD_AVE_TYPE and not VMS */ + +# if !defined (LDAV_DONE) && defined (LOAD_AVE_TYPE) /* Including VMS. */ + if (nelem > 0) + loadavg[elem++] = LDAV_CVT (load_ave[0]); + if (nelem > 1) + loadavg[elem++] = LDAV_CVT (load_ave[1]); + if (nelem > 2) + loadavg[elem++] = LDAV_CVT (load_ave[2]); + +# define LDAV_DONE +# endif /* !LDAV_DONE && LOAD_AVE_TYPE */ + +# ifdef LDAV_DONE + return elem; +# else + /* Set errno to zero to indicate that there was no particular error; + this function just can't work at all on this system. */ + errno = 0; + return -1; +# endif +} + +#endif /* ! HAVE_GETLOADAVG */ + +#ifdef TEST +#include "make.h" + +int +main (argc, argv) + int argc; + char **argv; +{ + int naptime = 0; + + if (argc > 1) + naptime = atoi (argv[1]); + + while (1) + { + double avg[3]; + int loads; + + errno = 0; /* Don't be misled if it doesn't set errno. */ + loads = getloadavg (avg, 3); + if (loads == -1) + { + perror ("Error getting load average"); + exit (1); + } + if (loads > 0) + printf ("1-minute: %f ", avg[0]); + if (loads > 1) + printf ("5-minute: %f ", avg[1]); + if (loads > 2) + printf ("15-minute: %f ", avg[2]); + if (loads > 0) + putchar ('\n'); + + if (naptime == 0) + break; + sleep (naptime); + } + + exit (0); +} +#endif /* TEST */ diff --git a/flaim/external/w32/make/getopt.c b/flaim/external/w32/make/getopt.c new file mode 100644 index 0000000..cd77419 --- /dev/null +++ b/flaim/external/w32/make/getopt.c @@ -0,0 +1,1047 @@ +/* Getopt for GNU. + NOTE: getopt is now part of the C library, so if you don't know what + "Keep this file name-space clean" means, talk to drepper@gnu.org + before changing it! + + Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98 + Free Software Foundation, Inc. + + NOTE: The canonical source of this file is maintained with the GNU C Library. + Bugs can be reported to bug-glibc@gnu.org. + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 2, or (at your option) any + later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + USA. */ + +/* This tells Alpha OSF/1 not to define a getopt prototype in . + Ditto for AIX 3.2 and . */ +#ifndef _NO_PROTO +# define _NO_PROTO +#endif + +#ifdef HAVE_CONFIG_H +# include +#endif + +#if !defined __STDC__ || !__STDC__ +/* This is a separate conditional since some stdc systems + reject `defined (const)'. */ +# ifndef const +# define const +# endif +#endif + +#include + +/* Comment out all this code if we are using the GNU C Library, and are not + actually compiling the library itself. This code is part of the GNU C + Library, but also included in many other GNU distributions. Compiling + and linking in this code is a waste when using the GNU C library + (especially if it is a shared library). Rather than having every GNU + program understand `configure --with-gnu-libc' and omit the object files, + it is simpler to just do this in the source for each such file. */ + +#define GETOPT_INTERFACE_VERSION 2 +#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2 +# include +# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION +# define ELIDE_CODE +# endif +#endif + +#ifndef ELIDE_CODE + + +/* This needs to come after some library #include + to get __GNU_LIBRARY__ defined. */ +#ifdef __GNU_LIBRARY__ +/* Don't include stdlib.h for non-GNU C libraries because some of them + contain conflicting prototypes for getopt. */ +# include +# include +#endif /* GNU C library. */ + +#ifdef VMS +# include +# if HAVE_STRING_H - 0 +# include +# endif +#endif + +/* This is for other GNU distributions with internationalized messages. + When compiling libc, the _ macro is predefined. */ +#include "gettext.h" +#define _(msgid) gettext (msgid) + + +/* This version of `getopt' appears to the caller like standard Unix `getopt' + but it behaves differently for the user, since it allows the user + to intersperse the options with the other arguments. + + As `getopt' works, it permutes the elements of ARGV so that, + when it is done, all the options precede everything else. Thus + all application programs are extended to handle flexible argument order. + + Setting the environment variable POSIXLY_CORRECT disables permutation. + Then the behavior is completely standard. + + GNU application programs can use a third alternative mode in which + they can distinguish the relative order of options and other arguments. */ + +#include "getopt.h" + +/* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +char *optarg = NULL; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns -1, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +/* 1003.2 says this must be 1 before any call. */ +int optind = 1; + +/* Formerly, initialization of getopt depended on optind==0, which + causes problems with re-calling getopt as programs generally don't + know that. */ + +int __getopt_initialized = 0; + +/* The next char to be scanned in the option-element + in which the last option character we returned was found. + This allows us to pick up the scan where we left off. + + If this is zero, or a null string, it means resume the scan + by advancing to the next ARGV-element. */ + +static char *nextchar; + +/* Callers store zero here to inhibit the error message + for unrecognized options. */ + +int opterr = 1; + +/* Set to an option character which was unrecognized. + This must be initialized on some systems to avoid linking in the + system's own getopt implementation. */ + +int optopt = '?'; + +/* Describe how to deal with options that follow non-option ARGV-elements. + + If the caller did not specify anything, + the default is REQUIRE_ORDER if the environment variable + POSIXLY_CORRECT is defined, PERMUTE otherwise. + + REQUIRE_ORDER means don't recognize them as options; + stop option processing when the first non-option is seen. + This is what Unix does. + This mode of operation is selected by either setting the environment + variable POSIXLY_CORRECT, or using `+' as the first character + of the list of option characters. + + PERMUTE is the default. We permute the contents of ARGV as we scan, + so that eventually all the non-options are at the end. This allows options + to be given in any order, even with programs that were not written to + expect this. + + RETURN_IN_ORDER is an option available to programs that were written + to expect options and other ARGV-elements in any order and that care about + the ordering of the two. We describe each non-option ARGV-element + as if it were the argument of an option with character code 1. + Using `-' as the first character of the list of option characters + selects this mode of operation. + + The special argument `--' forces an end of option-scanning regardless + of the value of `ordering'. In the case of RETURN_IN_ORDER, only + `--' can cause `getopt' to return -1 with `optind' != ARGC. */ + +static enum +{ + REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER +} ordering; + +/* Value of POSIXLY_CORRECT environment variable. */ +static char *posixly_correct; + +#ifdef __GNU_LIBRARY__ +/* We want to avoid inclusion of string.h with non-GNU libraries + because there are many ways it can cause trouble. + On some systems, it contains special magic macros that don't work + in GCC. */ +# include +# define my_index strchr +#else + +# if HAVE_STRING_H +# include +# else +# include +# endif + +/* Avoid depending on library functions or files + whose names are inconsistent. */ + +#ifndef getenv +extern char *getenv (); +#endif + +static char * +my_index (str, chr) + const char *str; + int chr; +{ + while (*str) + { + if (*str == chr) + return (char *) str; + str++; + } + return 0; +} + +/* If using GCC, we can safely declare strlen this way. + If not using GCC, it is ok not to declare it. */ +#ifdef __GNUC__ +/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. + That was relevant to code that was here before. */ +# if (!defined __STDC__ || !__STDC__) && !defined strlen +/* gcc with -traditional declares the built-in strlen to return int, + and has done so at least since version 2.4.5. -- rms. */ +extern int strlen (const char *); +# endif /* not __STDC__ */ +#endif /* __GNUC__ */ + +#endif /* not __GNU_LIBRARY__ */ + +/* Handle permutation of arguments. */ + +/* Describe the part of ARGV that contains non-options that have + been skipped. `first_nonopt' is the index in ARGV of the first of them; + `last_nonopt' is the index after the last of them. */ + +static int first_nonopt; +static int last_nonopt; + +#ifdef _LIBC +/* Bash 2.0 gives us an environment variable containing flags + indicating ARGV elements that should not be considered arguments. */ + +/* Defined in getopt_init.c */ +extern char *__getopt_nonoption_flags; + +static int nonoption_flags_max_len; +static int nonoption_flags_len; + +static int original_argc; +static char *const *original_argv; + +/* Make sure the environment variable bash 2.0 puts in the environment + is valid for the getopt call we must make sure that the ARGV passed + to getopt is that one passed to the process. */ +static void +__attribute__ ((unused)) +store_args_and_env (int argc, char *const *argv) +{ + /* XXX This is no good solution. We should rather copy the args so + that we can compare them later. But we must not use malloc(3). */ + original_argc = argc; + original_argv = argv; +} +# ifdef text_set_element +text_set_element (__libc_subinit, store_args_and_env); +# endif /* text_set_element */ + +# define SWAP_FLAGS(ch1, ch2) \ + if (nonoption_flags_len > 0) \ + { \ + char __tmp = __getopt_nonoption_flags[ch1]; \ + __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \ + __getopt_nonoption_flags[ch2] = __tmp; \ + } +#else /* !_LIBC */ +# define SWAP_FLAGS(ch1, ch2) +#endif /* _LIBC */ + +/* Exchange two adjacent subsequences of ARGV. + One subsequence is elements [first_nonopt,last_nonopt) + which contains all the non-options that have been skipped so far. + The other is elements [last_nonopt,optind), which contains all + the options processed since those non-options were skipped. + + `first_nonopt' and `last_nonopt' are relocated so that they describe + the new indices of the non-options in ARGV after they are moved. */ + +#if defined __STDC__ && __STDC__ +static void exchange (char **); +#endif + +static void +exchange (argv) + char **argv; +{ + int bottom = first_nonopt; + int middle = last_nonopt; + int top = optind; + char *tem; + + /* Exchange the shorter segment with the far end of the longer segment. + That puts the shorter segment into the right place. + It leaves the longer segment in the right place overall, + but it consists of two parts that need to be swapped next. */ + +#ifdef _LIBC + /* First make sure the handling of the `__getopt_nonoption_flags' + string can work normally. Our top argument must be in the range + of the string. */ + if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len) + { + /* We must extend the array. The user plays games with us and + presents new arguments. */ + char *new_str = malloc (top + 1); + if (new_str == NULL) + nonoption_flags_len = nonoption_flags_max_len = 0; + else + { + memset (__mempcpy (new_str, __getopt_nonoption_flags, + nonoption_flags_max_len), + '\0', top + 1 - nonoption_flags_max_len); + nonoption_flags_max_len = top + 1; + __getopt_nonoption_flags = new_str; + } + } +#endif + + while (top > middle && middle > bottom) + { + if (top - middle > middle - bottom) + { + /* Bottom segment is the short one. */ + int len = middle - bottom; + register int i; + + /* Swap it with the top part of the top segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[top - (middle - bottom) + i]; + argv[top - (middle - bottom) + i] = tem; + SWAP_FLAGS (bottom + i, top - (middle - bottom) + i); + } + /* Exclude the moved bottom segment from further swapping. */ + top -= len; + } + else + { + /* Top segment is the short one. */ + int len = top - middle; + register int i; + + /* Swap it with the bottom part of the bottom segment. */ + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[middle + i]; + argv[middle + i] = tem; + SWAP_FLAGS (bottom + i, middle + i); + } + /* Exclude the moved top segment from further swapping. */ + bottom += len; + } + } + + /* Update records for the slots the non-options now occupy. */ + + first_nonopt += (optind - last_nonopt); + last_nonopt = optind; +} + +/* Initialize the internal data when the first call is made. */ + +#if defined __STDC__ && __STDC__ +static const char *_getopt_initialize (int, char *const *, const char *); +#endif +static const char * +_getopt_initialize (argc, argv, optstring) + int argc; + char *const *argv; + const char *optstring; +{ + /* Start processing options with ARGV-element 1 (since ARGV-element 0 + is the program name); the sequence of previously skipped + non-option ARGV-elements is empty. */ + + first_nonopt = last_nonopt = optind; + + nextchar = NULL; + + posixly_correct = getenv ("POSIXLY_CORRECT"); + + /* Determine how to handle the ordering of options and nonoptions. */ + + if (optstring[0] == '-') + { + ordering = RETURN_IN_ORDER; + ++optstring; + } + else if (optstring[0] == '+') + { + ordering = REQUIRE_ORDER; + ++optstring; + } + else if (posixly_correct != NULL) + ordering = REQUIRE_ORDER; + else + ordering = PERMUTE; + +#ifdef _LIBC + if (posixly_correct == NULL + && argc == original_argc && argv == original_argv) + { + if (nonoption_flags_max_len == 0) + { + if (__getopt_nonoption_flags == NULL + || __getopt_nonoption_flags[0] == '\0') + nonoption_flags_max_len = -1; + else + { + const char *orig_str = __getopt_nonoption_flags; + int len = nonoption_flags_max_len = strlen (orig_str); + if (nonoption_flags_max_len < argc) + nonoption_flags_max_len = argc; + __getopt_nonoption_flags = + (char *) malloc (nonoption_flags_max_len); + if (__getopt_nonoption_flags == NULL) + nonoption_flags_max_len = -1; + else + memset (__mempcpy (__getopt_nonoption_flags, orig_str, len), + '\0', nonoption_flags_max_len - len); + } + } + nonoption_flags_len = nonoption_flags_max_len; + } + else + nonoption_flags_len = 0; +#endif + + return optstring; +} + +/* Scan elements of ARGV (whose length is ARGC) for option characters + given in OPTSTRING. + + If an element of ARGV starts with '-', and is not exactly "-" or "--", + then it is an option element. The characters of this element + (aside from the initial '-') are option characters. If `getopt' + is called repeatedly, it returns successively each of the option characters + from each of the option elements. + + If `getopt' finds another option character, it returns that character, + updating `optind' and `nextchar' so that the next call to `getopt' can + resume the scan with the following option character or ARGV-element. + + If there are no more option characters, `getopt' returns -1. + Then `optind' is the index in ARGV of the first ARGV-element + that is not an option. (The ARGV-elements have been permuted + so that those that are not options now come last.) + + OPTSTRING is a string containing the legitimate option characters. + If an option character is seen that is not listed in OPTSTRING, + return '?' after printing an error message. If you set `opterr' to + zero, the error message is suppressed but we still return '?'. + + If a char in OPTSTRING is followed by a colon, that means it wants an arg, + so the following text in the same ARGV-element, or the text of the following + ARGV-element, is returned in `optarg'. Two colons mean an option that + wants an optional arg; if there is text in the current ARGV-element, + it is returned in `optarg', otherwise `optarg' is set to zero. + + If OPTSTRING starts with `-' or `+', it requests different methods of + handling the non-option ARGV-elements. + See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. + + Long-named options begin with `--' instead of `-'. + Their names may be abbreviated as long as the abbreviation is unique + or is an exact match for some defined option. If they have an + argument, it follows the option name in the same ARGV-element, separated + from the option name by a `=', or else the in next ARGV-element. + When `getopt' finds a long-named option, it returns 0 if that option's + `flag' field is nonzero, the value of the option's `val' field + if the `flag' field is zero. + + The elements of ARGV aren't really const, because we permute them. + But we pretend they're const in the prototype to be compatible + with other systems. + + LONGOPTS is a vector of `struct option' terminated by an + element containing a name which is zero. + + LONGIND returns the index in LONGOPT of the long-named option found. + It is only valid when a long-named option has been found by the most + recent call. + + If LONG_ONLY is nonzero, '-' as well as '--' can introduce + long-named options. */ + +int +_getopt_internal (argc, argv, optstring, longopts, longind, long_only) + int argc; + char *const *argv; + const char *optstring; + const struct option *longopts; + int *longind; + int long_only; +{ + optarg = NULL; + + if (optind == 0 || !__getopt_initialized) + { + if (optind == 0) + optind = 1; /* Don't scan ARGV[0], the program name. */ + optstring = _getopt_initialize (argc, argv, optstring); + __getopt_initialized = 1; + } + + /* Test whether ARGV[optind] points to a non-option argument. + Either it does not have option syntax, or there is an environment flag + from the shell indicating it is not an option. The later information + is only used when the used in the GNU libc. */ +#ifdef _LIBC +# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ + || (optind < nonoption_flags_len \ + && __getopt_nonoption_flags[optind] == '1')) +#else +# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0') +#endif + + if (nextchar == NULL || *nextchar == '\0') + { + /* Advance to the next ARGV-element. */ + + /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been + moved back by the user (who may also have changed the arguments). */ + if (last_nonopt > optind) + last_nonopt = optind; + if (first_nonopt > optind) + first_nonopt = optind; + + if (ordering == PERMUTE) + { + /* If we have just processed some options following some non-options, + exchange them so that the options come first. */ + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange ((char **) argv); + else if (last_nonopt != optind) + first_nonopt = optind; + + /* Skip any additional non-options + and extend the range of non-options previously skipped. */ + + while (optind < argc && NONOPTION_P) + optind++; + last_nonopt = optind; + } + + /* The special ARGV-element `--' means premature end of options. + Skip it like a null option, + then exchange with previous non-options as if it were an option, + then skip everything else like a non-option. */ + + if (optind != argc && !strcmp (argv[optind], "--")) + { + optind++; + + if (first_nonopt != last_nonopt && last_nonopt != optind) + exchange ((char **) argv); + else if (first_nonopt == last_nonopt) + first_nonopt = optind; + last_nonopt = argc; + + optind = argc; + } + + /* If we have done all the ARGV-elements, stop the scan + and back over any non-options that we skipped and permuted. */ + + if (optind == argc) + { + /* Set the next-arg-index to point at the non-options + that we previously skipped, so the caller will digest them. */ + if (first_nonopt != last_nonopt) + optind = first_nonopt; + return -1; + } + + /* If we have come to a non-option and did not permute it, + either stop the scan or describe it to the caller and pass it by. */ + + if (NONOPTION_P) + { + if (ordering == REQUIRE_ORDER) + return -1; + optarg = argv[optind++]; + return 1; + } + + /* We have found another option-ARGV-element. + Skip the initial punctuation. */ + + nextchar = (argv[optind] + 1 + + (longopts != NULL && argv[optind][1] == '-')); + } + + /* Decode the current option-ARGV-element. */ + + /* Check whether the ARGV-element is a long option. + + If long_only and the ARGV-element has the form "-f", where f is + a valid short option, don't consider it an abbreviated form of + a long option that starts with f. Otherwise there would be no + way to give the -f short option. + + On the other hand, if there's a long option "fubar" and + the ARGV-element is "-fu", do consider that an abbreviation of + the long option, just like "--fu", and not "-f" with arg "u". + + This distinction seems to be the most useful approach. */ + + if (longopts != NULL + && (argv[optind][1] == '-' + || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) + { + char *nameend; + const struct option *p; + const struct option *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound = -1; + int option_index; + + for (nameend = nextchar; *nameend && *nameend != '='; nameend++) + /* Do nothing. */ ; + + /* Test all long options for either exact match + or abbreviated matches. */ + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!strncmp (p->name, nextchar, nameend - nextchar)) + { + if ((unsigned int) (nameend - nextchar) + == (unsigned int) strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else + /* Second or later nonexact match found. */ + ambig = 1; + } + + if (ambig && !exact) + { + if (opterr) + fprintf (stderr, _("%s: option `%s' is ambiguous\n"), + argv[0], argv[optind]); + nextchar += strlen (nextchar); + optind++; + optopt = 0; + return '?'; + } + + if (pfound != NULL) + { + option_index = indfound; + optind++; + if (*nameend) + { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if (pfound->has_arg) + optarg = nameend + 1; + else + { + if (opterr) + if (argv[optind - 1][1] == '-') + /* --option */ + fprintf (stderr, + _("%s: option `--%s' doesn't allow an argument\n"), + argv[0], pfound->name); + else + /* +option or -option */ + fprintf (stderr, + _("%s: option `%c%s' doesn't allow an argument\n"), + argv[0], argv[optind - 1][0], pfound->name); + + nextchar += strlen (nextchar); + + optopt = pfound->val; + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (optind < argc) + optarg = argv[optind++]; + else + { + if (opterr) + fprintf (stderr, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[optind - 1]); + nextchar += strlen (nextchar); + optopt = pfound->val; + return optstring[0] == ':' ? ':' : '?'; + } + } + nextchar += strlen (nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + + /* Can't find it as a long option. If this is not getopt_long_only, + or the option starts with '--' or is not a valid short + option, then it's an error. + Otherwise interpret it as a short option. */ + if (!long_only || argv[optind][1] == '-' + || my_index (optstring, *nextchar) == NULL) + { + if (opterr) + { + if (argv[optind][1] == '-') + /* --option */ + fprintf (stderr, _("%s: unrecognized option `--%s'\n"), + argv[0], nextchar); + else + /* +option or -option */ + fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), + argv[0], argv[optind][0], nextchar); + } + nextchar = (char *) ""; + optind++; + optopt = 0; + return '?'; + } + } + + /* Look at and handle the next short option-character. */ + + { + char c = *nextchar++; + char *temp = my_index (optstring, c); + + /* Increment `optind' when we start to process its last character. */ + if (*nextchar == '\0') + ++optind; + + if (temp == NULL || c == ':') + { + if (opterr) + { + if (posixly_correct) + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, _("%s: illegal option -- %c\n"), + argv[0], c); + else + fprintf (stderr, _("%s: invalid option -- %c\n"), + argv[0], c); + } + optopt = c; + return '?'; + } + /* Convenience. Treat POSIX -W foo same as long option --foo */ + if (temp[0] == 'W' && temp[1] == ';') + { + char *nameend; + const struct option *p; + const struct option *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound = 0; + int option_index; + + /* This is an option that requires an argument. */ + if (*nextchar != '\0') + { + optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + optind++; + } + else if (optind == argc) + { + if (opterr) + { + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, _("%s: option requires an argument -- %c\n"), + argv[0], c); + } + optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + return c; + } + else + /* We already incremented `optind' once; + increment it again when taking next ARGV-elt as argument. */ + optarg = argv[optind++]; + + /* optarg is now the argument, see if it's in the + table of longopts. */ + + for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++) + /* Do nothing. */ ; + + /* Test all long options for either exact match + or abbreviated matches. */ + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!strncmp (p->name, nextchar, nameend - nextchar)) + { + if ((unsigned int) (nameend - nextchar) == strlen (p->name)) + { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } + else + /* Second or later nonexact match found. */ + ambig = 1; + } + if (ambig && !exact) + { + if (opterr) + fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), + argv[0], argv[optind]); + nextchar += strlen (nextchar); + optind++; + return '?'; + } + if (pfound != NULL) + { + option_index = indfound; + if (*nameend) + { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if (pfound->has_arg) + optarg = nameend + 1; + else + { + if (opterr) + fprintf (stderr, _("\ +%s: option `-W %s' doesn't allow an argument\n"), + argv[0], pfound->name); + + nextchar += strlen (nextchar); + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (optind < argc) + optarg = argv[optind++]; + else + { + if (opterr) + fprintf (stderr, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[optind - 1]); + nextchar += strlen (nextchar); + return optstring[0] == ':' ? ':' : '?'; + } + } + nextchar += strlen (nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + nextchar = NULL; + return 'W'; /* Let the application handle it. */ + } + if (temp[1] == ':') + { + if (temp[2] == ':') + { + /* This is an option that accepts an argument optionally. */ + if (*nextchar != '\0') + { + optarg = nextchar; + optind++; + } + else + optarg = NULL; + nextchar = NULL; + } + else + { + /* This is an option that requires an argument. */ + if (*nextchar != '\0') + { + optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + optind++; + } + else if (optind == argc) + { + if (opterr) + { + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, + _("%s: option requires an argument -- %c\n"), + argv[0], c); + } + optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + } + else + /* We already incremented `optind' once; + increment it again when taking next ARGV-elt as argument. */ + optarg = argv[optind++]; + nextchar = NULL; + } + } + return c; + } +} + +int +getopt (argc, argv, optstring) + int argc; + char *const *argv; + const char *optstring; +{ + return _getopt_internal (argc, argv, optstring, + (const struct option *) 0, + (int *) 0, + 0); +} + +#endif /* Not ELIDE_CODE. */ + +#ifdef TEST + +/* Compile with -DTEST to make an executable for use in testing + the above definition of `getopt'. */ + +int +main (argc, argv) + int argc; + char **argv; +{ + int c; + int digit_optind = 0; + + while (1) + { + int this_option_optind = optind ? optind : 1; + + c = getopt (argc, argv, "abc:d:0123456789"); + if (c == -1) + break; + + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value `%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } + } + + if (optind < argc) + { + printf ("non-option ARGV-elements: "); + while (optind < argc) + printf ("%s ", argv[optind++]); + printf ("\n"); + } + + exit (0); +} + +#endif /* TEST */ diff --git a/flaim/external/w32/make/getopt.h b/flaim/external/w32/make/getopt.h new file mode 100644 index 0000000..fb30719 --- /dev/null +++ b/flaim/external/w32/make/getopt.h @@ -0,0 +1,133 @@ +/* Declarations for getopt. + Copyright (C) 1989,90,91,92,93,94,96,97 Free Software Foundation, Inc. + + NOTE: The canonical source of this file is maintained with the GNU C Library. + Bugs can be reported to bug-glibc@gnu.org. + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 2, or (at your option) any + later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + USA. */ + +#ifndef _GETOPT_H +#define _GETOPT_H 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* For communication from `getopt' to the caller. + When `getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +extern char *optarg; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `getopt'. + + On entry to `getopt', zero means this is the first call; initialize. + + When `getopt' returns -1, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +extern int optind; + +/* Callers store zero here to inhibit the error message `getopt' prints + for unrecognized options. */ + +extern int opterr; + +/* Set to an option character which was unrecognized. */ + +extern int optopt; + +/* Describe the long-named options requested by the application. + The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector + of `struct option' terminated by an element containing a name which is + zero. + + The field `has_arg' is: + no_argument (or 0) if the option does not take an argument, + required_argument (or 1) if the option requires an argument, + optional_argument (or 2) if the option takes an optional argument. + + If the field `flag' is not NULL, it points to a variable that is set + to the value given in the field `val' when the option is found, but + left unchanged if the option is not found. + + To have a long-named option do something other than set an `int' to + a compiled-in constant, such as set a value from `optarg', set the + option's `flag' field to zero and its `val' field to a nonzero + value (the equivalent single-letter option character, if there is + one). For long options that have a zero `flag' field, `getopt' + returns the contents of the `val' field. */ + +struct option +{ +#if defined (__STDC__) && __STDC__ + const char *name; +#else + char *name; +#endif + /* has_arg can't be an enum because some compilers complain about + type mismatches in all the code that assumes it is an int. */ + int has_arg; + int *flag; + int val; +}; + +/* Names for the values of the `has_arg' field of `struct option'. */ + +#define no_argument 0 +#define required_argument 1 +#define optional_argument 2 + +#if defined (__STDC__) && __STDC__ +#ifdef __GNU_LIBRARY__ +/* Many other libraries have conflicting prototypes for getopt, with + differences in the consts, in stdlib.h. To avoid compilation + errors, only prototype getopt for the GNU C library. */ +extern int getopt (int argc, char *const *argv, const char *shortopts); +#else /* not __GNU_LIBRARY__ */ +extern int getopt (); +#endif /* __GNU_LIBRARY__ */ +extern int getopt_long (int argc, char *const *argv, const char *shortopts, + const struct option *longopts, int *longind); +extern int getopt_long_only (int argc, char *const *argv, + const char *shortopts, + const struct option *longopts, int *longind); + +/* Internal only. Users should not call this directly. */ +extern int _getopt_internal (int argc, char *const *argv, + const char *shortopts, + const struct option *longopts, int *longind, + int long_only); +#else /* not __STDC__ */ +extern int getopt (); +extern int getopt_long (); +extern int getopt_long_only (); + +extern int _getopt_internal (); +#endif /* __STDC__ */ + +#ifdef __cplusplus +} +#endif + +#endif /* getopt.h */ diff --git a/flaim/external/w32/make/getopt1.c b/flaim/external/w32/make/getopt1.c new file mode 100644 index 0000000..ff25737 --- /dev/null +++ b/flaim/external/w32/make/getopt1.c @@ -0,0 +1,190 @@ +/* getopt_long and getopt_long_only entry points for GNU getopt. + Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98 + Free Software Foundation, Inc. + + NOTE: The canonical source of this file is maintained with the GNU C Library. + Bugs can be reported to bug-glibc@gnu.org. + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU General Public License as published by the + Free Software Foundation; either version 2, or (at your option) any + later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + USA. */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include "getopt.h" + +#if !defined __STDC__ || !__STDC__ +/* This is a separate conditional since some stdc systems + reject `defined (const)'. */ +#ifndef const +#define const +#endif +#endif + +#include + +/* Comment out all this code if we are using the GNU C Library, and are not + actually compiling the library itself. This code is part of the GNU C + Library, but also included in many other GNU distributions. Compiling + and linking in this code is a waste when using the GNU C library + (especially if it is a shared library). Rather than having every GNU + program understand `configure --with-gnu-libc' and omit the object files, + it is simpler to just do this in the source for each such file. */ + +#define GETOPT_INTERFACE_VERSION 2 +#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2 +#include +#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION +#define ELIDE_CODE +#endif +#endif + +#ifndef ELIDE_CODE + + +/* This needs to come after some library #include + to get __GNU_LIBRARY__ defined. */ +#ifdef __GNU_LIBRARY__ +#include +#endif + +#ifndef NULL +#define NULL 0 +#endif + +int +getopt_long (argc, argv, options, long_options, opt_index) + int argc; + char *const *argv; + const char *options; + const struct option *long_options; + int *opt_index; +{ + return _getopt_internal (argc, argv, options, long_options, opt_index, 0); +} + +/* Like getopt_long, but '-' as well as '--' can indicate a long option. + If an option that starts with '-' (not '--') doesn't match a long option, + but does match a short option, it is parsed as a short option + instead. */ + +int +getopt_long_only (argc, argv, options, long_options, opt_index) + int argc; + char *const *argv; + const char *options; + const struct option *long_options; + int *opt_index; +{ + return _getopt_internal (argc, argv, options, long_options, opt_index, 1); +} + + +#endif /* Not ELIDE_CODE. */ + +#ifdef TEST + +#include + +int +main (argc, argv) + int argc; + char **argv; +{ + int c; + int digit_optind = 0; + + while (1) + { + int this_option_optind = optind ? optind : 1; + int option_index = 0; + static struct option long_options[] = + { + {"add", 1, 0, 0}, + {"append", 0, 0, 0}, + {"delete", 1, 0, 0}, + {"verbose", 0, 0, 0}, + {"create", 0, 0, 0}, + {"file", 1, 0, 0}, + {0, 0, 0, 0} + }; + + c = getopt_long (argc, argv, "abc:d:0123456789", + long_options, &option_index); + if (c == -1) + break; + + switch (c) + { + case 0: + printf ("option %s", long_options[option_index].name); + if (optarg) + printf (" with arg %s", optarg); + printf ("\n"); + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (digit_optind != 0 && digit_optind != this_option_optind) + printf ("digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + printf ("option %c\n", c); + break; + + case 'a': + printf ("option a\n"); + break; + + case 'b': + printf ("option b\n"); + break; + + case 'c': + printf ("option c with value `%s'\n", optarg); + break; + + case 'd': + printf ("option d with value `%s'\n", optarg); + break; + + case '?': + break; + + default: + printf ("?? getopt returned character code 0%o ??\n", c); + } + } + + if (optind < argc) + { + printf ("non-option ARGV-elements: "); + while (optind < argc) + printf ("%s ", argv[optind++]); + printf ("\n"); + } + + exit (0); +} + +#endif /* TEST */ diff --git a/flaim/external/w32/make/gettext.h b/flaim/external/w32/make/gettext.h new file mode 100644 index 0000000..ea67f30 --- /dev/null +++ b/flaim/external/w32/make/gettext.h @@ -0,0 +1,59 @@ +/* Convenience header for conditional use of GNU . + Copyright (C) 1995-1998, 2000-2002 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU Library General Public License as published + by the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + USA. */ + +#ifndef _LIBGETTEXT_H +#define _LIBGETTEXT_H 1 + +/* NLS can be disabled through the configure --disable-nls option. */ +#if ENABLE_NLS + +/* Get declarations of GNU message catalog functions. */ +# include + +#else + +/* Disabled NLS. + The casts to 'const char *' serve the purpose of producing warnings + for invalid uses of the value returned from these functions. + On pre-ANSI systems without 'const', the config.h file is supposed to + contain "#define const". */ +# define gettext(Msgid) ((const char *) (Msgid)) +# define dgettext(Domainname, Msgid) ((const char *) (Msgid)) +# define dcgettext(Domainname, Msgid, Category) ((const char *) (Msgid)) +# define ngettext(Msgid1, Msgid2, N) \ + ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2)) +# define dngettext(Domainname, Msgid1, Msgid2, N) \ + ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2)) +# define dcngettext(Domainname, Msgid1, Msgid2, N, Category) \ + ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2)) +# define textdomain(Domainname) ((const char *) (Domainname)) +# define bindtextdomain(Domainname, Dirname) ((const char *) (Dirname)) +# define bind_textdomain_codeset(Domainname, Codeset) ((const char *) (Codeset)) + +#endif + +/* A pseudo function call that serves as a marker for the automated + extraction of messages, but does not call gettext(). The run-time + translation is done at a different place in the code. + The argument, String, should be a literal string. Concatenated strings + and other string expressions won't work. + The macro's expansion is not parenthesized, so that it is suitable as + initializer for static 'char[]' or 'const char[]' variables. */ +#define gettext_noop(String) String + +#endif /* _LIBGETTEXT_H */ diff --git a/flaim/external/w32/make/glob.c b/flaim/external/w32/make/glob.c new file mode 100644 index 0000000..bbbe22b --- /dev/null +++ b/flaim/external/w32/make/glob.c @@ -0,0 +1,1425 @@ +/* Copyright (C) 1991,92,93,94,95,96,97,98,99 Free Software Foundation, Inc. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* AIX requires this to be the first thing in the file. */ +#if defined _AIX && !defined __GNUC__ + #pragma alloca +#endif + +#ifdef HAVE_CONFIG_H +# include +#endif + +/* Enable GNU extensions in glob.h. */ +#ifndef _GNU_SOURCE +# define _GNU_SOURCE 1 +#endif + +#include +#include +#include + +/* Outcomment the following line for production quality code. */ +/* #define NDEBUG 1 */ +#include + +#include /* Needed on stupid SunOS for assert. */ + + +/* Comment out all this code if we are using the GNU C Library, and are not + actually compiling the library itself. This code is part of the GNU C + Library, but also included in many other GNU distributions. Compiling + and linking in this code is a waste when using the GNU C library + (especially if it is a shared library). Rather than having every GNU + program understand `configure --with-gnu-libc' and omit the object files, + it is simpler to just do this in the source for each such file. */ + +#define GLOB_INTERFACE_VERSION 1 +#if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1 +# include +# if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION +# define ELIDE_CODE +# endif +#endif + +#ifndef ELIDE_CODE + +#if defined STDC_HEADERS || defined __GNU_LIBRARY__ +# include +#endif + +#if defined HAVE_UNISTD_H || defined _LIBC +# include +# ifndef POSIX +# ifdef _POSIX_VERSION +# define POSIX +# endif +# endif +#endif + +#if !defined _AMIGA && !defined VMS && !defined WINDOWS32 +# include +#endif + +#if !defined __GNU_LIBRARY__ && !defined STDC_HEADERS +extern int errno; +#endif +#ifndef __set_errno +# define __set_errno(val) errno = (val) +#endif + +#ifndef NULL +# define NULL 0 +#endif + + +#if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__ +# include +# define NAMLEN(dirent) strlen((dirent)->d_name) +#else +# define dirent direct +# define NAMLEN(dirent) (dirent)->d_namlen +# ifdef HAVE_SYS_NDIR_H +# include +# endif +# ifdef HAVE_SYS_DIR_H +# include +# endif +# ifdef HAVE_NDIR_H +# include +# endif +# ifdef HAVE_VMSDIR_H +# include "vmsdir.h" +# endif /* HAVE_VMSDIR_H */ +#endif + + +/* In GNU systems, defines this macro for us. */ +#ifdef _D_NAMLEN +# undef NAMLEN +# define NAMLEN(d) _D_NAMLEN(d) +#endif + +/* When used in the GNU libc the symbol _DIRENT_HAVE_D_TYPE is available + if the `d_type' member for `struct dirent' is available. */ +#ifdef _DIRENT_HAVE_D_TYPE +# define HAVE_D_TYPE 1 +#endif + + +#if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__ +/* Posix does not require that the d_ino field be present, and some + systems do not provide it. */ +# define REAL_DIR_ENTRY(dp) 1 +#else +# define REAL_DIR_ENTRY(dp) (dp->d_ino != 0) +#endif /* POSIX */ + +#if defined STDC_HEADERS || defined __GNU_LIBRARY__ +# include +# include +# define ANSI_STRING +#else /* No standard headers. */ + +extern char *getenv (); + +# ifdef HAVE_STRING_H +# include +# define ANSI_STRING +# else +# include +# endif +# ifdef HAVE_MEMORY_H +# include +# endif + +extern void qsort (); +extern void abort (), exit (); + +#endif /* Standard headers. */ + +#ifndef ANSI_STRING + +# ifndef bzero +extern void bzero (); +# endif +# ifndef bcopy +extern void bcopy (); +# endif + +# define memcpy(d, s, n) bcopy ((s), (d), (n)) +# define strrchr rindex +/* memset is only used for zero here, but let's be paranoid. */ +# define memset(s, better_be_zero, n) \ + ((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0))) +#endif /* Not ANSI_STRING. */ + +#if !defined HAVE_STRCOLL && !defined _LIBC +# define strcoll strcmp +#endif + +#if !defined HAVE_MEMPCPY && __GLIBC__ - 0 == 2 && __GLIBC_MINOR__ >= 1 +# define HAVE_MEMPCPY 1 +# undef mempcpy +# define mempcpy(Dest, Src, Len) __mempcpy (Dest, Src, Len) +#endif + +#ifndef __GNU_LIBRARY__ +# ifdef __GNUC__ +__inline +# endif +# ifndef __SASC +# ifdef WINDOWS32 +static void * +# else +static char * +# endif +my_realloc (p, n) + char *p; + unsigned int n; +{ + /* These casts are the for sake of the broken Ultrix compiler, + which warns of illegal pointer combinations otherwise. */ + if (p == NULL) + return (char *) malloc (n); + return (char *) realloc (p, n); +} +# define realloc my_realloc +# endif /* __SASC */ +#endif /* __GNU_LIBRARY__ */ + + +#if !defined __alloca && !defined __GNU_LIBRARY__ + +# ifdef __GNUC__ +# undef alloca +# define alloca(n) __builtin_alloca (n) +# else /* Not GCC. */ +# ifdef HAVE_ALLOCA_H +# include +# else /* Not HAVE_ALLOCA_H. */ +# ifndef _AIX +# ifdef WINDOWS32 +# include +# else +extern char *alloca (); +# endif /* WINDOWS32 */ +# endif /* Not _AIX. */ +# endif /* sparc or HAVE_ALLOCA_H. */ +# endif /* GCC. */ + +# define __alloca alloca + +#endif + +#ifndef __GNU_LIBRARY__ +# define __stat stat +# ifdef STAT_MACROS_BROKEN +# undef S_ISDIR +# endif +# ifndef S_ISDIR +# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) +# endif +#endif + +#ifdef _LIBC +# undef strdup +# define strdup(str) __strdup (str) +# define sysconf(id) __sysconf (id) +# define closedir(dir) __closedir (dir) +# define opendir(name) __opendir (name) +# define readdir(str) __readdir (str) +# define getpwnam_r(name, bufp, buf, len, res) \ + __getpwnam_r (name, bufp, buf, len, res) +# ifndef __stat +# define __stat(fname, buf) __xstat (_STAT_VER, fname, buf) +# endif +#endif + +#if !(defined STDC_HEADERS || defined __GNU_LIBRARY__) +# undef size_t +# define size_t unsigned int +#endif + +/* Some system header files erroneously define these. + We want our own definitions from to take precedence. */ +#ifndef __GNU_LIBRARY__ +# undef FNM_PATHNAME +# undef FNM_NOESCAPE +# undef FNM_PERIOD +#endif +#include + +/* Some system header files erroneously define these. + We want our own definitions from to take precedence. */ +#ifndef __GNU_LIBRARY__ +# undef GLOB_ERR +# undef GLOB_MARK +# undef GLOB_NOSORT +# undef GLOB_DOOFFS +# undef GLOB_NOCHECK +# undef GLOB_APPEND +# undef GLOB_NOESCAPE +# undef GLOB_PERIOD +#endif +#include + +#ifdef HAVE_GETLOGIN_R +extern int getlogin_r __P ((char *, size_t)); +#else +extern char *getlogin __P ((void)); +#endif + +static +#if __GNUC__ - 0 >= 2 +inline +#endif +const char *next_brace_sub __P ((const char *begin)); +static int glob_in_dir __P ((const char *pattern, const char *directory, + int flags, + int (*errfunc) (const char *, int), + glob_t *pglob)); +static int prefix_array __P ((const char *prefix, char **array, size_t n)); +static int collated_compare __P ((const __ptr_t, const __ptr_t)); + +#ifdef VMS +/* these compilers like prototypes */ +#if !defined _LIBC || !defined NO_GLOB_PATTERN_P +int __glob_pattern_p (const char *pattern, int quote); +#endif +#endif + +/* Find the end of the sub-pattern in a brace expression. We define + this as an inline function if the compiler permits. */ +static +#if __GNUC__ - 0 >= 2 +inline +#endif +const char * +next_brace_sub (begin) + const char *begin; +{ + unsigned int depth = 0; + const char *cp = begin; + + while (1) + { + if (depth == 0) + { + if (*cp != ',' && *cp != '}' && *cp != '\0') + { + if (*cp == '{') + ++depth; + ++cp; + continue; + } + } + else + { + while (*cp != '\0' && (*cp != '}' || depth > 0)) + { + if (*cp == '}') + --depth; + ++cp; + } + if (*cp == '\0') + /* An incorrectly terminated brace expression. */ + return NULL; + + continue; + } + break; + } + + return cp; +} + +/* Do glob searching for PATTERN, placing results in PGLOB. + The bits defined above may be set in FLAGS. + If a directory cannot be opened or read and ERRFUNC is not nil, + it is called with the pathname that caused the error, and the + `errno' value from the failing call; if it returns non-zero + `glob' returns GLOB_ABORTED; if it returns zero, the error is ignored. + If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned. + Otherwise, `glob' returns zero. */ +int +glob (pattern, flags, errfunc, pglob) + const char *pattern; + int flags; + int (*errfunc) __P ((const char *, int)); + glob_t *pglob; +{ + const char *filename; + const char *dirname; + size_t dirlen; + int status; + int oldcount; + + if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0) + { + __set_errno (EINVAL); + return -1; + } + + if (flags & GLOB_BRACE) + { + const char *begin = strchr (pattern, '{'); + if (begin != NULL) + { + /* Allocate working buffer large enough for our work. Note that + we have at least an opening and closing brace. */ + int firstc; + char *alt_start; + const char *p; + const char *next; + const char *rest; + size_t rest_len; +#ifdef __GNUC__ + char onealt[strlen (pattern) - 1]; +#else + char *onealt = (char *) malloc (strlen (pattern) - 1); + if (onealt == NULL) + { + if (!(flags & GLOB_APPEND)) + globfree (pglob); + return GLOB_NOSPACE; + } +#endif + + /* We know the prefix for all sub-patterns. */ +#ifdef HAVE_MEMPCPY + alt_start = mempcpy (onealt, pattern, begin - pattern); +#else + memcpy (onealt, pattern, begin - pattern); + alt_start = &onealt[begin - pattern]; +#endif + + /* Find the first sub-pattern and at the same time find the + rest after the closing brace. */ + next = next_brace_sub (begin + 1); + if (next == NULL) + { + /* It is an illegal expression. */ +#ifndef __GNUC__ + free (onealt); +#endif + return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob); + } + + /* Now find the end of the whole brace expression. */ + rest = next; + while (*rest != '}') + { + rest = next_brace_sub (rest + 1); + if (rest == NULL) + { + /* It is an illegal expression. */ +#ifndef __GNUC__ + free (onealt); +#endif + return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob); + } + } + /* Please note that we now can be sure the brace expression + is well-formed. */ + rest_len = strlen (++rest) + 1; + + /* We have a brace expression. BEGIN points to the opening {, + NEXT points past the terminator of the first element, and END + points past the final }. We will accumulate result names from + recursive runs for each brace alternative in the buffer using + GLOB_APPEND. */ + + if (!(flags & GLOB_APPEND)) + { + /* This call is to set a new vector, so clear out the + vector so we can append to it. */ + pglob->gl_pathc = 0; + pglob->gl_pathv = NULL; + } + firstc = pglob->gl_pathc; + + p = begin + 1; + while (1) + { + int result; + + /* Construct the new glob expression. */ +#ifdef HAVE_MEMPCPY + mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len); +#else + memcpy (alt_start, p, next - p); + memcpy (&alt_start[next - p], rest, rest_len); +#endif + + result = glob (onealt, + ((flags & ~(GLOB_NOCHECK|GLOB_NOMAGIC)) + | GLOB_APPEND), errfunc, pglob); + + /* If we got an error, return it. */ + if (result && result != GLOB_NOMATCH) + { +#ifndef __GNUC__ + free (onealt); +#endif + if (!(flags & GLOB_APPEND)) + globfree (pglob); + return result; + } + + if (*next == '}') + /* We saw the last entry. */ + break; + + p = next + 1; + next = next_brace_sub (p); + assert (next != NULL); + } + +#ifndef __GNUC__ + free (onealt); +#endif + + if (pglob->gl_pathc != firstc) + /* We found some entries. */ + return 0; + else if (!(flags & (GLOB_NOCHECK|GLOB_NOMAGIC))) + return GLOB_NOMATCH; + } + } + + /* Find the filename. */ + filename = strrchr (pattern, '/'); +#if defined __MSDOS__ || defined WINDOWS32 + /* The case of "d:pattern". Since `:' is not allowed in + file names, we can safely assume that wherever it + happens in pattern, it signals the filename part. This + is so we could some day support patterns like "[a-z]:foo". */ + if (filename == NULL) + filename = strchr (pattern, ':'); +#endif /* __MSDOS__ || WINDOWS32 */ + if (filename == NULL) + { + /* This can mean two things: a simple name or "~name". The later + case is nothing but a notation for a directory. */ + if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && pattern[0] == '~') + { + dirname = pattern; + dirlen = strlen (pattern); + + /* Set FILENAME to NULL as a special flag. This is ugly but + other solutions would require much more code. We test for + this special case below. */ + filename = NULL; + } + else + { + filename = pattern; +#ifdef _AMIGA + dirname = ""; +#else + dirname = "."; +#endif + dirlen = 0; + } + } + else if (filename == pattern) + { + /* "/pattern". */ + dirname = "/"; + dirlen = 1; + ++filename; + } + else + { + char *newp; + dirlen = filename - pattern; +#if defined __MSDOS__ || defined WINDOWS32 + if (*filename == ':' + || (filename > pattern + 1 && filename[-1] == ':')) + { + char *drive_spec; + + ++dirlen; + drive_spec = (char *) __alloca (dirlen + 1); +#ifdef HAVE_MEMPCPY + *((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0'; +#else + memcpy (drive_spec, pattern, dirlen); + drive_spec[dirlen] = '\0'; +#endif + /* For now, disallow wildcards in the drive spec, to + prevent infinite recursion in glob. */ + if (__glob_pattern_p (drive_spec, !(flags & GLOB_NOESCAPE))) + return GLOB_NOMATCH; + /* If this is "d:pattern", we need to copy `:' to DIRNAME + as well. If it's "d:/pattern", don't remove the slash + from "d:/", since "d:" and "d:/" are not the same.*/ + } +#endif + newp = (char *) __alloca (dirlen + 1); +#ifdef HAVE_MEMPCPY + *((char *) mempcpy (newp, pattern, dirlen)) = '\0'; +#else + memcpy (newp, pattern, dirlen); + newp[dirlen] = '\0'; +#endif + dirname = newp; + ++filename; + + if (filename[0] == '\0' +#if defined __MSDOS__ || defined WINDOWS32 + && dirname[dirlen - 1] != ':' + && (dirlen < 3 || dirname[dirlen - 2] != ':' + || dirname[dirlen - 1] != '/') +#endif + && dirlen > 1) + /* "pattern/". Expand "pattern", appending slashes. */ + { + int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob); + if (val == 0) + pglob->gl_flags = ((pglob->gl_flags & ~GLOB_MARK) + | (flags & GLOB_MARK)); + return val; + } + } + + if (!(flags & GLOB_APPEND)) + { + pglob->gl_pathc = 0; + pglob->gl_pathv = NULL; + } + + oldcount = pglob->gl_pathc; + +#ifndef VMS + if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && dirname[0] == '~') + { + if (dirname[1] == '\0' || dirname[1] == '/') + { + /* Look up home directory. */ +#ifdef VMS +/* This isn't obvious, RTLs of DECC and VAXC know about "HOME" */ + const char *home_dir = getenv ("SYS$LOGIN"); +#else + const char *home_dir = getenv ("HOME"); +#endif +# ifdef _AMIGA + if (home_dir == NULL || home_dir[0] == '\0') + home_dir = "SYS:"; +# else +# ifdef WINDOWS32 + if (home_dir == NULL || home_dir[0] == '\0') + home_dir = "c:/users/default"; /* poor default */ +# else +# ifdef VMS +/* Again, this isn't obvious, if "HOME" isn't known "SYS$LOGIN" should be set */ + if (home_dir == NULL || home_dir[0] == '\0') + home_dir = "SYS$DISK:[]"; +# else + if (home_dir == NULL || home_dir[0] == '\0') + { + int success; + char *name; +# if defined HAVE_GETLOGIN_R || defined _LIBC + size_t buflen = sysconf (_SC_LOGIN_NAME_MAX) + 1; + + if (buflen == 0) + /* `sysconf' does not support _SC_LOGIN_NAME_MAX. Try + a moderate value. */ + buflen = 20; + name = (char *) __alloca (buflen); + + success = getlogin_r (name, buflen) >= 0; +# else + success = (name = getlogin ()) != NULL; +# endif + if (success) + { + struct passwd *p; +# if defined HAVE_GETPWNAM_R || defined _LIBC + size_t pwbuflen = sysconf (_SC_GETPW_R_SIZE_MAX); + char *pwtmpbuf; + struct passwd pwbuf; + int save = errno; + + if (pwbuflen == -1) + /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX. + Try a moderate value. */ + pwbuflen = 1024; + pwtmpbuf = (char *) __alloca (pwbuflen); + + while (getpwnam_r (name, &pwbuf, pwtmpbuf, pwbuflen, &p) + != 0) + { + if (errno != ERANGE) + { + p = NULL; + break; + } + pwbuflen *= 2; + pwtmpbuf = (char *) __alloca (pwbuflen); + __set_errno (save); + } +# else + p = getpwnam (name); +# endif + if (p != NULL) + home_dir = p->pw_dir; + } + } + if (home_dir == NULL || home_dir[0] == '\0') + { + if (flags & GLOB_TILDE_CHECK) + return GLOB_NOMATCH; + else + home_dir = "~"; /* No luck. */ + } +# endif /* VMS */ +# endif /* WINDOWS32 */ +# endif + /* Now construct the full directory. */ + if (dirname[1] == '\0') + dirname = home_dir; + else + { + char *newp; + size_t home_len = strlen (home_dir); + newp = (char *) __alloca (home_len + dirlen); +# ifdef HAVE_MEMPCPY + mempcpy (mempcpy (newp, home_dir, home_len), + &dirname[1], dirlen); +# else + memcpy (newp, home_dir, home_len); + memcpy (&newp[home_len], &dirname[1], dirlen); +# endif + dirname = newp; + } + } +# if !defined _AMIGA && !defined WINDOWS32 && !defined VMS + else + { + char *end_name = strchr (dirname, '/'); + const char *user_name; + const char *home_dir; + + if (end_name == NULL) + user_name = dirname + 1; + else + { + char *newp; + newp = (char *) __alloca (end_name - dirname); +# ifdef HAVE_MEMPCPY + *((char *) mempcpy (newp, dirname + 1, end_name - dirname)) + = '\0'; +# else + memcpy (newp, dirname + 1, end_name - dirname); + newp[end_name - dirname - 1] = '\0'; +# endif + user_name = newp; + } + + /* Look up specific user's home directory. */ + { + struct passwd *p; +# if defined HAVE_GETPWNAM_R || defined _LIBC + size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX); + char *pwtmpbuf; + struct passwd pwbuf; + int save = errno; + + if (buflen == -1) + /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX. Try a + moderate value. */ + buflen = 1024; + pwtmpbuf = (char *) __alloca (buflen); + + while (getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) != 0) + { + if (errno != ERANGE) + { + p = NULL; + break; + } + buflen *= 2; + pwtmpbuf = __alloca (buflen); + __set_errno (save); + } +# else + p = getpwnam (user_name); +# endif + if (p != NULL) + home_dir = p->pw_dir; + else + home_dir = NULL; + } + /* If we found a home directory use this. */ + if (home_dir != NULL) + { + char *newp; + size_t home_len = strlen (home_dir); + size_t rest_len = end_name == NULL ? 0 : strlen (end_name); + newp = (char *) __alloca (home_len + rest_len + 1); +# ifdef HAVE_MEMPCPY + *((char *) mempcpy (mempcpy (newp, home_dir, home_len), + end_name, rest_len)) = '\0'; +# else + memcpy (newp, home_dir, home_len); + memcpy (&newp[home_len], end_name, rest_len); + newp[home_len + rest_len] = '\0'; +# endif + dirname = newp; + } + else + if (flags & GLOB_TILDE_CHECK) + /* We have to regard it as an error if we cannot find the + home directory. */ + return GLOB_NOMATCH; + } +# endif /* Not Amiga && not WINDOWS32 && not VMS. */ + } +#endif /* Not VMS. */ + + /* Now test whether we looked for "~" or "~NAME". In this case we + can give the answer now. */ + if (filename == NULL) + { + struct stat st; + + /* Return the directory if we don't check for error or if it exists. */ + if ((flags & GLOB_NOCHECK) + || (((flags & GLOB_ALTDIRFUNC) + ? (*pglob->gl_stat) (dirname, &st) + : __stat (dirname, &st)) == 0 + && S_ISDIR (st.st_mode))) + { + pglob->gl_pathv + = (char **) realloc (pglob->gl_pathv, + (pglob->gl_pathc + + ((flags & GLOB_DOOFFS) ? + pglob->gl_offs : 0) + + 1 + 1) * + sizeof (char *)); + if (pglob->gl_pathv == NULL) + return GLOB_NOSPACE; + + if (flags & GLOB_DOOFFS) + while (pglob->gl_pathc < pglob->gl_offs) + pglob->gl_pathv[pglob->gl_pathc++] = NULL; + +#if defined HAVE_STRDUP || defined _LIBC + pglob->gl_pathv[pglob->gl_pathc] = strdup (dirname); +#else + { + size_t len = strlen (dirname) + 1; + char *dircopy = malloc (len); + if (dircopy != NULL) + pglob->gl_pathv[pglob->gl_pathc] = memcpy (dircopy, dirname, + len); + } +#endif + if (pglob->gl_pathv[pglob->gl_pathc] == NULL) + { + free (pglob->gl_pathv); + return GLOB_NOSPACE; + } + pglob->gl_pathv[++pglob->gl_pathc] = NULL; + pglob->gl_flags = flags; + + return 0; + } + + /* Not found. */ + return GLOB_NOMATCH; + } + + if (__glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE))) + { + /* The directory name contains metacharacters, so we + have to glob for the directory, and then glob for + the pattern in each directory found. */ + glob_t dirs; + register int i; + + status = glob (dirname, + ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE)) + | GLOB_NOSORT | GLOB_ONLYDIR), + errfunc, &dirs); + if (status != 0) + return status; + + /* We have successfully globbed the preceding directory name. + For each name we found, call glob_in_dir on it and FILENAME, + appending the results to PGLOB. */ + for (i = 0; i < dirs.gl_pathc; ++i) + { + int old_pathc; + +#ifdef SHELL + { + /* Make globbing interruptible in the bash shell. */ + extern int interrupt_state; + + if (interrupt_state) + { + globfree (&dirs); + globfree (&files); + return GLOB_ABORTED; + } + } +#endif /* SHELL. */ + + old_pathc = pglob->gl_pathc; + status = glob_in_dir (filename, dirs.gl_pathv[i], + ((flags | GLOB_APPEND) + & ~(GLOB_NOCHECK | GLOB_ERR)), + errfunc, pglob); + if (status == GLOB_NOMATCH) + /* No matches in this directory. Try the next. */ + continue; + + if (status != 0) + { + globfree (&dirs); + globfree (pglob); + return status; + } + + /* Stick the directory on the front of each name. */ + if (prefix_array (dirs.gl_pathv[i], + &pglob->gl_pathv[old_pathc], + pglob->gl_pathc - old_pathc)) + { + globfree (&dirs); + globfree (pglob); + return GLOB_NOSPACE; + } + } + + flags |= GLOB_MAGCHAR; + + /* We have ignored the GLOB_NOCHECK flag in the `glob_in_dir' calls. + But if we have not found any matching entry and thie GLOB_NOCHECK + flag was set we must return the list consisting of the disrectory + names followed by the filename. */ + if (pglob->gl_pathc == oldcount) + { + /* No matches. */ + if (flags & GLOB_NOCHECK) + { + size_t filename_len = strlen (filename) + 1; + char **new_pathv; + struct stat st; + + /* This is an pessimistic guess about the size. */ + pglob->gl_pathv + = (char **) realloc (pglob->gl_pathv, + (pglob->gl_pathc + + ((flags & GLOB_DOOFFS) ? + pglob->gl_offs : 0) + + dirs.gl_pathc + 1) * + sizeof (char *)); + if (pglob->gl_pathv == NULL) + { + globfree (&dirs); + return GLOB_NOSPACE; + } + + if (flags & GLOB_DOOFFS) + while (pglob->gl_pathc < pglob->gl_offs) + pglob->gl_pathv[pglob->gl_pathc++] = NULL; + + for (i = 0; i < dirs.gl_pathc; ++i) + { + const char *dir = dirs.gl_pathv[i]; + size_t dir_len = strlen (dir); + + /* First check whether this really is a directory. */ + if (((flags & GLOB_ALTDIRFUNC) + ? (*pglob->gl_stat) (dir, &st) : __stat (dir, &st)) != 0 + || !S_ISDIR (st.st_mode)) + /* No directory, ignore this entry. */ + continue; + + pglob->gl_pathv[pglob->gl_pathc] = malloc (dir_len + 1 + + filename_len); + if (pglob->gl_pathv[pglob->gl_pathc] == NULL) + { + globfree (&dirs); + globfree (pglob); + return GLOB_NOSPACE; + } + +#ifdef HAVE_MEMPCPY + mempcpy (mempcpy (mempcpy (pglob->gl_pathv[pglob->gl_pathc], + dir, dir_len), + "/", 1), + filename, filename_len); +#else + memcpy (pglob->gl_pathv[pglob->gl_pathc], dir, dir_len); + pglob->gl_pathv[pglob->gl_pathc][dir_len] = '/'; + memcpy (&pglob->gl_pathv[pglob->gl_pathc][dir_len + 1], + filename, filename_len); +#endif + ++pglob->gl_pathc; + } + + pglob->gl_pathv[pglob->gl_pathc] = NULL; + pglob->gl_flags = flags; + + /* Now we know how large the gl_pathv vector must be. */ + new_pathv = (char **) realloc (pglob->gl_pathv, + ((pglob->gl_pathc + 1) + * sizeof (char *))); + if (new_pathv != NULL) + pglob->gl_pathv = new_pathv; + } + else + return GLOB_NOMATCH; + } + + globfree (&dirs); + } + else + { + status = glob_in_dir (filename, dirname, flags, errfunc, pglob); + if (status != 0) + return status; + + if (dirlen > 0) + { + /* Stick the directory on the front of each name. */ + int ignore = oldcount; + + if ((flags & GLOB_DOOFFS) && ignore < pglob->gl_offs) + ignore = pglob->gl_offs; + + if (prefix_array (dirname, + &pglob->gl_pathv[ignore], + pglob->gl_pathc - ignore)) + { + globfree (pglob); + return GLOB_NOSPACE; + } + } + } + + if (flags & GLOB_MARK) + { + /* Append slashes to directory names. */ + int i; + struct stat st; + for (i = oldcount; i < pglob->gl_pathc; ++i) + if (((flags & GLOB_ALTDIRFUNC) + ? (*pglob->gl_stat) (pglob->gl_pathv[i], &st) + : __stat (pglob->gl_pathv[i], &st)) == 0 + && S_ISDIR (st.st_mode)) + { + size_t len = strlen (pglob->gl_pathv[i]) + 2; + char *new = realloc (pglob->gl_pathv[i], len); + if (new == NULL) + { + globfree (pglob); + return GLOB_NOSPACE; + } + strcpy (&new[len - 2], "/"); + pglob->gl_pathv[i] = new; + } + } + + if (!(flags & GLOB_NOSORT)) + { + /* Sort the vector. */ + int non_sort = oldcount; + + if ((flags & GLOB_DOOFFS) && pglob->gl_offs > oldcount) + non_sort = pglob->gl_offs; + + qsort ((__ptr_t) &pglob->gl_pathv[non_sort], + pglob->gl_pathc - non_sort, + sizeof (char *), collated_compare); + } + + return 0; +} + + +/* Free storage allocated in PGLOB by a previous `glob' call. */ +void +globfree (pglob) + register glob_t *pglob; +{ + if (pglob->gl_pathv != NULL) + { + register int i; + for (i = 0; i < pglob->gl_pathc; ++i) + if (pglob->gl_pathv[i] != NULL) + free ((__ptr_t) pglob->gl_pathv[i]); + free ((__ptr_t) pglob->gl_pathv); + } +} + + +/* Do a collated comparison of A and B. */ +static int +collated_compare (a, b) + const __ptr_t a; + const __ptr_t b; +{ + const char *const s1 = *(const char *const * const) a; + const char *const s2 = *(const char *const * const) b; + + if (s1 == s2) + return 0; + if (s1 == NULL) + return 1; + if (s2 == NULL) + return -1; + return strcoll (s1, s2); +} + + +/* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's + elements in place. Return nonzero if out of memory, zero if successful. + A slash is inserted between DIRNAME and each elt of ARRAY, + unless DIRNAME is just "/". Each old element of ARRAY is freed. */ +static int +prefix_array (dirname, array, n) + const char *dirname; + char **array; + size_t n; +{ + register size_t i; + size_t dirlen = strlen (dirname); +#if defined __MSDOS__ || defined WINDOWS32 + int sep_char = '/'; +# define DIRSEP_CHAR sep_char +#else +# define DIRSEP_CHAR '/' +#endif + + if (dirlen == 1 && dirname[0] == '/') + /* DIRNAME is just "/", so normal prepending would get us "//foo". + We want "/foo" instead, so don't prepend any chars from DIRNAME. */ + dirlen = 0; +#if defined __MSDOS__ || defined WINDOWS32 + else if (dirlen > 1) + { + if (dirname[dirlen - 1] == '/' && dirname[dirlen - 2] == ':') + /* DIRNAME is "d:/". Don't prepend the slash from DIRNAME. */ + --dirlen; + else if (dirname[dirlen - 1] == ':') + { + /* DIRNAME is "d:". Use `:' instead of `/'. */ + --dirlen; + sep_char = ':'; + } + } +#endif + + for (i = 0; i < n; ++i) + { + size_t eltlen = strlen (array[i]) + 1; + char *new = (char *) malloc (dirlen + 1 + eltlen); + if (new == NULL) + { + while (i > 0) + free ((__ptr_t) array[--i]); + return 1; + } + +#ifdef HAVE_MEMPCPY + { + char *endp = (char *) mempcpy (new, dirname, dirlen); + *endp++ = DIRSEP_CHAR; + mempcpy (endp, array[i], eltlen); + } +#else + memcpy (new, dirname, dirlen); + new[dirlen] = DIRSEP_CHAR; + memcpy (&new[dirlen + 1], array[i], eltlen); +#endif + free ((__ptr_t) array[i]); + array[i] = new; + } + + return 0; +} + + +/* We must not compile this function twice. */ +#if !defined _LIBC || !defined NO_GLOB_PATTERN_P +/* Return nonzero if PATTERN contains any metacharacters. + Metacharacters can be quoted with backslashes if QUOTE is nonzero. */ +int +__glob_pattern_p (pattern, quote) + const char *pattern; + int quote; +{ + register const char *p; + int open = 0; + + for (p = pattern; *p != '\0'; ++p) + switch (*p) + { + case '?': + case '*': + return 1; + + case '\\': + if (quote && p[1] != '\0') + ++p; + break; + + case '[': + open = 1; + break; + + case ']': + if (open) + return 1; + break; + } + + return 0; +} +# ifdef _LIBC +weak_alias (__glob_pattern_p, glob_pattern_p) +# endif +#endif + + +/* Like `glob', but PATTERN is a final pathname component, + and matches are searched for in DIRECTORY. + The GLOB_NOSORT bit in FLAGS is ignored. No sorting is ever done. + The GLOB_APPEND flag is assumed to be set (always appends). */ +static int +glob_in_dir (pattern, directory, flags, errfunc, pglob) + const char *pattern; + const char *directory; + int flags; + int (*errfunc) __P ((const char *, int)); + glob_t *pglob; +{ + __ptr_t stream = NULL; + + struct globlink + { + struct globlink *next; + char *name; + }; + struct globlink *names = NULL; + size_t nfound; + int meta; + int save; + +#ifdef VMS + if (*directory == 0) + directory = "[]"; +#endif + meta = __glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE)); + if (meta == 0) + { + if (flags & (GLOB_NOCHECK|GLOB_NOMAGIC)) + /* We need not do any tests. The PATTERN contains no meta + characters and we must not return an error therefore the + result will always contain exactly one name. */ + flags |= GLOB_NOCHECK; + else + { + /* Since we use the normal file functions we can also use stat() + to verify the file is there. */ + struct stat st; + size_t patlen = strlen (pattern); + size_t dirlen = strlen (directory); + char *fullname = (char *) __alloca (dirlen + 1 + patlen + 1); + +# ifdef HAVE_MEMPCPY + mempcpy (mempcpy (mempcpy (fullname, directory, dirlen), + "/", 1), + pattern, patlen + 1); +# else + memcpy (fullname, directory, dirlen); + fullname[dirlen] = '/'; + memcpy (&fullname[dirlen + 1], pattern, patlen + 1); +# endif + if (((flags & GLOB_ALTDIRFUNC) + ? (*pglob->gl_stat) (fullname, &st) + : __stat (fullname, &st)) == 0) + /* We found this file to be existing. Now tell the rest + of the function to copy this name into the result. */ + flags |= GLOB_NOCHECK; + } + + nfound = 0; + } + else + { + if (pattern[0] == '\0') + { + /* This is a special case for matching directories like in + "*a/". */ + names = (struct globlink *) __alloca (sizeof (struct globlink)); + names->name = (char *) malloc (1); + if (names->name == NULL) + goto memory_error; + names->name[0] = '\0'; + names->next = NULL; + nfound = 1; + meta = 0; + } + else + { + stream = ((flags & GLOB_ALTDIRFUNC) + ? (*pglob->gl_opendir) (directory) + : (__ptr_t) opendir (directory)); + if (stream == NULL) + { + if (errno != ENOTDIR + && ((errfunc != NULL && (*errfunc) (directory, errno)) + || (flags & GLOB_ERR))) + return GLOB_ABORTED; + nfound = 0; + meta = 0; + } + else + { + int fnm_flags = ((!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) + | ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0) +#if defined _AMIGA || defined VMS + | FNM_CASEFOLD +#endif + ); + nfound = 0; + flags |= GLOB_MAGCHAR; + + while (1) + { + const char *name; + size_t len; + struct dirent *d = ((flags & GLOB_ALTDIRFUNC) + ? (*pglob->gl_readdir) (stream) + : readdir ((DIR *) stream)); + if (d == NULL) + break; + if (! REAL_DIR_ENTRY (d)) + continue; + +#ifdef HAVE_D_TYPE + /* If we shall match only directories use the information + provided by the dirent call if possible. */ + if ((flags & GLOB_ONLYDIR) + && d->d_type != DT_UNKNOWN && d->d_type != DT_DIR) + continue; +#endif + + name = d->d_name; + + if (fnmatch (pattern, name, fnm_flags) == 0) + { + struct globlink *new = (struct globlink *) + __alloca (sizeof (struct globlink)); + len = NAMLEN (d); + new->name = (char *) malloc (len + 1); + if (new->name == NULL) + goto memory_error; +#ifdef HAVE_MEMPCPY + *((char *) mempcpy ((__ptr_t) new->name, name, len)) + = '\0'; +#else + memcpy ((__ptr_t) new->name, name, len); + new->name[len] = '\0'; +#endif + new->next = names; + names = new; + ++nfound; + } + } + } + } + } + + if (nfound == 0 && (flags & GLOB_NOCHECK)) + { + size_t len = strlen (pattern); + nfound = 1; + names = (struct globlink *) __alloca (sizeof (struct globlink)); + names->next = NULL; + names->name = (char *) malloc (len + 1); + if (names->name == NULL) + goto memory_error; +#ifdef HAVE_MEMPCPY + *((char *) mempcpy (names->name, pattern, len)) = '\0'; +#else + memcpy (names->name, pattern, len); + names->name[len] = '\0'; +#endif + } + + if (nfound != 0) + { + pglob->gl_pathv + = (char **) realloc (pglob->gl_pathv, + (pglob->gl_pathc + + ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) + + nfound + 1) * + sizeof (char *)); + if (pglob->gl_pathv == NULL) + goto memory_error; + + if (flags & GLOB_DOOFFS) + while (pglob->gl_pathc < pglob->gl_offs) + pglob->gl_pathv[pglob->gl_pathc++] = NULL; + + for (; names != NULL; names = names->next) + pglob->gl_pathv[pglob->gl_pathc++] = names->name; + pglob->gl_pathv[pglob->gl_pathc] = NULL; + + pglob->gl_flags = flags; + } + + save = errno; + if (stream != NULL) + { + if (flags & GLOB_ALTDIRFUNC) + (*pglob->gl_closedir) (stream); + else + closedir ((DIR *) stream); + } + __set_errno (save); + + return nfound == 0 ? GLOB_NOMATCH : 0; + + memory_error: + { + int save = errno; + if (flags & GLOB_ALTDIRFUNC) + (*pglob->gl_closedir) (stream); + else + closedir ((DIR *) stream); + __set_errno (save); + } + while (names != NULL) + { + if (names->name != NULL) + free ((__ptr_t) names->name); + names = names->next; + } + return GLOB_NOSPACE; +} + +#endif /* Not ELIDE_CODE. */ diff --git a/flaim/external/w32/make/glob.h b/flaim/external/w32/make/glob.h new file mode 100644 index 0000000..9f735fe --- /dev/null +++ b/flaim/external/w32/make/glob.h @@ -0,0 +1,205 @@ +/* Copyright (C) 1991, 92, 95, 96, 97, 98 Free Software Foundation, Inc. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#ifndef _GLOB_H +#define _GLOB_H 1 + +#ifdef __cplusplus +extern "C" { +#endif + +#undef __ptr_t +#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32 +# if !defined __GLIBC__ || !defined __P +# undef __P +# undef __PMT +# define __P(protos) protos +# define __PMT(protos) protos +# if !defined __GNUC__ || __GNUC__ < 2 +# undef __const +# define __const const +# endif +# endif +# define __ptr_t void * +#else /* Not C++ or ANSI C. */ +# undef __P +# undef __PMT +# define __P(protos) () +# define __PMT(protos) () +# undef __const +# define __const +# define __ptr_t char * +#endif /* C++ or ANSI C. */ + +/* We need `size_t' for the following definitions. */ +#ifndef __size_t +# if defined __GNUC__ && __GNUC__ >= 2 +typedef __SIZE_TYPE__ __size_t; +# else +/* This is a guess. */ +/*hb + * Conflicts with DECCs aready defined type __size_t. + * Defining an own type with a name beginning with '__' is no good. + * Anyway if DECC is used and __SIZE_T is defined then __size_t is + * already defined (and I hope it's exactly the one we need here). + */ +#if !(defined __DECC && defined __SIZE_T) +typedef unsigned long int __size_t; +#endif +# endif +#else +/* The GNU CC stddef.h version defines __size_t as empty. We need a real + definition. */ +# undef __size_t +# define __size_t size_t +#endif + +/* Bits set in the FLAGS argument to `glob'. */ +#define GLOB_ERR (1 << 0)/* Return on read errors. */ +#define GLOB_MARK (1 << 1)/* Append a slash to each name. */ +#define GLOB_NOSORT (1 << 2)/* Don't sort the names. */ +#define GLOB_DOOFFS (1 << 3)/* Insert PGLOB->gl_offs NULLs. */ +#define GLOB_NOCHECK (1 << 4)/* If nothing matches, return the pattern. */ +#define GLOB_APPEND (1 << 5)/* Append to results of a previous call. */ +#define GLOB_NOESCAPE (1 << 6)/* Backslashes don't quote metacharacters. */ +#define GLOB_PERIOD (1 << 7)/* Leading `.' can be matched by metachars. */ + +#if (!defined _POSIX_C_SOURCE || _POSIX_C_SOURCE < 2 || defined _BSD_SOURCE \ + || defined _GNU_SOURCE) +# define GLOB_MAGCHAR (1 << 8)/* Set in gl_flags if any metachars seen. */ +# define GLOB_ALTDIRFUNC (1 << 9)/* Use gl_opendir et al functions. */ +# define GLOB_BRACE (1 << 10)/* Expand "{a,b}" to "a" "b". */ +# define GLOB_NOMAGIC (1 << 11)/* If no magic chars, return the pattern. */ +# define GLOB_TILDE (1 << 12)/* Expand ~user and ~ to home directories. */ +# define GLOB_ONLYDIR (1 << 13)/* Match only directories. */ +# define GLOB_TILDE_CHECK (1 << 14)/* Like GLOB_TILDE but return an error + if the user name is not available. */ +# define __GLOB_FLAGS (GLOB_ERR|GLOB_MARK|GLOB_NOSORT|GLOB_DOOFFS| \ + GLOB_NOESCAPE|GLOB_NOCHECK|GLOB_APPEND| \ + GLOB_PERIOD|GLOB_ALTDIRFUNC|GLOB_BRACE| \ + GLOB_NOMAGIC|GLOB_TILDE|GLOB_ONLYDIR|GLOB_TILDE_CHECK) +#else +# define __GLOB_FLAGS (GLOB_ERR|GLOB_MARK|GLOB_NOSORT|GLOB_DOOFFS| \ + GLOB_NOESCAPE|GLOB_NOCHECK|GLOB_APPEND| \ + GLOB_PERIOD) +#endif + +/* Error returns from `glob'. */ +#define GLOB_NOSPACE 1 /* Ran out of memory. */ +#define GLOB_ABORTED 2 /* Read error. */ +#define GLOB_NOMATCH 3 /* No matches found. */ +#define GLOB_NOSYS 4 /* Not implemented. */ +#ifdef _GNU_SOURCE +/* Previous versions of this file defined GLOB_ABEND instead of + GLOB_ABORTED. Provide a compatibility definition here. */ +# define GLOB_ABEND GLOB_ABORTED +#endif + +/* Structure describing a globbing run. */ +#if !defined _AMIGA && !defined VMS /* Buggy compiler. */ +struct stat; +#endif +typedef struct + { + __size_t gl_pathc; /* Count of paths matched by the pattern. */ + char **gl_pathv; /* List of matched pathnames. */ + __size_t gl_offs; /* Slots to reserve in `gl_pathv'. */ + int gl_flags; /* Set to FLAGS, maybe | GLOB_MAGCHAR. */ + + /* If the GLOB_ALTDIRFUNC flag is set, the following functions + are used instead of the normal file access functions. */ + void (*gl_closedir) __PMT ((void *)); + struct dirent *(*gl_readdir) __PMT ((void *)); + __ptr_t (*gl_opendir) __PMT ((__const char *)); + int (*gl_lstat) __PMT ((__const char *, struct stat *)); +#if defined(VMS) && defined(__DECC) && !defined(_POSIX_C_SOURCE) + int (*gl_stat) __PMT ((__const char *, struct stat *, ...)); +#else + int (*gl_stat) __PMT ((__const char *, struct stat *)); +#endif + } glob_t; + +#ifdef _LARGEFILE64_SOURCE +struct stat64; +typedef struct + { + __size_t gl_pathc; + char **gl_pathv; + __size_t gl_offs; + int gl_flags; + + /* If the GLOB_ALTDIRFUNC flag is set, the following functions + are used instead of the normal file access functions. */ + void (*gl_closedir) __PMT ((void *)); + struct dirent64 *(*gl_readdir) __PMT ((void *)); + __ptr_t (*gl_opendir) __PMT ((__const char *)); + int (*gl_lstat) __PMT ((__const char *, struct stat64 *)); + int (*gl_stat) __PMT ((__const char *, struct stat64 *)); + } glob64_t; +#endif + +#if _FILE_OFFSET_BITS == 64 && __GNUC__ < 2 +# define glob glob64 +# define globfree globfree64 +#else +# ifdef _LARGEFILE64_SOURCE +extern int glob64 __P ((__const char *__pattern, int __flags, + int (*__errfunc) (__const char *, int), + glob64_t *__pglob)); + +extern void globfree64 __P ((glob64_t *__pglob)); +# endif +#endif + +/* Do glob searching for PATTERN, placing results in PGLOB. + The bits defined above may be set in FLAGS. + If a directory cannot be opened or read and ERRFUNC is not nil, + it is called with the pathname that caused the error, and the + `errno' value from the failing call; if it returns non-zero + `glob' returns GLOB_ABEND; if it returns zero, the error is ignored. + If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned. + Otherwise, `glob' returns zero. */ +#if _FILE_OFFSET_BITS != 64 || __GNUC__ < 2 +extern int glob __P ((__const char *__pattern, int __flags, + int (*__errfunc) (__const char *, int), + glob_t *__pglob)); + +/* Free storage allocated in PGLOB by a previous `glob' call. */ +extern void globfree __P ((glob_t *__pglob)); +#else +extern int glob __P ((__const char *__pattern, int __flags, + int (*__errfunc) (__const char *, int), + glob_t *__pglob)) __asm__ ("glob64"); + +extern void globfree __P ((glob_t *__pglob)) __asm__ ("globfree64"); +#endif + + +#ifdef _GNU_SOURCE +/* Return nonzero if PATTERN contains any metacharacters. + Metacharacters can be quoted with backslashes if QUOTE is nonzero. + + This function is not part of the interface specified by POSIX.2 + but several programs want to use it. */ +extern int glob_pattern_p __P ((__const char *__pattern, int __quote)); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* glob.h */ diff --git a/flaim/external/w32/make/hash.c b/flaim/external/w32/make/hash.c new file mode 100644 index 0000000..9083b60 --- /dev/null +++ b/flaim/external/w32/make/hash.c @@ -0,0 +1,369 @@ +/* hash.c -- hash table maintenance + Copyright (C) 1995, 1999, 2002 Free Software Foundation, Inc. + Written by Greg McGary + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +*/ + +#include "make.h" +#include "hash.h" + +#define CALLOC(t, n) ((t *) calloc (sizeof (t), (n))) +#define MALLOC(t, n) ((t *) xmalloc (sizeof (t) * (n))) +#define REALLOC(o, t, n) ((t *) xrealloc ((o), sizeof (t) * (n))) +#define CLONE(o, t, n) ((t *) memcpy (MALLOC (t, (n)), (o), sizeof (t) * (n))) + +static void hash_rehash __P((struct hash_table* ht)); +static unsigned long round_up_2 __P((unsigned long rough)); + +/* Implement double hashing with open addressing. The table size is + always a power of two. The secondary (`increment') hash function + is forced to return an odd-value, in order to be relatively prime + to the table size. This guarantees that the increment can + potentially hit every slot in the table during collision + resolution. */ + +void *hash_deleted_item = &hash_deleted_item; + +/* Force the table size to be a power of two, possibly rounding up the + given size. */ + +void +hash_init (ht, size, hash_1, hash_2, hash_cmp) + struct hash_table* ht; + unsigned long size; + hash_func_t hash_1; + hash_func_t hash_2; + hash_cmp_func_t hash_cmp; +{ + ht->ht_size = round_up_2 (size); + ht->ht_empty_slots = ht->ht_size; + ht->ht_vec = (void**) CALLOC (struct token *, ht->ht_size); + if (ht->ht_vec == 0) + { + fprintf (stderr, _("can't allocate %ld bytes for hash table: memory exhausted"), + ht->ht_size * sizeof(struct token *)); + exit (1); + } + + ht->ht_capacity = ht->ht_size - (ht->ht_size / 16); /* 93.75% loading factor */ + ht->ht_fill = 0; + ht->ht_collisions = 0; + ht->ht_lookups = 0; + ht->ht_rehashes = 0; + ht->ht_hash_1 = hash_1; + ht->ht_hash_2 = hash_2; + ht->ht_compare = hash_cmp; +} + +/* Load an array of items into `ht'. */ + +void +hash_load (ht, item_table, cardinality, size) + struct hash_table* ht; + void *item_table; + unsigned long cardinality; + unsigned long size; +{ + char *items = (char *) item_table; + while (cardinality--) + { + hash_insert (ht, items); + items += size; + } +} + +/* Returns the address of the table slot matching `key'. If `key' is + not found, return the address of an empty slot suitable for + inserting `key'. The caller is responsible for incrementing + ht_fill on insertion. */ + +void ** +hash_find_slot (ht, key) + struct hash_table* ht; + void const *key; +{ + void **slot; + void **deleted_slot = 0; + unsigned int hash_2 = 0; + unsigned int hash_1 = (*ht->ht_hash_1) (key); + + ht->ht_lookups++; + for (;;) + { + hash_1 &= (ht->ht_size - 1); + slot = &ht->ht_vec[hash_1]; + + if (*slot == 0) + return (deleted_slot ? deleted_slot : slot); + if (*slot == hash_deleted_item) + { + if (deleted_slot == 0) + deleted_slot = slot; + } + else + { + if (key == *slot) + return slot; + if ((*ht->ht_compare) (key, *slot) == 0) + return slot; + ht->ht_collisions++; + } + if (!hash_2) + hash_2 = (*ht->ht_hash_2) (key) | 1; + hash_1 += hash_2; + } +} + +void * +hash_find_item (ht, key) + struct hash_table* ht; + void const *key; +{ + void **slot = hash_find_slot (ht, key); + return ((HASH_VACANT (*slot)) ? 0 : *slot); +} + +void * +hash_insert (ht, item) + struct hash_table* ht; + void *item; +{ + void **slot = hash_find_slot (ht, item); + void *old_item = slot ? *slot : 0; + hash_insert_at (ht, item, slot); + return ((HASH_VACANT (old_item)) ? 0 : old_item); +} + +void * +hash_insert_at (ht, item, slot) + struct hash_table* ht; + void *item; + void const *slot; +{ + void *old_item = *(void **) slot; + if (HASH_VACANT (old_item)) + { + ht->ht_fill++; + if (old_item == 0) + ht->ht_empty_slots--; + old_item = item; + } + *(void const **) slot = item; + if (ht->ht_empty_slots < ht->ht_size - ht->ht_capacity) + { + hash_rehash (ht); + return (void *) hash_find_slot (ht, item); + } + else + return (void *) slot; +} + +void * +hash_delete (ht, item) + struct hash_table* ht; + void const *item; +{ + void **slot = hash_find_slot (ht, item); + return hash_delete_at (ht, slot); +} + +void * +hash_delete_at (ht, slot) + struct hash_table* ht; + void const *slot; +{ + void *item = *(void **) slot; + if (!HASH_VACANT (item)) + { + *(void const **) slot = hash_deleted_item; + ht->ht_fill--; + return item; + } + else + return 0; +} + +void +hash_free_items (ht) + struct hash_table* ht; +{ + void **vec = ht->ht_vec; + void **end = &vec[ht->ht_size]; + for (; vec < end; vec++) + { + void *item = *vec; + if (!HASH_VACANT (item)) + free (item); + *vec = 0; + } + ht->ht_fill = 0; + ht->ht_empty_slots = ht->ht_size; +} + +void +hash_delete_items (ht) + struct hash_table* ht; +{ + void **vec = ht->ht_vec; + void **end = &vec[ht->ht_size]; + for (; vec < end; vec++) + *vec = 0; + ht->ht_fill = 0; + ht->ht_collisions = 0; + ht->ht_lookups = 0; + ht->ht_rehashes = 0; + ht->ht_empty_slots = ht->ht_size; +} + +void +hash_free (ht, free_items) + struct hash_table* ht; + int free_items; +{ + if (free_items) + hash_free_items (ht); + else + { + ht->ht_fill = 0; + ht->ht_empty_slots = ht->ht_size; + } + free (ht->ht_vec); + ht->ht_vec = 0; + ht->ht_capacity = 0; +} + +void +hash_map (ht, map) + struct hash_table *ht; + hash_map_func_t map; +{ + void **slot; + void **end = &ht->ht_vec[ht->ht_size]; + + for (slot = ht->ht_vec; slot < end; slot++) + { + if (!HASH_VACANT (*slot)) + (*map) (*slot); + } +} + +void +hash_map_arg (ht, map, arg) + struct hash_table *ht; + hash_map_arg_func_t map; + void *arg; +{ + void **slot; + void **end = &ht->ht_vec[ht->ht_size]; + + for (slot = ht->ht_vec; slot < end; slot++) + { + if (!HASH_VACANT (*slot)) + (*map) (*slot, arg); + } +} + +/* Double the size of the hash table in the event of overflow... */ + +static void +hash_rehash (ht) + struct hash_table* ht; +{ + unsigned long old_ht_size = ht->ht_size; + void **old_vec = ht->ht_vec; + void **ovp; + + if (ht->ht_fill >= ht->ht_capacity) + { + ht->ht_size *= 2; + ht->ht_capacity = ht->ht_size - (ht->ht_size >> 4); + } + ht->ht_rehashes++; + ht->ht_vec = (void **) CALLOC (struct token *, ht->ht_size); + + for (ovp = old_vec; ovp < &old_vec[old_ht_size]; ovp++) + { + if (! HASH_VACANT (*ovp)) + { + void **slot = hash_find_slot (ht, *ovp); + *slot = *ovp; + } + } + ht->ht_empty_slots = ht->ht_size - ht->ht_fill; + free (old_vec); +} + +void +hash_print_stats (ht, out_FILE) + struct hash_table *ht; + FILE *out_FILE; +{ + /* GKM FIXME: honor NO_FLOAT */ + fprintf (out_FILE, _("Load=%ld/%ld=%.0f%%, "), ht->ht_fill, ht->ht_size, + 100.0 * (double) ht->ht_fill / (double) ht->ht_size); + fprintf (out_FILE, _("Rehash=%d, "), ht->ht_rehashes); + fprintf (out_FILE, _("Collisions=%ld/%ld=%.0f%%"), ht->ht_collisions, ht->ht_lookups, + (ht->ht_lookups + ? (100.0 * (double) ht->ht_collisions / (double) ht->ht_lookups) + : 0)); +} + +/* Dump all items into a NULL-terminated vector. Use the + user-supplied vector, or malloc one. */ + +void ** +hash_dump (ht, vector_0, compare) + struct hash_table *ht; + void **vector_0; + qsort_cmp_t compare; +{ + void **vector; + void **slot; + void **end = &ht->ht_vec[ht->ht_size]; + + if (vector_0 == 0) + vector_0 = MALLOC (void *, ht->ht_fill + 1); + vector = vector_0; + + for (slot = ht->ht_vec; slot < end; slot++) + if (!HASH_VACANT (*slot)) + *vector++ = *slot; + *vector = 0; + + if (compare) + qsort (vector_0, ht->ht_fill, sizeof (void *), compare); + return vector_0; +} + +/* Round a given number up to the nearest power of 2. */ + +static unsigned long +round_up_2 (n) + unsigned long n; +{ + n |= (n >> 1); + n |= (n >> 2); + n |= (n >> 4); + n |= (n >> 8); + n |= (n >> 16); + +#if !defined(HAVE_LIMITS_H) || ULONG_MAX > 4294967295 + /* We only need this on systems where unsigned long is >32 bits. */ + n |= (n >> 32); +#endif + + return n + 1; +} diff --git a/flaim/external/w32/make/hash.h b/flaim/external/w32/make/hash.h new file mode 100644 index 0000000..405f1da --- /dev/null +++ b/flaim/external/w32/make/hash.h @@ -0,0 +1,233 @@ +/* hash.h -- decls for hash table + Copyright (C) 1995, 1999, 2002 Free Software Foundation, Inc. + Written by Greg McGary + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +#ifndef _hash_h_ +#define _hash_h_ + +#include +#include + +#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32 +# if !defined __GLIBC__ || !defined __P +# undef __P +# define __P(protos) protos +# endif +#else /* Not C++ or ANSI C. */ +# undef __P +# define __P(protos) () +/* We can get away without defining `const' here only because in this file + it is used only inside the prototype for `fnmatch', which is elided in + non-ANSI C where `const' is problematical. */ +#endif /* C++ or ANSI C. */ + +typedef unsigned long (*hash_func_t) __P((void const *key)); +typedef int (*hash_cmp_func_t) __P((void const *x, void const *y)); +typedef void (*hash_map_func_t) __P((void const *item)); +typedef void (*hash_map_arg_func_t) __P((void const *item, void *arg)); + +struct hash_table +{ + void **ht_vec; + unsigned long ht_size; /* total number of slots (power of 2) */ + unsigned long ht_capacity; /* usable slots, limited by loading-factor */ + unsigned long ht_fill; /* items in table */ + unsigned long ht_empty_slots; /* empty slots not including deleted slots */ + unsigned long ht_collisions; /* # of failed calls to comparison function */ + unsigned long ht_lookups; /* # of queries */ + unsigned int ht_rehashes; /* # of times we've expanded table */ + hash_func_t ht_hash_1; /* primary hash function */ + hash_func_t ht_hash_2; /* secondary hash function */ + hash_cmp_func_t ht_compare; /* comparison function */ +}; + +typedef int (*qsort_cmp_t) __P((void const *, void const *)); + +void hash_init __P((struct hash_table *ht, unsigned long size, + hash_func_t hash_1, hash_func_t hash_2, hash_cmp_func_t hash_cmp)); +void hash_load __P((struct hash_table *ht, void *item_table, + unsigned long cardinality, unsigned long size)); +void **hash_find_slot __P((struct hash_table *ht, void const *key)); +void *hash_find_item __P((struct hash_table *ht, void const *key)); +void *hash_insert __P((struct hash_table *ht, void *item)); +void *hash_insert_at __P((struct hash_table *ht, void *item, void const *slot)); +void *hash_delete __P((struct hash_table *ht, void const *item)); +void *hash_delete_at __P((struct hash_table *ht, void const *slot)); +void hash_delete_items __P((struct hash_table *ht)); +void hash_free_items __P((struct hash_table *ht)); +void hash_free __P((struct hash_table *ht, int free_items)); +void hash_map __P((struct hash_table *ht, hash_map_func_t map)); +void hash_map_arg __P((struct hash_table *ht, hash_map_arg_func_t map, void *arg)); +void hash_print_stats __P((struct hash_table *ht, FILE *out_FILE)); +void **hash_dump __P((struct hash_table *ht, void **vector_0, qsort_cmp_t compare)); + +extern void *hash_deleted_item; +#define HASH_VACANT(item) ((item) == 0 || (void *) (item) == hash_deleted_item) + + +/* hash and comparison macros for case-sensitive string keys. */ + +#define STRING_HASH_1(KEY, RESULT) do { \ + unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \ + while (*++_key_) \ + (RESULT) += (*_key_ << (_key_[1] & 0xf)); \ +} while (0) +#define return_STRING_HASH_1(KEY) do { \ + unsigned long _result_ = 0; \ + STRING_HASH_1 ((KEY), _result_); \ + return _result_; \ +} while (0) + +#define STRING_HASH_2(KEY, RESULT) do { \ + unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \ + while (*++_key_) \ + (RESULT) += (*_key_ << (_key_[1] & 0x7)); \ +} while (0) +#define return_STRING_HASH_2(KEY) do { \ + unsigned long _result_ = 0; \ + STRING_HASH_2 ((KEY), _result_); \ + return _result_; \ +} while (0) + +#define STRING_COMPARE(X, Y, RESULT) do { \ + RESULT = strcmp ((X), (Y)); \ +} while (0) +#define return_STRING_COMPARE(X, Y) do { \ + return strcmp ((X), (Y)); \ +} while (0) + + +#define STRING_N_HASH_1(KEY, N, RESULT) do { \ + unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \ + int _n_ = (N); \ + if (_n_) \ + while (--_n_ && *++_key_) \ + (RESULT) += (*_key_ << (_key_[1] & 0xf)); \ + (RESULT) += *++_key_; \ +} while (0) +#define return_STRING_N_HASH_1(KEY, N) do { \ + unsigned long _result_ = 0; \ + STRING_N_HASH_1 ((KEY), (N), _result_); \ + return _result_; \ +} while (0) + +#define STRING_N_HASH_2(KEY, N, RESULT) do { \ + unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \ + int _n_ = (N); \ + if (_n_) \ + while (--_n_ && *++_key_) \ + (RESULT) += (*_key_ << (_key_[1] & 0x7)); \ + (RESULT) += *++_key_; \ +} while (0) +#define return_STRING_N_HASH_2(KEY, N) do { \ + unsigned long _result_ = 0; \ + STRING_N_HASH_2 ((KEY), (N), _result_); \ + return _result_; \ +} while (0) + +#define STRING_N_COMPARE(X, Y, N, RESULT) do { \ + RESULT = strncmp ((X), (Y), (N)); \ +} while (0) +#define return_STRING_N_COMPARE(X, Y, N) do { \ + return strncmp ((X), (Y), (N)); \ +} while (0) + +#ifdef HAVE_CASE_INSENSITIVE_FS + +/* hash and comparison macros for case-insensitive string _key_s. */ + +#define ISTRING_HASH_1(KEY, RESULT) do { \ + unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \ + while (*++_key_) \ + (RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0xf)); \ +} while (0) +#define return_ISTRING_HASH_1(KEY) do { \ + unsigned long _result_ = 0; \ + ISTRING_HASH_1 ((KEY), _result_); \ + return _result_; \ +} while (0) + +#define ISTRING_HASH_2(KEY, RESULT) do { \ + unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \ + while (*++_key_) \ + (RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0x7)); \ +} while (0) +#define return_ISTRING_HASH_2(KEY) do { \ + unsigned long _result_ = 0; \ + ISTRING_HASH_2 ((KEY), _result_); \ + return _result_; \ +} while (0) + +#define ISTRING_COMPARE(X, Y, RESULT) do { \ + RESULT = strcmpi ((X), (Y)); \ +} while (0) +#define return_ISTRING_COMPARE(X, Y) do { \ + return strcmpi ((X), (Y)); \ +} while (0) + +#else + +#define ISTRING_HASH_1(KEY, RESULT) STRING_HASH_1 ((KEY), (RESULT)) +#define return_ISTRING_HASH_1(KEY) return_STRING_HASH_1 (KEY) + +#define ISTRING_HASH_2(KEY, RESULT) STRING_HASH_2 ((KEY), (RESULT)) +#define return_ISTRING_HASH_2(KEY) return_STRING_HASH_2 (KEY) + +#define ISTRING_COMPARE(X, Y, RESULT) STRING_COMPARE ((X), (Y), (RESULT)) +#define return_ISTRING_COMPARE(X, Y) return_STRING_COMPARE ((X), (Y)) + +#endif + +/* hash and comparison macros for integer _key_s. */ + +#define INTEGER_HASH_1(KEY, RESULT) do { \ + (RESULT) += ((unsigned long)(KEY)); \ +} while (0) +#define return_INTEGER_HASH_1(KEY) do { \ + unsigned long _result_ = 0; \ + INTEGER_HASH_1 ((KEY), _result_); \ + return _result_; \ +} while (0) + +#define INTEGER_HASH_2(KEY, RESULT) do { \ + (RESULT) += ~((unsigned long)(KEY)); \ +} while (0) +#define return_INTEGER_HASH_2(KEY) do { \ + unsigned long _result_ = 0; \ + INTEGER_HASH_2 ((KEY), _result_); \ + return _result_; \ +} while (0) + +#define INTEGER_COMPARE(X, Y, RESULT) do { \ + (RESULT) = X - Y; \ +} while (0) +#define return_INTEGER_COMPARE(X, Y) do { \ + int _result_; \ + INTEGER_COMPARE (X, Y, _result_); \ + return _result_; \ +} while (0) + +/* hash and comparison macros for address keys. */ + +#define ADDRESS_HASH_1(KEY, RESULT) INTEGER_HASH_1 (((unsigned long)(KEY)) >> 3, (RESULT)) +#define ADDRESS_HASH_2(KEY, RESULT) INTEGER_HASH_2 (((unsigned long)(KEY)) >> 3, (RESULT)) +#define ADDRESS_COMPARE(X, Y, RESULT) INTEGER_COMPARE ((X), (Y), (RESULT)) +#define return_ADDRESS_HASH_1(KEY) return_INTEGER_HASH_1 (((unsigned long)(KEY)) >> 3) +#define return_ADDRESS_HASH_2(KEY) return_INTEGER_HASH_2 (((unsigned long)(KEY)) >> 3) +#define return_ADDRESS_COMPARE(X, Y) return_INTEGER_COMPARE ((X), (Y)) + +#endif /* not _hash_h_ */ diff --git a/flaim/external/w32/make/implicit.c b/flaim/external/w32/make/implicit.c new file mode 100644 index 0000000..857895d --- /dev/null +++ b/flaim/external/w32/make/implicit.c @@ -0,0 +1,635 @@ +/* Implicit rule searching for GNU Make. +Copyright (C) 1988,89,90,91,92,93,94,97,2000 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "rule.h" +#include "dep.h" +#include "filedef.h" +#include "debug.h" + +static int pattern_search PARAMS ((struct file *file, int archive, unsigned int depth, + unsigned int recursions)); + +/* For a FILE which has no commands specified, try to figure out some + from the implicit pattern rules. + Returns 1 if a suitable implicit rule was found, + after modifying FILE to contain the appropriate commands and deps, + or returns 0 if no implicit rule was found. */ + +int +try_implicit_rule (file, depth) + struct file *file; + unsigned int depth; +{ + DBF (DB_IMPLICIT, _("Looking for an implicit rule for `%s'.\n")); + + /* The order of these searches was previously reversed. My logic now is + that since the non-archive search uses more information in the target + (the archive search omits the archive name), it is more specific and + should come first. */ + + if (pattern_search (file, 0, depth, 0)) + return 1; + +#ifndef NO_ARCHIVES + /* If this is an archive member reference, use just the + archive member name to search for implicit rules. */ + if (ar_name (file->name)) + { + DBF (DB_IMPLICIT, + _("Looking for archive-member implicit rule for `%s'.\n")); + if (pattern_search (file, 1, depth, 0)) + return 1; + } +#endif + + return 0; +} + + +/* Search the pattern rules for a rule with an existing dependency to make + FILE. If a rule is found, the appropriate commands and deps are put in FILE + and 1 is returned. If not, 0 is returned. + + If ARCHIVE is nonzero, FILE->name is of the form "LIB(MEMBER)". A rule for + "(MEMBER)" will be searched for, and "(MEMBER)" will not be chopped up into + directory and filename parts. + + If an intermediate file is found by pattern search, the intermediate file + is set up as a target by the recursive call and is also made a dependency + of FILE. + + DEPTH is used for debugging messages. */ + +static int +pattern_search (file, archive, depth, recursions) + struct file *file; + int archive; + unsigned int depth; + unsigned int recursions; +{ + /* Filename we are searching for a rule for. */ + char *filename = archive ? strchr (file->name, '(') : file->name; + + /* Length of FILENAME. */ + unsigned int namelen = strlen (filename); + + /* The last slash in FILENAME (or nil if there is none). */ + char *lastslash; + + /* This is a file-object used as an argument in + recursive calls. It never contains any data + except during a recursive call. */ + struct file *intermediate_file = 0; + + /* List of dependencies found recursively. */ + struct file **intermediate_files + = (struct file **) xmalloc (max_pattern_deps * sizeof (struct file *)); + + /* List of the patterns used to find intermediate files. */ + char **intermediate_patterns + = (char **) alloca (max_pattern_deps * sizeof (char *)); + + /* This buffer records all the dependencies actually found for a rule. */ + char **found_files = (char **) alloca (max_pattern_deps * sizeof (char *)); + /* Number of dep names now in FOUND_FILES. */ + unsigned int deps_found = 0; + + /* Names of possible dependencies are constructed in this buffer. */ + register char *depname = (char *) alloca (namelen + max_pattern_dep_length); + + /* The start and length of the stem of FILENAME for the current rule. */ + register char *stem = 0; + register unsigned int stemlen = 0; + register unsigned int fullstemlen = 0; + + /* Buffer in which we store all the rules that are possibly applicable. */ + struct rule **tryrules + = (struct rule **) xmalloc (num_pattern_rules * max_pattern_targets + * sizeof (struct rule *)); + + /* Number of valid elements in TRYRULES. */ + unsigned int nrules; + + /* The numbers of the rule targets of each rule + in TRYRULES that matched the target file. */ + unsigned int *matches + = (unsigned int *) alloca (num_pattern_rules * sizeof (unsigned int)); + + /* Each element is nonzero if LASTSLASH was used in + matching the corresponding element of TRYRULES. */ + char *checked_lastslash + = (char *) alloca (num_pattern_rules * sizeof (char)); + + /* The index in TRYRULES of the rule we found. */ + unsigned int foundrule; + + /* Nonzero if should consider intermediate files as dependencies. */ + int intermed_ok; + + /* Nonzero if we have matched a pattern-rule target + that is not just `%'. */ + int specific_rule_matched = 0; + + register unsigned int i = 0; /* uninit checks OK */ + register struct rule *rule; + register struct dep *dep; + + char *p, *vp; + +#ifndef NO_ARCHIVES + if (archive || ar_name (filename)) + lastslash = 0; + else +#endif + { + /* Set LASTSLASH to point at the last slash in FILENAME + but not counting any slash at the end. (foo/bar/ counts as + bar/ in directory foo/, not empty in directory foo/bar/.) */ +#ifdef VMS + lastslash = strrchr (filename, ']'); + if (lastslash == 0) + lastslash = strrchr (filename, ':'); +#else + lastslash = strrchr (filename, '/'); +#ifdef HAVE_DOS_PATHS + /* Handle backslashes (possibly mixed with forward slashes) + and the case of "d:file". */ + { + char *bslash = strrchr (filename, '\\'); + if (lastslash == 0 || bslash > lastslash) + lastslash = bslash; + if (lastslash == 0 && filename[0] && filename[1] == ':') + lastslash = filename + 1; + } +#endif +#endif + if (lastslash != 0 && lastslash[1] == '\0') + lastslash = 0; + } + + /* First see which pattern rules match this target + and may be considered. Put them in TRYRULES. */ + + nrules = 0; + for (rule = pattern_rules; rule != 0; rule = rule->next) + { + /* If the pattern rule has deps but no commands, ignore it. + Users cancel built-in rules by redefining them without commands. */ + if (rule->deps != 0 && rule->cmds == 0) + continue; + + /* If this rule is in use by a parent pattern_search, + don't use it here. */ + if (rule->in_use) + { + DBS (DB_IMPLICIT, (_("Avoiding implicit rule recursion.\n"))); + continue; + } + + for (i = 0; rule->targets[i] != 0; ++i) + { + char *target = rule->targets[i]; + char *suffix = rule->suffixes[i]; + int check_lastslash; + + /* Rules that can match any filename and are not terminal + are ignored if we're recursing, so that they cannot be + intermediate files. */ + if (recursions > 0 && target[1] == '\0' && !rule->terminal) + continue; + + if (rule->lens[i] > namelen) + /* It can't possibly match. */ + continue; + + /* From the lengths of the filename and the pattern parts, + find the stem: the part of the filename that matches the %. */ + stem = filename + (suffix - target - 1); + stemlen = namelen - rule->lens[i] + 1; + + /* Set CHECK_LASTSLASH if FILENAME contains a directory + prefix and the target pattern does not contain a slash. */ + +#ifdef VMS + check_lastslash = lastslash != 0 + && ((strchr (target, ']') == 0) + && (strchr (target, ':') == 0)); +#else + check_lastslash = lastslash != 0 && strchr (target, '/') == 0; +#endif + if (check_lastslash) + { + /* In that case, don't include the + directory prefix in STEM here. */ + unsigned int difference = lastslash - filename + 1; + if (difference > stemlen) + continue; + stemlen -= difference; + stem += difference; + } + + /* Check that the rule pattern matches the text before the stem. */ + if (check_lastslash) + { + if (stem > (lastslash + 1) + && !strneq (target, lastslash + 1, stem - lastslash - 1)) + continue; + } + else if (stem > filename + && !strneq (target, filename, stem - filename)) + continue; + + /* Check that the rule pattern matches the text after the stem. + We could test simply use streq, but this way we compare the + first two characters immediately. This saves time in the very + common case where the first character matches because it is a + period. */ + if (*suffix != stem[stemlen] + || (*suffix != '\0' && !streq (&suffix[1], &stem[stemlen + 1]))) + continue; + + /* Record if we match a rule that not all filenames will match. */ + if (target[1] != '\0') + specific_rule_matched = 1; + + /* A rule with no dependencies and no commands exists solely to set + specific_rule_matched when it matches. Don't try to use it. */ + if (rule->deps == 0 && rule->cmds == 0) + continue; + + /* Record this rule in TRYRULES and the index of the matching + target in MATCHES. If several targets of the same rule match, + that rule will be in TRYRULES more than once. */ + tryrules[nrules] = rule; + matches[nrules] = i; + checked_lastslash[nrules] = check_lastslash; + ++nrules; + } + } + + /* If we have found a matching rule that won't match all filenames, + retroactively reject any non-"terminal" rules that do always match. */ + if (specific_rule_matched) + for (i = 0; i < nrules; ++i) + if (!tryrules[i]->terminal) + { + register unsigned int j; + for (j = 0; tryrules[i]->targets[j] != 0; ++j) + if (tryrules[i]->targets[j][1] == '\0') + break; + if (tryrules[i]->targets[j] != 0) + tryrules[i] = 0; + } + + /* Try each rule once without intermediate files, then once with them. */ + for (intermed_ok = 0; intermed_ok == !!intermed_ok; ++intermed_ok) + { + /* Try each pattern rule till we find one that applies. + If it does, copy the names of its dependencies (as substituted) + and store them in FOUND_FILES. DEPS_FOUND is the number of them. */ + + for (i = 0; i < nrules; i++) + { + int check_lastslash; + + rule = tryrules[i]; + + /* RULE is nil when we discover that a rule, + already placed in TRYRULES, should not be applied. */ + if (rule == 0) + continue; + + /* Reject any terminal rules if we're + looking to make intermediate files. */ + if (intermed_ok && rule->terminal) + continue; + + /* Mark this rule as in use so a recursive + pattern_search won't try to use it. */ + rule->in_use = 1; + + /* From the lengths of the filename and the matching pattern parts, + find the stem: the part of the filename that matches the %. */ + stem = filename + + (rule->suffixes[matches[i]] - rule->targets[matches[i]]) - 1; + stemlen = namelen - rule->lens[matches[i]] + 1; + check_lastslash = checked_lastslash[i]; + if (check_lastslash) + { + stem += lastslash - filename + 1; + stemlen -= (lastslash - filename) + 1; + } + + DBS (DB_IMPLICIT, (_("Trying pattern rule with stem `%.*s'.\n"), + (int) stemlen, stem)); + + /* Try each dependency; see if it "exists". */ + + deps_found = 0; + for (dep = rule->deps; dep != 0; dep = dep->next) + { + /* If the dependency name has a %, substitute the stem. */ + p = strchr (dep_name (dep), '%'); + if (p != 0) + { + register unsigned int i; + if (check_lastslash) + { + /* Copy directory name from the original FILENAME. */ + i = lastslash - filename + 1; + bcopy (filename, depname, i); + } + else + i = 0; + bcopy (dep_name (dep), depname + i, p - dep_name (dep)); + i += p - dep_name (dep); + bcopy (stem, depname + i, stemlen); + i += stemlen; + strcpy (depname + i, p + 1); + p = depname; + } + else + p = dep_name (dep); + + /* P is now the actual dependency name as substituted. */ + + if (file_impossible_p (p)) + { + /* If this dependency has already been ruled + "impossible", then the rule fails and don't + bother trying it on the second pass either + since we know that will fail too. */ + DBS (DB_IMPLICIT, + (p == depname + ? _("Rejecting impossible implicit prerequisite `%s'.\n") + : _("Rejecting impossible rule prerequisite `%s'.\n"), + p)); + tryrules[i] = 0; + break; + } + + intermediate_files[deps_found] = 0; + + DBS (DB_IMPLICIT, + (p == depname + ? _("Trying implicit prerequisite `%s'.\n") + : _("Trying rule prerequisite `%s'.\n"), p)); + + /* The DEP->changed flag says that this dependency resides in a + nonexistent directory. So we normally can skip looking for + the file. However, if CHECK_LASTSLASH is set, then the + dependency file we are actually looking for is in a different + directory (the one gotten by prepending FILENAME's directory), + so it might actually exist. */ + + if (lookup_file (p) != 0 + || ((!dep->changed || check_lastslash) && file_exists_p (p))) + { + found_files[deps_found++] = xstrdup (p); + continue; + } + /* This code, given FILENAME = "lib/foo.o", dependency name + "lib/foo.c", and VPATH=src, searches for "src/lib/foo.c". */ + vp = p; + if (vpath_search (&vp, (FILE_TIMESTAMP *) 0)) + { + DBS (DB_IMPLICIT, + (_("Found prerequisite `%s' as VPATH `%s'\n"), p, vp)); + strcpy (vp, p); + found_files[deps_found++] = vp; + continue; + } + + /* We could not find the file in any place we should look. + Try to make this dependency as an intermediate file, + but only on the second pass. */ + + if (intermed_ok) + { + if (intermediate_file == 0) + intermediate_file + = (struct file *) alloca (sizeof (struct file)); + + DBS (DB_IMPLICIT, + (_("Looking for a rule with intermediate file `%s'.\n"), + p)); + + bzero ((char *) intermediate_file, sizeof (struct file)); + intermediate_file->name = p; + if (pattern_search (intermediate_file, 0, depth + 1, + recursions + 1)) + { + p = xstrdup (p); + intermediate_patterns[deps_found] + = intermediate_file->name; + intermediate_file->name = p; + intermediate_files[deps_found] = intermediate_file; + intermediate_file = 0; + /* Allocate an extra copy to go in FOUND_FILES, + because every elt of FOUND_FILES is consumed + or freed later. */ + found_files[deps_found] = xstrdup (p); + ++deps_found; + continue; + } + + /* If we have tried to find P as an intermediate + file and failed, mark that name as impossible + so we won't go through the search again later. */ + file_impossible (p); + } + + /* A dependency of this rule does not exist. + Therefore, this rule fails. */ + break; + } + + /* This rule is no longer `in use' for recursive searches. */ + rule->in_use = 0; + + if (dep != 0) + { + /* This pattern rule does not apply. + If some of its dependencies succeeded, + free the data structure describing them. */ + while (deps_found-- > 0) + { + register struct file *f = intermediate_files[deps_found]; + free (found_files[deps_found]); + if (f != 0 + && (f->stem < f->name + || f->stem > f->name + strlen (f->name))) + free (f->stem); + } + } + else + /* This pattern rule does apply. Stop looking for one. */ + break; + } + + /* If we found an applicable rule without + intermediate files, don't try with them. */ + if (i < nrules) + break; + + rule = 0; + } + + /* RULE is nil if the loop went all the way + through the list and everything failed. */ + if (rule == 0) + goto done; + + foundrule = i; + + /* If we are recursing, store the pattern that matched + FILENAME in FILE->name for use in upper levels. */ + + if (recursions > 0) + /* Kludge-o-matic */ + file->name = rule->targets[matches[foundrule]]; + + /* FOUND_FILES lists the dependencies for the rule we found. + This includes the intermediate files, if any. + Convert them into entries on the deps-chain of FILE. */ + + while (deps_found-- > 0) + { + register char *s; + + if (intermediate_files[deps_found] != 0) + { + /* If we need to use an intermediate file, + make sure it is entered as a target, with the info that was + found for it in the recursive pattern_search call. + We know that the intermediate file did not already exist as + a target; therefore we can assume that the deps and cmds + of F below are null before we change them. */ + + struct file *imf = intermediate_files[deps_found]; + register struct file *f = enter_file (imf->name); + f->deps = imf->deps; + f->cmds = imf->cmds; + f->stem = imf->stem; + f->also_make = imf->also_make; + imf = lookup_file (intermediate_patterns[deps_found]); + if (imf != 0 && imf->precious) + f->precious = 1; + f->intermediate = 1; + f->tried_implicit = 1; + for (dep = f->deps; dep != 0; dep = dep->next) + { + dep->file = enter_file (dep->name); + /* enter_file uses dep->name _if_ we created a new file. */ + if (dep->name != dep->file->name) + free (dep->name); + dep->name = 0; + dep->file->tried_implicit |= dep->changed; + } + } + + dep = (struct dep *) xmalloc (sizeof (struct dep)); + dep->ignore_mtime = 0; + s = found_files[deps_found]; + if (recursions == 0) + { + dep->name = 0; + dep->file = lookup_file (s); + if (dep->file == 0) + /* enter_file consumes S's storage. */ + dep->file = enter_file (s); + else + /* A copy of S is already allocated in DEP->file->name. + So we can free S. */ + free (s); + } + else + { + dep->name = s; + dep->file = 0; + dep->changed = 0; + } + if (intermediate_files[deps_found] == 0 && tryrules[foundrule]->terminal) + { + /* If the file actually existed (was not an intermediate file), + and the rule that found it was a terminal one, then we want + to mark the found file so that it will not have implicit rule + search done for it. If we are not entering a `struct file' for + it now, we indicate this with the `changed' flag. */ + if (dep->file == 0) + dep->changed = 1; + else + dep->file->tried_implicit = 1; + } + dep->next = file->deps; + file->deps = dep; + } + + if (!checked_lastslash[foundrule]) + { + /* Always allocate new storage, since STEM might be + on the stack for an intermediate file. */ + file->stem = savestring (stem, stemlen); + fullstemlen = stemlen; + } + else + { + int dirlen = (lastslash + 1) - filename; + + /* We want to prepend the directory from + the original FILENAME onto the stem. */ + fullstemlen = dirlen + stemlen; + file->stem = (char *) xmalloc (fullstemlen + 1); + bcopy (filename, file->stem, dirlen); + bcopy (stem, file->stem + dirlen, stemlen); + file->stem[fullstemlen] = '\0'; + } + + file->cmds = rule->cmds; + + /* If this rule builds other targets, too, put the others into FILE's + `also_make' member. */ + + if (rule->targets[1] != 0) + for (i = 0; rule->targets[i] != 0; ++i) + if (i != matches[foundrule]) + { + struct dep *new = (struct dep *) xmalloc (sizeof (struct dep)); + /* GKM FIMXE: handle '|' here too */ + new->ignore_mtime = 0; + new->name = p = (char *) xmalloc (rule->lens[i] + fullstemlen + 1); + bcopy (rule->targets[i], p, + rule->suffixes[i] - rule->targets[i] - 1); + p += rule->suffixes[i] - rule->targets[i] - 1; + bcopy (file->stem, p, fullstemlen); + p += fullstemlen; + bcopy (rule->suffixes[i], p, + rule->lens[i] - (rule->suffixes[i] - rule->targets[i]) + 1); + new->file = enter_file (new->name); + new->next = file->also_make; + file->also_make = new; + } + + done: + free (intermediate_files); + free (tryrules); + + return rule != 0; +} diff --git a/flaim/external/w32/make/job.c b/flaim/external/w32/make/job.c new file mode 100644 index 0000000..63456a7 --- /dev/null +++ b/flaim/external/w32/make/job.c @@ -0,0 +1,3110 @@ +/* Job execution and handling for GNU Make. +Copyright (C) 1988,89,90,91,92,93,94,95,96,97,99 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" + +#include + +#include "job.h" +#include "debug.h" +#include "filedef.h" +#include "commands.h" +#include "variable.h" +#include "debug.h" + +#include + +/* Default shell to use. */ +#ifdef WINDOWS32 +char *default_shell = "sh.exe"; +int no_default_sh_exe = 1; +int batch_mode_shell = 1; +#else /* WINDOWS32 */ +# ifdef _AMIGA +char default_shell[] = ""; +extern int MyExecute (char **); +# else /* _AMIGA */ +# ifdef __MSDOS__ +/* The default shell is a pointer so we can change it if Makefile + says so. It is without an explicit path so we get a chance + to search the $PATH for it (since MSDOS doesn't have standard + directories we could trust). */ +char *default_shell = "command.com"; +# else /* __MSDOS__ */ +# ifdef VMS +# include +char default_shell[] = ""; +# else +char default_shell[] = "/bin/sh"; +# endif /* VMS */ +# endif /* __MSDOS__ */ +int batch_mode_shell = 0; +# endif /* _AMIGA */ +#endif /* WINDOWS32 */ + +#ifdef __MSDOS__ +# include +static int execute_by_shell; +static int dos_pid = 123; +int dos_status; +int dos_command_running; +#endif /* __MSDOS__ */ + +#ifdef _AMIGA +# include +static int amiga_pid = 123; +static int amiga_status; +static char amiga_bname[32]; +static int amiga_batch_file; +#endif /* Amiga. */ + +#ifdef VMS +# ifndef __GNUC__ +# include +# endif +# include +# include +#endif + +#ifdef WINDOWS32 +# include +# include +# include +# include "sub_proc.h" +# include "w32err.h" +# include "pathstuff.h" +#endif /* WINDOWS32 */ + +#ifdef HAVE_FCNTL_H +# include +#else +# include +#endif + +#if defined (HAVE_SYS_WAIT_H) || defined (HAVE_UNION_WAIT) +# include +#endif + +#ifdef HAVE_WAITPID +# define WAIT_NOHANG(status) waitpid (-1, (status), WNOHANG) +#else /* Don't have waitpid. */ +# ifdef HAVE_WAIT3 +# ifndef wait3 +extern int wait3 (); +# endif +# define WAIT_NOHANG(status) wait3 ((status), WNOHANG, (struct rusage *) 0) +# endif /* Have wait3. */ +#endif /* Have waitpid. */ + +#if !defined (wait) && !defined (POSIX) +extern int wait (); +#endif + +#ifndef HAVE_UNION_WAIT + +# define WAIT_T int + +# ifndef WTERMSIG +# define WTERMSIG(x) ((x) & 0x7f) +# endif +# ifndef WCOREDUMP +# define WCOREDUMP(x) ((x) & 0x80) +# endif +# ifndef WEXITSTATUS +# define WEXITSTATUS(x) (((x) >> 8) & 0xff) +# endif +# ifndef WIFSIGNALED +# define WIFSIGNALED(x) (WTERMSIG (x) != 0) +# endif +# ifndef WIFEXITED +# define WIFEXITED(x) (WTERMSIG (x) == 0) +# endif + +#else /* Have `union wait'. */ + +# define WAIT_T union wait +# ifndef WTERMSIG +# define WTERMSIG(x) ((x).w_termsig) +# endif +# ifndef WCOREDUMP +# define WCOREDUMP(x) ((x).w_coredump) +# endif +# ifndef WEXITSTATUS +# define WEXITSTATUS(x) ((x).w_retcode) +# endif +# ifndef WIFSIGNALED +# define WIFSIGNALED(x) (WTERMSIG(x) != 0) +# endif +# ifndef WIFEXITED +# define WIFEXITED(x) (WTERMSIG(x) == 0) +# endif + +#endif /* Don't have `union wait'. */ + +/* How to set close-on-exec for a file descriptor. */ + +#if !defined F_SETFD +# define CLOSE_ON_EXEC(_d) +#else +# ifndef FD_CLOEXEC +# define FD_CLOEXEC 1 +# endif +# define CLOSE_ON_EXEC(_d) (void) fcntl ((_d), F_SETFD, FD_CLOEXEC) +#endif + +#ifdef VMS +static int vms_jobsefnmask = 0; +#endif /* !VMS */ + +#ifndef HAVE_UNISTD_H +extern int dup2 (); +extern int execve (); +extern void _exit (); +# ifndef VMS +extern int geteuid (); +extern int getegid (); +extern int setgid (); +extern int getgid (); +# endif +#endif + +extern char *allocated_variable_expand_for_file PARAMS ((char *line, struct file *file)); + +extern int getloadavg PARAMS ((double loadavg[], int nelem)); +extern int start_remote_job PARAMS ((char **argv, char **envp, int stdin_fd, + int *is_remote, int *id_ptr, int *used_stdin)); +extern int start_remote_job_p PARAMS ((int)); +extern int remote_status PARAMS ((int *exit_code_ptr, int *signal_ptr, + int *coredump_ptr, int block)); + +RETSIGTYPE child_handler PARAMS ((int)); +static void free_child PARAMS ((struct child *)); +static void start_job_command PARAMS ((struct child *child)); +static int load_too_high PARAMS ((void)); +static int job_next_command PARAMS ((struct child *)); +static int start_waiting_job PARAMS ((struct child *)); +#ifdef VMS +static void vmsWaitForChildren PARAMS ((int *)); +#endif + +/* Chain of all live (or recently deceased) children. */ + +struct child *children = 0; + +/* Number of children currently running. */ + +unsigned int job_slots_used = 0; + +/* Nonzero if the `good' standard input is in use. */ + +static int good_stdin_used = 0; + +/* Chain of children waiting to run until the load average goes down. */ + +static struct child *waiting_jobs = 0; + +/* Non-zero if we use a *real* shell (always so on Unix). */ + +int unixy_shell = 1; + + +#ifdef WINDOWS32 +/* + * The macro which references this function is defined in make.h. + */ +int w32_kill(int pid, int sig) +{ + return ((process_kill(pid, sig) == TRUE) ? 0 : -1); +} +#endif /* WINDOWS32 */ + +/* Write an error message describing the exit status given in + EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME. + Append "(ignored)" if IGNORED is nonzero. */ + +static void +child_error (target_name, exit_code, exit_sig, coredump, ignored) + char *target_name; + int exit_code, exit_sig, coredump; + int ignored; +{ + if (ignored && silent_flag) + return; + +#ifdef VMS + if (!(exit_code & 1)) + error (NILF, + (ignored ? _("*** [%s] Error 0x%x (ignored)") + : _("*** [%s] Error 0x%x")), + target_name, exit_code); +#else + if (exit_sig == 0) + error (NILF, ignored ? _("[%s] Error %d (ignored)") : + _("*** [%s] Error %d"), + target_name, exit_code); + else + error (NILF, "*** [%s] %s%s", + target_name, strsignal (exit_sig), + coredump ? _(" (core dumped)") : ""); +#endif /* VMS */ +} + +#ifdef VMS +/* Wait for nchildren children to terminate */ +static void +vmsWaitForChildren(int *status) +{ + while (1) + { + if (!vms_jobsefnmask) + { + *status = 0; + return; + } + + *status = sys$wflor (32, vms_jobsefnmask); + } + return; +} + +/* Set up IO redirection. */ + +char * +vms_redirect (desc, fname, ibuf) + struct dsc$descriptor_s *desc; + char *fname; + char *ibuf; +{ + char *fptr; + extern char *vmsify (); + + ibuf++; + while (isspace ((unsigned char)*ibuf)) + ibuf++; + fptr = ibuf; + while (*ibuf && !isspace ((unsigned char)*ibuf)) + ibuf++; + *ibuf = 0; + if (strcmp (fptr, "/dev/null") != 0) + { + strcpy (fname, vmsify (fptr, 0)); + if (strchr (fname, '.') == 0) + strcat (fname, "."); + } + desc->dsc$w_length = strlen(fname); + desc->dsc$a_pointer = fname; + desc->dsc$b_dtype = DSC$K_DTYPE_T; + desc->dsc$b_class = DSC$K_CLASS_S; + + if (*fname == 0) + printf (_("Warning: Empty redirection\n")); + return ibuf; +} + + +/* + found apostrophe at (p-1) + + inc p until after closing apostrophe. */ + +static char * +handle_apos (char *p) +{ + int alast; + int inside; + +#define SEPCHARS ",/()= " + + inside = 0; + + while (*p != 0) + { + if (*p == '"') + { + if (inside) + { + while ((alast > 0) + && (*p == '"')) + { + p++; + alast--; + } + if (alast == 0) + inside = 0; + else + { + fprintf (stderr, _("Syntax error, still inside '\"'\n")); + exit (3); + } + } + else + { + p++; + if (strchr (SEPCHARS, *p)) + break; + inside = 1; + alast = 1; + while (*p == '"') + { + alast++; + p++; + } + } + } + else + p++; + } + + return p; +} + +#endif + + +/* Handle a dead child. This handler may or may not ever be installed. + + If we're using the jobserver feature, we need it. First, installing it + ensures the read will interrupt on SIGCHLD. Second, we close the dup'd + read FD to ensure we don't enter another blocking read without reaping all + the dead children. In this case we don't need the dead_children count. + + If we don't have either waitpid or wait3, then make is unreliable, but we + use the dead_children count to reap children as best we can. */ + +static unsigned int dead_children = 0; + +RETSIGTYPE +child_handler (sig) + int sig; +{ + ++dead_children; + + if (job_rfd >= 0) + { + close (job_rfd); + job_rfd = -1; + } + + DB (DB_JOBS, (_("Got a SIGCHLD; %u unreaped children.\n"), dead_children)); +} + + +extern int shell_function_pid, shell_function_completed; + +/* Reap all dead children, storing the returned status and the new command + state (`cs_finished') in the `file' member of the `struct child' for the + dead child, and removing the child from the chain. In addition, if BLOCK + nonzero, we block in this function until we've reaped at least one + complete child, waiting for it to die if necessary. If ERR is nonzero, + print an error message first. */ + +void +reap_children (block, err) + int block, err; +{ + WAIT_T status; + /* Initially, assume we have some. */ + int reap_more = 1; + +#ifdef WAIT_NOHANG +# define REAP_MORE reap_more +#else +# define REAP_MORE dead_children +#endif + + /* As long as: + + We have at least one child outstanding OR a shell function in progress, + AND + We're blocking for a complete child OR there are more children to reap + + we'll keep reaping children. */ + + while ((children != 0 || shell_function_pid != 0) + && (block || REAP_MORE)) + { + int remote = 0; + register int pid; + int exit_code, exit_sig, coredump; + register struct child *lastc, *c; + int child_failed; + int any_remote, any_local; + + if (err && block) + { + /* We might block for a while, so let the user know why. */ + fflush (stdout); + error (NILF, _("*** Waiting for unfinished jobs....")); + } + + /* We have one less dead child to reap. As noted in + child_handler() above, this count is completely unimportant for + all modern, POSIX-y systems that support wait3() or waitpid(). + The rest of this comment below applies only to early, broken + pre-POSIX systems. We keep the count only because... it's there... + + The test and decrement are not atomic; if it is compiled into: + register = dead_children - 1; + dead_children = register; + a SIGCHLD could come between the two instructions. + child_handler increments dead_children. + The second instruction here would lose that increment. But the + only effect of dead_children being wrong is that we might wait + longer than necessary to reap a child, and lose some parallelism; + and we might print the "Waiting for unfinished jobs" message above + when not necessary. */ + + if (dead_children > 0) + --dead_children; + + any_remote = 0; + any_local = shell_function_pid != 0; + for (c = children; c != 0; c = c->next) + { + any_remote |= c->remote; + any_local |= ! c->remote; + DB (DB_JOBS, (_("Live child 0x%08lx (%s) PID %ld %s\n"), + (unsigned long int) c, c->file->name, + (long) c->pid, c->remote ? _(" (remote)") : "")); +#ifdef VMS + break; +#endif + } + + /* First, check for remote children. */ + if (any_remote) + pid = remote_status (&exit_code, &exit_sig, &coredump, 0); + else + pid = 0; + + if (pid > 0) + /* We got a remote child. */ + remote = 1; + else if (pid < 0) + { + /* A remote status command failed miserably. Punt. */ + remote_status_lose: + pfatal_with_name ("remote_status"); + } + else + { + /* No remote children. Check for local children. */ +#if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32) + if (any_local) + { +#ifdef VMS + vmsWaitForChildren (&status); + pid = c->pid; +#else +#ifdef WAIT_NOHANG + if (!block) + pid = WAIT_NOHANG (&status); + else +#endif + pid = wait (&status); +#endif /* !VMS */ + } + else + pid = 0; + + if (pid < 0) + { + /* The wait*() failed miserably. Punt. */ + pfatal_with_name ("wait"); + } + else if (pid > 0) + { + /* We got a child exit; chop the status word up. */ + exit_code = WEXITSTATUS (status); + exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0; + coredump = WCOREDUMP (status); + } + else + { + /* No local children are dead. */ + reap_more = 0; + + if (!block || !any_remote) + break; + + /* Now try a blocking wait for a remote child. */ + pid = remote_status (&exit_code, &exit_sig, &coredump, 1); + if (pid < 0) + goto remote_status_lose; + else if (pid == 0) + /* No remote children either. Finally give up. */ + break; + + /* We got a remote child. */ + remote = 1; + } +#endif /* !__MSDOS__, !Amiga, !WINDOWS32. */ + +#ifdef __MSDOS__ + /* Life is very different on MSDOS. */ + pid = dos_pid - 1; + status = dos_status; + exit_code = WEXITSTATUS (status); + if (exit_code == 0xff) + exit_code = -1; + exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0; + coredump = 0; +#endif /* __MSDOS__ */ +#ifdef _AMIGA + /* Same on Amiga */ + pid = amiga_pid - 1; + status = amiga_status; + exit_code = amiga_status; + exit_sig = 0; + coredump = 0; +#endif /* _AMIGA */ +#ifdef WINDOWS32 + { + HANDLE hPID; + int err; + + /* wait for anything to finish */ + if (hPID = process_wait_for_any()) { + + /* was an error found on this process? */ + err = process_last_err(hPID); + + /* get exit data */ + exit_code = process_exit_code(hPID); + + if (err) + fprintf(stderr, "make (e=%d): %s", + exit_code, map_windows32_error_to_string(exit_code)); + + /* signal */ + exit_sig = process_signal(hPID); + + /* cleanup process */ + process_cleanup(hPID); + + coredump = 0; + } + pid = (int) hPID; + } +#endif /* WINDOWS32 */ + } + + /* Check if this is the child of the `shell' function. */ + if (!remote && pid == shell_function_pid) + { + /* It is. Leave an indicator for the `shell' function. */ + if (exit_sig == 0 && exit_code == 127) + shell_function_completed = -1; + else + shell_function_completed = 1; + break; + } + + child_failed = exit_sig != 0 || exit_code != 0; + + /* Search for a child matching the deceased one. */ + lastc = 0; + for (c = children; c != 0; lastc = c, c = c->next) + if (c->remote == remote && c->pid == pid) + break; + + if (c == 0) + /* An unknown child died. + Ignore it; it was inherited from our invoker. */ + continue; + + DB (DB_JOBS, (child_failed + ? _("Reaping losing child 0x%08lx PID %ld %s\n") + : _("Reaping winning child 0x%08lx PID %ld %s\n"), + (unsigned long int) c, (long) c->pid, + c->remote ? _(" (remote)") : "")); + + if (c->sh_batch_file) { + DB (DB_JOBS, (_("Cleaning up temp batch file %s\n"), + c->sh_batch_file)); + + /* just try and remove, don't care if this fails */ + remove (c->sh_batch_file); + + /* all done with memory */ + free (c->sh_batch_file); + c->sh_batch_file = NULL; + } + + /* If this child had the good stdin, say it is now free. */ + if (c->good_stdin) + good_stdin_used = 0; + + if (child_failed && !c->noerror && !ignore_errors_flag) + { + /* The commands failed. Write an error message, + delete non-precious targets, and abort. */ + static int delete_on_error = -1; + child_error (c->file->name, exit_code, exit_sig, coredump, 0); + c->file->update_status = 2; + if (delete_on_error == -1) + { + struct file *f = lookup_file (".DELETE_ON_ERROR"); + delete_on_error = f != 0 && f->is_target; + } + if (exit_sig != 0 || delete_on_error) + delete_child_targets (c); + } + else + { + if (child_failed) + { + /* The commands failed, but we don't care. */ + child_error (c->file->name, + exit_code, exit_sig, coredump, 1); + child_failed = 0; + } + + /* If there are more commands to run, try to start them. */ + if (job_next_command (c)) + { + if (handling_fatal_signal) + { + /* Never start new commands while we are dying. + Since there are more commands that wanted to be run, + the target was not completely remade. So we treat + this as if a command had failed. */ + c->file->update_status = 2; + } + else + { + /* Check again whether to start remotely. + Whether or not we want to changes over time. + Also, start_remote_job may need state set up + by start_remote_job_p. */ + c->remote = start_remote_job_p (0); + start_job_command (c); + /* Fatal signals are left blocked in case we were + about to put that child on the chain. But it is + already there, so it is safe for a fatal signal to + arrive now; it will clean up this child's targets. */ + unblock_sigs (); + if (c->file->command_state == cs_running) + /* We successfully started the new command. + Loop to reap more children. */ + continue; + } + + if (c->file->update_status != 0) + /* We failed to start the commands. */ + delete_child_targets (c); + } + else + /* There are no more commands. We got through them all + without an unignored error. Now the target has been + successfully updated. */ + c->file->update_status = 0; + } + + /* When we get here, all the commands for C->file are finished + (or aborted) and C->file->update_status contains 0 or 2. But + C->file->command_state is still cs_running if all the commands + ran; notice_finish_file looks for cs_running to tell it that + it's interesting to check the file's modtime again now. */ + + if (! handling_fatal_signal) + /* Notice if the target of the commands has been changed. + This also propagates its values for command_state and + update_status to its also_make files. */ + notice_finished_file (c->file); + + DB (DB_JOBS, (_("Removing child 0x%08lx PID %ld%s from chain.\n"), + (unsigned long int) c, (long) c->pid, + c->remote ? _(" (remote)") : "")); + + /* Block fatal signals while frobnicating the list, so that + children and job_slots_used are always consistent. Otherwise + a fatal signal arriving after the child is off the chain and + before job_slots_used is decremented would believe a child was + live and call reap_children again. */ + block_sigs (); + + /* There is now another slot open. */ + if (job_slots_used > 0) + --job_slots_used; + + /* Remove the child from the chain and free it. */ + if (lastc == 0) + children = c->next; + else + lastc->next = c->next; + + free_child (c); + + unblock_sigs (); + + /* If the job failed, and the -k flag was not given, die, + unless we are already in the process of dying. */ + if (!err && child_failed && !keep_going_flag && + /* fatal_error_signal will die with the right signal. */ + !handling_fatal_signal) + die (2); + + /* Only block for one child. */ + block = 0; + } + + return; +} + +/* Free the storage allocated for CHILD. */ + +static void +free_child (child) + register struct child *child; +{ + /* If this child is the only one it was our "free" job, so don't put a + token back for it. This child has already been removed from the list, + so if there any left this wasn't the last one. */ + + if (job_fds[1] >= 0 && children) + { + char token = '+'; + + /* Write a job token back to the pipe. */ + + if (write (job_fds[1], &token, 1) != 1) + pfatal_with_name (_("write jobserver")); + + DB (DB_JOBS, (_("Released token for child 0x%08lx (%s).\n"), + (unsigned long int) child, child->file->name)); + } + + if (handling_fatal_signal) /* Don't bother free'ing if about to die. */ + return; + + if (child->command_lines != 0) + { + register unsigned int i; + for (i = 0; i < child->file->cmds->ncommand_lines; ++i) + free (child->command_lines[i]); + free ((char *) child->command_lines); + } + + if (child->environment != 0) + { + register char **ep = child->environment; + while (*ep != 0) + free (*ep++); + free ((char *) child->environment); + } + + free ((char *) child); +} + +#ifdef POSIX +extern sigset_t fatal_signal_set; +#endif + +void +block_sigs () +{ +#ifdef POSIX + (void) sigprocmask (SIG_BLOCK, &fatal_signal_set, (sigset_t *) 0); +#else +# ifdef HAVE_SIGSETMASK + (void) sigblock (fatal_signal_mask); +# endif +#endif +} + +#ifdef POSIX +void +unblock_sigs () +{ + sigset_t empty; + sigemptyset (&empty); + sigprocmask (SIG_SETMASK, &empty, (sigset_t *) 0); +} +#endif + +#ifdef MAKE_JOBSERVER +/* Set the child handler action flags to FLAGS. */ +static void +set_child_handler_action_flags (flags) + int flags; +{ + struct sigaction sa; + bzero ((char *) &sa, sizeof sa); + sa.sa_handler = child_handler; + sa.sa_flags = flags; +#if defined SIGCHLD + sigaction (SIGCHLD, &sa, NULL); +#endif +#if defined SIGCLD && SIGCLD != SIGCHLD + sigaction (SIGCLD, &sa, NULL); +#endif +} +#endif + + +/* Start a job to run the commands specified in CHILD. + CHILD is updated to reflect the commands and ID of the child process. + + NOTE: On return fatal signals are blocked! The caller is responsible + for calling `unblock_sigs', once the new child is safely on the chain so + it can be cleaned up in the event of a fatal signal. */ + +static void +start_job_command (child) + register struct child *child; +{ +#ifndef _AMIGA + static int bad_stdin = -1; +#endif + register char *p; + int flags; +#ifdef VMS + char *argv; +#else + char **argv; +#endif + + /* If we have a completely empty commandset, stop now. */ + if (!child->command_ptr) + goto next_command; + + /* Combine the flags parsed for the line itself with + the flags specified globally for this target. */ + flags = (child->file->command_flags + | child->file->cmds->lines_flags[child->command_line - 1]); + + p = child->command_ptr; + child->noerror = flags & COMMANDS_NOERROR; + + while (*p != '\0') + { + if (*p == '@') + flags |= COMMANDS_SILENT; + else if (*p == '+') + flags |= COMMANDS_RECURSE; + else if (*p == '-') + child->noerror = 1; + else if (!isblank ((unsigned char)*p)) + break; + ++p; + } + + /* Update the file's command flags with any new ones we found. We only + keep the COMMANDS_RECURSE setting. Even this isn't 100% correct; we are + now marking more commands recursive than should be in the case of + multiline define/endef scripts where only one line is marked "+". In + order to really fix this, we'll have to keep a lines_flags for every + actual line, after expansion. */ + child->file->cmds->lines_flags[child->command_line - 1] + |= flags & COMMANDS_RECURSE; + + /* Figure out an argument list from this command line. */ + + { + char *end = 0; +#ifdef VMS + argv = p; +#else + argv = construct_command_argv (p, &end, child->file, &child->sh_batch_file); +#endif + if (end == NULL) + child->command_ptr = NULL; + else + { + *end++ = '\0'; + child->command_ptr = end; + } + } + + /* If -q was given, say that updating `failed' if there was any text on the + command line, or `succeeded' otherwise. The exit status of 1 tells the + user that -q is saying `something to do'; the exit status for a random + error is 2. */ + if (argv != 0 && question_flag && !(flags & COMMANDS_RECURSE)) + { +#ifndef VMS + free (argv[0]); + free ((char *) argv); +#endif + child->file->update_status = 1; + notice_finished_file (child->file); + return; + } + + if (touch_flag && !(flags & COMMANDS_RECURSE)) + { + /* Go on to the next command. It might be the recursive one. + We construct ARGV only to find the end of the command line. */ +#ifndef VMS + if (argv) + { + free (argv[0]); + free ((char *) argv); + } +#endif + argv = 0; + } + + if (argv == 0) + { + next_command: +#ifdef __MSDOS__ + execute_by_shell = 0; /* in case construct_command_argv sets it */ +#endif + /* This line has no commands. Go to the next. */ + if (job_next_command (child)) + start_job_command (child); + else + { + /* No more commands. Make sure we're "running"; we might not be if + (e.g.) all commands were skipped due to -n. */ + set_command_state (child->file, cs_running); + child->file->update_status = 0; + notice_finished_file (child->file); + } + return; + } + + /* Print out the command. If silent, we call `message' with null so it + can log the working directory before the command's own error messages + appear. */ + + message (0, (just_print_flag || (!(flags & COMMANDS_SILENT) && !silent_flag)) + ? "%s" : (char *) 0, p); + + /* Tell update_goal_chain that a command has been started on behalf of + this target. It is important that this happens here and not in + reap_children (where we used to do it), because reap_children might be + reaping children from a different target. We want this increment to + guaranteedly indicate that a command was started for the dependency + chain (i.e., update_file recursion chain) we are processing. */ + + ++commands_started; + + /* Optimize an empty command. People use this for timestamp rules, + so avoid forking a useless shell. Do this after we increment + commands_started so make still treats this special case as if it + performed some action (makes a difference as to what messages are + printed, etc. */ + +#if !defined(VMS) && !defined(_AMIGA) + if ( +#ifdef __MSDOS__ + unixy_shell /* the test is complicated and we already did it */ +#else + (argv[0] && !strcmp (argv[0], "/bin/sh")) +#endif + && (argv[1] + && argv[1][0] == '-' && argv[1][1] == 'c' && argv[1][2] == '\0') + && (argv[2] && argv[2][0] == ':' && argv[2][1] == '\0') + && argv[3] == NULL) + { + free (argv[0]); + free ((char *) argv); + goto next_command; + } +#endif /* !VMS && !_AMIGA */ + + /* If -n was given, recurse to get the next line in the sequence. */ + + if (just_print_flag && !(flags & COMMANDS_RECURSE)) + { +#ifndef VMS + free (argv[0]); + free ((char *) argv); +#endif + goto next_command; + } + + /* Flush the output streams so they won't have things written twice. */ + + fflush (stdout); + fflush (stderr); + +#ifndef VMS +#if !defined(WINDOWS32) && !defined(_AMIGA) && !defined(__MSDOS__) + + /* Set up a bad standard input that reads from a broken pipe. */ + + if (bad_stdin == -1) + { + /* Make a file descriptor that is the read end of a broken pipe. + This will be used for some children's standard inputs. */ + int pd[2]; + if (pipe (pd) == 0) + { + /* Close the write side. */ + (void) close (pd[1]); + /* Save the read side. */ + bad_stdin = pd[0]; + + /* Set the descriptor to close on exec, so it does not litter any + child's descriptor table. When it is dup2'd onto descriptor 0, + that descriptor will not close on exec. */ + CLOSE_ON_EXEC (bad_stdin); + } + } + +#endif /* !WINDOWS32 && !_AMIGA && !__MSDOS__ */ + + /* Decide whether to give this child the `good' standard input + (one that points to the terminal or whatever), or the `bad' one + that points to the read side of a broken pipe. */ + + child->good_stdin = !good_stdin_used; + if (child->good_stdin) + good_stdin_used = 1; + +#endif /* !VMS */ + + child->deleted = 0; + +#ifndef _AMIGA + /* Set up the environment for the child. */ + if (child->environment == 0) + child->environment = target_environment (child->file); +#endif + +#if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32) + +#ifndef VMS + /* start_waiting_job has set CHILD->remote if we can start a remote job. */ + if (child->remote) + { + int is_remote, id, used_stdin; + if (start_remote_job (argv, child->environment, + child->good_stdin ? 0 : bad_stdin, + &is_remote, &id, &used_stdin)) + /* Don't give up; remote execution may fail for various reasons. If + so, simply run the job locally. */ + goto run_local; + else + { + if (child->good_stdin && !used_stdin) + { + child->good_stdin = 0; + good_stdin_used = 0; + } + child->remote = is_remote; + child->pid = id; + } + } + else +#endif /* !VMS */ + { + /* Fork the child process. */ + + char **parent_environ; + + run_local: + block_sigs (); + + child->remote = 0; + +#ifdef VMS + + if (!child_execute_job (argv, child)) { + /* Fork failed! */ + perror_with_name ("vfork", ""); + goto error; + } + +#else + + parent_environ = environ; + child->pid = vfork (); + environ = parent_environ; /* Restore value child may have clobbered. */ + if (child->pid == 0) + { + /* We are the child side. */ + unblock_sigs (); + + /* If we aren't running a recursive command and we have a jobserver + pipe, close it before exec'ing. */ + if (!(flags & COMMANDS_RECURSE) && job_fds[0] >= 0) + { + close (job_fds[0]); + close (job_fds[1]); + } + if (job_rfd >= 0) + close (job_rfd); + + child_execute_job (child->good_stdin ? 0 : bad_stdin, 1, + argv, child->environment); + } + else if (child->pid < 0) + { + /* Fork failed! */ + unblock_sigs (); + perror_with_name ("vfork", ""); + goto error; + } +#endif /* !VMS */ + } + +#else /* __MSDOS__ or Amiga or WINDOWS32 */ +#ifdef __MSDOS__ + { + int proc_return; + + block_sigs (); + dos_status = 0; + + /* We call `system' to do the job of the SHELL, since stock DOS + shell is too dumb. Our `system' knows how to handle long + command lines even if pipes/redirection is needed; it will only + call COMMAND.COM when its internal commands are used. */ + if (execute_by_shell) + { + char *cmdline = argv[0]; + /* We don't have a way to pass environment to `system', + so we need to save and restore ours, sigh... */ + char **parent_environ = environ; + + environ = child->environment; + + /* If we have a *real* shell, tell `system' to call + it to do everything for us. */ + if (unixy_shell) + { + /* A *real* shell on MSDOS may not support long + command lines the DJGPP way, so we must use `system'. */ + cmdline = argv[2]; /* get past "shell -c" */ + } + + dos_command_running = 1; + proc_return = system (cmdline); + environ = parent_environ; + execute_by_shell = 0; /* for the next time */ + } + else + { + dos_command_running = 1; + proc_return = spawnvpe (P_WAIT, argv[0], argv, child->environment); + } + + /* Need to unblock signals before turning off + dos_command_running, so that child's signals + will be treated as such (see fatal_error_signal). */ + unblock_sigs (); + dos_command_running = 0; + + /* If the child got a signal, dos_status has its + high 8 bits set, so be careful not to alter them. */ + if (proc_return == -1) + dos_status |= 0xff; + else + dos_status |= (proc_return & 0xff); + ++dead_children; + child->pid = dos_pid++; + } +#endif /* __MSDOS__ */ +#ifdef _AMIGA + amiga_status = MyExecute (argv); + + ++dead_children; + child->pid = amiga_pid++; + if (amiga_batch_file) + { + amiga_batch_file = 0; + DeleteFile (amiga_bname); /* Ignore errors. */ + } +#endif /* Amiga */ +#ifdef WINDOWS32 + { + HANDLE hPID; + char* arg0; + + /* make UNC paths safe for CreateProcess -- backslash format */ + arg0 = argv[0]; + if (arg0 && arg0[0] == '/' && arg0[1] == '/') + for ( ; arg0 && *arg0; arg0++) + if (*arg0 == '/') + *arg0 = '\\'; + + /* make sure CreateProcess() has Path it needs */ + sync_Path_environment(); + + hPID = process_easy(argv, child->environment); + + if (hPID != INVALID_HANDLE_VALUE) + child->pid = (int) hPID; + else { + int i; + unblock_sigs(); + fprintf(stderr, + _("process_easy() failed failed to launch process (e=%d)\n"), + process_last_err(hPID)); + for (i = 0; argv[i]; i++) + fprintf(stderr, "%s ", argv[i]); + fprintf(stderr, _("\nCounted %d args in failed launch\n"), i); + } + } +#endif /* WINDOWS32 */ +#endif /* __MSDOS__ or Amiga or WINDOWS32 */ + + /* We are the parent side. Set the state to + say the commands are running and return. */ + + set_command_state (child->file, cs_running); + + /* Free the storage used by the child's argument list. */ +#ifndef VMS + free (argv[0]); + free ((char *) argv); +#endif + + return; + + error: + child->file->update_status = 2; + notice_finished_file (child->file); + return; +} + +/* Try to start a child running. + Returns nonzero if the child was started (and maybe finished), or zero if + the load was too high and the child was put on the `waiting_jobs' chain. */ + +static int +start_waiting_job (c) + struct child *c; +{ + struct file *f = c->file; + + /* If we can start a job remotely, we always want to, and don't care about + the local load average. We record that the job should be started + remotely in C->remote for start_job_command to test. */ + + c->remote = start_remote_job_p (1); + + /* If we are running at least one job already and the load average + is too high, make this one wait. */ + if (!c->remote && job_slots_used > 0 && load_too_high ()) + { + /* Put this child on the chain of children waiting for the load average + to go down. */ + set_command_state (f, cs_running); + c->next = waiting_jobs; + waiting_jobs = c; + return 0; + } + + /* Start the first command; reap_children will run later command lines. */ + start_job_command (c); + + switch (f->command_state) + { + case cs_running: + c->next = children; + DB (DB_JOBS, (_("Putting child 0x%08lx (%s) PID %ld%s on the chain.\n"), + (unsigned long int) c, c->file->name, + (long) c->pid, c->remote ? _(" (remote)") : "")); + children = c; + /* One more job slot is in use. */ + ++job_slots_used; + unblock_sigs (); + break; + + case cs_not_started: + /* All the command lines turned out to be empty. */ + f->update_status = 0; + /* FALLTHROUGH */ + + case cs_finished: + notice_finished_file (f); + free_child (c); + break; + + default: + assert (f->command_state == cs_finished); + break; + } + + return 1; +} + +/* Create a `struct child' for FILE and start its commands running. */ + +void +new_job (file) + register struct file *file; +{ + register struct commands *cmds = file->cmds; + register struct child *c; + char **lines; + register unsigned int i; + + /* Let any previously decided-upon jobs that are waiting + for the load to go down start before this new one. */ + start_waiting_jobs (); + + /* Reap any children that might have finished recently. */ + reap_children (0, 0); + + /* Chop the commands up into lines if they aren't already. */ + chop_commands (cmds); + + /* Expand the command lines and store the results in LINES. */ + lines = (char **) xmalloc (cmds->ncommand_lines * sizeof (char *)); + for (i = 0; i < cmds->ncommand_lines; ++i) + { + /* Collapse backslash-newline combinations that are inside variable + or function references. These are left alone by the parser so + that they will appear in the echoing of commands (where they look + nice); and collapsed by construct_command_argv when it tokenizes. + But letting them survive inside function invocations loses because + we don't want the functions to see them as part of the text. */ + + char *in, *out, *ref; + + /* IN points to where in the line we are scanning. + OUT points to where in the line we are writing. + When we collapse a backslash-newline combination, + IN gets ahead of OUT. */ + + in = out = cmds->command_lines[i]; + while ((ref = strchr (in, '$')) != 0) + { + ++ref; /* Move past the $. */ + + if (out != in) + /* Copy the text between the end of the last chunk + we processed (where IN points) and the new chunk + we are about to process (where REF points). */ + bcopy (in, out, ref - in); + + /* Move both pointers past the boring stuff. */ + out += ref - in; + in = ref; + + if (*ref == '(' || *ref == '{') + { + char openparen = *ref; + char closeparen = openparen == '(' ? ')' : '}'; + int count; + char *p; + + *out++ = *in++; /* Copy OPENPAREN. */ + /* IN now points past the opening paren or brace. + Count parens or braces until it is matched. */ + count = 0; + while (*in != '\0') + { + if (*in == closeparen && --count < 0) + break; + else if (*in == '\\' && in[1] == '\n') + { + /* We have found a backslash-newline inside a + variable or function reference. Eat it and + any following whitespace. */ + + int quoted = 0; + for (p = in - 1; p > ref && *p == '\\'; --p) + quoted = !quoted; + + if (quoted) + /* There were two or more backslashes, so this is + not really a continuation line. We don't collapse + the quoting backslashes here as is done in + collapse_continuations, because the line will + be collapsed again after expansion. */ + *out++ = *in++; + else + { + /* Skip the backslash, newline and + any following whitespace. */ + in = next_token (in + 2); + + /* Discard any preceding whitespace that has + already been written to the output. */ + while (out > ref + && isblank ((unsigned char)out[-1])) + --out; + + /* Replace it all with a single space. */ + *out++ = ' '; + } + } + else + { + if (*in == openparen) + ++count; + + *out++ = *in++; + } + } + } + } + + /* There are no more references in this line to worry about. + Copy the remaining uninteresting text to the output. */ + if (out != in) + strcpy (out, in); + + /* Finally, expand the line. */ + lines[i] = allocated_variable_expand_for_file (cmds->command_lines[i], + file); + } + + /* Start the command sequence, record it in a new + `struct child', and add that to the chain. */ + + c = (struct child *) xmalloc (sizeof (struct child)); + bzero ((char *)c, sizeof (struct child)); + c->file = file; + c->command_lines = lines; + c->sh_batch_file = NULL; + + /* Fetch the first command line to be run. */ + job_next_command (c); + + /* Wait for a job slot to be freed up. If we allow an infinite number + don't bother; also job_slots will == 0 if we're using the jobserver. */ + + if (job_slots != 0) + while (job_slots_used == job_slots) + reap_children (1, 0); + +#ifdef MAKE_JOBSERVER + /* If we are controlling multiple jobs make sure we have a token before + starting the child. */ + + /* This can be inefficient. There's a decent chance that this job won't + actually have to run any subprocesses: the command script may be empty + or otherwise optimized away. It would be nice if we could defer + obtaining a token until just before we need it, in start_job_command. + To do that we'd need to keep track of whether we'd already obtained a + token (since start_job_command is called for each line of the job, not + just once). Also more thought needs to go into the entire algorithm; + this is where the old parallel job code waits, so... */ + + else if (job_fds[0] >= 0) + while (1) + { + char token; + int got_token; + int saved_errno; + + DB (DB_JOBS, ("Need a job token; we %shave children\n", + children ? "" : "don't ")); + + /* If we don't already have a job started, use our "free" token. */ + if (!children) + break; + + /* Read a token. As long as there's no token available we'll block. + We enable interruptible system calls before the read(2) so that if + we get a SIGCHLD while we're waiting, we'll return with EINTR and + we can process the death(s) and return tokens to the free pool. + + Once we return from the read, we immediately reinstate restartable + system calls. This allows us to not worry about checking for + EINTR on all the other system calls in the program. + + There is one other twist: there is a span between the time + reap_children() does its last check for dead children and the time + the read(2) call is entered, below, where if a child dies we won't + notice. This is extremely serious as it could cause us to + deadlock, given the right set of events. + + To avoid this, we do the following: before we reap_children(), we + dup(2) the read FD on the jobserver pipe. The read(2) call below + uses that new FD. In the signal handler, we close that FD. That + way, if a child dies during the section mentioned above, the + read(2) will be invoked with an invalid FD and will return + immediately with EBADF. */ + + /* Make sure we have a dup'd FD. */ + if (job_rfd < 0) + { + DB (DB_JOBS, ("Duplicate the job FD\n")); + job_rfd = dup (job_fds[0]); + } + + /* Reap anything that's currently waiting. */ + reap_children (0, 0); + + /* If our "free" token has become available, use it. */ + if (!children) + break; + + /* Set interruptible system calls, and read() for a job token. */ + set_child_handler_action_flags (0); + got_token = read (job_rfd, &token, 1); + saved_errno = errno; + set_child_handler_action_flags (SA_RESTART); + + /* If we got one, we're done here. */ + if (got_token == 1) + { + DB (DB_JOBS, (_("Obtained token for child 0x%08lx (%s).\n"), + (unsigned long int) c, c->file->name)); + break; + } + + /* If the error _wasn't_ expected (EINTR or EBADF), punt. Otherwise, + go back and reap_children(), and try again. */ + errno = saved_errno; + if (errno != EINTR && errno != EBADF) + pfatal_with_name (_("read jobs pipe")); + if (errno == EBADF) + DB (DB_JOBS, ("Read returned EBADF.\n")); + } +#endif + + /* The job is now primed. Start it running. + (This will notice if there are in fact no commands.) */ + (void) start_waiting_job (c); + + if (job_slots == 1 || not_parallel) + /* Since there is only one job slot, make things run linearly. + Wait for the child to die, setting the state to `cs_finished'. */ + while (file->command_state == cs_running) + reap_children (1, 0); + + return; +} + +/* Move CHILD's pointers to the next command for it to execute. + Returns nonzero if there is another command. */ + +static int +job_next_command (child) + struct child *child; +{ + while (child->command_ptr == 0 || *child->command_ptr == '\0') + { + /* There are no more lines in the expansion of this line. */ + if (child->command_line == child->file->cmds->ncommand_lines) + { + /* There are no more lines to be expanded. */ + child->command_ptr = 0; + return 0; + } + else + /* Get the next line to run. */ + child->command_ptr = child->command_lines[child->command_line++]; + } + return 1; +} + +static int +load_too_high () +{ +#if defined(__MSDOS__) || defined(VMS) || defined(_AMIGA) + return 1; +#else + double load; + + if (max_load_average < 0) + return 0; + + make_access (); + if (getloadavg (&load, 1) != 1) + { + static int lossage = -1; + /* Complain only once for the same error. */ + if (lossage == -1 || errno != lossage) + { + if (errno == 0) + /* An errno value of zero means getloadavg is just unsupported. */ + error (NILF, + _("cannot enforce load limits on this operating system")); + else + perror_with_name (_("cannot enforce load limit: "), "getloadavg"); + } + lossage = errno; + load = 0; + } + user_access (); + + DB (DB_JOBS, ("Current system load = %f (max requested = %f)\n", + load, max_load_average)); + return load >= max_load_average; +#endif +} + +/* Start jobs that are waiting for the load to be lower. */ + +void +start_waiting_jobs () +{ + struct child *job; + + if (waiting_jobs == 0) + return; + + do + { + /* Check for recently deceased descendants. */ + reap_children (0, 0); + + /* Take a job off the waiting list. */ + job = waiting_jobs; + waiting_jobs = job->next; + + /* Try to start that job. We break out of the loop as soon + as start_waiting_job puts one back on the waiting list. */ + } + while (start_waiting_job (job) && waiting_jobs != 0); + + return; +} + +#ifndef WINDOWS32 +#ifdef VMS +#include +#include + +/* This is called as an AST when a child process dies (it won't get + interrupted by anything except a higher level AST). +*/ +int vmsHandleChildTerm(struct child *child) +{ + int status; + register struct child *lastc, *c; + int child_failed; + + vms_jobsefnmask &= ~(1 << (child->efn - 32)); + + lib$free_ef(&child->efn); + + (void) sigblock (fatal_signal_mask); + + child_failed = !(child->cstatus & 1 || ((child->cstatus & 7) == 0)); + + /* Search for a child matching the deceased one. */ + lastc = 0; +#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */ + for (c = children; c != 0 && c != child; lastc = c, c = c->next); +#else + c = child; +#endif + + if (child_failed && !c->noerror && !ignore_errors_flag) + { + /* The commands failed. Write an error message, + delete non-precious targets, and abort. */ + child_error (c->file->name, c->cstatus, 0, 0, 0); + c->file->update_status = 1; + delete_child_targets (c); + } + else + { + if (child_failed) + { + /* The commands failed, but we don't care. */ + child_error (c->file->name, c->cstatus, 0, 0, 1); + child_failed = 0; + } + +#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */ + /* If there are more commands to run, try to start them. */ + start_job (c); + + switch (c->file->command_state) + { + case cs_running: + /* Successfully started. */ + break; + + case cs_finished: + if (c->file->update_status != 0) { + /* We failed to start the commands. */ + delete_child_targets (c); + } + break; + + default: + error (NILF, _("internal error: `%s' command_state"), + c->file->name); + abort (); + break; + } +#endif /* RECURSIVEJOBS */ + } + + /* Set the state flag to say the commands have finished. */ + c->file->command_state = cs_finished; + notice_finished_file (c->file); + +#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */ + /* Remove the child from the chain and free it. */ + if (lastc == 0) + children = c->next; + else + lastc->next = c->next; + free_child (c); +#endif /* RECURSIVEJOBS */ + + /* There is now another slot open. */ + if (job_slots_used > 0) + --job_slots_used; + + /* If the job failed, and the -k flag was not given, die. */ + if (child_failed && !keep_going_flag) + die (EXIT_FAILURE); + + (void) sigsetmask (sigblock (0) & ~(fatal_signal_mask)); + + return 1; +} + +/* VMS: + Spawn a process executing the command in ARGV and return its pid. */ + +#define MAXCMDLEN 200 + +/* local helpers to make ctrl+c and ctrl+y working, see below */ +#include +#include +#include + +static int ctrlMask= LIB$M_CLI_CTRLY; +static int oldCtrlMask; +static int setupYAstTried= 0; +static int pidToAbort= 0; +static int chan= 0; + +static void reEnableAst(void) { + lib$enable_ctrl (&oldCtrlMask,0); +} + +static astHandler (void) { + if (pidToAbort) { + sys$forcex (&pidToAbort, 0, SS$_ABORT); + pidToAbort= 0; + } + kill (getpid(),SIGQUIT); +} + +static void tryToSetupYAst(void) { + $DESCRIPTOR(inputDsc,"SYS$COMMAND"); + int status; + struct { + short int status, count; + int dvi; + } iosb; + + setupYAstTried++; + + if (!chan) { + status= sys$assign(&inputDsc,&chan,0,0); + if (!(status&SS$_NORMAL)) { + lib$signal(status); + return; + } + } + status= sys$qiow (0, chan, IO$_SETMODE|IO$M_CTRLYAST,&iosb,0,0, + astHandler,0,0,0,0,0); + if (status==SS$_ILLIOFUNC) { + sys$dassgn(chan); +#ifdef CTRLY_ENABLED_ANYWAY + fprintf (stderr, + _("-warning, CTRL-Y will leave sub-process(es) around.\n")); +#else + return; +#endif + } + if (status==SS$_NORMAL) + status= iosb.status; + if (!(status&SS$_NORMAL)) { + lib$signal(status); + return; + } + + /* called from AST handler ? */ + if (setupYAstTried>1) + return; + if (atexit(reEnableAst)) + fprintf (stderr, + _("-warning, you may have to re-enable CTRL-Y handling from DCL.\n")); + status= lib$disable_ctrl (&ctrlMask, &oldCtrlMask); + if (!(status&SS$_NORMAL)) { + lib$signal(status); + return; + } +} +int +child_execute_job (argv, child) + char *argv; + struct child *child; +{ + int i; + static struct dsc$descriptor_s cmddsc; + static struct dsc$descriptor_s pnamedsc; + static struct dsc$descriptor_s ifiledsc; + static struct dsc$descriptor_s ofiledsc; + static struct dsc$descriptor_s efiledsc; + int have_redirection = 0; + int have_newline = 0; + + int spflags = CLI$M_NOWAIT; + int status; + char *cmd = alloca (strlen (argv) + 512), *p, *q; + char ifile[256], ofile[256], efile[256]; + char *comname = 0; + char procname[100]; + + /* Parse IO redirection. */ + + ifile[0] = 0; + ofile[0] = 0; + efile[0] = 0; + + DB (DB_JOBS, ("child_execute_job (%s)\n", argv)); + + while (isspace ((unsigned char)*argv)) + argv++; + + if (*argv == 0) + return 0; + + sprintf (procname, "GMAKE_%05x", getpid () & 0xfffff); + pnamedsc.dsc$w_length = strlen(procname); + pnamedsc.dsc$a_pointer = procname; + pnamedsc.dsc$b_dtype = DSC$K_DTYPE_T; + pnamedsc.dsc$b_class = DSC$K_CLASS_S; + + /* Handle comments and redirection. */ + for (p = argv, q = cmd; *p; p++, q++) + { + switch (*p) + { + case '#': + *p-- = 0; + *q-- = 0; + break; + case '\\': + p++; + if (*p == '\n') + p++; + if (isspace ((unsigned char)*p)) + { + do { p++; } while (isspace ((unsigned char)*p)); + p--; + } + *q = *p; + break; + case '<': + p = vms_redirect (&ifiledsc, ifile, p); + *q = ' '; + have_redirection = 1; + break; + case '>': + have_redirection = 1; + if (*(p-1) == '2') + { + q--; + if (strncmp (p, ">&1", 3) == 0) + { + p += 3; + strcpy (efile, "sys$output"); + efiledsc.dsc$w_length = strlen(efile); + efiledsc.dsc$a_pointer = efile; + efiledsc.dsc$b_dtype = DSC$K_DTYPE_T; + efiledsc.dsc$b_class = DSC$K_CLASS_S; + } + else + { + p = vms_redirect (&efiledsc, efile, p); + } + } + else + { + p = vms_redirect (&ofiledsc, ofile, p); + } + *q = ' '; + break; + case '\n': + have_newline = 1; + default: + *q = *p; + break; + } + } + *q = *p; + + if (strncmp (cmd, "builtin_", 8) == 0) + { + child->pid = 270163; + child->efn = 0; + child->cstatus = 1; + + DB (DB_JOBS, (_("BUILTIN [%s][%s]\n"), cmd, cmd+8)); + + p = cmd + 8; + + if ((*(p) == 'c') + && (*(p+1) == 'd') + && ((*(p+2) == ' ') || (*(p+2) == '\t'))) + { + p += 3; + while ((*p == ' ') || (*p == '\t')) + p++; + DB (DB_JOBS, (_("BUILTIN CD %s\n"), p)); + if (chdir (p)) + return 0; + else + return 1; + } + else if ((*(p) == 'r') + && (*(p+1) == 'm') + && ((*(p+2) == ' ') || (*(p+2) == '\t'))) + { + int in_arg; + + /* rm */ + p += 3; + while ((*p == ' ') || (*p == '\t')) + p++; + in_arg = 1; + + DB (DB_JOBS, (_("BUILTIN RM %s\n"), p)); + while (*p) + { + switch (*p) + { + case ' ': + case '\t': + if (in_arg) + { + *p++ = ';'; + in_arg = 0; + } + break; + default: + break; + } + p++; + } + } + else + { + printf(_("Unknown builtin command '%s'\n"), cmd); + fflush(stdout); + return 0; + } + } + + /* Create a *.com file if either the command is too long for + lib$spawn, or the command contains a newline, or if redirection + is desired. Forcing commands with newlines into DCLs allows to + store search lists on user mode logicals. */ + + if (strlen (cmd) > MAXCMDLEN + || (have_redirection != 0) + || (have_newline != 0)) + { + FILE *outfile; + char c; + char *sep; + int alevel = 0; /* apostrophe level */ + + if (strlen (cmd) == 0) + { + printf (_("Error, empty command\n")); + fflush (stdout); + return 0; + } + + outfile = open_tmpfile (&comname, "sys$scratch:CMDXXXXXX.COM"); + if (outfile == 0) + pfatal_with_name (_("fopen (temporary file)")); + + if (ifile[0]) + { + fprintf (outfile, "$ assign/user %s sys$input\n", ifile); + DB (DB_JOBS, (_("Redirected input from %s\n"), ifile)); + ifiledsc.dsc$w_length = 0; + } + + if (efile[0]) + { + fprintf (outfile, "$ define sys$error %s\n", efile); + DB (DB_JOBS, (_("Redirected error to %s\n"), efile)); + efiledsc.dsc$w_length = 0; + } + + if (ofile[0]) + { + fprintf (outfile, "$ define sys$output %s\n", ofile); + DB (DB_JOBS, (_("Redirected output to %s\n"), ofile)); + ofiledsc.dsc$w_length = 0; + } + + p = sep = q = cmd; + for (c = '\n'; c; c = *q++) + { + switch (c) + { + case '\n': + /* At a newline, skip any whitespace around a leading $ + from the command and issue exactly one $ into the DCL. */ + while (isspace ((unsigned char)*p)) + p++; + if (*p == '$') + p++; + while (isspace ((unsigned char)*p)) + p++; + fwrite (p, 1, q - p, outfile); + fputc ('$', outfile); + fputc (' ', outfile); + /* Reset variables. */ + p = sep = q; + break; + + /* Nice places for line breaks are after strings, after + comma or space and before slash. */ + case '"': + q = handle_apos (q + 1); + sep = q; + break; + case ',': + case ' ': + sep = q; + break; + case '/': + case '\0': + sep = q - 1; + break; + default: + break; + } + if (sep - p > 78) + { + /* Enough stuff for a line. */ + fwrite (p, 1, sep - p, outfile); + p = sep; + if (*sep) + { + /* The command continues. */ + fputc ('-', outfile); + } + fputc ('\n', outfile); + } + } + + fwrite (p, 1, q - p, outfile); + fputc ('\n', outfile); + + fclose (outfile); + + sprintf (cmd, "$ @%s", comname); + + DB (DB_JOBS, (_("Executing %s instead\n"), cmd)); + } + + cmddsc.dsc$w_length = strlen(cmd); + cmddsc.dsc$a_pointer = cmd; + cmddsc.dsc$b_dtype = DSC$K_DTYPE_T; + cmddsc.dsc$b_class = DSC$K_CLASS_S; + + child->efn = 0; + while (child->efn < 32 || child->efn > 63) + { + status = lib$get_ef ((unsigned long *)&child->efn); + if (!(status & 1)) + return 0; + } + + sys$clref (child->efn); + + vms_jobsefnmask |= (1 << (child->efn - 32)); + +/* + LIB$SPAWN [command-string] + [,input-file] + [,output-file] + [,flags] + [,process-name] + [,process-id] [,completion-status-address] [,byte-integer-event-flag-num] + [,AST-address] [,varying-AST-argument] + [,prompt-string] [,cli] [,table] +*/ + +#ifndef DONTWAITFORCHILD +/* + * Code to make ctrl+c and ctrl+y working. + * The problem starts with the synchronous case where after lib$spawn is + * called any input will go to the child. But with input re-directed, + * both control characters won't make it to any of the programs, neither + * the spawning nor to the spawned one. Hence the caller needs to spawn + * with CLI$M_NOWAIT to NOT give up the input focus. A sys$waitfr + * has to follow to simulate the wanted synchronous behaviour. + * The next problem is ctrl+y which isn't caught by the crtl and + * therefore isn't converted to SIGQUIT (for a signal handler which is + * already established). The only way to catch ctrl+y, is an AST + * assigned to the input channel. But ctrl+y handling of DCL needs to be + * disabled, otherwise it will handle it. Not to mention the previous + * ctrl+y handling of DCL needs to be re-established before make exits. + * One more: At the time of LIB$SPAWN signals are blocked. SIGQUIT will + * make it to the signal handler after the child "normally" terminates. + * This isn't enough. It seems reasonable for simple command lines like + * a 'cc foobar.c' spawned in a subprocess but it is unacceptable for + * spawning make. Therefore we need to abort the process in the AST. + * + * Prior to the spawn it is checked if an AST is already set up for + * ctrl+y, if not one is set up for a channel to SYS$COMMAND. In general + * this will work except if make is run in a batch environment, but there + * nobody can press ctrl+y. During the setup the DCL handling of ctrl+y + * is disabled and an exit handler is established to re-enable it. + * If the user interrupts with ctrl+y, the assigned AST will fire, force + * an abort to the subprocess and signal SIGQUIT, which will be caught by + * the already established handler and will bring us back to common code. + * After the spawn (now /nowait) a sys$waitfr simulates the /wait and + * enables the ctrl+y be delivered to this code. And the ctrl+c too, + * which the crtl converts to SIGINT and which is caught by the common + * signal handler. Because signals were blocked before entering this code + * sys$waitfr will always complete and the SIGQUIT will be processed after + * it (after termination of the current block, somewhere in common code). + * And SIGINT too will be delayed. That is ctrl+c can only abort when the + * current command completes. Anyway it's better than nothing :-) + */ + + if (!setupYAstTried) + tryToSetupYAst(); + status = lib$spawn (&cmddsc, /* cmd-string */ + (ifiledsc.dsc$w_length == 0)?0:&ifiledsc, /* input-file */ + (ofiledsc.dsc$w_length == 0)?0:&ofiledsc, /* output-file */ + &spflags, /* flags */ + &pnamedsc, /* proc name */ + &child->pid, &child->cstatus, &child->efn, + 0, 0, + 0, 0, 0); + pidToAbort= child->pid; + status= sys$waitfr (child->efn); + pidToAbort= 0; + vmsHandleChildTerm(child); +#else + status = lib$spawn (&cmddsc, + (ifiledsc.dsc$w_length == 0)?0:&ifiledsc, + (ofiledsc.dsc$w_length == 0)?0:&ofiledsc, + &spflags, + &pnamedsc, + &child->pid, &child->cstatus, &child->efn, + vmsHandleChildTerm, child, + 0, 0, 0); +#endif + + if (!(status & 1)) + { + printf (_("Error spawning, %d\n") ,status); + fflush (stdout); + } + + if (comname && !ISDB (DB_JOBS)) + unlink (comname); + + return (status & 1); +} + +#else /* !VMS */ + +#if !defined (_AMIGA) && !defined (__MSDOS__) +/* UNIX: + Replace the current process with one executing the command in ARGV. + STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is + the environment of the new program. This function does not return. */ + +void +child_execute_job (stdin_fd, stdout_fd, argv, envp) + int stdin_fd, stdout_fd; + char **argv, **envp; +{ + if (stdin_fd != 0) + (void) dup2 (stdin_fd, 0); + if (stdout_fd != 1) + (void) dup2 (stdout_fd, 1); + if (stdin_fd != 0) + (void) close (stdin_fd); + if (stdout_fd != 1) + (void) close (stdout_fd); + + /* Run the command. */ + exec_command (argv, envp); +} +#endif /* !AMIGA && !__MSDOS__ */ +#endif /* !VMS */ +#endif /* !WINDOWS32 */ + +#ifndef _AMIGA +/* Replace the current process with one running the command in ARGV, + with environment ENVP. This function does not return. */ + +void +exec_command (argv, envp) + char **argv, **envp; +{ +#ifdef VMS + /* to work around a problem with signals and execve: ignore them */ +#ifdef SIGCHLD + signal (SIGCHLD,SIG_IGN); +#endif + /* Run the program. */ + execve (argv[0], argv, envp); + perror_with_name ("execve: ", argv[0]); + _exit (EXIT_FAILURE); +#else +#ifdef WINDOWS32 + HANDLE hPID; + HANDLE hWaitPID; + int err = 0; + int exit_code = EXIT_FAILURE; + + /* make sure CreateProcess() has Path it needs */ + sync_Path_environment(); + + /* launch command */ + hPID = process_easy(argv, envp); + + /* make sure launch ok */ + if (hPID == INVALID_HANDLE_VALUE) + { + int i; + fprintf(stderr, + _("process_easy() failed failed to launch process (e=%d)\n"), + process_last_err(hPID)); + for (i = 0; argv[i]; i++) + fprintf(stderr, "%s ", argv[i]); + fprintf(stderr, _("\nCounted %d args in failed launch\n"), i); + exit(EXIT_FAILURE); + } + + /* wait and reap last child */ + while (hWaitPID = process_wait_for_any()) + { + /* was an error found on this process? */ + err = process_last_err(hWaitPID); + + /* get exit data */ + exit_code = process_exit_code(hWaitPID); + + if (err) + fprintf(stderr, "make (e=%d, rc=%d): %s", + err, exit_code, map_windows32_error_to_string(err)); + + /* cleanup process */ + process_cleanup(hWaitPID); + + /* expect to find only last pid, warn about other pids reaped */ + if (hWaitPID == hPID) + break; + else + fprintf(stderr, + _("make reaped child pid %d, still waiting for pid %d\n"), + hWaitPID, hPID); + } + + /* return child's exit code as our exit code */ + exit(exit_code); + +#else /* !WINDOWS32 */ + + /* Be the user, permanently. */ + child_access (); + + /* Run the program. */ + environ = envp; + execvp (argv[0], argv); + + switch (errno) + { + case ENOENT: + error (NILF, _("%s: Command not found"), argv[0]); + break; + case ENOEXEC: + { + /* The file is not executable. Try it as a shell script. */ + extern char *getenv (); + char *shell; + char **new_argv; + int argc; + + shell = getenv ("SHELL"); + if (shell == 0) + shell = default_shell; + + argc = 1; + while (argv[argc] != 0) + ++argc; + + new_argv = (char **) alloca ((1 + argc + 1) * sizeof (char *)); + new_argv[0] = shell; + new_argv[1] = argv[0]; + while (argc > 0) + { + new_argv[1 + argc] = argv[argc]; + --argc; + } + + execvp (shell, new_argv); + if (errno == ENOENT) + error (NILF, _("%s: Shell program not found"), shell); + else + perror_with_name ("execvp: ", shell); + break; + } + + default: + perror_with_name ("execvp: ", argv[0]); + break; + } + + _exit (127); +#endif /* !WINDOWS32 */ +#endif /* !VMS */ +} +#else /* On Amiga */ +void exec_command (argv) + char **argv; +{ + MyExecute (argv); +} + +void clean_tmp (void) +{ + DeleteFile (amiga_bname); +} + +#endif /* On Amiga */ + +#ifndef VMS +/* Figure out the argument list necessary to run LINE as a command. Try to + avoid using a shell. This routine handles only ' quoting, and " quoting + when no backslash, $ or ` characters are seen in the quotes. Starting + quotes may be escaped with a backslash. If any of the characters in + sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[] + is the first word of a line, the shell is used. + + If RESTP is not NULL, *RESTP is set to point to the first newline in LINE. + If *RESTP is NULL, newlines will be ignored. + + SHELL is the shell to use, or nil to use the default shell. + IFS is the value of $IFS, or nil (meaning the default). */ + +static char ** +construct_command_argv_internal (line, restp, shell, ifs, batch_filename_ptr) + char *line, **restp; + char *shell, *ifs; + char **batch_filename_ptr; +{ +#ifdef __MSDOS__ + /* MSDOS supports both the stock DOS shell and ports of Unixy shells. + We call `system' for anything that requires ``slow'' processing, + because DOS shells are too dumb. When $SHELL points to a real + (unix-style) shell, `system' just calls it to do everything. When + $SHELL points to a DOS shell, `system' does most of the work + internally, calling the shell only for its internal commands. + However, it looks on the $PATH first, so you can e.g. have an + external command named `mkdir'. + + Since we call `system', certain characters and commands below are + actually not specific to COMMAND.COM, but to the DJGPP implementation + of `system'. In particular: + + The shell wildcard characters are in DOS_CHARS because they will + not be expanded if we call the child via `spawnXX'. + + The `;' is in DOS_CHARS, because our `system' knows how to run + multiple commands on a single line. + + DOS_CHARS also include characters special to 4DOS/NDOS, so we + won't have to tell one from another and have one more set of + commands and special characters. */ + static char sh_chars_dos[] = "*?[];|<>%^&()"; + static char *sh_cmds_dos[] = { "break", "call", "cd", "chcp", "chdir", "cls", + "copy", "ctty", "date", "del", "dir", "echo", + "erase", "exit", "for", "goto", "if", "md", + "mkdir", "path", "pause", "prompt", "rd", + "rmdir", "rem", "ren", "rename", "set", + "shift", "time", "type", "ver", "verify", + "vol", ":", 0 }; + + static char sh_chars_sh[] = "#;\"*?[]&|<>(){}$`^"; + static char *sh_cmds_sh[] = { "cd", "echo", "eval", "exec", "exit", "login", + "logout", "set", "umask", "wait", "while", + "for", "case", "if", ":", ".", "break", + "continue", "export", "read", "readonly", + "shift", "times", "trap", "switch", "unset", + 0 }; + + char *sh_chars; + char **sh_cmds; +#else +#ifdef _AMIGA + static char sh_chars[] = "#;\"|<>()?*$`"; + static char *sh_cmds[] = { "cd", "eval", "if", "delete", "echo", "copy", + "rename", "set", "setenv", "date", "makedir", + "skip", "else", "endif", "path", "prompt", + "unset", "unsetenv", "version", + 0 }; +#else +#ifdef WINDOWS32 + static char sh_chars_dos[] = "\"|&<>"; + static char *sh_cmds_dos[] = { "break", "call", "cd", "chcp", "chdir", "cls", + "copy", "ctty", "date", "del", "dir", "echo", + "erase", "exit", "for", "goto", "if", "if", "md", + "mkdir", "path", "pause", "prompt", "rd", "rem", + "ren", "rename", "rmdir", "set", "shift", "time", + "type", "ver", "verify", "vol", ":", 0 }; + static char sh_chars_sh[] = "#;\"*?[]&|<>(){}$`^"; + static char *sh_cmds_sh[] = { "cd", "eval", "exec", "exit", "login", + "logout", "set", "umask", "wait", "while", "for", + "case", "if", ":", ".", "break", "continue", + "export", "read", "readonly", "shift", "times", + "trap", "switch", "test", +#ifdef BATCH_MODE_ONLY_SHELL + "echo", +#endif + 0 }; + char* sh_chars; + char** sh_cmds; +#else /* must be UNIX-ish */ + static char sh_chars[] = "#;\"*?[]&|<>(){}$`^~"; + static char *sh_cmds[] = { "cd", "eval", "exec", "exit", "login", + "logout", "set", "umask", "wait", "while", "for", + "case", "if", ":", ".", "break", "continue", + "export", "read", "readonly", "shift", "times", + "trap", "switch", 0 }; +#endif /* WINDOWS32 */ +#endif /* Amiga */ +#endif /* __MSDOS__ */ + register int i; + register char *p; + register char *ap; + char *end; + int instring, word_has_equals, seen_nonequals, last_argument_was_empty; + char **new_argv = 0; +#ifdef WINDOWS32 + int slow_flag = 0; + + if (no_default_sh_exe) { + sh_cmds = sh_cmds_dos; + sh_chars = sh_chars_dos; + } else { + sh_cmds = sh_cmds_sh; + sh_chars = sh_chars_sh; + } +#endif /* WINDOWS32 */ + + if (restp != NULL) + *restp = NULL; + + /* Make sure not to bother processing an empty line. */ + while (isblank ((unsigned char)*line)) + ++line; + if (*line == '\0') + return 0; + + /* See if it is safe to parse commands internally. */ + if (shell == 0) + shell = default_shell; +#ifdef WINDOWS32 + else if (strcmp (shell, default_shell)) + { + char *s1 = _fullpath(NULL, shell, 0); + char *s2 = _fullpath(NULL, default_shell, 0); + + slow_flag = strcmp((s1 ? s1 : ""), (s2 ? s2 : "")); + + if (s1) + free (s1); + if (s2) + free (s2); + } + if (slow_flag) + goto slow; +#else /* not WINDOWS32 */ +#ifdef __MSDOS__ + else if (stricmp (shell, default_shell)) + { + extern int _is_unixy_shell (const char *_path); + + message (1, _("$SHELL changed (was `%s', now `%s')"), default_shell, shell); + unixy_shell = _is_unixy_shell (shell); + default_shell = shell; + } + if (unixy_shell) + { + sh_chars = sh_chars_sh; + sh_cmds = sh_cmds_sh; + } + else + { + sh_chars = sh_chars_dos; + sh_cmds = sh_cmds_dos; + } +#else /* not __MSDOS__ */ + else if (strcmp (shell, default_shell)) + goto slow; +#endif /* not __MSDOS__ */ +#endif /* not WINDOWS32 */ + + if (ifs != 0) + for (ap = ifs; *ap != '\0'; ++ap) + if (*ap != ' ' && *ap != '\t' && *ap != '\n') + goto slow; + + i = strlen (line) + 1; + + /* More than 1 arg per character is impossible. */ + new_argv = (char **) xmalloc (i * sizeof (char *)); + + /* All the args can fit in a buffer as big as LINE is. */ + ap = new_argv[0] = (char *) xmalloc (i); + end = ap + i; + + /* I is how many complete arguments have been found. */ + i = 0; + instring = word_has_equals = seen_nonequals = last_argument_was_empty = 0; + for (p = line; *p != '\0'; ++p) + { + if (ap > end) + abort (); + + if (instring) + { + string_char: + /* Inside a string, just copy any char except a closing quote + or a backslash-newline combination. */ + if (*p == instring) + { + instring = 0; + if (ap == new_argv[0] || *(ap-1) == '\0') + last_argument_was_empty = 1; + } + else if (*p == '\\' && p[1] == '\n') + goto swallow_escaped_newline; + else if (*p == '\n' && restp != NULL) + { + /* End of the command line. */ + *restp = p; + goto end_of_line; + } + /* Backslash, $, and ` are special inside double quotes. + If we see any of those, punt. + But on MSDOS, if we use COMMAND.COM, double and single + quotes have the same effect. */ + else if (instring == '"' && strchr ("\\$`", *p) != 0 && unixy_shell) + goto slow; + else + *ap++ = *p; + } + else if (strchr (sh_chars, *p) != 0) + /* Not inside a string, but it's a special char. */ + goto slow; +#ifdef __MSDOS__ + else if (*p == '.' && p[1] == '.' && p[2] == '.' && p[3] != '.') + /* `...' is a wildcard in DJGPP. */ + goto slow; +#endif + else + /* Not a special char. */ + switch (*p) + { + case '=': + /* Equals is a special character in leading words before the + first word with no equals sign in it. This is not the case + with sh -k, but we never get here when using nonstandard + shell flags. */ + if (! seen_nonequals && unixy_shell) + goto slow; + word_has_equals = 1; + *ap++ = '='; + break; + + case '\\': + /* Backslash-newline combinations are eaten. */ + if (p[1] == '\n') + { + swallow_escaped_newline: + + /* Eat the backslash, the newline, and following whitespace, + replacing it all with a single space. */ + p += 2; + + /* If there is a tab after a backslash-newline, + remove it from the source line which will be echoed, + since it was most likely used to line + up the continued line with the previous one. */ + if (*p == '\t') + /* Note these overlap and strcpy() is undefined for + overlapping objects in ANSI C. The strlen() _IS_ right, + since we need to copy the nul byte too. */ + bcopy (p + 1, p, strlen (p)); + + if (instring) + goto string_char; + else + { + if (ap != new_argv[i]) + /* Treat this as a space, ending the arg. + But if it's at the beginning of the arg, it should + just get eaten, rather than becoming an empty arg. */ + goto end_of_arg; + else + p = next_token (p) - 1; + } + } + else if (p[1] != '\0') + { +#ifdef HAVE_DOS_PATHS + /* Only remove backslashes before characters special + to Unixy shells. All other backslashes are copied + verbatim, since they are probably DOS-style + directory separators. This still leaves a small + window for problems, but at least it should work + for the vast majority of naive users. */ + +#ifdef __MSDOS__ + /* A dot is only special as part of the "..." + wildcard. */ + if (strneq (p + 1, ".\\.\\.", 5)) + { + *ap++ = '.'; + *ap++ = '.'; + p += 4; + } + else +#endif + if (p[1] != '\\' && p[1] != '\'' + && !isspace ((unsigned char)p[1]) + && (strchr (sh_chars_sh, p[1]) == 0)) + /* back up one notch, to copy the backslash */ + --p; +#endif /* HAVE_DOS_PATHS */ + + /* Copy and skip the following char. */ + *ap++ = *++p; + } + break; + + case '\'': + case '"': + instring = *p; + break; + + case '\n': + if (restp != NULL) + { + /* End of the command line. */ + *restp = p; + goto end_of_line; + } + else + /* Newlines are not special. */ + *ap++ = '\n'; + break; + + case ' ': + case '\t': + end_of_arg: + /* We have the end of an argument. + Terminate the text of the argument. */ + *ap++ = '\0'; + new_argv[++i] = ap; + last_argument_was_empty = 0; + + /* Update SEEN_NONEQUALS, which tells us if every word + heretofore has contained an `='. */ + seen_nonequals |= ! word_has_equals; + if (word_has_equals && ! seen_nonequals) + /* An `=' in a word before the first + word without one is magical. */ + goto slow; + word_has_equals = 0; /* Prepare for the next word. */ + + /* If this argument is the command name, + see if it is a built-in shell command. + If so, have the shell handle it. */ + if (i == 1) + { + register int j; + for (j = 0; sh_cmds[j] != 0; ++j) + if (streq (sh_cmds[j], new_argv[0])) + goto slow; + } + + /* Ignore multiple whitespace chars. */ + p = next_token (p); + /* Next iteration should examine the first nonwhite char. */ + --p; + break; + + default: + *ap++ = *p; + break; + } + } + end_of_line: + + if (instring) + /* Let the shell deal with an unterminated quote. */ + goto slow; + + /* Terminate the last argument and the argument list. */ + + *ap = '\0'; + if (new_argv[i][0] != '\0' || last_argument_was_empty) + ++i; + new_argv[i] = 0; + + if (i == 1) + { + register int j; + for (j = 0; sh_cmds[j] != 0; ++j) + if (streq (sh_cmds[j], new_argv[0])) + goto slow; + } + + if (new_argv[0] == 0) + /* Line was empty. */ + return 0; + else + return new_argv; + + slow:; + /* We must use the shell. */ + + if (new_argv != 0) + { + /* Free the old argument list we were working on. */ + free (new_argv[0]); + free ((void *)new_argv); + } + +#ifdef __MSDOS__ + execute_by_shell = 1; /* actually, call `system' if shell isn't unixy */ +#endif + +#ifdef _AMIGA + { + char *ptr; + char *buffer; + char *dptr; + + buffer = (char *)xmalloc (strlen (line)+1); + + ptr = line; + for (dptr=buffer; *ptr; ) + { + if (*ptr == '\\' && ptr[1] == '\n') + ptr += 2; + else if (*ptr == '@') /* Kludge: multiline commands */ + { + ptr += 2; + *dptr++ = '\n'; + } + else + *dptr++ = *ptr++; + } + *dptr = 0; + + new_argv = (char **) xmalloc (2 * sizeof (char *)); + new_argv[0] = buffer; + new_argv[1] = 0; + } +#else /* Not Amiga */ +#ifdef WINDOWS32 + /* + * Not eating this whitespace caused things like + * + * sh -c "\n" + * + * which gave the shell fits. I think we have to eat + * whitespace here, but this code should be considered + * suspicious if things start failing.... + */ + + /* Make sure not to bother processing an empty line. */ + while (isspace ((unsigned char)*line)) + ++line; + if (*line == '\0') + return 0; +#endif /* WINDOWS32 */ + { + /* SHELL may be a multi-word command. Construct a command line + "SHELL -c LINE", with all special chars in LINE escaped. + Then recurse, expanding this command line to get the final + argument list. */ + + unsigned int shell_len = strlen (shell); +#ifndef VMS + static char minus_c[] = " -c "; +#else + static char minus_c[] = ""; +#endif + unsigned int line_len = strlen (line); + + char *new_line = (char *) alloca (shell_len + (sizeof (minus_c) - 1) + + (line_len * 2) + 1); + char *command_ptr = NULL; /* used for batch_mode_shell mode */ + + ap = new_line; + bcopy (shell, ap, shell_len); + ap += shell_len; + bcopy (minus_c, ap, sizeof (minus_c) - 1); + ap += sizeof (minus_c) - 1; + command_ptr = ap; + for (p = line; *p != '\0'; ++p) + { + if (restp != NULL && *p == '\n') + { + *restp = p; + break; + } + else if (*p == '\\' && p[1] == '\n') + { + /* Eat the backslash, the newline, and following whitespace, + replacing it all with a single space (which is escaped + from the shell). */ + p += 2; + + /* If there is a tab after a backslash-newline, + remove it from the source line which will be echoed, + since it was most likely used to line + up the continued line with the previous one. */ + if (*p == '\t') + bcopy (p + 1, p, strlen (p)); + + p = next_token (p); + --p; + if (unixy_shell && !batch_mode_shell) + *ap++ = '\\'; + *ap++ = ' '; + continue; + } + + /* DOS shells don't know about backslash-escaping. */ + if (unixy_shell && !batch_mode_shell && + (*p == '\\' || *p == '\'' || *p == '"' + || isspace ((unsigned char)*p) + || strchr (sh_chars, *p) != 0)) + *ap++ = '\\'; +#ifdef __MSDOS__ + else if (unixy_shell && strneq (p, "...", 3)) + { + /* The case of `...' wildcard again. */ + strcpy (ap, "\\.\\.\\"); + ap += 5; + p += 2; + } +#endif + *ap++ = *p; + } + if (ap == new_line + shell_len + sizeof (minus_c) - 1) + /* Line was empty. */ + return 0; + *ap = '\0'; + +#ifdef WINDOWS32 + /* Some shells do not work well when invoked as 'sh -c xxx' to run a + command line (e.g. Cygnus GNUWIN32 sh.exe on WIN32 systems). In these + cases, run commands via a script file. */ + if ((no_default_sh_exe || batch_mode_shell) && batch_filename_ptr) { + FILE* batch = NULL; + int id = GetCurrentProcessId(); + PATH_VAR(fbuf); + char* fname = NULL; + + /* create a file name */ + sprintf(fbuf, "make%d", id); + fname = tempnam(".", fbuf); + + /* create batch file name */ + *batch_filename_ptr = xmalloc(strlen(fname) + 5); + strcpy(*batch_filename_ptr, fname); + + /* make sure path name is in DOS backslash format */ + if (!unixy_shell) { + fname = *batch_filename_ptr; + for (i = 0; fname[i] != '\0'; ++i) + if (fname[i] == '/') + fname[i] = '\\'; + strcat(*batch_filename_ptr, ".bat"); + } else { + strcat(*batch_filename_ptr, ".sh"); + } + + DB (DB_JOBS, (_("Creating temporary batch file %s\n"), + *batch_filename_ptr)); + + /* create batch file to execute command */ + batch = fopen (*batch_filename_ptr, "w"); + if (!unixy_shell) + fputs ("@echo off\n", batch); + fputs (command_ptr, batch); + fputc ('\n', batch); + fclose (batch); + + /* create argv */ + new_argv = (char **) xmalloc(3 * sizeof (char *)); + if (unixy_shell) { + new_argv[0] = xstrdup (shell); + new_argv[1] = *batch_filename_ptr; /* only argv[0] gets freed later */ + } else { + new_argv[0] = xstrdup (*batch_filename_ptr); + new_argv[1] = NULL; + } + new_argv[2] = NULL; + } else +#endif /* WINDOWS32 */ + if (unixy_shell) + new_argv = construct_command_argv_internal (new_line, (char **) NULL, + (char *) 0, (char *) 0, + (char **) 0); +#ifdef __MSDOS__ + else + { + /* With MSDOS shells, we must construct the command line here + instead of recursively calling ourselves, because we + cannot backslash-escape the special characters (see above). */ + new_argv = (char **) xmalloc (sizeof (char *)); + line_len = strlen (new_line) - shell_len - sizeof (minus_c) + 1; + new_argv[0] = xmalloc (line_len + 1); + strncpy (new_argv[0], + new_line + shell_len + sizeof (minus_c) - 1, line_len); + new_argv[0][line_len] = '\0'; + } +#else + else + fatal (NILF, _("%s (line %d) Bad shell context (!unixy && !batch_mode_shell)\n"), + __FILE__, __LINE__); +#endif + } +#endif /* ! AMIGA */ + + return new_argv; +} +#endif /* !VMS */ + +/* Figure out the argument list necessary to run LINE as a command. Try to + avoid using a shell. This routine handles only ' quoting, and " quoting + when no backslash, $ or ` characters are seen in the quotes. Starting + quotes may be escaped with a backslash. If any of the characters in + sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[] + is the first word of a line, the shell is used. + + If RESTP is not NULL, *RESTP is set to point to the first newline in LINE. + If *RESTP is NULL, newlines will be ignored. + + FILE is the target whose commands these are. It is used for + variable expansion for $(SHELL) and $(IFS). */ + +char ** +construct_command_argv (line, restp, file, batch_filename_ptr) + char *line, **restp; + struct file *file; + char** batch_filename_ptr; +{ + char *shell, *ifs; + char **argv; + +#ifdef VMS + char *cptr; + int argc; + + argc = 0; + cptr = line; + for (;;) + { + while ((*cptr != 0) + && (isspace ((unsigned char)*cptr))) + cptr++; + if (*cptr == 0) + break; + while ((*cptr != 0) + && (!isspace((unsigned char)*cptr))) + cptr++; + argc++; + } + + argv = (char **)malloc (argc * sizeof (char *)); + if (argv == 0) + abort (); + + cptr = line; + argc = 0; + for (;;) + { + while ((*cptr != 0) + && (isspace ((unsigned char)*cptr))) + cptr++; + if (*cptr == 0) + break; + DB (DB_JOBS, ("argv[%d] = [%s]\n", argc, cptr)); + argv[argc++] = cptr; + while ((*cptr != 0) + && (!isspace((unsigned char)*cptr))) + cptr++; + if (*cptr != 0) + *cptr++ = 0; + } +#else + { + /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */ + int save = warn_undefined_variables_flag; + warn_undefined_variables_flag = 0; + + shell = allocated_variable_expand_for_file ("$(SHELL)", file); +#ifdef WINDOWS32 + /* + * Convert to forward slashes so that construct_command_argv_internal() + * is not confused. + */ + if (shell) { + char *p = w32ify(shell, 0); + strcpy(shell, p); + } +#endif + ifs = allocated_variable_expand_for_file ("$(IFS)", file); + + warn_undefined_variables_flag = save; + } + + argv = construct_command_argv_internal (line, restp, shell, ifs, batch_filename_ptr); + + free (shell); + free (ifs); +#endif /* !VMS */ + return argv; +} + +#if !defined(HAVE_DUP2) && !defined(_AMIGA) +int +dup2 (old, new) + int old, new; +{ + int fd; + + (void) close (new); + fd = dup (old); + if (fd != new) + { + (void) close (fd); + errno = EMFILE; + return -1; + } + + return fd; +} +#endif /* !HAPE_DUP2 && !_AMIGA */ diff --git a/flaim/external/w32/make/job.h b/flaim/external/w32/make/job.h new file mode 100644 index 0000000..00e9599 --- /dev/null +++ b/flaim/external/w32/make/job.h @@ -0,0 +1,83 @@ +/* Definitions for managing subprocesses in GNU Make. +Copyright (C) 1992, 1993, 1996, 1999 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#ifndef SEEN_JOB_H +#define SEEN_JOB_H + +/* Structure describing a running or dead child process. */ + +struct child + { + struct child *next; /* Link in the chain. */ + + struct file *file; /* File being remade. */ + + char **environment; /* Environment for commands. */ + + char **command_lines; /* Array of variable-expanded cmd lines. */ + unsigned int command_line; /* Index into above. */ + char *command_ptr; /* Ptr into command_lines[command_line]. */ + + pid_t pid; /* Child process's ID number. */ +#ifdef VMS + int efn; /* Completion event flag number */ + int cstatus; /* Completion status */ +#endif + char *sh_batch_file; /* Script file for shell commands */ + unsigned int remote:1; /* Nonzero if executing remotely. */ + + unsigned int noerror:1; /* Nonzero if commands contained a `-'. */ + + unsigned int good_stdin:1; /* Nonzero if this child has a good stdin. */ + unsigned int deleted:1; /* Nonzero if targets have been deleted. */ + }; + +extern struct child *children; + +extern void new_job PARAMS ((struct file *file)); +extern void reap_children PARAMS ((int block, int err)); +extern void start_waiting_jobs PARAMS ((void)); + +extern char **construct_command_argv PARAMS ((char *line, char **restp, struct file *file, char** batch_file)); +#ifdef VMS +extern int child_execute_job PARAMS ((char *argv, struct child *child)); +#else +extern void child_execute_job PARAMS ((int stdin_fd, int stdout_fd, char **argv, char **envp)); +#endif +#ifdef _AMIGA +extern void exec_command PARAMS ((char **argv)); +#else +extern void exec_command PARAMS ((char **argv, char **envp)); +#endif + +extern unsigned int job_slots_used; + +extern void block_sigs PARAMS ((void)); +#ifdef POSIX +extern void unblock_sigs PARAMS ((void)); +#else +#ifdef HAVE_SIGSETMASK +extern int fatal_signal_mask; +#define unblock_sigs() sigsetmask (0) +#else +#define unblock_sigs() +#endif +#endif + +#endif /* SEEN_JOB_H */ diff --git a/flaim/external/w32/make/main.c b/flaim/external/w32/make/main.c new file mode 100644 index 0000000..a04671d --- /dev/null +++ b/flaim/external/w32/make/main.c @@ -0,0 +1,2813 @@ +/* Argument parsing and main program of GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1994, 1995, 1996, 1997, 1998, 1999, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, +MA 02111-1307, USA. */ + +#include "make.h" +#include "dep.h" +#include "filedef.h" +#include "variable.h" +#include "job.h" +#include "commands.h" +#include "rule.h" +#include "debug.h" +#include "getopt.h" + +#include +#ifdef _AMIGA +# include +# include +#endif +#ifdef WINDOWS32 +#include +#include "pathstuff.h" +#endif +#if defined(MAKE_JOBSERVER) && defined(HAVE_FCNTL_H) +# include +#endif + +#ifdef _AMIGA +int __stack = 20000; /* Make sure we have 20K of stack space */ +#endif + +extern void init_dir PARAMS ((void)); +extern void remote_setup PARAMS ((void)); +extern void remote_cleanup PARAMS ((void)); +extern RETSIGTYPE fatal_error_signal PARAMS ((int sig)); + +extern void print_variable_data_base PARAMS ((void)); +extern void print_dir_data_base PARAMS ((void)); +extern void print_rule_data_base PARAMS ((void)); +extern void print_file_data_base PARAMS ((void)); +extern void print_vpath_data_base PARAMS ((void)); + +#if defined HAVE_WAITPID || defined HAVE_WAIT3 +# define HAVE_WAIT_NOHANG +#endif + +#ifndef HAVE_UNISTD_H +extern int chdir (); +#endif +#ifndef STDC_HEADERS +# ifndef sun /* Sun has an incorrect decl in a header. */ +extern void exit PARAMS ((int)) __attribute__ ((noreturn)); +# endif +extern double atof (); +#endif + +static void print_data_base PARAMS ((void)); +static void print_version PARAMS ((void)); +static void decode_switches PARAMS ((int argc, char **argv, int env)); +static void decode_env_switches PARAMS ((char *envar, unsigned int len)); +static void define_makeflags PARAMS ((int all, int makefile)); +static char *quote_for_env PARAMS ((char *out, char *in)); +static void initialize_global_hash_tables PARAMS ((void)); + + +/* The structure that describes an accepted command switch. */ + +struct command_switch + { + int c; /* The switch character. */ + + enum /* Type of the value. */ + { + flag, /* Turn int flag on. */ + flag_off, /* Turn int flag off. */ + string, /* One string per switch. */ + positive_int, /* A positive integer. */ + floating, /* A floating-point number (double). */ + ignore /* Ignored. */ + } type; + + char *value_ptr; /* Pointer to the value-holding variable. */ + + unsigned int env:1; /* Can come from MAKEFLAGS. */ + unsigned int toenv:1; /* Should be put in MAKEFLAGS. */ + unsigned int no_makefile:1; /* Don't propagate when remaking makefiles. */ + + char *noarg_value; /* Pointer to value used if no argument is given. */ + char *default_value;/* Pointer to default value. */ + + char *long_name; /* Long option name. */ + }; + +/* True if C is a switch value that corresponds to a short option. */ + +#define short_option(c) ((c) <= CHAR_MAX) + +/* The structure used to hold the list of strings given + in command switches of a type that takes string arguments. */ + +struct stringlist + { + char **list; /* Nil-terminated list of strings. */ + unsigned int idx; /* Index into above. */ + unsigned int max; /* Number of pointers allocated. */ + }; + + +/* The recognized command switches. */ + +/* Nonzero means do not print commands to be executed (-s). */ + +int silent_flag; + +/* Nonzero means just touch the files + that would appear to need remaking (-t) */ + +int touch_flag; + +/* Nonzero means just print what commands would need to be executed, + don't actually execute them (-n). */ + +int just_print_flag; + +/* Print debugging info (--debug). */ + +static struct stringlist *db_flags; +static int debug_flag = 0; + +int db_level = 0; + +#ifdef WINDOWS32 +/* Suspend make in main for a short time to allow debugger to attach */ + +int suspend_flag = 0; +#endif + +/* Environment variables override makefile definitions. */ + +int env_overrides = 0; + +/* Nonzero means ignore status codes returned by commands + executed to remake files. Just treat them all as successful (-i). */ + +int ignore_errors_flag = 0; + +/* Nonzero means don't remake anything, just print the data base + that results from reading the makefile (-p). */ + +int print_data_base_flag = 0; + +/* Nonzero means don't remake anything; just return a nonzero status + if the specified targets are not up to date (-q). */ + +int question_flag = 0; + +/* Nonzero means do not use any of the builtin rules (-r) / variables (-R). */ + +int no_builtin_rules_flag = 0; +int no_builtin_variables_flag = 0; + +/* Nonzero means keep going even if remaking some file fails (-k). */ + +int keep_going_flag; +int default_keep_going_flag = 0; + +/* Nonzero means print directory before starting and when done (-w). */ + +int print_directory_flag = 0; + +/* Nonzero means ignore print_directory_flag and never print the directory. + This is necessary because print_directory_flag is set implicitly. */ + +int inhibit_print_directory_flag = 0; + +/* Nonzero means print version information. */ + +int print_version_flag = 0; + +/* List of makefiles given with -f switches. */ + +static struct stringlist *makefiles = 0; + +/* Number of job slots (commands that can be run at once). */ + +unsigned int job_slots = 1; +unsigned int default_job_slots = 1; + +/* Value of job_slots that means no limit. */ + +static unsigned int inf_jobs = 0; + +/* File descriptors for the jobs pipe. */ + +static struct stringlist *jobserver_fds = 0; + +int job_fds[2] = { -1, -1 }; +int job_rfd = -1; + +/* Maximum load average at which multiple jobs will be run. + Negative values mean unlimited, while zero means limit to + zero load (which could be useful to start infinite jobs remotely + but one at a time locally). */ +#ifndef NO_FLOAT +double max_load_average = -1.0; +double default_load_average = -1.0; +#else +int max_load_average = -1; +int default_load_average = -1; +#endif + +/* List of directories given with -C switches. */ + +static struct stringlist *directories = 0; + +/* List of include directories given with -I switches. */ + +static struct stringlist *include_directories = 0; + +/* List of files given with -o switches. */ + +static struct stringlist *old_files = 0; + +/* List of files given with -W switches. */ + +static struct stringlist *new_files = 0; + +/* If nonzero, we should just print usage and exit. */ + +static int print_usage_flag = 0; + +/* If nonzero, we should print a warning message + for each reference to an undefined variable. */ + +int warn_undefined_variables_flag; + +/* If nonzero, always build all targets, regardless of whether + they appear out of date or not. */ + +int always_make_flag = 0; + +/* The usage output. We write it this way to make life easier for the + translators, especially those trying to translate to right-to-left + languages like Hebrew. */ + +static const char *const usage[] = + { + N_("Options:\n"), + N_("\ + -b, -m Ignored for compatibility.\n"), + N_("\ + -B, --always-make Unconditionally make all targets.\n"), + N_("\ + -C DIRECTORY, --directory=DIRECTORY\n\ + Change to DIRECTORY before doing anything.\n"), + N_("\ + -d Print lots of debugging information.\n"), + N_("\ + --debug[=FLAGS] Print various types of debugging information.\n"), + N_("\ + -e, --environment-overrides\n\ + Environment variables override makefiles.\n"), + N_("\ + -f FILE, --file=FILE, --makefile=FILE\n\ + Read FILE as a makefile.\n"), + N_("\ + -h, --help Print this message and exit.\n"), + N_("\ + -i, --ignore-errors Ignore errors from commands.\n"), + N_("\ + -I DIRECTORY, --include-dir=DIRECTORY\n\ + Search DIRECTORY for included makefiles.\n"), + N_("\ + -j [N], --jobs[=N] Allow N jobs at once; infinite jobs with no arg.\n"), + N_("\ + -k, --keep-going Keep going when some targets can't be made.\n"), + N_("\ + -l [N], --load-average[=N], --max-load[=N]\n\ + Don't start multiple jobs unless load is below N.\n"), + N_("\ + -n, --just-print, --dry-run, --recon\n\ + Don't actually run any commands; just print them.\n"), + N_("\ + -o FILE, --old-file=FILE, --assume-old=FILE\n\ + Consider FILE to be very old and don't remake it.\n"), + N_("\ + -p, --print-data-base Print make's internal database.\n"), + N_("\ + -q, --question Run no commands; exit status says if up to date.\n"), + N_("\ + -r, --no-builtin-rules Disable the built-in implicit rules.\n"), + N_("\ + -R, --no-builtin-variables Disable the built-in variable settings.\n"), + N_("\ + -s, --silent, --quiet Don't echo commands.\n"), + N_("\ + -S, --no-keep-going, --stop\n\ + Turns off -k.\n"), + N_("\ + -t, --touch Touch targets instead of remaking them.\n"), + N_("\ + -v, --version Print the version number of make and exit.\n"), + N_("\ + -w, --print-directory Print the current directory.\n"), + N_("\ + --no-print-directory Turn off -w, even if it was turned on implicitly.\n"), + N_("\ + -W FILE, --what-if=FILE, --new-file=FILE, --assume-new=FILE\n\ + Consider FILE to be infinitely new.\n"), + N_("\ + --warn-undefined-variables Warn when an undefined variable is referenced.\n"), + NULL + }; + +/* The table of command switches. */ + +static const struct command_switch switches[] = + { + { 'b', ignore, 0, 0, 0, 0, 0, 0, 0 }, + { 'B', flag, (char *) &always_make_flag, 1, 1, 0, 0, 0, "always-make" }, + { 'C', string, (char *) &directories, 0, 0, 0, 0, 0, "directory" }, + { 'd', flag, (char *) &debug_flag, 1, 1, 0, 0, 0, 0 }, + { CHAR_MAX+1, string, (char *) &db_flags, 1, 1, 0, "basic", 0, "debug" }, +#ifdef WINDOWS32 + { 'D', flag, (char *) &suspend_flag, 1, 1, 0, 0, 0, "suspend-for-debug" }, +#endif + { 'e', flag, (char *) &env_overrides, 1, 1, 0, 0, 0, + "environment-overrides", }, + { 'f', string, (char *) &makefiles, 0, 0, 0, 0, 0, "file" }, + { 'h', flag, (char *) &print_usage_flag, 0, 0, 0, 0, 0, "help" }, + { 'i', flag, (char *) &ignore_errors_flag, 1, 1, 0, 0, 0, + "ignore-errors" }, + { 'I', string, (char *) &include_directories, 1, 1, 0, 0, 0, + "include-dir" }, + { 'j', positive_int, (char *) &job_slots, 1, 1, 0, (char *) &inf_jobs, + (char *) &default_job_slots, "jobs" }, + { CHAR_MAX+2, string, (char *) &jobserver_fds, 1, 1, 0, 0, 0, + "jobserver-fds" }, + { 'k', flag, (char *) &keep_going_flag, 1, 1, 0, 0, + (char *) &default_keep_going_flag, "keep-going" }, +#ifndef NO_FLOAT + { 'l', floating, (char *) &max_load_average, 1, 1, 0, + (char *) &default_load_average, (char *) &default_load_average, + "load-average" }, +#else + { 'l', positive_int, (char *) &max_load_average, 1, 1, 0, + (char *) &default_load_average, (char *) &default_load_average, + "load-average" }, +#endif + { 'm', ignore, 0, 0, 0, 0, 0, 0, 0 }, + { 'n', flag, (char *) &just_print_flag, 1, 1, 1, 0, 0, "just-print" }, + { 'o', string, (char *) &old_files, 0, 0, 0, 0, 0, "old-file" }, + { 'p', flag, (char *) &print_data_base_flag, 1, 1, 0, 0, 0, + "print-data-base" }, + { 'q', flag, (char *) &question_flag, 1, 1, 1, 0, 0, "question" }, + { 'r', flag, (char *) &no_builtin_rules_flag, 1, 1, 0, 0, 0, + "no-builtin-rules" }, + { 'R', flag, (char *) &no_builtin_variables_flag, 1, 1, 0, 0, 0, + "no-builtin-variables" }, + { 's', flag, (char *) &silent_flag, 1, 1, 0, 0, 0, "silent" }, + { 'S', flag_off, (char *) &keep_going_flag, 1, 1, 0, 0, + (char *) &default_keep_going_flag, "no-keep-going" }, + { 't', flag, (char *) &touch_flag, 1, 1, 1, 0, 0, "touch" }, + { 'v', flag, (char *) &print_version_flag, 1, 1, 0, 0, 0, "version" }, + { 'w', flag, (char *) &print_directory_flag, 1, 1, 0, 0, 0, + "print-directory" }, + { CHAR_MAX+3, flag, (char *) &inhibit_print_directory_flag, 1, 1, 0, 0, 0, + "no-print-directory" }, + { 'W', string, (char *) &new_files, 0, 0, 0, 0, 0, "what-if" }, + { CHAR_MAX+4, flag, (char *) &warn_undefined_variables_flag, 1, 1, 0, 0, 0, + "warn-undefined-variables" }, + { '\0', } + }; + +/* Secondary long names for options. */ + +static struct option long_option_aliases[] = + { + { "quiet", no_argument, 0, 's' }, + { "stop", no_argument, 0, 'S' }, + { "new-file", required_argument, 0, 'W' }, + { "assume-new", required_argument, 0, 'W' }, + { "assume-old", required_argument, 0, 'o' }, + { "max-load", optional_argument, 0, 'l' }, + { "dry-run", no_argument, 0, 'n' }, + { "recon", no_argument, 0, 'n' }, + { "makefile", required_argument, 0, 'f' }, + }; + +/* List of goal targets. */ + +static struct dep *goals, *lastgoal; + +/* List of variables which were defined on the command line + (or, equivalently, in MAKEFLAGS). */ + +struct command_variable + { + struct command_variable *next; + struct variable *variable; + }; +static struct command_variable *command_variables; + +/* The name we were invoked with. */ + +char *program; + +/* Our current directory before processing any -C options. */ + +char *directory_before_chdir; + +/* Our current directory after processing all -C options. */ + +char *starting_directory; + +/* Value of the MAKELEVEL variable at startup (or 0). */ + +unsigned int makelevel; + +/* First file defined in the makefile whose name does not + start with `.'. This is the default to remake if the + command line does not specify. */ + +struct file *default_goal_file; + +/* Pointer to structure for the file .DEFAULT + whose commands are used for any file that has none of its own. + This is zero if the makefiles do not define .DEFAULT. */ + +struct file *default_file; + +/* Nonzero if we have seen the magic `.POSIX' target. + This turns on pedantic compliance with POSIX.2. */ + +int posix_pedantic; + +/* Nonzero if we have seen the `.NOTPARALLEL' target. + This turns off parallel builds for this invocation of make. */ + +int not_parallel; + +/* Nonzero if some rule detected clock skew; we keep track so (a) we only + print one warning about it during the run, and (b) we can print a final + warning at the end of the run. */ + +int clock_skew_detected; + +/* Mask of signals that are being caught with fatal_error_signal. */ + +#ifdef POSIX +sigset_t fatal_signal_set; +#else +# ifdef HAVE_SIGSETMASK +int fatal_signal_mask; +# endif +#endif + +#if !defined HAVE_BSD_SIGNAL && !defined bsd_signal +# if !defined HAVE_SIGACTION +# define bsd_signal signal +# else +typedef RETSIGTYPE (*bsd_signal_ret_t) (); + +static bsd_signal_ret_t +bsd_signal (sig, func) + int sig; + bsd_signal_ret_t func; +{ + struct sigaction act, oact; + act.sa_handler = func; + act.sa_flags = SA_RESTART; + sigemptyset (&act.sa_mask); + sigaddset (&act.sa_mask, sig); + if (sigaction (sig, &act, &oact) != 0) + return SIG_ERR; + return oact.sa_handler; +} +# endif +#endif + +static void +initialize_global_hash_tables () +{ + init_hash_global_variable_set (); + init_hash_files (); + hash_init_directories (); + hash_init_function_table (); +} + +static struct file * +enter_command_line_file (name) + char *name; +{ + if (name[0] == '\0') + fatal (NILF, _("empty string invalid as file name")); + + if (name[0] == '~') + { + char *expanded = tilde_expand (name); + if (expanded != 0) + name = expanded; /* Memory leak; I don't care. */ + } + + /* This is also done in parse_file_seq, so this is redundant + for names read from makefiles. It is here for names passed + on the command line. */ + while (name[0] == '.' && name[1] == '/' && name[2] != '\0') + { + name += 2; + while (*name == '/') + /* Skip following slashes: ".//foo" is "foo", not "/foo". */ + ++name; + } + + if (*name == '\0') + { + /* It was all slashes! Move back to the dot and truncate + it after the first slash, so it becomes just "./". */ + do + --name; + while (name[0] != '.'); + name[2] = '\0'; + } + + return enter_file (xstrdup (name)); +} + +/* Toggle -d on receipt of SIGUSR1. */ + +static RETSIGTYPE +debug_signal_handler (sig) + int sig; +{ + db_level = db_level ? DB_NONE : DB_BASIC; +} + +static void +decode_debug_flags () +{ + char **pp; + + if (debug_flag) + db_level = DB_ALL; + + if (!db_flags) + return; + + for (pp=db_flags->list; *pp; ++pp) + { + const char *p = *pp; + + while (1) + { + switch (tolower (p[0])) + { + case 'a': + db_level |= DB_ALL; + break; + case 'b': + db_level |= DB_BASIC; + break; + case 'i': + db_level |= DB_BASIC | DB_IMPLICIT; + break; + case 'j': + db_level |= DB_JOBS; + break; + case 'm': + db_level |= DB_BASIC | DB_MAKEFILES; + break; + case 'v': + db_level |= DB_BASIC | DB_VERBOSE; + break; + default: + fatal (NILF, _("unknown debug level specification `%s'"), p); + } + + while (*(++p) != '\0') + if (*p == ',' || *p == ' ') + break; + + if (*p == '\0') + break; + + ++p; + } + } +} + +#ifdef WINDOWS32 +/* + * HANDLE runtime exceptions by avoiding a requestor on the GUI. Capture + * exception and print it to stderr instead. + * + * If ! DB_VERBOSE, just print a simple message and exit. + * If DB_VERBOSE, print a more verbose message. + * If compiled for DEBUG, let exception pass through to GUI so that + * debuggers can attach. + */ +LONG WINAPI +handle_runtime_exceptions( struct _EXCEPTION_POINTERS *exinfo ) +{ + PEXCEPTION_RECORD exrec = exinfo->ExceptionRecord; + LPSTR cmdline = GetCommandLine(); + LPSTR prg = strtok(cmdline, " "); + CHAR errmsg[1024]; +#ifdef USE_EVENT_LOG + HANDLE hEventSource; + LPTSTR lpszStrings[1]; +#endif + + if (! ISDB (DB_VERBOSE)) + { + sprintf(errmsg, + _("%s: Interrupt/Exception caught (code = 0x%x, addr = 0x%x)\n"), + prg, exrec->ExceptionCode, exrec->ExceptionAddress); + fprintf(stderr, errmsg); + exit(255); + } + + sprintf(errmsg, + _("\nUnhandled exception filter called from program %s\nExceptionCode = %x\nExceptionFlags = %x\nExceptionAddress = %x\n"), + prg, exrec->ExceptionCode, exrec->ExceptionFlags, + exrec->ExceptionAddress); + + if (exrec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION + && exrec->NumberParameters >= 2) + sprintf(&errmsg[strlen(errmsg)], + (exrec->ExceptionInformation[0] + ? _("Access violation: write operation at address %x\n") + : _("Access violation: read operation at address %x\n")), + exrec->ExceptionInformation[1]); + + /* turn this on if we want to put stuff in the event log too */ +#ifdef USE_EVENT_LOG + hEventSource = RegisterEventSource(NULL, "GNU Make"); + lpszStrings[0] = errmsg; + + if (hEventSource != NULL) + { + ReportEvent(hEventSource, /* handle of event source */ + EVENTLOG_ERROR_TYPE, /* event type */ + 0, /* event category */ + 0, /* event ID */ + NULL, /* current user's SID */ + 1, /* strings in lpszStrings */ + 0, /* no bytes of raw data */ + lpszStrings, /* array of error strings */ + NULL); /* no raw data */ + + (VOID) DeregisterEventSource(hEventSource); + } +#endif + + /* Write the error to stderr too */ + fprintf(stderr, errmsg); + +#ifdef DEBUG + return EXCEPTION_CONTINUE_SEARCH; +#else + exit(255); + return (255); /* not reached */ +#endif +} + +/* + * On WIN32 systems we don't have the luxury of a /bin directory that + * is mapped globally to every drive mounted to the system. Since make could + * be invoked from any drive, and we don't want to propogate /bin/sh + * to every single drive. Allow ourselves a chance to search for + * a value for default shell here (if the default path does not exist). + */ + +int +find_and_set_default_shell(char *token) +{ + int sh_found = 0; + char* search_token; + PATH_VAR(sh_path); + extern char *default_shell; + + if (!token) + search_token = default_shell; + else + search_token = token; + + if (!no_default_sh_exe && + (token == NULL || !strcmp(search_token, default_shell))) { + /* no new information, path already set or known */ + sh_found = 1; + } else if (file_exists_p(search_token)) { + /* search token path was found */ + sprintf(sh_path, "%s", search_token); + default_shell = xstrdup(w32ify(sh_path,0)); + DB (DB_VERBOSE, + (_("find_and_set_shell setting default_shell = %s\n"), default_shell)); + sh_found = 1; + } else { + char *p; + struct variable *v = lookup_variable ("Path", 4); + + /* + * Search Path for shell + */ + if (v && v->value) { + char *ep; + + p = v->value; + ep = strchr(p, PATH_SEPARATOR_CHAR); + + while (ep && *ep) { + *ep = '\0'; + + if (dir_file_exists_p(p, search_token)) { + sprintf(sh_path, "%s/%s", p, search_token); + default_shell = xstrdup(w32ify(sh_path,0)); + sh_found = 1; + *ep = PATH_SEPARATOR_CHAR; + + /* terminate loop */ + p += strlen(p); + } else { + *ep = PATH_SEPARATOR_CHAR; + p = ++ep; + } + + ep = strchr(p, PATH_SEPARATOR_CHAR); + } + + /* be sure to check last element of Path */ + if (p && *p && dir_file_exists_p(p, search_token)) { + sprintf(sh_path, "%s/%s", p, search_token); + default_shell = xstrdup(w32ify(sh_path,0)); + sh_found = 1; + } + + if (sh_found) + DB (DB_VERBOSE, + (_("find_and_set_shell path search set default_shell = %s\n"), + default_shell)); + } + } + + /* naive test */ + if (!unixy_shell && sh_found && + (strstr(default_shell, "sh") || strstr(default_shell, "SH"))) { + unixy_shell = 1; + batch_mode_shell = 0; + } + +#ifdef BATCH_MODE_ONLY_SHELL + batch_mode_shell = 1; +#endif + + return (sh_found); +} +#endif /* WINDOWS32 */ + +#ifdef __MSDOS__ + +static void +msdos_return_to_initial_directory () +{ + if (directory_before_chdir) + chdir (directory_before_chdir); +} +#endif + +extern char *mktemp (); +extern int mkstemp (); + +FILE * +open_tmpfile(name, template) + char **name; + const char *template; +{ + int fd; + +#if defined HAVE_MKSTEMP || defined HAVE_MKTEMP +# define TEMPLATE_LEN strlen (template) +#else +# define TEMPLATE_LEN L_tmpnam +#endif + *name = xmalloc (TEMPLATE_LEN + 1); + strcpy (*name, template); + +#if defined HAVE_MKSTEMP && defined HAVE_FDOPEN + /* It's safest to use mkstemp(), if we can. */ + fd = mkstemp (*name); + if (fd == -1) + return 0; + return fdopen (fd, "w"); +#else +# ifdef HAVE_MKTEMP + (void) mktemp (*name); +# else + (void) tmpnam (*name); +# endif + +# ifdef HAVE_FDOPEN + /* Can't use mkstemp(), but guard against a race condition. */ + fd = open (*name, O_CREAT|O_EXCL|O_WRONLY, 0600); + if (fd == -1) + return 0; + return fdopen (fd, "w"); +# else + /* Not secure, but what can we do? */ + return fopen (*name, "w"); +# endif +#endif +} + + +#ifndef _AMIGA +int +main (argc, argv, envp) + int argc; + char **argv; + char **envp; +#else +int main (int argc, char ** argv) +#endif +{ + static char *stdin_nm = 0; + register struct file *f; + register unsigned int i; + char **p; + struct dep *read_makefiles; + PATH_VAR (current_directory); +#ifdef WINDOWS32 + char *unix_path = NULL; + char *windows32_path = NULL; + + SetUnhandledExceptionFilter(handle_runtime_exceptions); + + /* start off assuming we have no shell */ + unixy_shell = 0; + no_default_sh_exe = 1; +#endif + + default_goal_file = 0; + reading_file = 0; + +#if defined (__MSDOS__) && !defined (_POSIX_SOURCE) + /* Request the most powerful version of `system', to + make up for the dumb default shell. */ + __system_flags = (__system_redirect + | __system_use_shell + | __system_allow_multiple_cmds + | __system_allow_long_cmds + | __system_handle_null_commands + | __system_emulate_chdir); + +#endif + + /* Set up gettext/internationalization support. */ + setlocale (LC_ALL, ""); + bindtextdomain (PACKAGE, LOCALEDIR); + textdomain (PACKAGE); + +#ifdef POSIX + sigemptyset (&fatal_signal_set); +#define ADD_SIG(sig) sigaddset (&fatal_signal_set, sig) +#else +#ifdef HAVE_SIGSETMASK + fatal_signal_mask = 0; +#define ADD_SIG(sig) fatal_signal_mask |= sigmask (sig) +#else +#define ADD_SIG(sig) +#endif +#endif + +#define FATAL_SIG(sig) \ + if (bsd_signal (sig, fatal_error_signal) == SIG_IGN) \ + bsd_signal (sig, SIG_IGN); \ + else \ + ADD_SIG (sig); + +#ifdef SIGHUP + FATAL_SIG (SIGHUP); +#endif +#ifdef SIGQUIT + FATAL_SIG (SIGQUIT); +#endif + FATAL_SIG (SIGINT); + FATAL_SIG (SIGTERM); + +#ifdef __MSDOS__ + /* Windows 9X delivers FP exceptions in child programs to their + parent! We don't want Make to die when a child divides by zero, + so we work around that lossage by catching SIGFPE. */ + FATAL_SIG (SIGFPE); +#endif + +#ifdef SIGDANGER + FATAL_SIG (SIGDANGER); +#endif +#ifdef SIGXCPU + FATAL_SIG (SIGXCPU); +#endif +#ifdef SIGXFSZ + FATAL_SIG (SIGXFSZ); +#endif + +#undef FATAL_SIG + + /* Do not ignore the child-death signal. This must be done before + any children could possibly be created; otherwise, the wait + functions won't work on systems with the SVR4 ECHILD brain + damage, if our invoker is ignoring this signal. */ + +#ifdef HAVE_WAIT_NOHANG +# if defined SIGCHLD + (void) bsd_signal (SIGCHLD, SIG_DFL); +# endif +# if defined SIGCLD && SIGCLD != SIGCHLD + (void) bsd_signal (SIGCLD, SIG_DFL); +# endif +#endif + + /* Make sure stdout is line-buffered. */ + +#ifdef HAVE_SETVBUF +# ifdef SETVBUF_REVERSED + setvbuf (stdout, _IOLBF, xmalloc (BUFSIZ), BUFSIZ); +# else /* setvbuf not reversed. */ + /* Some buggy systems lose if we pass 0 instead of allocating ourselves. */ + setvbuf (stdout, (char *) 0, _IOLBF, BUFSIZ); +# endif /* setvbuf reversed. */ +#elif HAVE_SETLINEBUF + setlinebuf (stdout); +#endif /* setlinebuf missing. */ + + /* Figure out where this program lives. */ + + if (argv[0] == 0) + argv[0] = ""; + if (argv[0][0] == '\0') + program = "make"; + else + { +#ifdef VMS + program = strrchr (argv[0], ']'); +#else + program = strrchr (argv[0], '/'); +#endif +#ifdef __MSDOS__ + if (program == 0) + program = strrchr (argv[0], '\\'); + else + { + /* Some weird environments might pass us argv[0] with + both kinds of slashes; we must find the rightmost. */ + char *p = strrchr (argv[0], '\\'); + if (p && p > program) + program = p; + } + if (program == 0 && argv[0][1] == ':') + program = argv[0] + 1; +#endif + if (program == 0) + program = argv[0]; + else + ++program; + } + + /* Set up to access user data (files). */ + user_access (); + + initialize_global_hash_tables (); + + /* Figure out where we are. */ + +#ifdef WINDOWS32 + if (getcwd_fs (current_directory, GET_PATH_MAX) == 0) +#else + if (getcwd (current_directory, GET_PATH_MAX) == 0) +#endif + { +#ifdef HAVE_GETCWD + perror_with_name ("getcwd: ", ""); +#else + error (NILF, "getwd: %s", current_directory); +#endif + current_directory[0] = '\0'; + directory_before_chdir = 0; + } + else + directory_before_chdir = xstrdup (current_directory); +#ifdef __MSDOS__ + /* Make sure we will return to the initial directory, come what may. */ + atexit (msdos_return_to_initial_directory); +#endif + + /* Initialize the special variables. */ + define_variable (".VARIABLES", 10, "", o_default, 0)->special = 1; + /* define_variable (".TARGETS", 8, "", o_default, 0); */ + + /* Read in variables from the environment. It is important that this be + done before $(MAKE) is figured out so its definitions will not be + from the environment. */ + +#ifndef _AMIGA + for (i = 0; envp[i] != 0; ++i) + { + int do_not_define; + register char *ep = envp[i]; + + /* by default, everything gets defined and exported */ + do_not_define = 0; + + while (*ep != '=') + ++ep; +#ifdef WINDOWS32 + if (!unix_path && strneq(envp[i], "PATH=", 5)) + unix_path = ep+1; + else if (!windows32_path && !strnicmp(envp[i], "Path=", 5)) { + do_not_define = 1; /* it gets defined after loop exits */ + windows32_path = ep+1; + } +#endif + /* The result of pointer arithmetic is cast to unsigned int for + machines where ptrdiff_t is a different size that doesn't widen + the same. */ + if (!do_not_define) + define_variable (envp[i], (unsigned int) (ep - envp[i]), + ep + 1, o_env, 1) + /* Force exportation of every variable culled from the environment. + We used to rely on target_environment's v_default code to do this. + But that does not work for the case where an environment variable + is redefined in a makefile with `override'; it should then still + be exported, because it was originally in the environment. */ + ->export = v_export; + } +#ifdef WINDOWS32 + /* + * Make sure that this particular spelling of 'Path' is available + */ + if (windows32_path) + define_variable("Path", 4, windows32_path, o_env, 1)->export = v_export; + else if (unix_path) + define_variable("Path", 4, unix_path, o_env, 1)->export = v_export; + else + define_variable("Path", 4, "", o_env, 1)->export = v_export; + + /* + * PATH defaults to Path iff PATH not found and Path is found. + */ + if (!unix_path && windows32_path) + define_variable("PATH", 4, windows32_path, o_env, 1)->export = v_export; +#endif +#else /* For Amiga, read the ENV: device, ignoring all dirs */ + { + BPTR env, file, old; + char buffer[1024]; + int len; + __aligned struct FileInfoBlock fib; + + env = Lock ("ENV:", ACCESS_READ); + if (env) + { + old = CurrentDir (DupLock(env)); + Examine (env, &fib); + + while (ExNext (env, &fib)) + { + if (fib.fib_DirEntryType < 0) /* File */ + { + /* Define an empty variable. It will be filled in + variable_lookup(). Makes startup quite a bit + faster. */ + define_variable (fib.fib_FileName, + strlen (fib.fib_FileName), + "", o_env, 1)->export = v_export; + } + } + UnLock (env); + UnLock(CurrentDir(old)); + } + } +#endif + + /* Decode the switches. */ + + decode_env_switches ("MAKEFLAGS", 9); +#if 0 + /* People write things like: + MFLAGS="CC=gcc -pipe" "CFLAGS=-g" + and we set the -p, -i and -e switches. Doesn't seem quite right. */ + decode_env_switches ("MFLAGS", 6); +#endif + decode_switches (argc, argv, 0); +#ifdef WINDOWS32 + if (suspend_flag) { + fprintf(stderr, "%s (pid = %d)\n", argv[0], GetCurrentProcessId()); + fprintf(stderr, _("%s is suspending for 30 seconds..."), argv[0]); + Sleep(30 * 1000); + fprintf(stderr, _("done sleep(30). Continuing.\n")); + } +#endif + + decode_debug_flags (); + + /* Print version information. */ + + if (print_version_flag || print_data_base_flag || db_level) + print_version (); + + /* `make --version' is supposed to just print the version and exit. */ + if (print_version_flag) + die (0); + +#ifndef VMS + /* Set the "MAKE_COMMAND" variable to the name we were invoked with. + (If it is a relative pathname with a slash, prepend our directory name + so the result will run the same program regardless of the current dir. + If it is a name with no slash, we can only hope that PATH did not + find it in the current directory.) */ +#ifdef WINDOWS32 + /* + * Convert from backslashes to forward slashes for + * programs like sh which don't like them. Shouldn't + * matter if the path is one way or the other for + * CreateProcess(). + */ + if (strpbrk(argv[0], "/:\\") || + strstr(argv[0], "..") || + strneq(argv[0], "//", 2)) + argv[0] = xstrdup(w32ify(argv[0],1)); +#else /* WINDOWS32 */ +#ifdef __MSDOS__ + if (strchr (argv[0], '\\')) + { + char *p; + + argv[0] = xstrdup (argv[0]); + for (p = argv[0]; *p; p++) + if (*p == '\\') + *p = '/'; + } + /* If argv[0] is not in absolute form, prepend the current + directory. This can happen when Make is invoked by another DJGPP + program that uses a non-absolute name. */ + if (current_directory[0] != '\0' + && argv[0] != 0 + && (argv[0][0] != '/' && (argv[0][0] == '\0' || argv[0][1] != ':'))) + argv[0] = concat (current_directory, "/", argv[0]); +#else /* !__MSDOS__ */ + if (current_directory[0] != '\0' + && argv[0] != 0 && argv[0][0] != '/' && strchr (argv[0], '/') != 0) + argv[0] = concat (current_directory, "/", argv[0]); +#endif /* !__MSDOS__ */ +#endif /* WINDOWS32 */ +#endif + + /* The extra indirection through $(MAKE_COMMAND) is done + for hysterical raisins. */ + (void) define_variable ("MAKE_COMMAND", 12, argv[0], o_default, 0); + (void) define_variable ("MAKE", 4, "$(MAKE_COMMAND)", o_default, 1); + + if (command_variables != 0) + { + struct command_variable *cv; + struct variable *v; + unsigned int len = 0; + char *value, *p; + + /* Figure out how much space will be taken up by the command-line + variable definitions. */ + for (cv = command_variables; cv != 0; cv = cv->next) + { + v = cv->variable; + len += 2 * strlen (v->name); + if (! v->recursive) + ++len; + ++len; + len += 2 * strlen (v->value); + ++len; + } + + /* Now allocate a buffer big enough and fill it. */ + p = value = (char *) alloca (len); + for (cv = command_variables; cv != 0; cv = cv->next) + { + v = cv->variable; + p = quote_for_env (p, v->name); + if (! v->recursive) + *p++ = ':'; + *p++ = '='; + p = quote_for_env (p, v->value); + *p++ = ' '; + } + p[-1] = '\0'; /* Kill the final space and terminate. */ + + /* Define an unchangeable variable with a name that no POSIX.2 + makefile could validly use for its own variable. */ + (void) define_variable ("-*-command-variables-*-", 23, + value, o_automatic, 0); + + /* Define the variable; this will not override any user definition. + Normally a reference to this variable is written into the value of + MAKEFLAGS, allowing the user to override this value to affect the + exported value of MAKEFLAGS. In POSIX-pedantic mode, we cannot + allow the user's setting of MAKEOVERRIDES to affect MAKEFLAGS, so + a reference to this hidden variable is written instead. */ + (void) define_variable ("MAKEOVERRIDES", 13, + "${-*-command-variables-*-}", o_env, 1); + } + + /* If there were -C flags, move ourselves about. */ + if (directories != 0) + for (i = 0; directories->list[i] != 0; ++i) + { + char *dir = directories->list[i]; + if (dir[0] == '~') + { + char *expanded = tilde_expand (dir); + if (expanded != 0) + dir = expanded; + } + if (chdir (dir) < 0) + pfatal_with_name (dir); + if (dir != directories->list[i]) + free (dir); + } + +#ifdef WINDOWS32 + /* + * THIS BLOCK OF CODE MUST COME AFTER chdir() CALL ABOVE IN ORDER + * TO NOT CONFUSE THE DEPENDENCY CHECKING CODE IN implicit.c. + * + * The functions in dir.c can incorrectly cache information for "." + * before we have changed directory and this can cause file + * lookups to fail because the current directory (.) was pointing + * at the wrong place when it was first evaluated. + */ + no_default_sh_exe = !find_and_set_default_shell(NULL); + +#endif /* WINDOWS32 */ + /* Figure out the level of recursion. */ + { + struct variable *v = lookup_variable (MAKELEVEL_NAME, MAKELEVEL_LENGTH); + if (v != 0 && v->value[0] != '\0' && v->value[0] != '-') + makelevel = (unsigned int) atoi (v->value); + else + makelevel = 0; + } + + /* Except under -s, always do -w in sub-makes and under -C. */ + if (!silent_flag && (directories != 0 || makelevel > 0)) + print_directory_flag = 1; + + /* Let the user disable that with --no-print-directory. */ + if (inhibit_print_directory_flag) + print_directory_flag = 0; + + /* If -R was given, set -r too (doesn't make sense otherwise!) */ + if (no_builtin_variables_flag) + no_builtin_rules_flag = 1; + + /* Construct the list of include directories to search. */ + + construct_include_path (include_directories == 0 ? (char **) 0 + : include_directories->list); + + /* Figure out where we are now, after chdir'ing. */ + if (directories == 0) + /* We didn't move, so we're still in the same place. */ + starting_directory = current_directory; + else + { +#ifdef WINDOWS32 + if (getcwd_fs (current_directory, GET_PATH_MAX) == 0) +#else + if (getcwd (current_directory, GET_PATH_MAX) == 0) +#endif + { +#ifdef HAVE_GETCWD + perror_with_name ("getcwd: ", ""); +#else + error (NILF, "getwd: %s", current_directory); +#endif + starting_directory = 0; + } + else + starting_directory = current_directory; + } + + (void) define_variable ("CURDIR", 6, current_directory, o_default, 0); + + /* Read any stdin makefiles into temporary files. */ + + if (makefiles != 0) + { + register unsigned int i; + for (i = 0; i < makefiles->idx; ++i) + if (makefiles->list[i][0] == '-' && makefiles->list[i][1] == '\0') + { + /* This makefile is standard input. Since we may re-exec + and thus re-read the makefiles, we read standard input + into a temporary file and read from that. */ + FILE *outfile; + char *template, *tmpdir; + + if (stdin_nm) + fatal (NILF, _("Makefile from standard input specified twice.")); + +#ifdef VMS +# define DEFAULT_TMPDIR "sys$scratch:" +#else +# ifdef P_tmpdir +# define DEFAULT_TMPDIR P_tmpdir +# else +# define DEFAULT_TMPDIR "/tmp" +# endif +#endif +#define DEFAULT_TMPFILE "GmXXXXXX" + + if (((tmpdir = getenv ("TMPDIR")) == NULL || *tmpdir == '\0') +#if defined __MSDOS__ || defined(WINDOWS32) + /* These are also used commonly on these platforms. */ + && ((tmpdir = getenv ("TEMP")) == NULL || *tmpdir == '\0') + && ((tmpdir = getenv ("TMP")) == NULL || *tmpdir == '\0') +#endif + ) + tmpdir = DEFAULT_TMPDIR; + + template = (char *) alloca (strlen (tmpdir) + + sizeof (DEFAULT_TMPFILE) + 1); + strcpy (template, tmpdir); + +#ifdef HAVE_DOS_PATHS + if (strchr ("/\\", template[strlen (template) - 1]) == NULL) + strcat (template, "/"); +#else +# ifndef VMS + if (template[strlen (template) - 1] != '/') + strcat (template, "/"); +# endif /* !VMS */ +#endif /* !HAVE_DOS_PATHS */ + + strcat (template, DEFAULT_TMPFILE); + outfile = open_tmpfile (&stdin_nm, template); + if (outfile == 0) + pfatal_with_name (_("fopen (temporary file)")); + while (!feof (stdin)) + { + char buf[2048]; + unsigned int n = fread (buf, 1, sizeof (buf), stdin); + if (n > 0 && fwrite (buf, 1, n, outfile) != n) + pfatal_with_name (_("fwrite (temporary file)")); + } + (void) fclose (outfile); + + /* Replace the name that read_all_makefiles will + see with the name of the temporary file. */ + makefiles->list[i] = xstrdup (stdin_nm); + + /* Make sure the temporary file will not be remade. */ + f = enter_file (stdin_nm); + f->updated = 1; + f->update_status = 0; + f->command_state = cs_finished; + /* Can't be intermediate, or it'll be removed too early for + make re-exec. */ + f->intermediate = 0; + f->dontcare = 0; + } + } + +#if defined(MAKE_JOBSERVER) || !defined(HAVE_WAIT_NOHANG) + /* Set up to handle children dying. This must be done before + reading in the makefiles so that `shell' function calls will work. + + If we don't have a hanging wait we have to fall back to old, broken + functionality here and rely on the signal handler and counting + children. + + If we're using the jobs pipe we need a signal handler so that + SIGCHLD is not ignored; we need it to interrupt the read(2) of the + jobserver pipe in job.c if we're waiting for a token. + + If none of these are true, we don't need a signal handler at all. */ + { + extern RETSIGTYPE child_handler PARAMS ((int sig)); +# if defined SIGCHLD + bsd_signal (SIGCHLD, child_handler); +# endif +# if defined SIGCLD && SIGCLD != SIGCHLD + bsd_signal (SIGCLD, child_handler); +# endif + } +#endif + + /* Let the user send us SIGUSR1 to toggle the -d flag during the run. */ +#ifdef SIGUSR1 + bsd_signal (SIGUSR1, debug_signal_handler); +#endif + + /* Define the initial list of suffixes for old-style rules. */ + + set_default_suffixes (); + + /* Define the file rules for the built-in suffix rules. These will later + be converted into pattern rules. We used to do this in + install_default_implicit_rules, but since that happens after reading + makefiles, it results in the built-in pattern rules taking precedence + over makefile-specified suffix rules, which is wrong. */ + + install_default_suffix_rules (); + + /* Define some internal and special variables. */ + + define_automatic_variables (); + + /* Set up the MAKEFLAGS and MFLAGS variables + so makefiles can look at them. */ + + define_makeflags (0, 0); + + /* Define the default variables. */ + define_default_variables (); + + /* Read all the makefiles. */ + + default_file = enter_file (".DEFAULT"); + + read_makefiles + = read_all_makefiles (makefiles == 0 ? (char **) 0 : makefiles->list); + +#ifdef WINDOWS32 + /* look one last time after reading all Makefiles */ + if (no_default_sh_exe) + no_default_sh_exe = !find_and_set_default_shell(NULL); + + if (no_default_sh_exe && job_slots != 1) { + error (NILF, _("Do not specify -j or --jobs if sh.exe is not available.")); + error (NILF, _("Resetting make for single job mode.")); + job_slots = 1; + } +#endif /* WINDOWS32 */ + +#ifdef __MSDOS__ + /* We need to know what kind of shell we will be using. */ + { + extern int _is_unixy_shell (const char *_path); + struct variable *shv = lookup_variable ("SHELL", 5); + extern int unixy_shell; + extern char *default_shell; + + if (shv && *shv->value) + { + char *shell_path = recursively_expand(shv); + + if (shell_path && _is_unixy_shell (shell_path)) + unixy_shell = 1; + else + unixy_shell = 0; + if (shell_path) + default_shell = shell_path; + } + } +#endif /* __MSDOS__ */ + + /* Decode switches again, in case the variables were set by the makefile. */ + decode_env_switches ("MAKEFLAGS", 9); +#if 0 + decode_env_switches ("MFLAGS", 6); +#endif + +#ifdef __MSDOS__ + if (job_slots != 1) + { + error (NILF, + _("Parallel jobs (-j) are not supported on this platform.")); + error (NILF, _("Resetting to single job (-j1) mode.")); + job_slots = 1; + } +#endif + +#ifdef MAKE_JOBSERVER + /* If the jobserver-fds option is seen, make sure that -j is reasonable. */ + + if (jobserver_fds) + { + char *cp; + + for (i=1; i < jobserver_fds->idx; ++i) + if (!streq (jobserver_fds->list[0], jobserver_fds->list[i])) + fatal (NILF, _("internal error: multiple --jobserver-fds options")); + + /* Now parse the fds string and make sure it has the proper format. */ + + cp = jobserver_fds->list[0]; + + if (sscanf (cp, "%d,%d", &job_fds[0], &job_fds[1]) != 2) + fatal (NILF, + _("internal error: invalid --jobserver-fds string `%s'"), cp); + + /* The combination of a pipe + !job_slots means we're using the + jobserver. If !job_slots and we don't have a pipe, we can start + infinite jobs. If we see both a pipe and job_slots >0 that means the + user set -j explicitly. This is broken; in this case obey the user + (ignore the jobserver pipe for this make) but print a message. */ + + if (job_slots > 0) + error (NILF, + _("warning: -jN forced in submake: disabling jobserver mode.")); + + /* Create a duplicate pipe, that will be closed in the SIGCHLD + handler. If this fails with EBADF, the parent has closed the pipe + on us because it didn't think we were a submake. If so, print a + warning then default to -j1. */ + + else if ((job_rfd = dup (job_fds[0])) < 0) + { + if (errno != EBADF) + pfatal_with_name (_("dup jobserver")); + + error (NILF, + _("warning: jobserver unavailable: using -j1. Add `+' to parent make rule.")); + job_slots = 1; + } + + if (job_slots > 0) + { + close (job_fds[0]); + close (job_fds[1]); + job_fds[0] = job_fds[1] = -1; + free (jobserver_fds->list); + free (jobserver_fds); + jobserver_fds = 0; + } + } + + /* If we have >1 slot but no jobserver-fds, then we're a top-level make. + Set up the pipe and install the fds option for our children. */ + + if (job_slots > 1) + { + char c = '+'; + + if (pipe (job_fds) < 0 || (job_rfd = dup (job_fds[0])) < 0) + pfatal_with_name (_("creating jobs pipe")); + + /* Every make assumes that it always has one job it can run. For the + submakes it's the token they were given by their parent. For the + top make, we just subtract one from the number the user wants. We + want job_slots to be 0 to indicate we're using the jobserver. */ + + while (--job_slots) + if (write (job_fds[1], &c, 1) != 1) + pfatal_with_name (_("init jobserver pipe")); + + /* Fill in the jobserver_fds struct for our children. */ + + jobserver_fds = (struct stringlist *) + xmalloc (sizeof (struct stringlist)); + jobserver_fds->list = (char **) xmalloc (sizeof (char *)); + jobserver_fds->list[0] = xmalloc ((sizeof ("1024")*2)+1); + + sprintf (jobserver_fds->list[0], "%d,%d", job_fds[0], job_fds[1]); + jobserver_fds->idx = 1; + jobserver_fds->max = 1; + } +#endif + + /* Set up MAKEFLAGS and MFLAGS again, so they will be right. */ + + define_makeflags (1, 0); + + /* Make each `struct dep' point at the `struct file' for the file + depended on. Also do magic for special targets. */ + + snap_deps (); + + /* Convert old-style suffix rules to pattern rules. It is important to + do this before installing the built-in pattern rules below, so that + makefile-specified suffix rules take precedence over built-in pattern + rules. */ + + convert_to_pattern (); + + /* Install the default implicit pattern rules. + This used to be done before reading the makefiles. + But in that case, built-in pattern rules were in the chain + before user-defined ones, so they matched first. */ + + install_default_implicit_rules (); + + /* Compute implicit rule limits. */ + + count_implicit_rule_limits (); + + /* Construct the listings of directories in VPATH lists. */ + + build_vpath_lists (); + + /* Mark files given with -o flags as very old + and as having been updated already, and files given with -W flags as + brand new (time-stamp as far as possible into the future). */ + + if (old_files != 0) + for (p = old_files->list; *p != 0; ++p) + { + f = enter_command_line_file (*p); + f->last_mtime = f->mtime_before_update = OLD_MTIME; + f->updated = 1; + f->update_status = 0; + f->command_state = cs_finished; + } + + if (new_files != 0) + { + for (p = new_files->list; *p != 0; ++p) + { + f = enter_command_line_file (*p); + f->last_mtime = f->mtime_before_update = NEW_MTIME; + } + } + + /* Initialize the remote job module. */ + remote_setup (); + + if (read_makefiles != 0) + { + /* Update any makefiles if necessary. */ + + FILE_TIMESTAMP *makefile_mtimes = 0; + unsigned int mm_idx = 0; + char **nargv = argv; + int nargc = argc; + int orig_db_level = db_level; + + if (! ISDB (DB_MAKEFILES)) + db_level = DB_NONE; + + DB (DB_BASIC, (_("Updating makefiles....\n"))); + + /* Remove any makefiles we don't want to try to update. + Also record the current modtimes so we can compare them later. */ + { + register struct dep *d, *last; + last = 0; + d = read_makefiles; + while (d != 0) + { + register struct file *f = d->file; + if (f->double_colon) + for (f = f->double_colon; f != NULL; f = f->prev) + { + if (f->deps == 0 && f->cmds != 0) + { + /* This makefile is a :: target with commands, but + no dependencies. So, it will always be remade. + This might well cause an infinite loop, so don't + try to remake it. (This will only happen if + your makefiles are written exceptionally + stupidly; but if you work for Athena, that's how + you write your makefiles.) */ + + DB (DB_VERBOSE, + (_("Makefile `%s' might loop; not remaking it.\n"), + f->name)); + + if (last == 0) + read_makefiles = d->next; + else + last->next = d->next; + + /* Free the storage. */ + free ((char *) d); + + d = last == 0 ? read_makefiles : last->next; + + break; + } + } + if (f == NULL || !f->double_colon) + { + makefile_mtimes = (FILE_TIMESTAMP *) + xrealloc ((char *) makefile_mtimes, + (mm_idx + 1) * sizeof (FILE_TIMESTAMP)); + makefile_mtimes[mm_idx++] = file_mtime_no_search (d->file); + last = d; + d = d->next; + } + } + } + + /* Set up `MAKEFLAGS' specially while remaking makefiles. */ + define_makeflags (1, 1); + + switch (update_goal_chain (read_makefiles, 1)) + { + case 1: + /* The only way this can happen is if the user specified -q and asked + * for one of the makefiles to be remade as a target on the command + * line. Since we're not actually updating anything with -q we can + * treat this as "did nothing". + */ + + case -1: + /* Did nothing. */ + break; + + case 2: + /* Failed to update. Figure out if we care. */ + { + /* Nonzero if any makefile was successfully remade. */ + int any_remade = 0; + /* Nonzero if any makefile we care about failed + in updating or could not be found at all. */ + int any_failed = 0; + register unsigned int i; + struct dep *d; + + for (i = 0, d = read_makefiles; d != 0; ++i, d = d->next) + { + /* Reset the considered flag; we may need to look at the file + again to print an error. */ + d->file->considered = 0; + + if (d->file->updated) + { + /* This makefile was updated. */ + if (d->file->update_status == 0) + { + /* It was successfully updated. */ + any_remade |= (file_mtime_no_search (d->file) + != makefile_mtimes[i]); + } + else if (! (d->changed & RM_DONTCARE)) + { + FILE_TIMESTAMP mtime; + /* The update failed and this makefile was not + from the MAKEFILES variable, so we care. */ + error (NILF, _("Failed to remake makefile `%s'."), + d->file->name); + mtime = file_mtime_no_search (d->file); + any_remade |= (mtime != NONEXISTENT_MTIME + && mtime != makefile_mtimes[i]); + } + } + else + /* This makefile was not found at all. */ + if (! (d->changed & RM_DONTCARE)) + { + /* This is a makefile we care about. See how much. */ + if (d->changed & RM_INCLUDED) + /* An included makefile. We don't need + to die, but we do want to complain. */ + error (NILF, + _("Included makefile `%s' was not found."), + dep_name (d)); + else + { + /* A normal makefile. We must die later. */ + error (NILF, _("Makefile `%s' was not found"), + dep_name (d)); + any_failed = 1; + } + } + } + /* Reset this to empty so we get the right error message below. */ + read_makefiles = 0; + + if (any_remade) + goto re_exec; + if (any_failed) + die (2); + break; + } + + case 0: + re_exec: + /* Updated successfully. Re-exec ourselves. */ + + remove_intermediates (0); + + if (print_data_base_flag) + print_data_base (); + + log_working_directory (0); + + if (makefiles != 0) + { + /* These names might have changed. */ + register unsigned int i, j = 0; + for (i = 1; i < argc; ++i) + if (strneq (argv[i], "-f", 2)) /* XXX */ + { + char *p = &argv[i][2]; + if (*p == '\0') + argv[++i] = makefiles->list[j]; + else + argv[i] = concat ("-f", makefiles->list[j], ""); + ++j; + } + } + + /* Add -o option for the stdin temporary file, if necessary. */ + if (stdin_nm) + { + nargv = (char **) xmalloc ((nargc + 2) * sizeof (char *)); + bcopy ((char *) argv, (char *) nargv, argc * sizeof (char *)); + nargv[nargc++] = concat ("-o", stdin_nm, ""); + nargv[nargc] = 0; + } + + if (directories != 0 && directories->idx > 0) + { + char bad; + if (directory_before_chdir != 0) + { + if (chdir (directory_before_chdir) < 0) + { + perror_with_name ("chdir", ""); + bad = 1; + } + else + bad = 0; + } + else + bad = 1; + if (bad) + fatal (NILF, _("Couldn't change back to original directory.")); + } + +#ifndef _AMIGA + for (p = environ; *p != 0; ++p) + if ((*p)[MAKELEVEL_LENGTH] == '=' + && strneq (*p, MAKELEVEL_NAME, MAKELEVEL_LENGTH)) + { + /* The SGI compiler apparently can't understand + the concept of storing the result of a function + in something other than a local variable. */ + char *sgi_loses; + sgi_loses = (char *) alloca (40); + *p = sgi_loses; + sprintf (*p, "%s=%u", MAKELEVEL_NAME, makelevel); + break; + } +#else /* AMIGA */ + { + char buffer[256]; + int len; + + len = GetVar (MAKELEVEL_NAME, buffer, sizeof (buffer), GVF_GLOBAL_ONLY); + + if (len != -1) + { + sprintf (buffer, "%u", makelevel); + SetVar (MAKELEVEL_NAME, buffer, -1, GVF_GLOBAL_ONLY); + } + } +#endif + + if (ISDB (DB_BASIC)) + { + char **p; + fputs (_("Re-executing:"), stdout); + for (p = nargv; *p != 0; ++p) + printf (" %s", *p); + putchar ('\n'); + } + + fflush (stdout); + fflush (stderr); + + /* Close the dup'd jobserver pipe if we opened one. */ + if (job_rfd >= 0) + close (job_rfd); + +#ifndef _AMIGA + exec_command (nargv, environ); +#else + exec_command (nargv); + exit (0); +#endif + /* NOTREACHED */ + + default: +#define BOGUS_UPDATE_STATUS 0 + assert (BOGUS_UPDATE_STATUS); + break; + } + + db_level = orig_db_level; + } + + /* Set up `MAKEFLAGS' again for the normal targets. */ + define_makeflags (1, 0); + + /* If there is a temp file from reading a makefile from stdin, get rid of + it now. */ + if (stdin_nm && unlink (stdin_nm) < 0 && errno != ENOENT) + perror_with_name (_("unlink (temporary file): "), stdin_nm); + + { + int status; + + /* If there were no command-line goals, use the default. */ + if (goals == 0) + { + if (default_goal_file != 0) + { + goals = (struct dep *) xmalloc (sizeof (struct dep)); + goals->next = 0; + goals->name = 0; + goals->ignore_mtime = 0; + goals->file = default_goal_file; + } + } + else + lastgoal->next = 0; + + if (!goals) + { + if (read_makefiles == 0) + fatal (NILF, _("No targets specified and no makefile found")); + + fatal (NILF, _("No targets")); + } + + /* Update the goals. */ + + DB (DB_BASIC, (_("Updating goal targets....\n"))); + + switch (update_goal_chain (goals, 0)) + { + case -1: + /* Nothing happened. */ + case 0: + /* Updated successfully. */ + status = MAKE_SUCCESS; + break; + case 1: + /* We are under -q and would run some commands. */ + status = MAKE_TROUBLE; + break; + case 2: + /* Updating failed. POSIX.2 specifies exit status >1 for this; + but in VMS, there is only success and failure. */ + status = MAKE_FAILURE; + break; + default: + abort (); + } + + /* If we detected some clock skew, generate one last warning */ + if (clock_skew_detected) + error (NILF, + _("warning: Clock skew detected. Your build may be incomplete.")); + + /* Exit. */ + die (status); + } + + return 0; +} + +/* Parsing of arguments, decoding of switches. */ + +static char options[1 + sizeof (switches) / sizeof (switches[0]) * 3]; +static struct option long_options[(sizeof (switches) / sizeof (switches[0])) + + (sizeof (long_option_aliases) / + sizeof (long_option_aliases[0]))]; + +/* Fill in the string and vector for getopt. */ +static void +init_switches () +{ + register char *p; + register int c; + register unsigned int i; + + if (options[0] != '\0') + /* Already done. */ + return; + + p = options; + + /* Return switch and non-switch args in order, regardless of + POSIXLY_CORRECT. Non-switch args are returned as option 1. */ + *p++ = '-'; + + for (i = 0; switches[i].c != '\0'; ++i) + { + long_options[i].name = (switches[i].long_name == 0 ? "" : + switches[i].long_name); + long_options[i].flag = 0; + long_options[i].val = switches[i].c; + if (short_option (switches[i].c)) + *p++ = switches[i].c; + switch (switches[i].type) + { + case flag: + case flag_off: + case ignore: + long_options[i].has_arg = no_argument; + break; + + case string: + case positive_int: + case floating: + if (short_option (switches[i].c)) + *p++ = ':'; + if (switches[i].noarg_value != 0) + { + if (short_option (switches[i].c)) + *p++ = ':'; + long_options[i].has_arg = optional_argument; + } + else + long_options[i].has_arg = required_argument; + break; + } + } + *p = '\0'; + for (c = 0; c < (sizeof (long_option_aliases) / + sizeof (long_option_aliases[0])); + ++c) + long_options[i++] = long_option_aliases[c]; + long_options[i].name = 0; +} + +static void +handle_non_switch_argument (arg, env) + char *arg; + int env; +{ + /* Non-option argument. It might be a variable definition. */ + struct variable *v; + if (arg[0] == '-' && arg[1] == '\0') + /* Ignore plain `-' for compatibility. */ + return; + v = try_variable_definition (0, arg, o_command, 0); + if (v != 0) + { + /* It is indeed a variable definition. Record a pointer to + the variable for later use in define_makeflags. */ + struct command_variable *cv + = (struct command_variable *) xmalloc (sizeof (*cv)); + cv->variable = v; + cv->next = command_variables; + command_variables = cv; + } + else if (! env) + { + /* Not an option or variable definition; it must be a goal + target! Enter it as a file and add it to the dep chain of + goals. */ + struct file *f = enter_command_line_file (arg); + f->cmd_target = 1; + + if (goals == 0) + { + goals = (struct dep *) xmalloc (sizeof (struct dep)); + lastgoal = goals; + } + else + { + lastgoal->next = (struct dep *) xmalloc (sizeof (struct dep)); + lastgoal = lastgoal->next; + } + lastgoal->name = 0; + lastgoal->file = f; + lastgoal->ignore_mtime = 0; + + { + /* Add this target name to the MAKECMDGOALS variable. */ + struct variable *v; + char *value; + + v = lookup_variable ("MAKECMDGOALS", 12); + if (v == 0) + value = f->name; + else + { + /* Paste the old and new values together */ + unsigned int oldlen, newlen; + + oldlen = strlen (v->value); + newlen = strlen (f->name); + value = (char *) alloca (oldlen + 1 + newlen + 1); + bcopy (v->value, value, oldlen); + value[oldlen] = ' '; + bcopy (f->name, &value[oldlen + 1], newlen + 1); + } + define_variable ("MAKECMDGOALS", 12, value, o_default, 0); + } + } +} + +/* Print a nice usage method. */ + +static void +print_usage (bad) + int bad; +{ + extern char *make_host; + const char *const *cpp; + FILE *usageto; + + if (print_version_flag) + print_version (); + + usageto = bad ? stderr : stdout; + + fprintf (usageto, _("Usage: %s [options] [target] ...\n"), program); + + for (cpp = usage; *cpp; ++cpp) + fputs (_(*cpp), usageto); + + if (!remote_description || *remote_description == '\0') + fprintf (usageto, _("\nThis program built for %s\n"), make_host); + else + fprintf (usageto, _("\nThis program built for %s (%s)\n"), + make_host, remote_description); + + fprintf (usageto, _("Report bugs to \n")); +} + +/* Decode switches from ARGC and ARGV. + They came from the environment if ENV is nonzero. */ + +static void +decode_switches (argc, argv, env) + int argc; + char **argv; + int env; +{ + int bad = 0; + register const struct command_switch *cs; + register struct stringlist *sl; + register int c; + + /* getopt does most of the parsing for us. + First, get its vectors set up. */ + + init_switches (); + + /* Let getopt produce error messages for the command line, + but not for options from the environment. */ + opterr = !env; + /* Reset getopt's state. */ + optind = 0; + + while (optind < argc) + { + /* Parse the next argument. */ + c = getopt_long (argc, argv, options, long_options, (int *) 0); + if (c == EOF) + /* End of arguments, or "--" marker seen. */ + break; + else if (c == 1) + /* An argument not starting with a dash. */ + handle_non_switch_argument (optarg, env); + else if (c == '?') + /* Bad option. We will print a usage message and die later. + But continue to parse the other options so the user can + see all he did wrong. */ + bad = 1; + else + for (cs = switches; cs->c != '\0'; ++cs) + if (cs->c == c) + { + /* Whether or not we will actually do anything with + this switch. We test this individually inside the + switch below rather than just once outside it, so that + options which are to be ignored still consume args. */ + int doit = !env || cs->env; + + switch (cs->type) + { + default: + abort (); + + case ignore: + break; + + case flag: + case flag_off: + if (doit) + *(int *) cs->value_ptr = cs->type == flag; + break; + + case string: + if (!doit) + break; + + if (optarg == 0) + optarg = cs->noarg_value; + + sl = *(struct stringlist **) cs->value_ptr; + if (sl == 0) + { + sl = (struct stringlist *) + xmalloc (sizeof (struct stringlist)); + sl->max = 5; + sl->idx = 0; + sl->list = (char **) xmalloc (5 * sizeof (char *)); + *(struct stringlist **) cs->value_ptr = sl; + } + else if (sl->idx == sl->max - 1) + { + sl->max += 5; + sl->list = (char **) + xrealloc ((char *) sl->list, + sl->max * sizeof (char *)); + } + sl->list[sl->idx++] = optarg; + sl->list[sl->idx] = 0; + break; + + case positive_int: + /* See if we have an option argument; if we do require that + it's all digits, not something like "10foo". */ + if (optarg == 0 && argc > optind) + { + const char *cp; + for (cp=argv[optind]; ISDIGIT (cp[0]); ++cp) + ; + if (cp[0] == '\0') + optarg = argv[optind++]; + } + + if (!doit) + break; + + if (optarg != 0) + { + int i = atoi (optarg); + const char *cp; + + /* Yes, I realize we're repeating this in some cases. */ + for (cp = optarg; ISDIGIT (cp[0]); ++cp) + ; + + if (i < 1 || cp[0] != '\0') + { + error (NILF, _("the `-%c' option requires a positive integral argument"), + cs->c); + bad = 1; + } + else + *(unsigned int *) cs->value_ptr = i; + } + else + *(unsigned int *) cs->value_ptr + = *(unsigned int *) cs->noarg_value; + break; + +#ifndef NO_FLOAT + case floating: + if (optarg == 0 && optind < argc + && (ISDIGIT (argv[optind][0]) || argv[optind][0] == '.')) + optarg = argv[optind++]; + + if (doit) + *(double *) cs->value_ptr + = (optarg != 0 ? atof (optarg) + : *(double *) cs->noarg_value); + + break; +#endif + } + + /* We've found the switch. Stop looking. */ + break; + } + } + + /* There are no more options according to getting getopt, but there may + be some arguments left. Since we have asked for non-option arguments + to be returned in order, this only happens when there is a "--" + argument to prevent later arguments from being options. */ + while (optind < argc) + handle_non_switch_argument (argv[optind++], env); + + + if (!env && (bad || print_usage_flag)) + { + print_usage (bad); + die (bad ? 2 : 0); + } +} + +/* Decode switches from environment variable ENVAR (which is LEN chars long). + We do this by chopping the value into a vector of words, prepending a + dash to the first word if it lacks one, and passing the vector to + decode_switches. */ + +static void +decode_env_switches (envar, len) + char *envar; + unsigned int len; +{ + char *varref = (char *) alloca (2 + len + 2); + char *value, *p; + int argc; + char **argv; + + /* Get the variable's value. */ + varref[0] = '$'; + varref[1] = '('; + bcopy (envar, &varref[2], len); + varref[2 + len] = ')'; + varref[2 + len + 1] = '\0'; + value = variable_expand (varref); + + /* Skip whitespace, and check for an empty value. */ + value = next_token (value); + len = strlen (value); + if (len == 0) + return; + + /* Allocate a vector that is definitely big enough. */ + argv = (char **) alloca ((1 + len + 1) * sizeof (char *)); + + /* Allocate a buffer to copy the value into while we split it into words + and unquote it. We must use permanent storage for this because + decode_switches may store pointers into the passed argument words. */ + p = (char *) xmalloc (2 * len); + + /* getopt will look at the arguments starting at ARGV[1]. + Prepend a spacer word. */ + argv[0] = 0; + argc = 1; + argv[argc] = p; + while (*value != '\0') + { + if (*value == '\\' && value[1] != '\0') + ++value; /* Skip the backslash. */ + else if (isblank ((unsigned char)*value)) + { + /* End of the word. */ + *p++ = '\0'; + argv[++argc] = p; + do + ++value; + while (isblank ((unsigned char)*value)); + continue; + } + *p++ = *value++; + } + *p = '\0'; + argv[++argc] = 0; + + if (argv[1][0] != '-' && strchr (argv[1], '=') == 0) + /* The first word doesn't start with a dash and isn't a variable + definition. Add a dash and pass it along to decode_switches. We + need permanent storage for this in case decode_switches saves + pointers into the value. */ + argv[1] = concat ("-", argv[1], ""); + + /* Parse those words. */ + decode_switches (argc, argv, 1); +} + +/* Quote the string IN so that it will be interpreted as a single word with + no magic by decode_env_switches; also double dollar signs to avoid + variable expansion in make itself. Write the result into OUT, returning + the address of the next character to be written. + Allocating space for OUT twice the length of IN is always sufficient. */ + +static char * +quote_for_env (out, in) + char *out, *in; +{ + while (*in != '\0') + { + if (*in == '$') + *out++ = '$'; + else if (isblank ((unsigned char)*in) || *in == '\\') + *out++ = '\\'; + *out++ = *in++; + } + + return out; +} + +/* Define the MAKEFLAGS and MFLAGS variables to reflect the settings of the + command switches. Include options with args if ALL is nonzero. + Don't include options with the `no_makefile' flag set if MAKEFILE. */ + +static void +define_makeflags (all, makefile) + int all, makefile; +{ + static const char ref[] = "$(MAKEOVERRIDES)"; + static const char posixref[] = "$(-*-command-variables-*-)"; + register const struct command_switch *cs; + char *flagstring; + register char *p; + unsigned int words; + struct variable *v; + + /* We will construct a linked list of `struct flag's describing + all the flags which need to go in MAKEFLAGS. Then, once we + know how many there are and their lengths, we can put them all + together in a string. */ + + struct flag + { + struct flag *next; + const struct command_switch *cs; + char *arg; + }; + struct flag *flags = 0; + unsigned int flagslen = 0; +#define ADD_FLAG(ARG, LEN) \ + do { \ + struct flag *new = (struct flag *) alloca (sizeof (struct flag)); \ + new->cs = cs; \ + new->arg = (ARG); \ + new->next = flags; \ + flags = new; \ + if (new->arg == 0) \ + ++flagslen; /* Just a single flag letter. */ \ + else \ + flagslen += 1 + 1 + 1 + 1 + 3 * (LEN); /* " -x foo" */ \ + if (!short_option (cs->c)) \ + /* This switch has no single-letter version, so we use the long. */ \ + flagslen += 2 + strlen (cs->long_name); \ + } while (0) + + for (cs = switches; cs->c != '\0'; ++cs) + if (cs->toenv && (!makefile || !cs->no_makefile)) + switch (cs->type) + { + default: + abort (); + + case ignore: + break; + + case flag: + case flag_off: + if (!*(int *) cs->value_ptr == (cs->type == flag_off) + && (cs->default_value == 0 + || *(int *) cs->value_ptr != *(int *) cs->default_value)) + ADD_FLAG (0, 0); + break; + + case positive_int: + if (all) + { + if ((cs->default_value != 0 + && (*(unsigned int *) cs->value_ptr + == *(unsigned int *) cs->default_value))) + break; + else if (cs->noarg_value != 0 + && (*(unsigned int *) cs->value_ptr == + *(unsigned int *) cs->noarg_value)) + ADD_FLAG ("", 0); /* Optional value omitted; see below. */ + else if (cs->c == 'j') + /* Special case for `-j'. */ + ADD_FLAG ("1", 1); + else + { + char *buf = (char *) alloca (30); + sprintf (buf, "%u", *(unsigned int *) cs->value_ptr); + ADD_FLAG (buf, strlen (buf)); + } + } + break; + +#ifndef NO_FLOAT + case floating: + if (all) + { + if (cs->default_value != 0 + && (*(double *) cs->value_ptr + == *(double *) cs->default_value)) + break; + else if (cs->noarg_value != 0 + && (*(double *) cs->value_ptr + == *(double *) cs->noarg_value)) + ADD_FLAG ("", 0); /* Optional value omitted; see below. */ + else + { + char *buf = (char *) alloca (100); + sprintf (buf, "%g", *(double *) cs->value_ptr); + ADD_FLAG (buf, strlen (buf)); + } + } + break; +#endif + + case string: + if (all) + { + struct stringlist *sl = *(struct stringlist **) cs->value_ptr; + if (sl != 0) + { + /* Add the elements in reverse order, because + all the flags get reversed below; and the order + matters for some switches (like -I). */ + register unsigned int i = sl->idx; + while (i-- > 0) + ADD_FLAG (sl->list[i], strlen (sl->list[i])); + } + } + break; + } + + flagslen += 4 + sizeof posixref; /* Four more for the possible " -- ". */ + +#undef ADD_FLAG + + /* Construct the value in FLAGSTRING. + We allocate enough space for a preceding dash and trailing null. */ + flagstring = (char *) alloca (1 + flagslen + 1); + bzero (flagstring, 1 + flagslen + 1); + p = flagstring; + words = 1; + *p++ = '-'; + while (flags != 0) + { + /* Add the flag letter or name to the string. */ + if (short_option (flags->cs->c)) + *p++ = flags->cs->c; + else + { + if (*p != '-') + { + *p++ = ' '; + *p++ = '-'; + } + *p++ = '-'; + strcpy (p, flags->cs->long_name); + p += strlen (p); + } + if (flags->arg != 0) + { + /* A flag that takes an optional argument which in this case is + omitted is specified by ARG being "". We must distinguish + because a following flag appended without an intervening " -" + is considered the arg for the first. */ + if (flags->arg[0] != '\0') + { + /* Add its argument too. */ + *p++ = !short_option (flags->cs->c) ? '=' : ' '; + p = quote_for_env (p, flags->arg); + } + ++words; + /* Write a following space and dash, for the next flag. */ + *p++ = ' '; + *p++ = '-'; + } + else if (!short_option (flags->cs->c)) + { + ++words; + /* Long options must each go in their own word, + so we write the following space and dash. */ + *p++ = ' '; + *p++ = '-'; + } + flags = flags->next; + } + + /* Define MFLAGS before appending variable definitions. */ + + if (p == &flagstring[1]) + /* No flags. */ + flagstring[0] = '\0'; + else if (p[-1] == '-') + { + /* Kill the final space and dash. */ + p -= 2; + *p = '\0'; + } + else + /* Terminate the string. */ + *p = '\0'; + + /* Since MFLAGS is not parsed for flags, there is no reason to + override any makefile redefinition. */ + (void) define_variable ("MFLAGS", 6, flagstring, o_env, 1); + + if (all && command_variables != 0) + { + /* Now write a reference to $(MAKEOVERRIDES), which contains all the + command-line variable definitions. */ + + if (p == &flagstring[1]) + /* No flags written, so elide the leading dash already written. */ + p = flagstring; + else + { + /* Separate the variables from the switches with a "--" arg. */ + if (p[-1] != '-') + { + /* We did not already write a trailing " -". */ + *p++ = ' '; + *p++ = '-'; + } + /* There is a trailing " -"; fill it out to " -- ". */ + *p++ = '-'; + *p++ = ' '; + } + + /* Copy in the string. */ + if (posix_pedantic) + { + bcopy (posixref, p, sizeof posixref - 1); + p += sizeof posixref - 1; + } + else + { + bcopy (ref, p, sizeof ref - 1); + p += sizeof ref - 1; + } + } + else if (p == &flagstring[1]) + { + words = 0; + --p; + } + else if (p[-1] == '-') + /* Kill the final space and dash. */ + p -= 2; + /* Terminate the string. */ + *p = '\0'; + + v = define_variable ("MAKEFLAGS", 9, + /* If there are switches, omit the leading dash + unless it is a single long option with two + leading dashes. */ + &flagstring[(flagstring[0] == '-' + && flagstring[1] != '-') + ? 1 : 0], + /* This used to use o_env, but that lost when a + makefile defined MAKEFLAGS. Makefiles set + MAKEFLAGS to add switches, but we still want + to redefine its value with the full set of + switches. Of course, an override or command + definition will still take precedence. */ + o_file, 1); + if (! all) + /* The first time we are called, set MAKEFLAGS to always be exported. + We should not do this again on the second call, because that is + after reading makefiles which might have done `unexport MAKEFLAGS'. */ + v->export = v_export; +} + +/* Print version information. */ + +static void +print_version () +{ + static int printed_version = 0; + + char *precede = print_data_base_flag ? "# " : ""; + + if (printed_version) + /* Do it only once. */ + return; + + /* Print this untranslated. The coding standards recommend translating the + (C) to the copyright symbol, but this string is going to change every + year, and none of the rest of it should be translated (including the + word "Copyright", so it hardly seems worth it. */ + + printf ("%sGNU Make %s\n\ +%sCopyright (C) 2002 Free Software Foundation, Inc.\n", + precede, version_string, precede); + + printf (_("%sThis is free software; see the source for copying conditions.\n\ +%sThere is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A\n\ +%sPARTICULAR PURPOSE.\n"), + precede, precede, precede); + + printed_version = 1; + + /* Flush stdout so the user doesn't have to wait to see the + version information while things are thought about. */ + fflush (stdout); +} + +/* Print a bunch of information about this and that. */ + +static void +print_data_base () +{ + time_t when; + + when = time ((time_t *) 0); + printf (_("\n# Make data base, printed on %s"), ctime (&when)); + + print_variable_data_base (); + print_dir_data_base (); + print_rule_data_base (); + print_file_data_base (); + print_vpath_data_base (); + + when = time ((time_t *) 0); + printf (_("\n# Finished Make data base on %s\n"), ctime (&when)); +} + +/* Exit with STATUS, cleaning up as necessary. */ + +void +die (status) + int status; +{ + static char dying = 0; + + if (!dying) + { + int err; + + dying = 1; + + if (print_version_flag) + print_version (); + + /* Wait for children to die. */ + for (err = (status != 0); job_slots_used > 0; err = 0) + reap_children (1, err); + + /* Let the remote job module clean up its state. */ + remote_cleanup (); + + /* Remove the intermediate files. */ + remove_intermediates (0); + + if (print_data_base_flag) + print_data_base (); + + /* Try to move back to the original directory. This is essential on + MS-DOS (where there is really only one process), and on Unix it + puts core files in the original directory instead of the -C + directory. Must wait until after remove_intermediates(), or unlinks + of relative pathnames fail. */ + if (directory_before_chdir != 0) + chdir (directory_before_chdir); + + log_working_directory (0); + } + + exit (status); +} + +/* Write a message indicating that we've just entered or + left (according to ENTERING) the current directory. */ + +void +log_working_directory (entering) + int entering; +{ + static int entered = 0; + + /* Print nothing without the flag. Don't print the entering message + again if we already have. Don't print the leaving message if we + haven't printed the entering message. */ + if (! print_directory_flag || entering == entered) + return; + + entered = entering; + + if (print_data_base_flag) + fputs ("# ", stdout); + + /* Use entire sentences to give the translators a fighting chance. */ + + if (makelevel == 0) + if (starting_directory == 0) + if (entering) + printf (_("%s: Entering an unknown directory"), program); + else + printf (_("%s: Leaving an unknown directory"), program); + else + if (entering) + printf (_("%s: Entering directory `%s'\n"), + program, starting_directory); + else + printf (_("%s: Leaving directory `%s'\n"), + program, starting_directory); + else + if (starting_directory == 0) + if (entering) + printf (_("%s[%u]: Entering an unknown directory"), + program, makelevel); + else + printf (_("%s[%u]: Leaving an unknown directory"), + program, makelevel); + else + if (entering) + printf (_("%s[%u]: Entering directory `%s'\n"), + program, makelevel, starting_directory); + else + printf (_("%s[%u]: Leaving directory `%s'\n"), + program, makelevel, starting_directory); +} diff --git a/flaim/external/w32/make/make.h b/flaim/external/w32/make/make.h new file mode 100644 index 0000000..6648ea0 --- /dev/null +++ b/flaim/external/w32/make/make.h @@ -0,0 +1,562 @@ +/* Miscellaneous global declarations and portability cruft for GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* We use instead of "config.h" so that a compilation + using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h + (which it would do because make.h was found in $srcdir). */ +#include +#undef HAVE_CONFIG_H +#define HAVE_CONFIG_H 1 + +/* AIX requires this to be the first thing in the file. */ +#ifndef __GNUC__ +# if HAVE_ALLOCA_H +# include +# else +# ifdef _AIX + #pragma alloca +# else +# ifndef alloca /* predefined by HP cc +Olibcalls */ +char *alloca (); +# endif +# endif +# endif +#endif + + +/* Use prototypes if available. */ +#if defined (__cplusplus) || (defined (__STDC__) && __STDC__) +# undef PARAMS +# define PARAMS(protos) protos +#else /* Not C++ or ANSI C. */ +# undef PARAMS +# define PARAMS(protos) () +#endif /* C++ or ANSI C. */ + +/* Specify we want GNU source code. This must be defined before any + system headers are included. */ + +#define _GNU_SOURCE 1 + + +#ifdef CRAY +/* This must happen before #include so + that the declaration therein is changed. */ +# define signal bsdsignal +#endif + +/* If we're compiling for the dmalloc debugger, turn off string inlining. */ +#if defined(HAVE_DMALLOC_H) && defined(__GNUC__) +# define __NO_STRING_INLINES +#endif + +#include +#include +#include +#include +#include +#ifdef HAVE_SYS_TIMEB_H +/* SCO 3.2 "devsys 4.2" has a prototype for `ftime' in that bombs + unless has been included first. Does every system have a + ? If any does not, configure should check for it. */ +# include +#endif + +#if TIME_WITH_SYS_TIME +# include +# include +#else +# if HAVE_SYS_TIME_H +# include +# else +# include +# endif +#endif + +#include + +#ifndef errno +extern int errno; +#endif + +#ifndef isblank +# define isblank(c) ((c) == ' ' || (c) == '\t') +#endif + +#ifdef HAVE_UNISTD_H +# include +/* Ultrix's unistd.h always defines _POSIX_VERSION, but you only get + POSIX.1 behavior with `cc -YPOSIX', which predefines POSIX itself! */ +# if defined (_POSIX_VERSION) && !defined (ultrix) && !defined (VMS) +# define POSIX 1 +# endif +#endif + +/* Some systems define _POSIX_VERSION but are not really POSIX.1. */ +#if (defined (butterfly) || defined (__arm) || (defined (__mips) && defined (_SYSTYPE_SVR3)) || (defined (sequent) && defined (i386))) +# undef POSIX +#endif + +#if !defined (POSIX) && defined (_AIX) && defined (_POSIX_SOURCE) +# define POSIX 1 +#endif + +#ifndef RETSIGTYPE +# define RETSIGTYPE void +#endif + +#ifndef sigmask +# define sigmask(sig) (1 << ((sig) - 1)) +#endif + +#ifndef HAVE_SA_RESTART +# define SA_RESTART 0 +#endif + +#ifdef HAVE_LIMITS_H +# include +#endif +#ifdef HAVE_SYS_PARAM_H +# include +#endif + +#ifndef PATH_MAX +# ifndef POSIX +# define PATH_MAX MAXPATHLEN +# endif +#endif +#ifndef MAXPATHLEN +# define MAXPATHLEN 1024 +#endif + +#ifdef PATH_MAX +# define GET_PATH_MAX PATH_MAX +# define PATH_VAR(var) char var[PATH_MAX] +#else +# define NEED_GET_PATH_MAX 1 +# define GET_PATH_MAX (get_path_max ()) +# define PATH_VAR(var) char *var = (char *) alloca (GET_PATH_MAX) +extern unsigned int get_path_max PARAMS ((void)); +#endif + +#ifndef CHAR_BIT +# define CHAR_BIT 8 +#endif + +/* Nonzero if the integer type T is signed. */ +#define INTEGER_TYPE_SIGNED(t) ((t) -1 < 0) + +/* The minimum and maximum values for the integer type T. + Use ~ (t) 0, not -1, for portability to 1's complement hosts. */ +#define INTEGER_TYPE_MINIMUM(t) \ + (! INTEGER_TYPE_SIGNED (t) ? (t) 0 : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)) +#define INTEGER_TYPE_MAXIMUM(t) (~ (t) 0 - INTEGER_TYPE_MINIMUM (t)) + +#ifndef CHAR_MAX +# define CHAR_MAX INTEGER_TYPE_MAXIMUM (char) +#endif + +#ifdef STAT_MACROS_BROKEN +# ifdef S_ISREG +# undef S_ISREG +# endif +# ifdef S_ISDIR +# undef S_ISDIR +# endif +#endif /* STAT_MACROS_BROKEN. */ + +#ifndef S_ISREG +# define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) +#endif +#ifndef S_ISDIR +# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) +#endif + +#ifdef VMS +# include +# include +# include +# include +/* Needed to use alloca on VMS. */ +# include +#endif + +#ifndef __attribute__ +/* This feature is available in gcc versions 2.5 and later. */ +# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__ +# define __attribute__(x) +# endif +/* The __-protected variants of `format' and `printf' attributes + are accepted by gcc versions 2.6.4 (effectively 2.7) and later. */ +# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7) +# define __format__ format +# define __printf__ printf +# endif +#endif + +#if defined (STDC_HEADERS) || defined (__GNU_LIBRARY__) +# include +# include +# define ANSI_STRING 1 +#else /* No standard headers. */ +# ifdef HAVE_STRING_H +# include +# define ANSI_STRING 1 +# else +# include +# endif +# ifdef HAVE_MEMORY_H +# include +# endif +# ifdef HAVE_STDLIB_H +# include +# else +extern char *malloc PARAMS ((int)); +extern char *realloc PARAMS ((char *, int)); +extern void free PARAMS ((char *)); + +extern void abort PARAMS ((void)) __attribute__ ((noreturn)); +extern void exit PARAMS ((int)) __attribute__ ((noreturn)); +# endif /* HAVE_STDLIB_H. */ + +#endif /* Standard headers. */ + +/* These should be in stdlib.h. Make sure we have them. */ +#ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +#endif +#ifndef EXIT_FAILURE +# define EXIT_FAILURE 0 +#endif + +#ifdef ANSI_STRING + +# ifndef bcmp +# define bcmp(s1, s2, n) memcmp ((s1), (s2), (n)) +# endif +# ifndef bzero +# define bzero(s, n) memset ((s), 0, (n)) +# endif +# if defined(HAVE_MEMMOVE) && !defined(bcopy) +# define bcopy(s, d, n) memmove ((d), (s), (n)) +# endif + +#else /* Not ANSI_STRING. */ + +# ifndef HAVE_STRCHR +# define strchr(s, c) index((s), (c)) +# define strrchr(s, c) rindex((s), (c)) +# endif + +# ifndef bcmp +extern int bcmp PARAMS ((const char *, const char *, int)); +# endif +# ifndef bzero +extern void bzero PARAMS ((char *, int)); +#endif +# ifndef bcopy +extern void bcopy PARAMS ((const char *b1, char *b2, int)); +# endif + +#endif /* ANSI_STRING. */ +#undef ANSI_STRING + +/* SCO Xenix has a buggy macro definition in . */ +#undef strerror + +#if !defined(ANSI_STRING) && !defined(__DECC) +extern char *strerror PARAMS ((int errnum)); +#endif + +#if HAVE_INTTYPES_H +# include +#endif +#define FILE_TIMESTAMP uintmax_t + +#if !defined(HAVE_STRSIGNAL) +extern char *strsignal PARAMS ((int signum)); +#endif + +/* ISDIGIT offers the following features: + - Its arg may be any int or unsigned int; it need not be an unsigned char. + - It's guaranteed to evaluate its argument exactly once. + NOTE! Make relies on this behavior, don't change it! + - It's typically faster. + POSIX 1003.2-1992 section 2.5.2.1 page 50 lines 1556-1558 says that + only '0' through '9' are digits. Prefer ISDIGIT to isdigit() unless + it's important to use the locale's definition of `digit' even when the + host does not conform to POSIX. */ +#define ISDIGIT(c) ((unsigned) (c) - '0' <= 9) + +#ifndef iAPX286 +# define streq(a, b) \ + ((a) == (b) || \ + (*(a) == *(b) && (*(a) == '\0' || !strcmp ((a) + 1, (b) + 1)))) +# ifdef HAVE_CASE_INSENSITIVE_FS +/* This is only used on Windows/DOS platforms, so we assume strcmpi(). */ +# define strieq(a, b) \ + ((a) == (b) \ + || (tolower((unsigned char)*(a)) == tolower((unsigned char)*(b)) \ + && (*(a) == '\0' || !strcmpi ((a) + 1, (b) + 1)))) +# else +# define strieq(a, b) streq(a, b) +# endif +#else +/* Buggy compiler can't handle this. */ +# define streq(a, b) (strcmp ((a), (b)) == 0) +# define strieq(a, b) (strcmp ((a), (b)) == 0) +#endif +#define strneq(a, b, l) (strncmp ((a), (b), (l)) == 0) +#ifdef VMS +extern int strcmpi (const char *,const char *); +#endif + +#if defined(__GNUC__) || defined(ENUM_BITFIELDS) +# define ENUM_BITFIELD(bits) :bits +#else +# define ENUM_BITFIELD(bits) +#endif + +/* Handle gettext and locales. */ + +#if HAVE_LOCALE_H +# include +#else +# define setlocale(category, locale) +#endif + +#include + +#define _(msgid) gettext (msgid) +#define N_(msgid) gettext_noop (msgid) +#define S_(msg1,msg2,num) ngettext (msg1,msg2,num) + +/* Handle other OSs. */ + +#if defined(__MSDOS__) || defined(WINDOWS32) +# define PATH_SEPARATOR_CHAR ';' +#else +# if defined(VMS) +# define PATH_SEPARATOR_CHAR ',' +# else +# define PATH_SEPARATOR_CHAR ':' +# endif +#endif + +#ifdef WINDOWS32 +# include +# include +# define pipe(p) _pipe(p, 512, O_BINARY) +# define kill(pid,sig) w32_kill(pid,sig) + +extern void sync_Path_environment(void); +extern int kill(int pid, int sig); +extern int safe_stat(char *file, struct stat *sb); +extern char *end_of_token_w32(char *s, char stopchar); +extern int find_and_set_default_shell(char *token); + +/* indicates whether or not we have Bourne shell */ +extern int no_default_sh_exe; + +/* is default_shell unixy? */ +extern int unixy_shell; +#endif /* WINDOWS32 */ + +struct floc + { + char *filenm; + unsigned long lineno; + }; +#define NILF ((struct floc *)0) + +#define STRING_SIZE_TUPLE(_s) (_s), (sizeof (_s)-1) + + +/* Fancy processing for variadic functions in both ANSI and pre-ANSI + compilers. */ +#if defined __STDC__ && __STDC__ +extern void message (int prefix, const char *fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); +extern void error (const struct floc *flocp, const char *fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); +extern void fatal (const struct floc *flocp, const char *fmt, ...) + __attribute__ ((noreturn, __format__ (__printf__, 2, 3))); +#else +extern void message (); +extern void error (); +extern void fatal (); +#endif + +extern void die PARAMS ((int)) __attribute__ ((noreturn)); +extern void log_working_directory PARAMS ((int)); +extern void pfatal_with_name PARAMS ((const char *)) __attribute__ ((noreturn)); +extern void perror_with_name PARAMS ((const char *, const char *)); +extern char *savestring PARAMS ((const char *, unsigned int)); +extern char *concat PARAMS ((const char *, const char *, const char *)); +extern char *xmalloc PARAMS ((unsigned int)); +extern char *xrealloc PARAMS ((char *, unsigned int)); +extern char *xstrdup PARAMS ((const char *)); +extern char *find_next_token PARAMS ((char **, unsigned int *)); +extern char *next_token PARAMS ((const char *)); +extern char *end_of_token PARAMS ((char *)); +extern void collapse_continuations PARAMS ((char *)); +extern void remove_comments PARAMS((char *)); +extern char *sindex PARAMS ((const char *, unsigned int, \ + const char *, unsigned int)); +extern char *lindex PARAMS ((const char *, const char *, int)); +extern int alpha_compare PARAMS ((const void *, const void *)); +extern void print_spaces PARAMS ((unsigned int)); +extern char *find_char_unquote PARAMS ((char *, int, int, int)); +extern char *find_percent PARAMS ((char *)); +extern FILE *open_tmpfile PARAMS ((char **, const char *)); + +#ifndef NO_ARCHIVES +extern int ar_name PARAMS ((char *)); +extern void ar_parse_name PARAMS ((char *, char **, char **)); +extern int ar_touch PARAMS ((char *)); +extern time_t ar_member_date PARAMS ((char *)); +#endif + +extern int dir_file_exists_p PARAMS ((char *, char *)); +extern int file_exists_p PARAMS ((char *)); +extern int file_impossible_p PARAMS ((char *)); +extern void file_impossible PARAMS ((char *)); +extern char *dir_name PARAMS ((char *)); +extern void hash_init_directories PARAMS ((void)); + +extern void define_default_variables PARAMS ((void)); +extern void set_default_suffixes PARAMS ((void)); +extern void install_default_suffix_rules PARAMS ((void)); +extern void install_default_implicit_rules PARAMS ((void)); + +extern void build_vpath_lists PARAMS ((void)); +extern void construct_vpath_list PARAMS ((char *pattern, char *dirpath)); +extern int vpath_search PARAMS ((char **file, FILE_TIMESTAMP *mtime_ptr)); +extern int gpath_search PARAMS ((char *file, int len)); + +extern void construct_include_path PARAMS ((char **arg_dirs)); + +extern void user_access PARAMS ((void)); +extern void make_access PARAMS ((void)); +extern void child_access PARAMS ((void)); + +#ifdef HAVE_VFORK_H +# include +#endif + +/* We omit these declarations on non-POSIX systems which define _POSIX_VERSION, + because such systems often declare them in header files anyway. */ + +#if !defined (__GNU_LIBRARY__) && !defined (POSIX) && !defined (_POSIX_VERSION) && !defined(WINDOWS32) + +extern long int atol (); +# ifndef VMS +extern long int lseek (); +# endif + +#endif /* Not GNU C library or POSIX. */ + +#ifdef HAVE_GETCWD +# if !defined(VMS) && !defined(__DECC) +extern char *getcwd (); +#endif +#else +extern char *getwd (); +# define getcwd(buf, len) getwd (buf) +#endif + +extern const struct floc *reading_file; + +extern char **environ; + +extern int just_print_flag, silent_flag, ignore_errors_flag, keep_going_flag; +extern int print_data_base_flag, question_flag, touch_flag, always_make_flag; +extern int env_overrides, no_builtin_rules_flag, no_builtin_variables_flag; +extern int print_version_flag, print_directory_flag; +extern int warn_undefined_variables_flag, posix_pedantic, not_parallel; +extern int clock_skew_detected; + +/* can we run commands via 'sh -c xxx' or must we use batch files? */ +extern int batch_mode_shell; + +extern unsigned int job_slots; +extern int job_fds[2]; +extern int job_rfd; +#ifndef NO_FLOAT +extern double max_load_average; +#else +extern int max_load_average; +#endif + +extern char *program; +extern char *starting_directory; +extern unsigned int makelevel; +extern char *version_string, *remote_description; + +extern unsigned int commands_started; + +extern int handling_fatal_signal; + + +#ifndef MIN +#define MIN(_a,_b) ((_a)<(_b)?(_a):(_b)) +#endif +#ifndef MAX +#define MAX(_a,_b) ((_a)>(_b)?(_a):(_b)) +#endif + +#ifdef VMS +# define MAKE_SUCCESS 1 +# define MAKE_TROUBLE 2 +# define MAKE_FAILURE 3 +#else +# define MAKE_SUCCESS 0 +# define MAKE_TROUBLE 1 +# define MAKE_FAILURE 2 +#endif + +/* Set up heap debugging library dmalloc. */ + +#ifdef HAVE_DMALLOC_H +#include +#endif + + +/* If we have broken SA_RESTART support, then wrap stat() and readdir() with + versions that handle EINTR. Note that there are still plenty of system + calls that can fail with EINTR but this, reportedly, gets the vast + majority of failure cases. If you still experience failures you'll need + to either get a system where SA_RESTART works, or you need to avoid -j. */ + +#ifdef HAVE_BROKEN_RESTART + +/* Here we make an assumption that a system with a broken SA_RESTART has + dirent.h. Right now the only system I know of in this category is PTX, and + it does have dirent.h. +*/ +#include + +#define stat(_f,_b) atomic_stat ((_f), (_b)) +#define readdir(_d) atomic_readdir (_d) + +extern int atomic_stat PARAMS ((const char *file, struct stat *buf)); +extern struct dirent *atomic_readdir PARAMS ((DIR *dir)); + +#endif diff --git a/flaim/external/w32/make/misc.c b/flaim/external/w32/make/misc.c new file mode 100644 index 0000000..7f0b1b3 --- /dev/null +++ b/flaim/external/w32/make/misc.c @@ -0,0 +1,893 @@ +/* Miscellaneous generic support functions for GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1997, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "dep.h" +#include "debug.h" + +/* Variadic functions. We go through contortions to allow proper function + prototypes for both ANSI and pre-ANSI C compilers, and also for those + which support stdarg.h vs. varargs.h, and finally those which have + vfprintf(), etc. and those who have _doprnt... or nothing. + + This fancy stuff all came from GNU fileutils, except for the VA_PRINTF and + VA_END macros used here since we have multiple print functions. */ + +#if HAVE_VPRINTF || HAVE_DOPRNT +# define HAVE_STDVARARGS 1 +# if __STDC__ +# include +# define VA_START(args, lastarg) va_start(args, lastarg) +# else +# include +# define VA_START(args, lastarg) va_start(args) +# endif +# if HAVE_VPRINTF +# define VA_PRINTF(fp, lastarg, args) vfprintf((fp), (lastarg), (args)) +# else +# define VA_PRINTF(fp, lastarg, args) _doprnt((lastarg), (args), (fp)) +# endif +# define VA_END(args) va_end(args) +#else +/* # undef HAVE_STDVARARGS */ +# define va_alist a1, a2, a3, a4, a5, a6, a7, a8 +# define va_dcl char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8; +# define VA_START(args, lastarg) +# define VA_PRINTF(fp, lastarg, args) fprintf((fp), (lastarg), va_alist) +# define VA_END(args) +#endif + + +/* Compare strings *S1 and *S2. + Return negative if the first is less, positive if it is greater, + zero if they are equal. */ + +int +alpha_compare (v1, v2) + const void *v1, *v2; +{ + const char *s1 = *((char **)v1); + const char *s2 = *((char **)v2); + + if (*s1 != *s2) + return *s1 - *s2; + return strcmp (s1, s2); +} + +/* Discard each backslash-newline combination from LINE. + Backslash-backslash-newline combinations become backslash-newlines. + This is done by copying the text at LINE into itself. */ + +void +collapse_continuations (line) + char *line; +{ + register char *in, *out, *p; + register int backslash; + register unsigned int bs_write; + + in = strchr (line, '\n'); + if (in == 0) + return; + + out = in; + while (out > line && out[-1] == '\\') + --out; + + while (*in != '\0') + { + /* BS_WRITE gets the number of quoted backslashes at + the end just before IN, and BACKSLASH gets nonzero + if the next character is quoted. */ + backslash = 0; + bs_write = 0; + for (p = in - 1; p >= line && *p == '\\'; --p) + { + if (backslash) + ++bs_write; + backslash = !backslash; + + /* It should be impossible to go back this far without exiting, + but if we do, we can't get the right answer. */ + if (in == out - 1) + abort (); + } + + /* Output the appropriate number of backslashes. */ + while (bs_write-- > 0) + *out++ = '\\'; + + /* Skip the newline. */ + ++in; + + /* If the newline is quoted, discard following whitespace + and any preceding whitespace; leave just one space. */ + if (backslash) + { + in = next_token (in); + while (out > line && isblank ((unsigned char)out[-1])) + --out; + *out++ = ' '; + } + else + /* If the newline isn't quoted, put it in the output. */ + *out++ = '\n'; + + /* Now copy the following line to the output. + Stop when we find backslashes followed by a newline. */ + while (*in != '\0') + if (*in == '\\') + { + p = in + 1; + while (*p == '\\') + ++p; + if (*p == '\n') + { + in = p; + break; + } + while (in < p) + *out++ = *in++; + } + else + *out++ = *in++; + } + + *out = '\0'; +} + + +/* Remove comments from LINE. + This is done by copying the text at LINE onto itself. */ + +void +remove_comments (line) + char *line; +{ + char *comment; + + comment = find_char_unquote (line, '#', 0, 0); + + if (comment != 0) + /* Cut off the line at the #. */ + *comment = '\0'; +} + +/* Print N spaces (used in debug for target-depth). */ + +void +print_spaces (n) + unsigned int n; +{ + while (n-- > 0) + putchar (' '); +} + + +/* Return a newly-allocated string whose contents + concatenate those of s1, s2, s3. */ + +char * +concat (s1, s2, s3) + const char *s1, *s2, *s3; +{ + unsigned int len1, len2, len3; + char *result; + + len1 = *s1 != '\0' ? strlen (s1) : 0; + len2 = *s2 != '\0' ? strlen (s2) : 0; + len3 = *s3 != '\0' ? strlen (s3) : 0; + + result = (char *) xmalloc (len1 + len2 + len3 + 1); + + if (*s1 != '\0') + bcopy (s1, result, len1); + if (*s2 != '\0') + bcopy (s2, result + len1, len2); + if (*s3 != '\0') + bcopy (s3, result + len1 + len2, len3); + *(result + len1 + len2 + len3) = '\0'; + + return result; +} + +/* Print a message on stdout. */ + +void +#if __STDC__ && HAVE_STDVARARGS +message (int prefix, const char *fmt, ...) +#else +message (prefix, fmt, va_alist) + int prefix; + const char *fmt; + va_dcl +#endif +{ +#if HAVE_STDVARARGS + va_list args; +#endif + + log_working_directory (1); + + if (fmt != 0) + { + if (prefix) + { + if (makelevel == 0) + printf ("%s: ", program); + else + printf ("%s[%u]: ", program, makelevel); + } + VA_START (args, fmt); + VA_PRINTF (stdout, fmt, args); + VA_END (args); + putchar ('\n'); + } + + fflush (stdout); +} + +/* Print an error message. */ + +void +#if __STDC__ && HAVE_STDVARARGS +error (const struct floc *flocp, const char *fmt, ...) +#else +error (flocp, fmt, va_alist) + const struct floc *flocp; + const char *fmt; + va_dcl +#endif +{ +#if HAVE_STDVARARGS + va_list args; +#endif + + log_working_directory (1); + + if (flocp && flocp->filenm) + fprintf (stderr, "%s:%lu: ", flocp->filenm, flocp->lineno); + else if (makelevel == 0) + fprintf (stderr, "%s: ", program); + else + fprintf (stderr, "%s[%u]: ", program, makelevel); + + VA_START(args, fmt); + VA_PRINTF (stderr, fmt, args); + VA_END (args); + + putc ('\n', stderr); + fflush (stderr); +} + +/* Print an error message and exit. */ + +void +#if __STDC__ && HAVE_STDVARARGS +fatal (const struct floc *flocp, const char *fmt, ...) +#else +fatal (flocp, fmt, va_alist) + const struct floc *flocp; + const char *fmt; + va_dcl +#endif +{ +#if HAVE_STDVARARGS + va_list args; +#endif + + log_working_directory (1); + + if (flocp && flocp->filenm) + fprintf (stderr, "%s:%lu: *** ", flocp->filenm, flocp->lineno); + else if (makelevel == 0) + fprintf (stderr, "%s: *** ", program); + else + fprintf (stderr, "%s[%u]: *** ", program, makelevel); + + VA_START(args, fmt); + VA_PRINTF (stderr, fmt, args); + VA_END (args); + + fputs (_(". Stop.\n"), stderr); + + die (2); +} + +#ifndef HAVE_STRERROR + +#undef strerror + +char * +strerror (errnum) + int errnum; +{ + extern int errno, sys_nerr; +#ifndef __DECC + extern char *sys_errlist[]; +#endif + static char buf[] = "Unknown error 12345678901234567890"; + + if (errno < sys_nerr) + return sys_errlist[errnum]; + + sprintf (buf, _("Unknown error %d"), errnum); + return buf; +} +#endif + +/* Print an error message from errno. */ + +void +perror_with_name (str, name) + const char *str, *name; +{ + error (NILF, _("%s%s: %s"), str, name, strerror (errno)); +} + +/* Print an error message from errno and exit. */ + +void +pfatal_with_name (name) + const char *name; +{ + fatal (NILF, _("%s: %s"), name, strerror (errno)); + + /* NOTREACHED */ +} + +/* Like malloc but get fatal error if memory is exhausted. */ +/* Don't bother if we're using dmalloc; it provides these for us. */ + +#ifndef HAVE_DMALLOC_H + +#undef xmalloc +#undef xrealloc +#undef xstrdup + +char * +xmalloc (size) + unsigned int size; +{ + char *result = (char *) malloc (size); + if (result == 0) + fatal (NILF, _("virtual memory exhausted")); + return result; +} + + +char * +xrealloc (ptr, size) + char *ptr; + unsigned int size; +{ + char *result; + + /* Some older implementations of realloc() don't conform to ANSI. */ + result = ptr ? realloc (ptr, size) : malloc (size); + if (result == 0) + fatal (NILF, _("virtual memory exhausted")); + return result; +} + + +char * +xstrdup (ptr) + const char *ptr; +{ + char *result; + +#ifdef HAVE_STRDUP + result = strdup (ptr); +#else + result = (char *) malloc (strlen (ptr) + 1); +#endif + + if (result == 0) + fatal (NILF, _("virtual memory exhausted")); + +#ifdef HAVE_STRDUP + return result; +#else + return strcpy(result, ptr); +#endif +} + +#endif /* HAVE_DMALLOC_H */ + +char * +savestring (str, length) + const char *str; + unsigned int length; +{ + register char *out = (char *) xmalloc (length + 1); + if (length > 0) + bcopy (str, out, length); + out[length] = '\0'; + return out; +} + +/* Search string BIG (length BLEN) for an occurrence of + string SMALL (length SLEN). Return a pointer to the + beginning of the first occurrence, or return nil if none found. */ + +char * +sindex (big, blen, small, slen) + const char *big; + unsigned int blen; + const char *small; + unsigned int slen; +{ + if (!blen) + blen = strlen (big); + if (!slen) + slen = strlen (small); + + if (slen && blen >= slen) + { + register unsigned int b; + + /* Quit when there's not enough room left for the small string. */ + --slen; + blen -= slen; + + for (b = 0; b < blen; ++b, ++big) + if (*big == *small && strneq (big + 1, small + 1, slen)) + return (char *)big; + } + + return 0; +} + +/* Limited INDEX: + Search through the string STRING, which ends at LIMIT, for the character C. + Returns a pointer to the first occurrence, or nil if none is found. + Like INDEX except that the string searched ends where specified + instead of at the first null. */ + +char * +lindex (s, limit, c) + register const char *s, *limit; + int c; +{ + while (s < limit) + if (*s++ == c) + return (char *)(s - 1); + + return 0; +} + +/* Return the address of the first whitespace or null in the string S. */ + +char * +end_of_token (s) + char *s; +{ + while (*s != '\0' && !isblank ((unsigned char)*s)) + ++s; + return s; +} + +#ifdef WINDOWS32 +/* + * Same as end_of_token, but take into account a stop character + */ +char * +end_of_token_w32 (s, stopchar) + char *s; + char stopchar; +{ + register char *p = s; + register int backslash = 0; + + while (*p != '\0' && *p != stopchar + && (backslash || !isblank ((unsigned char)*p))) + { + if (*p++ == '\\') + { + backslash = !backslash; + while (*p == '\\') + { + backslash = !backslash; + ++p; + } + } + else + backslash = 0; + } + + return p; +} +#endif + +/* Return the address of the first nonwhitespace or null in the string S. */ + +char * +next_token (s) + const char *s; +{ + while (isblank ((unsigned char)*s)) + ++s; + return (char *)s; +} + +/* Find the next token in PTR; return the address of it, and store the + length of the token into *LENGTHPTR if LENGTHPTR is not nil. */ + +char * +find_next_token (ptr, lengthptr) + char **ptr; + unsigned int *lengthptr; +{ + char *p = next_token (*ptr); + char *end; + + if (*p == '\0') + return 0; + + *ptr = end = end_of_token (p); + if (lengthptr != 0) + *lengthptr = end - p; + return p; +} + +/* Copy a chain of `struct dep', making a new chain + with the same contents as the old one. */ + +struct dep * +copy_dep_chain (d) + register struct dep *d; +{ + register struct dep *c; + struct dep *firstnew = 0; + struct dep *lastnew = 0; + + while (d != 0) + { + c = (struct dep *) xmalloc (sizeof (struct dep)); + bcopy ((char *) d, (char *) c, sizeof (struct dep)); + if (c->name != 0) + c->name = xstrdup (c->name); + c->next = 0; + if (firstnew == 0) + firstnew = lastnew = c; + else + lastnew = lastnew->next = c; + + d = d->next; + } + + return firstnew; +} + +#ifdef iAPX286 +/* The losing compiler on this machine can't handle this macro. */ + +char * +dep_name (dep) + struct dep *dep; +{ + return dep->name == 0 ? dep->file->name : dep->name; +} +#endif + +#ifdef GETLOADAVG_PRIVILEGED + +#ifdef POSIX + +/* Hopefully if a system says it's POSIX.1 and has the setuid and setgid + functions, they work as POSIX.1 says. Some systems (Alpha OSF/1 1.2, + for example) which claim to be POSIX.1 also have the BSD setreuid and + setregid functions, but they don't work as in BSD and only the POSIX.1 + way works. */ + +#undef HAVE_SETREUID +#undef HAVE_SETREGID + +#else /* Not POSIX. */ + +/* Some POSIX.1 systems have the seteuid and setegid functions. In a + POSIX-like system, they are the best thing to use. However, some + non-POSIX systems have them too but they do not work in the POSIX style + and we must use setreuid and setregid instead. */ + +#undef HAVE_SETEUID +#undef HAVE_SETEGID + +#endif /* POSIX. */ + +#ifndef HAVE_UNISTD_H +extern int getuid (), getgid (), geteuid (), getegid (); +extern int setuid (), setgid (); +#ifdef HAVE_SETEUID +extern int seteuid (); +#else +#ifdef HAVE_SETREUID +extern int setreuid (); +#endif /* Have setreuid. */ +#endif /* Have seteuid. */ +#ifdef HAVE_SETEGID +extern int setegid (); +#else +#ifdef HAVE_SETREGID +extern int setregid (); +#endif /* Have setregid. */ +#endif /* Have setegid. */ +#endif /* No . */ + +/* Keep track of the user and group IDs for user- and make- access. */ +static int user_uid = -1, user_gid = -1, make_uid = -1, make_gid = -1; +#define access_inited (user_uid != -1) +static enum { make, user } current_access; + + +/* Under -d, write a message describing the current IDs. */ + +static void +log_access (flavor) + char *flavor; +{ + if (! ISDB (DB_JOBS)) + return; + + /* All the other debugging messages go to stdout, + but we write this one to stderr because it might be + run in a child fork whose stdout is piped. */ + + fprintf (stderr, _("%s: user %lu (real %lu), group %lu (real %lu)\n"), + flavor, (unsigned long) geteuid (), (unsigned long) getuid (), + (unsigned long) getegid (), (unsigned long) getgid ()); + fflush (stderr); +} + + +static void +init_access () +{ +#ifndef VMS + user_uid = getuid (); + user_gid = getgid (); + + make_uid = geteuid (); + make_gid = getegid (); + + /* Do these ever fail? */ + if (user_uid == -1 || user_gid == -1 || make_uid == -1 || make_gid == -1) + pfatal_with_name ("get{e}[gu]id"); + + log_access (_("Initialized access")); + + current_access = make; +#endif +} + +#endif /* GETLOADAVG_PRIVILEGED */ + +/* Give the process appropriate permissions for access to + user data (i.e., to stat files, or to spawn a child process). */ +void +user_access () +{ +#ifdef GETLOADAVG_PRIVILEGED + + if (!access_inited) + init_access (); + + if (current_access == user) + return; + + /* We are in "make access" mode. This means that the effective user and + group IDs are those of make (if it was installed setuid or setgid). + We now want to set the effective user and group IDs to the real IDs, + which are the IDs of the process that exec'd make. */ + +#ifdef HAVE_SETEUID + + /* Modern systems have the seteuid/setegid calls which set only the + effective IDs, which is ideal. */ + + if (seteuid (user_uid) < 0) + pfatal_with_name ("user_access: seteuid"); + +#else /* Not HAVE_SETEUID. */ + +#ifndef HAVE_SETREUID + + /* System V has only the setuid/setgid calls to set user/group IDs. + There is an effective ID, which can be set by setuid/setgid. + It can be set (unless you are root) only to either what it already is + (returned by geteuid/getegid, now in make_uid/make_gid), + the real ID (return by getuid/getgid, now in user_uid/user_gid), + or the saved set ID (what the effective ID was before this set-ID + executable (make) was exec'd). */ + + if (setuid (user_uid) < 0) + pfatal_with_name ("user_access: setuid"); + +#else /* HAVE_SETREUID. */ + + /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs. + They may be set to themselves or each other. So you have two alternatives + at any one time. If you use setuid/setgid, the effective will be set to + the real, leaving only one alternative. Using setreuid/setregid, however, + you can toggle between your two alternatives by swapping the values in a + single setreuid or setregid call. */ + + if (setreuid (make_uid, user_uid) < 0) + pfatal_with_name ("user_access: setreuid"); + +#endif /* Not HAVE_SETREUID. */ +#endif /* HAVE_SETEUID. */ + +#ifdef HAVE_SETEGID + if (setegid (user_gid) < 0) + pfatal_with_name ("user_access: setegid"); +#else +#ifndef HAVE_SETREGID + if (setgid (user_gid) < 0) + pfatal_with_name ("user_access: setgid"); +#else + if (setregid (make_gid, user_gid) < 0) + pfatal_with_name ("user_access: setregid"); +#endif +#endif + + current_access = user; + + log_access (_("User access")); + +#endif /* GETLOADAVG_PRIVILEGED */ +} + +/* Give the process appropriate permissions for access to + make data (i.e., the load average). */ +void +make_access () +{ +#ifdef GETLOADAVG_PRIVILEGED + + if (!access_inited) + init_access (); + + if (current_access == make) + return; + + /* See comments in user_access, above. */ + +#ifdef HAVE_SETEUID + if (seteuid (make_uid) < 0) + pfatal_with_name ("make_access: seteuid"); +#else +#ifndef HAVE_SETREUID + if (setuid (make_uid) < 0) + pfatal_with_name ("make_access: setuid"); +#else + if (setreuid (user_uid, make_uid) < 0) + pfatal_with_name ("make_access: setreuid"); +#endif +#endif + +#ifdef HAVE_SETEGID + if (setegid (make_gid) < 0) + pfatal_with_name ("make_access: setegid"); +#else +#ifndef HAVE_SETREGID + if (setgid (make_gid) < 0) + pfatal_with_name ("make_access: setgid"); +#else + if (setregid (user_gid, make_gid) < 0) + pfatal_with_name ("make_access: setregid"); +#endif +#endif + + current_access = make; + + log_access (_("Make access")); + +#endif /* GETLOADAVG_PRIVILEGED */ +} + +/* Give the process appropriate permissions for a child process. + This is like user_access, but you can't get back to make_access. */ +void +child_access () +{ +#ifdef GETLOADAVG_PRIVILEGED + + if (!access_inited) + abort (); + + /* Set both the real and effective UID and GID to the user's. + They cannot be changed back to make's. */ + +#ifndef HAVE_SETREUID + if (setuid (user_uid) < 0) + pfatal_with_name ("child_access: setuid"); +#else + if (setreuid (user_uid, user_uid) < 0) + pfatal_with_name ("child_access: setreuid"); +#endif + +#ifndef HAVE_SETREGID + if (setgid (user_gid) < 0) + pfatal_with_name ("child_access: setgid"); +#else + if (setregid (user_gid, user_gid) < 0) + pfatal_with_name ("child_access: setregid"); +#endif + + log_access (_("Child access")); + +#endif /* GETLOADAVG_PRIVILEGED */ +} + +#ifdef NEED_GET_PATH_MAX +unsigned int +get_path_max () +{ + static unsigned int value; + + if (value == 0) + { + long int x = pathconf ("/", _PC_PATH_MAX); + if (x > 0) + value = x; + else + return MAXPATHLEN; + } + + return value; +} +#endif + + +#ifdef HAVE_BROKEN_RESTART + +#undef stat +#undef readdir + +int +atomic_stat(file, buf) + const char *file; + struct stat *buf; +{ + int r; + + while ((r = stat (file, buf)) < 0) + if (errno != EINTR) + break; + + return r; +} + +struct dirent * +atomic_readdir(dir) + DIR *dir; +{ + struct dirent *r; + + while ((r = readdir (dir)) == NULL) + if (errno != EINTR) + break; + + return r; +} + +#endif /* HAVE_BROKEN_RESTART */ diff --git a/flaim/external/w32/make/misc_w32.c b/flaim/external/w32/make/misc_w32.c new file mode 100644 index 0000000..7e32652 --- /dev/null +++ b/flaim/external/w32/make/misc_w32.c @@ -0,0 +1,65 @@ +#include +#include +#include +#include +#include "proc.h" + + +/* + * Description: Convert a NULL string terminated UNIX environment block to + * an environment block suitable for a windows32 system call + * + * Returns: TRUE= success, FALSE=fail + * + * Notes/Dependencies: the environment block is sorted in case-insensitive + * order, is double-null terminated, and is a char *, not a char ** + */ +int _cdecl compare(const void *a1, const void *a2) +{ + return _stricoll(*((char**)a1),*((char**)a2)); +} +bool_t +arr2envblk(char **arr, char **envblk_out) +{ + char **tmp; + int size_needed; + int arrcnt; + char *ptr; + + arrcnt = 0; + while (arr[arrcnt]) { + arrcnt++; + } + + tmp = (char**) calloc(arrcnt + 1, sizeof(char *)); + if (!tmp) { + return FALSE; + } + + arrcnt = 0; + size_needed = 0; + while (arr[arrcnt]) { + tmp[arrcnt] = arr[arrcnt]; + size_needed += strlen(arr[arrcnt]) + 1; + arrcnt++; + } + size_needed++; + + qsort((void *) tmp, (size_t) arrcnt, sizeof (char*), compare); + + ptr = *envblk_out = calloc(size_needed, 1); + if (!ptr) { + free(tmp); + return FALSE; + } + + arrcnt = 0; + while (tmp[arrcnt]) { + strcpy(ptr, tmp[arrcnt]); + ptr += strlen(tmp[arrcnt]) + 1; + arrcnt++; + } + + free(tmp); + return TRUE; +} diff --git a/flaim/external/w32/make/pathstuff.c b/flaim/external/w32/make/pathstuff.c new file mode 100644 index 0000000..d8f3845 --- /dev/null +++ b/flaim/external/w32/make/pathstuff.c @@ -0,0 +1,238 @@ +#include +#include +#include "make.h" +#include "pathstuff.h" + +/* + * Convert delimiter separated vpath to Canonical format. + */ +char * +convert_vpath_to_windows32(char *Path, char to_delim) +{ + char *etok; /* token separator for old Path */ + + /* + * Convert all spaces to delimiters. Note that pathnames which + * contain blanks get trounced here. Use 8.3 format as a workaround. + */ + for (etok = Path; etok && *etok; etok++) + if (isblank ((unsigned char) *etok)) + *etok = to_delim; + + return (convert_Path_to_windows32(Path, to_delim)); +} + +/* + * Convert delimiter separated path to Canonical format. + */ +char * +convert_Path_to_windows32(char *Path, char to_delim) +{ + char *etok; /* token separator for old Path */ + char *p; /* points to element of old Path */ + + /* is this a multi-element Path ? */ + for (p = Path, etok = strpbrk(p, ":;"); + etok; + etok = strpbrk(p, ":;")) + if ((etok - p) == 1) { + if (*(etok - 1) == ';' || + *(etok - 1) == ':') { + etok[-1] = to_delim; + etok[0] = to_delim; + p = ++etok; + continue; /* ignore empty bucket */ + } else if (!isalpha ((unsigned char) *p)) { + /* found one to count, handle things like '.' */ + *etok = to_delim; + p = ++etok; + } else if ((*etok == ':') && (etok = strpbrk(etok+1, ":;"))) { + /* found one to count, handle drive letter */ + *etok = to_delim; + p = ++etok; + } else + /* all finished, force abort */ + p += strlen(p); + } else { + /* found another one, no drive letter */ + *etok = to_delim; + p = ++etok; + } + + return Path; +} + +/* + * Convert to forward slashes. Resolve to full pathname optionally + */ +char * +w32ify(char *filename, int resolve) +{ + static char w32_path[FILENAME_MAX]; + char *p; + + if (resolve) + _fullpath(w32_path, filename, sizeof (w32_path)); + else + strncpy(w32_path, filename, sizeof (w32_path)); + + for (p = w32_path; p && *p; p++) + if (*p == '\\') + *p = '/'; + + return w32_path; +} + +char * +getcwd_fs(char* buf, int len) +{ + char *p; + + if (p = getcwd(buf, len)) { + char *q = w32ify(buf, 0); + strncpy(buf, q, len); + } + + return p; +} + +#ifdef unused +/* + * Convert delimiter separated pathnames (e.g. PATH) or single file pathname + * (e.g. c:/foo, c:\bar) to NutC format. If we are handed a string that + * _NutPathToNutc() fails to convert, just return the path we were handed + * and assume the caller will know what to do with it (It was probably + * a mistake to try and convert it anyway due to some of the bizarre things + * that might look like pathnames in makefiles). + */ +char * +convert_path_to_nutc(char *path) +{ + int count; /* count of path elements */ + char *nutc_path; /* new NutC path */ + int nutc_path_len; /* length of buffer to allocate for new path */ + char *pathp; /* pointer to nutc_path used to build it */ + char *etok; /* token separator for old path */ + char *p; /* points to element of old path */ + char sep; /* what flavor of separator used in old path */ + char *rval; + + /* is this a multi-element path ? */ + for (p = path, etok = strpbrk(p, ":;"), count = 0; + etok; + etok = strpbrk(p, ":;")) + if ((etok - p) == 1) { + if (*(etok - 1) == ';' || + *(etok - 1) == ':') { + p = ++etok; + continue; /* ignore empty bucket */ + } else if (etok = strpbrk(etok+1, ":;")) + /* found one to count, handle drive letter */ + p = ++etok, count++; + else + /* all finished, force abort */ + p += strlen(p); + } else + /* found another one, no drive letter */ + p = ++etok, count++; + + if (count) { + count++; /* x1;x2;x3 <- need to count x3 */ + + /* + * Hazard a guess on how big the buffer needs to be. + * We have to convert things like c:/foo to /c=/foo. + */ + nutc_path_len = strlen(path) + (count*2) + 1; + nutc_path = xmalloc(nutc_path_len); + pathp = nutc_path; + *pathp = '\0'; + + /* + * Loop through PATH and convert one elemnt of the path at at + * a time. Single file pathnames will fail this and fall + * to the logic below loop. + */ + for (p = path, etok = strpbrk(p, ":;"); + etok; + etok = strpbrk(p, ":;")) { + + /* don't trip up on device specifiers or empty path slots */ + if ((etok - p) == 1) + if (*(etok - 1) == ';' || + *(etok - 1) == ':') { + p = ++etok; + continue; + } else if ((etok = strpbrk(etok+1, ":;")) == NULL) + break; /* thing found was a WINDOWS32 pathname */ + + /* save separator */ + sep = *etok; + + /* terminate the current path element -- temporarily */ + *etok = '\0'; + +#ifdef __NUTC__ + /* convert to NutC format */ + if (_NutPathToNutc(p, pathp, 0) == FALSE) { + free(nutc_path); + rval = savestring(path, strlen(path)); + return rval; + } +#else + *pathp++ = '/'; + *pathp++ = p[0]; + *pathp++ = '='; + *pathp++ = '/'; + strcpy(pathp, &p[2]); +#endif + + pathp += strlen(pathp); + *pathp++ = ':'; /* use Unix style path separtor for new path */ + *pathp = '\0'; /* make sure we are null terminaed */ + + /* restore path separator */ + *etok = sep; + + /* point p to first char of next path element */ + p = ++etok; + + } + } else { + nutc_path_len = strlen(path) + 3; + nutc_path = xmalloc(nutc_path_len); + pathp = nutc_path; + *pathp = '\0'; + p = path; + } + + /* + * OK, here we handle the last element in PATH (e.g. c of a;b;c) + * or the path was a single filename and will be converted + * here. Note, testing p here assures that we don't trip up + * on paths like a;b; which have trailing delimiter followed by + * nothing. + */ + if (*p != '\0') { +#ifdef __NUTC__ + if (_NutPathToNutc(p, pathp, 0) == FALSE) { + free(nutc_path); + rval = savestring(path, strlen(path)); + return rval; + } +#else + *pathp++ = '/'; + *pathp++ = p[0]; + *pathp++ = '='; + *pathp++ = '/'; + strcpy(pathp, &p[2]); +#endif + } else + *(pathp-1) = '\0'; /* we're already done, don't leave trailing : */ + + rval = savestring(nutc_path, strlen(nutc_path)); + free(nutc_path); + return rval; +} + +#endif diff --git a/flaim/external/w32/make/pathstuff.h b/flaim/external/w32/make/pathstuff.h new file mode 100644 index 0000000..a036f7b --- /dev/null +++ b/flaim/external/w32/make/pathstuff.h @@ -0,0 +1,9 @@ +#ifndef _PATHSTUFF_H +#define _PATHSTUFF_H + +extern char * convert_Path_to_windows32(char *Path, char to_delim); +extern char * convert_vpath_to_windows32(char *Path, char to_delim); +extern char * w32ify(char *file, int resolve); +extern char * getcwd_fs(char *buf, int len); + +#endif diff --git a/flaim/external/w32/make/proc.h b/flaim/external/w32/make/proc.h new file mode 100644 index 0000000..ce7a14f --- /dev/null +++ b/flaim/external/w32/make/proc.h @@ -0,0 +1,13 @@ +#ifndef _PROC_H +#define _PROC_H + +typedef int bool_t; + +#define E_SCALL 101 +#define E_IO 102 +#define E_NO_MEM 103 +#define E_FORK 104 + +extern bool_t arr2envblk(char **arr, char **envblk_out); + +#endif diff --git a/flaim/external/w32/make/read.c b/flaim/external/w32/make/read.c new file mode 100644 index 0000000..9a4c609 --- /dev/null +++ b/flaim/external/w32/make/read.c @@ -0,0 +1,3105 @@ +/* Reading and parsing of makefiles for GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" + +#include + +#include + +#include "dep.h" +#include "filedef.h" +#include "job.h" +#include "commands.h" +#include "variable.h" +#include "rule.h" +#include "debug.h" +#include "hash.h" + + +#ifndef WINDOWS32 +#ifndef _AMIGA +#ifndef VMS +#include +#else +struct passwd *getpwnam PARAMS ((char *name)); +#endif +#endif +#endif /* !WINDOWS32 */ + +/* A 'struct ebuffer' controls the origin of the makefile we are currently + eval'ing. +*/ + +struct ebuffer + { + char *buffer; /* Start of the current line in the buffer. */ + char *bufnext; /* Start of the next line in the buffer. */ + char *bufstart; /* Start of the entire buffer. */ + unsigned int size; /* Malloc'd size of buffer. */ + FILE *fp; /* File, or NULL if this is an internal buffer. */ + struct floc floc; /* Info on the file in fp (if any). */ + }; + +/* Types of "words" that can be read in a makefile. */ +enum make_word_type + { + w_bogus, w_eol, w_static, w_variable, w_colon, w_dcolon, w_semicolon, + w_varassign + }; + + +/* A `struct conditionals' contains the information describing + all the active conditionals in a makefile. + + The global variable `conditionals' contains the conditionals + information for the current makefile. It is initialized from + the static structure `toplevel_conditionals' and is later changed + to new structures for included makefiles. */ + +struct conditionals + { + unsigned int if_cmds; /* Depth of conditional nesting. */ + unsigned int allocated; /* Elts allocated in following arrays. */ + char *ignoring; /* Are we ignoring or interepreting? */ + char *seen_else; /* Have we already seen an `else'? */ + }; + +static struct conditionals toplevel_conditionals; +static struct conditionals *conditionals = &toplevel_conditionals; + + +/* Default directories to search for include files in */ + +static char *default_include_directories[] = + { +#if defined(WINDOWS32) && !defined(INCLUDEDIR) +/* + * This completely up to the user when they install MSVC or other packages. + * This is defined as a placeholder. + */ +#define INCLUDEDIR "." +#endif + INCLUDEDIR, +#ifndef _AMIGA + "/usr/gnu/include", + "/usr/local/include", + "/usr/include", +#endif + 0 + }; + +/* List of directories to search for include files in */ + +static char **include_directories; + +/* Maximum length of an element of the above. */ + +static unsigned int max_incl_len; + +/* The filename and pointer to line number of the + makefile currently being read in. */ + +const struct floc *reading_file = 0; + +/* The chain of makefiles read by read_makefile. */ + +static struct dep *read_makefiles = 0; + +static int eval_makefile PARAMS ((char *filename, int flags)); +static int eval PARAMS ((struct ebuffer *buffer, int flags)); + +static long readline PARAMS ((struct ebuffer *ebuf)); +static void do_define PARAMS ((char *name, unsigned int namelen, + enum variable_origin origin, + struct ebuffer *ebuf)); +static int conditional_line PARAMS ((char *line, const struct floc *flocp)); +static void record_files PARAMS ((struct nameseq *filenames, char *pattern, char *pattern_percent, + struct dep *deps, unsigned int cmds_started, char *commands, + unsigned int commands_idx, int two_colon, + int have_sysv_atvar, + const struct floc *flocp, int set_default)); +static void record_target_var PARAMS ((struct nameseq *filenames, char *defn, + int two_colon, + enum variable_origin origin, + const struct floc *flocp)); +static enum make_word_type get_next_mword PARAMS ((char *buffer, char *delim, + char **startp, unsigned int *length)); + +/* Read in all the makefiles and return the chain of their names. */ + +struct dep * +read_all_makefiles (makefiles) + char **makefiles; +{ + unsigned int num_makefiles = 0; + + /* Create *_LIST variables, to hold the makefiles, targets, and variables + we will be reading. */ + + define_variable ("MAKEFILE_LIST", sizeof ("MAKEFILE_LIST")-1, "", o_file, 0); + + DB (DB_BASIC, (_("Reading makefiles...\n"))); + + /* If there's a non-null variable MAKEFILES, its value is a list of + files to read first thing. But don't let it prevent reading the + default makefiles and don't let the default goal come from there. */ + + { + char *value; + char *name, *p; + unsigned int length; + + { + /* Turn off --warn-undefined-variables while we expand MAKEFILES. */ + int save = warn_undefined_variables_flag; + warn_undefined_variables_flag = 0; + + value = allocated_variable_expand ("$(MAKEFILES)"); + + warn_undefined_variables_flag = save; + } + + /* Set NAME to the start of next token and LENGTH to its length. + MAKEFILES is updated for finding remaining tokens. */ + p = value; + + while ((name = find_next_token (&p, &length)) != 0) + { + if (*p != '\0') + *p++ = '\0'; + name = xstrdup (name); + if (eval_makefile (name, + RM_NO_DEFAULT_GOAL|RM_INCLUDED|RM_DONTCARE) < 2) + free (name); + } + + free (value); + } + + /* Read makefiles specified with -f switches. */ + + if (makefiles != 0) + while (*makefiles != 0) + { + struct dep *tail = read_makefiles; + register struct dep *d; + + if (! eval_makefile (*makefiles, 0)) + perror_with_name ("", *makefiles); + + /* Find the right element of read_makefiles. */ + d = read_makefiles; + while (d->next != tail) + d = d->next; + + /* Use the storage read_makefile allocates. */ + *makefiles = dep_name (d); + ++num_makefiles; + ++makefiles; + } + + /* If there were no -f switches, try the default names. */ + + if (num_makefiles == 0) + { + static char *default_makefiles[] = +#ifdef VMS + /* all lower case since readdir() (the vms version) 'lowercasifies' */ + { "makefile.vms", "gnumakefile.", "makefile.", 0 }; +#else +#ifdef _AMIGA + { "GNUmakefile", "Makefile", "SMakefile", 0 }; +#else /* !Amiga && !VMS */ + { "GNUmakefile", "makefile", "Makefile", 0 }; +#endif /* AMIGA */ +#endif /* VMS */ + register char **p = default_makefiles; + while (*p != 0 && !file_exists_p (*p)) + ++p; + + if (*p != 0) + { + if (! eval_makefile (*p, 0)) + perror_with_name ("", *p); + } + else + { + /* No default makefile was found. Add the default makefiles to the + `read_makefiles' chain so they will be updated if possible. */ + struct dep *tail = read_makefiles; + /* Add them to the tail, after any MAKEFILES variable makefiles. */ + while (tail != 0 && tail->next != 0) + tail = tail->next; + for (p = default_makefiles; *p != 0; ++p) + { + struct dep *d = (struct dep *) xmalloc (sizeof (struct dep)); + d->name = 0; + d->file = enter_file (*p); + d->file->dontcare = 1; + d->ignore_mtime = 0; + /* Tell update_goal_chain to bail out as soon as this file is + made, and main not to die if we can't make this file. */ + d->changed = RM_DONTCARE; + if (tail == 0) + read_makefiles = d; + else + tail->next = d; + tail = d; + } + if (tail != 0) + tail->next = 0; + } + } + + return read_makefiles; +} + +static int +eval_makefile (filename, flags) + char *filename; + int flags; +{ + struct dep *deps; + struct ebuffer ebuf; + const struct floc *curfile; + int makefile_errno; + int r; + + ebuf.floc.filenm = filename; + ebuf.floc.lineno = 1; + + if (ISDB (DB_VERBOSE)) + { + printf (_("Reading makefile `%s'"), filename); + if (flags & RM_NO_DEFAULT_GOAL) + printf (_(" (no default goal)")); + if (flags & RM_INCLUDED) + printf (_(" (search path)")); + if (flags & RM_DONTCARE) + printf (_(" (don't care)")); + if (flags & RM_NO_TILDE) + printf (_(" (no ~ expansion)")); + puts ("..."); + } + + /* First, get a stream to read. */ + + /* Expand ~ in FILENAME unless it came from `include', + in which case it was already done. */ + if (!(flags & RM_NO_TILDE) && filename[0] == '~') + { + char *expanded = tilde_expand (filename); + if (expanded != 0) + filename = expanded; + } + + ebuf.fp = fopen (filename, "r"); + /* Save the error code so we print the right message later. */ + makefile_errno = errno; + + /* If the makefile wasn't found and it's either a makefile from + the `MAKEFILES' variable or an included makefile, + search the included makefile search path for this makefile. */ + if (ebuf.fp == 0 && (flags & RM_INCLUDED) && *filename != '/') + { + register unsigned int i; + for (i = 0; include_directories[i] != 0; ++i) + { + char *name = concat (include_directories[i], "/", filename); + ebuf.fp = fopen (name, "r"); + if (ebuf.fp == 0) + free (name); + else + { + filename = name; + break; + } + } + } + + /* Add FILENAME to the chain of read makefiles. */ + deps = (struct dep *) xmalloc (sizeof (struct dep)); + deps->next = read_makefiles; + read_makefiles = deps; + deps->name = 0; + deps->file = lookup_file (filename); + if (deps->file == 0) + { + deps->file = enter_file (xstrdup (filename)); + if (flags & RM_DONTCARE) + deps->file->dontcare = 1; + } + if (filename != ebuf.floc.filenm) + free (filename); + filename = deps->file->name; + deps->changed = flags; + deps->ignore_mtime = 0; + + /* If the makefile can't be found at all, give up entirely. */ + + if (ebuf.fp == 0) + { + /* If we did some searching, errno has the error from the last + attempt, rather from FILENAME itself. Restore it in case the + caller wants to use it in a message. */ + errno = makefile_errno; + return 0; + } + + /* Add this makefile to the list. */ + do_variable_definition (&ebuf.floc, "MAKEFILE_LIST", filename, o_file, + f_append, 0); + + /* Evaluate the makefile */ + + ebuf.size = 200; + ebuf.buffer = ebuf.bufnext = ebuf.bufstart = xmalloc (ebuf.size); + + curfile = reading_file; + reading_file = &ebuf.floc; + + r = eval (&ebuf, !(flags & RM_NO_DEFAULT_GOAL)); + + reading_file = curfile; + + fclose (ebuf.fp); + + free (ebuf.bufstart); + return r; +} + +int +eval_buffer (buffer) + char *buffer; +{ + struct ebuffer ebuf; + const struct floc *curfile; + int r; + + /* Evaluate the buffer */ + + ebuf.size = strlen (buffer); + ebuf.buffer = ebuf.bufnext = ebuf.bufstart = buffer; + ebuf.fp = NULL; + + ebuf.floc = *reading_file; + + curfile = reading_file; + reading_file = &ebuf.floc; + + r = eval (&ebuf, 1); + + reading_file = curfile; + + return r; +} + + +/* Read file FILENAME as a makefile and add its contents to the data base. + + SET_DEFAULT is true if we are allowed to set the default goal. + + FILENAME is added to the `read_makefiles' chain. + + Returns 0 if a file was not found or not read. + Returns 1 if FILENAME was found and read. + Returns 2 if FILENAME was read, and we kept a reference (don't free it). */ + +static int +eval (ebuf, set_default) + struct ebuffer *ebuf; + int set_default; +{ + static char *collapsed = 0; + static unsigned int collapsed_length = 0; + unsigned int commands_len = 200; + char *commands; + unsigned int commands_idx = 0; + unsigned int cmds_started, tgts_started; + int ignoring = 0, in_ignored_define = 0; + int no_targets = 0; /* Set when reading a rule without targets. */ + int have_sysv_atvar = 0; + struct nameseq *filenames = 0; + struct dep *deps = 0; + long nlines = 0; + int two_colon = 0; + char *pattern = 0, *pattern_percent; + struct floc *fstart; + struct floc fi; + +#define record_waiting_files() \ + do \ + { \ + if (filenames != 0) \ + { \ + fi.lineno = tgts_started; \ + record_files (filenames, pattern, pattern_percent, deps, \ + cmds_started, commands, commands_idx, two_colon, \ + have_sysv_atvar, &fi, set_default); \ + } \ + filenames = 0; \ + commands_idx = 0; \ + no_targets = 0; \ + if (pattern) { free(pattern); pattern = 0; } \ + } while (0) + + pattern_percent = 0; + cmds_started = tgts_started = 1; + + fstart = &ebuf->floc; + fi.filenm = ebuf->floc.filenm; + + /* Loop over lines in the file. + The strategy is to accumulate target names in FILENAMES, dependencies + in DEPS and commands in COMMANDS. These are used to define a rule + when the start of the next rule (or eof) is encountered. + + When you see a "continue" in the loop below, that means we are moving on + to the next line _without_ ending any rule that we happen to be working + with at the moment. If you see a "goto rule_complete", then the + statement we just parsed also finishes the previous rule. */ + + commands = xmalloc (200); + + while (1) + { + int linelen; + char *line; + int len; + char *p; + char *p2; + + /* Grab the next line to be evaluated */ + ebuf->floc.lineno += nlines; + nlines = readline (ebuf); + + /* If there is nothing left to eval, we're done. */ + if (nlines < 0) + break; + + /* If this line is empty, skip it. */ + line = ebuf->buffer; + if (line[0] == '\0') + continue; + + linelen = strlen (line); + + /* Check for a shell command line first. + If it is not one, we can stop treating tab specially. */ + if (line[0] == '\t') + { + if (no_targets) + /* Ignore the commands in a rule with no targets. */ + continue; + + /* If there is no preceding rule line, don't treat this line + as a command, even though it begins with a tab character. + SunOS 4 make appears to behave this way. */ + + if (filenames != 0) + { + if (ignoring) + /* Yep, this is a shell command, and we don't care. */ + continue; + + /* Append this command line to the line being accumulated. */ + if (commands_idx == 0) + cmds_started = ebuf->floc.lineno; + + if (linelen + 1 + commands_idx > commands_len) + { + commands_len = (linelen + 1 + commands_idx) * 2; + commands = xrealloc (commands, commands_len); + } + bcopy (line, &commands[commands_idx], linelen); + commands_idx += linelen; + commands[commands_idx++] = '\n'; + + continue; + } + } + + /* This line is not a shell command line. Don't worry about tabs. */ + + if (collapsed_length < linelen+1) + { + collapsed_length = linelen+1; + if (collapsed != 0) + free (collapsed); + collapsed = (char *) xmalloc (collapsed_length); + } + strcpy (collapsed, line); + /* Collapse continuation lines. */ + collapse_continuations (collapsed); + remove_comments (collapsed); + + /* Compare a word, both length and contents. */ +#define word1eq(s) (len == sizeof(s)-1 && strneq (s, p, sizeof(s)-1)) + p = collapsed; + while (isspace ((unsigned char)*p)) + ++p; + + if (*p == '\0') + /* This line is completely empty--ignore it. */ + continue; + + /* Find the end of the first token. Note we don't need to worry about + * ":" here since we compare tokens by length (so "export" will never + * be equal to "export:"). + */ + for (p2 = p+1; *p2 != '\0' && !isspace ((unsigned char)*p2); ++p2) + ; + len = p2 - p; + + /* Find the start of the second token. If it looks like a target or + variable definition it can't be a preprocessor token so skip + them--this allows variables/targets named `ifdef', `export', etc. */ + while (isspace ((unsigned char)*p2)) + ++p2; + + if ((p2[0] == ':' || p2[0] == '+' || p2[0] == '=') && p2[1] == '\0') + { + /* It can't be a preprocessor token so skip it if we're ignoring */ + if (ignoring) + continue; + + goto skip_conditionals; + } + + /* We must first check for conditional and `define' directives before + ignoring anything, since they control what we will do with + following lines. */ + + if (!in_ignored_define + && (word1eq ("ifdef") || word1eq ("ifndef") + || word1eq ("ifeq") || word1eq ("ifneq") + || word1eq ("else") || word1eq ("endif"))) + { + int i = conditional_line (p, fstart); + if (i < 0) + fatal (fstart, _("invalid syntax in conditional")); + + ignoring = i; + continue; + } + + if (word1eq ("endef")) + { + if (!in_ignored_define) + fatal (fstart, _("extraneous `endef'")); + in_ignored_define = 0; + continue; + } + + if (word1eq ("define")) + { + if (ignoring) + in_ignored_define = 1; + else + { + if (*p2 == '\0') + fatal (fstart, _("empty variable name")); + + /* Let the variable name be the whole rest of the line, + with trailing blanks stripped (comments have already been + removed), so it could be a complex variable/function + reference that might contain blanks. */ + p = strchr (p2, '\0'); + while (isblank ((unsigned char)p[-1])) + --p; + do_define (p2, p - p2, o_file, ebuf); + } + continue; + } + + if (word1eq ("override")) + { + if (*p2 == '\0') + error (fstart, _("empty `override' directive")); + + if (strneq (p2, "define", 6) + && (isblank ((unsigned char)p2[6]) || p2[6] == '\0')) + { + if (ignoring) + in_ignored_define = 1; + else + { + p2 = next_token (p2 + 6); + if (*p2 == '\0') + fatal (fstart, _("empty variable name")); + + /* Let the variable name be the whole rest of the line, + with trailing blanks stripped (comments have already been + removed), so it could be a complex variable/function + reference that might contain blanks. */ + p = strchr (p2, '\0'); + while (isblank ((unsigned char)p[-1])) + --p; + do_define (p2, p - p2, o_override, ebuf); + } + } + else if (!ignoring + && !try_variable_definition (fstart, p2, o_override, 0)) + error (fstart, _("invalid `override' directive")); + + continue; + } + + if (ignoring) + /* Ignore the line. We continue here so conditionals + can appear in the middle of a rule. */ + continue; + + if (word1eq ("export")) + { + /* 'export' by itself causes everything to be exported. */ + if (*p2 == '\0') + export_all_variables = 1; + else + { + struct variable *v; + + v = try_variable_definition (fstart, p2, o_file, 0); + if (v != 0) + v->export = v_export; + else + { + unsigned int len; + char *ap; + + /* Expand the line so we can use indirect and constructed + variable names in an export command. */ + p2 = ap = allocated_variable_expand (p2); + + for (p = find_next_token (&p2, &len); p != 0; + p = find_next_token (&p2, &len)) + { + v = lookup_variable (p, len); + if (v == 0) + v = define_variable_loc (p, len, "", o_file, 0, + fstart); + v->export = v_export; + } + + free (ap); + } + } + goto rule_complete; + } + + if (word1eq ("unexport")) + { + if (*p2 == '\0') + export_all_variables = 0; + else + { + unsigned int len; + struct variable *v; + char *ap; + + /* Expand the line so we can use indirect and constructed + variable names in an unexport command. */ + p2 = ap = allocated_variable_expand (p2); + + for (p = find_next_token (&p2, &len); p != 0; + p = find_next_token (&p2, &len)) + { + v = lookup_variable (p, len); + if (v == 0) + v = define_variable_loc (p, len, "", o_file, 0, fstart); + + v->export = v_noexport; + } + + free (ap); + } + goto rule_complete; + } + + skip_conditionals: + if (word1eq ("vpath")) + { + char *pattern; + unsigned int len; + p2 = variable_expand (p2); + p = find_next_token (&p2, &len); + if (p != 0) + { + pattern = savestring (p, len); + p = find_next_token (&p2, &len); + /* No searchpath means remove all previous + selective VPATH's with the same pattern. */ + } + else + /* No pattern means remove all previous selective VPATH's. */ + pattern = 0; + construct_vpath_list (pattern, p); + if (pattern != 0) + free (pattern); + + goto rule_complete; + } + + if (word1eq ("include") || word1eq ("-include") || word1eq ("sinclude")) + { + /* We have found an `include' line specifying a nested + makefile to be read at this point. */ + struct conditionals *save; + struct conditionals new_conditionals; + struct nameseq *files; + /* "-include" (vs "include") says no error if the file does not + exist. "sinclude" is an alias for this from SGI. */ + int noerror = (p[0] != 'i'); + + p = allocated_variable_expand (p2); + if (*p == '\0') + { + error (fstart, + _("no file name for `%sinclude'"), noerror ? "-" : ""); + continue; + } + + /* Parse the list of file names. */ + p2 = p; + files = multi_glob (parse_file_seq (&p2, '\0', + sizeof (struct nameseq), + 1), + sizeof (struct nameseq)); + free (p); + + /* Save the state of conditionals and start + the included makefile with a clean slate. */ + save = conditionals; + bzero ((char *) &new_conditionals, sizeof new_conditionals); + conditionals = &new_conditionals; + + /* Record the rules that are waiting so they will determine + the default goal before those in the included makefile. */ + record_waiting_files (); + + /* Read each included makefile. */ + while (files != 0) + { + struct nameseq *next = files->next; + char *name = files->name; + int r; + + free ((char *)files); + files = next; + + r = eval_makefile (name, (RM_INCLUDED | RM_NO_TILDE + | (noerror ? RM_DONTCARE : 0))); + if (!r) + { + if (!noerror) + error (fstart, "%s: %s", name, strerror (errno)); + free (name); + } + } + + /* Free any space allocated by conditional_line. */ + if (conditionals->ignoring) + free (conditionals->ignoring); + if (conditionals->seen_else) + free (conditionals->seen_else); + + /* Restore state. */ + conditionals = save; + + goto rule_complete; + } + + if (try_variable_definition (fstart, p, o_file, 0)) + /* This line has been dealt with. */ + goto rule_complete; + + if (line[0] == '\t') + { + p = collapsed; /* Ignore comments, etc. */ + while (isblank ((unsigned char)*p)) + ++p; + if (*p == '\0') + /* The line is completely blank; that is harmless. */ + continue; + + /* This line starts with a tab but was not caught above + because there was no preceding target, and the line + might have been usable as a variable definition. + But now we know it is definitely lossage. */ + fatal(fstart, _("commands commence before first target")); + } + + /* This line describes some target files. This is complicated by + the existence of target-specific variables, because we can't + expand the entire line until we know if we have one or not. So + we expand the line word by word until we find the first `:', + then check to see if it's a target-specific variable. + + In this algorithm, `lb_next' will point to the beginning of the + unexpanded parts of the input buffer, while `p2' points to the + parts of the expanded buffer we haven't searched yet. */ + + { + enum make_word_type wtype; + enum variable_origin v_origin; + char *cmdleft, *semip, *lb_next; + unsigned int len, plen = 0; + char *colonp; + + /* Record the previous rule. */ + + record_waiting_files (); + tgts_started = fstart->lineno; + + /* Search the line for an unquoted ; that is not after an + unquoted #. */ + cmdleft = find_char_unquote (line, ';', '#', 0); + if (cmdleft != 0 && *cmdleft == '#') + { + /* We found a comment before a semicolon. */ + *cmdleft = '\0'; + cmdleft = 0; + } + else if (cmdleft != 0) + /* Found one. Cut the line short there before expanding it. */ + *(cmdleft++) = '\0'; + semip = cmdleft; + + collapse_continuations (line); + + /* We can't expand the entire line, since if it's a per-target + variable we don't want to expand it. So, walk from the + beginning, expanding as we go, and looking for "interesting" + chars. The first word is always expandable. */ + wtype = get_next_mword(line, NULL, &lb_next, &len); + switch (wtype) + { + case w_eol: + if (cmdleft != 0) + fatal(fstart, _("missing rule before commands")); + /* This line contained something but turned out to be nothing + but whitespace (a comment?). */ + continue; + + case w_colon: + case w_dcolon: + /* We accept and ignore rules without targets for + compatibility with SunOS 4 make. */ + no_targets = 1; + continue; + + default: + break; + } + + p2 = variable_expand_string(NULL, lb_next, len); + while (1) + { + lb_next += len; + if (cmdleft == 0) + { + /* Look for a semicolon in the expanded line. */ + cmdleft = find_char_unquote (p2, ';', 0, 0); + + if (cmdleft != 0) + { + unsigned long p2_off = p2 - variable_buffer; + unsigned long cmd_off = cmdleft - variable_buffer; + char *pend = p2 + strlen(p2); + + /* Append any remnants of lb, then cut the line short + at the semicolon. */ + *cmdleft = '\0'; + + /* One school of thought says that you shouldn't expand + here, but merely copy, since now you're beyond a ";" + and into a command script. However, the old parser + expanded the whole line, so we continue that for + backwards-compatiblity. Also, it wouldn't be + entirely consistent, since we do an unconditional + expand below once we know we don't have a + target-specific variable. */ + (void)variable_expand_string(pend, lb_next, (long)-1); + lb_next += strlen(lb_next); + p2 = variable_buffer + p2_off; + cmdleft = variable_buffer + cmd_off + 1; + } + } + + colonp = find_char_unquote(p2, ':', 0, 0); +#ifdef HAVE_DOS_PATHS + /* The drive spec brain-damage strikes again... */ + /* Note that the only separators of targets in this context + are whitespace and a left paren. If others are possible, + they should be added to the string in the call to index. */ + while (colonp && (colonp[1] == '/' || colonp[1] == '\\') && + colonp > p2 && isalpha ((unsigned char)colonp[-1]) && + (colonp == p2 + 1 || strchr (" \t(", colonp[-2]) != 0)) + colonp = find_char_unquote(colonp + 1, ':', 0, 0); +#endif + if (colonp != 0) + break; + + wtype = get_next_mword(lb_next, NULL, &lb_next, &len); + if (wtype == w_eol) + break; + + p2 += strlen(p2); + *(p2++) = ' '; + p2 = variable_expand_string(p2, lb_next, len); + /* We don't need to worry about cmdleft here, because if it was + found in the variable_buffer the entire buffer has already + been expanded... we'll never get here. */ + } + + p2 = next_token (variable_buffer); + + /* If the word we're looking at is EOL, see if there's _anything_ + on the line. If not, a variable expanded to nothing, so ignore + it. If so, we can't parse this line so punt. */ + if (wtype == w_eol) + { + if (*p2 != '\0') + /* There's no need to be ivory-tower about this: check for + one of the most common bugs found in makefiles... */ + fatal (fstart, _("missing separator%s"), + !strneq(line, " ", 8) ? "" + : _(" (did you mean TAB instead of 8 spaces?)")); + continue; + } + + /* Make the colon the end-of-string so we know where to stop + looking for targets. */ + *colonp = '\0'; + filenames = multi_glob (parse_file_seq (&p2, '\0', + sizeof (struct nameseq), + 1), + sizeof (struct nameseq)); + *p2 = ':'; + + if (!filenames) + { + /* We accept and ignore rules without targets for + compatibility with SunOS 4 make. */ + no_targets = 1; + continue; + } + /* This should never be possible; we handled it above. */ + assert (*p2 != '\0'); + ++p2; + + /* Is this a one-colon or two-colon entry? */ + two_colon = *p2 == ':'; + if (two_colon) + p2++; + + /* Test to see if it's a target-specific variable. Copy the rest + of the buffer over, possibly temporarily (we'll expand it later + if it's not a target-specific variable). PLEN saves the length + of the unparsed section of p2, for later. */ + if (*lb_next != '\0') + { + unsigned int l = p2 - variable_buffer; + plen = strlen (p2); + (void) variable_buffer_output (p2+plen, + lb_next, strlen (lb_next)+1); + p2 = variable_buffer + l; + } + + /* See if it's an "override" keyword; if so see if what comes after + it looks like a variable definition. */ + + wtype = get_next_mword (p2, NULL, &p, &len); + + v_origin = o_file; + if (wtype == w_static && word1eq ("override")) + { + v_origin = o_override; + wtype = get_next_mword (p+len, NULL, &p, &len); + } + + if (wtype != w_eol) + wtype = get_next_mword (p+len, NULL, NULL, NULL); + + if (wtype == w_varassign) + { + /* If there was a semicolon found, add it back, plus anything + after it. */ + if (semip) + { + *(--semip) = ';'; + variable_buffer_output (p2 + strlen (p2), + semip, strlen (semip)+1); + } + record_target_var (filenames, p, two_colon, v_origin, fstart); + filenames = 0; + continue; + } + + /* This is a normal target, _not_ a target-specific variable. + Unquote any = in the dependency list. */ + find_char_unquote (lb_next, '=', 0, 0); + + /* We have some targets, so don't ignore the following commands. */ + no_targets = 0; + + /* Expand the dependencies, etc. */ + if (*lb_next != '\0') + { + unsigned int l = p2 - variable_buffer; + (void) variable_expand_string (p2 + plen, lb_next, (long)-1); + p2 = variable_buffer + l; + + /* Look for a semicolon in the expanded line. */ + if (cmdleft == 0) + { + cmdleft = find_char_unquote (p2, ';', 0, 0); + if (cmdleft != 0) + *(cmdleft++) = '\0'; + } + } + + /* Do any of the prerequisites appear to have $@ etc.? */ + have_sysv_atvar = 0; + if (!posix_pedantic) + for (p = strchr (p2, '$'); p != 0; p = strchr (p+1, '$')) + if (p[1] == '@' || (p[1] == '(' && p[2] == '@')) + { + have_sysv_atvar = 1; + break; + } + + /* Is this a static pattern rule: `target: %targ: %dep; ...'? */ + p = strchr (p2, ':'); + while (p != 0 && p[-1] == '\\') + { + register char *q = &p[-1]; + register int backslash = 0; + while (*q-- == '\\') + backslash = !backslash; + if (backslash) + p = strchr (p + 1, ':'); + else + break; + } +#ifdef _AMIGA + /* Here, the situation is quite complicated. Let's have a look + at a couple of targets: + + install: dev:make + + dev:make: make + + dev:make:: xyz + + The rule is that it's only a target, if there are TWO :'s + OR a space around the :. + */ + if (p && !(isspace ((unsigned char)p[1]) || !p[1] + || isspace ((unsigned char)p[-1]))) + p = 0; +#endif +#ifdef HAVE_DOS_PATHS + { + int check_again; + + do { + check_again = 0; + /* For DOS paths, skip a "C:\..." or a "C:/..." */ + if (p != 0 && (p[1] == '\\' || p[1] == '/') && + isalpha ((unsigned char)p[-1]) && + (p == p2 + 1 || strchr (" \t:(", p[-2]) != 0)) { + p = strchr (p + 1, ':'); + check_again = 1; + } + } while (check_again); + } +#endif + if (p != 0) + { + struct nameseq *target; + target = parse_file_seq (&p2, ':', sizeof (struct nameseq), 1); + ++p2; + if (target == 0) + fatal (fstart, _("missing target pattern")); + else if (target->next != 0) + fatal (fstart, _("multiple target patterns")); + pattern = target->name; + pattern_percent = find_percent (pattern); + if (pattern_percent == 0) + fatal (fstart, _("target pattern contains no `%%'")); + free((char *)target); + } + else + pattern = 0; + + /* Parse the dependencies. */ + deps = (struct dep *) + multi_glob (parse_file_seq (&p2, '|', sizeof (struct dep), 1), + sizeof (struct dep)); + if (*p2) + { + /* Files that follow '|' are special prerequisites that + need only exist in order to satisfy the dependency. + Their modification times are irrelevant. */ + struct dep **deps_ptr = &deps; + struct dep *d; + for (deps_ptr = &deps; *deps_ptr; deps_ptr = &(*deps_ptr)->next) + ; + ++p2; + *deps_ptr = (struct dep *) + multi_glob (parse_file_seq (&p2, '\0', sizeof (struct dep), 1), + sizeof (struct dep)); + for (d = *deps_ptr; d != 0; d = d->next) + d->ignore_mtime = 1; + } + + commands_idx = 0; + if (cmdleft != 0) + { + /* Semicolon means rest of line is a command. */ + unsigned int len = strlen (cmdleft); + + cmds_started = fstart->lineno; + + /* Add this command line to the buffer. */ + if (len + 2 > commands_len) + { + commands_len = (len + 2) * 2; + commands = (char *) xrealloc (commands, commands_len); + } + bcopy (cmdleft, commands, len); + commands_idx += len; + commands[commands_idx++] = '\n'; + } + + continue; + } + + /* We get here except in the case that we just read a rule line. + Record now the last rule we read, so following spurious + commands are properly diagnosed. */ + rule_complete: + record_waiting_files (); + } + +#undef word1eq + + if (conditionals->if_cmds) + fatal (fstart, _("missing `endif'")); + + /* At eof, record the last rule. */ + record_waiting_files (); + + free ((char *) commands); + + return 1; +} + + +/* Execute a `define' directive. + The first line has already been read, and NAME is the name of + the variable to be defined. The following lines remain to be read. */ + +static void +do_define (name, namelen, origin, ebuf) + char *name; + unsigned int namelen; + enum variable_origin origin; + struct ebuffer *ebuf; +{ + struct floc defstart; + long nlines = 0; + int nlevels = 1; + unsigned int length = 100; + char *definition = (char *) xmalloc (length); + unsigned int idx = 0; + char *p; + + /* Expand the variable name. */ + char *var = (char *) alloca (namelen + 1); + bcopy (name, var, namelen); + var[namelen] = '\0'; + var = variable_expand (var); + + defstart = ebuf->floc; + + while (1) + { + unsigned int len; + char *line; + + ebuf->floc.lineno += nlines; + nlines = readline (ebuf); + + /* If there is nothing left to eval, we're done. */ + if (nlines < 0) + break; + + line = ebuf->buffer; + + collapse_continuations (line); + + /* If the line doesn't begin with a tab, test to see if it introduces + another define, or ends one. */ + + /* Stop if we find an 'endef' */ + if (line[0] != '\t') + { + p = next_token (line); + len = strlen (p); + + /* If this is another 'define', increment the level count. */ + if ((len == 6 || (len > 6 && isblank ((unsigned char)p[6]))) + && strneq (p, "define", 6)) + ++nlevels; + + /* If this is an 'endef', decrement the count. If it's now 0, + we've found the last one. */ + else if ((len == 5 || (len > 5 && isblank ((unsigned char)p[5]))) + && strneq (p, "endef", 5)) + { + p += 5; + remove_comments (p); + if (*next_token (p) != '\0') + error (&ebuf->floc, + _("Extraneous text after `endef' directive")); + + if (--nlevels == 0) + { + /* Define the variable. */ + if (idx == 0) + definition[0] = '\0'; + else + definition[idx - 1] = '\0'; + + /* Always define these variables in the global set. */ + define_variable_global (var, strlen (var), definition, + origin, 1, &defstart); + free (definition); + return; + } + } + } + + /* Otherwise add this line to the variable definition. */ + len = strlen (line); + if (idx + len + 1 > length) + { + length = (idx + len) * 2; + definition = (char *) xrealloc (definition, length + 1); + } + + bcopy (line, &definition[idx], len); + idx += len; + /* Separate lines with a newline. */ + definition[idx++] = '\n'; + } + + /* No `endef'!! */ + fatal (&defstart, _("missing `endef', unterminated `define'")); + + /* NOTREACHED */ + return; +} + +/* Interpret conditional commands "ifdef", "ifndef", "ifeq", + "ifneq", "else" and "endif". + LINE is the input line, with the command as its first word. + + FILENAME and LINENO are the filename and line number in the + current makefile. They are used for error messages. + + Value is -1 if the line is invalid, + 0 if following text should be interpreted, + 1 if following text should be ignored. */ + +static int +conditional_line (line, flocp) + char *line; + const struct floc *flocp; +{ + int notdef; + char *cmdname; + register unsigned int i; + + if (*line == 'i') + { + /* It's an "if..." command. */ + notdef = line[2] == 'n'; + if (notdef) + { + cmdname = line[3] == 'd' ? "ifndef" : "ifneq"; + line += cmdname[3] == 'd' ? 7 : 6; + } + else + { + cmdname = line[2] == 'd' ? "ifdef" : "ifeq"; + line += cmdname[2] == 'd' ? 6 : 5; + } + } + else + { + /* It's an "else" or "endif" command. */ + notdef = line[1] == 'n'; + cmdname = notdef ? "endif" : "else"; + line += notdef ? 5 : 4; + } + + line = next_token (line); + + if (*cmdname == 'e') + { + if (*line != '\0') + error (flocp, _("Extraneous text after `%s' directive"), cmdname); + /* "Else" or "endif". */ + if (conditionals->if_cmds == 0) + fatal (flocp, _("extraneous `%s'"), cmdname); + /* NOTDEF indicates an `endif' command. */ + if (notdef) + --conditionals->if_cmds; + else if (conditionals->seen_else[conditionals->if_cmds - 1]) + fatal (flocp, _("only one `else' per conditional")); + else + { + /* Toggle the state of ignorance. */ + conditionals->ignoring[conditionals->if_cmds - 1] + = !conditionals->ignoring[conditionals->if_cmds - 1]; + /* Record that we have seen an `else' in this conditional. + A second `else' will be erroneous. */ + conditionals->seen_else[conditionals->if_cmds - 1] = 1; + } + for (i = 0; i < conditionals->if_cmds; ++i) + if (conditionals->ignoring[i]) + return 1; + return 0; + } + + if (conditionals->allocated == 0) + { + conditionals->allocated = 5; + conditionals->ignoring = (char *) xmalloc (conditionals->allocated); + conditionals->seen_else = (char *) xmalloc (conditionals->allocated); + } + + ++conditionals->if_cmds; + if (conditionals->if_cmds > conditionals->allocated) + { + conditionals->allocated += 5; + conditionals->ignoring = (char *) + xrealloc (conditionals->ignoring, conditionals->allocated); + conditionals->seen_else = (char *) + xrealloc (conditionals->seen_else, conditionals->allocated); + } + + /* Record that we have seen an `if...' but no `else' so far. */ + conditionals->seen_else[conditionals->if_cmds - 1] = 0; + + /* Search through the stack to see if we're already ignoring. */ + for (i = 0; i < conditionals->if_cmds - 1; ++i) + if (conditionals->ignoring[i]) + { + /* We are already ignoring, so just push a level + to match the next "else" or "endif", and keep ignoring. + We don't want to expand variables in the condition. */ + conditionals->ignoring[conditionals->if_cmds - 1] = 1; + return 1; + } + + if (cmdname[notdef ? 3 : 2] == 'd') + { + /* "Ifdef" or "ifndef". */ + char *var; + struct variable *v; + register char *p = end_of_token (line); + i = p - line; + p = next_token (p); + if (*p != '\0') + return -1; + + /* Expand the thing we're looking up, so we can use indirect and + constructed variable names. */ + line[i] = '\0'; + var = allocated_variable_expand (line); + + v = lookup_variable (var, strlen (var)); + conditionals->ignoring[conditionals->if_cmds - 1] + = (v != 0 && *v->value != '\0') == notdef; + + free (var); + } + else + { + /* "Ifeq" or "ifneq". */ + char *s1, *s2; + unsigned int len; + char termin = *line == '(' ? ',' : *line; + + if (termin != ',' && termin != '"' && termin != '\'') + return -1; + + s1 = ++line; + /* Find the end of the first string. */ + if (termin == ',') + { + register int count = 0; + for (; *line != '\0'; ++line) + if (*line == '(') + ++count; + else if (*line == ')') + --count; + else if (*line == ',' && count <= 0) + break; + } + else + while (*line != '\0' && *line != termin) + ++line; + + if (*line == '\0') + return -1; + + if (termin == ',') + { + /* Strip blanks after the first string. */ + char *p = line++; + while (isblank ((unsigned char)p[-1])) + --p; + *p = '\0'; + } + else + *line++ = '\0'; + + s2 = variable_expand (s1); + /* We must allocate a new copy of the expanded string because + variable_expand re-uses the same buffer. */ + len = strlen (s2); + s1 = (char *) alloca (len + 1); + bcopy (s2, s1, len + 1); + + if (termin != ',') + /* Find the start of the second string. */ + line = next_token (line); + + termin = termin == ',' ? ')' : *line; + if (termin != ')' && termin != '"' && termin != '\'') + return -1; + + /* Find the end of the second string. */ + if (termin == ')') + { + register int count = 0; + s2 = next_token (line); + for (line = s2; *line != '\0'; ++line) + { + if (*line == '(') + ++count; + else if (*line == ')') + { + if (count <= 0) + break; + else + --count; + } + } + } + else + { + ++line; + s2 = line; + while (*line != '\0' && *line != termin) + ++line; + } + + if (*line == '\0') + return -1; + + *line = '\0'; + line = next_token (++line); + if (*line != '\0') + error (flocp, _("Extraneous text after `%s' directive"), cmdname); + + s2 = variable_expand (s2); + conditionals->ignoring[conditionals->if_cmds - 1] + = streq (s1, s2) == notdef; + } + + /* Search through the stack to see if we're ignoring. */ + for (i = 0; i < conditionals->if_cmds; ++i) + if (conditionals->ignoring[i]) + return 1; + return 0; +} + +/* Remove duplicate dependencies in CHAIN. */ + +static unsigned long +dep_hash_1 (key) + const void *key; +{ + return_STRING_HASH_1 (dep_name ((struct dep const *) key)); +} + +static unsigned long +dep_hash_2 (key) + const void *key; +{ + return_STRING_HASH_2 (dep_name ((struct dep const *) key)); +} + +static int +dep_hash_cmp (x, y) + const void *x; + const void *y; +{ + struct dep *dx = (struct dep *) x; + struct dep *dy = (struct dep *) y; + int cmp = strcmp (dep_name (dx), dep_name (dy)); + + /* If the names are the same but ignore_mtimes are not equal, one of these + is an order-only prerequisite and one isn't. That means that we should + remove the one that isn't and keep the one that is. */ + + if (!cmp && dx->ignore_mtime != dy->ignore_mtime) + dx->ignore_mtime = dy->ignore_mtime = 0; + + return cmp; +} + + +void +uniquize_deps (chain) + struct dep *chain; +{ + struct hash_table deps; + register struct dep **depp; + + hash_init (&deps, 500, dep_hash_1, dep_hash_2, dep_hash_cmp); + + /* Make sure that no dependencies are repeated. This does not + really matter for the purpose of updating targets, but it + might make some names be listed twice for $^ and $?. */ + + depp = &chain; + while (*depp) + { + struct dep *dep = *depp; + struct dep **dep_slot = (struct dep **) hash_find_slot (&deps, dep); + if (HASH_VACANT (*dep_slot)) + { + hash_insert_at (&deps, dep, dep_slot); + depp = &dep->next; + } + else + { + /* Don't bother freeing duplicates. + It's dangerous and little benefit accrues. */ + *depp = dep->next; + } + } + + hash_free (&deps, 0); +} + +/* Record target-specific variable values for files FILENAMES. + TWO_COLON is nonzero if a double colon was used. + + The links of FILENAMES are freed, and so are any names in it + that are not incorporated into other data structures. + + If the target is a pattern, add the variable to the pattern-specific + variable value list. */ + +static void +record_target_var (filenames, defn, two_colon, origin, flocp) + struct nameseq *filenames; + char *defn; + int two_colon; + enum variable_origin origin; + const struct floc *flocp; +{ + struct nameseq *nextf; + struct variable_set_list *global; + + global = current_variable_set_list; + + /* If the variable is an append version, store that but treat it as a + normal recursive variable. */ + + for (; filenames != 0; filenames = nextf) + { + struct variable *v; + register char *name = filenames->name; + struct variable_set_list *vlist; + char *fname; + char *percent; + + nextf = filenames->next; + free ((char *) filenames); + + /* If it's a pattern target, then add it to the pattern-specific + variable list. */ + percent = find_percent (name); + if (percent) + { + struct pattern_var *p; + + /* Get a reference for this pattern-specific variable struct. */ + p = create_pattern_var(name, percent); + vlist = p->vars; + fname = p->target; + } + else + { + struct file *f; + + /* Get a file reference for this file, and initialize it. + We don't want to just call enter_file() because that allocates a + new entry if the file is a double-colon, which we don't want in + this situation. */ + f = lookup_file (name); + if (!f) + f = enter_file (name); + else if (f->double_colon) + f = f->double_colon; + + initialize_file_variables (f, 1); + vlist = f->variables; + fname = f->name; + } + + /* Make the new variable context current and define the variable. */ + current_variable_set_list = vlist; + v = try_variable_definition (flocp, defn, origin, 1); + if (!v) + error (flocp, _("Malformed per-target variable definition")); + v->per_target = 1; + + /* If it's not an override, check to see if there was a command-line + setting. If so, reset the value. */ + if (origin != o_override) + { + struct variable *gv; + int len = strlen(v->name); + + current_variable_set_list = global; + gv = lookup_variable (v->name, len); + if (gv && (gv->origin == o_env_override || gv->origin == o_command)) + { + v = define_variable_in_set (v->name, len, gv->value, gv->origin, + gv->recursive, vlist->set, flocp); + v->append = 0; + } + } + + /* Free name if not needed further. */ + if (name != fname && (name < fname || name > fname + strlen (fname))) + free (name); + } + + current_variable_set_list = global; +} + +/* Record a description line for files FILENAMES, + with dependencies DEPS, commands to execute described + by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED. + TWO_COLON is nonzero if a double colon was used. + If not nil, PATTERN is the `%' pattern to make this + a static pattern rule, and PATTERN_PERCENT is a pointer + to the `%' within it. + + The links of FILENAMES are freed, and so are any names in it + that are not incorporated into other data structures. */ + +static void +record_files (filenames, pattern, pattern_percent, deps, cmds_started, + commands, commands_idx, two_colon, have_sysv_atvar, + flocp, set_default) + struct nameseq *filenames; + char *pattern, *pattern_percent; + struct dep *deps; + unsigned int cmds_started; + char *commands; + unsigned int commands_idx; + int two_colon; + int have_sysv_atvar; + const struct floc *flocp; + int set_default; +{ + struct nameseq *nextf; + int implicit = 0; + unsigned int max_targets = 0, target_idx = 0; + char **targets = 0, **target_percents = 0; + struct commands *cmds; + + if (commands_idx > 0) + { + cmds = (struct commands *) xmalloc (sizeof (struct commands)); + cmds->fileinfo.filenm = flocp->filenm; + cmds->fileinfo.lineno = cmds_started; + cmds->commands = savestring (commands, commands_idx); + cmds->command_lines = 0; + } + else + cmds = 0; + + for (; filenames != 0; filenames = nextf) + { + char *name = filenames->name; + struct file *f; + struct dep *d; + struct dep *this; + char *implicit_percent; + + nextf = filenames->next; + free (filenames); + + /* Check for .POSIX. We used to do this in snap_deps() but that's not + good enough: it doesn't happen until after the makefile is read, + which means we cannot use its value during parsing. */ + + if (streq (name, ".POSIX")) + posix_pedantic = 1; + + implicit_percent = find_percent (name); + implicit |= implicit_percent != 0; + + if (implicit && pattern != 0) + fatal (flocp, _("mixed implicit and static pattern rules")); + + if (implicit && implicit_percent == 0) + fatal (flocp, _("mixed implicit and normal rules")); + + if (implicit) + { + if (targets == 0) + { + max_targets = 5; + targets = (char **) xmalloc (5 * sizeof (char *)); + target_percents = (char **) xmalloc (5 * sizeof (char *)); + target_idx = 0; + } + else if (target_idx == max_targets - 1) + { + max_targets += 5; + targets = (char **) xrealloc ((char *) targets, + max_targets * sizeof (char *)); + target_percents + = (char **) xrealloc ((char *) target_percents, + max_targets * sizeof (char *)); + } + targets[target_idx] = name; + target_percents[target_idx] = implicit_percent; + ++target_idx; + continue; + } + + /* If there are multiple filenames, copy the chain DEPS + for all but the last one. It is not safe for the same deps + to go in more than one place in the data base. */ + this = nextf != 0 ? copy_dep_chain (deps) : deps; + + if (pattern != 0) + { + /* If this is an extended static rule: + `targets: target%pattern: dep%pattern; cmds', + translate each dependency pattern into a plain filename + using the target pattern and this target's name. */ + if (!pattern_matches (pattern, pattern_percent, name)) + { + /* Give a warning if the rule is meaningless. */ + error (flocp, + _("target `%s' doesn't match the target pattern"), name); + this = 0; + } + else + { + /* We use patsubst_expand to do the work of translating + the target pattern, the target's name and the dependencies' + patterns into plain dependency names. */ + char *buffer = variable_expand (""); + + for (d = this; d != 0; d = d->next) + { + char *o; + char *percent = find_percent (d->name); + if (percent == 0) + continue; + o = patsubst_expand (buffer, name, pattern, d->name, + pattern_percent, percent); + /* If the name expanded to the empty string, that's + illegal. */ + if (o == buffer) + fatal (flocp, + _("target `%s' leaves prerequisite pattern empty"), + name); + free (d->name); + d->name = savestring (buffer, o - buffer); + } + } + } + + /* If at least one of the dependencies uses $$@ etc. deal with that. + It would be very nice and very simple to just expand everything, but + it would break a lot of backward compatibility. Maybe that's OK + since we're just emulating a SysV function, and if we do that then + why not emulate it completely (that's what SysV make does: it + re-expands the entire prerequisite list, all the time, with $@ + etc. in scope. But, it would be a pain indeed to document this + ("iff you use $$@, your prerequisite lists is expanded twice...") + Ouch. Maybe better to make the code more complex. */ + + if (have_sysv_atvar) + { + char *p; + int tlen = strlen (name); + char *fnp = strrchr (name, '/'); + int dlen; + int flen; + + if (fnp) + { + dlen = fnp - name; + ++fnp; + flen = strlen (fnp); + } + else + { + dlen = 0; + fnp = name; + flen = tlen; + } + + + for (d = this; d != 0; d = d->next) + for (p = strchr (d->name, '$'); p != 0; p = strchr (p+1, '$')) + { + char *s = p; + char *at; + int atlen; + + /* If it's a '$@' or '$(@', it's escaped */ + if ((++p)[0] == '$' + && (p[1] == '@' || (p[1] == '(' && p[2] == '@'))) + { + bcopy (p, s, strlen (p)+1); + continue; + } + + /* Maybe found one. Check. p will point to '@' [for $@] or + ')' [for $(@)] or 'D' [for $(@D)] or 'F' [for $(@F)]. */ + if (p[0] != '@' + && (p[0] != '(' || (++p)[0] != '@' + || ((++p)[0] != ')' + && (p[1] != ')' || (p[0] != 'D' && p[0] != 'F'))))) + continue; + + /* Found one. Compute the length and string ptr. Move p + past the variable reference. */ + switch (p[0]) + { + case 'D': + atlen = dlen; + at = name; + p += 2; + break; + + case 'F': + atlen = flen; + at = fnp; + p += 2; + break; + + default: + atlen = tlen; + at = name; + ++p; + break; + } + + /* Get more space. */ + { + int soff = s - d->name; + int poff = p - d->name; + d->name = (char *) xrealloc (d->name, + strlen (d->name) + atlen + 1); + s = d->name + soff; + p = d->name + poff; + } + + /* Copy the string over. */ + bcopy(p, s+atlen, strlen (p)+1); + bcopy(at, s, atlen); + p = s + atlen - 1; + } + } + + if (!two_colon) + { + /* Single-colon. Combine these dependencies + with others in file's existing record, if any. */ + f = enter_file (name); + + if (f->double_colon) + fatal (flocp, + _("target file `%s' has both : and :: entries"), f->name); + + /* If CMDS == F->CMDS, this target was listed in this rule + more than once. Just give a warning since this is harmless. */ + if (cmds != 0 && cmds == f->cmds) + error (flocp, + _("target `%s' given more than once in the same rule."), + f->name); + + /* Check for two single-colon entries both with commands. + Check is_target so that we don't lose on files such as .c.o + whose commands were preinitialized. */ + else if (cmds != 0 && f->cmds != 0 && f->is_target) + { + error (&cmds->fileinfo, + _("warning: overriding commands for target `%s'"), + f->name); + error (&f->cmds->fileinfo, + _("warning: ignoring old commands for target `%s'"), + f->name); + } + + f->is_target = 1; + + /* Defining .DEFAULT with no deps or cmds clears it. */ + if (f == default_file && this == 0 && cmds == 0) + f->cmds = 0; + if (cmds != 0) + f->cmds = cmds; + /* Defining .SUFFIXES with no dependencies + clears out the list of suffixes. */ + if (f == suffix_file && this == 0) + { + d = f->deps; + while (d != 0) + { + struct dep *nextd = d->next; + free (d->name); + free ((char *)d); + d = nextd; + } + f->deps = 0; + } + else if (f->deps != 0) + { + /* Add the file's old deps and the new ones in THIS together. */ + + struct dep *firstdeps, *moredeps; + if (cmds != 0) + { + /* This is the rule with commands, so put its deps first. + The rationale behind this is that $< expands to the + first dep in the chain, and commands use $< expecting + to get the dep that rule specifies. */ + firstdeps = this; + moredeps = f->deps; + } + else + { + /* Append the new deps to the old ones. */ + firstdeps = f->deps; + moredeps = this; + } + + if (firstdeps == 0) + firstdeps = moredeps; + else + { + d = firstdeps; + while (d->next != 0) + d = d->next; + d->next = moredeps; + } + + f->deps = firstdeps; + } + else + f->deps = this; + + /* If this is a static pattern rule, set the file's stem to + the part of its name that matched the `%' in the pattern, + so you can use $* in the commands. */ + if (pattern != 0) + { + static char *percent = "%"; + char *buffer = variable_expand (""); + char *o = patsubst_expand (buffer, name, pattern, percent, + pattern_percent, percent); + f->stem = savestring (buffer, o - buffer); + } + } + else + { + /* Double-colon. Make a new record + even if the file already has one. */ + f = lookup_file (name); + /* Check for both : and :: rules. Check is_target so + we don't lose on default suffix rules or makefiles. */ + if (f != 0 && f->is_target && !f->double_colon) + fatal (flocp, + _("target file `%s' has both : and :: entries"), f->name); + f = enter_file (name); + /* If there was an existing entry and it was a double-colon + entry, enter_file will have returned a new one, making it the + prev pointer of the old one, and setting its double_colon + pointer to the first one. */ + if (f->double_colon == 0) + /* This is the first entry for this name, so we must + set its double_colon pointer to itself. */ + f->double_colon = f; + f->is_target = 1; + f->deps = this; + f->cmds = cmds; + } + + /* Free name if not needed further. */ + if (f != 0 && name != f->name + && (name < f->name || name > f->name + strlen (f->name))) + { + free (name); + name = f->name; + } + + /* See if this is first target seen whose name does + not start with a `.', unless it contains a slash. */ + if (default_goal_file == 0 && set_default + && (*name != '.' || strchr (name, '/') != 0 +#ifdef HAVE_DOS_PATHS + || strchr (name, '\\') != 0 +#endif + )) + { + int reject = 0; + + /* If this file is a suffix, don't + let it be the default goal file. */ + + for (d = suffix_file->deps; d != 0; d = d->next) + { + register struct dep *d2; + if (*dep_name (d) != '.' && streq (name, dep_name (d))) + { + reject = 1; + break; + } + for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next) + { + register unsigned int len = strlen (dep_name (d2)); + if (!strneq (name, dep_name (d2), len)) + continue; + if (streq (name + len, dep_name (d))) + { + reject = 1; + break; + } + } + if (reject) + break; + } + + if (!reject) + default_goal_file = f; + } + } + + if (implicit) + { + targets[target_idx] = 0; + target_percents[target_idx] = 0; + create_pattern_rule (targets, target_percents, two_colon, deps, cmds, 1); + free ((char *) target_percents); + } +} + +/* Search STRING for an unquoted STOPCHAR or blank (if BLANK is nonzero). + Backslashes quote STOPCHAR, blanks if BLANK is nonzero, and backslash. + Quoting backslashes are removed from STRING by compacting it into + itself. Returns a pointer to the first unquoted STOPCHAR if there is + one, or nil if there are none. */ + +char * +find_char_unquote (string, stop1, stop2, blank) + char *string; + int stop1; + int stop2; + int blank; +{ + unsigned int string_len = 0; + register char *p = string; + + while (1) + { + if (stop2 && blank) + while (*p != '\0' && *p != stop1 && *p != stop2 + && ! isblank ((unsigned char) *p)) + ++p; + else if (stop2) + while (*p != '\0' && *p != stop1 && *p != stop2) + ++p; + else if (blank) + while (*p != '\0' && *p != stop1 + && ! isblank ((unsigned char) *p)) + ++p; + else + while (*p != '\0' && *p != stop1) + ++p; + + if (*p == '\0') + break; + + if (p > string && p[-1] == '\\') + { + /* Search for more backslashes. */ + register int i = -2; + while (&p[i] >= string && p[i] == '\\') + --i; + ++i; + /* Only compute the length if really needed. */ + if (string_len == 0) + string_len = strlen (string); + /* The number of backslashes is now -I. + Copy P over itself to swallow half of them. */ + bcopy (&p[i / 2], &p[i], (string_len - (p - string)) - (i / 2) + 1); + p += i / 2; + if (i % 2 == 0) + /* All the backslashes quoted each other; the STOPCHAR was + unquoted. */ + return p; + + /* The STOPCHAR was quoted by a backslash. Look for another. */ + } + else + /* No backslash in sight. */ + return p; + } + + /* Never hit a STOPCHAR or blank (with BLANK nonzero). */ + return 0; +} + +/* Search PATTERN for an unquoted %. */ + +char * +find_percent (pattern) + char *pattern; +{ + return find_char_unquote (pattern, '%', 0, 0); +} + +/* Parse a string into a sequence of filenames represented as a + chain of struct nameseq's in reverse order and return that chain. + + The string is passed as STRINGP, the address of a string pointer. + The string pointer is updated to point at the first character + not parsed, which either is a null char or equals STOPCHAR. + + SIZE is how big to construct chain elements. + This is useful if we want them actually to be other structures + that have room for additional info. + + If STRIP is nonzero, strip `./'s off the beginning. */ + +struct nameseq * +parse_file_seq (stringp, stopchar, size, strip) + char **stringp; + int stopchar; + unsigned int size; + int strip; +{ + register struct nameseq *new = 0; + register struct nameseq *new1, *lastnew1; + register char *p = *stringp; + char *q; + char *name; + +#ifdef VMS +# define VMS_COMMA ',' +#else +# define VMS_COMMA 0 +#endif + + while (1) + { + /* Skip whitespace; see if any more names are left. */ + p = next_token (p); + if (*p == '\0') + break; + if (*p == stopchar) + break; + + /* Yes, find end of next name. */ + q = p; + p = find_char_unquote (q, stopchar, VMS_COMMA, 1); +#ifdef VMS + /* convert comma separated list to space separated */ + if (p && *p == ',') + *p =' '; +#endif +#ifdef _AMIGA + if (stopchar == ':' && p && *p == ':' + && !(isspace ((unsigned char)p[1]) || !p[1] + || isspace ((unsigned char)p[-1]))) + { + p = find_char_unquote (p+1, stopchar, VMS_COMMA, 1); + } +#endif +#ifdef HAVE_DOS_PATHS + /* For DOS paths, skip a "C:\..." or a "C:/..." until we find the + first colon which isn't followed by a slash or a backslash. + Note that tokens separated by spaces should be treated as separate + tokens since make doesn't allow path names with spaces */ + if (stopchar == ':') + while (p != 0 && !isspace ((unsigned char)*p) && + (p[1] == '\\' || p[1] == '/') && isalpha ((unsigned char)p[-1])) + p = find_char_unquote (p + 1, stopchar, VMS_COMMA, 1); +#endif + if (p == 0) + p = q + strlen (q); + + if (strip) +#ifdef VMS + /* Skip leading `[]'s. */ + while (p - q > 2 && q[0] == '[' && q[1] == ']') +#else + /* Skip leading `./'s. */ + while (p - q > 2 && q[0] == '.' && q[1] == '/') +#endif + { + q += 2; /* Skip "./". */ + while (q < p && *q == '/') + /* Skip following slashes: ".//foo" is "foo", not "/foo". */ + ++q; + } + + /* Extract the filename just found, and skip it. */ + + if (q == p) + /* ".///" was stripped to "". */ +#ifdef VMS + continue; +#else +#ifdef _AMIGA + name = savestring ("", 0); +#else + name = savestring ("./", 2); +#endif +#endif + else +#ifdef VMS +/* VMS filenames can have a ':' in them but they have to be '\'ed but we need + * to remove this '\' before we can use the filename. + * Savestring called because q may be read-only string constant. + */ + { + char *qbase = xstrdup (q); + char *pbase = qbase + (p-q); + char *q1 = qbase; + char *q2 = q1; + char *p1 = pbase; + + while (q1 != pbase) + { + if (*q1 == '\\' && *(q1+1) == ':') + { + q1++; + p1--; + } + *q2++ = *q1++; + } + name = savestring (qbase, p1 - qbase); + free (qbase); + } +#else + name = savestring (q, p - q); +#endif + + /* Add it to the front of the chain. */ + new1 = (struct nameseq *) xmalloc (size); + new1->name = name; + new1->next = new; + new = new1; + } + +#ifndef NO_ARCHIVES + + /* Look for multi-word archive references. + They are indicated by a elt ending with an unmatched `)' and + an elt further down the chain (i.e., previous in the file list) + with an unmatched `(' (e.g., "lib(mem"). */ + + new1 = new; + lastnew1 = 0; + while (new1 != 0) + if (new1->name[0] != '(' /* Don't catch "(%)" and suchlike. */ + && new1->name[strlen (new1->name) - 1] == ')' + && strchr (new1->name, '(') == 0) + { + /* NEW1 ends with a `)' but does not contain a `('. + Look back for an elt with an opening `(' but no closing `)'. */ + + struct nameseq *n = new1->next, *lastn = new1; + char *paren = 0; + while (n != 0 && (paren = strchr (n->name, '(')) == 0) + { + lastn = n; + n = n->next; + } + if (n != 0 + /* Ignore something starting with `(', as that cannot actually + be an archive-member reference (and treating it as such + results in an empty file name, which causes much lossage). */ + && n->name[0] != '(') + { + /* N is the first element in the archive group. + Its name looks like "lib(mem" (with no closing `)'). */ + + char *libname; + + /* Copy "lib(" into LIBNAME. */ + ++paren; + libname = (char *) alloca (paren - n->name + 1); + bcopy (n->name, libname, paren - n->name); + libname[paren - n->name] = '\0'; + + if (*paren == '\0') + { + /* N was just "lib(", part of something like "lib( a b)". + Edit it out of the chain and free its storage. */ + lastn->next = n->next; + free (n->name); + free ((char *) n); + /* LASTN->next is the new stopping elt for the loop below. */ + n = lastn->next; + } + else + { + /* Replace N's name with the full archive reference. */ + name = concat (libname, paren, ")"); + free (n->name); + n->name = name; + } + + if (new1->name[1] == '\0') + { + /* NEW1 is just ")", part of something like "lib(a b )". + Omit it from the chain and free its storage. */ + if (lastnew1 == 0) + new = new1->next; + else + lastnew1->next = new1->next; + lastn = new1; + new1 = new1->next; + free (lastn->name); + free ((char *) lastn); + } + else + { + /* Replace also NEW1->name, which already has closing `)'. */ + name = concat (libname, new1->name, ""); + free (new1->name); + new1->name = name; + new1 = new1->next; + } + + /* Trace back from NEW1 (the end of the list) until N + (the beginning of the list), rewriting each name + with the full archive reference. */ + + while (new1 != n) + { + name = concat (libname, new1->name, ")"); + free (new1->name); + new1->name = name; + lastnew1 = new1; + new1 = new1->next; + } + } + else + { + /* No frobnication happening. Just step down the list. */ + lastnew1 = new1; + new1 = new1->next; + } + } + else + { + lastnew1 = new1; + new1 = new1->next; + } + +#endif + + *stringp = p; + return new; +} + +/* Find the next line of text in an eval buffer, combining continuation lines + into one line. + Return the number of actual lines read (> 1 if continuation lines). + Returns -1 if there's nothing left in the buffer. + + After this function, ebuf->buffer points to the first character of the + line we just found. + */ + +/* Read a line of text from a STRING. + Since we aren't really reading from a file, don't bother with linenumbers. + */ + +static unsigned long +readstring (ebuf) + struct ebuffer *ebuf; +{ + char *p; + + /* If there is nothing left in this buffer, return 0. */ + if (ebuf->bufnext > ebuf->bufstart + ebuf->size) + return -1; + + /* Set up a new starting point for the buffer, and find the end of the + next logical line (taking into account backslash/newline pairs). */ + + p = ebuf->buffer = ebuf->bufnext; + + while (1) + { + int backslash = 0; + + /* Find the next newline. Keep track of backslashes as we look. */ + for (; *p != '\n' && *p != '\0'; ++p) + if (*p == '\\') + backslash = !backslash; + + /* If we got to the end of the string or a newline with no backslash, + we're done. */ + if (*p == '\0' || !backslash) + break; + } + + /* Overwrite the newline char. */ + *p = '\0'; + ebuf->bufnext = p+1; + + return 0; +} + +static long +readline (ebuf) + struct ebuffer *ebuf; +{ + char *p; + char *end; + char *start; + long nlines = 0; + + /* The behaviors between string and stream buffers are different enough to + warrant different functions. Do the Right Thing. */ + + if (!ebuf->fp) + return readstring (ebuf); + + /* When reading from a file, we always start over at the beginning of the + buffer for each new line. */ + + p = start = ebuf->bufstart; + end = p + ebuf->size; + *p = '\0'; + + while (fgets (p, end - p, ebuf->fp) != 0) + { + char *p2; + unsigned long len; + int backslash; + + len = strlen (p); + if (len == 0) + { + /* This only happens when the first thing on the line is a '\0'. + It is a pretty hopeless case, but (wonder of wonders) Athena + lossage strikes again! (xmkmf puts NULs in its makefiles.) + There is nothing really to be done; we synthesize a newline so + the following line doesn't appear to be part of this line. */ + error (&ebuf->floc, + _("warning: NUL character seen; rest of line ignored")); + p[0] = '\n'; + len = 1; + } + + /* Jump past the text we just read. */ + p += len; + + /* If the last char isn't a newline, the whole line didn't fit into the + buffer. Get some more buffer and try again. */ + if (p[-1] != '\n') + goto more_buffer; + + /* We got a newline, so add one to the count of lines. */ + ++nlines; + +#if !defined(WINDOWS32) && !defined(__MSDOS__) + /* Check to see if the line was really ended with CRLF; if so ignore + the CR. */ + if ((p - start) > 1 && p[-2] == '\r') + { + --p; + p[-1] = '\n'; + } +#endif + + backslash = 0; + for (p2 = p - 2; p2 >= start; --p2) + { + if (*p2 != '\\') + break; + backslash = !backslash; + } + + if (!backslash) + { + p[-1] = '\0'; + break; + } + + /* It was a backslash/newline combo. If we have more space, read + another line. */ + if (end - p >= 80) + continue; + + /* We need more space at the end of our buffer, so realloc it. + Make sure to preserve the current offset of p. */ + more_buffer: + { + unsigned long off = p - start; + ebuf->size *= 2; + start = ebuf->buffer = ebuf->bufstart = (char *) xrealloc (start, + ebuf->size); + p = start + off; + end = start + ebuf->size; + *p = '\0'; + } + } + + if (ferror (ebuf->fp)) + pfatal_with_name (ebuf->floc.filenm); + + /* If we found some lines, return how many. + If we didn't, but we did find _something_, that indicates we read the last + line of a file with no final newline; return 1. + If we read nothing, we're at EOF; return -1. */ + + return nlines ? nlines : p == ebuf->bufstart ? -1 : 1; +} + +/* Parse the next "makefile word" from the input buffer, and return info + about it. + + A "makefile word" is one of: + + w_bogus Should never happen + w_eol End of input + w_static A static word; cannot be expanded + w_variable A word containing one or more variables/functions + w_colon A colon + w_dcolon A double-colon + w_semicolon A semicolon + w_varassign A variable assignment operator (=, :=, +=, or ?=) + + Note that this function is only used when reading certain parts of the + makefile. Don't use it where special rules hold sway (RHS of a variable, + in a command list, etc.) */ + +static enum make_word_type +get_next_mword (buffer, delim, startp, length) + char *buffer; + char *delim; + char **startp; + unsigned int *length; +{ + enum make_word_type wtype = w_bogus; + char *p = buffer, *beg; + char c; + + /* Skip any leading whitespace. */ + while (isblank ((unsigned char)*p)) + ++p; + + beg = p; + c = *(p++); + switch (c) + { + case '\0': + wtype = w_eol; + break; + + case ';': + wtype = w_semicolon; + break; + + case '=': + wtype = w_varassign; + break; + + case ':': + wtype = w_colon; + switch (*p) + { + case ':': + ++p; + wtype = w_dcolon; + break; + + case '=': + ++p; + wtype = w_varassign; + break; + } + break; + + case '+': + case '?': + if (*p == '=') + { + ++p; + wtype = w_varassign; + break; + } + + default: + if (delim && strchr (delim, c)) + wtype = w_static; + break; + } + + /* Did we find something? If so, return now. */ + if (wtype != w_bogus) + goto done; + + /* This is some non-operator word. A word consists of the longest + string of characters that doesn't contain whitespace, one of [:=#], + or [?+]=, or one of the chars in the DELIM string. */ + + /* We start out assuming a static word; if we see a variable we'll + adjust our assumptions then. */ + wtype = w_static; + + /* We already found the first value of "c", above. */ + while (1) + { + char closeparen; + int count; + + switch (c) + { + case '\0': + case ' ': + case '\t': + case '=': + goto done_word; + + case ':': +#ifdef HAVE_DOS_PATHS + /* A word CAN include a colon in its drive spec. The drive + spec is allowed either at the beginning of a word, or as part + of the archive member name, like in "libfoo.a(d:/foo/bar.o)". */ + if (!(p - beg >= 2 + && (*p == '/' || *p == '\\') && isalpha ((unsigned char)p[-2]) + && (p - beg == 2 || p[-3] == '('))) +#endif + goto done_word; + + case '$': + c = *(p++); + if (c == '$') + break; + + /* This is a variable reference, so note that it's expandable. + Then read it to the matching close paren. */ + wtype = w_variable; + + if (c == '(') + closeparen = ')'; + else if (c == '{') + closeparen = '}'; + else + /* This is a single-letter variable reference. */ + break; + + for (count=0; *p != '\0'; ++p) + { + if (*p == c) + ++count; + else if (*p == closeparen && --count < 0) + { + ++p; + break; + } + } + break; + + case '?': + case '+': + if (*p == '=') + goto done_word; + break; + + case '\\': + switch (*p) + { + case ':': + case ';': + case '=': + case '\\': + ++p; + break; + } + break; + + default: + if (delim && strchr (delim, c)) + goto done_word; + break; + } + + c = *(p++); + } + done_word: + --p; + + done: + if (startp) + *startp = beg; + if (length) + *length = p - beg; + return wtype; +} + +/* Construct the list of include directories + from the arguments and the default list. */ + +void +construct_include_path (arg_dirs) + char **arg_dirs; +{ + register unsigned int i; +#ifdef VAXC /* just don't ask ... */ + stat_t stbuf; +#else + struct stat stbuf; +#endif + /* Table to hold the dirs. */ + + register unsigned int defsize = (sizeof (default_include_directories) + / sizeof (default_include_directories[0])); + register unsigned int max = 5; + register char **dirs = (char **) xmalloc ((5 + defsize) * sizeof (char *)); + register unsigned int idx = 0; + +#ifdef __MSDOS__ + defsize++; +#endif + + /* First consider any dirs specified with -I switches. + Ignore dirs that don't exist. */ + + if (arg_dirs != 0) + while (*arg_dirs != 0) + { + char *dir = *arg_dirs++; + + if (dir[0] == '~') + { + char *expanded = tilde_expand (dir); + if (expanded != 0) + dir = expanded; + } + + if (stat (dir, &stbuf) == 0 && S_ISDIR (stbuf.st_mode)) + { + if (idx == max - 1) + { + max += 5; + dirs = (char **) + xrealloc ((char *) dirs, (max + defsize) * sizeof (char *)); + } + dirs[idx++] = dir; + } + else if (dir != arg_dirs[-1]) + free (dir); + } + + /* Now add at the end the standard default dirs. */ + +#ifdef __MSDOS__ + { + /* The environment variable $DJDIR holds the root of the + DJGPP directory tree; add ${DJDIR}/include. */ + struct variable *djdir = lookup_variable ("DJDIR", 5); + + if (djdir) + { + char *defdir = (char *) xmalloc (strlen (djdir->value) + 8 + 1); + + strcat (strcpy (defdir, djdir->value), "/include"); + dirs[idx++] = defdir; + } + } +#endif + + for (i = 0; default_include_directories[i] != 0; ++i) + if (stat (default_include_directories[i], &stbuf) == 0 + && S_ISDIR (stbuf.st_mode)) + dirs[idx++] = default_include_directories[i]; + + dirs[idx] = 0; + + /* Now compute the maximum length of any name in it. */ + + max_incl_len = 0; + for (i = 0; i < idx; ++i) + { + unsigned int len = strlen (dirs[i]); + /* If dir name is written with a trailing slash, discard it. */ + if (dirs[i][len - 1] == '/') + /* We can't just clobber a null in because it may have come from + a literal string and literal strings may not be writable. */ + dirs[i] = savestring (dirs[i], len - 1); + if (len > max_incl_len) + max_incl_len = len; + } + + include_directories = dirs; +} + +/* Expand ~ or ~USER at the beginning of NAME. + Return a newly malloc'd string or 0. */ + +char * +tilde_expand (name) + char *name; +{ +#ifndef VMS + if (name[1] == '/' || name[1] == '\0') + { + extern char *getenv (); + char *home_dir; + int is_variable; + + { + /* Turn off --warn-undefined-variables while we expand HOME. */ + int save = warn_undefined_variables_flag; + warn_undefined_variables_flag = 0; + + home_dir = allocated_variable_expand ("$(HOME)"); + + warn_undefined_variables_flag = save; + } + + is_variable = home_dir[0] != '\0'; + if (!is_variable) + { + free (home_dir); + home_dir = getenv ("HOME"); + } +#if !defined(_AMIGA) && !defined(WINDOWS32) + if (home_dir == 0 || home_dir[0] == '\0') + { + extern char *getlogin (); + char *logname = getlogin (); + home_dir = 0; + if (logname != 0) + { + struct passwd *p = getpwnam (logname); + if (p != 0) + home_dir = p->pw_dir; + } + } +#endif /* !AMIGA && !WINDOWS32 */ + if (home_dir != 0) + { + char *new = concat (home_dir, "", name + 1); + if (is_variable) + free (home_dir); + return new; + } + } +#if !defined(_AMIGA) && !defined(WINDOWS32) + else + { + struct passwd *pwent; + char *userend = strchr (name + 1, '/'); + if (userend != 0) + *userend = '\0'; + pwent = getpwnam (name + 1); + if (pwent != 0) + { + if (userend == 0) + return xstrdup (pwent->pw_dir); + else + return concat (pwent->pw_dir, "/", userend + 1); + } + else if (userend != 0) + *userend = '/'; + } +#endif /* !AMIGA && !WINDOWS32 */ +#endif /* !VMS */ + return 0; +} + +/* Given a chain of struct nameseq's describing a sequence of filenames, + in reverse of the intended order, return a new chain describing the + result of globbing the filenames. The new chain is in forward order. + The links of the old chain are freed or used in the new chain. + Likewise for the names in the old chain. + + SIZE is how big to construct chain elements. + This is useful if we want them actually to be other structures + that have room for additional info. */ + +struct nameseq * +multi_glob (chain, size) + struct nameseq *chain; + unsigned int size; +{ + extern void dir_setup_glob (); + register struct nameseq *new = 0; + register struct nameseq *old; + struct nameseq *nexto; + glob_t gl; + + dir_setup_glob (&gl); + + for (old = chain; old != 0; old = nexto) + { +#ifndef NO_ARCHIVES + char *memname; +#endif + + nexto = old->next; + + if (old->name[0] == '~') + { + char *newname = tilde_expand (old->name); + if (newname != 0) + { + free (old->name); + old->name = newname; + } + } + +#ifndef NO_ARCHIVES + if (ar_name (old->name)) + { + /* OLD->name is an archive member reference. + Replace it with the archive file name, + and save the member name in MEMNAME. + We will glob on the archive name and then + reattach MEMNAME later. */ + char *arname; + ar_parse_name (old->name, &arname, &memname); + free (old->name); + old->name = arname; + } + else + memname = 0; +#endif /* !NO_ARCHIVES */ + + switch (glob (old->name, GLOB_NOCHECK|GLOB_ALTDIRFUNC, NULL, &gl)) + { + case 0: /* Success. */ + { + register int i = gl.gl_pathc; + while (i-- > 0) + { +#ifndef NO_ARCHIVES + if (memname != 0) + { + /* Try to glob on MEMNAME within the archive. */ + struct nameseq *found + = ar_glob (gl.gl_pathv[i], memname, size); + if (found == 0) + { + /* No matches. Use MEMNAME as-is. */ + unsigned int alen = strlen (gl.gl_pathv[i]); + unsigned int mlen = strlen (memname); + struct nameseq *elt + = (struct nameseq *) xmalloc (size); + if (size > sizeof (struct nameseq)) + bzero (((char *) elt) + sizeof (struct nameseq), + size - sizeof (struct nameseq)); + elt->name = (char *) xmalloc (alen + 1 + mlen + 2); + bcopy (gl.gl_pathv[i], elt->name, alen); + elt->name[alen] = '('; + bcopy (memname, &elt->name[alen + 1], mlen); + elt->name[alen + 1 + mlen] = ')'; + elt->name[alen + 1 + mlen + 1] = '\0'; + elt->next = new; + new = elt; + } + else + { + /* Find the end of the FOUND chain. */ + struct nameseq *f = found; + while (f->next != 0) + f = f->next; + + /* Attach the chain being built to the end of the FOUND + chain, and make FOUND the new NEW chain. */ + f->next = new; + new = found; + } + + free (memname); + } + else +#endif /* !NO_ARCHIVES */ + { + struct nameseq *elt = (struct nameseq *) xmalloc (size); + if (size > sizeof (struct nameseq)) + bzero (((char *) elt) + sizeof (struct nameseq), + size - sizeof (struct nameseq)); + elt->name = xstrdup (gl.gl_pathv[i]); + elt->next = new; + new = elt; + } + } + globfree (&gl); + free (old->name); + free ((char *)old); + break; + } + + case GLOB_NOSPACE: + fatal (NILF, _("virtual memory exhausted")); + break; + + default: + old->next = new; + new = old; + break; + } + } + + return new; +} diff --git a/flaim/external/w32/make/remake.c b/flaim/external/w32/make/remake.c new file mode 100644 index 0000000..72c4d78 --- /dev/null +++ b/flaim/external/w32/make/remake.c @@ -0,0 +1,1420 @@ +/* Basic dependency engine for GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "filedef.h" +#include "job.h" +#include "commands.h" +#include "dep.h" +#include "variable.h" +#include "debug.h" + +#include + +#ifdef HAVE_FCNTL_H +#include +#else +#include +#endif + +#ifdef VMS +#include +#endif +#ifdef WINDOWS32 +#include +#endif + +extern int try_implicit_rule PARAMS ((struct file *file, unsigned int depth)); + + +/* The test for circular dependencies is based on the 'updating' bit in + `struct file'. However, double colon targets have seperate `struct + file's; make sure we always use the base of the double colon chain. */ + +#define start_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\ + ->updating = 1) +#define finish_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\ + ->updating = 0) +#define is_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\ + ->updating) + + +/* Incremented when a command is started (under -n, when one would be). */ +unsigned int commands_started = 0; + +/* Current value for pruning the scan of the goal chain (toggle 0/1). */ +static unsigned int considered; + +static int update_file PARAMS ((struct file *file, unsigned int depth)); +static int update_file_1 PARAMS ((struct file *file, unsigned int depth)); +static int check_dep PARAMS ((struct file *file, unsigned int depth, FILE_TIMESTAMP this_mtime, int *must_make_ptr)); +static int touch_file PARAMS ((struct file *file)); +static void remake_file PARAMS ((struct file *file)); +static FILE_TIMESTAMP name_mtime PARAMS ((char *name)); +static int library_search PARAMS ((char **lib, FILE_TIMESTAMP *mtime_ptr)); + + +/* Remake all the goals in the `struct dep' chain GOALS. Return -1 if nothing + was done, 0 if all goals were updated successfully, or 1 if a goal failed. + If MAKEFILES is nonzero, these goals are makefiles, so -t, -q, and -n should + be disabled for them unless they were also command-line targets, and we + should only make one goal at a time and return as soon as one goal whose + `changed' member is nonzero is successfully made. */ + +int +update_goal_chain (goals, makefiles) + register struct dep *goals; + int makefiles; +{ + int t = touch_flag, q = question_flag, n = just_print_flag; + unsigned int j = job_slots; + int status = -1; + +#define MTIME(file) (makefiles ? file_mtime_no_search (file) \ + : file_mtime (file)) + + /* Duplicate the chain so we can remove things from it. */ + + goals = copy_dep_chain (goals); + + { + /* Clear the `changed' flag of each goal in the chain. + We will use the flag below to notice when any commands + have actually been run for a target. When no commands + have been run, we give an "up to date" diagnostic. */ + + struct dep *g; + for (g = goals; g != 0; g = g->next) + g->changed = 0; + } + + /* All files start with the considered bit 0, so the global value is 1. */ + considered = 1; + + /* Update all the goals until they are all finished. */ + + while (goals != 0) + { + register struct dep *g, *lastgoal; + + /* Start jobs that are waiting for the load to go down. */ + + start_waiting_jobs (); + + /* Wait for a child to die. */ + + reap_children (1, 0); + + lastgoal = 0; + g = goals; + while (g != 0) + { + /* Iterate over all double-colon entries for this file. */ + struct file *file; + int stop = 0, any_not_updated = 0; + + for (file = g->file->double_colon ? g->file->double_colon : g->file; + file != NULL; + file = file->prev) + { + unsigned int ocommands_started; + int x; + check_renamed (file); + if (makefiles) + { + if (file->cmd_target) + { + touch_flag = t; + question_flag = q; + just_print_flag = n; + } + else + touch_flag = question_flag = just_print_flag = 0; + } + + /* Save the old value of `commands_started' so we can compare + later. It will be incremented when any commands are + actually run. */ + ocommands_started = commands_started; + + x = update_file (file, makefiles ? 1 : 0); + check_renamed (file); + + /* Set the goal's `changed' flag if any commands were started + by calling update_file above. We check this flag below to + decide when to give an "up to date" diagnostic. */ + g->changed += commands_started - ocommands_started; + + /* If we updated a file and STATUS was not already 1, set it to + 1 if updating failed, or to 0 if updating succeeded. Leave + STATUS as it is if no updating was done. */ + + stop = 0; + if ((x != 0 || file->updated) && status < 1) + { + if (file->update_status != 0) + { + /* Updating failed, or -q triggered. The STATUS value + tells our caller which. */ + status = file->update_status; + /* If -q just triggered, stop immediately. It doesn't + matter how much more we run, since we already know + the answer to return. */ + stop = (!keep_going_flag && !question_flag + && !makefiles); + } + else + { + FILE_TIMESTAMP mtime = MTIME (file); + check_renamed (file); + + if (file->updated && g->changed && + mtime != file->mtime_before_update) + { + /* Updating was done. If this is a makefile and + just_print_flag or question_flag is set (meaning + -n or -q was given and this file was specified + as a command-line target), don't change STATUS. + If STATUS is changed, we will get re-exec'd, and + enter an infinite loop. */ + if (!makefiles + || (!just_print_flag && !question_flag)) + status = 0; + if (makefiles && file->dontcare) + /* This is a default makefile; stop remaking. */ + stop = 1; + } + } + } + + /* Keep track if any double-colon entry is not finished. + When they are all finished, the goal is finished. */ + any_not_updated |= !file->updated; + + if (stop) + break; + } + + /* Reset FILE since it is null at the end of the loop. */ + file = g->file; + + if (stop || !any_not_updated) + { + /* If we have found nothing whatever to do for the goal, + print a message saying nothing needs doing. */ + + if (!makefiles + /* If the update_status is zero, we updated successfully + or not at all. G->changed will have been set above if + any commands were actually started for this goal. */ + && file->update_status == 0 && !g->changed + /* Never give a message under -s or -q. */ + && !silent_flag && !question_flag) + message (1, ((file->phony || file->cmds == 0) + ? _("Nothing to be done for `%s'.") + : _("`%s' is up to date.")), + file->name); + + /* This goal is finished. Remove it from the chain. */ + if (lastgoal == 0) + goals = g->next; + else + lastgoal->next = g->next; + + /* Free the storage. */ + free ((char *) g); + + g = lastgoal == 0 ? goals : lastgoal->next; + + if (stop) + break; + } + else + { + lastgoal = g; + g = g->next; + } + } + + /* If we reached the end of the dependency graph toggle the considered + flag for the next pass. */ + if (g == 0) + considered = !considered; + } + + if (makefiles) + { + touch_flag = t; + question_flag = q; + just_print_flag = n; + job_slots = j; + } + return status; +} + +/* If FILE is not up to date, execute the commands for it. + Return 0 if successful, 1 if unsuccessful; + but with some flag settings, just call `exit' if unsuccessful. + + DEPTH is the depth in recursions of this function. + We increment it during the consideration of our dependencies, + then decrement it again after finding out whether this file + is out of date. + + If there are multiple double-colon entries for FILE, + each is considered in turn. */ + +static int +update_file (file, depth) + struct file *file; + unsigned int depth; +{ + register int status = 0; + register struct file *f; + + f = file->double_colon ? file->double_colon : file; + + /* Prune the dependency graph: if we've already been here on _this_ + pass through the dependency graph, we don't have to go any further. + We won't reap_children until we start the next pass, so no state + change is possible below here until then. */ + if (f->considered == considered) + { + DBF (DB_VERBOSE, _("Pruning file `%s'.\n")); + return f->command_state == cs_finished ? f->update_status : 0; + } + + /* This loop runs until we start commands for a double colon rule, or until + the chain is exhausted. */ + for (; f != 0; f = f->prev) + { + f->considered = considered; + + status |= update_file_1 (f, depth); + check_renamed (f); + + if (status != 0 && !keep_going_flag) + break; + + if (f->command_state == cs_running + || f->command_state == cs_deps_running) + { + /* Don't run the other :: rules for this + file until this rule is finished. */ + status = 0; + break; + } + } + + /* Process the remaining rules in the double colon chain so they're marked + considered. Start their prerequisites, too. */ + for (; f != 0 ; f = f->prev) + { + struct dep *d; + + f->considered = considered; + + for (d = f->deps; d != 0; d = d->next) + status |= update_file (d->file, depth + 1); + } + + return status; +} + +/* Consider a single `struct file' and update it as appropriate. */ + +static int +update_file_1 (file, depth) + struct file *file; + unsigned int depth; +{ + register FILE_TIMESTAMP this_mtime; + int noexist, must_make, deps_changed; + int dep_status = 0; + register struct dep *d, *lastd; + int running = 0; + + DBF (DB_VERBOSE, _("Considering target file `%s'.\n")); + + if (file->updated) + { + if (file->update_status > 0) + { + DBF (DB_VERBOSE, + _("Recently tried and failed to update file `%s'.\n")); + return file->update_status; + } + + DBF (DB_VERBOSE, _("File `%s' was considered already.\n")); + return 0; + } + + switch (file->command_state) + { + case cs_not_started: + case cs_deps_running: + break; + case cs_running: + DBF (DB_VERBOSE, _("Still updating file `%s'.\n")); + return 0; + case cs_finished: + DBF (DB_VERBOSE, _("Finished updating file `%s'.\n")); + return file->update_status; + default: + abort (); + } + + ++depth; + + /* Notice recursive update of the same file. */ + start_updating (file); + + /* Looking at the file's modtime beforehand allows the possibility + that its name may be changed by a VPATH search, and thus it may + not need an implicit rule. If this were not done, the file + might get implicit commands that apply to its initial name, only + to have that name replaced with another found by VPATH search. */ + + this_mtime = file_mtime (file); + check_renamed (file); + noexist = this_mtime == NONEXISTENT_MTIME; + if (noexist) + DBF (DB_BASIC, _("File `%s' does not exist.\n")); + else if (ORDINARY_MTIME_MIN <= this_mtime && this_mtime <= ORDINARY_MTIME_MAX + && file->low_resolution_time) + { + /* Avoid spurious rebuilds due to low resolution time stamps. */ + int ns = FILE_TIMESTAMP_NS (this_mtime); + if (ns != 0) + error (NILF, _("*** Warning: .LOW_RESOLUTION_TIME file `%s' has a high resolution time stamp"), + file->name); + this_mtime += FILE_TIMESTAMPS_PER_S - 1 - ns; + } + + must_make = noexist; + + /* If file was specified as a target with no commands, + come up with some default commands. */ + + if (!file->phony && file->cmds == 0 && !file->tried_implicit) + { + if (try_implicit_rule (file, depth)) + DBF (DB_IMPLICIT, _("Found an implicit rule for `%s'.\n")); + else + DBF (DB_IMPLICIT, _("No implicit rule found for `%s'.\n")); + file->tried_implicit = 1; + } + if (file->cmds == 0 && !file->is_target + && default_file != 0 && default_file->cmds != 0) + { + DBF (DB_IMPLICIT, _("Using default commands for `%s'.\n")); + file->cmds = default_file->cmds; + } + + /* Update all non-intermediate files we depend on, if necessary, + and see whether any of them is more recent than this file. */ + + lastd = 0; + d = file->deps; + while (d != 0) + { + FILE_TIMESTAMP mtime; + int maybe_make; + + check_renamed (d->file); + + mtime = file_mtime (d->file); + check_renamed (d->file); + + if (is_updating (d->file)) + { + error (NILF, _("Circular %s <- %s dependency dropped."), + file->name, d->file->name); + /* We cannot free D here because our the caller will still have + a reference to it when we were called recursively via + check_dep below. */ + if (lastd == 0) + file->deps = d->next; + else + lastd->next = d->next; + d = d->next; + continue; + } + + d->file->parent = file; + maybe_make = must_make; + dep_status |= check_dep (d->file, depth, this_mtime, &maybe_make); + if (! d->ignore_mtime) + must_make = maybe_make; + + check_renamed (d->file); + + { + register struct file *f = d->file; + if (f->double_colon) + f = f->double_colon; + do + { + running |= (f->command_state == cs_running + || f->command_state == cs_deps_running); + f = f->prev; + } + while (f != 0); + } + + if (dep_status != 0 && !keep_going_flag) + break; + + if (!running) + d->changed = file_mtime (d->file) != mtime; + + lastd = d; + d = d->next; + } + + /* Now we know whether this target needs updating. + If it does, update all the intermediate files we depend on. */ + + if (must_make || always_make_flag) + { + for (d = file->deps; d != 0; d = d->next) + if (d->file->intermediate) + { + FILE_TIMESTAMP mtime = file_mtime (d->file); + check_renamed (d->file); + d->file->parent = file; + dep_status |= update_file (d->file, depth); + check_renamed (d->file); + + { + register struct file *f = d->file; + if (f->double_colon) + f = f->double_colon; + do + { + running |= (f->command_state == cs_running + || f->command_state == cs_deps_running); + f = f->prev; + } + while (f != 0); + } + + if (dep_status != 0 && !keep_going_flag) + break; + + if (!running) + d->changed = ((file->phony && file->cmds != 0) + || file_mtime (d->file) != mtime); + } + } + + finish_updating (file); + + DBF (DB_VERBOSE, _("Finished prerequisites of target file `%s'.\n")); + + if (running) + { + set_command_state (file, cs_deps_running); + --depth; + DBF (DB_VERBOSE, _("The prerequisites of `%s' are being made.\n")); + return 0; + } + + /* If any dependency failed, give up now. */ + + if (dep_status != 0) + { + file->update_status = dep_status; + notice_finished_file (file); + + --depth; + + DBF (DB_VERBOSE, _("Giving up on target file `%s'.\n")); + + if (depth == 0 && keep_going_flag + && !just_print_flag && !question_flag) + error (NILF, + _("Target `%s' not remade because of errors."), file->name); + + return dep_status; + } + + if (file->command_state == cs_deps_running) + /* The commands for some deps were running on the last iteration, but + they have finished now. Reset the command_state to not_started to + simplify later bookkeeping. It is important that we do this only + when the prior state was cs_deps_running, because that prior state + was definitely propagated to FILE's also_make's by set_command_state + (called above), but in another state an also_make may have + independently changed to finished state, and we would confuse that + file's bookkeeping (updated, but not_started is bogus state). */ + set_command_state (file, cs_not_started); + + /* Now record which prerequisites are more + recent than this file, so we can define $?. */ + + deps_changed = 0; + for (d = file->deps; d != 0; d = d->next) + { + FILE_TIMESTAMP d_mtime = file_mtime (d->file); + check_renamed (d->file); + + if (! d->ignore_mtime) + { +#if 1 + /* %%% In version 4, remove this code completely to + implement not remaking deps if their deps are newer + than their parents. */ + if (d_mtime == NONEXISTENT_MTIME && !d->file->intermediate) + /* We must remake if this dep does not + exist and is not intermediate. */ + must_make = 1; +#endif + + /* Set DEPS_CHANGED if this dep actually changed. */ + deps_changed |= d->changed; + } + + /* Set D->changed if either this dep actually changed, + or its dependent, FILE, is older or does not exist. */ + d->changed |= noexist || d_mtime > this_mtime; + + if (!noexist && ISDB (DB_BASIC|DB_VERBOSE)) + { + const char *fmt = 0; + + if (d->ignore_mtime) + { + if (ISDB (DB_VERBOSE)) + fmt = _("Prerequisite `%s' is order-only for target `%s'.\n"); + } + else if (d_mtime == NONEXISTENT_MTIME) + { + if (ISDB (DB_BASIC)) + fmt = _("Prerequisite `%s' of target `%s' does not exist.\n"); + } + else if (d->changed) + { + if (ISDB (DB_BASIC)) + fmt = _("Prerequisite `%s' is newer than target `%s'.\n"); + } + else if (ISDB (DB_VERBOSE)) + fmt = _("Prerequisite `%s' is older than target `%s'.\n"); + + if (fmt) + { + print_spaces (depth); + printf (fmt, dep_name (d), file->name); + fflush (stdout); + } + } + } + + /* Here depth returns to the value it had when we were called. */ + depth--; + + if (file->double_colon && file->deps == 0) + { + must_make = 1; + DBF (DB_BASIC, + _("Target `%s' is double-colon and has no prerequisites.\n")); + } + else if (!noexist && file->is_target && !deps_changed && file->cmds == 0 + && !always_make_flag) + { + must_make = 0; + DBF (DB_VERBOSE, + _("No commands for `%s' and no prerequisites actually changed.\n")); + } + else if (!must_make && file->cmds != 0 && always_make_flag) + { + must_make = 1; + DBF (DB_VERBOSE, _("Making `%s' due to always-make flag.\n")); + } + + if (!must_make) + { + if (ISDB (DB_VERBOSE)) + { + print_spaces (depth); + printf (_("No need to remake target `%s'"), file->name); + if (!streq (file->name, file->hname)) + printf (_("; using VPATH name `%s'"), file->hname); + puts ("."); + fflush (stdout); + } + + notice_finished_file (file); + + /* Since we don't need to remake the file, convert it to use the + VPATH filename if we found one. hfile will be either the + local name if no VPATH or the VPATH name if one was found. */ + + while (file) + { + file->name = file->hname; + file = file->prev; + } + + return 0; + } + + DBF (DB_BASIC, _("Must remake target `%s'.\n")); + + /* It needs to be remade. If it's VPATH and not reset via GPATH, toss the + VPATH. */ + if (!streq(file->name, file->hname)) + { + DB (DB_BASIC, (_(" Ignoring VPATH name `%s'.\n"), file->hname)); + file->ignore_vpath = 1; + } + + /* Now, take appropriate actions to remake the file. */ + remake_file (file); + + if (file->command_state != cs_finished) + { + DBF (DB_VERBOSE, _("Commands of `%s' are being run.\n")); + return 0; + } + + switch (file->update_status) + { + case 2: + DBF (DB_BASIC, _("Failed to remake target file `%s'.\n")); + break; + case 0: + DBF (DB_BASIC, _("Successfully remade target file `%s'.\n")); + break; + case 1: + DBF (DB_BASIC, _("Target file `%s' needs remade under -q.\n")); + break; + default: + assert (file->update_status >= 0 && file->update_status <= 2); + break; + } + + file->updated = 1; + return file->update_status; +} + +/* Set FILE's `updated' flag and re-check its mtime and the mtime's of all + files listed in its `also_make' member. Under -t, this function also + touches FILE. + + On return, FILE->update_status will no longer be -1 if it was. */ + +void +notice_finished_file (file) + register struct file *file; +{ + struct dep *d; + int ran = file->command_state == cs_running; + int touched = 0; + + file->command_state = cs_finished; + file->updated = 1; + + if (touch_flag + /* The update status will be: + -1 if this target was not remade; + 0 if 0 or more commands (+ or ${MAKE}) were run and won; + 1 if some commands were run and lost. + We touch the target if it has commands which either were not run + or won when they ran (i.e. status is 0). */ + && file->update_status == 0) + { + if (file->cmds != 0 && file->cmds->any_recurse) + { + /* If all the command lines were recursive, + we don't want to do the touching. */ + unsigned int i; + for (i = 0; i < file->cmds->ncommand_lines; ++i) + if (!(file->cmds->lines_flags[i] & COMMANDS_RECURSE)) + goto have_nonrecursing; + } + else + { + have_nonrecursing: + if (file->phony) + file->update_status = 0; + else + { + /* Should set file's modification date and do nothing else. */ + file->update_status = touch_file (file); + + /* Pretend we ran a real touch command, to suppress the + "`foo' is up to date" message. */ + commands_started++; + + /* Request for the timestamp to be updated (and distributed + to the double-colon entries). Simply setting ran=1 would + almost have done the trick, but messes up with the also_make + updating logic below. */ + touched = 1; + } + } + } + + if (file->mtime_before_update == UNKNOWN_MTIME) + file->mtime_before_update = file->last_mtime; + + if ((ran && !file->phony) || touched) + { + struct file *f; + int i = 0; + + /* If -n, -t, or -q and all the commands are recursive, we ran them so + really check the target's mtime again. Otherwise, assume the target + would have been updated. */ + + if (question_flag || just_print_flag || touch_flag) + { + for (i = file->cmds->ncommand_lines; i > 0; --i) + if (! (file->cmds->lines_flags[i-1] & COMMANDS_RECURSE)) + break; + } + + /* If there were no commands at all, it's always new. */ + + else if (file->is_target && file->cmds == 0) + i = 1; + + file->last_mtime = i == 0 ? UNKNOWN_MTIME : NEW_MTIME; + + /* Propagate the change of modification time to all the double-colon + entries for this file. */ + for (f = file->double_colon; f != 0; f = f->prev) + f->last_mtime = file->last_mtime; + } + + if (ran && file->update_status != -1) + /* We actually tried to update FILE, which has + updated its also_make's as well (if it worked). + If it didn't work, it wouldn't work again for them. + So mark them as updated with the same status. */ + for (d = file->also_make; d != 0; d = d->next) + { + d->file->command_state = cs_finished; + d->file->updated = 1; + d->file->update_status = file->update_status; + + if (ran && !d->file->phony) + /* Fetch the new modification time. + We do this instead of just invalidating the cached time + so that a vpath_search can happen. Otherwise, it would + never be done because the target is already updated. */ + (void) f_mtime (d->file, 0); + } + else if (file->update_status == -1) + /* Nothing was done for FILE, but it needed nothing done. + So mark it now as "succeeded". */ + file->update_status = 0; +} + +/* Check whether another file (whose mtime is THIS_MTIME) + needs updating on account of a dependency which is file FILE. + If it does, store 1 in *MUST_MAKE_PTR. + In the process, update any non-intermediate files + that FILE depends on (including FILE itself). + Return nonzero if any updating failed. */ + +static int +check_dep (file, depth, this_mtime, must_make_ptr) + struct file *file; + unsigned int depth; + FILE_TIMESTAMP this_mtime; + int *must_make_ptr; +{ + struct dep *d; + int dep_status = 0; + + ++depth; + start_updating (file); + + if (!file->intermediate) + /* If this is a non-intermediate file, update it and record + whether it is newer than THIS_MTIME. */ + { + FILE_TIMESTAMP mtime; + dep_status = update_file (file, depth); + check_renamed (file); + mtime = file_mtime (file); + check_renamed (file); + if (mtime == NONEXISTENT_MTIME || mtime > this_mtime) + *must_make_ptr = 1; + } + else + { + /* FILE is an intermediate file. */ + FILE_TIMESTAMP mtime; + + if (!file->phony && file->cmds == 0 && !file->tried_implicit) + { + if (try_implicit_rule (file, depth)) + DBF (DB_IMPLICIT, _("Found an implicit rule for `%s'.\n")); + else + DBF (DB_IMPLICIT, _("No implicit rule found for `%s'.\n")); + file->tried_implicit = 1; + } + if (file->cmds == 0 && !file->is_target + && default_file != 0 && default_file->cmds != 0) + { + DBF (DB_IMPLICIT, _("Using default commands for `%s'.\n")); + file->cmds = default_file->cmds; + } + + /* If the intermediate file actually exists + and is newer, then we should remake from it. */ + check_renamed (file); + mtime = file_mtime (file); + check_renamed (file); + if (mtime != NONEXISTENT_MTIME && mtime > this_mtime) + *must_make_ptr = 1; + /* Otherwise, update all non-intermediate files we depend on, + if necessary, and see whether any of them is more + recent than the file on whose behalf we are checking. */ + else + { + struct dep *lastd; + + lastd = 0; + d = file->deps; + while (d != 0) + { + int maybe_make; + + if (is_updating (d->file)) + { + error (NILF, _("Circular %s <- %s dependency dropped."), + file->name, d->file->name); + if (lastd == 0) + { + file->deps = d->next; + free ((char *) d); + d = file->deps; + } + else + { + lastd->next = d->next; + free ((char *) d); + d = lastd->next; + } + continue; + } + + d->file->parent = file; + maybe_make = *must_make_ptr; + dep_status |= check_dep (d->file, depth, this_mtime, + &maybe_make); + if (! d->ignore_mtime) + *must_make_ptr = maybe_make; + check_renamed (d->file); + if (dep_status != 0 && !keep_going_flag) + break; + + if (d->file->command_state == cs_running + || d->file->command_state == cs_deps_running) + /* Record that some of FILE's deps are still being made. + This tells the upper levels to wait on processing it until + the commands are finished. */ + set_command_state (file, cs_deps_running); + + lastd = d; + d = d->next; + } + } + } + + finish_updating (file); + return dep_status; +} + +/* Touch FILE. Return zero if successful, one if not. */ + +#define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1) + +static int +touch_file (file) + register struct file *file; +{ + if (!silent_flag) + message (0, "touch %s", file->name); + +#ifndef NO_ARCHIVES + if (ar_name (file->name)) + return ar_touch (file->name); + else +#endif + { + int fd = open (file->name, O_RDWR | O_CREAT, 0666); + + if (fd < 0) + TOUCH_ERROR ("touch: open: "); + else + { + struct stat statbuf; + char buf; + + if (fstat (fd, &statbuf) < 0) + TOUCH_ERROR ("touch: fstat: "); + /* Rewrite character 0 same as it already is. */ + if (read (fd, &buf, 1) < 0) + TOUCH_ERROR ("touch: read: "); + if (lseek (fd, 0L, 0) < 0L) + TOUCH_ERROR ("touch: lseek: "); + if (write (fd, &buf, 1) < 0) + TOUCH_ERROR ("touch: write: "); + /* If file length was 0, we just + changed it, so change it back. */ + if (statbuf.st_size == 0) + { + (void) close (fd); + fd = open (file->name, O_RDWR | O_TRUNC, 0666); + if (fd < 0) + TOUCH_ERROR ("touch: open: "); + } + (void) close (fd); + } + } + + return 0; +} + +/* Having checked and updated the dependencies of FILE, + do whatever is appropriate to remake FILE itself. + Return the status from executing FILE's commands. */ + +static void +remake_file (file) + struct file *file; +{ + if (file->cmds == 0) + { + if (file->phony) + /* Phony target. Pretend it succeeded. */ + file->update_status = 0; + else if (file->is_target) + /* This is a nonexistent target file we cannot make. + Pretend it was successfully remade. */ + file->update_status = 0; + else + { + const char *msg_noparent + = _("%sNo rule to make target `%s'%s"); + const char *msg_parent + = _("%sNo rule to make target `%s', needed by `%s'%s"); + + /* This is a dependency file we cannot remake. Fail. */ + if (!keep_going_flag && !file->dontcare) + { + if (file->parent == 0) + fatal (NILF, msg_noparent, "", file->name, ""); + + fatal (NILF, msg_parent, "", file->name, file->parent->name, ""); + } + + if (!file->dontcare) + { + if (file->parent == 0) + error (NILF, msg_noparent, "*** ", file->name, "."); + else + error (NILF, msg_parent, "*** ", + file->name, file->parent->name, "."); + } + file->update_status = 2; + } + } + else + { + chop_commands (file->cmds); + + /* The normal case: start some commands. */ + if (!touch_flag || file->cmds->any_recurse) + { + execute_file_commands (file); + return; + } + + /* This tells notice_finished_file it is ok to touch the file. */ + file->update_status = 0; + } + + /* This does the touching under -t. */ + notice_finished_file (file); +} + +/* Return the mtime of a file, given a `struct file'. + Caches the time in the struct file to avoid excess stat calls. + + If the file is not found, and SEARCH is nonzero, VPATH searching and + replacement is done. If that fails, a library (-lLIBNAME) is tried and + the library's actual name (/lib/libLIBNAME.a, etc.) is substituted into + FILE. */ + +FILE_TIMESTAMP +f_mtime (file, search) + register struct file *file; + int search; +{ + FILE_TIMESTAMP mtime; + + /* File's mtime is not known; must get it from the system. */ + +#ifndef NO_ARCHIVES + if (ar_name (file->name)) + { + /* This file is an archive-member reference. */ + + char *arname, *memname; + struct file *arfile; + int arname_used = 0; + time_t member_date; + + /* Find the archive's name. */ + ar_parse_name (file->name, &arname, &memname); + + /* Find the modification time of the archive itself. + Also allow for its name to be changed via VPATH search. */ + arfile = lookup_file (arname); + if (arfile == 0) + { + arfile = enter_file (arname); + arname_used = 1; + } + mtime = f_mtime (arfile, search); + check_renamed (arfile); + if (search && strcmp (arfile->hname, arname)) + { + /* The archive's name has changed. + Change the archive-member reference accordingly. */ + + char *name; + unsigned int arlen, memlen; + + if (!arname_used) + { + free (arname); + arname_used = 1; + } + + arname = arfile->hname; + arlen = strlen (arname); + memlen = strlen (memname); + + /* free (file->name); */ + + name = (char *) xmalloc (arlen + 1 + memlen + 2); + bcopy (arname, name, arlen); + name[arlen] = '('; + bcopy (memname, name + arlen + 1, memlen); + name[arlen + 1 + memlen] = ')'; + name[arlen + 1 + memlen + 1] = '\0'; + + /* If the archive was found with GPATH, make the change permanent; + otherwise defer it until later. */ + if (arfile->name == arfile->hname) + rename_file (file, name); + else + rehash_file (file, name); + check_renamed (file); + } + + if (!arname_used) + free (arname); + free (memname); + + file->low_resolution_time = 1; + + if (mtime == NONEXISTENT_MTIME) + /* The archive doesn't exist, so its members don't exist either. */ + return NONEXISTENT_MTIME; + + member_date = ar_member_date (file->hname); + mtime = (member_date == (time_t) -1 + ? NONEXISTENT_MTIME + : file_timestamp_cons (file->hname, member_date, 0)); + } + else +#endif + { + mtime = name_mtime (file->name); + + if (mtime == NONEXISTENT_MTIME && search && !file->ignore_vpath) + { + /* If name_mtime failed, search VPATH. */ + char *name = file->name; + if (vpath_search (&name, &mtime) + /* Last resort, is it a library (-lxxx)? */ + || (name[0] == '-' && name[1] == 'l' + && library_search (&name, &mtime))) + { + if (mtime != UNKNOWN_MTIME) + /* vpath_search and library_search store UNKNOWN_MTIME + if they didn't need to do a stat call for their work. */ + file->last_mtime = mtime; + + /* If we found it in VPATH, see if it's in GPATH too; if so, + change the name right now; if not, defer until after the + dependencies are updated. */ + if (gpath_search (name, strlen(name) - strlen(file->name) - 1)) + { + rename_file (file, name); + check_renamed (file); + return file_mtime (file); + } + + rehash_file (file, name); + check_renamed (file); + mtime = name_mtime (name); + } + } + } + + { + /* Files can have bogus timestamps that nothing newly made will be + "newer" than. Updating their dependents could just result in loops. + So notify the user of the anomaly with a warning. + + We only need to do this once, for now. */ + + if (!clock_skew_detected + && mtime != NONEXISTENT_MTIME + && !file->updated) + { + static FILE_TIMESTAMP adjusted_now; + + FILE_TIMESTAMP adjusted_mtime = mtime; + +#if defined(WINDOWS32) || defined(__MSDOS__) + /* Experimentation has shown that FAT filesystems can set file times + up to 3 seconds into the future! Play it safe. */ + +#define FAT_ADJ_OFFSET (FILE_TIMESTAMP) 3 + + FILE_TIMESTAMP adjustment = FAT_ADJ_OFFSET << FILE_TIMESTAMP_LO_BITS; + if (ORDINARY_MTIME_MIN + adjustment <= adjusted_mtime) + adjusted_mtime -= adjustment; +#endif + + /* If the file's time appears to be in the future, update our + concept of the present and try once more. */ + if (adjusted_now < adjusted_mtime) + { + int resolution; + FILE_TIMESTAMP now = file_timestamp_now (&resolution); + adjusted_now = now + (resolution - 1); + if (adjusted_now < adjusted_mtime) + { +#ifdef NO_FLOAT + error (NILF, _("Warning: File `%s' has modification time in the future"), + file->name); +#else + double from_now = + (FILE_TIMESTAMP_S (mtime) - FILE_TIMESTAMP_S (now) + + ((FILE_TIMESTAMP_NS (mtime) - FILE_TIMESTAMP_NS (now)) + / 1e9)); + error (NILF, _("Warning: File `%s' has modification time %.2g s in the future"), + file->name, from_now); +#endif + clock_skew_detected = 1; + } + } + } + } + + /* Store the mtime into all the entries for this file. */ + if (file->double_colon) + file = file->double_colon; + + do + { + /* If this file is not implicit but it is intermediate then it was + made so by the .INTERMEDIATE target. If this file has never + been built by us but was found now, it existed before make + started. So, turn off the intermediate bit so make doesn't + delete it, since it didn't create it. */ + if (mtime != NONEXISTENT_MTIME && file->command_state == cs_not_started + && file->command_state == cs_not_started + && !file->tried_implicit && file->intermediate) + file->intermediate = 0; + + file->last_mtime = mtime; + file = file->prev; + } + while (file != 0); + + return mtime; +} + + +/* Return the mtime of the file or archive-member reference NAME. */ + +static FILE_TIMESTAMP +name_mtime (name) + register char *name; +{ + struct stat st; + + if (stat (name, &st) != 0) + { + if (errno != ENOENT && errno != ENOTDIR) + perror_with_name ("stat:", name); + return NONEXISTENT_MTIME; + } + + return FILE_TIMESTAMP_STAT_MODTIME (name, st); +} + + +/* Search for a library file specified as -lLIBNAME, searching for a + suitable library file in the system library directories and the VPATH + directories. */ + +static int +library_search (lib, mtime_ptr) + char **lib; + FILE_TIMESTAMP *mtime_ptr; +{ + static char *dirs[] = + { +#ifndef _AMIGA + "/lib", + "/usr/lib", +#endif +#if defined(WINDOWS32) && !defined(LIBDIR) +/* + * This is completely up to the user at product install time. Just define + * a placeholder. + */ +#define LIBDIR "." +#endif + LIBDIR, /* Defined by configuration. */ + 0 + }; + + static char *libpatterns = NULL; + + char *libname = &(*lib)[2]; /* Name without the `-l'. */ + FILE_TIMESTAMP mtime; + + /* Loop variables for the libpatterns value. */ + char *p, *p2; + unsigned int len; + + char *file, **dp; + + /* If we don't have libpatterns, get it. */ + if (!libpatterns) + { + int save = warn_undefined_variables_flag; + warn_undefined_variables_flag = 0; + + libpatterns = xstrdup (variable_expand ("$(strip $(.LIBPATTERNS))")); + + warn_undefined_variables_flag = save; + } + + /* Loop through all the patterns in .LIBPATTERNS, and search on each one. */ + p2 = libpatterns; + while ((p = find_next_token (&p2, &len)) != 0) + { + static char *buf = NULL; + static int buflen = 0; + static int libdir_maxlen = -1; + char *libbuf = variable_expand (""); + + /* Expand the pattern using LIBNAME as a replacement. */ + { + char c = p[len]; + char *p3, *p4; + + p[len] = '\0'; + p3 = find_percent (p); + if (!p3) + { + /* Give a warning if there is no pattern, then remove the + pattern so it's ignored next time. */ + error (NILF, _(".LIBPATTERNS element `%s' is not a pattern"), p); + for (; len; --len, ++p) + *p = ' '; + *p = c; + continue; + } + p4 = variable_buffer_output (libbuf, p, p3-p); + p4 = variable_buffer_output (p4, libname, strlen (libname)); + p4 = variable_buffer_output (p4, p3+1, len - (p3-p)); + p[len] = c; + } + + /* Look first for `libNAME.a' in the current directory. */ + mtime = name_mtime (libbuf); + if (mtime != NONEXISTENT_MTIME) + { + *lib = xstrdup (libbuf); + if (mtime_ptr != 0) + *mtime_ptr = mtime; + return 1; + } + + /* Now try VPATH search on that. */ + + file = libbuf; + if (vpath_search (&file, mtime_ptr)) + { + *lib = file; + return 1; + } + + /* Now try the standard set of directories. */ + + if (!buflen) + { + for (dp = dirs; *dp != 0; ++dp) + { + int l = strlen (*dp); + if (l > libdir_maxlen) + libdir_maxlen = l; + } + buflen = strlen (libbuf); + buf = xmalloc(libdir_maxlen + buflen + 2); + } + else if (buflen < strlen (libbuf)) + { + buflen = strlen (libbuf); + buf = xrealloc (buf, libdir_maxlen + buflen + 2); + } + + for (dp = dirs; *dp != 0; ++dp) + { + sprintf (buf, "%s/%s", *dp, libbuf); + mtime = name_mtime (buf); + if (mtime != NONEXISTENT_MTIME) + { + *lib = xstrdup (buf); + if (mtime_ptr != 0) + *mtime_ptr = mtime; + return 1; + } + } + } + + return 0; +} diff --git a/flaim/external/w32/make/remote-stub.c b/flaim/external/w32/make/remote-stub.c new file mode 100644 index 0000000..69af397 --- /dev/null +++ b/flaim/external/w32/make/remote-stub.c @@ -0,0 +1,109 @@ +/* Template for the remote job exportation interface to GNU Make. +Copyright (C) 1988, 1989, 1992, 1993, 1996 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "filedef.h" +#include "job.h" +#include "commands.h" + + +char *remote_description = 0; + +/* Call once at startup even if no commands are run. */ + +void +remote_setup () +{ +} + +/* Called before exit. */ + +void +remote_cleanup () +{ +} + +/* Return nonzero if the next job should be done remotely. */ + +int +start_remote_job_p (first_p) + int first_p; +{ + return 0; +} + +/* Start a remote job running the command in ARGV, + with environment from ENVP. It gets standard input from STDIN_FD. On + failure, return nonzero. On success, return zero, and set *USED_STDIN + to nonzero if it will actually use STDIN_FD, zero if not, set *ID_PTR to + a unique identification, and set *IS_REMOTE to zero if the job is local, + nonzero if it is remote (meaning *ID_PTR is a process ID). */ + +int +start_remote_job (argv, envp, stdin_fd, is_remote, id_ptr, used_stdin) + char **argv, **envp; + int stdin_fd; + int *is_remote; + int *id_ptr; + int *used_stdin; +{ + return -1; +} + +/* Get the status of a dead remote child. Block waiting for one to die + if BLOCK is nonzero. Set *EXIT_CODE_PTR to the exit status, *SIGNAL_PTR + to the termination signal or zero if it exited normally, and *COREDUMP_PTR + nonzero if it dumped core. Return the ID of the child that died, + 0 if we would have to block and !BLOCK, or < 0 if there were none. */ + +int +remote_status (exit_code_ptr, signal_ptr, coredump_ptr, block) + int *exit_code_ptr, *signal_ptr, *coredump_ptr; + int block; +{ + errno = ECHILD; + return -1; +} + +/* Block asynchronous notification of remote child death. + If this notification is done by raising the child termination + signal, do not block that signal. */ +void +block_remote_children () +{ + return; +} + +/* Restore asynchronous notification of remote child death. + If this is done by raising the child termination signal, + do not unblock that signal. */ +void +unblock_remote_children () +{ + return; +} + +/* Send signal SIG to child ID. Return 0 if successful, -1 if not. */ +int +remote_kill (id, sig) + int id; + int sig; +{ + return -1; +} diff --git a/flaim/external/w32/make/rule.c b/flaim/external/w32/make/rule.c new file mode 100644 index 0000000..e693c02 --- /dev/null +++ b/flaim/external/w32/make/rule.c @@ -0,0 +1,717 @@ +/* Pattern and suffix rule internals for GNU Make. +Copyright (C) 1988,89,90,91,92,93, 1998 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "dep.h" +#include "filedef.h" +#include "job.h" +#include "commands.h" +#include "variable.h" +#include "rule.h" + +static void freerule PARAMS ((struct rule *rule, struct rule *lastrule)); + +/* Chain of all pattern rules. */ + +struct rule *pattern_rules; + +/* Pointer to last rule in the chain, so we can add onto the end. */ + +struct rule *last_pattern_rule; + +/* Number of rules in the chain. */ + +unsigned int num_pattern_rules; + +/* Maximum number of target patterns of any pattern rule. */ + +unsigned int max_pattern_targets; + +/* Maximum number of dependencies of any pattern rule. */ + +unsigned int max_pattern_deps; + +/* Maximum length of the name of a dependencies of any pattern rule. */ + +unsigned int max_pattern_dep_length; + +/* Chain of all pattern-specific variables. */ + +static struct pattern_var *pattern_vars; + +/* Pointer to last struct in the chain, so we can add onto the end. */ + +static struct pattern_var *last_pattern_var; + +/* Pointer to structure for the file .SUFFIXES + whose dependencies are the suffixes to be searched. */ + +struct file *suffix_file; + +/* Maximum length of a suffix. */ + +unsigned int maxsuffix; + +/* Compute the maximum dependency length and maximum number of + dependencies of all implicit rules. Also sets the subdir + flag for a rule when appropriate, possibly removing the rule + completely when appropriate. */ + +void +count_implicit_rule_limits () +{ + char *name; + unsigned int namelen; + register struct rule *rule, *lastrule; + + num_pattern_rules = max_pattern_targets = max_pattern_deps = 0; + max_pattern_dep_length = 0; + + name = 0; + namelen = 0; + rule = pattern_rules; + lastrule = 0; + while (rule != 0) + { + unsigned int ndeps = 0; + register struct dep *dep; + struct rule *next = rule->next; + unsigned int ntargets; + + ++num_pattern_rules; + + ntargets = 0; + while (rule->targets[ntargets] != 0) + ++ntargets; + + if (ntargets > max_pattern_targets) + max_pattern_targets = ntargets; + + for (dep = rule->deps; dep != 0; dep = dep->next) + { + unsigned int len = strlen (dep->name); + +#ifdef VMS + char *p = strrchr (dep->name, ']'); + char *p2; + if (p == 0) + p = strrchr (dep->name, ':'); + p2 = p != 0 ? strchr (dep->name, '%') : 0; +#else + char *p = strrchr (dep->name, '/'); + char *p2 = p != 0 ? strchr (dep->name, '%') : 0; +#endif + ndeps++; + + if (len > max_pattern_dep_length) + max_pattern_dep_length = len; + + if (p != 0 && p2 > p) + { + /* There is a slash before the % in the dep name. + Extract the directory name. */ + if (p == dep->name) + ++p; + if (p - dep->name > namelen) + { + if (name != 0) + free (name); + namelen = p - dep->name; + name = (char *) xmalloc (namelen + 1); + } + bcopy (dep->name, name, p - dep->name); + name[p - dep->name] = '\0'; + + /* In the deps of an implicit rule the `changed' flag + actually indicates that the dependency is in a + nonexistent subdirectory. */ + + dep->changed = !dir_file_exists_p (name, ""); +#ifdef VMS + if (dep->changed && strchr (name, ':') != 0) +#else + if (dep->changed && *name == '/') +#endif + { + /* The name is absolute and the directory does not exist. + This rule can never possibly match, since this dependency + can never possibly exist. So just remove the rule from + the list. */ + freerule (rule, lastrule); + --num_pattern_rules; + goto end_main_loop; + } + } + else + /* This dependency does not reside in a subdirectory. */ + dep->changed = 0; + } + + if (ndeps > max_pattern_deps) + max_pattern_deps = ndeps; + + lastrule = rule; + end_main_loop: + rule = next; + } + + if (name != 0) + free (name); +} + +/* Create a pattern rule from a suffix rule. + TARGET is the target suffix; SOURCE is the source suffix. + CMDS are the commands. + If TARGET is nil, it means the target pattern should be `(%.o)'. + If SOURCE is nil, it means there should be no deps. */ + +static void +convert_suffix_rule (target, source, cmds) + char *target, *source; + struct commands *cmds; +{ + char *targname, *targpercent, *depname; + char **names, **percents; + struct dep *deps; + unsigned int len; + + if (target == 0) + /* Special case: TARGET being nil means we are defining a + `.X.a' suffix rule; the target pattern is always `(%.o)'. */ + { +#ifdef VMS + targname = savestring ("(%.obj)", 7); +#else + targname = savestring ("(%.o)", 5); +#endif + targpercent = targname + 1; + } + else + { + /* Construct the target name. */ + len = strlen (target); + targname = xmalloc (1 + len + 1); + targname[0] = '%'; + bcopy (target, targname + 1, len + 1); + targpercent = targname; + } + + names = (char **) xmalloc (2 * sizeof (char *)); + percents = (char **) alloca (2 * sizeof (char *)); + names[0] = targname; + percents[0] = targpercent; + names[1] = percents[1] = 0; + + if (source == 0) + deps = 0; + else + { + /* Construct the dependency name. */ + len = strlen (source); + depname = xmalloc (1 + len + 1); + depname[0] = '%'; + bcopy (source, depname + 1, len + 1); + deps = (struct dep *) xmalloc (sizeof (struct dep)); + deps->next = 0; + deps->name = depname; + deps->ignore_mtime = 0; + } + + create_pattern_rule (names, percents, 0, deps, cmds, 0); +} + +/* Convert old-style suffix rules to pattern rules. + All rules for the suffixes on the .SUFFIXES list + are converted and added to the chain of pattern rules. */ + +void +convert_to_pattern () +{ + register struct dep *d, *d2; + register struct file *f; + register char *rulename; + register unsigned int slen, s2len; + + /* Compute maximum length of all the suffixes. */ + + maxsuffix = 0; + for (d = suffix_file->deps; d != 0; d = d->next) + { + register unsigned int namelen = strlen (dep_name (d)); + if (namelen > maxsuffix) + maxsuffix = namelen; + } + + rulename = (char *) alloca ((maxsuffix * 2) + 1); + + for (d = suffix_file->deps; d != 0; d = d->next) + { + /* Make a rule that is just the suffix, with no deps or commands. + This rule exists solely to disqualify match-anything rules. */ + convert_suffix_rule (dep_name (d), (char *) 0, (struct commands *) 0); + + f = d->file; + if (f->cmds != 0) + /* Record a pattern for this suffix's null-suffix rule. */ + convert_suffix_rule ("", dep_name (d), f->cmds); + + /* Record a pattern for each of this suffix's two-suffix rules. */ + slen = strlen (dep_name (d)); + bcopy (dep_name (d), rulename, slen); + for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next) + { + s2len = strlen (dep_name (d2)); + + if (slen == s2len && streq (dep_name (d), dep_name (d2))) + continue; + + bcopy (dep_name (d2), rulename + slen, s2len + 1); + f = lookup_file (rulename); + if (f == 0 || f->cmds == 0) + continue; + + if (s2len == 2 && rulename[slen] == '.' && rulename[slen + 1] == 'a') + /* A suffix rule `.X.a:' generates the pattern rule `(%.o): %.X'. + It also generates a normal `%.a: %.X' rule below. */ + convert_suffix_rule ((char *) 0, /* Indicates `(%.o)'. */ + dep_name (d), + f->cmds); + + /* The suffix rule `.X.Y:' is converted + to the pattern rule `%.Y: %.X'. */ + convert_suffix_rule (dep_name (d2), dep_name (d), f->cmds); + } + } +} + + +/* Install the pattern rule RULE (whose fields have been filled in) + at the end of the list (so that any rules previously defined + will take precedence). If this rule duplicates a previous one + (identical target and dependencies), the old one is replaced + if OVERRIDE is nonzero, otherwise this new one is thrown out. + When an old rule is replaced, the new one is put at the end of the + list. Return nonzero if RULE is used; zero if not. */ + +int +new_pattern_rule (rule, override) + register struct rule *rule; + int override; +{ + register struct rule *r, *lastrule; + register unsigned int i, j; + + rule->in_use = 0; + rule->terminal = 0; + + rule->next = 0; + + /* Search for an identical rule. */ + lastrule = 0; + for (r = pattern_rules; r != 0; lastrule = r, r = r->next) + for (i = 0; rule->targets[i] != 0; ++i) + { + for (j = 0; r->targets[j] != 0; ++j) + if (!streq (rule->targets[i], r->targets[j])) + break; + if (r->targets[j] == 0) + /* All the targets matched. */ + { + register struct dep *d, *d2; + for (d = rule->deps, d2 = r->deps; + d != 0 && d2 != 0; d = d->next, d2 = d2->next) + if (!streq (dep_name (d), dep_name (d2))) + break; + if (d == 0 && d2 == 0) + { + /* All the dependencies matched. */ + if (override) + { + /* Remove the old rule. */ + freerule (r, lastrule); + /* Install the new one. */ + if (pattern_rules == 0) + pattern_rules = rule; + else + last_pattern_rule->next = rule; + last_pattern_rule = rule; + + /* We got one. Stop looking. */ + goto matched; + } + else + { + /* The old rule stays intact. Destroy the new one. */ + freerule (rule, (struct rule *) 0); + return 0; + } + } + } + } + + matched:; + + if (r == 0) + { + /* There was no rule to replace. */ + if (pattern_rules == 0) + pattern_rules = rule; + else + last_pattern_rule->next = rule; + last_pattern_rule = rule; + } + + return 1; +} + + +/* Install an implicit pattern rule based on the three text strings + in the structure P points to. These strings come from one of + the arrays of default implicit pattern rules. + TERMINAL specifies what the `terminal' field of the rule should be. */ + +void +install_pattern_rule (p, terminal) + struct pspec *p; + int terminal; +{ + register struct rule *r; + char *ptr; + + r = (struct rule *) xmalloc (sizeof (struct rule)); + + r->targets = (char **) xmalloc (2 * sizeof (char *)); + r->suffixes = (char **) xmalloc (2 * sizeof (char *)); + r->lens = (unsigned int *) xmalloc (2 * sizeof (unsigned int)); + + r->targets[1] = 0; + r->suffixes[1] = 0; + r->lens[1] = 0; + + r->lens[0] = strlen (p->target); + /* These will all be string literals, but we malloc space for + them anyway because somebody might want to free them later on. */ + r->targets[0] = savestring (p->target, r->lens[0]); + r->suffixes[0] = find_percent (r->targets[0]); + if (r->suffixes[0] == 0) + /* Programmer-out-to-lunch error. */ + abort (); + else + ++r->suffixes[0]; + + ptr = p->dep; + r->deps = (struct dep *) multi_glob (parse_file_seq (&ptr, '\0', + sizeof (struct dep), 1), + sizeof (struct dep)); + + if (new_pattern_rule (r, 0)) + { + r->terminal = terminal; + r->cmds = (struct commands *) xmalloc (sizeof (struct commands)); + r->cmds->fileinfo.filenm = 0; + r->cmds->fileinfo.lineno = 0; + /* These will all be string literals, but we malloc space for them + anyway because somebody might want to free them later. */ + r->cmds->commands = xstrdup (p->commands); + r->cmds->command_lines = 0; + } +} + + +/* Free all the storage used in RULE and take it out of the + pattern_rules chain. LASTRULE is the rule whose next pointer + points to RULE. */ + +static void +freerule (rule, lastrule) + register struct rule *rule, *lastrule; +{ + struct rule *next = rule->next; + register unsigned int i; + register struct dep *dep; + + for (i = 0; rule->targets[i] != 0; ++i) + free (rule->targets[i]); + + dep = rule->deps; + while (dep) + { + struct dep *t; + + t = dep->next; + /* We might leak dep->name here, but I'm not sure how to fix this: I + think that pointer might be shared (e.g., in the file hash?) */ + free ((char *) dep); + dep = t; + } + + free ((char *) rule->targets); + free ((char *) rule->suffixes); + free ((char *) rule->lens); + + /* We can't free the storage for the commands because there + are ways that they could be in more than one place: + * If the commands came from a suffix rule, they could also be in + the `struct file's for other suffix rules or plain targets given + on the same makefile line. + * If two suffixes that together make a two-suffix rule were each + given twice in the .SUFFIXES list, and in the proper order, two + identical pattern rules would be created and the second one would + be discarded here, but both would contain the same `struct commands' + pointer from the `struct file' for the suffix rule. */ + + free ((char *) rule); + + if (pattern_rules == rule) + if (lastrule != 0) + abort (); + else + pattern_rules = next; + else if (lastrule != 0) + lastrule->next = next; + if (last_pattern_rule == rule) + last_pattern_rule = lastrule; +} + +/* Create a new pattern rule with the targets in the nil-terminated + array TARGETS. If TARGET_PERCENTS is not nil, it is an array of + pointers into the elements of TARGETS, where the `%'s are. + The new rule has dependencies DEPS and commands from COMMANDS. + It is a terminal rule if TERMINAL is nonzero. This rule overrides + identical rules with different commands if OVERRIDE is nonzero. + + The storage for TARGETS and its elements is used and must not be freed + until the rule is destroyed. The storage for TARGET_PERCENTS is not used; + it may be freed. */ + +void +create_pattern_rule (targets, target_percents, + terminal, deps, commands, override) + char **targets, **target_percents; + int terminal; + struct dep *deps; + struct commands *commands; + int override; +{ + register struct rule *r = (struct rule *) xmalloc (sizeof (struct rule)); + register unsigned int max_targets, i; + + r->cmds = commands; + r->deps = deps; + r->targets = targets; + + max_targets = 2; + r->lens = (unsigned int *) xmalloc (2 * sizeof (unsigned int)); + r->suffixes = (char **) xmalloc (2 * sizeof (char *)); + for (i = 0; targets[i] != 0; ++i) + { + if (i == max_targets - 1) + { + max_targets += 5; + r->lens = (unsigned int *) + xrealloc ((char *) r->lens, max_targets * sizeof (unsigned int)); + r->suffixes = (char **) + xrealloc ((char *) r->suffixes, max_targets * sizeof (char *)); + } + r->lens[i] = strlen (targets[i]); + r->suffixes[i] = (target_percents == 0 ? find_percent (targets[i]) + : target_percents[i]) + 1; + if (r->suffixes[i] == 0) + abort (); + } + + if (i < max_targets - 1) + { + r->lens = (unsigned int *) xrealloc ((char *) r->lens, + (i + 1) * sizeof (unsigned int)); + r->suffixes = (char **) xrealloc ((char *) r->suffixes, + (i + 1) * sizeof (char *)); + } + + if (new_pattern_rule (r, override)) + r->terminal = terminal; +} + +/* Create a new pattern-specific variable struct. */ + +struct pattern_var * +create_pattern_var (target, suffix) + char *target, *suffix; +{ + register struct pattern_var *p = 0; + unsigned int len = strlen(target); + + /* Look to see if this pattern already exists in the list. */ + for (p = pattern_vars; p != NULL; p = p->next) + if (p->len == len && !strcmp(p->target, target)) + break; + + if (p == 0) + { + p = (struct pattern_var *) xmalloc (sizeof (struct pattern_var)); + if (last_pattern_var != 0) + last_pattern_var->next = p; + else + pattern_vars = p; + last_pattern_var = p; + p->next = 0; + p->target = target; + p->len = len; + p->suffix = suffix + 1; + p->vars = create_new_variable_set(); + } + + return p; +} + +/* Look up a target in the pattern-specific variable list. */ + +struct pattern_var * +lookup_pattern_var (target) + char *target; +{ + struct pattern_var *p; + unsigned int targlen = strlen(target); + + for (p = pattern_vars; p != 0; p = p->next) + { + char *stem; + unsigned int stemlen; + + if (p->len > targlen) + /* It can't possibly match. */ + continue; + + /* From the lengths of the filename and the pattern parts, + find the stem: the part of the filename that matches the %. */ + stem = target + (p->suffix - p->target - 1); + stemlen = targlen - p->len + 1; + + /* Compare the text in the pattern before the stem, if any. */ + if (stem > target && !strneq (p->target, target, stem - target)) + continue; + + /* Compare the text in the pattern after the stem, if any. + We could test simply using streq, but this way we compare the + first two characters immediately. This saves time in the very + common case where the first character matches because it is a + period. */ + if (*p->suffix == stem[stemlen] + && (*p->suffix == '\0' || streq (&p->suffix[1], &stem[stemlen+1]))) + break; + } + + return p; +} + +/* Print the data base of rules. */ + +static void /* Useful to call from gdb. */ +print_rule (r) + struct rule *r; +{ + register unsigned int i; + register struct dep *d; + + for (i = 0; r->targets[i] != 0; ++i) + { + fputs (r->targets[i], stdout); + if (r->targets[i + 1] != 0) + putchar (' '); + else + putchar (':'); + } + if (r->terminal) + putchar (':'); + + for (d = r->deps; d != 0; d = d->next) + printf (" %s", dep_name (d)); + putchar ('\n'); + + if (r->cmds != 0) + print_commands (r->cmds); +} + +void +print_rule_data_base () +{ + register unsigned int rules, terminal; + register struct rule *r; + + puts (_("\n# Implicit Rules")); + + rules = terminal = 0; + for (r = pattern_rules; r != 0; r = r->next) + { + ++rules; + + putchar ('\n'); + print_rule (r); + + if (r->terminal) + ++terminal; + } + + if (rules == 0) + puts (_("\n# No implicit rules.")); + else + { + printf (_("\n# %u implicit rules, %u"), rules, terminal); +#ifndef NO_FLOAT + printf (" (%.1f%%)", (double) terminal / (double) rules * 100.0); +#else + { + int f = (terminal * 1000 + 5) / rules; + printf (" (%d.%d%%)", f/10, f%10); + } +#endif + puts (_(" terminal.")); + } + + if (num_pattern_rules != rules) + { + /* This can happen if a fatal error was detected while reading the + makefiles and thus count_implicit_rule_limits wasn't called yet. */ + if (num_pattern_rules != 0) + fatal (NILF, _("BUG: num_pattern_rules wrong! %u != %u"), + num_pattern_rules, rules); + } + + puts (_("\n# Pattern-specific variable values")); + + { + struct pattern_var *p; + + rules = 0; + for (p = pattern_vars; p != 0; p = p->next) + { + ++rules; + + printf ("\n%s :\n", p->target); + print_variable_set (p->vars->set, "# "); + } + + if (rules == 0) + puts (_("\n# No pattern-specific variable values.")); + else + { + printf (_("\n# %u pattern-specific variable values"), rules); + } + } +} diff --git a/flaim/external/w32/make/rule.h b/flaim/external/w32/make/rule.h new file mode 100644 index 0000000..30cc544 --- /dev/null +++ b/flaim/external/w32/make/rule.h @@ -0,0 +1,72 @@ +/* Definitions for using pattern rules in GNU Make. +Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* Structure used for pattern rules. */ + +struct rule + { + struct rule *next; + char **targets; /* Targets of the rule. */ + unsigned int *lens; /* Lengths of each target. */ + char **suffixes; /* Suffixes (after `%') of each target. */ + struct dep *deps; /* Dependencies of the rule. */ + struct commands *cmds; /* Commands to execute. */ + char terminal; /* If terminal (double-colon). */ + char in_use; /* If in use by a parent pattern_search. */ + }; + +struct pattern_var + { + struct pattern_var *next; + char *target; + unsigned int len; + char *suffix; + struct variable_set_list *vars; + }; + +/* For calling install_pattern_rule. */ +struct pspec + { + char *target, *dep, *commands; + }; + + +extern struct rule *pattern_rules; +extern struct rule *last_pattern_rule; +extern unsigned int num_pattern_rules; + +extern unsigned int max_pattern_deps; +extern unsigned int max_pattern_targets; +extern unsigned int max_pattern_dep_length; + +extern struct file *suffix_file; +extern unsigned int maxsuffix; + + +extern void install_pattern_rule PARAMS ((struct pspec *p, int terminal)); +extern int new_pattern_rule PARAMS ((struct rule *rule, int override)); +extern struct pattern_var *create_pattern_var PARAMS ((char *target, char *suffix)); +extern struct pattern_var *lookup_pattern_var PARAMS ((char *target)); +extern void count_implicit_rule_limits PARAMS ((void)); +extern void convert_to_pattern PARAMS ((void)); +extern void create_pattern_rule PARAMS ((char **targets, + char **target_percents, int terminal, + struct dep *deps, + struct commands *commands, + int override)); diff --git a/flaim/external/w32/make/signame.c b/flaim/external/w32/make/signame.c new file mode 100644 index 0000000..051d544 --- /dev/null +++ b/flaim/external/w32/make/signame.c @@ -0,0 +1,255 @@ +/* Convert between signal names and numbers. +Copyright (C) 1990,92,93,95,96,99, 2002 Free Software Foundation, Inc. +This file was part of the GNU C Library, but is now part of GNU make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" + +/* If the system provides strsignal, we don't need it. */ + +#if !defined(HAVE_STRSIGNAL) + +/* If the system provides sys_siglist, we'll use that. + Otherwise create our own. + */ + +#if !defined(SYS_SIGLIST_DECLARED) + +/* Some systems do not define NSIG in . */ +#ifndef NSIG +#ifdef _NSIG +#define NSIG _NSIG +#else +#define NSIG 32 +#endif +#endif + +/* There is too much variation in Sys V signal numbers and names, so + we must initialize them at runtime. */ + +static const char *undoc; + +static const char *sys_siglist[NSIG]; + +/* Table of abbreviations for signals. Note: A given number can + appear more than once with different abbreviations. */ +#define SIG_TABLE_SIZE (NSIG*2) + +typedef struct + { + int number; + const char *abbrev; + } num_abbrev; + +static num_abbrev sig_table[SIG_TABLE_SIZE]; + +/* Number of elements of sig_table used. */ +static int sig_table_nelts = 0; + +/* Enter signal number NUMBER into the tables with ABBREV and NAME. */ + +static void +init_sig (number, abbrev, name) + int number; + const char *abbrev; + const char *name; +{ + /* If this value is ever greater than NSIG it seems like it'd be a bug in + the system headers, but... better safe than sorry. We know, for + example, that this isn't always true on VMS. */ + + if (number >= 0 && number < NSIG) + sys_siglist[number] = name; + + if (sig_table_nelts < SIG_TABLE_SIZE) + { + sig_table[sig_table_nelts].number = number; + sig_table[sig_table_nelts++].abbrev = abbrev; + } +} + +static int +signame_init () +{ + int i; + + undoc = xstrdup (_("unknown signal")); + + /* Initialize signal names. */ + for (i = 0; i < NSIG; i++) + sys_siglist[i] = undoc; + + /* Initialize signal names. */ +#if defined (SIGHUP) + init_sig (SIGHUP, "HUP", _("Hangup")); +#endif +#if defined (SIGINT) + init_sig (SIGINT, "INT", _("Interrupt")); +#endif +#if defined (SIGQUIT) + init_sig (SIGQUIT, "QUIT", _("Quit")); +#endif +#if defined (SIGILL) + init_sig (SIGILL, "ILL", _("Illegal Instruction")); +#endif +#if defined (SIGTRAP) + init_sig (SIGTRAP, "TRAP", _("Trace/breakpoint trap")); +#endif + /* If SIGIOT == SIGABRT, we want to print it as SIGABRT because + SIGABRT is in ANSI and POSIX.1 and SIGIOT isn't. */ +#if defined (SIGABRT) + init_sig (SIGABRT, "ABRT", _("Aborted")); +#endif +#if defined (SIGIOT) + init_sig (SIGIOT, "IOT", _("IOT trap")); +#endif +#if defined (SIGEMT) + init_sig (SIGEMT, "EMT", _("EMT trap")); +#endif +#if defined (SIGFPE) + init_sig (SIGFPE, "FPE", _("Floating point exception")); +#endif +#if defined (SIGKILL) + init_sig (SIGKILL, "KILL", _("Killed")); +#endif +#if defined (SIGBUS) + init_sig (SIGBUS, "BUS", _("Bus error")); +#endif +#if defined (SIGSEGV) + init_sig (SIGSEGV, "SEGV", _("Segmentation fault")); +#endif +#if defined (SIGSYS) + init_sig (SIGSYS, "SYS", _("Bad system call")); +#endif +#if defined (SIGPIPE) + init_sig (SIGPIPE, "PIPE", _("Broken pipe")); +#endif +#if defined (SIGALRM) + init_sig (SIGALRM, "ALRM", _("Alarm clock")); +#endif +#if defined (SIGTERM) + init_sig (SIGTERM, "TERM", _("Terminated")); +#endif +#if defined (SIGUSR1) + init_sig (SIGUSR1, "USR1", _("User defined signal 1")); +#endif +#if defined (SIGUSR2) + init_sig (SIGUSR2, "USR2", _("User defined signal 2")); +#endif + /* If SIGCLD == SIGCHLD, we want to print it as SIGCHLD because that + is what is in POSIX.1. */ +#if defined (SIGCHLD) + init_sig (SIGCHLD, "CHLD", _("Child exited")); +#endif +#if defined (SIGCLD) + init_sig (SIGCLD, "CLD", _("Child exited")); +#endif +#if defined (SIGPWR) + init_sig (SIGPWR, "PWR", _("Power failure")); +#endif +#if defined (SIGTSTP) + init_sig (SIGTSTP, "TSTP", _("Stopped")); +#endif +#if defined (SIGTTIN) + init_sig (SIGTTIN, "TTIN", _("Stopped (tty input)")); +#endif +#if defined (SIGTTOU) + init_sig (SIGTTOU, "TTOU", _("Stopped (tty output)")); +#endif +#if defined (SIGSTOP) + init_sig (SIGSTOP, "STOP", _("Stopped (signal)")); +#endif +#if defined (SIGXCPU) + init_sig (SIGXCPU, "XCPU", _("CPU time limit exceeded")); +#endif +#if defined (SIGXFSZ) + init_sig (SIGXFSZ, "XFSZ", _("File size limit exceeded")); +#endif +#if defined (SIGVTALRM) + init_sig (SIGVTALRM, "VTALRM", _("Virtual timer expired")); +#endif +#if defined (SIGPROF) + init_sig (SIGPROF, "PROF", _("Profiling timer expired")); +#endif +#if defined (SIGWINCH) + /* "Window size changed" might be more accurate, but even if that + is all that it means now, perhaps in the future it will be + extended to cover other kinds of window changes. */ + init_sig (SIGWINCH, "WINCH", _("Window changed")); +#endif +#if defined (SIGCONT) + init_sig (SIGCONT, "CONT", _("Continued")); +#endif +#if defined (SIGURG) + init_sig (SIGURG, "URG", _("Urgent I/O condition")); +#endif +#if defined (SIGIO) + /* "I/O pending" has also been suggested. A disadvantage is + that signal only happens when the process has + asked for it, not everytime I/O is pending. Another disadvantage + is the confusion from giving it a different name than under Unix. */ + init_sig (SIGIO, "IO", _("I/O possible")); +#endif +#if defined (SIGWIND) + init_sig (SIGWIND, "WIND", _("SIGWIND")); +#endif +#if defined (SIGPHONE) + init_sig (SIGPHONE, "PHONE", _("SIGPHONE")); +#endif +#if defined (SIGPOLL) + init_sig (SIGPOLL, "POLL", _("I/O possible")); +#endif +#if defined (SIGLOST) + init_sig (SIGLOST, "LOST", _("Resource lost")); +#endif +#if defined (SIGDANGER) + init_sig (SIGDANGER, "DANGER", _("Danger signal")); +#endif +#if defined (SIGINFO) + init_sig (SIGINFO, "INFO", _("Information request")); +#endif +#if defined (SIGNOFP) + init_sig (SIGNOFP, "NOFP", _("Floating point co-processor not available")); +#endif + + return 1; +} + +#endif /* SYS_SIGLIST_DECLARED */ + + +char * +strsignal (signal) + int signal; +{ + static char buf[] = "Signal 12345678901234567890"; + +#if !defined(SYS_SIGLIST_DECLARED) + static char sig_initted = 0; + + if (!sig_initted) + sig_initted = signame_init (); +#endif + + if (signal > 0 || signal < NSIG) + return (char *) sys_siglist[signal]; + + sprintf (buf, "Signal %d", signal); + return buf; +} + +#endif /* HAVE_STRSIGNAL */ diff --git a/flaim/external/w32/make/sub_proc.c b/flaim/external/w32/make/sub_proc.c new file mode 100644 index 0000000..52f2fa2 --- /dev/null +++ b/flaim/external/w32/make/sub_proc.c @@ -0,0 +1,1207 @@ +#include +#include +#include /* for msvc _beginthreadex, _endthreadex */ +#include + +#include "sub_proc.h" +#include "proc.h" +#include "w32err.h" +#include "config.h" +#include "debug.h" + +static char *make_command_line(char *shell_name, char *exec_path, char **argv); + +typedef struct sub_process_t { + int sv_stdin[2]; + int sv_stdout[2]; + int sv_stderr[2]; + int using_pipes; + char *inp; + DWORD incnt; + char * volatile outp; + volatile DWORD outcnt; + char * volatile errp; + volatile DWORD errcnt; + int pid; + int exit_code; + int signal; + long last_err; + long lerrno; +} sub_process; + +/* keep track of children so we can implement a waitpid-like routine */ +static sub_process *proc_array[256]; +static int proc_index = 0; +static int fake_exits_pending = 0; + +/* + * When a process has been waited for, adjust the wait state + * array so that we don't wait for it again + */ +static void +process_adjust_wait_state(sub_process* pproc) +{ + int i; + + if (!proc_index) + return; + + for (i = 0; i < proc_index; i++) + if (proc_array[i]->pid == pproc->pid) + break; + + if (i < proc_index) { + proc_index--; + if (i != proc_index) + memmove(&proc_array[i], &proc_array[i+1], + (proc_index-i) * sizeof(sub_process*)); + proc_array[proc_index] = NULL; + } +} + +/* + * Waits for any of the registered child processes to finish. + */ +static sub_process * +process_wait_for_any_private(void) +{ + HANDLE handles[256]; + DWORD retval, which; + int i; + + if (!proc_index) + return NULL; + + /* build array of handles to wait for */ + for (i = 0; i < proc_index; i++) { + handles[i] = (HANDLE) proc_array[i]->pid; + + if (fake_exits_pending && proc_array[i]->exit_code) + break; + } + + /* wait for someone to exit */ + if (!fake_exits_pending) { + retval = WaitForMultipleObjects(proc_index, handles, FALSE, INFINITE); + which = retval - WAIT_OBJECT_0; + } else { + fake_exits_pending--; + retval = !WAIT_FAILED; + which = i; + } + + /* return pointer to process */ + if (retval != WAIT_FAILED) { + sub_process* pproc = proc_array[which]; + process_adjust_wait_state(pproc); + return pproc; + } else + return NULL; +} + +/* + * Terminate a process. + */ +BOOL +process_kill(HANDLE proc, int signal) +{ + sub_process* pproc = (sub_process*) proc; + pproc->signal = signal; + return (TerminateProcess((HANDLE) pproc->pid, signal)); +} + +/* + * Use this function to register processes you wish to wait for by + * calling process_file_io(NULL) or process_wait_any(). This must be done + * because it is possible for callers of this library to reuse the same + * handle for multiple processes launches :-( + */ +void +process_register(HANDLE proc) +{ + proc_array[proc_index++] = (sub_process *) proc; +} + +/* + * Public function which works kind of like waitpid(). Wait for any + * of the children to die and return results. To call this function, + * you must do 1 of things: + * + * x = process_easy(...); + * + * or + * + * x = process_init_fd(); + * process_register(x); + * + * or + * + * x = process_init(); + * process_register(x); + * + * You must NOT then call process_pipe_io() because this function is + * not capable of handling automatic notification of any child + * death. + */ + +HANDLE +process_wait_for_any(void) +{ + sub_process* pproc = process_wait_for_any_private(); + + if (!pproc) + return NULL; + else { + /* + * Ouch! can't tell caller if this fails directly. Caller + * will have to use process_last_err() + */ + (void) process_file_io(pproc); + return ((HANDLE) pproc); + } +} + +long +process_errno(HANDLE proc) +{ + return (((sub_process *)proc)->lerrno); +} + +long +process_signal(HANDLE proc) +{ + return (((sub_process *)proc)->signal); +} + + long +process_last_err(HANDLE proc) +{ + return (((sub_process *)proc)->last_err); +} + + long +process_exit_code(HANDLE proc) +{ + return (((sub_process *)proc)->exit_code); +} + + char * +process_outbuf(HANDLE proc) +{ + return (((sub_process *)proc)->outp); +} + + char * +process_errbuf(HANDLE proc) +{ + return (((sub_process *)proc)->errp); +} + + int +process_outcnt(HANDLE proc) +{ + return (((sub_process *)proc)->outcnt); +} + + int +process_errcnt(HANDLE proc) +{ + return (((sub_process *)proc)->errcnt); +} + + void +process_pipes(HANDLE proc, int pipes[3]) +{ + pipes[0] = ((sub_process *)proc)->sv_stdin[0]; + pipes[1] = ((sub_process *)proc)->sv_stdout[0]; + pipes[2] = ((sub_process *)proc)->sv_stderr[0]; + return; +} + + + HANDLE +process_init() +{ + sub_process *pproc; + /* + * open file descriptors for attaching stdin/stdout/sterr + */ + HANDLE stdin_pipes[2]; + HANDLE stdout_pipes[2]; + HANDLE stderr_pipes[2]; + SECURITY_ATTRIBUTES inherit; + BYTE sd[SECURITY_DESCRIPTOR_MIN_LENGTH]; + + pproc = malloc(sizeof(*pproc)); + memset(pproc, 0, sizeof(*pproc)); + + /* We can't use NULL for lpSecurityDescriptor because that + uses the default security descriptor of the calling process. + Instead we use a security descriptor with no DACL. This + allows nonrestricted access to the associated objects. */ + + if (!InitializeSecurityDescriptor((PSECURITY_DESCRIPTOR)(&sd), + SECURITY_DESCRIPTOR_REVISION)) { + pproc->last_err = GetLastError(); + pproc->lerrno = E_SCALL; + return((HANDLE)pproc); + } + + inherit.nLength = sizeof(inherit); + inherit.lpSecurityDescriptor = (PSECURITY_DESCRIPTOR)(&sd); + inherit.bInheritHandle = TRUE; + + // By convention, parent gets pipe[0], and child gets pipe[1] + // This means the READ side of stdin pipe goes into pipe[1] + // and the WRITE side of the stdout and stderr pipes go into pipe[1] + if (CreatePipe( &stdin_pipes[1], &stdin_pipes[0], &inherit, 0) == FALSE || + CreatePipe( &stdout_pipes[0], &stdout_pipes[1], &inherit, 0) == FALSE || + CreatePipe( &stderr_pipes[0], &stderr_pipes[1], &inherit, 0) == FALSE) { + + pproc->last_err = GetLastError(); + pproc->lerrno = E_SCALL; + return((HANDLE)pproc); + } + + // + // Mark the parent sides of the pipes as non-inheritable + // + if (SetHandleInformation(stdin_pipes[0], + HANDLE_FLAG_INHERIT, 0) == FALSE || + SetHandleInformation(stdout_pipes[0], + HANDLE_FLAG_INHERIT, 0) == FALSE || + SetHandleInformation(stderr_pipes[0], + HANDLE_FLAG_INHERIT, 0) == FALSE) { + + pproc->last_err = GetLastError(); + pproc->lerrno = E_SCALL; + return((HANDLE)pproc); + } + pproc->sv_stdin[0] = (int) stdin_pipes[0]; + pproc->sv_stdin[1] = (int) stdin_pipes[1]; + pproc->sv_stdout[0] = (int) stdout_pipes[0]; + pproc->sv_stdout[1] = (int) stdout_pipes[1]; + pproc->sv_stderr[0] = (int) stderr_pipes[0]; + pproc->sv_stderr[1] = (int) stderr_pipes[1]; + + pproc->using_pipes = 1; + + pproc->lerrno = 0; + + return((HANDLE)pproc); +} + + + HANDLE +process_init_fd(HANDLE stdinh, HANDLE stdouth, HANDLE stderrh) +{ + sub_process *pproc; + + pproc = malloc(sizeof(*pproc)); + memset(pproc, 0, sizeof(*pproc)); + + /* + * Just pass the provided file handles to the 'child side' of the + * pipe, bypassing pipes altogether. + */ + pproc->sv_stdin[1] = (int) stdinh; + pproc->sv_stdout[1] = (int) stdouth; + pproc->sv_stderr[1] = (int) stderrh; + + pproc->last_err = pproc->lerrno = 0; + + return((HANDLE)pproc); +} + + +static HANDLE +find_file(char *exec_path, LPOFSTRUCT file_info) +{ + HANDLE exec_handle; + char *fname; + char *ext; + + fname = malloc(strlen(exec_path) + 5); + strcpy(fname, exec_path); + ext = fname + strlen(fname); + + strcpy(ext, ".exe"); + if ((exec_handle = (HANDLE)OpenFile(fname, file_info, + OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) { + free(fname); + return(exec_handle); + } + + strcpy(ext, ".cmd"); + if ((exec_handle = (HANDLE)OpenFile(fname, file_info, + OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) { + free(fname); + return(exec_handle); + } + + strcpy(ext, ".bat"); + if ((exec_handle = (HANDLE)OpenFile(fname, file_info, + OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) { + free(fname); + return(exec_handle); + } + + /* should .com come before this case? */ + if ((exec_handle = (HANDLE)OpenFile(exec_path, file_info, + OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) { + free(fname); + return(exec_handle); + } + + strcpy(ext, ".com"); + if ((exec_handle = (HANDLE)OpenFile(fname, file_info, + OF_READ | OF_SHARE_COMPAT)) != (HANDLE)HFILE_ERROR) { + free(fname); + return(exec_handle); + } + + free(fname); + return(exec_handle); +} + + +/* + * Description: Create the child process to be helped + * + * Returns: + * + * Notes/Dependencies: + */ +long +process_begin( + HANDLE proc, + char **argv, + char **envp, + char *exec_path, + char *as_user) +{ + sub_process *pproc = (sub_process *)proc; + char *shell_name = 0; + int file_not_found=0; + HANDLE exec_handle; + char buf[256]; + DWORD bytes_returned; + DWORD flags; + char *command_line; + STARTUPINFO startInfo; + PROCESS_INFORMATION procInfo; + char *envblk=NULL; + OFSTRUCT file_info; + + + /* + * Shell script detection... if the exec_path starts with #! then + * we want to exec shell-script-name exec-path, not just exec-path + * NT doesn't recognize #!/bin/sh or #!/etc/Tivoli/bin/perl. We do not + * hard-code the path to the shell or perl or whatever: Instead, we + * assume it's in the path somewhere (generally, the NT tools + * bin directory) + * We use OpenFile here because it is capable of searching the Path. + */ + + exec_handle = find_file(exec_path, &file_info); + + /* + * If we couldn't open the file, just assume that Windows32 will be able + * to find and execute it. + */ + if (exec_handle == (HANDLE)HFILE_ERROR) { + file_not_found++; + } + else { + /* Attempt to read the first line of the file */ + if (ReadFile( exec_handle, + buf, sizeof(buf) - 1, /* leave room for trailing NULL */ + &bytes_returned, 0) == FALSE || bytes_returned < 2) { + + pproc->last_err = GetLastError(); + pproc->lerrno = E_IO; + CloseHandle(exec_handle); + return(-1); + } + if (buf[0] == '#' && buf[1] == '!') { + /* + * This is a shell script... Change the command line from + * exec_path args to shell_name exec_path args + */ + char *p; + + /* Make sure buf is NULL terminated */ + buf[bytes_returned] = 0; + /* + * Depending on the file system type, etc. the first line + * of the shell script may end with newline or newline-carriage-return + * Whatever it ends with, cut it off. + */ + p= strchr(buf, '\n'); + if (p) + *p = 0; + p = strchr(buf, '\r'); + if (p) + *p = 0; + + /* + * Find base name of shell + */ + shell_name = strrchr( buf, '/'); + if (shell_name) { + shell_name++; + } else { + shell_name = &buf[2];/* skipping "#!" */ + } + + } + CloseHandle(exec_handle); + } + + flags = 0; + + if (file_not_found) + command_line = make_command_line( shell_name, exec_path, argv); + else + command_line = make_command_line( shell_name, file_info.szPathName, + argv); + + if ( command_line == NULL ) { + pproc->last_err = 0; + pproc->lerrno = E_NO_MEM; + return(-1); + } + + if (envp) { + if (arr2envblk(envp, &envblk) ==FALSE) { + pproc->last_err = 0; + pproc->lerrno = E_NO_MEM; + free( command_line ); + return(-1); + } + } + + if ((shell_name) || (file_not_found)) { + exec_path = 0; /* Search for the program in %Path% */ + } else { + exec_path = file_info.szPathName; + } + + /* + * Set up inherited stdin, stdout, stderr for child + */ + GetStartupInfo(&startInfo); + startInfo.dwFlags = STARTF_USESTDHANDLES; + startInfo.lpReserved = 0; + startInfo.cbReserved2 = 0; + startInfo.lpReserved2 = 0; + startInfo.lpTitle = shell_name ? shell_name : exec_path; + startInfo.hStdInput = (HANDLE)pproc->sv_stdin[1]; + startInfo.hStdOutput = (HANDLE)pproc->sv_stdout[1]; + startInfo.hStdError = (HANDLE)pproc->sv_stderr[1]; + + if (as_user) { + if (envblk) free(envblk); + return -1; + } else { + DB (DB_JOBS, ("CreateProcess(%s,%s,...)\n", + exec_path ? exec_path : "NULL", + command_line ? command_line : "NULL")); + if (CreateProcess( + exec_path, + command_line, + NULL, + 0, /* default security attributes for thread */ + TRUE, /* inherit handles (e.g. helper pipes, oserv socket) */ + flags, + envblk, + 0, /* default starting directory */ + &startInfo, + &procInfo) == FALSE) { + + pproc->last_err = GetLastError(); + pproc->lerrno = E_FORK; + fprintf(stderr, "process_begin: CreateProcess(%s, %s, ...) failed.\n", exec_path, command_line); + if (envblk) free(envblk); + free( command_line ); + return(-1); + } + } + + pproc->pid = (int)procInfo.hProcess; + /* Close the thread handle -- we'll just watch the process */ + CloseHandle(procInfo.hThread); + + /* Close the halves of the pipes we don't need */ + if (pproc->sv_stdin) { + CloseHandle((HANDLE)pproc->sv_stdin[1]); + (HANDLE)pproc->sv_stdin[1] = 0; + } + if (pproc->sv_stdout) { + CloseHandle((HANDLE)pproc->sv_stdout[1]); + (HANDLE)pproc->sv_stdout[1] = 0; + } + if (pproc->sv_stderr) { + CloseHandle((HANDLE)pproc->sv_stderr[1]); + (HANDLE)pproc->sv_stderr[1] = 0; + } + + free( command_line ); + if (envblk) free(envblk); + pproc->lerrno=0; + return 0; +} + + + +static DWORD +proc_stdin_thread(sub_process *pproc) +{ + DWORD in_done; + for (;;) { + if (WriteFile( (HANDLE) pproc->sv_stdin[0], pproc->inp, pproc->incnt, + &in_done, NULL) == FALSE) + _endthreadex(0); + // This if should never be true for anonymous pipes, but gives + // us a chance to change I/O mechanisms later + if (in_done < pproc->incnt) { + pproc->incnt -= in_done; + pproc->inp += in_done; + } else { + _endthreadex(0); + } + } + return 0; // for compiler warnings only.. not reached +} + +static DWORD +proc_stdout_thread(sub_process *pproc) +{ + DWORD bufsize = 1024; + char c; + DWORD nread; + pproc->outp = malloc(bufsize); + if (pproc->outp == NULL) + _endthreadex(0); + pproc->outcnt = 0; + + for (;;) { + if (ReadFile( (HANDLE)pproc->sv_stdout[0], &c, 1, &nread, NULL) + == FALSE) { +/* map_windows32_error_to_string(GetLastError());*/ + _endthreadex(0); + } + if (nread == 0) + _endthreadex(0); + if (pproc->outcnt + nread > bufsize) { + bufsize += nread + 512; + pproc->outp = realloc(pproc->outp, bufsize); + if (pproc->outp == NULL) { + pproc->outcnt = 0; + _endthreadex(0); + } + } + pproc->outp[pproc->outcnt++] = c; + } + return 0; +} + +static DWORD +proc_stderr_thread(sub_process *pproc) +{ + DWORD bufsize = 1024; + char c; + DWORD nread; + pproc->errp = malloc(bufsize); + if (pproc->errp == NULL) + _endthreadex(0); + pproc->errcnt = 0; + + for (;;) { + if (ReadFile( (HANDLE)pproc->sv_stderr[0], &c, 1, &nread, NULL) == FALSE) { + map_windows32_error_to_string(GetLastError()); + _endthreadex(0); + } + if (nread == 0) + _endthreadex(0); + if (pproc->errcnt + nread > bufsize) { + bufsize += nread + 512; + pproc->errp = realloc(pproc->errp, bufsize); + if (pproc->errp == NULL) { + pproc->errcnt = 0; + _endthreadex(0); + } + } + pproc->errp[pproc->errcnt++] = c; + } + return 0; +} + + +/* + * Purpose: collects output from child process and returns results + * + * Description: + * + * Returns: + * + * Notes/Dependencies: + */ + long +process_pipe_io( + HANDLE proc, + char *stdin_data, + int stdin_data_len) +{ + sub_process *pproc = (sub_process *)proc; + bool_t stdin_eof = FALSE, stdout_eof = FALSE, stderr_eof = FALSE; + HANDLE childhand = (HANDLE) pproc->pid; + HANDLE tStdin, tStdout, tStderr; + DWORD dwStdin, dwStdout, dwStderr; + HANDLE wait_list[4]; + DWORD wait_count; + DWORD wait_return; + HANDLE ready_hand; + bool_t child_dead = FALSE; + + + /* + * Create stdin thread, if needed + */ + pproc->inp = stdin_data; + pproc->incnt = stdin_data_len; + if (!pproc->inp) { + stdin_eof = TRUE; + CloseHandle((HANDLE)pproc->sv_stdin[0]); + (HANDLE)pproc->sv_stdin[0] = 0; + } else { + tStdin = (HANDLE) _beginthreadex( 0, 1024, + (unsigned (__stdcall *) (void *))proc_stdin_thread, pproc, 0, + (unsigned int *) &dwStdin); + if (tStdin == 0) { + pproc->last_err = GetLastError(); + pproc->lerrno = E_SCALL; + goto done; + } + } + + /* + * Assume child will produce stdout and stderr + */ + tStdout = (HANDLE) _beginthreadex( 0, 1024, + (unsigned (__stdcall *) (void *))proc_stdout_thread, pproc, 0, + (unsigned int *) &dwStdout); + tStderr = (HANDLE) _beginthreadex( 0, 1024, + (unsigned (__stdcall *) (void *))proc_stderr_thread, pproc, 0, + (unsigned int *) &dwStderr); + + if (tStdout == 0 || tStderr == 0) { + + pproc->last_err = GetLastError(); + pproc->lerrno = E_SCALL; + goto done; + } + + + /* + * Wait for all I/O to finish and for the child process to exit + */ + + while (!stdin_eof || !stdout_eof || !stderr_eof || !child_dead) { + wait_count = 0; + if (!stdin_eof) { + wait_list[wait_count++] = tStdin; + } + if (!stdout_eof) { + wait_list[wait_count++] = tStdout; + } + if (!stderr_eof) { + wait_list[wait_count++] = tStderr; + } + if (!child_dead) { + wait_list[wait_count++] = childhand; + } + + wait_return = WaitForMultipleObjects(wait_count, wait_list, + FALSE, /* don't wait for all: one ready will do */ + child_dead? 1000 :INFINITE); /* after the child dies, subthreads have + one second to collect all remaining output */ + + if (wait_return == WAIT_FAILED) { +/* map_windows32_error_to_string(GetLastError());*/ + pproc->last_err = GetLastError(); + pproc->lerrno = E_SCALL; + goto done; + } + + ready_hand = wait_list[wait_return - WAIT_OBJECT_0]; + + if (ready_hand == tStdin) { + CloseHandle((HANDLE)pproc->sv_stdin[0]); + (HANDLE)pproc->sv_stdin[0] = 0; + CloseHandle(tStdin); + tStdin = 0; + stdin_eof = TRUE; + + } else if (ready_hand == tStdout) { + + CloseHandle((HANDLE)pproc->sv_stdout[0]); + (HANDLE)pproc->sv_stdout[0] = 0; + CloseHandle(tStdout); + tStdout = 0; + stdout_eof = TRUE; + + } else if (ready_hand == tStderr) { + + CloseHandle((HANDLE)pproc->sv_stderr[0]); + (HANDLE)pproc->sv_stderr[0] = 0; + CloseHandle(tStderr); + tStderr = 0; + stderr_eof = TRUE; + + } else if (ready_hand == childhand) { + + if (GetExitCodeProcess(childhand, &pproc->exit_code) == FALSE) { + pproc->last_err = GetLastError(); + pproc->lerrno = E_SCALL; + goto done; + } + child_dead = TRUE; + + } else { + + /* ?? Got back a handle we didn't query ?? */ + pproc->last_err = 0; + pproc->lerrno = E_FAIL; + goto done; + } + } + + done: + if (tStdin != 0) + CloseHandle(tStdin); + if (tStdout != 0) + CloseHandle(tStdout); + if (tStderr != 0) + CloseHandle(tStderr); + + if (pproc->lerrno) + return(-1); + else + return(0); + +} + +/* + * Purpose: collects output from child process and returns results + * + * Description: + * + * Returns: + * + * Notes/Dependencies: + */ + long +process_file_io( + HANDLE proc) +{ + sub_process *pproc; + HANDLE childhand; + DWORD wait_return; + + if (proc == NULL) + pproc = process_wait_for_any_private(); + else + pproc = (sub_process *)proc; + + /* some sort of internal error */ + if (!pproc) + return -1; + + childhand = (HANDLE) pproc->pid; + + /* + * This function is poorly named, and could also be used just to wait + * for child death if you're doing your own pipe I/O. If that is + * the case, close the pipe handles here. + */ + if (pproc->sv_stdin[0]) { + CloseHandle((HANDLE)pproc->sv_stdin[0]); + pproc->sv_stdin[0] = 0; + } + if (pproc->sv_stdout[0]) { + CloseHandle((HANDLE)pproc->sv_stdout[0]); + pproc->sv_stdout[0] = 0; + } + if (pproc->sv_stderr[0]) { + CloseHandle((HANDLE)pproc->sv_stderr[0]); + pproc->sv_stderr[0] = 0; + } + + /* + * Wait for the child process to exit + */ + + wait_return = WaitForSingleObject(childhand, INFINITE); + + if (wait_return != WAIT_OBJECT_0) { +/* map_windows32_error_to_string(GetLastError());*/ + pproc->last_err = GetLastError(); + pproc->lerrno = E_SCALL; + goto done2; + } + + if (GetExitCodeProcess(childhand, &pproc->exit_code) == FALSE) { + pproc->last_err = GetLastError(); + pproc->lerrno = E_SCALL; + } + +done2: + if (pproc->lerrno) + return(-1); + else + return(0); + +} + +/* + * Description: Clean up any leftover handles, etc. It is up to the + * caller to manage and free the input, ouput, and stderr buffers. + */ + void +process_cleanup( + HANDLE proc) +{ + sub_process *pproc = (sub_process *)proc; + int i; + + if (pproc->using_pipes) { + for (i= 0; i <= 1; i++) { + if ((HANDLE)pproc->sv_stdin[i]) + CloseHandle((HANDLE)pproc->sv_stdin[i]); + if ((HANDLE)pproc->sv_stdout[i]) + CloseHandle((HANDLE)pproc->sv_stdout[i]); + if ((HANDLE)pproc->sv_stderr[i]) + CloseHandle((HANDLE)pproc->sv_stderr[i]); + } + } + if ((HANDLE)pproc->pid) + CloseHandle((HANDLE)pproc->pid); + + free(pproc); +} + + +/* + * Description: + * Create a command line buffer to pass to CreateProcess + * + * Returns: the buffer or NULL for failure + * Shell case: sh_name a:/full/path/to/script argv[1] argv[2] ... + * Otherwise: argv[0] argv[1] argv[2] ... + * + * Notes/Dependencies: + * CreateProcess does not take an argv, so this command creates a + * command line for the executable. + */ + +static char * +make_command_line( char *shell_name, char *full_exec_path, char **argv) +{ + int argc = 0; + char** argvi; + int* enclose_in_quotes = NULL; + int* enclose_in_quotes_i; + unsigned int bytes_required = 0; + char* command_line; + char* command_line_i; + int cygwin_mode = 0; /* HAVE_CYGWIN_SHELL */ + int have_sh = 0; /* HAVE_CYGWIN_SHELL */ + +#ifdef HAVE_CYGWIN_SHELL + have_sh = (shell_name != NULL || strstr(full_exec_path, "sh.exe")); + cygwin_mode = 1; +#endif + + if (shell_name && full_exec_path) { + bytes_required + = strlen(shell_name) + 1 + strlen(full_exec_path); + /* + * Skip argv[0] if any, when shell_name is given. + */ + if (*argv) argv++; + /* + * Add one for the intervening space. + */ + if (*argv) bytes_required++; + } + + argvi = argv; + while (*(argvi++)) argc++; + + if (argc) { + enclose_in_quotes = (int*) calloc(1, argc * sizeof(int)); + + if (!enclose_in_quotes) { + return NULL; + } + } + + /* We have to make one pass through each argv[i] to see if we need + * to enclose it in ", so we might as well figure out how much + * memory we'll need on the same pass. + */ + + argvi = argv; + enclose_in_quotes_i = enclose_in_quotes; + while(*argvi) { + char* p = *argvi; + unsigned int backslash_count = 0; + + /* + * We have to enclose empty arguments in ". + */ + if (!(*p)) *enclose_in_quotes_i = 1; + + while(*p) { + switch (*p) { + case '\"': + /* + * We have to insert a backslash for each " + * and each \ that precedes the ". + */ + bytes_required += (backslash_count + 1); + backslash_count = 0; + break; + +#if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL) + case '\\': + backslash_count++; + break; +#endif + /* + * At one time we set *enclose_in_quotes_i for '*' or '?' to suppress + * wildcard expansion in programs linked with MSVC's SETARGV.OBJ so + * that argv in always equals argv out. This was removed. Say you have + * such a program named glob.exe. You enter + * glob '*' + * at the sh command prompt. Obviously the intent is to make glob do the + * wildcarding instead of sh. If we set *enclose_in_quotes_i for '*' or '?', + * then the command line that glob would see would be + * glob "*" + * and the _setargv in SETARGV.OBJ would _not_ expand the *. + */ + case ' ': + case '\t': + *enclose_in_quotes_i = 1; + /* fall through */ + + default: + backslash_count = 0; + break; + } + + /* + * Add one for each character in argv[i]. + */ + bytes_required++; + + p++; + } + + if (*enclose_in_quotes_i) { + /* + * Add one for each enclosing ", + * and one for each \ that precedes the + * closing ". + */ + bytes_required += (backslash_count + 2); + } + + /* + * Add one for the intervening space. + */ + if (*(++argvi)) bytes_required++; + enclose_in_quotes_i++; + } + + /* + * Add one for the terminating NULL. + */ + bytes_required++; + + command_line = (char*) malloc(bytes_required); + + if (!command_line) { + if (enclose_in_quotes) free(enclose_in_quotes); + return NULL; + } + + command_line_i = command_line; + + if (shell_name && full_exec_path) { + while(*shell_name) { + *(command_line_i++) = *(shell_name++); + } + + *(command_line_i++) = ' '; + + while(*full_exec_path) { + *(command_line_i++) = *(full_exec_path++); + } + + if (*argv) { + *(command_line_i++) = ' '; + } + } + + argvi = argv; + enclose_in_quotes_i = enclose_in_quotes; + + while(*argvi) { + char* p = *argvi; + unsigned int backslash_count = 0; + + if (*enclose_in_quotes_i) { + *(command_line_i++) = '\"'; + } + + while(*p) { + if (*p == '\"') { + if (cygwin_mode && have_sh) { /* HAVE_CYGWIN_SHELL */ + /* instead of a \", cygwin likes "" */ + *(command_line_i++) = '\"'; + } else { + + /* + * We have to insert a backslash for the " + * and each \ that precedes the ". + */ + backslash_count++; + + while(backslash_count) { + *(command_line_i++) = '\\'; + backslash_count--; + }; + } +#if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL) + } else if (*p == '\\') { + backslash_count++; + } else { + backslash_count = 0; +#endif + } + + /* + * Copy the character. + */ + *(command_line_i++) = *(p++); + } + + if (*enclose_in_quotes_i) { +#if !defined(HAVE_MKS_SHELL) && !defined(HAVE_CYGWIN_SHELL) + /* + * Add one \ for each \ that precedes the + * closing ". + */ + while(backslash_count--) { + *(command_line_i++) = '\\'; + }; +#endif + *(command_line_i++) = '\"'; + } + + /* + * Append an intervening space. + */ + if (*(++argvi)) { + *(command_line_i++) = ' '; + } + + enclose_in_quotes_i++; + } + + /* + * Append the terminating NULL. + */ + *command_line_i = '\0'; + + if (enclose_in_quotes) free(enclose_in_quotes); + return command_line; +} + +/* + * Description: Given an argv and optional envp, launch the process + * using the default stdin, stdout, and stderr handles. + * Also, register process so that process_wait_for_any_private() + * can be used via process_file_io(NULL) or + * process_wait_for_any(). + * + * Returns: + * + * Notes/Dependencies: + */ +HANDLE +process_easy( + char **argv, + char **envp) +{ + HANDLE hIn; + HANDLE hOut; + HANDLE hErr; + HANDLE hProcess; + + if (DuplicateHandle(GetCurrentProcess(), + GetStdHandle(STD_INPUT_HANDLE), + GetCurrentProcess(), + &hIn, + 0, + TRUE, + DUPLICATE_SAME_ACCESS) == FALSE) { + fprintf(stderr, + "process_easy: DuplicateHandle(In) failed (e=%d)\n", + GetLastError()); + return INVALID_HANDLE_VALUE; + } + if (DuplicateHandle(GetCurrentProcess(), + GetStdHandle(STD_OUTPUT_HANDLE), + GetCurrentProcess(), + &hOut, + 0, + TRUE, + DUPLICATE_SAME_ACCESS) == FALSE) { + fprintf(stderr, + "process_easy: DuplicateHandle(Out) failed (e=%d)\n", + GetLastError()); + return INVALID_HANDLE_VALUE; + } + if (DuplicateHandle(GetCurrentProcess(), + GetStdHandle(STD_ERROR_HANDLE), + GetCurrentProcess(), + &hErr, + 0, + TRUE, + DUPLICATE_SAME_ACCESS) == FALSE) { + fprintf(stderr, + "process_easy: DuplicateHandle(Err) failed (e=%d)\n", + GetLastError()); + return INVALID_HANDLE_VALUE; + } + + hProcess = process_init_fd(hIn, hOut, hErr); + + if (process_begin(hProcess, argv, envp, argv[0], NULL)) { + fake_exits_pending++; + ((sub_process*) hProcess)->exit_code = process_last_err(hProcess); + + /* close up unused handles */ + CloseHandle(hIn); + CloseHandle(hOut); + CloseHandle(hErr); + } + + process_register(hProcess); + + return hProcess; +} diff --git a/flaim/external/w32/make/sub_proc.h b/flaim/external/w32/make/sub_proc.h new file mode 100644 index 0000000..d7c57a2 --- /dev/null +++ b/flaim/external/w32/make/sub_proc.h @@ -0,0 +1,47 @@ +#ifndef SUB_PROC_H +#define SUB_PROC_H + +/* + * Component Name: + * + * $Date: 1997/08/27 20:34:23 $ + * + * $Source: /cvsroot/make/make/w32/include/sub_proc.h,v $ + * + * $Revision: 1.4 $ + */ + +/* $Id: sub_proc.h,v 1.4 1997/08/27 20:34:23 psmith Exp $ */ + +#ifdef WINDOWS32 + +#define EXTERN_DECL(entry, args) extern entry args +#define VOID_DECL void + +EXTERN_DECL(HANDLE process_init, (VOID_DECL)); +EXTERN_DECL(HANDLE process_init_fd, (HANDLE stdinh, HANDLE stdouth, + HANDLE stderrh)); +EXTERN_DECL(long process_begin, (HANDLE proc, char **argv, char **envp, + char *exec_path, char *as_user)); +EXTERN_DECL(long process_pipe_io, (HANDLE proc, char *stdin_data, + int stdin_data_len)); +EXTERN_DECL(long process_file_io, (HANDLE proc)); +EXTERN_DECL(void process_cleanup, (HANDLE proc)); +EXTERN_DECL(HANDLE process_wait_for_any, (VOID_DECL)); +EXTERN_DECL(void process_register, (HANDLE proc)); +EXTERN_DECL(HANDLE process_easy, (char** argv, char** env)); +EXTERN_DECL(BOOL process_kill, (HANDLE proc, int signal)); + +/* support routines */ +EXTERN_DECL(long process_errno, (HANDLE proc)); +EXTERN_DECL(long process_last_err, (HANDLE proc)); +EXTERN_DECL(long process_exit_code, (HANDLE proc)); +EXTERN_DECL(long process_signal, (HANDLE proc)); +EXTERN_DECL(char * process_outbuf, (HANDLE proc)); +EXTERN_DECL(char * process_errbuf, (HANDLE proc)); +EXTERN_DECL(int process_outcnt, (HANDLE proc)); +EXTERN_DECL(int process_errcnt, (HANDLE proc)); +EXTERN_DECL(void process_pipes, (HANDLE proc, int pipes[3])); + +#endif +#endif diff --git a/flaim/external/w32/make/variable.c b/flaim/external/w32/make/variable.c new file mode 100644 index 0000000..bb8d810 --- /dev/null +++ b/flaim/external/w32/make/variable.c @@ -0,0 +1,1263 @@ +/* Internals of variables for GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1996, 1997, +2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "dep.h" +#include "filedef.h" +#include "job.h" +#include "commands.h" +#include "variable.h" +#include "rule.h" +#ifdef WINDOWS32 +#include "pathstuff.h" +#endif +#include "hash.h" + +/* Hash table of all global variable definitions. */ + +static unsigned long +variable_hash_1 (keyv) + const void *keyv; +{ + struct variable const *key = (struct variable const *) keyv; + return_STRING_N_HASH_1 (key->name, key->length); +} + +static unsigned long +variable_hash_2 (keyv) + const void *keyv; +{ + struct variable const *key = (struct variable const *) keyv; + return_STRING_N_HASH_2 (key->name, key->length); +} + +static int +variable_hash_cmp (xv, yv) + const void *xv; + const void *yv; +{ + struct variable const *x = (struct variable const *) xv; + struct variable const *y = (struct variable const *) yv; + int result = x->length - y->length; + if (result) + return result; + return_STRING_N_COMPARE (x->name, y->name, x->length); +} + +#ifndef VARIABLE_BUCKETS +#define VARIABLE_BUCKETS 523 +#endif +#ifndef PERFILE_VARIABLE_BUCKETS +#define PERFILE_VARIABLE_BUCKETS 23 +#endif +#ifndef SMALL_SCOPE_VARIABLE_BUCKETS +#define SMALL_SCOPE_VARIABLE_BUCKETS 13 +#endif + +static struct variable_set global_variable_set; +static struct variable_set_list global_setlist + = { 0, &global_variable_set }; +struct variable_set_list *current_variable_set_list = &global_setlist; + +/* Implement variables. */ + +void +init_hash_global_variable_set () +{ + hash_init (&global_variable_set.table, VARIABLE_BUCKETS, + variable_hash_1, variable_hash_2, variable_hash_cmp); +} + +/* Define variable named NAME with value VALUE in SET. VALUE is copied. + LENGTH is the length of NAME, which does not need to be null-terminated. + ORIGIN specifies the origin of the variable (makefile, command line + or environment). + If RECURSIVE is nonzero a flag is set in the variable saying + that it should be recursively re-expanded. */ + +struct variable * +define_variable_in_set (name, length, value, origin, recursive, set, flocp) + const char *name; + unsigned int length; + char *value; + enum variable_origin origin; + int recursive; + struct variable_set *set; + const struct floc *flocp; +{ + struct variable *v; + struct variable **var_slot; + struct variable var_key; + + if (set == NULL) + set = &global_variable_set; + + var_key.name = (char *) name; + var_key.length = length; + var_slot = (struct variable **) hash_find_slot (&set->table, &var_key); + + if (env_overrides && origin == o_env) + origin = o_env_override; + + v = *var_slot; + if (! HASH_VACANT (v)) + { + if (env_overrides && v->origin == o_env) + /* V came from in the environment. Since it was defined + before the switches were parsed, it wasn't affected by -e. */ + v->origin = o_env_override; + + /* A variable of this name is already defined. + If the old definition is from a stronger source + than this one, don't redefine it. */ + if ((int) origin >= (int) v->origin) + { + if (v->value != 0) + free (v->value); + v->value = xstrdup (value); + if (flocp != 0) + v->fileinfo = *flocp; + else + v->fileinfo.filenm = 0; + v->origin = origin; + v->recursive = recursive; + } + return v; + } + + /* Create a new variable definition and add it to the hash table. */ + + v = (struct variable *) xmalloc (sizeof (struct variable)); + v->name = savestring (name, length); + v->length = length; + hash_insert_at (&set->table, v, var_slot); + v->value = xstrdup (value); + if (flocp != 0) + v->fileinfo = *flocp; + else + v->fileinfo.filenm = 0; + v->origin = origin; + v->recursive = recursive; + v->expanding = 0; + v->exp_count = 0; + v->per_target = 0; + v->append = 0; + v->export = v_default; + + v->exportable = 1; + if (*name != '_' && (*name < 'A' || *name > 'Z') + && (*name < 'a' || *name > 'z')) + v->exportable = 0; + else + { + for (++name; *name != '\0'; ++name) + if (*name != '_' && (*name < 'a' || *name > 'z') + && (*name < 'A' || *name > 'Z') && !ISDIGIT(*name)) + break; + + if (*name != '\0') + v->exportable = 0; + } + + return v; +} + +/* If the variable passed in is "special", handle its special nature. + Currently there are two such variables, both used for introspection: + .VARIABLES expands to a list of all the variables defined in this instance + of make. + .TARGETS expands to a list of all the targets defined in this + instance of make. + Returns the variable reference passed in. */ + +#define EXPANSION_INCREMENT(_l) ((((_l) / 500) + 1) * 500) + +static struct variable * +handle_special_var (var) + struct variable *var; +{ + static unsigned long last_var_count = 0; + + + /* This one actually turns out to be very hard, due to the way the parser + records targets. The way it works is that target information is collected + internally until make knows the target is completely specified. It unitl + it sees that some new construct (a new target or variable) is defined that + it knows the previous one is done. In short, this means that if you do + this: + + all: + + TARGS := $(.TARGETS) + + then $(TARGS) won't contain "all", because it's not until after the + variable is created that the previous target is completed. + + Changing this would be a major pain. I think a less complex way to do it + would be to pre-define the target files as soon as the first line is + parsed, then come back and do the rest of the definition as now. That + would allow $(.TARGETS) to be correct without a major change to the way + the parser works. + + if (streq (var->name, ".TARGETS")) + var->value = build_target_list (var->value); + else + */ + + if (streq (var->name, ".VARIABLES") + && global_variable_set.table.ht_fill != last_var_count) + { + unsigned long max = EXPANSION_INCREMENT (strlen (var->value)); + unsigned long len; + char *p; + struct variable **vp = (struct variable **) global_variable_set.table.ht_vec; + struct variable **end = &vp[global_variable_set.table.ht_size]; + + /* Make sure we have at least MAX bytes in the allocated buffer. */ + var->value = xrealloc (var->value, max); + + /* Walk through the hash of variables, constructing a list of names. */ + p = var->value; + len = 0; + for (; vp < end; ++vp) + if (!HASH_VACANT (*vp)) + { + struct variable *v = *vp; + int l = v->length; + + len += l + 1; + if (len > max) + { + unsigned long off = p - var->value; + + max += EXPANSION_INCREMENT (l + 1); + var->value = xrealloc (var->value, max); + p = &var->value[off]; + } + + bcopy (v->name, p, l); + p += l; + *(p++) = ' '; + } + *(p-1) = '\0'; + + /* Remember how many variables are in our current count. Since we never + remove variables from the list, this is a reliable way to know whether + the list is up to date or needs to be recomputed. */ + + last_var_count = global_variable_set.table.ht_fill; + } + + return var; +} + + +/* Lookup a variable whose name is a string starting at NAME + and with LENGTH chars. NAME need not be null-terminated. + Returns address of the `struct variable' containing all info + on the variable, or nil if no such variable is defined. */ + +struct variable * +lookup_variable (name, length) + const char *name; + unsigned int length; +{ + const struct variable_set_list *setlist; + struct variable var_key; + + var_key.name = (char *) name; + var_key.length = length; + + for (setlist = current_variable_set_list; + setlist != 0; setlist = setlist->next) + { + const struct variable_set *set = setlist->set; + struct variable *v; + + v = (struct variable *) hash_find_item ((struct hash_table *) &set->table, &var_key); + if (v) + return v->special ? handle_special_var (v) : v; + } + +#ifdef VMS + /* since we don't read envp[] on startup, try to get the + variable via getenv() here. */ + { + char *vname = alloca (length + 1); + char *value; + strncpy (vname, name, length); + vname[length] = 0; + value = getenv (vname); + if (value != 0) + { + char *sptr; + int scnt; + + sptr = value; + scnt = 0; + + while ((sptr = strchr (sptr, '$'))) + { + scnt++; + sptr++; + } + + if (scnt > 0) + { + char *nvalue; + char *nptr; + + nvalue = alloca (strlen (value) + scnt + 1); + sptr = value; + nptr = nvalue; + + while (*sptr) + { + if (*sptr == '$') + { + *nptr++ = '$'; + *nptr++ = '$'; + } + else + { + *nptr++ = *sptr; + } + sptr++; + } + + *nptr = '\0'; + return define_variable (vname, length, nvalue, o_env, 1); + + } + + return define_variable (vname, length, value, o_env, 1); + } + } +#endif /* VMS */ + + return 0; +} + +/* Lookup a variable whose name is a string starting at NAME + and with LENGTH chars in set SET. NAME need not be null-terminated. + Returns address of the `struct variable' containing all info + on the variable, or nil if no such variable is defined. */ + +struct variable * +lookup_variable_in_set (name, length, set) + const char *name; + unsigned int length; + const struct variable_set *set; +{ + struct variable var_key; + + var_key.name = (char *) name; + var_key.length = length; + + return (struct variable *) hash_find_item ((struct hash_table *) &set->table, &var_key); +} + +/* Initialize FILE's variable set list. If FILE already has a variable set + list, the topmost variable set is left intact, but the the rest of the + chain is replaced with FILE->parent's setlist. If FILE is a double-colon + rule, then we will use the "root" double-colon target's variable set as the + parent of FILE's variable set. + + If we're READing a makefile, don't do the pattern variable search now, + since the pattern variable might not have been defined yet. */ + +void +initialize_file_variables (file, reading) + struct file *file; + int reading; +{ + register struct variable_set_list *l = file->variables; + + if (l == 0) + { + l = (struct variable_set_list *) + xmalloc (sizeof (struct variable_set_list)); + l->set = (struct variable_set *) xmalloc (sizeof (struct variable_set)); + hash_init (&l->set->table, PERFILE_VARIABLE_BUCKETS, + variable_hash_1, variable_hash_2, variable_hash_cmp); + file->variables = l; + } + + /* If this is a double-colon, then our "parent" is the "root" target for + this double-colon rule. Since that rule has the same name, parent, + etc. we can just use its variables as the "next" for ours. */ + + if (file->double_colon && file->double_colon != file) + { + initialize_file_variables (file->double_colon, reading); + l->next = file->double_colon->variables; + return; + } + + if (file->parent == 0) + l->next = &global_setlist; + else + { + initialize_file_variables (file->parent, reading); + l->next = file->parent->variables; + } + + /* If we're not reading makefiles and we haven't looked yet, see if + we can find a pattern variable. */ + + if (!reading && !file->pat_searched) + { + struct pattern_var *p = lookup_pattern_var (file->name); + + file->pat_searched = 1; + if (p != 0) + { + /* If we found one, insert it between the current target's + variables and the next set, whatever it is. */ + file->pat_variables = (struct variable_set_list *) + xmalloc (sizeof (struct variable_set_list)); + file->pat_variables->set = p->vars->set; + } + } + + /* If we have a pattern variable match, set it up. */ + + if (file->pat_variables != 0) + { + file->pat_variables->next = l->next; + l->next = file->pat_variables; + } +} + +/* Pop the top set off the current variable set list, + and free all its storage. */ + +static void +free_variable_name_and_value (item) + void *item; +{ + struct variable *v = (struct variable *) item; + free (v->name); + free (v->value); +} + +void +pop_variable_scope () +{ + struct variable_set_list *setlist = current_variable_set_list; + struct variable_set *set = setlist->set; + + current_variable_set_list = setlist->next; + free ((char *) setlist); + + hash_map (&set->table, free_variable_name_and_value); + hash_free (&set->table, 1); + + free ((char *) set); +} + +struct variable_set_list * +create_new_variable_set () +{ + register struct variable_set_list *setlist; + register struct variable_set *set; + + set = (struct variable_set *) xmalloc (sizeof (struct variable_set)); + hash_init (&set->table, SMALL_SCOPE_VARIABLE_BUCKETS, + variable_hash_1, variable_hash_2, variable_hash_cmp); + + setlist = (struct variable_set_list *) + xmalloc (sizeof (struct variable_set_list)); + setlist->set = set; + setlist->next = current_variable_set_list; + + return setlist; +} + +/* Create a new variable set and push it on the current setlist. */ + +struct variable_set_list * +push_new_variable_scope () +{ + return (current_variable_set_list = create_new_variable_set()); +} + +/* Merge SET1 into SET0, freeing unused storage in SET1. */ + +static void +merge_variable_sets (to_set, from_set) + struct variable_set *to_set, *from_set; +{ + struct variable **from_var_slot = (struct variable **) from_set->table.ht_vec; + struct variable **from_var_end = from_var_slot + from_set->table.ht_size; + + for ( ; from_var_slot < from_var_end; from_var_slot++) + if (! HASH_VACANT (*from_var_slot)) + { + struct variable *from_var = *from_var_slot; + struct variable **to_var_slot + = (struct variable **) hash_find_slot (&to_set->table, *from_var_slot); + if (HASH_VACANT (*to_var_slot)) + hash_insert_at (&to_set->table, from_var, to_var_slot); + else + { + /* GKM FIXME: delete in from_set->table */ + free (from_var->value); + free (from_var); + } + } +} + +/* Merge SETLIST1 into SETLIST0, freeing unused storage in SETLIST1. */ + +void +merge_variable_set_lists (setlist0, setlist1) + struct variable_set_list **setlist0, *setlist1; +{ + register struct variable_set_list *list0 = *setlist0; + struct variable_set_list *last0 = 0; + + while (setlist1 != 0 && list0 != 0) + { + struct variable_set_list *next = setlist1; + setlist1 = setlist1->next; + + merge_variable_sets (list0->set, next->set); + + last0 = list0; + list0 = list0->next; + } + + if (setlist1 != 0) + { + if (last0 == 0) + *setlist0 = setlist1; + else + last0->next = setlist1; + } +} + +/* Define the automatic variables, and record the addresses + of their structures so we can change their values quickly. */ + +void +define_automatic_variables () +{ +#ifdef WINDOWS32 + extern char* default_shell; +#else + extern char default_shell[]; +#endif + register struct variable *v; + char buf[200]; + + sprintf (buf, "%u", makelevel); + (void) define_variable (MAKELEVEL_NAME, MAKELEVEL_LENGTH, buf, o_env, 0); + + sprintf (buf, "%s%s%s", + version_string, + (remote_description == 0 || remote_description[0] == '\0') + ? "" : "-", + (remote_description == 0 || remote_description[0] == '\0') + ? "" : remote_description); + (void) define_variable ("MAKE_VERSION", 12, buf, o_default, 0); + +#ifdef __MSDOS__ + /* Allow to specify a special shell just for Make, + and use $COMSPEC as the default $SHELL when appropriate. */ + { + static char shell_str[] = "SHELL"; + const int shlen = sizeof (shell_str) - 1; + struct variable *mshp = lookup_variable ("MAKESHELL", 9); + struct variable *comp = lookup_variable ("COMSPEC", 7); + + /* Make $MAKESHELL override $SHELL even if -e is in effect. */ + if (mshp) + (void) define_variable (shell_str, shlen, + mshp->value, o_env_override, 0); + else if (comp) + { + /* $COMSPEC shouldn't override $SHELL. */ + struct variable *shp = lookup_variable (shell_str, shlen); + + if (!shp) + (void) define_variable (shell_str, shlen, comp->value, o_env, 0); + } + } +#endif + + /* This won't override any definition, but it + will provide one if there isn't one there. */ + v = define_variable ("SHELL", 5, default_shell, o_default, 0); + v->export = v_export; /* Always export SHELL. */ + + /* On MSDOS we do use SHELL from environment, since + it isn't a standard environment variable on MSDOS, + so whoever sets it, does that on purpose. */ +#ifndef __MSDOS__ + /* Don't let SHELL come from the environment. */ + if (*v->value == '\0' || v->origin == o_env || v->origin == o_env_override) + { + free (v->value); + v->origin = o_file; + v->value = xstrdup (default_shell); + } +#endif + + /* Make sure MAKEFILES gets exported if it is set. */ + v = define_variable ("MAKEFILES", 9, "", o_default, 0); + v->export = v_ifset; + + /* Define the magic D and F variables in terms of + the automatic variables they are variations of. */ + +#ifdef VMS + define_variable ("@D", 2, "$(dir $@)", o_automatic, 1); + define_variable ("%D", 2, "$(dir $%)", o_automatic, 1); + define_variable ("*D", 2, "$(dir $*)", o_automatic, 1); + define_variable ("variables; + + hash_init (&table, VARIABLE_BUCKETS, + variable_hash_1, variable_hash_2, variable_hash_cmp); + + /* Run through all the variable sets in the list, + accumulating variables in TABLE. */ + for (s = set_list; s != 0; s = s->next) + { + struct variable_set *set = s->set; + v_slot = (struct variable **) set->table.ht_vec; + v_end = v_slot + set->table.ht_size; + for ( ; v_slot < v_end; v_slot++) + if (! HASH_VACANT (*v_slot)) + { + struct variable **new_slot; + struct variable *v = *v_slot; + + /* If this is a per-target variable and it hasn't been touched + already then look up the global version and take its export + value. */ + if (v->per_target && v->export == v_default) + { + struct variable *gv; + + gv = lookup_variable_in_set (v->name, strlen(v->name), + &global_variable_set); + if (gv) + v->export = gv->export; + } + + switch (v->export) + { + case v_default: + if (v->origin == o_default || v->origin == o_automatic) + /* Only export default variables by explicit request. */ + continue; + + /* The variable doesn't have a name that can be exported. */ + if (! v->exportable) + continue; + + if (! export_all_variables + && v->origin != o_command + && v->origin != o_env && v->origin != o_env_override) + continue; + break; + + case v_export: + break; + + case v_noexport: + continue; + + case v_ifset: + if (v->origin == o_default) + continue; + break; + } + + new_slot = (struct variable **) hash_find_slot (&table, v); + if (HASH_VACANT (*new_slot)) + hash_insert_at (&table, v, new_slot); + } + } + + makelevel_key.name = MAKELEVEL_NAME; + makelevel_key.length = MAKELEVEL_LENGTH; + hash_delete (&table, &makelevel_key); + + result = result_0 = (char **) xmalloc ((table.ht_fill + 2) * sizeof (char *)); + + v_slot = (struct variable **) table.ht_vec; + v_end = v_slot + table.ht_size; + for ( ; v_slot < v_end; v_slot++) + if (! HASH_VACANT (*v_slot)) + { + struct variable *v = *v_slot; + + /* If V is recursively expanded and didn't come from the environment, + expand its value. If it came from the environment, it should + go back into the environment unchanged. */ + if (v->recursive + && v->origin != o_env && v->origin != o_env_override) + { + char *value = recursively_expand_for_file (v, file); +#ifdef WINDOWS32 + if (strcmp(v->name, "Path") == 0 || + strcmp(v->name, "PATH") == 0) + convert_Path_to_windows32(value, ';'); +#endif + *result++ = concat (v->name, "=", value); + free (value); + } + else + { +#ifdef WINDOWS32 + if (strcmp(v->name, "Path") == 0 || + strcmp(v->name, "PATH") == 0) + convert_Path_to_windows32(v->value, ';'); +#endif + *result++ = concat (v->name, "=", v->value); + } + } + + *result = (char *) xmalloc (100); + (void) sprintf (*result, "%s=%u", MAKELEVEL_NAME, makelevel + 1); + *++result = 0; + + hash_free (&table, 0); + + return result_0; +} + +/* Given a variable, a value, and a flavor, define the variable. + See the try_variable_definition() function for details on the parameters. */ + +struct variable * +do_variable_definition (flocp, varname, value, origin, flavor, target_var) + const struct floc *flocp; + const char *varname; + char *value; + enum variable_origin origin; + enum variable_flavor flavor; + int target_var; +{ + char *p, *alloc_value = NULL; + struct variable *v; + int append = 0; + + /* Calculate the variable's new value in VALUE. */ + + switch (flavor) + { + default: + case f_bogus: + /* Should not be possible. */ + abort (); + case f_simple: + /* A simple variable definition "var := value". Expand the value. + We have to allocate memory since otherwise it'll clobber the + variable buffer, and we may still need that if we're looking at a + target-specific variable. */ + p = alloc_value = allocated_variable_expand (value); + break; + case f_conditional: + /* A conditional variable definition "var ?= value". + The value is set IFF the variable is not defined yet. */ + v = lookup_variable (varname, strlen (varname)); + if (v) + return v; + + flavor = f_recursive; + /* FALLTHROUGH */ + case f_recursive: + /* A recursive variable definition "var = value". + The value is used verbatim. */ + p = value; + break; + case f_append: + { + /* If we have += but we're in a target variable context, we want to + append only with other variables in the context of this target. */ + if (target_var) + { + append = 1; + v = lookup_variable_in_set (varname, strlen (varname), + current_variable_set_list->set); + } + else + v = lookup_variable (varname, strlen (varname)); + + if (v == 0) + { + /* There was no old value. + This becomes a normal recursive definition. */ + p = value; + flavor = f_recursive; + } + else + { + /* Paste the old and new values together in VALUE. */ + + unsigned int oldlen, vallen; + char *val; + + val = value; + if (v->recursive) + /* The previous definition of the variable was recursive. + The new value is the unexpanded old and new values. */ + flavor = f_recursive; + else + /* The previous definition of the variable was simple. + The new value comes from the old value, which was expanded + when it was set; and from the expanded new value. Allocate + memory for the expansion as we may still need the rest of the + buffer if we're looking at a target-specific variable. */ + val = alloc_value = allocated_variable_expand (val); + + oldlen = strlen (v->value); + vallen = strlen (val); + p = (char *) alloca (oldlen + 1 + vallen + 1); + bcopy (v->value, p, oldlen); + p[oldlen] = ' '; + bcopy (val, &p[oldlen + 1], vallen + 1); + } + } + } + +#ifdef __MSDOS__ + /* Many Unix Makefiles include a line saying "SHELL=/bin/sh", but + non-Unix systems don't conform to this default configuration (in + fact, most of them don't even have `/bin'). On the other hand, + $SHELL in the environment, if set, points to the real pathname of + the shell. + Therefore, we generally won't let lines like "SHELL=/bin/sh" from + the Makefile override $SHELL from the environment. But first, we + look for the basename of the shell in the directory where SHELL= + points, and along the $PATH; if it is found in any of these places, + we define $SHELL to be the actual pathname of the shell. Thus, if + you have bash.exe installed as d:/unix/bash.exe, and d:/unix is on + your $PATH, then SHELL=/usr/local/bin/bash will have the effect of + defining SHELL to be "d:/unix/bash.exe". */ + if ((origin == o_file || origin == o_override) + && strcmp (varname, "SHELL") == 0) + { + char shellpath[PATH_MAX]; + extern char * __dosexec_find_on_path (const char *, char *[], char *); + + /* See if we can find "/bin/sh.exe", "/bin/sh.com", etc. */ + if (__dosexec_find_on_path (p, (char **)0, shellpath)) + { + char *p; + + for (p = shellpath; *p; p++) + { + if (*p == '\\') + *p = '/'; + } + v = define_variable_loc (varname, strlen (varname), + shellpath, origin, flavor == f_recursive, + flocp); + } + else + { + char *shellbase, *bslash; + struct variable *pathv = lookup_variable ("PATH", 4); + char *path_string; + char *fake_env[2]; + size_t pathlen = 0; + + shellbase = strrchr (p, '/'); + bslash = strrchr (p, '\\'); + if (!shellbase || bslash > shellbase) + shellbase = bslash; + if (!shellbase && p[1] == ':') + shellbase = p + 1; + if (shellbase) + shellbase++; + else + shellbase = p; + + /* Search for the basename of the shell (with standard + executable extensions) along the $PATH. */ + if (pathv) + pathlen = strlen (pathv->value); + path_string = (char *)xmalloc (5 + pathlen + 2 + 1); + /* On MSDOS, current directory is considered as part of $PATH. */ + sprintf (path_string, "PATH=.;%s", pathv ? pathv->value : ""); + fake_env[0] = path_string; + fake_env[1] = (char *)0; + if (__dosexec_find_on_path (shellbase, fake_env, shellpath)) + { + char *p; + + for (p = shellpath; *p; p++) + { + if (*p == '\\') + *p = '/'; + } + v = define_variable_loc (varname, strlen (varname), + shellpath, origin, + flavor == f_recursive, flocp); + } + else + v = lookup_variable (varname, strlen (varname)); + + free (path_string); + } + } + else +#endif /* __MSDOS__ */ +#ifdef WINDOWS32 + if ((origin == o_file || origin == o_override) && streq (varname, "SHELL")) + { + extern char *default_shell; + + /* Call shell locator function. If it returns TRUE, then + set no_default_sh_exe to indicate sh was found and + set new value for SHELL variable. */ + + if (find_and_set_default_shell (p)) + { + v = define_variable_in_set (varname, strlen (varname), default_shell, + origin, flavor == f_recursive, + (target_var + ? current_variable_set_list->set + : NULL), + flocp); + no_default_sh_exe = 0; + } + else + v = lookup_variable (varname, strlen (varname)); + } + else +#endif + + /* If we are defining variables inside an $(eval ...), we might have a + different variable context pushed, not the global context (maybe we're + inside a $(call ...) or something. Since this function is only ever + invoked in places where we want to define globally visible variables, + make sure we define this variable in the global set. */ + + v = define_variable_in_set (varname, strlen (varname), p, + origin, flavor == f_recursive, + (target_var + ? current_variable_set_list->set : NULL), + flocp); + v->append = append; + + if (alloc_value) + free (alloc_value); + + return v; +} + +/* Try to interpret LINE (a null-terminated string) as a variable definition. + + ORIGIN may be o_file, o_override, o_env, o_env_override, + or o_command specifying that the variable definition comes + from a makefile, an override directive, the environment with + or without the -e switch, or the command line. + + See the comments for parse_variable_definition(). + + If LINE was recognized as a variable definition, a pointer to its `struct + variable' is returned. If LINE is not a variable definition, NULL is + returned. */ + +struct variable * +try_variable_definition (flocp, line, origin, target_var) + const struct floc *flocp; + char *line; + enum variable_origin origin; + int target_var; +{ + register int c; + register char *p = line; + register char *beg; + register char *end; + enum variable_flavor flavor = f_bogus; + char *name, *expanded_name; + struct variable *v; + + while (1) + { + c = *p++; + if (c == '\0' || c == '#') + return 0; + if (c == '=') + { + end = p - 1; + flavor = f_recursive; + break; + } + else if (c == ':') + if (*p == '=') + { + end = p++ - 1; + flavor = f_simple; + break; + } + else + /* A colon other than := is a rule line, not a variable defn. */ + return 0; + else if (c == '+' && *p == '=') + { + end = p++ - 1; + flavor = f_append; + break; + } + else if (c == '?' && *p == '=') + { + end = p++ - 1; + flavor = f_conditional; + break; + } + else if (c == '$') + { + /* This might begin a variable expansion reference. Make sure we + don't misrecognize chars inside the reference as =, := or +=. */ + char closeparen; + int count; + c = *p++; + if (c == '(') + closeparen = ')'; + else if (c == '{') + closeparen = '}'; + else + continue; /* Nope. */ + + /* P now points past the opening paren or brace. + Count parens or braces until it is matched. */ + count = 0; + for (; *p != '\0'; ++p) + { + if (*p == c) + ++count; + else if (*p == closeparen && --count < 0) + { + ++p; + break; + } + } + } + } + + beg = next_token (line); + while (end > beg && isblank ((unsigned char)end[-1])) + --end; + p = next_token (p); + + /* Expand the name, so "$(foo)bar = baz" works. */ + name = (char *) alloca (end - beg + 1); + bcopy (beg, name, end - beg); + name[end - beg] = '\0'; + expanded_name = allocated_variable_expand (name); + + if (expanded_name[0] == '\0') + fatal (flocp, _("empty variable name")); + + v = do_variable_definition (flocp, expanded_name, p, + origin, flavor, target_var); + + free (expanded_name); + + return v; +} + +/* Print information for variable V, prefixing it with PREFIX. */ + +static void +print_variable (v, prefix) + register struct variable *v; + char *prefix; +{ + const char *origin; + + switch (v->origin) + { + case o_default: + origin = _("default"); + break; + case o_env: + origin = _("environment"); + break; + case o_file: + origin = _("makefile"); + break; + case o_env_override: + origin = _("environment under -e"); + break; + case o_command: + origin = _("command line"); + break; + case o_override: + origin = _("`override' directive"); + break; + case o_automatic: + origin = _("automatic"); + break; + case o_invalid: + default: + abort (); + } + fputs ("# ", stdout); + fputs (origin, stdout); + if (v->fileinfo.filenm) + printf (_(" (from `%s', line %lu)"), + v->fileinfo.filenm, v->fileinfo.lineno); + putchar ('\n'); + fputs (prefix, stdout); + + /* Is this a `define'? */ + if (v->recursive && strchr (v->value, '\n') != 0) + printf ("define %s\n%s\nendef\n", v->name, v->value); + else + { + register char *p; + + printf ("%s %s= ", v->name, v->recursive ? v->append ? "+" : "" : ":"); + + /* Check if the value is just whitespace. */ + p = next_token (v->value); + if (p != v->value && *p == '\0') + /* All whitespace. */ + printf ("$(subst ,,%s)", v->value); + else if (v->recursive) + fputs (v->value, stdout); + else + /* Double up dollar signs. */ + for (p = v->value; *p != '\0'; ++p) + { + if (*p == '$') + putchar ('$'); + putchar (*p); + } + putchar ('\n'); + } +} + + +/* Print all the variables in SET. PREFIX is printed before + the actual variable definitions (everything else is comments). */ + +void +print_variable_set (set, prefix) + register struct variable_set *set; + char *prefix; +{ + hash_map_arg (&set->table, print_variable, prefix); + + fputs (_("# variable set hash-table stats:\n"), stdout); + fputs ("# ", stdout); + hash_print_stats (&set->table, stdout); + putc ('\n', stdout); +} + +/* Print the data base of variables. */ + +void +print_variable_data_base () +{ + puts (_("\n# Variables\n")); + + print_variable_set (&global_variable_set, ""); +} + + +/* Print all the local variables of FILE. */ + +void +print_file_variables (file) + struct file *file; +{ + if (file->variables != 0) + print_variable_set (file->variables->set, "# "); +} + +#ifdef WINDOWS32 +void +sync_Path_environment(void) +{ + char* path = allocated_variable_expand("$(Path)"); + static char* environ_path = NULL; + + if (!path) + return; + + /* + * If done this before, don't leak memory unnecessarily. + * Free the previous entry before allocating new one. + */ + if (environ_path) + free(environ_path); + + /* + * Create something WINDOWS32 world can grok + */ + convert_Path_to_windows32(path, ';'); + environ_path = concat("Path", "=", path); + putenv(environ_path); + free(path); +} +#endif diff --git a/flaim/external/w32/make/variable.h b/flaim/external/w32/make/variable.h new file mode 100644 index 0000000..d9cd7f7 --- /dev/null +++ b/flaim/external/w32/make/variable.h @@ -0,0 +1,183 @@ +/* Definitions for using variables in GNU Make. +Copyright (C) 1988, 1989, 1990, 1991, 1992, 2002 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "hash.h" + +/* Codes in a variable definition saying where the definition came from. + Increasing numeric values signify less-overridable definitions. */ +enum variable_origin + { + o_default, /* Variable from the default set. */ + o_env, /* Variable from environment. */ + o_file, /* Variable given in a makefile. */ + o_env_override, /* Variable from environment, if -e. */ + o_command, /* Variable given by user. */ + o_override, /* Variable from an `override' directive. */ + o_automatic, /* Automatic variable -- cannot be set. */ + o_invalid /* Core dump time. */ + }; + +enum variable_flavor + { + f_bogus, /* Bogus (error) */ + f_simple, /* Simple definition (:=) */ + f_recursive, /* Recursive definition (=) */ + f_append, /* Appending definition (+=) */ + f_conditional /* Conditional definition (?=) */ + }; + +/* Structure that represents one variable definition. + Each bucket of the hash table is a chain of these, + chained through `next'. */ + +#define EXP_COUNT_BITS 15 /* This gets all the bitfields into 32 bits */ + +#define EXP_COUNT_MAX ((1<1, allow this many self-referential + expansions. */ + + enum variable_origin + origin ENUM_BITFIELD (3); /* Variable origin. */ + + unsigned int exportable:1; /* Nonzero if the variable _could_ be + exported. */ + enum variable_export + { + v_export, /* Export this variable. */ + v_noexport, /* Don't export this variable. */ + v_ifset, /* Export it if it has a non-default value. */ + v_default /* Decide in target_environment. */ + } export ENUM_BITFIELD (2); + }; + +/* Structure that represents a variable set. */ + +struct variable_set + { + struct hash_table table; /* Hash table of variables. */ + }; + +/* Structure that represents a list of variable sets. */ + +struct variable_set_list + { + struct variable_set_list *next; /* Link in the chain. */ + struct variable_set *set; /* Variable set. */ + }; + +extern char *variable_buffer; +extern struct variable_set_list *current_variable_set_list; + +/* expand.c */ +extern char *variable_buffer_output PARAMS ((char *ptr, char *string, unsigned int length)); +extern char *variable_expand PARAMS ((char *line)); +extern char *allocated_variable_expand_for_file PARAMS ((char *line, struct file *file)); +#define allocated_variable_expand(line) \ + allocated_variable_expand_for_file (line, (struct file *) 0) +extern char *expand_argument PARAMS ((char *str, char *end)); +extern char *variable_expand_string PARAMS ((char *line, char *string, + long length)); + +/* function.c */ +extern int handle_function PARAMS ((char **op, char **stringp)); +extern int pattern_matches PARAMS ((char *pattern, char *percent, char *str)); +extern char *subst_expand PARAMS ((char *o, char *text, char *subst, char *replace, + unsigned int slen, unsigned int rlen, int by_word, int suffix_only)); +extern char *patsubst_expand PARAMS ((char *o, char *text, char *pattern, char *replace, + char *pattern_percent, char *replace_percent)); + +/* expand.c */ +extern char *recursively_expand_for_file PARAMS ((struct variable *v, + struct file *file)); +#define recursively_expand(v) recursively_expand_for_file (v, NULL) + +/* variable.c */ +extern struct variable_set_list *create_new_variable_set PARAMS ((void)); +extern struct variable_set_list *push_new_variable_scope PARAMS ((void)); +extern void pop_variable_scope PARAMS ((void)); +extern void define_automatic_variables PARAMS ((void)); +extern void initialize_file_variables PARAMS ((struct file *file, int read)); +extern void print_file_variables PARAMS ((struct file *file)); +extern void print_variable_set PARAMS ((struct variable_set *set, char *prefix)); +extern void merge_variable_set_lists PARAMS ((struct variable_set_list **setlist0, struct variable_set_list *setlist1)); +extern struct variable *do_variable_definition PARAMS ((const struct floc *flocp, const char *name, char *value, enum variable_origin origin, enum variable_flavor flavor, int target_var)); +extern struct variable *try_variable_definition PARAMS ((const struct floc *flocp, char *line, enum variable_origin origin, int target_var)); +extern void init_hash_global_variable_set PARAMS ((void)); +extern void hash_init_function_table PARAMS ((void)); +extern struct variable *lookup_variable PARAMS ((const char *name, unsigned int length)); +extern struct variable *lookup_variable_in_set PARAMS ((const char *name, + unsigned int length, + const struct variable_set *set)); + +extern struct variable *define_variable_in_set + PARAMS ((const char *name, unsigned int length, char *value, + enum variable_origin origin, int recursive, + struct variable_set *set, const struct floc *flocp)); + +/* Define a variable in the current variable set. */ + +#define define_variable(n,l,v,o,r) \ + define_variable_in_set((n),(l),(v),(o),(r),\ + current_variable_set_list->set,NILF) + +/* Define a variable with a location in the current variable set. */ + +#define define_variable_loc(n,l,v,o,r,f) \ + define_variable_in_set((n),(l),(v),(o),(r),\ + current_variable_set_list->set,(f)) + +/* Define a variable with a location in the global variable set. */ + +#define define_variable_global(n,l,v,o,r,f) \ + define_variable_in_set((n),(l),(v),(o),(r),NULL,(f)) + +/* Define a variable in FILE's variable set. */ + +#define define_variable_for_file(n,l,v,o,r,f) \ + define_variable_in_set((n),(l),(v),(o),(r),(f)->variables->set,NILF) + +/* Warn that NAME is an undefined variable. */ + +#define warn_undefined(n,l) do{\ + if (warn_undefined_variables_flag) \ + error (reading_file, \ + _("warning: undefined variable `%.*s'"), \ + (int)(l), (n)); \ + }while(0) + +extern char **target_environment PARAMS ((struct file *file)); + +extern int export_all_variables; + +#define MAKELEVEL_NAME "MAKELEVEL" +#define MAKELEVEL_LENGTH (sizeof (MAKELEVEL_NAME) - 1) diff --git a/flaim/external/w32/make/version.c b/flaim/external/w32/make/version.c new file mode 100644 index 0000000..1918b6f --- /dev/null +++ b/flaim/external/w32/make/version.c @@ -0,0 +1,17 @@ +/* We use instead of "config.h" so that a compilation + using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h + (which it would do because make.h was found in $srcdir). */ +#include + +#ifndef MAKE_HOST +# define MAKE_HOST "unknown" +#endif + +char *version_string = VERSION; +char *make_host = MAKE_HOST; + +/* + Local variables: + version-control: never + End: + */ diff --git a/flaim/external/w32/make/vpath.c b/flaim/external/w32/make/vpath.c new file mode 100644 index 0000000..065779b --- /dev/null +++ b/flaim/external/w32/make/vpath.c @@ -0,0 +1,587 @@ +/* Implementation of pattern-matching file search paths for GNU Make. +Copyright (C) 1988,89,91,92,93,94,95,96,97 Free Software Foundation, Inc. +This file is part of GNU Make. + +GNU Make is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Make 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 General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Make; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +#include "make.h" +#include "filedef.h" +#include "variable.h" +#ifdef WINDOWS32 +#include "pathstuff.h" +#endif + + +/* Structure used to represent a selective VPATH searchpath. */ + +struct vpath + { + struct vpath *next; /* Pointer to next struct in the linked list. */ + char *pattern; /* The pattern to match. */ + char *percent; /* Pointer into `pattern' where the `%' is. */ + unsigned int patlen;/* Length of the pattern. */ + char **searchpath; /* Null-terminated list of directories. */ + unsigned int maxlen;/* Maximum length of any entry in the list. */ + }; + +/* Linked-list of all selective VPATHs. */ + +static struct vpath *vpaths; + +/* Structure for the general VPATH given in the variable. */ + +static struct vpath *general_vpath; + +/* Structure for GPATH given in the variable. */ + +static struct vpath *gpaths; + +static int selective_vpath_search PARAMS ((struct vpath *path, char **file, FILE_TIMESTAMP *mtime_ptr)); + +/* Reverse the chain of selective VPATH lists so they + will be searched in the order given in the makefiles + and construct the list from the VPATH variable. */ + +void +build_vpath_lists () +{ + register struct vpath *new = 0; + register struct vpath *old, *nexto; + register char *p; + + /* Reverse the chain. */ + for (old = vpaths; old != 0; old = nexto) + { + nexto = old->next; + old->next = new; + new = old; + } + + vpaths = new; + + /* If there is a VPATH variable with a nonnull value, construct the + general VPATH list from it. We use variable_expand rather than just + calling lookup_variable so that it will be recursively expanded. */ + + { + /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */ + int save = warn_undefined_variables_flag; + warn_undefined_variables_flag = 0; + + p = variable_expand ("$(strip $(VPATH))"); + + warn_undefined_variables_flag = save; + } + + if (*p != '\0') + { + /* Save the list of vpaths. */ + struct vpath *save_vpaths = vpaths; + + /* Empty `vpaths' so the new one will have no next, and `vpaths' + will still be nil if P contains no existing directories. */ + vpaths = 0; + + /* Parse P. */ + construct_vpath_list ("%", p); + + /* Store the created path as the general path, + and restore the old list of vpaths. */ + general_vpath = vpaths; + vpaths = save_vpaths; + } + + /* If there is a GPATH variable with a nonnull value, construct the + GPATH list from it. We use variable_expand rather than just + calling lookup_variable so that it will be recursively expanded. */ + + { + /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */ + int save = warn_undefined_variables_flag; + warn_undefined_variables_flag = 0; + + p = variable_expand ("$(strip $(GPATH))"); + + warn_undefined_variables_flag = save; + } + + if (*p != '\0') + { + /* Save the list of vpaths. */ + struct vpath *save_vpaths = vpaths; + + /* Empty `vpaths' so the new one will have no next, and `vpaths' + will still be nil if P contains no existing directories. */ + vpaths = 0; + + /* Parse P. */ + construct_vpath_list ("%", p); + + /* Store the created path as the GPATH, + and restore the old list of vpaths. */ + gpaths = vpaths; + vpaths = save_vpaths; + } +} + +/* Construct the VPATH listing for the pattern and searchpath given. + + This function is called to generate selective VPATH lists and also for + the general VPATH list (which is in fact just a selective VPATH that + is applied to everything). The returned pointer is either put in the + linked list of all selective VPATH lists or in the GENERAL_VPATH + variable. + + If SEARCHPATH is nil, remove all previous listings with the same + pattern. If PATTERN is nil, remove all VPATH listings. Existing + and readable directories that are not "." given in the searchpath + separated by the path element separator (defined in make.h) are + loaded into the directory hash table if they are not there already + and put in the VPATH searchpath for the given pattern with trailing + slashes stripped off if present (and if the directory is not the + root, "/"). The length of the longest entry in the list is put in + the structure as well. The new entry will be at the head of the + VPATHS chain. */ + +void +construct_vpath_list (pattern, dirpath) + char *pattern, *dirpath; +{ + register unsigned int elem; + register char *p; + register char **vpath; + register unsigned int maxvpath; + unsigned int maxelem; + char *percent = NULL; + + if (pattern != 0) + { + pattern = xstrdup (pattern); + percent = find_percent (pattern); + } + + if (dirpath == 0) + { + /* Remove matching listings. */ + register struct vpath *path, *lastpath; + + lastpath = 0; + path = vpaths; + while (path != 0) + { + struct vpath *next = path->next; + + if (pattern == 0 + || (((percent == 0 && path->percent == 0) + || (percent - pattern == path->percent - path->pattern)) + && streq (pattern, path->pattern))) + { + /* Remove it from the linked list. */ + if (lastpath == 0) + vpaths = path->next; + else + lastpath->next = next; + + /* Free its unused storage. */ + free (path->pattern); + free ((char *) path->searchpath); + free ((char *) path); + } + else + lastpath = path; + + path = next; + } + + if (pattern != 0) + free (pattern); + return; + } + +#ifdef WINDOWS32 + convert_vpath_to_windows32(dirpath, ';'); +#endif + + /* Figure out the maximum number of VPATH entries and put it in + MAXELEM. We start with 2, one before the first separator and one + nil (the list terminator) and increment our estimated number for + each separator or blank we find. */ + maxelem = 2; + p = dirpath; + while (*p != '\0') + if (*p++ == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*p)) + ++maxelem; + + vpath = (char **) xmalloc (maxelem * sizeof (char *)); + maxvpath = 0; + + /* Skip over any initial separators and blanks. */ + p = dirpath; + while (*p == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*p)) + ++p; + + elem = 0; + while (*p != '\0') + { + char *v; + unsigned int len; + + /* Find the end of this entry. */ + v = p; + while (*p != '\0' && *p != PATH_SEPARATOR_CHAR + && !isblank ((unsigned char)*p)) + ++p; + + len = p - v; + /* Make sure there's no trailing slash, + but still allow "/" as a directory. */ +#ifdef __MSDOS__ + /* We need also to leave alone a trailing slash in "d:/". */ + if (len > 3 || (len > 1 && v[1] != ':')) +#endif + if (len > 1 && p[-1] == '/') + --len; + + if (len > 1 || *v != '.') + { + v = savestring (v, len); + + /* Verify that the directory actually exists. */ + + if (dir_file_exists_p (v, "")) + { + /* It does. Put it in the list. */ + vpath[elem++] = dir_name (v); + free (v); + if (len > maxvpath) + maxvpath = len; + } + else + /* The directory does not exist. Omit from the list. */ + free (v); + } + + /* Skip over separators and blanks between entries. */ + while (*p == PATH_SEPARATOR_CHAR || isblank ((unsigned char)*p)) + ++p; + } + + if (elem > 0) + { + struct vpath *path; + /* ELEM is now incremented one element past the last + entry, to where the nil-pointer terminator goes. + Usually this is maxelem - 1. If not, shrink down. */ + if (elem < (maxelem - 1)) + vpath = (char **) xrealloc ((char *) vpath, + (elem + 1) * sizeof (char *)); + + /* Put the nil-pointer terminator on the end of the VPATH list. */ + vpath[elem] = 0; + + /* Construct the vpath structure and put it into the linked list. */ + path = (struct vpath *) xmalloc (sizeof (struct vpath)); + path->searchpath = vpath; + path->maxlen = maxvpath; + path->next = vpaths; + vpaths = path; + + /* Set up the members. */ + path->pattern = pattern; + path->percent = percent; + path->patlen = strlen (pattern); + } + else + { + /* There were no entries, so free whatever space we allocated. */ + free ((char *) vpath); + if (pattern != 0) + free (pattern); + } +} + +/* Search the GPATH list for a pathname string that matches the one passed + in. If it is found, return 1. Otherwise we return 0. */ + +int +gpath_search (file, len) + char *file; + int len; +{ + register char **gp; + + if (gpaths && (len <= gpaths->maxlen)) + for (gp = gpaths->searchpath; *gp != NULL; ++gp) + if (strneq (*gp, file, len) && (*gp)[len] == '\0') + return 1; + + return 0; +} + +/* Search the VPATH list whose pattern matches *FILE for a directory + where the name pointed to by FILE exists. If it is found, we set *FILE to + the newly malloc'd name of the existing file, *MTIME_PTR (if MTIME_PTR is + not NULL) to its modtime (or zero if no stat call was done), and return 1. + Otherwise we return 0. */ + +int +vpath_search (file, mtime_ptr) + char **file; + FILE_TIMESTAMP *mtime_ptr; +{ + register struct vpath *v; + + /* If there are no VPATH entries or FILENAME starts at the root, + there is nothing we can do. */ + + if (**file == '/' +#ifdef HAVE_DOS_PATHS + || **file == '\\' + || (*file)[1] == ':' +#endif + || (vpaths == 0 && general_vpath == 0)) + return 0; + + for (v = vpaths; v != 0; v = v->next) + if (pattern_matches (v->pattern, v->percent, *file)) + if (selective_vpath_search (v, file, mtime_ptr)) + return 1; + + if (general_vpath != 0 + && selective_vpath_search (general_vpath, file, mtime_ptr)) + return 1; + + return 0; +} + + +/* Search the given VPATH list for a directory where the name pointed + to by FILE exists. If it is found, we set *FILE to the newly malloc'd + name of the existing file, *MTIME_PTR (if MTIME_PTR is not NULL) to + its modtime (or zero if no stat call was done), and we return 1. + Otherwise we return 0. */ + +static int +selective_vpath_search (path, file, mtime_ptr) + struct vpath *path; + char **file; + FILE_TIMESTAMP *mtime_ptr; +{ + int not_target; + char *name, *n; + char *filename; + register char **vpath = path->searchpath; + unsigned int maxvpath = path->maxlen; + register unsigned int i; + unsigned int flen, vlen, name_dplen; + int exists = 0; + + /* Find out if *FILE is a target. + If and only if it is NOT a target, we will accept prospective + files that don't exist but are mentioned in a makefile. */ + { + struct file *f = lookup_file (*file); + not_target = f == 0 || !f->is_target; + } + + flen = strlen (*file); + + /* Split *FILE into a directory prefix and a name-within-directory. + NAME_DPLEN gets the length of the prefix; FILENAME gets the + pointer to the name-within-directory and FLEN is its length. */ + + n = strrchr (*file, '/'); +#ifdef HAVE_DOS_PATHS + /* We need the rightmost slash or backslash. */ + { + char *bslash = strrchr(*file, '\\'); + if (!n || bslash > n) + n = bslash; + } +#endif + name_dplen = n != 0 ? n - *file : 0; + filename = name_dplen > 0 ? n + 1 : *file; + if (name_dplen > 0) + flen -= name_dplen + 1; + + /* Allocate enough space for the biggest VPATH entry, + a slash, the directory prefix that came with *FILE, + another slash (although this one may not always be + necessary), the filename, and a null terminator. */ + name = (char *) xmalloc (maxvpath + 1 + name_dplen + 1 + flen + 1); + + /* Try each VPATH entry. */ + for (i = 0; vpath[i] != 0; ++i) + { + int exists_in_cache = 0; + + n = name; + + /* Put the next VPATH entry into NAME at N and increment N past it. */ + vlen = strlen (vpath[i]); + bcopy (vpath[i], n, vlen); + n += vlen; + + /* Add the directory prefix already in *FILE. */ + if (name_dplen > 0) + { +#ifndef VMS + *n++ = '/'; +#endif + bcopy (*file, n, name_dplen); + n += name_dplen; + } + +#ifdef HAVE_DOS_PATHS + /* Cause the next if to treat backslash and slash alike. */ + if (n != name && n[-1] == '\\' ) + n[-1] = '/'; +#endif + /* Now add the name-within-directory at the end of NAME. */ +#ifndef VMS + if (n != name && n[-1] != '/') + { + *n = '/'; + bcopy (filename, n + 1, flen + 1); + } + else +#endif + bcopy (filename, n, flen + 1); + + /* Check if the file is mentioned in a makefile. If *FILE is not + a target, that is enough for us to decide this file exists. + If *FILE is a target, then the file must be mentioned in the + makefile also as a target to be chosen. + + The restriction that *FILE must not be a target for a + makefile-mentioned file to be chosen was added by an + inadequately commented change in July 1990; I am not sure off + hand what problem it fixes. + + In December 1993 I loosened this restriction to allow a file + to be chosen if it is mentioned as a target in a makefile. This + seem logical. */ + { + struct file *f = lookup_file (name); + if (f != 0) + exists = not_target || f->is_target; + } + + if (!exists) + { + /* That file wasn't mentioned in the makefile. + See if it actually exists. */ + +#ifdef VMS + exists_in_cache = exists = dir_file_exists_p (vpath[i], filename); +#else + /* Clobber a null into the name at the last slash. + Now NAME is the name of the directory to look in. */ + *n = '\0'; + + /* We know the directory is in the hash table now because either + construct_vpath_list or the code just above put it there. + Does the file we seek exist in it? */ + exists_in_cache = exists = dir_file_exists_p (name, filename); +#endif + } + + if (exists) + { + /* The file is in the directory cache. + Now check that it actually exists in the filesystem. + The cache may be out of date. When vpath thinks a file + exists, but stat fails for it, confusion results in the + higher levels. */ + + struct stat st; + +#ifndef VMS + /* Put the slash back in NAME. */ + *n = '/'; +#endif + + if (!exists_in_cache /* Makefile-mentioned file need not exist. */ + || stat (name, &st) == 0) /* Does it really exist? */ + { + /* We have found a file. + Store the name we found into *FILE for the caller. */ + + *file = savestring (name, (n + 1 - name) + flen); + + if (mtime_ptr != 0) + /* Store the modtime into *MTIME_PTR for the caller. + If we have had no need to stat the file here, + we record UNKNOWN_MTIME to indicate this. */ + *mtime_ptr = (exists_in_cache + ? FILE_TIMESTAMP_STAT_MODTIME (name, st) + : UNKNOWN_MTIME); + + free (name); + return 1; + } + else + exists = 0; + } + } + + free (name); + return 0; +} + +/* Print the data base of VPATH search paths. */ + +void +print_vpath_data_base () +{ + register unsigned int nvpaths; + register struct vpath *v; + + puts (_("\n# VPATH Search Paths\n")); + + nvpaths = 0; + for (v = vpaths; v != 0; v = v->next) + { + register unsigned int i; + + ++nvpaths; + + printf ("vpath %s ", v->pattern); + + for (i = 0; v->searchpath[i] != 0; ++i) + printf ("%s%c", v->searchpath[i], + v->searchpath[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR); + } + + if (vpaths == 0) + puts (_("# No `vpath' search paths.")); + else + printf (_("\n# %u `vpath' search paths.\n"), nvpaths); + + if (general_vpath == 0) + puts (_("\n# No general (`VPATH' variable) search path.")); + else + { + register char **path = general_vpath->searchpath; + register unsigned int i; + + fputs (_("\n# General (`VPATH' variable) search path:\n# "), stdout); + + for (i = 0; path[i] != 0; ++i) + printf ("%s%c", path[i], + path[i + 1] == 0 ? '\n' : PATH_SEPARATOR_CHAR); + } +} diff --git a/flaim/external/w32/make/w32err.c b/flaim/external/w32/make/w32err.c new file mode 100644 index 0000000..6afb81b --- /dev/null +++ b/flaim/external/w32/make/w32err.c @@ -0,0 +1,51 @@ +#include +#include "w32err.h" + +/* + * Description: the windows32 version of perror() + * + * Returns: a pointer to a static error + * + * Notes/Dependencies: I got this from + * comp.os.ms-windows.programmer.win32 + */ +char * +map_windows32_error_to_string (DWORD ercode) { +/* __declspec (thread) necessary if you will use multiple threads */ +__declspec (thread) static char szMessageBuffer[128]; + + /* Fill message buffer with a default message in + * case FormatMessage fails + */ + wsprintf (szMessageBuffer, "Error %ld", ercode); + + /* + * Special code for winsock error handling. + */ + if (ercode > WSABASEERR) { + HMODULE hModule = GetModuleHandle("wsock32"); + if (hModule != NULL) { + FormatMessage(FORMAT_MESSAGE_FROM_HMODULE, + hModule, + ercode, + LANG_NEUTRAL, + szMessageBuffer, + sizeof(szMessageBuffer), + NULL); + FreeLibrary(hModule); + } + } else { + /* + * Default system message handling + */ + FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, + NULL, + ercode, + LANG_NEUTRAL, + szMessageBuffer, + sizeof(szMessageBuffer), + NULL); + } + return szMessageBuffer; +} + diff --git a/flaim/external/w32/make/w32err.h b/flaim/external/w32/make/w32err.h new file mode 100644 index 0000000..263908d --- /dev/null +++ b/flaim/external/w32/make/w32err.h @@ -0,0 +1,10 @@ +#ifndef _W32ERR_H_ +#define _W32ERR_H_ + +#ifndef EXTERN_DECL +#define EXTERN_DECL(entry, args) entry args +#endif + +EXTERN_DECL(char * map_windows32_error_to_string, (DWORD error)); + +#endif /* !_W32ERR_H */ diff --git a/flaim/external/w32/printf/build.bat b/flaim/external/w32/printf/build.bat new file mode 100644 index 0000000..14ec690 --- /dev/null +++ b/flaim/external/w32/printf/build.bat @@ -0,0 +1,33 @@ +@echo off + +REM ------------------------------------------------------------------------- +REM Desc: Batch file for building GNU printf on Windows platforms +REM Tabs: 3 +REM +REM Copyright (c) 2006 Novell, Inc. All Rights Reserved. +REM +REM This program is free software; you can redistribute it and/or +REM modify it under the terms of version 2 of the GNU General Public +REM License as published by the Free Software Foundation. +REM +REM This program is distributed in the hope that it will be useful, +REM but WITHOUT ANY WARRANTY; without even the implied warranty of +REM MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +REM GNU General Public License for more details. +REM +REM You should have received a copy of the GNU General Public License +REM along with this program; if not, contact Novell, Inc. +REM +REM To contact Novell about this file by physical or electronic mail, +REM you may find current contact information at www.novell.com +REM +REM $Id$ +REM ------------------------------------------------------------------------- + +setlocal +if exist build-dir rd /s /q build-dir +mkdir build-dir +cd build-dir +cl /nologo -I.. ../*.cpp /Feprintf.exe +cd .. +endlocal diff --git a/flaim/external/w32/printf/printf.cpp b/flaim/external/w32/printf/printf.cpp new file mode 100644 index 0000000..6d04e35 --- /dev/null +++ b/flaim/external/w32/printf/printf.cpp @@ -0,0 +1,716 @@ +// printf - format and print data +// Copyright (C) 90, 91, 92, 93, 1994 Free Software Foundation, Inc. +// +// This program is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 2, or (at your option) +// any later version. +// +// This program 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 General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program; if not, write to the Free Software +// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +// +// Orignal version by David MacKenzie +// Modified to build and run on Windows platforms by ahodgkinson@novell.com + +#include +#include +#include +#include +#include + +#define isodigit(c) \ + ((c) >= '0' && (c) <= '7') + +#define hextobin(c) \ + ((c) >= 'a' && (c) <= 'f' ? (c) - 'a' + 10 \ + : (c) >= 'A' && (c) <= 'F' \ + ? (c) - 'A' + 10 : (c) - '0') + +#define octtobin(c) \ + ((c) - '0') + +char *xmalloc(); +void error(); + +static int exit_status = 0; +char * program_name; + +void usage( + int status); + +int print_formatted( + char * format, + int argc, + char ** argv); + +int print_esc( + char * escstart); + +void print_esc_char( + char c); + +void print_esc_string( + char * str); + +void print_direc( + char * start, + int length, + int field_width, + int precision, + char * argument); + +unsigned long xstrtoul( + char * s); + +long xstrtol( + char * s); + +double xstrtod( + char * s); + +void verify( + char * s, + char * end); + +void error( + int status, + int errnum, + char * message, ...); + +/**************************************************************************** +Desc: +****************************************************************************/ +inline bool isxdigit( + char c) +{ + if( (c >= '0' && c <= '9') || + (c >= 'a' && c <= 'f') || + (c >= 'A' && c <= 'F')) + { + return( true); + } + + return( false); +} + +/**************************************************************************** +Desc: +****************************************************************************/ +void main( + int argc, + char ** argv) +{ + char * format; + int args_used; + + program_name = argv[ 0]; + + if( argc == 1) + { + fprintf (stderr, "Usage: %s format [argument...]\n", program_name); + exit( 1); + } + + format = argv[ 1]; + argc -= 2; + argv += 2; + + do + { + args_used = print_formatted (format, argc, argv); + argc -= args_used; + argv += args_used; + } + while( args_used > 0 && argc > 0); + + exit (exit_status); +} + +/**************************************************************************** +Desc: +****************************************************************************/ +void usage( + int status) +{ + if( status != 0) + { + fprintf (stderr, "Try `%s --help' for more information.\n", program_name); + } + else + { + printf( "Usage: %s FORMAT [ARGUMENT]...\n or: %s OPTION\n", + program_name, program_name); + + printf( "\n" + "FORMAT controls the output as in C printf. Interpreted sequences are:\n" + "\n" + " \\\" double quote\n" + " \\0NNN character with octal value NNN (0 to 3 digits)\n" + " \\\\ backslash\n" + " \\a alert (BEL)\n" + " \\b backspace\n" + " \\c produce no further output\n" + " \\f form feed\n" + " \\n new line\n" + " \\r carriage return\n" + " \\t horizontal tab\n" + " \\v vertical tab\n" + " \\xNNN character with hexadecimal value NNN (1 to 3 digits)\n" + "\n" + " %%%% a single %%\n" + " %%b ARGUMENT as a string with `\\' escapes interpreted\n" + "\n" + " and all C format specifications ending with one of\n" + " diouxXfeEgGcs, with ARGUMENTs converted to proper type\n" + " first. Variable widths are handled.\n"); + } + + exit (status); +} + +/**************************************************************************** +Desc: Print the text in FORMAT, using ARGV (with ARGC elements) for + arguments to any `%' directives. + + Return the number of elements of ARGV used. +****************************************************************************/ +int print_formatted( + char * format, + int argc, + char ** argv) +{ + int save_argc = argc; // Preserve original value + char * f; // Pointer into `format' + char * direc_start; // Start of % directive + int direc_length; // Length of % directive + int field_width; // Arg to first '*', or -1 if none + int precision; // Arg to second '*', or -1 if none + + for( f = format; *f; ++f) + { + switch( *f) + { + case '%': + { + direc_start = f++; + direc_length = 1; + field_width = precision = -1; + + if( *f == '%') + { + putchar ('%'); + break; + } + + if( *f == 'b') + { + if( argc > 0) + { + print_esc_string (*argv); + ++argv; + --argc; + } + + break; + } + + if( strchr( "-+ #", *f)) + { + ++f; + ++direc_length; + } + + if( *f == '*') + { + ++f; + ++direc_length; + + if (argc > 0) + { + field_width = xstrtoul (*argv); + ++argv; + --argc; + } + else + { + field_width = 0; + } + } + else + { + while( isdigit (*f)) + { + ++f; + ++direc_length; + } + + if( *f == '.') + { + ++f; + ++direc_length; + + if( *f == '*') + { + ++f; + ++direc_length; + + if (argc > 0) + { + precision = xstrtoul (*argv); + ++argv; + --argc; + } + else + { + precision = 0; + } + } + else + { + while( isdigit (*f)) + { + ++f; + ++direc_length; + } + } + } + + if( *f == 'l' || *f == 'L' || *f == 'h') + { + ++f; + ++direc_length; + } + + if( !strchr( "diouxXfeEgGcs", *f)) + { + error( 1, 0, "%%%c: invalid directive", *f); + } + + ++direc_length; + + if( argc > 0) + { + print_direc( direc_start, direc_length, field_width, + precision, *argv); + ++argv; + --argc; + } + else + { + print_direc( direc_start, direc_length, field_width, + precision, ""); + } + } + + break; + } + + case '\\': + { + f += print_esc (f); + break; + } + + default: + { + putchar( *f); + } + } + } + + return( save_argc - argc); +} + +/**************************************************************************** +Desc: Print a \ escape sequence starting at ESCSTART. + Return the number of characters in the escape sequence + besides the backslash. +****************************************************************************/ +int print_esc( + char * escstart) +{ + register char * p = escstart + 1; + int esc_value = 0; // Value of \nnn escape + int esc_length; // Length of \nnn escape + + // \0ooo and \xhhh escapes have maximum length of 3 chars. + + if (*p == 'x') + { + for( esc_length = 0, ++p; + esc_length < 3 && isxdigit (*p); + ++esc_length, ++p) + { + esc_value = esc_value * 16 + hextobin (*p); + } + + if (esc_length == 0) + { + error (1, 0, "missing hexadecimal number in escape"); + putchar (esc_value); + } + } + else if( *p == '0') + { + for( esc_length = 0, ++p; + esc_length < 3 && isodigit (*p); + ++esc_length, ++p) + { + esc_value = esc_value * 8 + octtobin (*p); + } + + putchar (esc_value); + } + else if( strchr ("\"\\abcfnrtv", *p)) + { + print_esc_char (*p++); + } + else + { + error( 1, 0, "\\%c: invalid escape", *p); + } + + return( p - escstart - 1); +} + +/**************************************************************************** +Desc: Output a single-character \ escape +****************************************************************************/ +void print_esc_char( + char c) +{ + switch (c) + { + case 'a': // Alert + { + putchar (7); + break; + } + + case 'b': // Backspace + { + putchar (8); + break; + } + + case 'c': // Cancel the rest of the output + { + exit (0); + break; + } + + case 'f': // Form feed + { + putchar (12); + break; + } + + case 'n': // New line + { + putchar (10); + break; + } + + case 'r': // Carriage return + { + putchar (13); + break; + } + + case 't': // Horizontal tab + { + putchar (9); + break; + } + + case 'v': // Vertical tab + { + putchar (11); + break; + } + + default: + { + putchar (c); + break; + } + } +} + +/**************************************************************************** +Desc: Print string STR, evaluating \ escapes +****************************************************************************/ +void print_esc_string( + char * str) +{ + for( ; *str; str++) + { + if (*str == '\\') + { + str += print_esc (str); + } + else + { + putchar (*str); + } + } +} + +/**************************************************************************** +Desc: Output a % directive. START is the start of the directive, + LENGTH is its length, and ARGUMENT is its argument. + If FIELD_WIDTH or PRECISION is non-negative, they are args for + '*' values in those fields +****************************************************************************/ +void print_direc( + char * start, + int length, + int field_width, + int precision, + char * argument) +{ + char * p; // Null-terminated copy of % directive + + p = (char *)malloc( (unsigned)(length + 1)); + strncpy (p, start, length); + p[length] = 0; + + switch( p[ length - 1]) + { + case 'd': + case 'i': + { + if (field_width < 0) + { + if (precision < 0) + { + printf (p, xstrtol (argument)); + } + else + { + printf (p, precision, xstrtol (argument)); + } + } + else + { + if (precision < 0) + { + printf (p, field_width, xstrtol (argument)); + } + else + { + printf (p, field_width, precision, xstrtol (argument)); + } + } + + break; + } + + case 'o': + case 'u': + case 'x': + case 'X': + { + if (field_width < 0) + { + if (precision < 0) + { + printf (p, xstrtoul (argument)); + } + else + { + printf (p, precision, xstrtoul (argument)); + } + } + else + { + if (precision < 0) + { + printf (p, field_width, xstrtoul (argument)); + } + else + { + printf (p, field_width, precision, xstrtoul (argument)); + } + } + + break; + } + + case 'f': + case 'e': + case 'E': + case 'g': + case 'G': + { + if( field_width < 0) + { + if (precision < 0) + { + printf (p, xstrtod (argument)); + } + else + { + printf (p, precision, xstrtod (argument)); + } + } + else + { + if (precision < 0) + { + printf (p, field_width, xstrtod (argument)); + } + else + { + printf (p, field_width, precision, xstrtod (argument)); + } + } + + break; + } + + case 'c': + { + printf (p, *argument); + break; + } + + case 's': + { + if( field_width < 0) + { + if (precision < 0) + { + printf (p, argument); + } + else + { + printf (p, precision, argument); + } + } + else + { + if (precision < 0) + { + printf (p, field_width, argument); + } + else + { + printf (p, field_width, precision, argument); + } + } + + break; + } + } + + free( p); +} + +/**************************************************************************** +Desc: +****************************************************************************/ +unsigned long xstrtoul( + char * s) +{ + char * end; + unsigned long val; + + errno = 0; + val = strtoul (s, &end, 0); + verify (s, end); + + return( val); +} + +/**************************************************************************** +Desc: +****************************************************************************/ +long xstrtol( + char * s) +{ + char * end; + long val; + + errno = 0; + val = strtol (s, &end, 0); + verify( s, end); + + return( val); +} + +/**************************************************************************** +Desc: +****************************************************************************/ +double xstrtod( + char * s) +{ + char * end; + double val; + + errno = 0; + val = strtod (s, &end); + verify (s, end); + + return( val); +} + +/**************************************************************************** +Desc: +****************************************************************************/ +void verify( + char * s, + char * end) +{ + if( *end) + { + if( s == end) + { + error (0, 0, "%s: expected a numeric value", s); + } + else + { + error (0, 0, "%s: value not completely converted", s); + } + + exit_status = 1; + } +} + +/**************************************************************************** +Desc: +****************************************************************************/ +void error( + int status, + int errnum, + char * message, ...) +{ + va_list args; + + fflush (stdout); + fprintf (stderr, "%s: ", program_name); + + va_start( args, message); + vfprintf( stderr, message, args); + va_end( args); + + if (errnum) + { + fprintf( stderr, ": %d", errnum); + } + + putc ('\n', stderr); + + fflush (stderr); + + if (status) + { + exit( status); + } +} diff --git a/flaim/gnumake.tar b/flaim/gnumake.tar deleted file mode 100644 index 94a9f45b554e11415e0f9642d22d6639e8641dd1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2938062 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:LqSNL;T<<`km4A)ImKn$a3BzoT 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�eh;aW!=XDg6IrWqWt@@Wi^xb#zWL#Y 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%0Abc6Q$L(Bsv`C!1ei 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
jE+jkzp0cjwhla>XOES!+Yac45}| zu*{o=(av3I73*l;RXR-=;?W(@(mab*ow zlOSvL&++i+!C6%(8>7Xj8pxv3)(2-=A3ruCZ4t)O%k9G#dyfV$Y89;cjq3vZQ(ZAN zLIi_q8WRK_UT#D4S+}2C%in7i+V5ujg~{Bq#gFaR`R0GGtoN2z|3ahl^UsxCDw?uh znn}nGI?ZgD3~A31O`Dg5zc6zlS+e_d7B-(ee7N%c^5&iDXLn(<%l^>9pt~^a6f(L} z>56xn@sqW$P43MiL8oLkUHbGM-<<1`zje1=S|LZ2i9Ii7V;;_}jV^wLgqz2yGBoNc z5Og{TOXc4vU!}`NFDVJ#%My;} zVGS_+gSTe!&-;QctN2dGeH7#Gr{?YQ<@x{YPET0o(~3Jms?F~+xCu<4crwNtMynwR zfdBW7-F-5lNaMuuMao?4bT52`GiI3HozV}QXMCs!A7Quh!Z_>~AuD-ax)&GB0Tak5 zhMzcm@X=pt*FCQ$g6Xv|Uy2L&zsTl&o_`X1{ zL`V}?;m+}CBY9d4Ol;NpB<=Jcb~CtxOPNK?tWw`?C8>zBS(Cvi_Dtl$+0Wdk(Wt?!mZ#M5}*-pX+ul2pxny*rKN+`WM0*gKV z`y;Pf@XIztB6>IH5#85UEfv zSJf#DDjpif;xBTYs5K*0JW@7WW#$gFJhRUUC9i+oy|TOa`pO}hL#t{A z&-pcJ{7wvTpT!AGTJp6|KVA6<_9CwuCHZC9Fc8Ki{U;R))w*M*^ZfR!JNAQ32`p(I zJG-y@_LhI~dD}zBt|HW1ZPcicy}-Y&D+=`-N_0M}P1CBQT>VrPpO;%f&1P|XAyBMx zeio?yLRNRHyk0cr<8xEKf_UoQg;|+Op-<{(XrbA708@I;*5Z594daFN1xSLvJl(;Q z)_jnzCTNSI1+^3vV$Qy%5?2tLwG~NlRP7s>N?iecmhF9a-YyQ2MUz;AW<~p<+gJ7aI=-W)G>co@v z<;A0yF>p%Tu~DU!QK?SWVKW^gDrmDERXWyioAL%g^O!(5NUff#tt|s#Ofz%jzeoS{ z;f)r`sTgb1z_SS&t&)&7umkPXJyV3H&09>P^6bf5tiV`OJ$T@F(@E~eemPxgYSY!W z*gaB4UTJpn6|jH2_xDpwsggqXWH30e29Ebk+$~IxQz=w33b$~Y``I@i{-HTxdPhNb=5L+~u>L%LBGh4Bs4XUu6#Lg|_2#=a z3mC&vs~BBZIB!T(YB>5YZYzqov3;ns~gg|aB{>y_eN*aA^7IpHq4 z*-oQ)&3$4zyF3!fKx%}y9PN9Bp~F@XA#3Pmn{S7I>9R`L!yj@=E>5@X{k+3vQQE#) zAT_}E>uVcZcmC(>XA7&X{9h%a_PkxgkNbB1{x9+0SK0Hub?xTOn?!!y zr^7#XXF5NkAKC{T7|ly=`(mjbw^7r`fU#k%P535(}|9Q}3Vdu9+!uk6D&0DuW|6K9kw{Bd&edG3ZeqX!( zd;IrrI|XO9MlORDC63PXJtOI3j$fWzvO{E&PicmpSJ7 z#qBervm;HodAxmtv^m?^^wPm zr|bE-M$cE87v|X?hBFI)J)E}WU|r>#*#g6ZW3e@MLqInfaN=@krNx1hMkY

hOz8 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≈y1-=gW*FB@ z*h5Hm3LanQ|T{{rf>)px6kv`MiOdaY`MJk$h8uDhohK%tqNMHx@8` zeI|j&_f^RH30oBYxhviwLc7!ypJhcU!u>`eDObB=)A*-Pul_puK^dTYn*)Q{j?eEP z(axaUy^SnM|bT0VAW}Z5B+Qm;ty_+YEl;-o7|FCkL|Z^FRJO|7h2SpD+FE zzb)On=g*TLZTzyI>f z&%eC;*}X4$_W75;|LlJZ?*7+J;rgE7_(&#$>l@@7dAZ+`>Ghip|9ds~MkW)OL7dJK z9i&ucye~d_QjTDcl1$L!NRTsX_y`uZ_%Cb$OS83~bseB1qNJP`B?~J@;@Ib$-uLeO z{>~phSN|8*PM2n9zd1d_iv5^wJ&l#KQzbu2=c9M-2H-fj?rpANY#5hbu`ePt6L|?q z1&K7!cKTMBw1!9((JM^>5xAR!WW(BG?75Q!EOylvbt;xAOOK=3SxG^&-yGqtIXs)y zif6we-4G7y2fTpx^j@~4l?}p}w^wIJuq)tDTFUB13rU3+wM{~(wDHUGhq}y=U_80w zlb3rSj{Oe$5qTlANAhb5)jX4tbFh4Md8XxrP3`5u@p)VeZy()mw?P&n!e8f-R-=R2 zW?*eMXm>Tc*nRQs?&xT5bpQU$%y+K-e~g8_qJY8pI5%d*XU~w&n70Z!5xrbq@b&Z; ze6a$SNOt@oa{@h7{lf!nDTwUQT1vLoP^;y<_|T{8h?dw~Z0o3BFg?ECO5z!8<09d{ z4=r*0nTLNyITd}7ebpJSAlAP?ras_P$;FQ@YUcBvF&$=6!3h?OHD}>Ono%;kVxve zyol6ySkCAz!vBeLuS3xoe6t7ry>p-MJGXABeLZ`0iZX)h884<1u0tTJ`N+s(^F^gO z)#-qr31T6Z=OpxKs0VhS5kxQVmk8TkJyL?D*lqKol2~M#!+W#-HN4mfJHI;2--eUf zBfxO9hbF6CBicTUDL_h5QZi&f->6RHvkH)hS59L>Q8^(6?*I|=$QN{Poz2pPY%!D| zK7;%0AK)aDfhhFUW>{ISJtBG-y}<#jk^zj_XvIix&#oe!AT=+Xhxog$NVBTDOGdBa zwzR43elBf2d-!nu&ud%vXS-hq+(NK)cJ1D7OFmb{NG)9ZjASZW+*<~TJsO_rB>edsCe52VikZ|4ofI9Kv zC-b9=J*47=t^*&_LL!OQoIj`N{4YG$S>~!PMq$Yn5kM|KX1I=u6Gj7O3%@x$`cGRwcWTk z1m9;6jF?o+N0fT>f*pGgl$K4}2_T`)i3nx{b3QJNj+BNa`T6vJ8To-uRKTs=UcSB| z@GmcF)35#8y&$e$rw#XXwvlWWVSLmQ#=xmfkz}P;<8Z6Ks)TmV^1XRgEV#~#hu~?l zjcJ{+>!OkbrUa6PbILDr?9&=#_{Ko~;py`B_wU8a5U4_lj`__RTfH(I*RRT$j#(Qs zJ=FviO1g925%BSr-jD}p;eQJL5RP?>eXwhhNSF1LP>Gz(Cx0YqL$L|HuM%#U@ZJXQ=0PsF*M%-0Sj1|18f?^$zVfY;|$OAA7x!l<&gzS-|IJURo9 zp6^~P?N!|QWPSzz&v1Q-e=F4!?y_R%IdAsj16^;cy-iMi9Wv#yE|~%^B~(;GSHy3o zAof2sp-=v(*?jWNHy=i9VC67n;Rp0YXwNv-7&ovb%0h4~tEI6|JC2&D@MV&JW>2n; zFOT511Q{fPAe!mcJn=v1u^gFYs|xG%!Jxk2(|mC``-WqOshHF1xej#&z`epM;eVcY)UCf$sTCwBhd^OHUtb4wk*aw0 z#SsAjM&+wfl+!B$p5wYT`{Jz@D-cs@2$sUjLmA~O4AxPbOpI0b;VikjRJLK1B!w2m zPH$I5<@W5iM~XG0mxpjrwsfmdF~?7gAHpvZj-vdKT9P5t2ilRWj5t(yh0!~*m~3K#)M~nfA&UP#aBz` zJsMRT?oYVgBd^cK^V!Ninji&DLToC`>&e9$;FN$}FVmzjo5GB~f$(q%An@-UUF=<* zpq{`>kz2bUh?6rCubo{wai$=PLs)MyExeT+kZuPFIwG5Zt3=_{TtW*AS`ng@BE9o! z1L5ndqYH$<=h1YQMgBMq)|C{WG+@j%$CPlUnC~lQH#m7c zIDfN0xH#b-{Vj=$tW>%fDZU20Vr*FP<(YPlw2d_MlsOon()3g#Lc(kzl>oBV^ge`4 zJN1Ry#`SnDs(tU{g00y?^mrva&>qCiiN}C$bagJ#m3fu4eQk&#Sq77vkRxWcvR9&n zbgMS2kApGRIy?uZz&XX&ONha~2Oo$_5<6+nMUIP-9UbKqXw5X&VI311XK3kGS;a9% zZ%>||p>9gGqp}uj*4b!o2Mw5S@6H~QMLm5S7I%`kT1jggJjQrxb5xXvZBgOqU!)V%JF`131WhOwSs6+ z3XiE;%VosR!OvfhKHGnNGSwDztn2r`EF-#(t;7PHlx$1*Iq$A8~Z?c^!A92z9Wh@KZYuqaviX?_Us)+nekrOH6KKd0(rQt2 z@8ydN-6V$G!GGl$^qDb+Kf$)n%wUB=agjqeF#B71jrgr)-FdCYm(mayqv#CONJTBc zmbKKzKvo!8=%B(r*V+hzs-wW6;rOgQB#)JGQ+8)}{cVGGmF=qV1*%f)x`mV`nMoPK z`@I89AS^U-2zexrl-uT!usI?3>^i4dHU0HAT|C0)L#*g+p$@7BvQ0&8#>ue#@`~P} ztwOOD-fw3S&f3zsef!CE&016*K|F}4Ulk{q&Gbmth|=b;;yBUV7z?ubCiEUWKFi*5 zsu`odF`Fn%OI>5lmX@wrmBJ}P2G5R_KjgrGHcqk2*_&23t_W^9)#Fo!jNUI!>aQoS zVs?r=i zjnjd}g<-RTwOz!N{CjADsq9K&hityQK3L?S{vuM;My5YpTMX~H>gWgCOS_a#asZgk zvbZQaXseAa3%1(mq?|sBlFcb4T->kpTxXyLp)PjvOn};Z9%B?Xr^eVsz0YCTcyG#7 z&ntMULIfy#^_QHW$U=u@piO-JsCmax%d3k6CLpoZtiUUW|4I%C;ejxbR}vH%OJ!Vb zRn#A-pE~=~TLeda28QJnpFYiDph77^F~iVvk}Bx}#tEg_-v$&hI{E6DGxR{Axezwz zy!vsyfkr?{vY6F56m^|568~ZrA*Q=yq?PFVcwg!QX8|ipab_i_3jvi~^IX57xaP}u zN(Fo`R5$9FJzktq|1NhS)=2k-38gfM>=mkYl%_H;nO009w^U9`8EcX1)2z=hss}1+ zimcSP{VyDo4Bo0cYQ9M>gRR+grJb#(w=4S5s0)kimKK6|w`dN4Vkp9t@oT618?#?E z_02BrEuD3jxu;=pPYn_uC3JP)^Vc8a^z03Wrv!wl+mtjvd{GSH!lrSERH^`_!`4j4 z!j^J#T97Lk4yGh}8B-wezrds=2_VKe^H<6W#TfHoNJbThF=jr;4sbg2VIXaFurRI; z4+1ZX98X8ExS&1QoSETwD=WDTI(O29qH`krh!Bg3rT`!q-f-i+Od3L)m}-GR!ZDQ(4&NAy4HvOt@<0O>VrVomq*SZS1Z{icNuFpS zzg;_cRGyriK{i6cWK72ZdM+R zN%I?7aOfC$$wZ0;UMHnw5#iz(6*~TAeY1!r=>)JZNfHFRvP#H-oUq`IJqiKCL>OoY zGzo{ioP?*l=fK~tTp?Pv3Syukv_itm5u61I4LVd9ba6fS;0txr72!R)4nYEhLMFOy z_7ES7ZN2f@vau7CSZdlyxG1wvJ2T__D6y|tbA%Uxq6IwWdP)*`Ez!rJ8aS23TYCyu zw{6lXLHDw^+0Vj9?{fFSZ|wIsH6&y?a`A-tX%W{BhN+a(p~m>c)1-wA9>DbzWgf^z z6qfWhE*XUkI70Kr7u>QC6RUPm81cOBz5Uuu676fXPT_|Vp>&;Ew|-r)k!2O|Fi@&2 z3SU#9`z|9<>vVu$rARaXIO1?n*)x?3Wx=cq5--9ju?FZ9tauw})Q9RaBF6v{p7PqW z1=|vVmX&|vUq(5LDtTL6_~0&HKfoL)=>GYG}H*qthGPdr76>}a$cMLG4RW1Y$7 z$02eNG)MrH*c}lUv&;EQ1);UQ1{6n{k?wrH0_Xk{eloJL zI-Z5b@>_>h^ey^qccLBMwh{4zN$c1r_aIPwbF2NvrLN`7zeO;u`ffLVXo#j76@#ps9;_XS0K0dDDb273~qWl zm+B&L^{xXhP5rv?vTwf}U;&*D#Go?mJZK^NraH5L$9bD;$IjrkdpfR$J^%;xxT5S- zt0eJe=kz`GN&KuqbN8>8M@x791~fAjU0}!W;=;aAfR5Hn-6suFZw(m(tcB~8)RB^J zf+E<8ESH40W2K`o4zV?alll3VgSiE%L)wz5gUBE2z_jx~<6JCB5;?_D)TVj3L!A#h&cK7-raa6(sQM~UvcwRXMa&`r z{uEpD@sDZ}PYC7G0qBGCxW2GUIisFR^g5y|OjWXVb_16Lqt+ubim-jDDe<%Ofqtu=Y2J)Yy`k@Gu&Q6il6n=e8u)6l+Dy@F#@EUe*p+Jr{F23 zC1CdX@e*W&@_BW^Oe%lV_66vnEmcI#d6Bk9qbfyP8pw9@hC?v`ew`3IaS9>p2^6Nh z&HT;{@W66k?(O}H-P?*AyxU_B)CgZIePbs`qvoy#VIAG3Iq9Q|bBZ)sGrWjXtEtpL z-X*7Qd2?lLO$i+rU91>slss~*Cd33CJ9-_{C$=TALtlM4ZnQfWVx6FXXfN=-QtJjz zeWUAEs=f(;9ej+^DcazRTueTb4WqN z-m2(S2o6%dMEsaCt^%X_TMEqOIlR&iQG!HvD8kuc7cpG;giR~z(Df>Nh@vg;g>yvJ z8Ua#Si&@J!NzijdI4Qh>)8~s%GnksKklEH{D}nUp5wC4a-C}R~nQr6QUP#e))iIH> z!mm-y2EA>R`;?U>e(9^f0l!QV=lZ*5)Sgm0OHs^U^!KZ)J*I=9J^YF1@^A@hxtMnVvL z38kkOrB#ZrFdat0S~g0WdN_q{%F6g#U~7}<05xRz7^qe%jmT(CsfUhnlBg!s0*P7q zqYoTWw$vTce@d8YoV~6AW0jo`C9_Dh>d9L-B(ki@mt#^at+QNwU}x;drxRejK-7RFxU4x3 za-8%Lq>GIxzZ}Mb^h!9Je;eQaf&gk$c|s2)uxjk$nogVS>S{k%O5gnQZ=se{+k;@% zRaG>+)HE5H(^*vD?iPfY*1m99sUXGb_Y0y)3Jr{IWp?CVbb7Q1goUVB z5WLnr5TPcdCJ4q|_@O4C!rA<<#RH@k8{m57x&q*`fKr|xprj--uvCmyH#VmSn=Nya8B zaYILzSRDy$Me zfkQ$Vs@ndq@zL&zFds?8ap~4kLGgSMJ(Ams@3MHzd3d^)(pM>FeaqrBiz)2=9r)> zAp9|Z?J?%RWQ_S=Vu*)(RIvP+nt%_%75q&FiIiCr(g%68O zl|E}R_^j)Trn!x~+t*o^DP%tJbg^a&!jZx+2)S*uo?tNyRH#NE^x&1wX@G)f`=>fq zja6-N_0Et47=+GMt{(11JL_P!$(9p1YTsE=W?dZk%n)6)R?xQ z3c-v2z;TXMtP}R?yeHQaJcuvBp)Mm^hU<~VsTgkOTuEl<6uwoQ_2U_sA73A%xM&0Y zM6(jtBo;#h8?nlbb!A9Ev4paKb1|S5Nb&eHlE=dWoi{vL^*h1RthI%u(kJFD`RB`T$S`uvrQ-05L2tb;O6G zoyNOy9j_H%$_zHM1ySn7-PW^lnfR!mW?zR(Gr68LGpaQaxjVT$-a%^uLELJ!6*=!Gc*b=Y^C28YM2oE+1ZxIfi>>#jCS z=wmaA{EP*p)5A4-LDlIk7>=KgR#%aJ%NI~pHKgI2&L+s-%M&7Wqm`*$7#4;ZRWqWi z(gj0P%e*IoKz6c2^GN2PlQWi&V2QD;VvCnnY76kH7MI16E>AeE&M|VaGSW-4aqwG- zr&!SlwTSsJ&;1j_SdAQ04};D__OJ$Sh&Nr`CL7^h`JM^P>HIrXKm=F9Hn_L)LDo)s z?$FT;1au9B*!TU!=?y2-klDm$IV2vEianaros-tFp48kiB0%iw_RZmTQ+2dylfWg zPn7Id^pL&4>F6Nm00*s(aZR~P#P*>&aL23^7oxkJrkfW*ZLRyxe{G$WB3cK{(ZNM02QNLEs!shg`u z=!o3CqZAAoJ;qZi-VNCi9fNF4BLUB-h+j0Vpry`ECNmVMbm4?=FI+heGw2{yxP408 z7I{X>gZ8*6m71>!l*)4F7=#YiiiYAO1@t58%HwgMjKa{$bIp1YD*ohkP=K2Gp-68! z7O_je+&_nOVime`#!1s?BsroIlnmr5K*7p`#W}268E5lVO;mXL5nE@a+`bV?N8-FMnDn~@L({$ost5fj*;U(vN? zT?vV#Ep1673aiUFi7^rJOW8{{DZ9hk1gT9=>V>Rew{5eZ7hbaymMJaN($8c_0Z46{ z6*b*HBIyt2Ox+eMm2KA#Z6D5XIo-_u-X(@|$K?BJvOOFXrhy%rBZhWx>NO+vt19=$ zrAJ%+I8b*JYh%k0*~|N|S10@LBu#1KvJQNo5hY7>G;WlZTg{qj@gmhdn#O{_v#Vz2 z%!b2$GxK%x=Q6I}G`ROosVS#>8S4**P__B$t34h5vo5jY$|@f|RIA@M8;HFcGvUk< zm4=n>#g%#a5*haD@L<9|#W5vQ$D{yQt5bji^{eR#fg6mWfdZ2fOJq8-MTb;Turqni z2HY85kE$_#Fp1E-`fAc@3#(+}L?@2qo&cDaZ96Tj*d}6rH_#__l?k8fu&tTVb~f+)MV} zZQgeKuS-pjZISy}@3-ANsX|#ogmK2}58_19B0^W`vX>MJajsMD#oZ&a?W9Uc6lpgD zdg9r(zuiLGSp-`m9UIfi$buEHIn$8L{`#fuL)_B8sY+z~M@Tr=#wy?>Hj0nyUtAOG7Kt&b+ZYMo#&* z%kkRj!4TyeWk$#2XzZCBc@ki-yCRgdT{<9bFgX+T!Tei80u|Q`GI?lB{UKrAHY+s) zY1&-+tc&yjQ^_4i$ORPOsFdh*H%29UEht2Jcm4sIbK#C(CQo;|NlsgpPx-c;DsGY1Tw|c6#B{NW! z8uPR5h@mtiE9AveYCWK7LjLPsAW%x_uo)1tJa>$@mK8X8mGEoU%1%0z-71R_nNi#W zPW|#bdhyZZoUt?P#$&Uu_k0x1(?_wcbjFa&BzdZu5tjdKghw;WqBTYDT!m=GmV9`U zWI4JR4hCuRX*wBMQAsWEi)qTR&+H0~TstnrLB)rZM8P{%^$SQm)L=i)P`A$Y!%P7ru1mX&^2^#?y;{6`N9;2!w{=lp*cNIDcglA^r6WT98V#dbB zhcg14V$H>tZwDiHQW}E=7~o)(h;4B}7X!e+6mxq(a#_^vbyNV&bSHu_h^Vx7v90S) z#fy<)YpM0~TL_9CY?a=&KqhC}5)_=3XkNYAJ{p3+1WI;rg^cJ52}AhT{+Qz-pcecc z+0>*p40BeG!haAM9o35>ROI8tH{%Ftnol5n1>1GG2g-4vsV|*XaY`A(%%~?aN1-Z4 zD@l=Z$~j(EGZjbyiEc8$0V;uF%tO!8%aq%1kR);^o2Hzm`8rgWtKb)C;gxsXdFEQS z1VsUpaUBp`o0{CDi{zJ$?}YhFa07yhqXoY^Lh{oNbW?;7 zRVdVqVjj^-@KdZSN@Y~DWo5zb(f;-y^z(r+Ap49duO+a3nyBH)|L^p@~LJ02_yJY6@I=df!p| zYsk6q@S)X8o-mFS19p%?EV)GlZKEbEU(7@=8#}LJo~_n!B@)18j3j1gZYpSf4@OAx zt>tewdoR6cI@j0~{uQ1fC@0k&K+!Be-gv+Pu6KV(MZmlvUPVAQ7YcmK_0m!4u{*D= z@9xUhn=Qs-ZcEB@dw6NI>b}OPd@p?Gehh!6LcBUFbT;SLtLf*w{Vd*+ZuMLDy0}|M zjmN^KRK77PlRZp0O3n-+OZs(#fn;f2@;F>2s5s| z&9sxe4FIGrmd3V4>}nlEsGQ1QyB98jjL*7vn5mF=UJezAro;7^s~E0PZ_E_M2P`EZ zp`~b@tP6Wim}@?*^m7GWgwxSGSNknrC`XS~Y8g%IVP&Q(YUb zmM7Oj)w(3}KO9xF^Xs8%>d}s}n!PGsqY`>hMZ96uKioythY;%p+qM7mP$%MS#6`CD z|M)WkGU8t09#jgrZb4!fpq6O(jBqcBTZ8hVFo0PE0}yca1rA=_>A z@P$T>3vj4tz_~%EyE0kEmX(ps=VrLX)aAH45=jXh$q&IbsOA5R1v0G$^73u5n7H|6 zOwbDia+{K6b-Jta3XeY6$_V*^da>7(6qeQL8^5bSZ0kW0_&@=I#vyFs?uW!g(L1G} zWoV6+(o8yGJuov~!2ziI3A&qS`)VlbgW6pMKz;&`>U{?j!mkr|sF8;+(b96> zkS?8d$!pWOv(w$a8<=J84V)71mnD*qSdVEm)=aHsPM(+hJU`o>Xl10xzyw74E4Xs$ ze>0!916a?g?%3gl-U|w&c-GO;!L$N4gC-NST}Yaq8A&}O)u^HfeQniQAMQFeT~{nF z{EUV@!HB>1)IE1Vn+|1`0;P6y8j&`nMtC9ZE+k=UpmL@{n9YK)y$~;LW8neQC}OfD zCRC~qIkLbt*vtVLCoCFV!!?OPhAF9vq*x!~HUJdhq}FJs(wrmNoD3N(t4*vlYCOp1 z4s|qE-Gy^Jbiehr;4RxQ9kuo1BceS5d$vuAUeJQTUtLWYMslgIXlGIa`Tedv^jAqJX z2y>Wd5<*!~)~cP3#<#&*E3MyU7spVS#c6y3MTGe7+Px)gD%f^NMwMLE5)WpdwW?j} zN+mw5{8=p@P~CpLcl-6pr4G*C?u<3l6WrCCnDVxVSUR^|O7fPVv7F&o28&@m=0o1w z-&KRyA=4VK3LT>q8l%#VC+A{Cmf@~aF~p)TsWE{F;H?npTxq^DB|ox z-;T+zJg0tj__2f{OKDh|$!uXUH?P%9X%T!o&c-q``0ov=&FE&FAX^W)SeBD`TaZvd zXJiw)-0q=O5nXe@W}vYOfnmx+go>7Y;u|bv6@+*%OR5w2giHD%xb}giokwiR-_P7xT8))2g%E03Bt?$}HcF2qnV`4}i6Domq zmjj>)E_E7(b81AxFFznHY7J4r}aA+Wiv?OHXEUC#6%Ku>rI z8$)2y?!tc+7Qe~H!k0o;W>yl0BpegT! zZ=H!5$-8O_tcH4F{-nrDCCBoVs=Pl&Yu3Zd3gSF#n@X!4pjN2QjR)Vdur~jE1ver=FgsQtS>*U#<%9~lpWJ> zjPpH093HK3)wcty#5ap=k=jIX++y_Mst9iNi+Nw+`6!zm647=9RjV?ArH~kFy+la* zw|)zJ4$4_7OW_`!m*wPicX8Zsy>Y|21d(FTd~AXpd@xb+(1b+Ear)&md;aoSCR=uQ zy>u`J{`MvRfHlh2>~_)a{Pntsy{|j@;@#iMa5P(I{Cs3+jQ2GFov0$*z)YslB7B$E4sK301s zHF3<7a}vRglZfQSLzEw?+rW`^MZ_d0sIkH|80$fc;Gnd4j#GQKZsyDDT6NMe zZfxz98(TFqxGzplpoey6H@BK;&t+kVLBGnix-GUxmAwlaGLRtcT+{FMSj;h* zuDAmcr9~&s4uxV`PS_4LEf?BkF{-@N?Q?id-m@;;BjX^f6YF_INBuPZ8^uI5bS>C? zrd{~47jkFf7r{A0u6O1!>)3MF*8a>;aZ@atYla7ACWPJX^J*1)L^w$iYNku>d^3%1 z$^K?Gc%`L$Q%$seU!5NKrZzXq7hP538{e{AuzmGk&Fk%VZ*^v%8exV<i zOB=H8L4{&jOAh)0gPxZfknGDS=O>9_ruQ$u{_p=^5D@WCFU;J#KQl)?nz#EibN~4D z&&|#*-nrBKOViBF5<0d2&d%w-`rq8*o%y+@S-iI}H$OjrXK|KCbNBAt`eh_D76WLvIGrpy zsOmH6H=I~Md;{OYZWB2)O}{Pf_!lWedQI9PZ=zEMfouMd4rxmQOX9rajzXo7;K zWXIh?Yqz!OIC=X2GG0{$w`sTG4VCPo>?ns2$F^2B)?RF_J%84ldHTXM$+IX{?bbj7 zyq6ouaLj6txt|{^Z)}^Jkw|8VEMzkzdfZmGi|s%USwSQ=*qwdSge1uX1cYRP5o?I)34%;DvJQ?Ksk}l0g9`u#=D_isMx2 zo;{Ki`sk3;pr*r?>2|}C=+L&84o6vM7^DNLHCRy9vTLPfKs+LUY6~X?bT{2F&$N8G zx#Ci6ZDc(2DnnqLFpR=FoT)UwiDiK@>9R!vl?~;2l;IVR{0}=OnP(;-$OmxA&2yHO4nq2_Yv77}iKPg3&*kJ*9?+rZ7bGKOa5;v<3#o$% z9?Ir4F4$z-Sa&vM;qEwJ<~m{G(u3X%m5JwiGaJTzH2}X?D2 zkueJ(4Dz9M#K7G@Mgp?@2gaswI}2!fpu;FFo)zQ+6^Walrc897zPWt-kbTPuEK{^p z(-rIz>H`}Uu9*)QJ4sPs;ZJy>Jz5We%OhJEz8JxUx)s7o_YNZwMZMwg5y?8imEOJb zrWTfuC?(YGp6X{mgj~?cLVcSugEw%`1X2TkjP9#()QQ{OY;MiQ>hk0D)rNc5w+!*lVT9(Su}mIhmwna+W3XQ% z1}!A~oF*A^@sRY7Exe>1$OiSU5356AIzi#;4j(9jfCN&62SOC@W?-9uKJp!F6N!cT z49<*C@uR?7e7TXaDDm7j6-Mz_8BB=x>d(^?<^nA_WpFE1MdKarCJJ?E`=e2a23eVo z)JpA;kH-9?@=1vA+dbVXRqmj69&S-ROMY>R2V6y_W@i%HVhWHAu0CA<968QnKKV^? z2N^qLcBp{QO}BxWIa}L$(ag@=J#@m^>CJThKGqhq5l&95MC|!BR)6fDSTl@mM;9Kc zfDnfeKMB#Q_qFE6pQl%v8_HektvFv6`-%*x4}zjzWf~XIl?dq2tC+@~-7Aco23aJV zaBLbcIF?TUh0+(c!sQQ2>F^~4x=773S;p?kFL};(NI7tsNlpXvVLZ8=emd0IR`?X+ z0KGA$e!KpI>t2K+`~PuyNNE_w5z*D^kNH6CUxU>w3`CE_W~hUUQ>f0tZ1V2!VVtZW zi1NRO_nDc4Qdt^GnyfOZmA(RJA_>h;RkIX#)=2L`V1Z7Y;uQgpZ_80NX)cNiI1A9$ zXTe9mF5Yo~(??Jmy`>1(=hI#&ylw-c2y3KF8lG72&s{fz)I?(>yGq+Q7!8=XX~xn9 zatJB4hr5uHA1R?@ox8O=>~jc@XE0|gc)GubhqOHf=(~-hSr|jnIS818E`@GMDno>7 z`EVEEBzYuVxbOGA)i$+}R-Ji@vz@|FT-=9Ljp=oK) zsN(?Y5J*(1N0YPP=C#U3oi^aZVQ8VNQ#txSdNF~>{t>)c_6rNA2}Vab?DGgU!B+>obUHf3lp%seZe!if`wn$ zZ6B4rcD2G~Z%P5x1A2K9iG_+s`kmC!9EURL4afVD&OX)5eyWpt=@oK>ra5bGp+qHM znezcf+XN7OA?C2gHaO>k%8~h}@64J5n`EGH^huwF19g8z*KUMpnYt>eBk~e~q1W@o0icY8@Z%Q#sLYxX(Vi4fIJ1aM7Y{&e*h80qd31 zKxV_4AQ)PMX#>j0kX<-D{ffBQp|_;$6COXoyoR9czC8Y0av6ME>B(qFS1wEa6WBtM z+fXV-W19<4BQRqM3mn7cyTrSW5P0?zV$29mJWSm<9(KZtuE?ts3xF!gU*}zuUsIq# z8l)PNMU0H=E(rP>;vPrr`_bw4UT5E#9t9?-RAeYo?|P`I3~2FK(Uw^jVxdr+O_(}x z!WF=4X$s=ynvX`|_7A8$d`Z~ZWbZk%(cuZ^#-tN6qQL`nP``8>w>uG$vSFRC#G)I!p=WP_>0#`e*wwy^a!f> z3=m7|S&w~$GyWsKe$d>`dQii#{EyzNSN{%-Oz~27>%_!N7L*h_Qum3VWQ)n|B05MU z_}cUK&_Ct*5aW4|dLvKF<-kn>Hv2#K&k6Fny7qw7D%iqlL$d?| zH6Z^rypZiy=ID z%0X=50DEa30xtG75&l-r1VtJA3;r+M@=b(_FQu ziSm%D*oQF~!+pNHX*sG<-Yxk$9gx4B*xCXr)iwCCN*gec^y8ZITCo&m`6@Luv@%GH zgP}*ggG*fy%=7D+Ha}I&DfvL|qZ{SLeP(4llw^4J!8{poTO7TPiMVCoP=*qcf-wrO zRG2O&j$G6J>$>IhbG#jBIh81Y;NQh0a5)G$5N{D45BOQ4f_|rhO8KBHq{(;(%4c^` z-?h3JRk|d?7MSY1kmy9I4l<-5fOnyJKtKv%uoZr515%kpcx8hesOp1Tiv_>h9jjJh z%H|I#&|VC0U2(S=3iXt2($;!S&w>;nB%STQut}Tl7<*z$r*s;YgbMM_(_+nXatX{4 zebT`a)eS+w2u=Dp4&(XePZ!0wnQtTPwFzp^~hPEY+7T zBuq%A|G;$?S`^oMIbIN0?5icMO187Pj9HV5;|Oqp)9RhuKd3_D-_=G0*n@xN#^&m3 zv;1`PIk7*0zeNKDV%8;O)~&3i2L&I!q#DB}5=&h&%$bno)eCMkJ=#BZgndLIFco0D zvZIJuEx+9Q?)iqx(1-+CTu;cFN2igPkN45rD3}91pn)DJ!Xv@Dr&_B!Qg#={YyfA)ax7tUYGKqvnH<_kNx#^;}o|1T`g&Mzwdzc@$qpA-P%|MRnV z7JrTZUjwv%_b0b+HS65ljt%b?ai00XSHy)7#tWQg&2b(M(cSaQ1G~JZaDW-?&X7{g znKzb?pT;j+z&jJGkVy#*_1ya2GhpnVt}q756}e-M?}nU*{EMDdy)*L7s#yoBHGW z+D*GT!YkItheNAt7g78|Z%`|lDm}3Zb08FvJ4K{JRyQ}BC(k#U<>tlm#@5=( z%csj5&5M^Cq@%BrXc-LOw&e=gNf)qC7#Rh481SOiaS;m*$fXF&mP%tqtv|aV_zrX$ z$Aouc#Mk)ST>2RLtUQ15BdH*>B|28&HqqlbvbFqOUq_;^ot(*JhgO zwXgg@u4A0Kow=PoP)Lsjg_|J0D=*d0q&wY(ua=LAHI$h&l0h?`uW=wYAW%dXy09HM z<}H%dI(okq^&XH4yZrrXf93hJCu`sKzw79_D^7< zLissP4f6i3G;sa@o6UdyS2I~besk-wAg>MS_u~&vK*yAzkmdDF{*KA`-?}RP;*`F8 z4g&u z4*yzppYbb}(x21~(i z|IRSMC$l%%FN9ezpx=M?96Z^85pm?|=^E^`%rOC}R{hQAFE>`m#;Z`CTLEqx!UCnC z$8w|$JxzGlUta7Ta>r)fcvl_zBik`s&E}7r{jIh2)kn|~o42|0yjhr;Z*JflVh+un znfV*0LtAo!6On=P)q$)EDfG?n^oxFdA9qfV@z1lXQ6TttwiLeD(I-V6F98-~hk*L= zDb%T$3853aO2LnVZmX+KAAc~WE+14zgmFyAX=OA5uQKAdwQA2PnD6X_soLGP-QIFX zTI`I~RItQxeqylX*?}=2d!p?7eNacP9eeO~c4i_#Q#rrjJ{g18>e{od4KR7%%wnbl z{d*oy>#UBO1T4u4+xRuA5rw9WKn@4L(fJ^Rzq@IWX?E1m<9c$uSXouLn-2ul=#x=a zCsMUfT25tu_BU6zsPCYaHs5^XpNPZ2t;T*io9xFJfC1%jVD*yQ&*Q=5u5piMQa|W> zg8wJh8h`!yVxrTRF%!d0&Z@y?#o*h$;|$o~Voz8Mw!S=qV&8MTDxV?@Ir<`hwT^xc znm(G!+8_JhuWoFT1KB3*S&Aq8P{6fMX6BGgs3V79j42kcc6XcUAMG7k5-!K^6=lcv zLY`@A*swDaR}wA$np3IWfro@Rp(v(3^zi%jO~BAZ7d|Vo1mdrf>y>!lRMgICBv(4L zP^*z6AF6O5TxGG$mZ`O(4doF;J~-kuI{VVDp}&28JR${;$-S#NA8Un&Z2kCRwZHlO z#=^~^1_QJpe4^bJhYR-?Z{E~$UFg`{$`YjmwHlAT>ozZXQ9D)pDj2Ey^*1dPLpkcG zSB3v=u6_FyOdHw|amIMlf4sVa>bv^*X3{(&>AbncCiD?L^3VP0FD>uKyKIP zueU(ZZ=Wqc)!dU$-7vW()_SABMl8Cs{qA3m<)TM?OLI6}N`$iAMxlDI0gV0kqj)BJRLxK|dE?U?B?IjL=<8b~9ObD1%Se*4MT+yS&1pYy*>cG3iiM%9fat)@>wlh3UC{T(v8F z|Hbmwcm4I{KN=7Xq=C9E-NqNTVr+yzs>##UXTyNY^>@CAZET-$cw+v}$bzd`M2l}% zxBB^%k@IH@ReSRN^2Q`#Fu-c)%g;aMmw#c94y%8*y85`^=~ldG{BVf17$Xku+|u>ub-})?coxU!C@w{7o}vDK_jMeDLN$PQxg1aQL75 zn2~Ca-4P(hLN>}AJK*vkbHK@151)4ijX9}Ppq8Xzojb8bzxiaSwGZG3HNqY?x0bgc z*_DmwoBc-{&;PrTqVs{x{@UiosyJfEq4q)Wi(r*{{&;Pp`=LLmxnUzyY;-)|jIykD zkXThbn8Zi54{c6P#;<>Ec=Kd^%akVlWUgg-2_!Z4nN+>;;PbulQRz*SqkV%C!Xi@u z{SHkljEMGGYn8OmP`}<&BF#8v_vuLUqDxo95H96Bm-=~hMJM;Q|CnxAJ%fs-q zD7XyUP+ zRFx&08D*jHT^*&TF|muGMJ~?VL2b{hBtoL|GxuPraGHO>!tZG*$@KeupDiHqADwqT zdEWVt0)k3dM@MMK<~;e1)NAzeVVzS3@zb?O8_OF%%FR`w3D`J_WNx!N<^=`V{+f0)@y(??mTw?#r|O2{dGJcD8Q>LLc2f*1eIjGtClT7FsF(W=0*huK3RLZYF-tD z!TO8ll8=%5{fl8GYv?<99_%Ccdd8%7~3sdDt+MY>UQD}>R#yNieB2O>`M}dZ# zx7h;?Ll(V{#4uJ0aB_0braV03E?>E*Hz|=Wcgnz1`HJ*+OBuMX$nHpT>;4tQm*S-C zn?otOG=i}wRi|d27U~Tq+_u;HJLGBrsM=SP+F>VsdOPgr(3C=tHuhTa!;rV(8n0fM zPAn(mANSE2!m}txtSTqUEp6EBY5r!&noAaL*zFOlG@Zee#bQiPRs(f6ye|uWr5F{y zob04sHj6V)-sSO-Jt5(cdIFg4>oPy`Hh%^M`rqKA(6r%u%Q`ze>H7;|>M+(&4?7lC z%LVf-)8&5FUR#>UY6NQ zGm{$n?b?ADg@Mon9WIW#tkZ~z#Tf7Bn6WHWC_zFdJG-&<|&*=4SF&`)kGqGzNM zmiJoCO!kHa#L-%1J$X$R{KzDEDql>wqnVCNG91TfQISr`sk63B=GpVDRUCMh(ZX37 zCFNV*4Z3AI1oLthhSY(}!;9Zk<01s&Z1e$H!a6iZr!P(iAU7!xxYDQRmX_v;zjzf^ zw9=V*oQ;;!a(9;0F1ab^?%rLT=AZkd1>wC^JVf1?mvUluf(IO>fBmMJSVB9*t+#jh znuW1hq(A}f0(-2%!-2h=ya}jO{z?6C4-0{>atw~I6vxvJ5eVUU4{s~7lU{0lO!#d} zI`XTJ)su|N;&wN$yAFxcp{+QuC&(cXLT=v4$=o-7^Y?V4RsHUpW~nmw4wqm2asK{d zOHZQD|CrpyYa2CtCnvYf7MkP%J~S^@GkGhX-qK^Ze0ebOX9kh4jgDOW(EQ&T*qOfM z2QElcFxzOz%JQa_=UYX^-&!Na_++zK9bklQ2(VKMRr3SFlN_a56)hMOyRXu)8>bG-h>}#HTuTac--!)wd6JaJGJ8!H3@Em=zB>_d1i| zkDM4=5sHm9fXGSWf>V1?4ZI_(p9-Il1(n7?k;C*mBuA|JLh84>U^`%oQ5d26x`oNr zpU0E}%joqa<~!9KfnIu$yKUp}&k=yax(k=gGR4e6S-fFJ1B9e37H=LIS!F9;0aF|X ze!(&kM1)FpP@&^i`EGghJNeU0#SGRrAxMSk z+fc^j4{OgJKmTEKVZOpP^Gt58%E;Kl&X;ScnfQ9542=Ho^W2*p4$a8LJKS=Lmc;^$ z1&$r!fqmGC>4c(RW=T)Q1#_^=0ce-{<(V6F{xF6*J3QN;JiFQS{Rb&5b0}-if%`KI z>1x?3b2oW*xHn}E^>+*N{mzrF5ywfc-Tn(XcB`~)_qP`NQG(mL&<}NNqFlXqJ{fEu z?DrMA4!5t+8D?o$Aj&GgAeyq%HgRPI6ziWJ^e;|1kl1Ig(N;!|6kPIf&h(>gra7nv zU>}y$$4ux0o^8TyeJiOE&8<7yh_mypN)SL*h&hBDDbC86AYmoS5kI1=1V_KTBnPg7 zN{>G|t-9}%!yjFmG;K#k5Fft(@CT7?)z}{Tw9<2JN_0U2eXqN4xgt^rj&>2hKT8CM zE^h4L_-lKT!WD5&`hrx7lT*F+Mo@DF)U)`{W>8Rc}V& z=rEsd#=7=6nbS_LTGz;wj47Xh3(m}|R<7Piv_$JW%zqA;~T` z1#O=V_WOWZM`$DYxm}b^Z@85o>!gic@iK@(CNrWrJa_67=yr{^(+X1Eg-@0Gnd7*e zG1=N%RKu*AqeBci@QG1t=32Zum3-PhI(xIN6j-vntcEALXY9Mp zltPj_j60rBbomOO0TWPW+{Zb?LZme&#~@x1c+3O?{O$(UbZ|oM?4S3^kskqt7Bs|S z)jh1SFVz5bgrt-~zoyR)^Qg8F9;3d8NahWjn^Thyto*AU_4#_rt|s)Y6jgsrGSI z+s^W=o^bys%dAk2(Pw69)F^$iYSOODK}%oCSxhtq((1i}kdVPgjA|HVdEUV-ZRQlG z13D3oTgQg9XBX!~UA?x+kMGKR(tudDBYWGfChQ)|Fd1IYEu4GO2L>bUanqdlIg5@D ztZg)IbCrpHtq*r8oPcFCfhc)D?!7UsSUFJP$E+`fiTllr-bauD2RjnIgy;89aF2xw-x9It&kh8sY1( z&j<1*-MyiO6qh>LeU_r!Mr7+iN~4PjM$agCGF~KIb{+A>yutJcnm40GSg?)5g6tvq zTDq^5jxhWcuJ8S~@mabc?7tD>y|D91E0{q$=Q;t6YH#yt7uW6*8AmHWJkB8;!O1b& zeMgKs=An z?M=m`jO(}TF^DzH_V&5ptTVB06ZKVP1uI;xrHlB3Y%7AYeG9J);@R8%{j>gS6{oTX zMINd*%cGC)%+Qj!+V1O)sCY^OsFf0kKTZ6N_QO>B)XF$NSGgi3JeBZ?vDs)`JucjS zv@f4WoUDqLF}EzqHQI>tP$wuJzBhaQZui`A#YVZ!I7Yv3DOm@mI^hkJ2boK9nz5bv5o2cM&G?ngW8CL6ud@EF4qu0G%t_y|wMi2c5-Gr`Av+lKeD&Xw%T$rU~+ z@FGj7I9d2T+25Y(6J40($IahO^79Y+^+3N0H7Besw=H-9zdLPze?{9e*yB|WUB4jD zYe1f?yw4o2f^n18O*qxC`)2dAXXB(6&bu>&{nwGBLy3g})Gu6{{=M`q-gr!9jPY@B zz>z4GCAk12F8J~nCB=golky^k?2Gg<*RogtxVF`Qvb^^6<%V*C!<*XFkDG;-V}5}O4WzHm2(zWC?}TKr#u6bU+aXBi_yRPSn;nN{F6XH zOtf?UUp0yT!E^ug`F|DrU(osgdmR5?-~g@8|KGhk|LghxfABVp?aoeU63$*@+l~Dr z-lOO|dd~Uj-X%pIm20}rW8p?-)i!f8i}$>YixL97T&(1WcM!$rIpe+d?8)h;n?#CWA2^j5x>i)dlSG>Ia--cJUGNq_nke*^< z&mIr=BtyuSXfw;w|DKXUcB$ujM7{ew+EohP4|?6==W+7u3oG8Mwlb+0RJ`|LQ^`== zne*;;DAi3dfR)o_M^>Z4DOGImU=xs0lI5+N*(J`~lLRb}5TzEDmWWc5sj)>C2aDIk{$VZ? zlyTsnMg4PcsyDH8U%!^hCVl!yy)E*Et`xv$#9UY^N+9Vv7KztHEoHf_dLWEL-#t{l zAg&v*Y-uGJaPx$gC@lR6L&0nIDVr_IK6_0hL0?}tcms1tf_f^KMEZ;>PU0L;$pNN< z?>okD&|Eo7jWRq-FSA2Op?_+gUVc61DSJW(|>-tJkOMZAN&xB+`G>1fvXd z1%$~vf#}OBCD@fxEU$&v9{%$j2?vkYwb<^Bt{finy;SBKWOgUzdyH7Jz99s zEZv{KbH93Yhjw@F%r4AT&+hVU3DT{eq~ z{dXVd<`?hYi*HCT!_^IT^5x>q<9*3B+TCZ~@nVI;>V(UiM<0|*SIU=vWXI>`^Bd}ao?M=N zMdpWv59qaLu$u{4K``; z@$THho$OFgn$`E)+MbVh7nbhivh2mCmHhp9_s+fh3$dmjaF%kQeUEMykyb-bvn$@- zU%WT+_Ql}^*E$}3yt}kCm&lkMHcuiS;p5`mJt)&>{5TyuNXcz7);}&T+$nR(;xze+ zl2ZwXP234q(6_W(q{>Tl>fblZN3TyQi1_CCv|UWl<%c|L*jacS{xp^nGqXPRCi+wtV1GgIH#<-CBXL!pC@@W=Z( zaBjuNx!HxKLIbP2Z{)J%;oZgA1mo&^N)0+wnq9nqFB!oLa{Z3DXZ<4ueeT>TA1gBi zzBYGvb|LW^)&*%@p0Pc1bKq|Fu;C>P#qH*2=kMm{cF$I!;JJBEL$V7ShUH zc&PwEdF-$E93s*4|GlSh~ljOV##Y?%)8vFt9gt#{dAdUD`>mc4vKi6 zT`D4NMXGpd0};&?2L2rN9^I~bdFTFoa+(&B95 zz=oI8{75mcmdsPEHp^LZpZ8J=0tnxpY9D!YZ!Y(7tu3D}tQf z^9yNGQY?M*R%m+=(6@HU!sTPfKO$VZ|n~^-blajjNGD4OC=~x?xQ5dWD3aCUFsS0_vhz} z9=eRi0&kLXdbbs8@w8btqhBu<@7zmF$(Jwf+9}>a_Bmj_+x&36b1F1-Yr;1$Uxtpw z+a=s_xe@ucyPBoB`%8)WPxdL~jZI2B)QJQO1tld!q&d$PiYP<`2cx{a8H;?exKM;u z`Qj0`E$*Tf&)!2^2i#s>=q?^v|ImJZ$v3D=g;j?@tFTdedZF!BEiBTO_IK|umG%?W0XcCz^S)>Z$}( zIJ=l*iwhi)7?w-JCb)mMh!bFD7pP;n?Z5vRhMo^+%-5e6TW=MgN3r)leW&j+6B_aV zPXA*sf&HZa7p{qMHthesxA5!zuVekS|LBM29L1aRtN)j)T{ERdUNarW`_=!8U-wu4 z@2HphSO0J2Z&rc-|Kt3>GHf2yu`rHBhpTjolfsxp51RCo^5Eqe(JDN~615o+p2t_a{K$I0q~ZH%c$8E#G*N2&~^Akn9BsdEIn1dr-ll}BPsx=&$z zjEU;l(!!+M%N_oz#KTJH=*pl|&x1~FJWXw5iQkWjF`1N!Fi3lkZ!}PZW*09hwt~;T zJu6N^kFF2kthi!=`zM$7BjNtwK?ylkKk}{C};8urcsRf(K*m9=*)pO9h}yUBvuoY z<$#TcXO}9B#Kyh9P&aE_;bIq+2w)G`7rPED!_Nvi&`$Tf0M6Lwm=_dAf7Dq*Yp|Ze z=R1Dq1((D8;#{_|I<_mXG_AO=iD=~E+kH#r{WNS0gbH5*A?~-aNcV~23YtmSa97}q z))XtTJvaNYWD#wLC2AlJOK&WMo3sNhwjUj;yzeP)-nb~npW2+lJ{;dw^MfkeR{Vsj z>u=+}7>^>>J+V=?-pZ(KyR9Bt6kOY?ug!+k2*FfsQbT52+lv8zxuJkNW*x^7-K?_? z_ums#J(QJ4%#|>*uTIqFCf-md>S-D1;xqt*g)?j#4rJZq^P0QVDWOhBL??ZP0z2g1 zF$=prE;Aoo`f*{sI_1i6q_M6&ChSiZE0^bf8hLoD`vOQW=V%)Fs7F&xg2~6P4A1W1 zv^29*!-jo2V8*RII`VnlqL3^}3CU%qntyG5vy>BWrl(2Xz+Y?k1ppd}V6I|t59joB zuQ$r;B`8X$a@-8sw-&$;A~!Zp(+Gu)ZP+x=Px1q34Wmh(Q5q@Wc|{AB{9^d#n_drb zQ_CY!|9ax47GS=i`ioBQMj%|_B?pr3`{uf27=?CgC}P@aCDa>wPm69Gb*O>8bzIac zbbJEZFy*zv!o?%_{1<=>ewNKr@^ z{2Uj%joy|c{b2Lr10VxktJ$x3M0a#t8{9>+GHC2OxdA1HiYKYp`+;Df9%q-Jt!FPK zTe9G9r+eE!E!ufes6N`i?8KuVokmP21dv#J_ri5Gjj-`>8(W1p)vcvDYLW1nnUODS z79-K-x>pfoRRO?y@)(G2n1lJ0L5v%Y#-{7ew4@wbJWv&?Q_~S`4~MPWwgC(Y7@ZO* zH^kJd{5sCieT{JbTg%reb)qkLRvcpOuh$(4y5uvU5^T^fSU`g_s zV)>eSCqO?kb-RwvDhr9t*jZ0%g31CiVa3C14C`z~SjoLLy7~;kpo^&6;Q!FL;qLZg z_eRTnY6Z)5P3AEvFYL7IHkk_$O}ZV~>`k?Xq04@N)#laL7oNsoSy?8!G_8_%VARs> ztnfQ^l)aprvTRf<0NKTP-m|T;la4UlT_hfyd9s4d0jQpx>E>C?fm~Tk^crwByA?|b zQ^XU>y4a$-Z_h2lcVRc1T!m)wT4TOvVFO4ph6H{%$T*7QprCRcc83tqSX3nN|8+~$(AsF@fX>|c=S4P&H zMY5OzkVgc|;JnU7lKnNr9=&9fY5PxLATCwKlgmdLN9;g%Q#X&aYPFQw(jWq5o$p%> zPXL#dEMzQAQq%3U2`KGu3%lPXJBE?tNs~_oCjiN*pWipmi{{NI@Jk8^+eOM!s1PQq zY{yNEX2!v)Q)^KWO}pCJJ%Od08r7LEGcg`=V7Ci{Z`Lbf&o0fxU=tzH@inFlko;Bgj*f(G$BmtnJaZA6J%^x>Zss@HMI0JZ<;x2V_O<#m8Np!;2ow070GR2J4-=3 zg)!_O32s+akiatlSqkM!=!wI9 zm2P0%xD!%?QlX8yuUbW-*Mi`^Cs1NIkF|kx6ikE z-GK}6bVdsIx|8u#$?<*R2qI1)ZfCA=wAV09pI zN({dGzk(`^;oOQ@3oLd$D>_ok_ppO5bvcW`lFX!@QrkJcf$byY7B_O+UI`vuP+w<8 zB6WnMAE5Fh@fx~HYaKIsQb%BdIe83mO$XO1D;JP$aAszY=?vA;uBi&H)*_r;`HB{} zr^MUqM1hJeYWgdHc9XR$($PB#xs(L8EzNDvNlG4GWIZLte^G>~!Kp%*WH7U)w4a>k zZ7J7)-6TJU^Gx!;GdG`)W?eq6MhPN!y_+y-92o(rk4z&{FJl`TDTYxreRg?H*$)pE z!rLNvC}k)+w51k9b8L@gdWOJlFRVpgo7NzCGL$x5Er(fcV50-3fyl}@rC9<%T`K4i z%8j8%3DUC8GMjEk^tCFRQx`6aZ%qd&mNf}ShZ3%bdUzs_1G=3op%yJ)rLW zq??#M)CXD1K_sTIH#q8`3dh2Zp#(a_ZW6Z%0dG20pm>|1U5}7lUJU5qL!?-wcoGG% zbj{K7xa)?70Qpb!BChkAgl}v=XXK^=ng1pGz6Mu7BX{ByF^`$bxcu>UX4O(*2 z3u&j}RpWE+SNu1(m%!k1At`dFDlwfXTZWb4{kgn%T6#w*D*tr6OgC8Ku0|G zP)mP8YY)4lEuRl{lq(RK02C`dC|2E((boVd&<}mIm{l(Hm7<^y+kBSMQwsH*+JJlU zXm{pfo05xZ)q=W<*c6hHbmzl6NvKw9376&`;uq=q#v(WltGWxrxQcAi2lc7oJvy5_ zh-Xx`0|-I0?1}&}5{FVxY{TxMFfC7I+7isE&%&;;iq4qQHXchC zHT+^l8?Kt_&(5AmpJFZaleAshRUu{$|+{E5SCtJ=@E%BrA!1bkF^oFjx^%ujN?G<+-m|a(u5f^Fb&#h zn#~D3b0+#qqMtimPDvoOXkQ+=ks4{HNj`{kKSKlNTQ3fa#|~x018tgYzV*I`nwqDn zgZ@rCp7W)vwNzYWOmBHssN3IT@kZVCg9c$`>lAF2)n#r!cVBH+`D8h_`fO3#V}@{3 zXE(hDohuaB02Em1dthmgllR;wZMjj7r&HUmnz$KC&xOyt0~ zFV8}zbO%|;R7lBF1!PTVELw>nR1VEXBkB3mMY$oX|IDS~-q zl7h^*jYH(-`JN&RM@MvFD%Qp+g+=z7_1$mDpnF5U=3`X_JUz2JaB-ZHiSRwRDO-)g zH;d+++1cMe=~+cT@Aw6mG&GNAnoUZu!m5N-RSqJi73e`F6;_kiH!aT0OMJgtTU}jM zM8l7cRTn)?^t>eM%=}I7@cHF=W_yrt@dggLQc@6Ac~cXGGgDaxW9nGfD+!9HC*`jC zp4gZ)tJp`=)h)Z#_r;9jEV2US$zBc68z-`?@ynB*w~LD`Vy6Jx8gbu!lF6g@NWrk1 zvjGxIkL}m34p3;Bjf&Rlwzf!M)`Tv&$6KV&LQH)%b=-?v5}R;3*&8}uW4~!Uw{%hlBwX(1f~@Hc!(g4Dn&8=*3rcCc`eI|KK}Ql`dv-#WpahyV@5&V z$qstG^5y6kVnNXFAO>?Uj{?2ZdSVd zkso!8k137-F`{qdxjd_M6jID~-*yi~)=?Ye(A&eaGxg{=!?Rv~?DX0F{EBY1B{Fb} z6~slxJ*McHK$@U1-O*6OyA0OOEV~HhkGtmarkwXEs{BR~%}yUd6<#Dvs10=0B{Rp1 zEo0jk=i9z~(yMhVL3KSmh=T`+!Pan_GFpTPoEqr0UXWvKwM7Tp#~f4VViuFI?)vFc zDtJQC@<6`~PxKg|)ixfK;}prmyx_mqvwwolvTF)atuaZZnKD-E3nUvDjSJ}RHa|zCoy6iDmYsTs)J5gVvfPiKzw`(3eV63Z!YKIbAGS%_CTArT5+0o`Sidu|P zU`=}wriwPUv+ZW-fRmu~R%ALsy#L^o+IE0}kn~g!-p~0aIQW@vz;-=J+qmZnDoW|s zDheK66j&Y=3Qbhwh((Pu@aud=kB^RZs)MhQ4euzID5T}O3OaS*KiY?&aww6nPoa@O zK$`I?CP=<7iZ@x0Ia9cU4Aj>%y%iV=Ne#SHVqfr#JmlBXst}m+(kw?!`PyzO6`PWN zx_8<$7nz1*)QfXV8DqA%$j~v>PN}?jjdp>K8Hj-7+}K>pv?Y6c*2rY5LjqXSZYtsF zv7*ycT@Fi^wqWQ}gx~AT`Zub9AINyQ0BBmr3cEj zlb<#3J~2p3^f5jjLiXINr#dz9hj7mM)Cn9FB%%J5kfDg|XC$Oy`N}a zLuQ&6JuDw_u_!Pva7H(QN|fxwR8MzFfcRQSi5krff7FORI@4I(`rvZiFSiqvVpbs3 zAont*^69RHscqLC!=6hs(ylTQ#doBqx%(};p>Cz)yRFW$`OZ&a)vWN4jDyoue5Cz= zZ_`@X!`CO5GpFaT(Q>^lR?yKU>W3hM0bo|!$)!0XWNkSxn1u;H^D6+69|QMr8GFgi zTD%y=s=Kgsyb}%=MfVeQ@F-}6LOz_tJEfd$I}6?IE=!L~sUdWf5Vr0VRSnQcgZ#i% zzsH8X6302CwS!(FhHfZody`aCJwWxSNg2kx;_1QR>zOzBf`mM5U8cvAl8iC*6>}>rf9ix%*SXOB%P39TVY*`1tk`a9qXIaO zKQPOQO>AFeB5;BLYYI_|LJ=~c!FN~YeOoL8vDgoewrgSt0JP`;@KU1-DyHsUk_d{j z?^?QWt0mxK@bs=8$bzprM-68Rhd9nlyPk*b-8YWC5=KVorB3AMu+aL}73T|}Sj<3- z)N!$bk&D{7jh?(x_EtmrmN#F*A4rxkciL;v+~@ zc}}XA#ZkqE`C#(S@U`_)4TJ87uZ6CWkNfY~cQbU^blo|~b;0Nr;?+ML2C`(mF_h6f zVJ^xc1t+tQHC0%Q)?|ap_V5U;8O6R$&{yS(u^>&&ayl*yFRJ%5V*CfUA2=7G_76y95q9r%l zoP@SA!~lzqQpWB{p@uxyH|b8;=0WpfV|8Qo-(RkAYdZyVdDe{(tUO;|Uw-zu`*7qd zJlJZ9JuBzBF=2A5OE`7TYe^rZpRHb$t+#$yD4KDOhr`CYfaOzndOMT zn5Wgm0W7F9I8wsODw`nOK1W$4?g9_a!+gfiCz{Dy=*|1Rp<{S6;g@ESaEEe|$Cf&@ zEc{CtHL`w{m;-azMfJyl!en|5plZ6PHi&NYP33d4;uE9?x)xT3d4>vP;c21;AFo}B zkSL@BMT1pfO^dSrg%2<{YFohAdM1qkJS-QrEP4xWFBgE6tam5oIimHgP%s6F2e(XN zla3-ILu=AW!JYO%BsY*5q<8iyHfaH233OIr-a}2>`u&Z(abO13=#BHEQQ%LN!bW?% zY`a|MX8l~Aa2lWZxRB~)pi!F?svZD<1+*O7>kV;3)ymY<*=a9eU(Pm~&JyAyw90OC z7lgn750utmS`~Uk+A5wlBtQocJ=ac{=9}x|bz z1_2loBlI|ebIO@S87)OYkHKCA)|Qh^VS%?OD!tdKQzPB5^`I*j|AjOqZIJ~Z*o}B!G%WDXNJb$($tRJ?`ue%rh@I zq7JAQMC!vh$ajDL})DM)Cdw#P=Mih0Q;2nfJ< z%qHAT7pSB*Dr(Jv%xeR_-ArlfrksXM?bDXdsBm(j1-_eSudy=m#p2PdhunNt!Ko|F zM(ZVvIBE?Gzf+Wp^#HeS?G4~E)}XL8l6=or;&Rh5oi?Nq5tvufuqJ92>c&JZAl%}R zb=gyNgQFE4akSL9U;uuy%w;*c`#{$9zq z(40l>g(OPTcw()E)z+Gmsq8F~S|13*T|Cp1tb_%wWP%(VQKO1bPQ(AED@XChzC-Tg zWH^~QZQkze@ox@@*XeKomVMw^_dYXD{=ySv*=b8wLr ze(6B)sq(*T4(iHDEGSmC%k~QX{w{mew9LP9GPCP%eEkm$4%w!FV{B`+h{i409+WoM z>m*x7M=jJJlpQD?LtJR5y}of$j!c1C($fslGyPe@MNTm z0Hd2zp}4!0EsXBl?le?LH9cXhJPzw7Vs7jwVH@CzL}OC%8T$rq8_P6O?)M7t#st<1onxi{7?aZN$YKu z(g4S|^4JycTV`5opS4x0xubMh2>X>lGC|lF=Uti!>fw{!hKgd$XNWJ0Yb9rNCLI2p zav~BD&{R6MNDwQ-o7$c zAn)duWNM}1qpTvbY^z&S!J6(y)8O^AMLry$Z-iR?N}U^=+0q>%K&ChAh6)?fT*AeW zp!G^>N4ca|HOI2Sdhy8EP%w4#5EcE_WUB^6)={borCn-pH?%7^K1m7Y#Ryl598@RanF(cfL z*RsT97$H2QfLtDOJ83LN#j(Vn+T@~mU|MJ!d|~F3j}(qVn<9-$0cpksj*7h$L*(s= z85R+k_-A@+=EcX83Z^Pt!G8vqR&AtwXhWDQdOT3%Js{3-q|3OM zQIG4{h++B(@9yBSEa~Sqtl4X6-=#ssY-0zFlxvC#1fHRgsrYaEWg2A+EIZKs1J1mU z!2q0&0z&bM6eFd#3F-S>N`VTZo9ZLOn5}K2F5I{=gV@XjEoBNOAGma3tA@a2(;8)7JB(GTYA*Up4a+#&UTgJHt0iUUwb^;3QMD3D1->qFwVK zlL1+?F?DwA%#351=ceG08M6%Dr5t=V?i{wh@~~N0^EMFugF|xu3rb~6ivh~~w!*Pw zh!sH2(}BV6&D4VV>*DVMYO%SHn>VadQA(m4bm}(dkn3p5@=fX}n-PPn?{QsF^VBS89jgu!SD2ZxnK33TUGR1ozuFiy&^&X4W%c)RUERwxcvyEjMdK{pf2 zVbD^-u9%9WmZfqDx`v{9jmf?!W%9O5O34-e&tgm(r9Ju}{hlOLByIFX#neTA$uK-Tb911hk zvK7&Db%(a06Mk)elpW6liK)r2;C#{pBQE5#*} zhD6WS=dLncLSgD?rJ#o5WufC_exOzn1Ix8s70Z&+){~y`1!$;nlzp5gHUW?9L;gy>XdU+LSmz#q%_kKoQNxe zb85m*xMG45dJ&#z1Gp{ zW2gQEa;o7KgBK2JOs57Dc{%QIV6xd)dLj(l(=X9ZNo1i{A;198)vDWA9nIA@;}20l zxF~KTs@|yH)^@or4x@i;qNO%*QPHmWVY~=At@92=PP4CXlsYNTm~?C`39Yk(cNgz; z|FkO!9)}Y_2MSM;I;h~PSkU?Y%~Uze$M?lL|`dm&_TU{X015%U0yj{LKd~tC=%u zTP*5kCUgWkaG3Zy=#X(rGqOQu=}s1s5BsYigBO)AHjos|?OsmJuxDsdx}U`u&Hq}c z+YmlbFvAuk{@A|YpDJ26{K>CTwF<$1jj9P_J{eW3@aGfSiD-vo$Cd+%3gUXn%J^Fe zii%PgcI|c=Ra35U1Hu*hN%h!OmC#ugM9I^IaDHqUF=um$7+dg!7KsV*2#yfJejs`B zW%sDuyr*;9ooreZ+O$MnUzI>bvm;yG_}Z~L2iKH7gxo&q-H^veIm%|^-!Pt1?6Yl5 zrHnF}+g>JNl}3xJS;7O^B#X+F*ObK`N}ABLwFbn?6Un*^zA&D<+u>+hPke^HT7}US z=g%-2z;OuJflK5F16tsdWm=%k1em4g(VzR58V>QuE~+7^1YA9FCx!s4zbbJ^dW-v6 zU6ijScsAtqz~9*U+YO0`k+ncTC4yDslgOGM@>;u+$t&_r(rA%Cdg$zRtxLJyiW%DR zY!pRFQ?FKPwriP01X{GZPHT>a_!(eA5G;HcLcXFDP->0u1fN;Eb>~o zz&$BZm4GT5gAx`8m#<%QN=IPXA?N*{NKm;%E8+_EsAPYbokjM5KP%WCi3f@Nr&oTF zNfy-?-JFb~0hKYj?@PMC74O5|YbTJ+hv(X6Le%T?rO&+h?)kGH>BIQ5KO4)cr!xbh z=G9x_^_I3H<;;8{UQa~$Rg@j{N7Q1mwA7Em^vNyf4#g;eYYpWqW{QAd}!I4vI7ET?aV$;@Ek_fnv6_BCPc(qkH8_2^JDgLAlGbBGHD#;HWIS`YN7E zR&{@xE>r&hjNaB_{83`lsVkE#VcC zcY1YB)pDekG32vgS}jW|yr(dkwo$SX%0NP6%`0ab78O>c22zGHI+Dji!=QhQJEk!V zz9ym^Nbe_f7%4z9^$;*2)+unKwS%#YDM63$<^Q4vJ->vv zR*zntQj>vVKqw5nD5t9|--bvn0Sp}UXZxqvX-cCrtCw$6*!pp;#li81gch z1?r1NXJcM@(B2XjENbFtDD6O~XEyAoIl&O6U(FdtiQbeL1J8_ zpo|!*XgS~~pvl*3n|op@2n`Sd(ljD2!NLSakQZawJKsk@LWKU;b| zTG1*cSBOPE^p)x0Xy@E_C|t!2y~p>LCu|iK0YwWSrNJQ**$Tn2Rru$^Lv(8S1v&M9 zfPMgx!!-!92jtA$z&{vi%qIt?P{X@1XF^Lbd&83@N>Yl%xdq~&baOc>P5$uY(!ek{ zQ-K|5eK>uArA__=bOb*^P{nXSnK(x;+Q8#z)Qtk{gwi?D0(O@)|JH~@U#e4dd`$`n z00~&GvJ~v#i$yX#yqUrKl%|FujvGjALkST`21xv{Y>B5>^gJ*VMaBD` zoV9vJQ7T};14h|?j%6I!W?+gCK(QmVfJ1cYk(l8)emLx=y3Li!TRS;!sAb&wM7fx*_I;dWB~S*D5}S4H<|<|Elv+ zcqmqE$GLwPxuvjsYMZ}|#J5;UEijxR!50gK1Y;{ZCo1<7@bFPWZ$?2%h;Z&$iu-i3 zPZCLPu%Fcl(p;TVw|>1gaofuJBuqM&nh1LmhW}?=n|O8HF9A@HqM&|x^9*m0Xh7(m z4=J8$r%}t_)*h$L70QO8fBUf*I3J^2VJaw}Ee?i()wpAB1yKJZ50e?wy+>iz$DWpU!r|05r5AR0X#&pxx-h_!A?Vr3R51Yw)r09RL z_pV)WU02?3-k$mt^{C||q!!4soj8`0jxj-j^#3KPzwfDNrHSf2DTf}#!2d|`a<;l!?uPGfjdj)9zM$&J@%%l#& zsI7}y@y;8BGe59+9TAGMWU!T31v+r#K!wKSSDQi;#z18_v^u5R<_hMYg9_B?waQhA zR{~B{u*Eper!>bFUJQBe2<*9$)ts@#~5L2f&UR8EkyDxAMWzTD^*pNj~ix0I5b9% zFqc$=e(QDV!Ezy^ymS#VMMrDTDqS?XXLa{3fS3(ql}e(jL(RQ_Af+Y8ItEU|z2*Xy zhR}D@Rvfl--HT_$5FPi}5$YVC-RnZK&BI@@SwpXpb;2ys*}A*c2HL@7cGMfJNr_Yg z6K53)6nPUq-jcRL29dB3hC>A;I7zeaqI70nXq_)XnV{8rsW!Le@)OPWgfY)Lp4zt) z;-SOZk5{4_ZRjziH&^<|AHhts&^m**pAgpyG#hck%<|c~0DPccyvizg~pfT%|Q|{#2#Q+VViN&dkGHfHm@j^OK zD1qRMbZH(;QpyV{SL~DZ@KKqP>1N;{oCXUbvJMf#N|@G_0Z75wo8oQ^%OW4(MGNUl=1E2uxEljsjn&ih3kDSX^}dl zQN&ZeV^Q)Acf`F!FKWJ6D@flq`wu&(*Tp9?2E@e&CunQf4pKfIbIFuxmfq{RZKMuCVzjDr4=BG7(dLb{n~|v;x!@M~G?Cb+IS+6df+;Ltx_bs0DjP~i;Lg#t>Fm{9 zU{WrJ?O_j$?JE#Q=1=nj@IVkn3hsR)%;RTi69@X1DJ>CA!$T5m-<_VSMfWJS3GY1V(+M;%t+ph0R%$BC7m%xlqXaUL20mNENr$= z4V{b3P%}E`v%q``L~2Nm>sXL*I(%#!pHJNLld4xTl;#NtFyzdF#z;p;opqAPgY1hjPeyn}SA50P~p(Lk4sby`Y_p z)T`Dg;23~i4a#Koh0AWZv@s4UZfaz;z>wmRYR}7a$TAotGky7hBXz6~pDiqq&tPM^V(=6Wne9*gQ+%0yp{E_~~o3SwhosC+R&# zn!cqPOs9a~Lre%Mr87y&H@Oy+3Qx z)VCKf=LQi(ct7FOEvwW$>!oF-sQFA?@5k=5K`~onWf5z~6U1W81_qwpXRxZK``^p! zUfKtN0uLCy%T4OZ;^@^fS$p$33q{}@d-@l@pT}<|CH&C-R(9y~y)!aHV?p+aOrEO{ z8beG?TUc@Mucn5n-8066#I&hYd4bV);Kk|b_!eW2V^Dv~@sl!eguRXqgp6D8ik3Lm z`o>z=xXtcIiHBA-gG9g5&ydI1_zj2p8a;9{nSmSA+N5-U`Mz4-7&pTNPssG6EL@MM zEcyf+^92B$yOsfxg@Pj+4SPVEm8hS{89jH^62H%Y8ed?L2wMP3O3hKb-bss21u>5F ziFA*BO5xO_RiZYe{enF@C~O_NL{lk5xBK^!^iu9>A-s8FTUFg0V;!ebvTsLG4Sdw1 z-`Q=fLRZE@K!wtZr<6Og4E~*rcs2aINAik;U?iciiR4`2?W~uYi7VhQyD5uye2#UW zM02XLcqly=q73$)o)6u+XMVui6T86l3KDjF1(eqa{RR^(HDRUt?A{)Cqe7sNr$FgVTH z6Lfe7QH69NVI!qmsCTdFCaYUv*sZSSA?hM=KJtBs)~jlQ!rb}G4(Sdb*CUSdI}p`+-3-ed ztZD_Vj1_!<h}A8GBwGFi?h z(qr9yoS8%t#kU)uu94t@$;qwVWb^jy{>LVR^Gn;3X~r^q=^7jkin@_CgB*M($seUN zVaf$yhj2O7M&9G90w&aI+t=78N`uV&`!Pa&m2aYwLH>flh`B3QraLP(Hg}Y zm95NmSR(KpsB9j83a1>CaY3BX;kJcM5Mmu$PdN56;3oC;ZL~{A&5v5$NRjT0UX2^q zj2G-8`$DZ;c(08EYG)af0NeL*vK&s!I2qU{YU6mFAyx>DhfW02oRFOopScfFh3yn_ zXZ+v__H`PRq7kb130I+$MZvRP5_9Idocf*a{G;Ilr1#nqK7KM0&rbCNM|=4uS|8PmYo9V3!Ncz zQ-G_cQgFVaGHc_&*Jf+Fhy`ooLo`idG3py6AG(_^nLsFvZ3q-x8HMxSBHeE&=Y$Qe z<+hZbjxs0_a2DTsA`0oaml~QFPc8Pg(2iPTEG-i#Ddi`c0Ent2&apdRqnJ2UGVr){ zn-*Ie$OcOSIWsh>IG;$`S~{fMKN@jpQLF`2@U>lDu~sJK7BKf8XH5(s58b(L2J!_7 zWq6{dbC(BjBNOr`WUS-x9zY9im2}(n7{!z^zP~0c9ABKC1Z>`ostL3J!4e7O9-X;= zr`RmIw)VCV_wwNP$QydQ8jUZzC3P$6(y#({HD4x>YEG;#vES0n3gUSf=kJuIh(sby zL??wV(p@4&ijt*yuq@Y9N)*ZyLFkT~$eL(C4Qqc3ynTR6mxfDn6f_q>sDe|*abGne z0L*zc({>P!%X<(vO+}aLu7PMMYBD!oL1gY(-DQbll86DJx@HrI9VN%I1bRCNU+jDh zd8=dSFPGKNoXSl33ue;sDUF^(y-h=`?cQ6%Sk~Qg*6BEDs99QgUS#OW+8B3Z=JTu`T45w>$vAwaQfY8nczx|a!K8U=g#kh1N=~>{)bEu!Yc$8{9(J~yg zkB*4spsc<-UA2}8gzOcVRem{C%LVGmEWUPS7J^XNji6)p(};XJ@EFHdcd$)v8L3Km zjqLug*mB#JNPe+i&Va z7hR1b%>@m{0qnw{v~k_yYhGA1m(O%xbY|Za8?|PgqbP&&Rs@y&Lt48GWDIGaij99!7$pYwE!zl9~r}M}x3t z7yin|Jb?B%@|TCV8-L7sgch>Gk2^ z+oA_62}H`#ONgP8H7_%G3Mz7!eaG313Gp6u&ZvOQYTz*t0i zqE6`oQsDy}*d%B@au=)dkrKN#*>EQL^`j}Hn+|af4>U(rh}OWtX4Msw7H~qv$=C9ERZ}9IDaqy!72Bnl%Z1UjroI<75{Zl&W zM)oo1sk1=LeEo7^1Zinz)E9C8NPZaSc~2dUQW#+t6&5 z!0^g+_mJc!<)t9P>Gbpl5AUL1Ze*KXu%Vf8)y3;;WF1I0k~)J8t;<)F)xs#9buF?3 zR4^N%ee%tGCW$p@2s9N1#IdzSOTj6^+!gnYii5}k5V~^r7CD^iTYUQV-muY<_^zt$ z;1vn~{+WeJQGF+ct&l7kL@DHVPB{be%YQmO(gu!ZJQ&h}ZV?J;k>#ABEu4l)T!|g( ze`s*1KtjrF1oho)QrGk$hrH$j7tA|h6n5Yn!Cw861(rRg;6 zRth4Rt_ z=U{rJZe*07K!o^GI|E8I`ej75$kK^mm(^HX9ul~#x&R_6&Fh2L%&r(kL@VuJVm`s? zwep97pfZ%m#nh2Sq?}J$*d%07^T)D)vQ7I3y&yYj?x1gybwZzhL_a-L_V?Wrnwi+K zcs~2NZB0WB29$&n-oCKjAvcx}raZ28t{NqeTFm?GER>Xq;72oo5OsFq@r6DdP{7wc zhS!EUHXm(m7J`}_1Cxl6+!B+Rta8Z%W0Fqs?i5A8xvf)HY_$T?(WbloYIAzA6CB+m z<9tM>YG6w+F=22@WsFy?UGP{veGz(TLlWr&bw#9jO0f{ZON#?yI}TZlV%gzf7ju_W zkV_gckB~*yz_iX9m^)5cavVLZmzYVm>_mB#M-Bw^fSf?{?=#m!oPF=P4izPL^}n#w z158vclUaqg_NKj*lT~^G=U2+lqh}OJ!Z&WpI@P{Y59k&(kW^eF*Esw_kOTk~6+Cv- zNT7dDS1K^<{GB36!r)MD6Iv{M*DXYiJY&*e-dMV>DjY~x3sX-j(G!0~Y*qqESBsVb z$~3CAV<$fBCL%eBdewtT=*@LFZ#I2#5k`CCW!YaC`SKn-{f3inVes+j0oV>gf>FCJ zy&7TX(wy*DXlqrNSk4AephfhA>)DR0Zk^>wK`jd#X=weEk$8{U8tSm_Kc}w8iCWo( zKc*ZiVrWkz`0S)=CU8Q|=?s#JzCD-U!vWBhyVj0`8ce3zbPXI~u|9tGgo<8{R558& zaJ`Hq8K-qZaAaV@@@3;V0^kz~V{Zwr1k%L8xWrQ^;^Etx3VYCX=MY65y~7of_+kr* zqm`?tPNI(=ad|ZBT8MXZ!xhTJh&hmT_gO@PK*sen_D~^MN9h%DwUpsRm5;Ij!qc~s?rvKxZGDgdp)=Ek1|E{XQzhrw+*W*(Y6BSWhN`xKwVHl?WuAgi9{p0-Un_5* zN%c~8s}8L;U(W%Yh*l2rEOdps;O+D5PY5F#By$7+AMj{1fjLyM?OCkM`mbJ+wD(`W zp{5OLiy;e>?pMSE2Qo6X69GHz?1nzohJKJYneYrCwU{Byv0slutPl`CxBvfe{BLYO ztDmA6;S(3=?`LU36^VRveMQd6o08Lyl0}TKe-p0&z+h1bdCIbS(Xy zQr!yTVBsOz5z(eF5*-o`K^l)?#%T9dyMh5;YOE~DHJRNM;&v-es9Ot}UyIg)TBgWo zn@x{_L$gV#$R~>j*mE(Ej%cfMRUd1}*Vpn#eV}PIH2DNz2hhwVv_F=WNUw?#xhYt^rn1|pv?(4OwB#0rfMX2D z8NECwq=@J%9O3154AvTDWP=@2k}8Ilb6UeJ&t8~oOiyuxd2vos3$$;la|6~%)gV;pZ;q64_(Bv4MEWq^Ng2$-98sh zD>~Oc_@D8Iot-eiEsj0>zzqxBvrio@ofY{AL=kQ%!s9sB-L>C*8R0cVK4Bi4!`Oos zZEFS=iH*5e0HR_||ZukO%1c$gYhohe&@v=FJvuqszFwe(vt>h8jJ`zgrX!g0};?AAluWBMi= zN7adJM#AU#)3slJLCO@3qM8x@=~o29De`~woOsgRufF;UXBUE3@`g=~ys1YtX4^YP zw1|HPXTLrEKF=-)J_O>%>Dv!crM9whlhJrAkQ-ilLJ>r^ZN&AjEZ6}^}{QL zzkS5cNlrdd@U!au`iJ9^{W4mpenrc9iA%48h1+rh^#Mc*mZO5@u!ecbd8&N^v`Com*FWWrzxk-;oT_g_;!8i=`j^ZI2e=I50p2f`ySQFO0bL5j(r}5j*?W zkJ#DT{mlpK&mQiMe|PuaE;#2M1@@8ByWyDCuIkMT-V)wFl-9U?I0Z=kw}P|=Nh;)3 zwf|;vQDVA>o4cETee(FPo7>w@wwEk;@j?f0_NHm`@yDiOu4;llUfcZB(}_%D z@$TmKqs{wU>${uFUt2WQ!>w!D)Z@5mMlHA0Y+) z@DXeK!$+*`4>L)YR+S4<4?6cafm*>q}m~^t}sT{ySz?=Qw3* zU9$5f@K&7ik~g*R4f%TNpaiUqjVrtb=UNEqjVo<;*~?GE@*y z@AAq7r>9S^vfL#TK7D$X9dC`m15V#HIFMg4h4mha~E_`pi1RV)pD82aNcU{Bb zEacj&kny|C-OFCn@hm=_@BW_CAqJx`2C%-6l!TUgCR5k7WNf=XUcTrs>S$l~lD;qR zUJ*CCMH21h?`gN4GdkY762UH}zM~h1|8<2)m%V%?Ua|D$t4zJ*<*-&RTY1mm_)iS5 z%N_@|OHlaX{VUM~~toAzVHAB9r-;3~j6rsO3&K6+#0 z(f#k9tUtU+=lqUq>&?T8ZZ4Un9_z^KDnzL*&C#V+7%lTIbe|L$rb98&-oALj?Xeak zDsW!m7#BKGG@>Hw7teda`9IwJe)HkQNbq2Ij(+3f`7VIclkf2^Zr$I!01Xyz^a>E- zU>CkiEchxK(-Pu_0aG@9@rE_CA8Vpm2m9pN?$c+xe|_>)IT6bT*iZ|d)0bQ&LmY8i zwLW@TrEHX2UnpKQZ9dio8uc=<6gO4B_+ZELIzYX+e6`Gpi?r^uRu8moU0cYcPyZfW z=}Jb!GEsgtBX|iFY(KhWv)=KNmv{cS`S9W8?+?r?x2L}RogF$Ybh@kn?8(L}l{b1A zXH{PpYc(4An(UYuHt@S&LtFH zKG#d;-kEW_Ud>irf;hW>kJRVotM#gyMT_2v zU3lXAtEs-<9dd0Lp|I}7E6#a8+sS?Cy?Vtt7rmNI(Jp~;q?e(F&Rd>Wb4M(}57L1T z_V>;XE+M2J>ao6ARPSE0^d;1AxglqsaKYPZ`1A2|PcM0OIUWCb{YoCb#blwEui%MY z^77TRlSME8|DWC2ZsDPJwu%NdluG03 z>5EEtncMR5VO9r)o#{zm0~ zxYac|2(K@t1-!r&&2AV#$sE)Icb^@;+h0?AIMP=UyFPo0VwlVV|&!JwILz2nwIAcECRy@S4V8ayekRinTuuEr5L zS)IrS^R=spvX7E28I40Fzd8%3#Ier6YkHCC<^njG`EtW>H5Q1!&B1h;duXs1;OT95w{d88pW#Xj>|EZ zY=9UH?!3c;Yifnk_ExQAsM{b4#uhp9)>@nKHrwH{h#I1|7Usscsj`oJJsRd@zdoH& zZ{1)A>&zQOU1r|R79AOWrifYPyY9N9xBD~}_^nPIs=;7dk;#ia?x{SYxX!(nj9!5p zK)p>(bN9n{>?XT>(4i?W*@z=5I0IOfUqcMS(&5M~hL&+G+808OdiS4}n_|39snN?5 zm41!7e#-4H6K8uCP*$r0x7CUR)X~Px8La?)>rtj~j(Z814#|6i4;V=2W==r46Ns_LMewl4fBn5Gkon4G zV5_>3owk8Ae-n*>+x!W3jvD$2P4#$VI`09FiinR+&!=>(Q2SLrfhUOlch8MhCii}S zgX(`x&@i@D4}(M-b7=(&&da-5M=Yqh_#U-4E^uO@EhAy-jD-H_wY49k<_B{*IvYh% z)w>UBP{dwS^qGcfGyZ}l0vP@{{IB?}kR^X<`Fwi9$6RVhffXy4Yd+I3#299m9czwi zaAw+z_E5oZBv(XFYMDi4x|#;O#JPhc@y7I>W~nQP8ZwM&+uTs_>zQ-^zZx0{TXrSR z)LTx2g;?`0IJ9;tMDa9M2ZOJrb*C=Kg`nycrXy1=6&pPdW?-DysapJ+#X;$|IP?09 z1`x!sciD7=5T#VY#q}ZiPkMbhx7Bi%BK$#dNWBv1Ys?$$k2Mrwb6^*!coO2Mb~!J?~Mc7tLR=?g-7Wm@AL|n$~>H)F)0GIM@WMA&YoGp>q>MFf2P4M0b(Vezu@X zEiJoo=r}bldd0QWR<2PsOXC>iFkN&|51>c&KY`k%!}rb^022@r}%_bBmzt z8%gy9^$!;SdKtNiiA;4KZo;phi1t1%IG^)61la zFxu!EN2!kFzM${gy*|$A@rl$1ci}DW1?N-0T_>x_2%M>y}@- zO{mgZc^zY1*4Wclwt_>(=YCSkTiuUZn&oX;@u(vd0Es7)G&L(*pxaAKpWBTEil}r% z?@#F=sKP_o4Q^5Hb#-}&h~msjo5e1T6etv>DQbeaYe{&1Vh%&=JD{ZYGjJOa1^BsZ zjIVnU9Zc?sE!Lgl{=v{N)l*!>TI+tsB zK%Mo|B>rttWV=cz!=N`!Si4;#Lv+&Wl^$(nG+~{I8g{fMAH8Ftj98Cp=RzIS3ocYh zJgcJHs_*9evPSYF-5@aCr%V~~m{p~1!j+)FJcT@*q}vJO+z=_o{@2^RiF9^%9{!8K z3gjzJrjl*juufJK|gxD5ST~L z_T^SSoitX=107U;b&9IK8)Z?$p%8kps74n){YC}YzqDb;8hz(hF$ZzVJ2VxA6V2EOHjDF0a3*5J%?_${B6DoR6PD%8g-jO95-qC*frD?%P=`D)DXnT0F=!YZXK7w+O)N(CE!=oR3s6H#j{wCi93Lu}dG-$!_wLuG@ji;)H97IQZ=ANF#deY*#q zyc7aLp{c6cY8%1=9_;J%{T2370Os{{?WiHEfGuV#rrUwJ)t1g)Rpu4uvRYv)EBKI? zu+bqR#-!U3aJj;=h7gT@N8twvB!?j0(2{Wp~aqz{tfp_3^Y5uevTRTPT*YACa(&^f(JidQHXdh^1!S&tyql1Gc#MD4+ zhA-{!k5~DhdOI?A$>645t3{b-_c7Z2U4y2c9 zsNd2(C>o_Tx1~!weN$?Wyetk5w8a?l4!J#J?;~`_z$w0|_RSm;&erHLjL!znQ6mBq zj$o1?k=kW-3PC3CgO3YIL_aMma`n%)yq>l!EUfk2Q@e_4)d>UvIZ_p-W2X}Ei!l?3 z{RLLnYue)Dw85oUi;7#@P?w+s-FIolD2AzHZKiPcuJa@DgB`tpMHjrDZnzqrbE|XPK&jPxN_xofOSbb6#HKM`>jx4#@mo`KsjPF2QRGw~c z{y)#QcD8mmcVa_HWaEt|j~=Z*PA5-&=o^4Ja(5kxz<_EGeqtV)1)5AAMzBYoTYzF7D+e!0e8}GD=^ezvDk@7>v z0`%BMIz(_5oclne6&rlxA&x<`7215IQ(+oef$YculR9J)i zE?$OYf(>IM$;ygZp{eG*3VkhwlU0x^E-gis6ViJH(G_V>(?F7+7*& zVkRFSy~5GtI^IX?w%X@zAB-bfQn|bC&)F| zgnTh(oyk~}t(j?RM;e`;Xt)~)Ub$(R+U%WS&gonwJJa zczShq{%XrzP-_c0IUR{MV7G-UM^Gzq-=n-@B5AG~koU0zC?&hx2{=HP+MICR_AuAd zM*=fj&zG` zD@~>8*#NOC*&09N&`3^3*XuT+|?(AIA`@V}$i3nIV7P3QzZy|uxQcguvd=N}$ zc<||T-qt(>0;{_7{D{jdBG6*2pWM+KcX-!d@xoRx8Frv(@NizG;wI!>m)W0Q=b^DW zh!yE0f1y~8DhUg~XrQ^p{pabcli3B1a)IqT-g?4~GatB72UefmGkueCb`PIf1B@yz zr}HXS$~Tx7*McG4y|s|Gg=gh5z*lsm7R(pkKwR-$!CvoyXro24_Pp@k%|AYQv>ABO z2+u(8Cq@jfk2em7`lo2&kY7d=49raB4X#hj2GZ!bl&wUsr(*Q5mM!D~pUKAzi~m_S z>NIkjUyt=#xVAJLX%5_a0*bZk$fOvRyJ}Ly+!zYWANiGcNnirQ;7K4S2RjO-wzJeQLZ2{h47KB zbT4H9$5!DX(le&71JG_0&VG8n?{1$g-_Hx108IeT*-v{%r4#S~5iaVcAm8`My6WPtI@gTH|`dfAdo5<5KLB5`5i{ z&=p&;c+C=N;8$R8X`tIv!#xnz-ZatZ^!b14ZXwHrGOm5);!OX4Oi)_V-&#AJS$k-L zXhE!AcW&hR2U?Pak5y_=`iCSfqWe-Hh5I%)^2G}AAjtG5>K1u%c?m#V#sZERL=s7( zkY(2J%oefO(3_NEkvB6&b6?+TCvva5dDwaj`unqc>}`LDRmX47#;b3~*Z(m5*!MNX zK%>#FavQvU_K&TQ%az*(XQS^O>}i=_qktc#$=8o6j2>8r;B;uXhQt_e>iQn6sQyDr z!&}*f5jQ_=XW~t+qcvby8ig1pAeB)G3G*dz>MyAIh)2z8yVq+L7$Lzz+7PYg^381* zsbOK`2-Y~U&^bXpyzNe6)P=t1%?K^Kvgg$aWSo-oV?^VSf*PFhm{PWlHlF0;+PN_z zZr{Oy=fq4Dp;L4g*ol}{nZ6D&F|f4hDE#aVBX2|;m)ZpP(l?N;Ns$W$%X?k0pr~@N zme7c#7IB%PxVSH`9(5COLRv!OX%d7mW^N(k0E-F>800ctUtxv_|FJ1fBE1InVaG?W z#??CB6?qu#RBNE7ZMSbq9L)2(9L$1dsDn@EIbU(W)m8J6$C${CMa_8UPxj=|(sdH> zz)-In6gtSsXzaO;$w6>>sqimkrP69oq=W6Kp(UiyeHC6sUpN!P#G!C0Ill2y`Yk(! zVcktL#ew>~GZ|l}l7@u!WHRnK@XmW#M;mxT+QA}ZMLrXaV+LSVCt= zM5&0_%fM0k#wrvbrv*s#4Xzc|)^#NXmm=r=fi4f^%_V97JLPKvWQ`LtJ?kw zED=u0hsv#e5yc4mj*H_M*;j@LB_tet6CzQS)c#Pvm8SFJ=q2X0qbBJ;vKUNeW^uzT zda}cFQhK<+19+|1^<%MB(0zI&L}oRo&-0c|<%vv*{U4zE`szKaokdxpRfw;L`LD$~ zJ3I1LPTzvXYHKe0;N9W=tCJ(C&*ERoY}ZzR=4evGby~9zJvp;0C+65R}G`S9!P zJC0JSYg>!h>E8Ii&UHs<^RY9}u4DmgIgA^_Zpr<8%cs_ZVQ-DzHhvpt6^mVd6bdJtWvp|?*v^|d!ZDK-49tlO!~!ZSCL}!PSHK$0;liIDm!DR_2I`7Y zse?;1lY?%MtDV^EsWDHZ(Jn47v>B65@CG_h%L>A;7S;}vcQ;;x*(lqGUWnZjdzimC z`B#gGb)i-Gy25$IeoH>}HDHSd=*HPDKxibsjO)Gm_%bn8#{!68@q_ObpnGiY-9OJsqg|+El9ppwYx`TP#ZqGHvF-)uGh=C*<&QD?u z+*8re_4%RApu(%7JZ6eJVhvr?;pe{dgCun*j&&f9NDqbZ4w_##hwRMy3dlVHZaVk5 z4YZ@zw&8s*m8#xOq?D$OQ9sj66hHu~GS`yXEcwNNMIIE^G|3q@-*EKuhZ!gAsIIPB>8^2yr%?N8QDZ};$AOJ>b0 zf0XG?R)9|@Q9L|Wb?O+rHITH65Q@dGoYOPf3BzX414bflovN`9ID77mXL@@Cw8H4> z$Vg|CN|%B-<2jgl!|hBYxdXKcA-vXiZy15Y73%E!Mlzfi$_iCdG_oZO`xdG%W!H90 zZE?I5Rv)DeH+^}8g)HpD7DL1w`~+vCX?@{ptC(v#ZNNbouz|AbtA@~Krl;C4C&o}v ze{s9We8u+gmFK~^+3jp*t5FX>mx*{6+}R~`n7y2|lAd{;pTP1z$w9y(*3X(Sc zv}Yhse^FHB0dL3cPJNYy4MtY4^-~*QAgWkpkhIk@(&i4)lh8jqORHn8IQ`w49r_X6 zuXQ*)CH%kt>e{%%SB9W8Yg|Zs`(!06=?C0q5%7h0+8Sj#JZmIvekj6Oqb{dZhIS7i ztiXzz#4B7Csg(CEfmbPt_TK2O>)yZ?t)s}IZ#dWEam+#z-hr-V68>^fzR6W1#)7T1 zN)zh&b1UyS&T-&qh0=B$RJI8s$O=Xt1V|vo$eK82!$Tv~^f~(jAP7(&hA?0qv+Zbx z3s^S&6=oC$W)7tY!`$jzf((NJFS!BaOyA@VV;tty`6Ks(0%OO&gzX!$H;d7 z!%-^zEjUAjQDG^>1t|bF3|&K9?D7ixvf$~jM_bv-O5f#c=)W=Ei~HgS+|Iecvv(H^ zH&X;&_-`sV&p)m^4=&WQhp5)r%`6Hef9Yo1@j;D76ZZ_daWDCmDimIM4eJQ0A-Cz= zNSFO(eO%0-`TImKX+M=?a-36lVbe}&XnaPb?<38Z^YY+;JoNskRR%@mut(X#De3fh z+GRIO{JJV+KrVd^RX8XcKb4RDb4pmraI7IIssnAqt+{CFi49hY`b#c?Ht_&dORB!{ z9$Hff9Ic`9TaY(qIbnJ?FYca42&lk0HJ_AsNviaEL#2JT*vuKAAx(X_zs3xyhASW& zHw^hM;Hr~|xiE9u*#$??4$z04Z4L_)H{fj0;&ZJm^Mx+W)6`)BNYsbF*0TLk1jSj~0@c=BGTfB~bPR+N$0t}Y{ zhDp=+n;B!#tge`pcRrdWtuBGA-B}_|v=y3dAy5&+?d}*d2SAumV%K(;Gu+^|XQSt+ zE3aiI?Lt*VE>Hfo1@iS z3^PRd1Bm8g>47Ra->4?H!vwi!Mrd&&52Gk8?#nPjc}@#OWwj?rtKueI{JK>CMY(U^ zHzQ>Xph~x?Tnv9O9-FNZ)0m#^-&>ZVkc~@G5pcgRju9w%Z!dzdFj zrD28pwR-#65#onqo)ipn6s{mPAT^`|W(kflay^orE7}^B{>&6<1InpPSs^S}!L@Ob zJj{KPKp3I4DlPy@D50o=W+3B_`}&Qf7&qhB&;c)HY|W0~1Hr z`^cOUs-b*D=L1 z03SZy_-y<%98_a2*X3&6C)-<_J2ygoOQqF^)dODtNw23{Ne@;rL=GM+4Bpur>2`l8 zA9d%!=mU&nBwxp>c)YFr*F}69q1Ew8+{GO?jko(QazGk9J*|r*=7EXPXOA($EYh;G zAsiES8^_3V2RDShy*;BeOi#IpOWc#=$Ho z7Vk*X*Yu!drA;_?ArcIg?d!2z^wmGXgB^^wm(>A} zp7zUvowfadiAtgYhP78WVqqd#h)vQQNfUX32&Y%D-4*mLQDZq!*jDVXz&r!8fm*~| z`|oIokfIG}NfX9rrt}gUnRXMTyd6L+T?BdNDGnfO>QHOu$a0I=L!eqO39AJt*wxD9 zM^_Pl+Y6w0rx8{*H+p{rBXk&JG_#KRX@Z6KW`IM^jy;Ny$jn&4KX_m7Wm~DVFYuka z&9$7HM1ujN0KUUXD6+8Uusa%VI^r<9GjYkVIz|Udqha0`-kxx9W>GKIVCl^%=MTvS zBMXyysPDhnJ0gW1PIZ~SA4>2j$zE6t&7~A=WZMu=bSBB51?ulU0y!th=ob20kAsIc z0k(D{YR^T7;ZG6AgOZRq0mhr2q0e|zF1|H8><4$!OjfT|)R4JUEzP8{H zwf8rK0Iz&pk(rTPbjEIEyY#i5ZhXEC(D=xch??c2*XE4MI7LXeDoYFgiB__7U`TTS zHyg-O?|}PgV%HkGI90bUsL9C!ji1%P-7!e;V*>C?B20cLaBd_%-`}CsgebE`h~eT zbG=p*asb*^bgJ2fA*6AhX612y1V%l_aC#NuuX~ON@+guDI=l(d1B!@VS-b-p`puxh zfce{_b^qEs3nSwAaM4okX&P%7v&;Foxiy^!(+k9+d`u&$J>Mz5DPM?fqr; z;D+a8Y^o93Pg3E9U!Ydlp}NpfdXoGOV%ONK`X1VW9l+d@1|k~{of|6Dh4-P0C+`~Y z7a8Wz&JG?A7toliXgU@>-Pe5xk{(O;;b0%%y@z9ytW~&;54En)sRbdzEed98g%J*~ z4-el;pV@m3-J+oG$%>HgPqy7pN4)@HG6(Bvg0PJmXJ*`83olPE-E!8J1U3c8=IJX} zOJKR!mKbK=2NK7n8L5Ai`H=GNGf$`iOExseDbErz7wbc3(djX>cf=R3b)CJWi-HX? zYq4k*ClUMkNeM(#T5|w(6gtfin=))aUxOfy2Li%g4#zHX^TK1PY-&w{<|KCDuf?Kr zqlE8HLvDY;fc9u4w~nWWG8G3zw+tg5r&ai;@K}s$i-dTG8&P!mGJ6eDxjv_iM&?Mx z)Im z_Y#u2w1tx!I2f~aWh`E&TBoHyPi+6P9{r=gl#9_jh)B~tp9S45O?<0O+ktJo0&0t&U7jKZi&{Dp5v8 zuz8RWH9CYQ7ueGqrndm!a;r9Kp}_haI^0;mNqWNsg%{^y(2jKp$8q_-alrie@aM>i zV?S?IaeRb17D_frU)WeSOz`2_fI)48>?^+}Mt=hIXyA(bkJLAlZK9J<1YeAM`hmB_ zI_a3u)8cgWu(~17JMaCC{Yt{#69?p%{(cJ7HnBc{X@v zqUOMw_g^TT1l>D`G&-m-wui7|xt_TvP=bKFm_{x*0JVjm6(|#%h5k&JOreE2!R3gR z7GMzq$VxfuMeuM&Oai_;YXjSTs;6a>B`J<4z7Fn2mrM@pQhZgCHRhvRRGdvLs9sPV zo7Q1%FPk~(93&V3G2fP1Kw=*ss4<}8luAHldF{e?Xa|a#P8E?{H%A#B~u*L zV*6}F8vsbV^$&b2Guso-*ffbc^3EjT=@8>Vi^%TBF1UWD%7U7nOGuZcB$G*Dd~qe%`43&4kmLYO$uh2 z5r!6ewju2V<31BGR{rI^cT(!grbq_efnk|z ze?zGuMKdFDmR`1UMuh_QeXbz}6u$ESnIK^5i`0Grt+$MCybL}}o|v4nv>-({x0WU+w~k#Ju{v}&cDi9*(xgLsZU;Pt=#!9j`v=MCw)T&E415- zTq4-TFdN`&C8LQM!mfR^;-XnH=pNw=&R0UeQKl1!w{BPt=BN}s(@_$>cT7AwoQy5C ziT)4p1g0(Ob`w`J)au{eVLJsBSUho4O+j^da+O;gakKO}iWEp?uHc5)`@yMYqkCGw z&8sm_qH+;Lvb1^Z1Sfx|BOJA)nrI`^UrZh5l8BxUba2qBfl?!>SGd~N(uQAp?7ypH zU(Q1ddb2!qHnF2I(T!pD%2FPBeLF?ivQHL~Ke-HN@x37HG2h7|2+weI_QQH|4 zALR{};4HvF-d`mssK2LsIKu*~9ltXraATe0E8|t|y>;f(caZ=h;)J7W4(b@K=AkZl z;-GIZRlYcn5}(87=xO3={lei2CY5=9o^uca15E&KLSRnD3rIwMLMS(RY z8@SrEjZ)ihiZ#kjnF6afhZjI&<6e#=O!I8WIn1z~T$Zk5p-fSz1|7UF=%ZXIUtSz* zo^;{<5&-C53e59*bj_fs{cH0yM@|SS^h9dufrhs<({k5PlwG@N=DcO7v%ue-?Wv6q zR^f%J&QfwLjO^%lv486REIA5<50!q~hQ5j>V{+`qN}|jxAfI7SA{m9Mvx954OfP{t zLvftEy7at0JTvnIF-*R^l-ZOzIsoWoYw}moF3R!^g#>p_FEz67&StDcAvQ>ptJUMj z>yI{XFwe@LQ)8E#oRo1~Qx1g@b5m$S81#~>gK3k)1q_nRb(e$ibTA!H7XH|=Wjlmf zgUUNueyiaEcYx~afJJpe6#BWp8L*%pXu`Kz>)IY3P3d#-X>A~qL4F8s(qB&c$<0)> z)WN=stMIM;*U)EVi5U5jrg4JWwh+San~T(9rqr-4XAOK)xIJXTj6CO?Ph^o=kF{uj zRhOL5`?3MBb;#+@F}cIi@GwvAoKMfmePj~A_JU&!`Q?DK z1b!W!G*)2?F^i(SGQ8AkhspF2a;iC!FW5}7L=*cmF{WSJZyO~WoA{8XD-bM`A0-7e zJW~T*fmYl!bO>;+z5uixogj^WemCkvB$t3a0ZB^E#3}Cf4ljTvCN~3UhQ6j#`eY5| z(7*R?TuU8^JSt&O1bw`DIzLx9qvt=0J4S^4IeX^Sx-^uVDt8b~tTaO)$1|tnCF@ijzmv!ev za-Nl08{m}i%6@R9Y?YbqN%=O|lSu_pheFd8OVGehG+x7%S@ zP8$X%jZ~clqiLk+)H>c^#iX2N_ZYN16z&()-^ey4M3ky}vUBrTZ6JjbHtZYW1R6nv zZsb4+WP`WMXiNpgsWPdUv`v|^?5eRd)8vu zUG~}6$fj|S-gN?{wT|H09kqgh<|XIC(gSuJ9~h}9OCTDV!POrGL~u!*@TNx+f?wgV z<$$10W27jj#f1at!enAH0;D8ghPIMu69nd#^eU097+opi@f2O!p8oO4<3E>ct@V)q z_WbDh-6{fLH@Z+imcc`vg;M2EV@7V?>%#_~1sPC(&02_zJ|%*XSQ? z93ge-rj|xZgIjkh28oJ~nB7N! zMsJ4)tMdvY+k{n!a5uS5cox#LAkr089M~?RVWJ3Oc4Nqcv7ih#@TAZL#6fEmsn55O z>KGT#tg|_=pj6+|%aH*@&S_X_`*3*R0<9Xvo&0CkOOuL%B%qN9sxiTHzWqrV62k}^ zr?Mra5tqkC8cL5*<~P?1`M= zVN-`O7jrYcS1Vt+eL<1iRUBJKFp4rVY)x_^#DKNb;am&gzw_){65VzvGmtt@+7AE! zTWIm|Ge)2)*Jo2dgnVp55WT*VW8C~&MD^qF!7<-ITK_+rH^-|R0ID{5t^rryBUA|!!ylUZPCd%Yf;^*j4f)5=#!A_)`WCq z7d^*0H6F)2T9S_|mXFn}f*!V{6n@iE`qTwr)>@RFJc!wZyRX@nkwgbSS$%zDbn1(U z%Gu3h=ju!Q?wm?tDc?Kv(DBtlSm`J_xJ>cgIRUip!&Ex07(&LL+^TA>I$CwL$H#|g zX}C@#7}B?WE;x_P^4<+ed_`+@ zL<>0ic=zHep&l9Fe0*M);xPk5y(20@oW zn&y?PrY_mLbj1US)b6H-ZY?9fj|ob^IfrsZ?yP$znI4>^t)cE3N+n4W{p-A^RB?Be zku~y^B$ZwwB@&)NXSNdkFG;HqmuQznpf_kJC~F;$yQ;M1s~O;^Ky#v@mM*F|7kjpBx@^l3eH@qYj;I#0SK z#Xuou<3C97ixn1=RPSv|#$Hk_RKr!mZwzTI(0AkU82Zam_CG3{yD~G_m#lQZCZVG# zni!s}-FcJ=csIn>im}xBrVb|;efoF`f&y14I~tI2^+Am*L`YPoYj zf|rD!z;rk4@--cxbz|+b=jTD* zP0i-1J_m`%^EE6!dS)F@X~J3Z+rOhPTsQLF*$3lsJ@8pB;j`sq#Jbu8-MgRXyPq@s zR3VT{m-BgSasK&{8vmt0(# zLkvL2k#LN4SSw~@t=XKsO4jK6-D%`~6!B5XPvtlAHLaC$#Ot5xHfpHcC=@HHRC9z1 z&baZ1hU+6&do0!V1rHXU5uC}%<_6GPGxCe4(eme>)cgw{^};T2l|fAdr&zek2F+2M zt1K8?nzTbd*)|$UXrLTfyHrCS=BIty9(vH`8pF2_j6?X5vbXLc*Mi0_cAq{ejy1(q zAdGJg4fd{DMx}O$cj|zR1bD)OERNpn(O_K&F10krfSHMZ6Wf4ahX6x)gn3&wNdVf) z;00tKSZS5k7On?ETQH5;Eii?xs`H^VJn>0QBX(*gn<|!t1*nP1Q2X-8hQ)gGUBx?i z#BiOfS&IiNEDgJG{NTy<#%AD156fnIU;3$d(^`+nBKJP=cc?6A9#f>EAcLipP7SHV z=&m?z2*ta!w#@IccdabNmbKB85-8TRw$N803_i#)FAtA!WX@*0-1FNJkxMJZ zA225@^{rh+7WIy?8qO_q9*v{%#X~S46z-4rgv+CYl zL@dZQLiwF6@8T1#0p6DYXTuaq2$N_j2W-zq{5hMsn*Nt+3RvSyU!?rE7T%>G5~e3{ zpk%Y^(4wKifNr^DU3ggK?!0@Y_HjvEctR&f*-l>}rVqV%zJ|C{-IEo0U4NM94Kmfi<4G*4TkSp+w$ zJ7J|%A`s6 z9?)ATT;Y9Y_ggeeky;PsS7LxzSuUorE+5du9lblZIjd@>KxOlJ$=&AWcaxTi`J-ba zeGLL{q3I`WQZG%#1EK<=#V3^Mvu3L!I^n%3ZPo-Df3H3F=d)Dk+|34kx!uECj;MxB zk&-@DQaXDySp#V+*^z@5>=!b{dG;4vhKpc4jN{R$l2-@Geldb!)ye2~43WB+Riat_0IytAI?$@9MHz-YjM=a;RxY=Jxo`UUzz6FM znSTf4kG9uv-8p_33-M}?mWj{tK$;q$JI@}FaMQY2TpgzE#R%2{cDcf174Xw&m?^Aw z4A`O!ma_lqFftV-#j>fU=(Mdk26%FOu=-#RFB07OfEMkj9zWNucm02P3->o4tUr6W zo4q8ogT}~>3HFR=zR6lW>NR^!Ax%p*JN%jlqV9?(QujogVy97Jv645BmYmH87=92T zqF^Jo5^Bst38L*o*~cg`&LQfprma`gv^6{AbC#uQMvE@O}Es@Aw4^jpbK3E4H)^NU9rKtHYSdqs{MwXz7)*_2gM~ zO3?`=O@q$@GZb2n;5C%7Va;36h#tJq2H;l&QZ7OtP$P0h;RP5MMU_!RK_zAexTAAH zQ8_z1f2+7a<_j}kj1v2nA{9D7&wvSAy8s!%h3GV|YXc0I7-Or(w}o^z{y)sDKVvPx zrM?%EuamuOVX7^~;4w-FM6Z=NymNGQ=5{Uk*wWjXOUQOp!J|&nsBX8z(Z_=j3YfsC zEsIWpm|D5+K_kCSyPiK=V!-|yc)NT< zDa}GoZ*WHSbdmE$_fSYmeFAOn;TCa-(TPU^94KFY0v!f?ZCHw-d8zug&h#)P;&ak z&qWNkA(&HCj1POij_{nw=53rIY6C!Td&LrxS!0C8? z9uj#-?nfTiWO(LT4&KQ$DPj`up<{R9rx-|>AcnllkvB0IT0$-%uoj7$x+$p#?8v0Y zJ{s}_Bg?Z{h<_L%wJmwIr4wCcGlNwX^2U;3>*rHCSjR9RL^lCnrPD>yPd0`&g?Ufs z08yPb3;#QE47Vjg#XvTjqOObHERKlfA`)9|nl`ay;qoq;FQH5UpRZ#aipXTZzX3)E zK5)Jb+EVzrb+Aw-gcZbSGT$9)jFO7bemkCv@NV2gxt*?YEcArO>Z(V?#Slpub=Ue6r)W$uVQ@>G zeb6n*=8BttdirF0_pj>@AO7|G_3f?oZyz=jjK+^@iAX|8w1Zp7XoRbPezsW@MhO;1 zx2wuQHkHvl2|pt7nryzr3>h#T0FdfUrAd{Z{e9lj<{|dj$n(`wY};3Nwj;}mdwbI3 z@1fmiWT*+I$!86cBs}>KEgYLRZ?^-2jXL61pxzUo;a|jkX9*Sbc%th3)*at@!!Zqc ze4{G2qv=uH&ji00GYa>HX)V`eJyGM6K{BO-89p*)YJu`D7Li6j*bCk}>LXIbb@z9(GHuki9K_nY6#@=b;~j;de2(t;+TLKCbL2xS zb%->h@pD{r{-kh_ptE_Cl&QK;ll_A`%`DL`C^m{Dj1lQoikBN75!YAq?w z!cpVX8opBZ82kc5eR<0J0$0?GkIH69^HA+%bY*vuk7{->Nv=IBkQX?p0&7F5vIuV- z!U|D17r9Q!-?z7vD{->Zvf~zkJ5gBS_vKZNR|8|kVn7ZQLW$r#U&539`Sx^PV5Lie zdJbGSMuk)BRUL4yq=H9^wNZ0OA{>rfFa}Z=$8Z5o%Vr`D4Q6tsR*2tB4vmq*wS>Xx zC|EJTiY#6KhWLwYm`#~#sgxIvL_v# zGwIJLr&aW2i{O1E8xYY3+A(U3(^zxt@)o%%(X_Wo6DO-n0h>9+Jo5Hjgv(;o>K&xi zCUGK852n(v2Wo8@FwNQAx+zev{!JPtGSwMF+(;Xm!G)fLOMKuN9?xtV;YBP*=iSy> zxkY8gE%Qh(KcweJFA1~j{tj{o-yI+3KPcv)9%$`l%<1E-AJP0wDC{T3tJm=-fY*6t z((T*VzqvX7H+M$xE3>4UhwksX*?-A|yu}3V-QF5MdJpj;qxMJ0l{!Fz4()E(LAkF! zyj3(N*hi*Zj3)&dwO-ZDHWCqP7?<`Sc0oXwI4%4LnG)W#$tqikOs1L7V=>CI>iM?@ zw+)SVe&KCH>3K8_DB#n-$tDyjA7*zYV9?Ue(rY=*=!BGgiiMi@bw#eEG>5|+?2bcT?^sJVm0zi02L)HzBcGTFcWqFE2zheFE&Ec8u zcD5uFKHD?N;DbT5a)+;Da)6CR&|3^lqgQ1rU9JCmgwpk?rkyGAl5?y4=Oyms;L(n4 zfWuX_uB<#Q^b(%(O}&|hhhXK!jU1iDg{DDL42Rrm1Bj-y1!sGNRUWFjc)kU-!{(ki zC|`MEHf1gS@QO16p*Xn`m~>^GkDCf8>0F*_C%#sVx;4Q}*{8GADT(ZIF!l$NtoJ+= zab|WA7p9_i5_?dWEptNvL_R_m=ZuQUp|aQC`!vXpY_+Cm+{2$gb% zGheK)>j+=^hM)^dxw|?-*9U38nGwfVgMx*6SAlv~p&jo{Y1V*F$x4-lX}D=Xh>F+V z&_5UHYh59Shx+hAu@LU5RSV+qL|Wx*$D#>a45uRgxrwMxL1k0WKlKh}0jL5U>x*7F zA#?q8`wWEuV<*4rGQ{}4R$>-p<+E8^L_LT?%Qpt`fFzI?x`?>CetY2-BCIx8jCN0A zJNw7X%M??JQ{os&)X={As^M+no`#SGtCeKlvx>!ZMV^SW>^m|)NLE0{$EMRbOY~8) zi4`;OReCfmDb&pT3{1?|ASYPvgSucGW$h?&o=W@JiE76z(0X-E9z+x&ewAM)%Yog- zouOLuL?m{jaulB6Ej&B2{QbT>2KUC@r>$XEVR-5~CJB3I)czVj_?K)wDTP3N6>zfpDH(a$l1Z^Q1v_QJ|s7a3Z`T1GDgFH7NAFTC@C}P zfw_BaZNiUT`2h~UHvrs|s$zRLIGZYuJ zcFpoU$SxwoMR0TWxI7^`-FIi_*kr=_fxHgKg&^z0O^xF@B27+lKOdis^rU5!8hj&D zEOx8kGPE$G)ur5KyJx(Zs3HBka?=-ME?H^b^C=8{zd=;j6K-WjI zNncTBMGfUy1^=8C+8-TlYhcc_(&k_}Kh#JYZ6s;u570HnkConaZ&Z&^K^|;V*fss$jb+L?}ZDTme6)GSS+nt28Y0VgT_v1&+16aroBGOGX!<~f&zH=TfLxrSj{$4(~6JYhYDTO**M zBMM5$VaPg{5)jv=jbhAm0ydec9*eQ^lZ)(-_6nlKqC>3&h^jQKNJWwxfj}1tBW+5D z1Eu(!2Lso%GnN3FHOMhUnnDDi4gmJul?ctEn;01v=LPp-ZbQcRnFnwN^9t1qHb894 zhj~ndfMh}!X_R3#)3B`;VVF4{BdJuZhHVNzSd|U1{*0=W5G2BGmG&c>KAiah^qE^_ z09Q>G%0W64d@oLFuuMRK1`r?h@5A|J*Y)UZMvaVubz z0xs{Zfxv=`ge#RoX>3>gm}jSN>}kRu3F~{Sf+MU!-?}1`zjTKSOyAH6po)8xi05-R z%0P#`(NN78+>I*2P2hym4P+YaV8*=_SeT*3>KvQ#h1v#KkA_N)#J!!Xr`W zYlPhUy)%1B=v#HfMUxQ8tbs6KW#WYqhP4LY`Bv<>xjnK6%SIV+33J6pXSal$yLI!i z=`X68Fa*jMw~S}A5*c|!UetO3%hDqVX*5%52+>M;ku!d@Q(-bfRQ@f!dFXW6!E(cMt=Nnd}hvFofC#AM6 zuhiuFE$b!=wvIj@2+^WogUA&=w@)sN^r z7rquBQv|K0+}s{zM*hT6EhOTk!dO?ZIOmPar)P&hRk($I<=D;3EY7eCpZ4Q4Zb8~J zlCNZa_H9!`d3}-1X+iH`7J^#Sjf)$irsG@6 zOuZF^-ZOnedautwV|)u`@s`bFJG5ob;78&syMoBiRL|ErSc9(&-yZDT7CKDB^(7&6TI>fQ14);AuMB;fJ#w__ zlx=^Z!nhYADw-_cR>Z|C$EsI2U~qLit$3ujpY6HP(n9R>boMWJ6n3z$ zYc4a`*1QddslCVPD(48r__TEG4Fe%Ax(J}cE_EOVTbY(7e5t3YK#)tOn$7k?kNcL@ zP>F%+8H&u7O2~fP5K>qdMuP{4({TQj@wiS-rtjW6LR`}N6w2zXzXjZ|j;!zP;>F=X zC1HRI5ur*J8mTTy*(vWoQeVDvI|m}@vtXo%Ct3amBkrz$w4ox69wbsO+)FZj{|5cr zv#0Bb9J>%sr`_aWV2r}?SkFxlw$sPVgKm}bljp_Q({n6`5PR0*b^bydLUg8QopUvY zq3%8=aBPkDT!J2&P~8w#Lx%1Y*3l6<^YP(Nd)ezC2YGY!@)ZdqT#;T5c@ReuOH;l- zQ!kzY>_e6o0a%lWA)>lyND6=;R-nNK!=RS>vKbUckC7ELKd8iX0ak>ApS{AlU<#;q zQSbQf!#$h(F-Q^dadwAGN`injfAAGNOC}%UGvMK`{`uekBnZe4xcd3pm%m-Rdq;n- z9nrRJ_49w|7Vm!g>2JRHV*IP|`0l4)d>X$$y{q5+clYzpzx?&D$K&68`Q>L{{O0q! zpMT0{pMCkoXTKVM`VU>jlEJXkXhb+(@@@CAD-aNX-6#Je{;FiiEsi~O_J##+yL)i1 zP9yjcAAuagjp}PZzPt9DFSDxyp4g)kWzkvb_W-2F>1i0o*5e0HR_Xh=N@djU)|1EM z?;bxJKgCUjGCLjZ;04}YZO>3DvHfR-jF|1-ctt}gdAa*`LMF{F|pe>CFP}SPRE;(4LbgG?blz>OcQOW zS#qC#MMWzmr0(*0_p7hILg~W)vkS{+QzLKc(ca1V-Z2K5B>zN!&8^2}98()2@A9wZRGyV8nKUm9+uYRo`ztN8`Z;x(#r8mC% zsvXh;b;H`>qCtEdhh&m)8-cTCZj%YVACo>6gs1A$qOH<43&CyJX`!}#xrHyYe1&nC z+efu|Gb#a0Tt1NS6hnP(706l9rvx^ zmXSd&HIlJ#RN`+wJtHZf_-=z2y`S4m!ej#sclq4@TbNd;=#|3XK4Ry(?qr(17DFZL z4#%F~>`Vp{pS(P`4co0Sn)%N_q+r>a`OKDaE<8`Ea#G_kg#nC|$x&}<(%IE#-P}y4 zunbLs!14rznM{O8X6)RAPkUAHXkcpE)!FY)!#Gb1ep~4gqfvjrrFjZgg0JPHzMk<~ z*%3ktja1j}g&97%cTdg}ToP!h;tlt>Ji<5VYUgP$+V&0YG|~;C3owQ0+0#w;5!rQ9 z!B;l|W2!Pd9W=?&0Iy9!;NC1oblbGHyaRhzD!!-lXfFt zqnMGj;(LCm76t>1$jw1yiWo*R@f;`g?#Oy|5{bV8pL7RC*bk1LlGNg2e+Vr<4nt7B z0J(SvuX|zr20vnSEqRh4Sr5vfYM0FE!W(!_Ykia442PNa>cij#nMUb*1DstEoDzLp zywmm@JHROI_7+eJI_{%PLep*I5sOXKCG)Qx4bjRkg!;3iOmXT@~i?;{< zy!4<133>G0W`!~^dWVNNlXdNDd?jjJ;pJ*qW@#6xqno@rBzSmoG>u?yY>oYQ)@3wD zmgQ>6oBgC(2lzM|1WUi+UaCMn1h&p6jE!*sKnxUmk1O6{Zf%DvSyI4=q~>8<&2%f% zs&pkfK)JfS0=sgY%v|7Rhb-LR%iw8o9!_0`Eyo<4Ll!2ejke08WsZCy_rHwMC%ILg zTCa=SceFcHY!S&lkP+iHq*Tm>DQc~mWBbF*bZdyqNe+;Xnvg2*Q?9JwM8QVo{3sRG zz4Ei2ys}*Ev$MM_Vn|*7VV*yHijcmN{(5&@0@w#+vbVq_U`NwDI#FH&=RiI{;;A~6} zKtp9b-=%#s$+~)CSYBC3k6FH>zcZ8fWf5t-JlskX}P+jIRkV9peDP- zjrr5*k@R68hEsT|`VTigMz1>L4xzdt6-CuskG;S@aAJ82zDt71$nT3A<%G9DT#T$c zL;S7k^_fhy7d@g$%d;t}x!p*tf&a-{6{?BHSbfxrldXG7Cyw0kS)9`2$p#8V)Jymg z@DZYoMitBn>nh?t^<*Fu@t}CPA(gJ5FaqKk%RV*3a}5PVmGq5vxYNu{h<4FJYO(AH zO(n`{gf@UI&fsx$*#~5KIc8txOaISGNaADC>`xs4DRdP?byZ}XzYAhPY~g4iF?gd9 zP~Vkj`++ONkm(G@EP+6`7sASC-V-Ua$HQHAJ?X2*Q3*!G! z1{xK)B)ADMyCWo3_yfLjJ%BgN1M2K_!vNuw62p=q)zv+*e|UzU70|P`fvf35K^-^< zR%<<~Yw0bhr5<&f2Vtyiz&6R-LQYk`q=1(2Q;@y_`~qZzjx5i(hM@0*nkrlp z+8qQZSDumOq`Kqxo z0AWjV58=~?;ozbD)+PLtwSxtDL@EMV<=XkoCwinmo<4o>aQ(X-XB5rd2U9Mo|3~O5p}+nO0^$xes4Cl?yD_GQ`1kSZRFD40_`m;q zOzjLgAiDlMkTxy*Vrj1EP$;QUb)--hFTVcjjswje-+^?D}$uDwFD?myx>n_u7rrsNT zNRp_YE&b8X$6}Ew?%y80J@j2oD-&SrObzQBQuevKb9!2V^3L8Vx0|wx-1aGFF=A*b z#p8Q2Lm$gg+o>#F*semBAtT_VtB+7C48?SPh`aD868?R}RaX4(%2 z92=M+L{K4JYlq_%F}c*VTjJC*{YGB586C)v9xPIYfJ@++`QBtrq^jhdU_^pXNxLLm zN!C8BNS=cY#R2wN>BJd`-B8KXCYsGm^CWe5a9esY26kV-%$!rx;d_QnE(pjB)>F#8 zA?@4Xka4<+#xy8~2=t4!SzZQXY-kPjM_5^DqMQ)n^px0w5-Mp4 zvQBIdtfV@YSo$=x-Uc0pBQ%?80X!}ry|=di`?UjV&sMC%Rf-wwli+FTwqiFe+Y!S8 zTvxZE0Wz^4u81b0Aj750`l_sSvfF5PESl!6F4eG4H%&bSR1;-?;a24(YgEA#2YGdDYZwmOYej)#*3P^0eWN6#DpXR& z1CevORlYbs10L=z{W^q{)c88aCHly65AjAidT{fGcR0Kbtq`$!g}3FlO=s}#DVJpa zkX>AaZ8eJYKtDLTb&`-9+X{KsucX`+iwX0MBgUX8=cRLeupZEm0D-+U z{l~++hHq14k>Z8RCuhC$Qct)hZ7>l$#@=~+UbucjDbYs5d%OxyS?%K&O@%Qo`!9F$8~}$SHp9xn{oR33(OnH>^VkCQ=8LC3|b^XaASe zjrdI0Xu7F&E}-nG=ybi2$b-(i7WcD1BRu6^H2@GDx^tL@hR_*OPN~V)1tyVz__!{h z!4-Cl7AadDk0Wr-e9+0A=SL@Zrc|h&pYUYpe)VEY`PCdV+p;W(=ELK^IP*CY^5s>HBXaw!TrHt>F@}Cyjw4N5G72FLV^M;Ma28P>e z!+`OK(c7TpDp=%eUb;~(2wx^PHQCf?Hsw%FJR0R+)wOWeGi`y>?1+R)cJr_vnac?l znV2sdhI*C4EDju3S}2!%eoeRvjIY5=qkfs^qbG)FF*vwx#}2BMf+h^7#}F@NkxL>l z--Wx*%QRyM8Y~WA*){nFH?%1}CJw3x1x3DEsd|?ZhQq!|Ch!e9kwfjOTSbQDzBESd zm+#-=a_t11c_8nz%*cJz!ow&MH?+|t-M&N4NT#&KA5GOXDO7IoavOvKH*6UrE4vBF z2`u0>J5W#S(l;ew@){w5VD8)l_EHy8bjnkyqu=QL@w%?=)yqQdE~P+37otR}slk~i z&cd9(X)xOInyj9v6(wfZs-!SN9YOqUf z)ckl@C<4Wbxna5?^XE44}|Hl*QUE=7f*q%8hDmVpb?mMA_;~X zm*j$MgPFasOR~Tk+XDw{cK~TUEFKuL08zZlVIzIuklWsIXYwp)n zubEgH3H_s;?1;GVVvYqjdb74}Hl(%)4xcz%L=CO(m(gYpiWMz5zu?6&J`1`+ATF0H z<9+@X+IY#briO0@@h@k9rPj={z-%gIatO{=*K;I?E1qEDt?+6pykEz z-FiwYGjxL-IlQMr1_12X0ZO$8h&6Pml}u-{kE1{jkR?FhP}7yC_f1X{F`baLSx5Y)7>^)L=QA8I4%I-{(9}Us{>fU-&@- zYT^9#<_jq_o7AFG0hsxL&iCg%rCk(1#-zqqgGqfy6=C5KC|zLRw)WRt&Hfzxcby!* z%eA#TyyPP-&^gl}nkmpciC8$`uU!mIRmu=dKeKRf4alOBRtj{}-==y-oxvW9+J8;D z7tMlF`AvmcJV{1~4nQ75+TA`+gxxXDv@L7sm_r=;^bJM`yvl26>(loNKT&btZbA-LffG6StN7gwuabdb~5axs;}X7Sr+^e$1;28_|jwA z^-PgF3TRy;rPzW+fN^5Z33?FSzLx)NBmF1AAI8A2eGRZMw^?XPTv>(+8);iYaC|C~hOJ zJ30D!b^7iDECBw&spdb7K3R_Qh(b?OUlkmMu&LZ@-`a;IR>;uKH@B+M0=CD(Lz)xw4qj1ic;|5PJM8b2K zG+}M9uw0RYJcS5=!`3(^pF~nws6!n;@Zm;v)ZMkvEQ24Yz{p<)j94P4fXEIMPLkbj%g5-nVa z?%6cC;QQao1hU#g#y7{wJPg z3^8U{#JV?l2Pni-x1yMhj~v^uE}$rI?pirSIOgOCirnqwaqg1MRplYP-4D%%5ah)H zm(WIk<$)Wwxf3pU&t#2+b$AfJ--#DZ*4R{#dgNCL@iP(xQFRdw30OQ|I03vz3_N90 z+SFf!XQ5W9gPwS4xUb}1SN!%>uS-IT6m)h&jMcZiM`&MJr2s-y!Tf+W!Mc1#!CqM? z5p<4?`7TvnvG%|z0cuvoHsmRmYEX6pxCs;J{H(iqprmyrts3iX!_}3oncvV#(e~$9 zV3KntVwL`d5NIY>vTz7D$z>X0KiDg_T24)ccb?1RmcnC<3nw8jXBl2%Z$cKJm3+x# zaMGg^&op*2SDw;AHGy7IuF@Ox`$GPcpN^;|lw(v0Un$+p_d+MLfA43kt*o8U*iGp{ zz|G@9XhL$=0~HRzMjVnk%vHc5nbL{wwCj>aB2(XTCh7s{85|K%Yg^*VocUgp-QbgO zKyK#%K##$VSD4xYS2H%As5~)($Ho^IHk_XPf9$<|b5z&0?wh~+Q}kiuBOsCtwiCzr zx^^%Y3AJr-foyMArH)%j0u&30NXRxx`MaOr^Nca(oU7Fh>|~!?_ujfGM@Zdk&6hF9 z``eraFULW>r!Ey702nJ5iqjqrx1Vj#;TWbrxQ2zap2=jzM*o<{^8Cv&G!K3j+srFy zogG&UE_KBEb3DFCkr@whcG!=pgf8b;E-cYd9slrTW2U7yNyn(HS1*!s4I0T}Ny$9L z=fxoeikFTj1VkAitCWNuVv%Sr)Emp25?wVTx9|zkNj zv}ytI-ekSw@lFT9?b-0h$Y+{fWL=9x{SHrxT0X4gGDjzt(Idoe9G%~=E?Yh4O~p#l z3p$otAZ!#AxHNh>D8^xrb(Y1dKqR07v$IFiFA5-#gw8f4bGYjO4-D4&InqAZ1RHzU z^*j(#o8V2`DV$WDI5Ue?o?jdh5t8o3NyG?2!OH2=gaLzU2maNa|JX^6k<27cUi4H3 zYTo6`vJ|^w9@EUEczapZ4219f9gtwBuUH;}zJF-@(f0SS!O0PoA|d(|k~9(%D&Kf^ zeEMYX_y%{K5S5U4FmIrHf!0UogKoKZm22c|$`N2gvU&4ZS@wGW&fv`n_s)(34Bfd? z&YMf_oqDs!MK1eyqHFk|L`qF)O-jn3ufE~A4S1=1o$jJs4stXD5mIX#;ya*u2z-<5 zEdZE(%83LE+(Tamx~6i;c0#Ho^FId{jkqznp3vdQ3o;U$K3i=4wK-yOqw%}_rnAe} z^u%h+joTj1kK_&5JK;(MjHf`IC5(s(JSfaqn4XTnBGBOfA!HRh<2q@40xxwdQ1}{f z4!cr>ZNv=dLVf8mGDsDe0#}FrGTZf;?t3@h^SvQ(;bKU%n6?FIr;aF3BuRx=MA{5E zd2@c{ucuGu=f|h7&S|X}OA(7O4Ligl)lwig@9Zl9t6{^-D|ch|dOx&-z-^AJ7CUb< zT68!;We>PdpO|?~S_sHeRjQG~i?xcQH1{bty?ZwT7*^S^DZ4g41k)}~@Gd9o3L1m#nmNuv{2vx6#ds(w7tr-}LMbz;mNQ^EV#gNFIc7s{MscMxF{Mz7j z{E!pX%pI7L(7A_aBm2!?BRKu}*{M2_E5UDr)7K@7*Ug74CYLYn3gHKyOB+q(Nn*Ba z1>;cKj`l48Ga0s!z%t8voLYVZlcmLyhA3c^$H|ZLE}nrrxdv(1!&%uDrb#{2q_TA5 zfG02(x(7d&Nx92`P199?b$}`TTljUs)W~UR3dGVoK-rDlixv3fHL#dAnBuiFkggIF zw~leZwYsM4JC#Rp;9*lmBP_}FJt-qj)G85z+=X)J^5)_38X^-^NQR2bPu)F+@t;94 z+zm7;pNC8lSW<5gIndig;>Xr!ortsimHj!Oq!|e-V@i#nbBqRz}kJ;yl7Brnw%EkGtwU$Mlm-8)GnFiWDk(lZVQ8Nzk1=Ct5V)!V-2`fmA zXhhuDaJGjBM^?2e@qy1h95fCjEv2GKs=$?655T*`;@dTJ6@0YPtX6khF;k05F5fO)v-0%sc0rcU#zI>+p-71|J- zrNa3%;fv3<8Bph^?6^ovu2;h`4`=I%b1oIF$e^**?9^OIn09%OTC0X%Z2c%Dg#6~M z9}f>-Zaq`jvs4imerTi!A?KRkCFINE^Mo-Za`j8IG+%4IzTufHUVkmZ|%M+GVvgT;eF*0^=!S7mDQYby9ohPza0E^P`f zCBz$7$r@(iykNA+l0(Jx$)mk?izMLz1z=GL?lB;)En)~DLzI`QZYfYVLyJf{Jon_y zFSZ)o0}H;Av8kvMJV-3dhnOh*Obx|2j@Z$~OIQLM33}(8_l_mYU(cjsb0SjTLM6~{ zNBm5;x)xhD+6aYoGO6FOK}q4WbXG|RZBIKJccU#dDw8!rAc?5_aR)}?0AWbh|KyN3 zgN9S~jDZ9`#0%own!-thfyf~i12mscV_3k+D~uELSUk7h0&E6f*njt1N?5Z2%hJ1K z0ygg0vTfIyfOo9m+f5#(cri;dDKE}WkQaHDvJiYsf|vM!PL)cEvL{M}>0cMwqw+K# zuMk6kl77%0bdVE>q$#7CdJx3v0m==am25LUCS@A+UTPq)84c~EcgUeWjU#|#@?}6C zd^q&&N!RrJu!T4l7jAU+8|hi#ERH%oUx=r90)x@k$>_6LFGSE6DZd{pkqKir=u5IO zE7%a2(W|Thp=DmSq$aihw#vW6Ijo{6;kU8C7eAs1PBNqL@oOd{>)x#UFW4+aS_~NQ z7(5$Eg8~On=(J-{GbRFpy63h4M;scRU7FIAohODs=*reSIw8hNy#tEB5^v)ic8N1C zUn$7gsAUVWVBhPcCl-YjY0mF~a;!IuGoVle?ai&+6(f-6C7t}LuvY#o(+3ixgr#qo(KzY2G_okq@+ zE{$qQEqh((?|f171^g;HH& z)z-&bnpC-+Iae|IIJZ)xO(DWe<4 z!CWN&kKohK$WPbRvd3R<+g5)PiX~}*^vZnKpI`8Nahs{_9W0D3kaCF z)5RGxSf_)6#0+)58DN2Y6ZQfp-^(fXDG(vvl?RLXK);Fsja494U$kj4nyI24|E%Js zkj9>+REhyP+2t{SqQ|nFjzz?+-BfBa1cy&!A!2>v49Pn*I>WNLA>Z6eV*309y1@t5tL`v;md=qE#XkvI1JA7a3Z<%tt`X;B8^t% zS>GovX<#Wk(j;G@dql+92U;Wi9OyL@dfDNuZ5x1kt56Ni0o9Ionz{Lk?n;2RHD$@- z{Y0X3?lO<+ZkFkaGY#vmT0+LM`&m4ggL`-4^-0HSReyD}MU`I^Jyvsz=%IqD=njog zfcO=Jf;3{!r;!~Q#{LNTw1R8ya6E-3*tJDrjWal`vsjlR6?+I&F-y=K{?hF)cD~%% z-TC3+gCBMtJ$m>E?KAtgvDs=GWyr8F{@XjYyEt8_?qMagwr3;f@IFFa_DSLI1E0{a zX&J2?;!1J0PhKt@;QPL1b&I=xK={FpKv=v9}^yuoVh@Wv_(%kfba05!vL zr(%if<8(Jma&*T7ZdT#2x%b)pKk!cI*Vxqx6SDPfs(XmBFA@YWL_n1;_;du4dW4$W z$qitpo~@b>Af;%Cvtlowd*fqu^72tQ=9U#Hfy@1zXlqAwA<<>PASg=aE9d(((4uSD z=sV$6(=oKmp1yqjc(PFO_5KE{_#90-(aMQ%Xmy8#0%9#~d5L7&W#Ev6A5$zXiSas?9uS!kZ6-e$ zycFHR?p6!QJDh1TU!l4;oczbqxM{>#Fufy<@y}bteuRbraa~&VHYgR-QX$PKtvEiV_&%t=3;K#8+yz zYRH1DWVbBd%=41L_w}QlyZ0Y{^SJuCD9{2)a7v*^HdV7`Xek2a#={{<41ztfCguJ% ze#=N&=CVpl@?o1a3?jXFXqmo`I&6{TvGjJ5UWS9v1OpjxFKN?>BxxD3YWZrwV%=>W ziiLTvWl{+V8L!2DDpmlvQ(z16o%*=mSmOopSNDg0!nE+UEFL5l2 zDrHcfWeOJaP0XGYJTpy`VO~b+4!1@8RXviVO6q_~#T9LN9f8RVknQ&}ZB2G{HRI}j zI)qleXGH3*pr9F5q_o*t?Dt9i(x$NWiMzB83|v>0L5Q~ZB`+3LI5FJ(fBsLJbSP0NbiKT*T+V|b1&ee!Az`mfLGpg{i2m|+9rDF& zIrq6-GnW(Aq*F2(m>^lVMQsa5MX)sTUb`)jxaMg!y690$kQct;)22nF7J&Ln+S}f- z$xjPaalpj$2QQ+&$bDHryvW!zfxvzB0essj-C`iSzT<-t3=!54Pot$LW93+OKP`_I z$#N^l+WI+%8`e{m&5v2=EX&IXHZB@yziIAhnjT z-zdN)hte#bZ>wgrgC%8GN*{tcGecVY(HI-;Smxh3L!&2-uJ~<9kS%kf)IHKdtawes zzL?NdWfiN8JRiC^j_Vs@P>2B`1<&D%E@*lEih@w(2RVXHe*Kx&Yd)>ElI zoiYoDlB+e5#ESQ#OQ|!M0?-3@&;}M;G!eLlKls%twWJ%0K&sJzJ{j5!T<0Q8r6K$+ zzOgF+Epy{~Ccgr^Z_H{uWMFhdxRFB_)8oWqA4EZZi}$SV7he^6Gob4vF-6cR?NOyZ zs`cUDiF{MTTIvcoXdoFHvsBn-FIrr%?{7WMLm=>KzD&ART*Rex^ zq@nE_W%X*Q9A@VwHKv)L%M#wL=gXrR-F$iyW1C_b5VI9heAP#m>@`YAOzUylWfwIj zahN8GD$-<}>=bht`5Z&o4P(RTGNQqu z$hZllpEZrx6vt_qE`5DZ4pMSbQnn?x_mP{8O_Gy4rAK|? zCeSXv3bmD>Ix74lR{#UVH+JQ?q_!7LWge`##KlzPQi=$3 zgK?S2_YTv`=-3r6Dy^|>fO*xdX~iSg6@jIW9)Koldu>E|9PlpbVI41IR>sTszudw3 z31!twl|L@%hA2k8u+)x&PHr*js2)rsNTDBYpj3zxnaV}~Y8NQ-n;e?lIuv^ta9Uw8 ziE)bs>QdM)vDs=t{%wPnpc3sJoAgTtC$i0e3W|r87dniXh;$*>_pqqkZ}Nve@;AwE z?h_z5+6Pi@|A~s2f6v;Z+m*%DDK=u4!4Cxsd~~9AFjkirm~G?g5U;8f<2=0NfBOx} zmZ_r|Z607Tw}^M-&&MiIxdHdnRXJ(dUODc!cOKop^ZA!Mw5MVErMYjUPnNpCHgD8+ zJmIcEGMtQ9O7npI#MBpwZEv2uo|;dmx1j>j;_5$=Zqkb|6Joig99nsc$Oub#K@zXZFPt`PLuaRGhMT6^zyz4)#Z zwHH>;#HU|!l)5##vapw@{B4^O>UP{)hhKnbD{GIfo+wPCJL>i5Bphc*yJ03$rJ?xk zd3z$T_j^!R>76Lrz9FLWHX2TvebxC7SVGtWj|J3U;mT4L#K;xU;gHguS>GtX79m6H zhRc+LzS~gNq+)wnd@!_yB=nA9VDPLh66^_*ET{#HGaYhTp{X7I)c8&~9K?NOYVewQ z1ad3y5wUnvE^3=g2Js4bR3*@`Zg}?{iX>{XS>(0@4Gp(y2s;XpNx&j_;dHQ|c9l-| z)wG>U^-RpF3CSXF2`HOw8HzWl9Jq-=-NDf<@reN3JAR3UKnfBG1n2`(*=yctf9SBx zQs0XI*^U`u>CMMN2W$$2*o7su+$Xx>!>!}=NBB1;solk?gKt)*nmAxXaYtM_ajZ;t zr#A-^u@pn637wyi_E9vM8FMIbtFf^f0b4CONpGbKfIT&)~qXNyaIn1Q9n z5IzK=jXVGO^}|QIKiv89%O8s9CGoqnqkDiFGB#jX*F-fdUsL7X0;7IS4Ej@q>NWr6 zF+$kcpj5-P*93%qiI8y|Ph(_;hs+S8V#nluAkvbRJ(fZ_uo-W`8!(g|JSJ!^xdb2N zKP|G!_sobhOfz(4C9&@3zz&J`@Q4(4J*Tk738yU6CP!imDR5k4cBZl=VPh08@kE&@ zEz3;$fEeVBP%Papp${)1GLSKwXT>j244fm7H=}e~j8!p>5Wu0^)T=0_0ma0A^o`X| z>G!*A-xUaLKkGP;`~Z0)pGiKqIrN1VC>uf-0uuA}6{xswnvXLM+H$=#+U9`NAhn%P zO26FscIQhgrIGifsFiYqm1suT$X#2lzB$t%f>U6Ie@TRGBNA&21B;Uf`N%;~Gg065 z(s1Er4;95=ko_JwvVVlXq*p!(a&4@|%?#`Jm}aXCf~|2eOIExmZ%V z6{F51V>aIy!7LTvyTg}M?8vBk+FHp_wm5uG=gMk&f!r3a1K(%Gw2CU&0Fu*Kg!!Z_ zCrSAuSGxBw3X)UUoYz{;hDTzBd=H^8N9CAu2R3C_FjqR{^!6$ss5w@sD%%pqio!nBnmgw~?r^ zGlpa9zJpz!`8GA7(aO9%6W$p}?R$=Eea+Y<`>ut=T5PX5)@s5b4tY69cK2PpjPK@L zvz~v?PFpG`=&>p1Eh)UhQl~9T_e)+iwUtF~c&0nT@n`p}6(S_ybZ3&1#&#vV+IRde z^ZerF(#_|PKuSj8c4S_dLD;XGZigVac#b?wC!Z-0rpxw>exg+5o}VDUolUV`R7;

&tDuOecFoSnT69;qnyUp*M>l&Ys16^UM|YP8K&SSuT;V zRgO0|pfR9ymv%OGWZHeT!pmVVXd=aWG#KE)f(YQM14p<_miSE^hUIjf_Tn?bHiZOG zF2H1m4Rg#|9OOxxkS`N3DeBQAR;;{1<{`(aew~>8jpTq$`?O1(Q|IlAEbeMaTTlJ- zR8b|<$afG++DGd0airF^!`43)?}Pi+FzwmS^!i+5j~lVy<~MVz@f2NEVA@*=-JaEF z_R-uAmrL_}g*ugX3NRFIEgl4oLnJ6wlnuB@I-4MY=5Ctq8fQlKt=|NH~s3Az9%!U{hHw>r-!;~_-;nms%Uc~Y|3jc*g0Q^ zs&O~xnH?WKMFNAZp`Jyr0kZ7yIsA|4vmHnq>I~tQTYsIS z1PU4BN|#kQ4$`-fv(7hA4AknSQxKkcKLb_GU(l;&s1%j(UyhnFHqii(Fc~9Gs@fhW zjJfD=f)X$paF3%u6uM!;XeE2+I%)VcD@g(oaG>V@o}$m;_kKX)sDm z>iPJiDsRNtYEGp(uuc9Oc9JDKkaYFHe4DncT*VY=j7;Xwt?k#zYEiHGwxQuHj_<;?9{GnTZ$DYF^DTIboli+^aZ^G)-2f zvC(Vy=;9(PmtI610&Yj })A`r+gI|GE9aW>gc2IG3Sb_4~8z|L5;Bs-Ik^%=b)8 zCz)NNA``R9C=`_zc4bN5gH&3eJEkN>>MHF_QPp1Zii0~Ow7)naRk@SF;;WoKlh0K# z5!ZI|S{5M5VC(fpVpCBTBFH##Doz2eGwx@p%(=E+)bg%qEXqaL2b0H2BBNBY8IQu= z{Q2vb5(OEA<0)91v6_6Sfj%cM&GID+?Q(lep1`dV6_FP6%7&73<2a8GF%sQj3RG8) z8R*_jlP&H?JK0i*)3)VS(f#>G!~zq{%8eWDcn(T(grywVsfl*cpL$A?d=M;%{Lf`( zD?{5$K^Q9!fJTm!Q}9s^x@ID4S$mF?pl6NL``AR-1r5jJF38(K;R+yD zmi!7L6Avy1ECw~JCL5^;kB3U_aVlQ#*o{f5ty2kHrlF}2&S@?rsX~HEG?KcaFq?E< z7+WytVg=R==pivA0rV_=Z%Gr4n+9uoy#ovkjJ5Lsw@zz0pE*!Q>y~s1dj&kap6Sh6 zi=U{oW!cxdqN**0SJmg(*oQF&uMto0%B|TB0YuVTO>T^BrrBy2apY+l0t)J#Bl!Yn zkBj-(PSe&rf?gJh%lE5Hw%5tjzOyzM!?d?U4OuB2u4NWPRZ)$Ni0 zP~3`?!$y6QFBz+#^-eshkIXDX!s@_W;|Fvoc#Fkl56fd48| zU$RqaEF}z%g1f=R}!cp|eO>Qb$HPzm-=nrOy04yy9FRVaH_P0~jEGJ%E;HOpik9ye#7^ zQAVbf`(REUf-?w*s`^Mo?dRvJoq(hyLvY+_XMNtq`xoy&JGpq@b2pci(LORU^QOPl zuc5{l6=l~eG(Z%q)hgGF30`EMg}9`x(v;>(E)KkY+Z11_!`~Zcum&~)LuihG)Xl6R z-mBM2aDmisD|}c&&f+Iew#@iJw8%d%b_8d+ZR8MCmC%QY0GpipkG&+xxlmMuO?Sa2 zqkU`}88jIGoL)|4;7f{42XrGKrZHA>wi??)TocHt?eH!>Zl_L%CKVUoIj=U~;9<3o zJUP9L(!4^HvJ^;h3^j;)OX>eux*1uuJCi#%o9F*grOzgz-%VH3Z1#n8U7hb;cnYA* zZ~7ge>qly35d4sPm`td_pQ z>dIvv0@-XL9^A;@XHMV}vD=E54yA{d-!8oYs?73G9#djQ78Qh;zw{aihuDcr4|{r* z3}(;bJW5~wF8slx@RZ|}6jSJwWeg^p6F`DC{;ae*jVy!L{l+Aoyek3d^49sbKw8Wo zfd!A*dcC*5AJtg;4O78tk93Xs)&F%pzIpM}{Pi~Jt=oM6$M^`9=OVgq}^)fv3yl#cKW#C9aH9c;572ZU%BVB1aQlS;(QOG;z( zAz7tsnNW+)xhK`64dNh80Cv1z;9b()VGIcPtdPl+-`U6hB?1y zD_(rnykbxNk>N=k%pw65D7DKfrfs0TeUPj$j1xYee=h_{4bzXSdzMQ?Xa{4bj&lH9 zwc+#`s5dm;C3;G72?-q4Ev7I}Ak+@;t{_O@FHvtJ-#T~0u0m-XmD%QDmI6IVSPLLe zAzdmhIGh`fAhZC!v@}_QPtYG<5g#@NG<+%lQx9bW$0$W%W#5O5G`@}eQF36YsZ7<$ zx#Iqxqjiw0#W;1A^GAnI0V%09c=g-w4y1gZ7X#OV&ZD>p2q{8Yh%X(z=}M@Ff%QDp zUJE>AJsnjCQV`nxe5M!$+AWw&ZA9D%+p|H3Ddys)99-b2e_sc;a2g~(u3jrv zfh%I+2eQ)__Gkxu|zW@>TiOht;@NmCcr4ViE>O5R#?hg}2s9P5%Z*LW^#f zptCgTQgEzlPQ(dD&-XoL%6W>%FbP_jFUuhqE7h32RFwI#6jLcYk1FxI9BFBOn=KaTwgXX_vY&21zH>`K2u-o>l@ z?;p{J+8M#Kn!CrFzJYmkqc*Bsooj(McQg95qx-8)o?&*yFC~?IJ(;xkQ6j^nm|(qC zzD83YRr+b`mEaoF*H$X$!8hzlS12dC#-!#Av=dkJK$Mcq)!zzfp|z^;lzk^-1w43C z(%A_sAf_n{R`y$j<9v?FWP$fu?&T0FPaCqk7;&JdI;s%mx96X74AOznEu;h6fT;;0 z7ctm=JTJAujKuDhW`gZSHL1OIHfJ)t0PpIIMcg}gzhQ{N!nHfD#Z9 zF$jJWU9!FEAPOxm!%ieD(7IC~Q~yGXVz0Vf*R_@g&rH2ESPM1Vkz|qre4Wlk!Htl8 zWl^CT^}ayW!!8`5up5^QHA&WvUc^8Z(J0|KM(0SA6#d1{y*uB0xl7u>Bwf1o`K#B0 zd*0sW_zs*rf7tZa*_Ud(_UKS8iu9oihLYRrD|8}#Rl;t7oic;L2^X9uoK~Sm=Hr>C zN;g$DE-I4^c$;d@BSfiJpu`Sr2g$-@iwqFFqodyIQZ{q}(!SIY6Lf2VQR4+L*XR;p zPt=`HX_mq(@uEE%>KBsmz(k)`aNo5aJOS@>w@sWTWXGV^rF0&(+p;u+M|st(B^c7z z&rk86@5Zig&nJH-Q(_i{x%%=PZURNubEIG}-0I(Q|tIGdSq*e-zW9(+L<$Gzg<%6zFDWrTfP>pk3o zRb!$+GCrZ1D}Zg+X;S_ZE(3xL%IOTwCg$w|wW^N}>mUGZsn+ZwKv47(x~avVbtAJt zA%>iDGEtaW_uD(5o*saRI{L{F*h6)QQ8%}8g>I*3r{`BPLek)ABC89ZZP&^Sm1gEK z2asu-O}Uq<4My)FqBDFTRa$GETms+$B~RI&DpC+&MiJs6H(n!Y#NtUy*9zP;drPGLE< zv8AB@cGG)<2fh!-YKRkL}mm%Mo5 z+_{xI9R^176cCDnl|Cc0aVUiqkIAGI!D(?@SMvUwB0EZ6WL5$M&M?$5avu=PQevhO zsz?VvnnW#FRdk-J-4@59q+~X5_iLB~cN*r-%q%#-m zP_m!KeXDCjR)LDqK$P#Ok-z}(%{w2#V3&W>xb8ZMi zr@mtgAv1J?Q-;pki4{i+mM1=ZW?gVt9wUnj;^bkBkj2K}vr`6}lNFHq_5+v7cl%7%jo>tquE|jG9PwO=Aa7)+EZR^}zMBYFiodKZZMX*2? z*zGSbPNY59z1E0?WzS?z^O%NepJ$;1hov#Ji7PF5&?i*OgW!z1|Ax7{HC+l8sZ=_- zp-kY;1uZ67#{RIkdHWDHd1L<7;mHLm^^N(Xay6~*<<;F}%}Lq)*y=4tvi?t}XXh(N znD;eE0?MN_*WH99zv&&le&^sP1yB!GzhB?hb!nlynKtl{i62cD^R1-!y0y&jAoc`n z^sk<~%_TQza-6R|17q0jHlF?!*>cUJ|zD+kJ9sq|HBvOTrP-wGxE9d?DgkhDJL{aU^6 z$vj&<@zSaqM@a;i??iGE#G|tE;2q|b$eceT9f7NkP@o6f33OMV7xob=(&8GoSpr8K z@nh$TrhQl_o6Hq;J%RHMi)t!@1e64yF>We1-e|ov_Sfu|WM*lhELk_R*&Ds}D;+B> zamHxH8mL3_ec>4WXdbK^+6X7yQJ0kPa1ulDK@r z)#!3jX5!NVKi28#brMp@I=lK0e*ZP{=!Fy{>J(E&90mJnLt9O;MT8-n`k5Q}Q=|qa zMUyK<#Q3_r7Ebz(%`C3+6=Pb0nS|mNY_TkcvG5$X%TAD%YVI8yb@G@}xu+_AUvQb< z!htXX(UGOHQipfDkacrvS&tT(3rdR9LL5Jtt&yBX<7FTRI!a=K@1ZHq1MGMwMxjT9jb1=%N_>Dt% zgF_EC*ZSE{hMct`c5~ZH+YTI^(tdmvKj&NduV2fjF;6Zi>4%{i0YEiawp!0~2zT3- z7kyS2k zaz9@Cf;NmO3zZ5Gl!1G1Y-tca#J$&9F>?n8(Ml%3wwfY2_CKPwy1zgxNVJNr#uHc+ zJi(utF<=3@iY+wxpu#?Cm}VUyLfm$o@=6BC8$L{V(c%|{^hjY?T>XW(+teA>VrOC| zWVk{9w7uX4Hh@9qarZVzSA@gaj=_hZ-&g3!WxX|-(^XEor<5*ijs7>6|0i8->%;Aj z|FC__8C7`ypPp`gbos%5;gef8Z~p$HkLJIb&u`uQ=w|$T^OpYQf44rmdF%JTo6mp$ z@y8#0^!pEQeRz}4KKS^Ec*@c&&8WYmI4jm@8K5xxwjtg z+}*wZ@PV6of4#T=Be;G(d%Sz+(e74zX6M1~qwi6mG}~<|9r;IP1pR-HZ~~K0pq1j3 zEbK;_yxyMeJosXHBr#HN(OWw>-V#W;aHMJReN zkBIZ8-w+LjQh|~wm7E73wo^eI_#nH+`PS(m=ZFKbhPdh=7&S0_5#qg0WG60Uo8R32 z-A5EZ$njryDct-7^Nc%`UOd6zxb?{=pWxhr_wK?V*woCM`ied{d%D6^y5T}V<9Cu| z+#@&$KIXeiBlx&o=-S=ujP{2=Y|c0Sz>piC+|-X-`ayBe#wQ=@2W#2*C;z~h8z;bQXNHv;P0R8$E05i!blNx2Dl(@MsyX2EquCC zKVXPd8xes(#VaF*MtSKSm82kRN?R28f092fp>QmNNG%>Y%oCXGw z4~bF|bG&7hJQRH+hE>LG6%533wK4mBwN5C?>vUFaF0$RWr_&ktrvzmaUTulsj2J&y z>*gnJASSb4K{74dY6z3`m1IV@XA&j{u5#O519|QrpfM`G^H6vhMA`b*QP!T%s-5G3 zJ2|Jfe{PzI`{6hykli&v;*)0=kUiM}3i5e{Rp~l`NWpSeuxuW9OKU^*@_y2d3PTq% zNsCs=Q7uiz9+<*6a5I5)9hw4x_3@r=A4Qy}{4*`aGn!P2MPD+ZM5Vj9fN~^JZmE~& zZ?vGofC}AO`Wj={j}xA_uB)^0-a5*bt_=_AN_wQOXg#I& zr;~2;u)cS@pxQ^%{ByERUxRVbXYCMdZPEMow%n;{$*0e9`^ zJDsM7%tk`48G`sL9@h>oMiN`R5)9@ZkgdG`iB)v<+LOJrG~M_OJL&4Ri)YXC6Mo~9 zKVLlm_b`#-C!o9isk2eaAaX{!KUwJE4YJ?ktBu@~#V?;}G9}eXvd3=q4gLX7THoNT zlZr7sF^_R$GrQvQtFc$~Fb8(GNATQ|v>e9KFi9dZa4(-1pT~ZbmGFR2~c=NQ@G|mgHFsQ?LqIi+7Nj ze+5Ivoz_M~JGwVlp{{fs3pqhU(9}sDl9sMl>MjUe8d_{(+5m(2)w`$aBXSw-x|J&6 z%tkzgXtHVzKqlbn=}YZLr`o8h2g9Ad_5 zW#c4rwC3)SOy;uA$*w`GI6_}`VG5A$)+&BTa-Go{gIL<9(owR*jzKDfB!bOU2fB5f za38Rs%_fmdvQ^twKn+DisYa4hl&Sz%cMwLSV?%FRVOu<~K?O_@sT^O5pIO#06Pg+_ zD_D}Fz-)xm@@JZ zNRZRPU9 zRm2dvO5x19bp~&c+2#Ja6UoJUR9yd}2p3FC=wja!v%qC5VXWlr+jruc?Mw$SBDbj7 z{02P63J5Bd?v=G?GPYlR7Q00{L_RVXzj=%#svttMFE zb1Y9@NK%BXj+d~X!(i~aM0+DM0tGHqkt*zkw*uS0CJzW7nht)MI{?7UGZiN1x3l7M z;JTBk>u=pmVh&ZM98pRR3ve!A9afu;rCOplFRUZCre(mPw)qkiDgunbXRVP$v)ue(1#;izT zdinD~eod3zy%$Ha;fJr|!+e5buUA{TNOgQ-?`*$xGtKC)Jom3~*nIx8tN&=f{|Z~y zM0^&%{2G{x#3s%<8&#P&762azLOPESB(xcLR`$43Ce-=91b&#BE&1qm%hnc_k)d;X z$_+TKMiF6_K6LdT;I%ZMUngyL0)W5H6KX6sfBW_QtACtx^&UTAf~LE*+?v4piEjIb zmD{f|(t|#bQwk4+)2uA4O*NymE0u&DWOHh7pfFWBO~jh} z3kYi%AS^D9ZaGs~Ls0xR*u1pO_>1vX+#BYejRD1_5kSgzPNvrsp;kzSS}BRatU5yx za(iYF^lEbx!G9{V$tZ-S9lx&nprYYOe0Z~J6Wr)~dFN57TAnlWV(99w3iJXwG)qOm z;A$yhJq^r=)I?Y8U!bI@*TQaivc(G!@v?kz;-k6q_m-au8wu!y`sJ6K1J;=)%3Rh4Ca6j!@0)U5jExbq=@R24Gjk;R?NPlEz-#a z31)6@3vmardamFC{oCvFe=EIP2Q6zmYa{h%tRxYoO}y|(rs^Ira{jy;oQ9NCN}`;$ z^Tnm{{bB-whHQ#DI@d@V%09kXoVtwRV3#~Wk?$9aUpl#H_^fS`ijv3IR_V19>C)J0 zG_AE&o4d3$YR9O$io~@@uM2y#!^kzIQ!7V$kEfL=LV2m_aqmFJ^!+H1Rz3cJVUccK zfbB;cdQsZj9Qm`;Q#jzkA$&1FAdhS9#gm4G^lmmIvzPosyuFW#^gb$*q}{(kwdnD*d~!;2@e&rJl^cDu z28DUuc(@ox#k*t@dny(%MZI%6tAxKn1~h~j4XnIzW(oMqnp7TiJHf2i z-=l}khm0N4T zzhEQCOd2&|PLEg9E@uDpMO??aF)v9%S5aTk+SJAEcI9rUPhfZx4E7%MK%DZh_K*fa`PukGww_+c~%^;syI~j|e1wQASI_3i-C) zGd*~s!!`Y_6n73Zix2Ka%Hg`qo_c+LkEl3_#vyMXReq#)@NHSPZ*)_)grEGyfH5{v zwd~|jDQtvxn8J#LeOHPyX6N=U8FD)xSE7-G zEgP9;Mb^%2zBUNk;s_z#Xn%R{sP=^%dq`?|~xsT)(zKUZ!l|6_|DhX(5%;#yMxY z23*ua1aB>4%r&?#UGI?jMdO0f2{R>2E3}tsvsgMkpPmq7orY`GYcX*<9cL)4nfJJO zZ|EbEY6rertVIrYD%fELb%^sjo1br*H(b9iWhL;a1iVGpY{l`JVXQm8ssW6xL?_HQ zKxMY3?Zewi<2`8Oy|)s_n?(IozBCCxVyXq+CAQyQEKwd3>Wyr_z0)|TlQ?bg+Q?`w zJ`UGS_OeYxwLV09eThz{OasZpa(qU0@b)c5<^>68N^9dyuK43#_N*?4{Ks#wZ>u z8p9rk`O5sUz;QAI$|};x@&pZ3NgQlQThNP*OG&$Dj>u2ITnQeo(D){EbAf=ONYX#* zfT9A{8AaI?MUJl4mBjmi;=7zp8k(r?SN2OGnVcc9ex%6!3Sn_AsD0OX6|q_!OSx{n zu=)HKbl>c0@|s`&9_rFw@P4_h)g!oWnYu1 zbnX!BiZ8ETd)?x-63p~6%Q%FOf{Ao?@&t(M7kD&v+g>SGzMU8@V^uqHM(|E$H!-{U zW&RZ8aCLRx6%db|7}`RcJe=BK*An8%HG>@*#Fs&Cprpc#h#I34~UvR=iN+ef9DFos+&;I%yvd zhh5<2SaEkcnLN+g5L46I7$ejPjsLmDqB*8e%T zTV<1*M|B>adI-~P#fk=OkEY5TPA4IA2iFw?oy=7!Eh+A(dAfK0JWTWft|I`opMcgt zB7)(ck^C9rc{9cM!N^-kc;zkwg0B&L%eyyBrXP}~pa~N!57rTS6cE^9S`xZausUwb zi*V3fy8z^;Q#d+cXy*1r0M9S`YMaH4t`zRHa83z-Lxbt$u!OSVp%zUqQjPmBD{oWj zKT}|QRNltpEAqS*XIOuJARafIpw9N{HLquWYx4s%5-~s9j5_ONlI@&zK4OlFKW9h0 zWj>jwWlIPGJ~+L2^2+_@B`E-te4}Tg1x~rK$n`R^#q-|ztnJ*Ym@Rz@3N=+36^jC(ZZA{!4CTj5Tt-L@ zYyOoQ3V1km9h1T=mQk;LV2Qwh&E#=1WEfl6I7$6iueBG%8#2r}aQ+S#Vo#`;%@Z@B zk~?xZhW%dSg}zYAh(N0DEjWI(4m?nnz@gFhz(Jc0_KRUFr+pDu^>%IJw`cL!4EBNj zBM_P#FFI*Zc8Qm#Ox|-6kI)mxAR5on*^|J-TjLkE^u-79Mf}|RAu_3XQNKjlQG0dr z-7P;cdE4%?E2K)DAO5g+{mT5x>%;Tx(6o2Uig3)L#;G}u9$(9nD9wDq>Nol7AEDWVgcG2&iFvR}dl?XR*ZKrJR%njb{)du1yPKOTybMtu?oV$-4k@v4l+1@H1Q-kLw$^fd4gzkt}iDa zV*y2E3_gESeX|ym7cIarr?Qe-r<7QyDLs=$_n|I4Lr*BHQyfvsMO@_lq2#ECrc5ip z8@)E7!w@nj#FWlos<>qn?+ih=pyKbB1JA4Fh@ID3ukMWMePS#`y7cIg6o5{tSLv(0eCjRYN#!IBB(&t!-$4}5vZO+4a6uL#rk=Ko*(Loc4 za1a6o{O|-?h3~g}LMFbBH+goxt(Z-C@zXQfJUr#VPsh%s+5(&wgXiE+1fF)?)**&{ zOW0<~?;w3ejUi0c#@W(ZI=B^d3EaEUyT8``8*prN)V$L#c!NPBrwG}hS(F4>+IttM z_OQS4ZAF_d-vYQ|veM;(e#^&%qX^4ein4sEauK(9Wz3hD@CFaGYXIW)UZ`Ufcf#ys zm@nk@koa$FUtI}cNZ%NqO13k!R!FV3`l^<6lYAJ!)#tHVEv7QIcNqT&7Nx!(fS3?& zZ@1DbDX{QxoJ1RLe+?7J9fOI=Aj`z5yMJWZ!TRK9MX(W)e{F&sU`Pf z)EJ^Iek@Z>(9|m1zQgR7;*Fn8x1j)i2cosYHbWaSX81;QieYizX^4cQvx{E)yFCwd z)<;%56=uy(^)zX8*~oTf#m^<|x=e`P_U@&ID(zG|LRWtT<<}@ePM=;7&Iro!cllwR zW@wzC9$41K$f5&Y-(gGHgp5amTgM}jiJ2O#rzy{a@XLhE04ubVQanGy$9r^wVhOM3 zCyE0WE27}TDxa`!WY>U!$)j zQ$!*iKV6(;mk)|$A5ELhzKanF*#!u1mu!J_KGW3Ij5I2vtCclvR={4d%=Ez7S=L-- z=JGlRBM)n{XB%A&?idFd{_sAa=hej{aEn?Mhr+8TI6b+$O_?M{0rH)n!OBx{52?Z* z12VOnehz1QFMR1I-=F_XsfY+AlDBfO)X$XXfT(OY6=S8}+&L!ae6}h_8;|N(GhO4lP^_}3sI@m~LN&ky@ zf25;ThL~NnCuT3_N`6soGkJI^c?ylP%xJgTyJWZf;4L4(j7mN^u3X+ ziqm3OOW)K+TGNJJQ8+K6XvH!M(M9W)7H>M^)`b%jT~|y-@|RwOdb4mk$DCs@C%CgkG=9^nIt{ z8upmrWnV$wIr{3f%=4P_-B)LmJzrD4Q-iZueAr;Rk_(*qU&Ck zbNEZ}>?}F6{F@vSZ1r#G)^@!~zZV;RatQV%^6&@FF9HePFB1Jc8a*0O;znO7Vz-5@ z@rrDOH^$pLD@4xwn-#UW5+k*f z;6AF;Kuk3aYPME`s@nZb8F2)9>|-xD60V)awD$fMCmg}8C5Ut_Kk9+%gqG^5X)olu zvIx#+D#Cz)x~N3HpU4`2PU=8QgxB;?5^(?#RLRE_uY(fWwWv`4*!=w%t^mW)MQOfS zgH&BE;C7mYZWhY`%j?TQ)j|prb~O3U+P(Jdu#VsYEmq9xB}~2cRClA!SImfM0he}2 zPqEZGqQ59~D^=VTeQ!7GE89mYP$albuOVO@XXMj)4w#n{woXWXH1oBPJndsRiO4I8 z^H!xM7aM4AtQp8eUk_c+L19`CL(z#ysRXmM?-bl3ZsUKsD$;ubs8FK@Wap}(Gju(G zXt!r;tk4byMM{7MB5(i*n6tE68IWz6=oCUc5oMR_4di)5{WN)Pp0O<~P-zY2H*CJjvlJ3Q!0ENA)TyQjAVt z7v48>4m8HZ$=(#4WY`yhUXm>Byi(0xXp{|3e;2n%i9=F;8N@+wj6cr0Wrsck$()Bi3)|c2O3SBUA6qYt?lQA#v-t(6*lppb>+`ODGO)8<1NqND#W#Mqw-9SZk3Jou?J!y6a3R?ogLL zP`6p!-J@&C>9eRJZ%(yzvQ579XWNviriuik)~MQncN5JA#AjgR0T8?@E477T6P5S9 zxJv61_p&g2t$js_QbT*6b6~rQ;atlY_&&@p6FMh1-l%nB2NW0wWI_!J>BXNaThUH> zrKH4@@FL1x80UU3gGsg<2iTlBN`ILg*RTi#GC5Dg%EAH zMR!`$1yvIW52L@pOQKh}1w??A*l4uru;zjr+OOKb4?-}Gaq*3A^p&=AnAKlo;G`MT z&01b(PVb8MWqgSmxG$>5_gXXB<};^12nty>wrHeQB-<1t_jzZCxnhMqFf}@5`lk^l zMD$a7L9-y=k6fj3w$Ox!%>{>BYgXRrrgT>_msT@k?K~Y^?QQ&M(gY=7rG~4F@C`fY z*TYJCz;V{WHs1dl`T*3HcN-g3*3`@w+*M0+|IX)M?jXy*z4PTaJ2NhyPKV6pXJ9b- z5W4IxUJEN7VUm_sGMr8_$#VSG!AJs9lXu>3FS|SulJu*Gk9Ov}JO8;$Mc4y{lN&;< zalhbTD`!vhKo5{Y&&6`p{S^kcm>p?Z7-Fzxv41Ms_Chw+Y0>)-XZ@?6Wii*u0bE!~ z?WD386uv@6L_4J%liO0Ie&OfDXCuC2oD5shlqLoU$qG+^1%0xusHr=m5&7~QK9+l0 zYFwDB0@;@&2p>k0dfYY|C@9j}dIp6v6j8pe(Gs*}!r5JILCr1Cx<@wZoSb917;SZ*Mg&5c|v(**4eQOjJ_8@TwX0imSn(h81Z5_Ks%t)G3%>&$~Wm( z=u+UG2U0Nj7%*$BRl_787lDSu_*n4v$3rSk?ScAqR8dTTbOKE-Eg=R0Q!+7wkXRUx znLiOYT3oO@1y_ZS-xR5=5#XA^SchnEq2C<~q4DlF|wO1n*T*+gQdfhu@mrl}H3pX@q-HnIurYLE*6W%7W zfJ;pm+tvjuyP~z+^RPu$(n7bG6(SlZC0hMQkI)C1wC3)hO{9x}1bbQVaz+?>8MGCg zow232`x~&my)znr#56IjUe{b=O@5&i&yq9ZUHSL{XS@wSMl2&0VefQlT8TRxlQAiA-%F_vtC zs9e1XgOS8#4MulKD7fDWMMd&PqAgDn_$DEJ>X0J4nB@m4e%k%D+MpM;geG!RwBtI&ocC;1pwTXMo~kkaGZ^#&6lbQujK5)jTL+DV0)68p{E3O*H3+FOK$4 z2`s~wY&N(HP6$w5s%N>@NwuOi1~k+P)7YxSAX-3}6`HGF%fqncl%=951`HH;4;%I| z@~fZel1%F5#fd2w#2`p-_c_{)la0LqxZ$i_7|bd{Vik+qsaux0=Cytev_<2VbhKho zhn;LyMpWc2gwE3N1iFv~t=`NE`}lqhWL5#e*xxW`9BiuUf*mUr1n3USr)7oJv~{*k zZ&*!ljnu|Qr4unO+!{2BFG_H=JhmZv_(p?iD!fCWFI{ZYg!&iVf?An_^lfF+wU+H; za@d=sxdl4>qmLlJuvA(qcR?3W)9q5Cm++Xv#&Z)dBMKX62J-B1ns^5LMMV8Hjn6sy z`JuE!`9867oa%&kivF7res#EnmYjD1mx&cM9J3nCDTm;+u#|8#6JQCSbJ;G7hfT*F zmOU|0>{0KP((d%zHP#__Or$bphs3xg=C}s(Yox^%pduDT^a3W3iaO4FzRPA?=d+gS zHA1BZAJP^t*^)(zv~+;Y09H8bLsu_T)sw%>^SjtL^RkZQm5>* zIT%pzog#3_mC_t#0v8mHUD1!T(II-1G&@BF%4o=nG2U{aU_p7J1+pZY7iobI&=U`V z9pH>$52b#e?>&udi#qhw*>bb2U)a<5HSCYAfS6pPT23&_)Jk92 z#0#s%s+H8DYhcg>lCMtH!dafY<0Cn6KP5F^MaB?H)X_)_E_aVZPP#mm7lf9e0=q+D zYZ)(*oh7mJ!+Nwy;^;@WVLO3R4u#l|5@dawcS>bNWHwNb5>;Ib4s7%hGWQ#6qTmC zrGl}qI_=f85#D2AuK;MxSlL3c=E!c!;MTZq=KP*R7vsv)MT7W7vGT#hlV+xIW?{uN z^y1|%_x{lUpn%! zqmb(UoT;c3C}l?)`{~JuRKxtjT3vc}@v4f>c~c4^Eq3uCgq9DFX?8J-$RaMZ-XT+S=&b(0(^48|Tvd zh&8$5Uwl)qyk#9NG%H0LExOiJvB1Yxrsy97)+2Ee?daL{}|t{V1)zQDXy1< zPjU;j35iY3ORq-X{Oa-67Y`qs?eOb&sC$%`JCqFh)bkvu&1*IfMyZWUL;lB-U?}B^ zKtp!UJoGGb)y3eW8c5C1`V6bf>P)CPUoYM6*Yup7QOe9$sya(!HpPWslq~)hT?g;Q zpzH)7Ep!v&;xPr8XU8;eJ64neCHx2&f~N3up5T|6QTpug8Ip+0YV0yVnTapssY5Y! z8wA%bPW+4p*x(W28xD95Fan<9l@Cey4(kZ+DZI;Rdp6=gw*RG6!d=M#rj~P19XvEX z2ylh$a>%w_vDk)BsKh1VU}`q*3b$Xl!&qMG&z@I}j1#cj38~-j>S@c21A!Ih#5x#P74H26+cmL?3nWpCrz!so z#zNwZcaBwB@l=Ao?; zyjHpn!K(7#^9gZJJ_+?Nu2Dk!yQb__5z-yh(c=24XXs_xR}JW}YMmeub@xTH!^4R? zT5^YiI-W>_W?M34-P7av^;VDtD&L!lD>P8MEGwKid(bR?VN2VCXcY-#KqF(-7-XNQ zvU#=k|OnLBr_!~Z8VmH>WvQ`T%HGrR>7 zGee5}NVOwwjL%#vGZpnBxmplM^ldX&k>zm}QgVhQ$Z!G_IWogUeQ~HW4X?Q5UNC}g zL9G45>j7Iw>AR1Cylg`}ADNw0V2XqQwc~Nq-*AWx zyb*kO23O3Wj$=A-mN^UZ=lX|gBfK>HbmdVN`Ad&2>r3b22v=kMVMHX87dRFgh}i#7 zNt(o{D=$V$76b<2WhPu zwL3kPbpfE|_ZwZlqb?Q7)P20b2YH(vkbfKF3)N+|w8Z79>ApAJgCg+5y;phF&iRa< zaRgBNMbS&-;OMKA4ltdAr?=QNIF;;rW*XsqV)a2-zWEtS5rfNVx_@WF#fs@ebDl|o zF{vZxNS%FMq7}t!LV$JPX{j2c??9_EjmKMoQ&l52g-_deA1L0|+NDHd$aBmI&{4uW;TD1TV8$067J~)S_j79JLj9T7o`BzP|F(7 z+cppM!X;iuKT&wzUE2|AEonR2N9P4g4sSS+-EkI0OOA4NE4Cpq2robs7AiSpak%%u znx$05_h6SJSACdlGc>S)bAsvyl*Ge=+nPi)79Ig`IrK>yNEuqhH(xNmiX_%sf_Hm+ zX>_IxU*F4i9Qx#IRH#eW=_TXZJ$*Tw4I^+n{24h(Eb*&yzs+vE@qgA&>2QlCR|?}5 z^is@ulHIaZ$R2wOXI={S(Nz!J|DjQn-EF zB3(c76CLHG1-ZK{x1*Xrb`rqwo^6dx4d7i?SjUR;dSkw;!WQ(rdwAt9HE5n5Pq0__ zdeOu0io~_@hRfqVW4VdE!x!hX*<{1RS8LrC&9dsD`=sqlK%=IDyBzAsK@|?rS|}_< zcJJ{KH)E4(imIHEi@SF>Its!_7SHz8!$(%Ix=dBu4Jk$HJlNj1W-m7+$gbQbH5pSV zfpZY1*liS=4bu)mQeQ|Q4vscj2!^pBR4m2F{DycXtq6k0hA&YHwT_C^(z~B&m0@Hc zWuN)ZU+a9~G^?&-vU%(eNFA%94tO+-+0y;2^TqdlccN6bfP+2w>0FRI|ACeLz|6#i zw~n8kWVgidA^xBT=6QWaMCMUZFJD$)WsG<4Uf*P>4B{6xkm<@5z1(8YyYu0$`m5K* z`783@nr^-Q^`K1h*al|$f#g=CaD;Kyq6^JGX+N=si$N#;ij)X8EDmF`33aNE}soA}y-U zR1y3#BvV!<@T?Z5U`Z+zee}63U$dFFC`^1h=B$j;#t{~A1nrbcpoyIN+_5&e0R%Uh zxOpum$Nv=HnfHZSuYro$WaDS6w~?_OoKv1qf{fxA%49sjX@e_V z9QPVksuT&3`5KRjYV~NGJs*UDk3*U**mZ$C&7EW4SsE7Z2D$FCYNd^UjsyDf!6oEl zj)+w^jAI&KSi;j`>3Xt2ZF1dpMPNnvL9F3LqtPqpNdfq-!w9ThsH4Fq(m-bW`%VeM`QcRbz6|3qfabrS zpGWeUFFq&hRAN^#V=ie_61bT8WP)>rW0>BBB&r=m1e~4X4A)~OcxRp1ijfNk;))@L zt;C@@z^S*IMg*hZ;J{<7(1lVw>9M$1y5P%WVR(hdqjEh~^5D0#%PF^=y0)lx7Z{MOk@EW$>A?Ul>4Cua3B3$bUCP$-3i+sq^9_gy>F1f?{@lc3~JpSctF$i zGJR*%JDX86zOYkXFbB7WZ_o{6Fp?CemN@R#w{h{nasScI-QD}&?gS8(WWRO)-q!9T(*FlIyJ&6v(!>uI ziX=MMf}=qcmOcBu*GOkr6Dy?DQl5O1_UH7e%NedHdWex1a3SlN^J|3EZf(x_`N8## z{A@#?ZOrx02OIU_6@5r6TYY$C>BH%h`FcHR+~0A#aQj1=oN6^xjzDO5^HELUUs6?+ zNPLkcp@9mi)m6ik5FT}mqBlV_1R5&U1R=Z_omM?=bfYF1CUByw+=dt9pouTLw}?`r zsuIZn*DGDHtDjr*uvTCtVVM2jUQT=yI-vf6KAe zv?3KK&MM1dsi|m7F<0c+KyNOq+qb!P7S0woN;?e%$9;J2`pTG?Eb9Vi3}NU2(|eFf zDljEYJw?e!uLV00E#~_5&Cyn@Q{VaO>)r2TP`?=>Fg~!2UD3>jCw@cMSdak_9JL*S zXo>aLRumHNPPP6GWF@x%j7qFI?&%R!vARkY#itRAOQj> zLIgcH{@~76I|=0A1)Tz0U|P>u{~Zu0D9;OxBPvXIBfBta*OOCD5u;4lMYoZqz`~bp zbcNM6X%LgfSPU_;3#%sMZF#YM`V*>4mAH;jDul=--c!^;x|?yjUEys+wH@Ap1^q$a zfy$1AX7LIXH`4oEc#2DN$SnbQUO?9B`e0PL?5jpzp=>mdw}U#aT(6Gg&Yl4%ijYRd ziaa&ZBnzX;PDF?rhBAP|)r_$h;2?4dBHMI7{ecNoBNA_$xMBH|{I@598T8T*e;jzl zmoY&+N_yPs-+e;?=}`X2KY9b{rN>a9hNoog<_Y5W!zT!T*LZH%w4en%4j>o;Zrpq- zMiU^0Vg7Gl*ogxWKp4NzKTT;%2RBOCt^kkJGD_t)kl6}>yyFf&mR}*PoOOWpCJB~S zdpQOMOWI6(qINYk%4&Cnw5=v-Qc1uZ7>QFE>(bAuUbR2Y_JN;AZBTeWT(c#HwV>w3 z!9m7f_RVtTx~sh^vt8+N2uYd}<(7C9RZa0CEKt>dozp0h(aIjl+yvAWSb-96g1GcG z!d;N>8;e@FmcIjimA{Nl`923F6DVnAXqUS9w+&C8xj#}c8FcVL2nt;b&Xg~Fac$n@ zf3(U$2Z=C|OzVm5AT=XQD_bkUsW4vEoz+xa^R(V>Ttv7aXiXCYTW1OuBP&sD zXSG1J0Ffs*@xkV#ykZ1n-{ci@gGk6i6rfrLj_bumpqtj9CA6+9gzV5+_8YF(LNnlu=)(s`=G84uSagb|~WDhJ|%_GP`I&3d@n zfoIxBYkt{0@x&I|hpldw1byPc%34tU52fg~`d~^=k=v&yW>v}FaNN^CR;)$ZfN*%~ z6qY+oR8}})1}iqeF^HU5I}C_(o>&DO+AMo9<8IEn;?bX+jB3ISHkGCn>1+aV{-c@A=ieZb*|v$a3uKgX+6)bvK1eX=NmGLbX=(G+cyC*G41d ze6ra8J}sx}S3T~fS@SIx2|c-tLse3E3BqeUTWnF4L4@YAw{gDs>dt@c-23v*pB_u? z80-1O2NtTUjo|l2zp*NFqMLT6gF`xLHCY6_>hSJMCweHdoF%)kNq z`9cthkA75H$9uLw)d94ZHrufVo76W zqbIASSbPs2?k7iLvpTH&Rl=a0H%`)Sfo?H)hHc# ziTQ1KhTDt8oIF=>H7b^t>#?#Zc&x{I6C-If)6y9pMZxeYA2uS*&TD7ov^Py{m+pjn zOIpqiBh-~P2)BMX_f{A!RFF|c7eBbFI(iBBQ!X`TPFHaWYwkZwye2(LuSQQ}r9W8h z;big%{4KZ%=)}W>rF)%+NFdCwJWU@JzMPl1Ru3R^W^kEx+vQRS~UFfXZsq}ERN2yg9p&%xj91Rq4jjRT4U?EXLf4k9B4W-TG zwR~bI-HMLhCels%m@uyKuJvfb0s6J08j^7koC0}?g0?$N7}+@EReZyXCel9<5$48< zt*ZPo?2r~mFE6s?P7UbPo_pdH4^%g}YANkA!@7?G=9tCk*kTxpF?Gj9y)a$XBP!(4 zlKWX&IY-7hy9J2bv8h5D?GF~bdKm9-kh5rj>BSKA@m2UXd7!lZ{hjnU3sKKnalzBX zIKBVy>6k0sX|!iH;F_%$#2zN3)13bhFLuJ3hFVvz-TUSNLA8eu6ruP=H9n6CF(Rce<-cG3 z$K^+V^?DovXlq*f~&PVW24UTw{hO^_B{@=ll1XI0N+S9C?~jc zp~n8hnUxMRj$Hqz3BPmQ=Gc|Ch3FhbPL2LS#Coc$K5fs)*TA606t$3%BL)u)qoU>a zl#gLxoMykQ!duqO(hNLxJcQ*N<{w{@^yP;@yD$f833jFqnLTaR$Y(=um658tQx%S4 z4>{r>719EQV_z08UMK|tATkTuKpI!D)GEBIx4gD3|WS1ih& zCx}+K(#QEUWRC6^w&LRykB`8gd-MiJ~nOBZ<3GvYLY~?In(>q4)?ehP&sf!ZFewqOF}dhjS;n z)KL6HcRkDd2_b5?xYnxJxQTFz*DbSpYRMgyX z#k~(+8@(Ji)3j08^mcmoy#P0ob$mnDM#eAkEMW+~q;Ys%Hc7C;PkV(t?Dwxjp`Jv) z@JbnL|E78_QGgnDEJVrsN+-40)444?3ifPC@w3CcQ^z#qu`_2cShK+6Hr2-0Zrm~_ z>_G(7As1G0sNPKaCYQ^SjuDAJE40#PI;~b&*61ctKm9hZ#Y(MZb)Hc3*cgx!R@Q0@ zirP4e*kCS&Q$V>vjeFjE^zf_A-G`fUxmIxa>&TY{So<|k?feiP{^#W_lW{2(n+#-y0bIB!Cyj8U_^b8-(NyoU7v;6>p3Fdty^Ip&`ft=M@-ZM!ZVtU4TPJ6R`{8brLY#vZ8o{2GohLwamnaY8%gvrgY z^ozuhfju62!xv*@NeX@HH%^-6hLwAgx)Orj?^OL(lW(R zB(s73!QRO;R071TL8A=_q&mFen4Y2RoxH%MPx6|uX5vlMVdtV_kOiOo<-MONi#_Yd4Az(Vot!&*T`cbnDZpS3c-_lammR9AsMrt!EuNn{O#50~8 z_GFB)f*q7&Ik!u)&Fy5BpAEdLb_(n!O(NI8Do2>`{j1j)TNi43CSg=oN%U*ioGf|t zRP|VCxoaQpdL;b_;e>6-cS%ouH@8z(in{d5`NdQDn|oN7cP8$xSj4dB$KTw$cmF^C zg)P4qBW%7mKn-+yW8*u4~8wsQvKE z)j^2^8pBJ))npO)V(b_@d)7I{FmCdULF}|#!it>w_V(##9qTjOR-o;!k7wb#l(SK} zs9sir8TJxdfv8B-)C;=63aM7UA^q|0qx%p3R7%w&-&20xY?^gMZ4Mu=T9GZKAXZ>~ z7}lX`oMZ4Vni6Z}qq}6_5sfvWo%kl@7-wWWaO!9n*j6q*f4)DzuH>oc_9Y2y?Z2@A z;eBbEDDc{Gbd^L3M`x@d!UndB%v5`mTJS@`D=mX(s5{gN(8KKTB&;w7;%qg}+t=JP98 zujw|E^B;6=>~+$euM7|IiYgO_2Zk?~LSB0I(?7Zg?#2UD53`(zdH#=-Yo2(_Jbh%l z%ulk3W*avNAg|0YIkvCP*YKDeyYzW`a7-wZcR)H2MX%%m_N1L`y(Z^oYzwW&Iu}`N z9Al{L^48?>-n;+ci_QBFiUJ=;$A!9SE;2KHCDv$T?sgr(T( zu}jHe^++ZoFZU`$+%#gLK-++w(dUiv#W=8lVv)JbO# zaqYN(LCvJR^9XG2vR$E4R&v+9ZrRHe_J*^F7O!qQs^eMoqfPUSxDTAL84ugr6PxUj z6F;#}z_rd1-)x!PI5@qLw2y`tt7U2dGgSenbb%LV;^$hvG{I2rY(X%BwB{Ve$C22Y zS}6-cu`Wkp2plxY4Butcpy|r3@I`Bg^>l5a^pD@y{@VOd!+5U$h60u*yx}YO!!&I>T_MbCwZSLr{z7nd-i<$`GA=` zAr6-Bj5uk`;Rj{fLQkJO!gv1O_BjH$UZ^7L#P)MtD(rJv$TtMv&FdwFPFf6bUswf> zU;e&*p2+NlB_C8dx!uLf?^r_fzF$NAyEw+jA${J|8Zxh)n>}Mv<&_iQptW1&7TeN> zwsaVYXkswG-%bTKf5d~UC5=BI2jNdRf{?kh^8~T@>>UI+4HRLpx zaIp}zbfSNfLK|c+k)|@fMVpb8erY!YOmYLUsef)41Kw}?nue1J`lrhInQo)Kg|;iS zlbAg^`Ji;)0sr;+d3!dWN@NygZwOFB=5SB^u!6Z~+~imu|oX#n}JH03>Q3(rpp(xnJ_VXiXCWu7&l4WMyTq zu%pL$bC6kL&ms+TR8ua#g_!<4v<{J|i0*oYXIQO~^GruT_8#2T5oblG#R8)@7LYuX z8q*rng}GMgqBT>fW%T_)Q`8%G5Z7N1Z;?crc_iFJuk5V6?*nx#bsJ4f25;u6sZ)xf zSAEOT5G?QXu4i~oScwlM%jB4K=*ZE@vNeb81>kpqOrVHhn;`N*tazn~R%5Aeia`4+ z3A#8x+rPcN{eCRsTv2+*l0wt0bL+}tDga7`BEJ1B0)R27x1|_UGp`{{d1mIfH|H|h zb(A7mCp|Xbj#fa<-M9kwH*vADwbBz@JR`HS9XfTV%F(d{3*Yb7eUuCm5rcR^zf?46 z9ESi*VOPL2tef3XUHy6lbDoXM_by(YVuFctsIDj^WoJ{PT*%YRfq~_QiPGyq<+SdI6Y_%#dJR5}0LJ_aMw$@w8)`rGj zt!6-i(~uq#1$9$PGdXbL>oPhZS=>U4syPRwjBR6a(J!IvA7S&$ns$=JQ)OKe`$J-n^xM`QNRNZhd^~ck}u0KmPcGkADB*tq*VV*#{qg`0;P%H~(8# zv1Tw#e#G^B&A0ty2=*sh$YZhd@S6MTTT@g z^IO}$|G3>wz~vEAwrtpW02rR0M)2K#aPOg-Mr=J++Xyn;)THxkLS}o_)dx1&aIP^NS ztN8`>D0C$*`O#DEdrxr-kWh_Z9uW(a*Ik+ntWbRP^x4_oi?|;czK`ujypSjws=+~A zEPix;PV0G3n_ScqqCKW>DE@EDbJS ztxx{&ht2uM9~g4ulbiZM;r7NSALz%2`oUT@KKY$~{9Zpk-kfcGqBlPIq#e>dwFY~9 z`t%idV3LKaPFr@rY=UL`F)7IbFMx^gh^+!W-=qobe7f>#tB>{B5jL|O!A}_A1p)}* z8}yRdlnH2y0)Ld$=umkicY}SRD;Vq{x4zt`tgncRA_K{r{RyD56izwkc*`m^i$@+- z`QjA+hpuT(0&!qQ>ts(}ry7n$*+p|zM=}R5wEe03^iU-vwb+dr{$-^LWF*q06`^gAYe z&fbqvJue`8bt$bCMxUl7h!iYm1xwYA>ShAy#8E8PdU-$ck;`wQ=Ftum?8QY030Xpwb!Z9%)~EN}yPRF#(u?mcrHr=(pWS!NI}UVcQ>?$L!i?gvM3QXc@GLsL zb_-j%H*6^VU%4~N6)Trg>BBR+#|oGBoSJGD8M(l)44EW8&Hizq#*VV$bI$HZ=u>en zupF>%@HZPn^r`uP?wX8xDBA$3*fy=Q#;&v-&N^<<;OJbJ0Kvirl=9ctw$$yfdukc| z+LxIDI7Z9HWL;*+f@*@uQJC9CmiIx}5|i3R1-ClaW{hOr?sHG))c1oP2EWm>+b@o^+;JES*RbPOQz zm(G#PFKMXZ9fH|l)N6PaIH6jr%#Kr+{cwy#8Q<< zR80i@eAuaNMHp;sgJaOU8FyK1zi+b^TucjnDfl2LVNbnp4=h2k{U6WEDbuV}jTdKu zGlOU68q_d`C24@QV3sV9$5tb>b-oqc0j4(rVV?VsTpOo}fao^LNx!fReaM_=${B*| z^#iHX(1J$5i#mq19!?=WSJWqnS=r1s+r${H_-(8LZizO6M8(H6##>C06{zA=F3{x8 zUR?--X&-PHcRVR#NNZQZQQI1yts4)J`C z_E$QbpE;YjyFy()?2{JkWYBVp$k1=HU~+FQHYGm%R}gAIyhN%@v{;K&I=g%Z?zNs~ zmk}uT-$;pG1F*o;xI(Z7CDTe=7Q@#^I@}3j*5YE6|4rSSHpi75X}bM6e?>Np zWn9EWEz(FWvSktq1XQ@g1s6bV);8SONgolUk?%`2n6^3lvFv#$FrmPV;VXI?^?AjVO-Y1wQ$ojYM)gBE}sMd7XZ`OcIikUK1a-%{H`5AfB z;3kH^Ayci|&h91!Xb=7$*p8U#P;x~#ivO?eNTO4G@JV~pF^uG4 zvdP~ru^0xF}-G&vlB+**Hskj*BuBy&lv1W}} z>~?Q#Ib(vv6~n{(>4wB8LF=I`1V)xqdL9Kq;^pq!d^?$>(@I3qIk!92HH(7z87U>N zguT`0)I?!9wNmPODu5|6sI@Q}I$i6mZxBO726QYjAZ%8YUFC#E)8RYPG$|emo+St( zA3u%8NTCdXtx|xhlJXu>qw_%Oixz&0n<%=c(i@di#04GR*6)WRwoU>h4CxPre`ukv z^Y1SawrBGN>> zYIBXDu9weV1%bR2&1ACwUgEiu*h*a|%j;>QZSTS6wJR^Y26aLiKAkeQJw5H7qh-j; zri+|Y@^72dyEaL#h-WF-yAMiN;w}c+ybgnV|0E2;sGGlLsMv@=L6}-1id4@=h}bqz z9Bu1QriS$;`FB;GdAm20oXa2V<`XsEzF9JO@iOu(v zY7ynhXAx@2s44je!>R1wbhWQ%x?zQ%Xb~yqv3^EV7)r;4!C?TAlImJJkJ!#Ma;z}@ zWnwpWX5QZI3ix;(Qlvfz9fDTO%_6Q8rwzE0T$gofz&!F*m1IR9`yj376ciMy3oCnQ>Q~yS( zKGB(iPXxcJs?+K!BKh@{`}4h>pX{DeyT9t^r{T$iL3W2Kp$!qq#P*GYy zRY*Y|LbE<)k6q0#KF(|Nbc}$>!&yiY89W`~(Oi(oOx2kpeR2RqcXXXQPsNo*-Av70 z($8%(ta?i&yzu+(@}-C1U(vkDOnRzAz@eV(wy*Y0PT?YucQf^=WwEbuX4bpGiAO)) zT_lwQm1yd=q#>VGPJwg^4AUdvuoCcbsoDZ0WR}$eeiflYU`n5|^n;^=7p|C)Z%?(F z)FN)*!9?~^k~0nr!5r@q{#Q}q0M_}@e+6uRf*2ZTZNEdG{$o@ol8C`YUZySb1n3}R zwm=a>)N^o!^7JI|AhYk|SzK4hpPRtrpxh+q8+IaqvIz5Wn3jp4z`4O@zoK=wb zh)b2T$hfdeRbL$~(8L^Y&*n9%l88i?RWh@Ay;@n1q$1aq)`AE(!oLVlwPmg2wxMJj zglL9GlL0%@&Xj%r3~9#=xFY_x)&)#SO*ZE6g-#r(Ci<@<))F{)%{nl?&k$jyq}v^J zJARuo7-WWSMwhguaYdXn#9ZFKHY6lR_TilYr`mCV%`;Q1XP+7A;u2O8V(nM9~YI3!?S+GKVClbfi@wSr)proapOhp{PY=44Z^1 zrpLPW8!m)0)V%Bb;_P1^a8?b+1eG-i2?>+d2oY(b#;@eBv>(k<>e&TZQSGcof(I)? zVJ2ZgM#%g+7&r%q3Z^mg`NiuOqH!v~R3?SPefjd@!Q}kn&zy@BLL!yySfUD=qtqF* zo63B&Jp0C0USH8N_B5hf&4!XzTZ2!M{zqc1`(dF;jaZKZmpAzxgUg}knkbZRp&m(X zTsZebF@Urk@~^3oW=Y8^85(jTP9-JfYsh=_p&^*X#$uHCWk5xRWukz7P->i`)3AW% z;>tRhJ2d3k7$Cr>>po?7z&fXMK17KOSsyTa^F&AEB>>=`ep-^vwrf*AtrpRjPISib1iO zMl}c?Z`drc%FX;t)E7%^8DAkd3 zu&A*In@^wedD);SOn>9drtZ8M==yr#47=V7=xi$@+Tuph2h+CSHvqQ`)Oha2{1us$2P#d&lJH%O|C=w%Ot@qrs0`Xt!dC5()EWd;RMtn-7p~>reAvRl5z&NXqRdc4VQ~VrA*D6rE|o|Cc8B zI5O4CejA$ZIXwF1Jsr)xeV5c_5J!Mr_Jw}>g5avCQdY3s9TnY|m~Tdm00T+j zF-J>>o8=dtg0~Tq7xewq^GuSOD7FVRsIP{OTY@BrEhuS_C~ZvErg!ekUb-()+f%Hp zzk})h2IPHHfXu<#*xEZ;e6|q>7b$KC#aa@{gR|Re_%Z6CYD-tlBv;7c$Ggd54|GmY zVk;Ww4=`cyrqx$S4@0kS!q0O2rJx5(w$!BCWZoqQAa52i;8(o<#YVcJDi^<%ClD2Q zMmU$1V^HS3Zp#$nnrQImS)$ReBILx}&5?VQ2|{BIE-5}n>6iQgtI6z(TC#v?U+eag zbb+8C(4;;^^7=}_HH#;IjBE z2EODvRS{Ee0cR2*%$K4SUFW!`)BtMz?UW-i2}iY0EWL3noUiK z@&jR5$QAbFQ%avcUEhHc8a51glOA%gfLk}$_4OUyS=}f@K<_|BEixPmR6;^;f!8+$ zrzk#w0^|qr_5Ld^2#xjaki3pUVAH9r4F89yZMAGZYhqB|ADX%I6;yO zp%P)$N07f!H1(lmk$n7isfl8Ej5n08l~`|#JYi9DD=Ri>J?o1Xl0>0OxOmwnXN(bWWD2p6-2e$#x3kiU_b0lnIgm#)OUkZC4?DpY(jb@Up6^%}As-mPci+z+r z@63Xho?r-GMq@K=lsG|R&}|VqWin|$J0E^k_JH`2yQLFNqWy zt$*C%3ym#_6>~VDfH=XLkaMnRx~1QIV>5+=Ck7*E!XW%e0#cIz0YGC<1 z(!ckPqy8lS0qwb;1xxuytSKLG{Hup@ij2Ly#8v;_0Pg+MD-8T!0V*9vy^MfT`tKu9 zp^b)iCc=N!3g}vA`>@b@VcyP6 zuUHQB00`}gfr5(2%J}V*ApwsFIF}x#o=q&>1X?7uUd=dezSvLtT_?x$tf2V(%_UWo zO327llWB4{^cb=@Y8c>5g2m)&)G+G9J((o!5cf1Wx9&fC!5tfTB<8pkQIN1St0xRO zv}|?Ln17%T<*8@}W{nVMDzF3dwm{A%XSg{^DkCUP8qzv10aXD6ftE)~s4r%sRb{NHT-gUDZ6sEDI$TGskad9h$AmQz5~LjWd& znaY|xH4?BzUN{e56>f{x11BCSB$&8TajWRN#Ash!D1g)r+~>G>DJh@SYy&d znJ97DaqM>Ri!XYn3umf;_(_d8yB*A)obek@0o#27E_7R;!kaOWYHG6qaQr#h9(LG8 z=A%2go%>v%6rln(OYIZ{fDecC!Vh9J(csb+a}Egy{8TpdfQp{F#CU1i4fpeOt4qR- zli*TKeFxrZraS7s8_i2Wnv!y9qx1tVVzcXO`YAZnYQK>|D)i9*yeVSmJ`qD_)D>z~ zc(LPctLwqZB1D#_*N8U!`Y#3*3E_l^Qf`1n=VUL;uf4uKwsiRTO3LOG++1O}JoQ4dQ{SFKE*@=j8eL&ai9B3^Vp#udnn@2IpikQV+?cZzARzyC%5$dEEbaGOrLx z7v=BNU(MdtfezJ|ZE3{S5CkEsb*=%(KG>JE zSX@HZCx%<$!lIKp%HXNg72bXNuO@fr^E>x+JWi@jLdg!92gJ65QG9InR+$fu=PHkW z3nG#5jI)-+ZNpuQsDre1-Q^U&C}ib9OIq3b3!BqmPO>jv8l5?xCy~#GlEnq)REUdR z0|5bA+Be}iJmA#2)PlYBxHlE~%qraPLCCE8sw}s0xRu9}oDnu3sYh{ zgdMn)=H>A$?c>k!6yitSNu@VcRM8zEk*kk4kHKI4^E54m1kvH1sLpsmIOtxD2`~~) zL<;ndswkBk(+Wb<#v+G}Pb^(o6{EKl@9=8$`Vv*BKtVd&9v)A$NL0S3-z#1Z;QkH-is&G~G~b*|^yXlIQNQgWsO>2%uZYgg+}1BzQvEwKA6iSSOi8G`~<$%Fg&6gM*O#i^R_EwkK}R0&~re+ zS8p%gND7!JqeUhs@(1^s$O4WmZ^Bw~Cb-u|*JGgj<7?GQcI`O=+~}iva`3jj9U(43 zMm6yj@=fFUU4@t{LdEZC&DE3|wG>X&GfIyk+UU%EyX`Ak|Y}b_9 zwA8~@cn|_@6n6gf6v+3sU?(^L*18x4HcBTz@`))i_ITJsX zMza4lST!w-*Kb@`r)QzNNK=qb+qGojhO2qZOQy7i#@M3gm!k$IJmWxrfP11YS@OR9 z@n8Fv)!h=SsXq^O-}33<^bt7&hK$(fG>rLcmPX7Qw|tO0aGd%aTPbQs<_wt80nRGw z{uI`sq%AqbU;!F?xij(t6WC5^6pA^;_12kN!mdaT)#y61QO}`ZUf^cs@waC8AzKo{ zN|Mu2&K+h*xuFH)w1e58hzj}+tY{IT!X;2U#-m9VR{RGQov3iGvvd}=H^z|;IXx#W zRTR131}+&hlI&L9wJw1sKt_EuZW7G9wGGoS(Z^BBW}0uMg^8&!+_H@yFZ?n@Vr}_e zZFA7NWvqpw?FDx>cWhS)5_G?M*1-v2#+l5%3dJ@nkpL@7C9R@fS~zjFtMV+;=2~|@ znuHgZS7>0*$?w>pYTu-8c2b0j<4Vw%zz*A_n%h@XQ#h`oAxRn1R)9!0n1}BXru0x^V4SJrUt}~NPUc^v@DOG6Bkc@tK_4V00dqmmt=W<(G8^y-B-Mj|2^><1p8PLS zEbT|$+c;E$j}C#{A&!=b*8$+m>jBVWlLkcx;_dm2qEWRiHVR`=F?EYSN(dm!OkRUD zRif?SOp1jd7@f8VSOzaR9uPxphoBRJH-F*WflX1(x)F!nl(<-WL>G>$f9CP|JIv>} zZQHE3o_=DxXyDKB|&U`LHG8ao!& zy}JCTcBMH7D?nMbk{6nY3^YqB>MM*|py5SM3N{HAUgHiLM3xV~PsSi*m~NS`oH zI$&)bUEn%S2zpx#ah8j9RT)XaJ2?G@NQ$AlJT_k^q*R4WiOBvq_ zk6b2G!*9de10E8SLjZKh1`NCU3DC=_(xnt?9wyBBwhFUL;X)!v@Z?P{tAGKlgvTly ztC$Yo$yC9+cu1M~8T${y6PHKx?6857ku8bk~?Ql8H!R;KE0KAVXy_&YL# zcln}TAhAl6MbR-D>>*-%vm6PiGlXyT?43#6lM-rDQ(ExM>*uUJZGePk-VUukNK{o% zOQK%MZa|vkIZRYkbeoKNPXiu)Jm;!f*|cI0nmO2AeNs&BR;o;KG*uTARej+}*ZNZ5 zB_Ns77{P;fZwL}>a>tzkaAF#Kg7&xg>~p&B)~JNDtq+XW2%^lNCUx+e1p|74!=ox9 zlm^ZzIgWV=ky@>~M)Q@FYlvpFsk?G2T;_YHb$wSQ*uIZKMYsR;svk~kLM}%H+t*CSlvj?c!~mXJ|x$BE_MqjWRUwUe`RJ)OiM)h)eA`Sw?E3-8W%nWMJsBJidy; zKVA2%Q#2BgSZVmHB9)*UjaAM;>~+}%5qvBPn%>1qP|i$F2qsIeAj}CqWleT9gv;&- z6mJoiU9hDmE|mZ=i#D||JBA^$w;`xKEl&`9qb^3ZQFaQ91^=n-0C8zp<*|-oOs9Vr zRNzEGtj621CJ?K@^YG#rAs(h$Rq~KhfaW}5lH&s^qXkONRpDajuyRP2AF=nvCZ+m& z!`*wpI=rtT4gsZ_gH!IMO(2f;Z5n#LAoaT}LYgh#k>MF~tR|}!dV&X&B-nH~iJ>~A z7(DK5fXW(DDqvDeDA@h*yeuva{&h^V^MRP*C@X_O!gd+aW07DXC49f&P2^U8vA zK67eHPA+zV*TZpF0};|j0ckl@6}`bUi{mhqMO`rjE(<7ZQI8>EHomS+gt@64bwI8f zdIhF%K02ke2tHsmFF~7VS4p*=r*tUE0JboeErE@3m)g`_(_n5ys1H>mj^N6JMyLS;HI3v5-3IXu0juYD9Er!re7kd&h zD@?>LufKML>ctAUnq=^6uF~#vvYRTCDm63IaqRR`QWseI{Bw}{Bm#taY(<-rJdP9h znuZ>Ng;iuxrhh+p2^m(*zpi^5-S!sdX8aq;;Jdf)_8WNbfg#T5Stj8LjOAz#*AD-* zc9g#kfxzcDc0vo7O7@lDOXdMrP@+hnq6TTi#(I#xlEj%fJFF03mTaHd=tem0QebuOnbOI)3r)B~9j7uhg$WV2G{2;?XfhR?@f%Lxw*eLFP$Fg%Ej6@r*DR4o761#P&pt z9N@CJ&ETUd)3MG`r9^(MjG&iLrzWeI+Qf5qcJW?>!8m!ho~R)jVkHh0u^u5w3y^e( zvXDK_mKZ?dU3o1BO|pCgiK(AQI`(Hf5|S)Rm*0d4WMjhOy)t~=9QFs(si^&u@D8}A-yiPw_PLOZx57qW9k zVJ<8xfjL)w#My^_#3zzaIY$KW#f})fHO^U#mmFPwFAUnbvvjjOcxo5fs5HawUF71hv2Z*S%cAx4xRmxKqG6sL4A8lcdd}R}NntAO3U)tfNKp)t#&fGXd*+ zHZOE=**fO5M(R4~c_cgk`gqQ&AbAT!u8JSG@XlWqbyQTRnjEoYk7VZ;}#M}OY87s+tBNDw<*-h zIDr7PP#!S8y`cF?!L_ds*T6;beVoxOL?Wh#32pr-q3Z=kiz_A_rz>$0U?FcS4#E)> zmKzUCs%MYaFAjz0W1xQHl&g1nq?RR}SK}KAR0ql&l;tQ6BPFNR*-k@@)B^uc*=?6?+8)ju00a0!TuXT2$^rxBN`w#f2n=YGMIx3$ab2EI5WyR0VQd#K(EHycm)? zI3;A3;~HbfU@i_h@8xEm zo@m!Mbs%;=`#xju&|?JK5tfuYrn@6sl4ti}DMvSAJ=O|$kd!3ARZ%O^oiTe5CE_QV zhL2cU}6~zJFk2shL7|93J0NtY8 zjOTAvplhQ&o*=}buzqf{j(RJa2y()@dF87YS{T43;&_o-Fb7N{;C9%wBe?y(GKF)b zgNN?u9Uh0;fvgcoc!fFJ;Dr_~ji|rAWPl8Fb(3+IbfhN|)6u1PVYa|o)qvuF*!rLa zceX)`tDO?K={%%_gd=>}L z=WBbA^RxXsZeNCqW+S&CevqrDb2&`}G$9j3NycXCN;Ip*8Us)Y;5US8MJ3X(I#Yk+ z@g`*wzfEK??OnSlSjKqbU0=41qX-(oq~ZH2hePF^6{9>>OxIecsva~@1nsZy#reQ3M$7|+Qwa&G#I`BFZh!2`3MnnBI;xF^TIzQU==D6;VUI$kN5BtL!W@uyS9b zY1zkKy4ajj{-0?rU{Qlj7UU7b?~D52I`$GZmw7i;X_Q*e{N4fmh7aQ)fObWJS@8)0 zN`JpT=yg@-oJ5Tq1MN}W6IW|h4U&T^q^lSq8U$~xqk^G#vari_xz$h0^_ zy5fF>0R^;b+5J*GXzoV1!YO*;Ul_R4j`>Z$SLXQPMBlbAv(HIvSE(I%IGVtz*5?Fg z?CimL>%mZaFZWQ(AmsvaAFv)J!5a|l}Oi0 zGKx$EUz3QTm5Q{wwG70lwG=nZXKzUF!vOQy&&u-?vNEFs$Hfa%x{Wp%4y!kAZ;WV9 z0SxjT{V|5hwl}kCk1{xzH54lOd%kd*xT-EblAylEXNi3E^H#{x+?ZvL<%0B@>m_$1 z(nRe=)zR!`7`X|QJ<-7yhT!!#aAsM%|6_Hccf#y(h+A1HofS_<8xyK?qHUt z_`L<1b{WXrSIkWMEW2Q&Wg{qoLLyzuaW%2NWSJo+7ne5H|A}}`5 z0jJr>gwATiA3<@*#H_7xq=A*vE)v;m(aZfb-&z$nxN7?aaidtl-H~__ML26AzPxMo zg16u3{%Xx-DzR`PE!+w|CZJ9t|MnVKrs#Sh&^RgHxp?t6N!DPYa#;hET>d^VpQ|C7 z=|Z%l9f&;%Ssm=V08oq(xc$7|~ktN$|dqXGWI)5C$7x+3@z&2UUF#4o1j7 zU_5kT%-Uq@!b)p3;qHEfJdMs?9!VxZvsXyF*kvlT^0hMymRYW(Gj|Ifq5=ovg$dH; z!~~`Xdl96>O4o0BXf#CG`FDT%fd_|+59nJ|Th@v#z7u==5PKnhk8u^@h+YsbOF=|) zv_XN0GweMIWSx;28YI@JK8DwZPNi2iknefOYl0r>qFNQI0DRg7w&QMPb?wpd`7H@; ztu1B0J(5<~7ULr+{w!Uf?9w#5qTP0wxNYd#Zv5u z0Z#*G36?oWI5`YCL^<;z65}$bECiP75)KcivqOqH0*HGs1Y=};S#2v7xlyt=x76EA z`Hxt;0UqvOmSM%D)=1&HI?g5(8RNuS4Xg|R_Z%M+V{{=3@?nmKoCj>7qqM_CF#++P zW-kq`V{R)ok3g0Mk>ruvn-rSGD7fDeew`7B$KbU>6(NOkx;wL%)7kSoIK$qb+KDj0 zBwbZl9xvy~4x_k0Z<7{GDPP5V<+IczTA_Qf~0Zd+cw9uEVBEI#3k zIFM6?C$+Rt&|*qm9m$|^-YI2#u*VoeqW4C@FY_)KiOXvKw*Q zi$SXrt;5UECzd6(GlM!t&(qcf_s#J4LnMhPQ(4*K(+)WpS;x-E&xQ?GM^_rk1V|*r zn;Mb9AtsSCB((!kjfhRcC&|A9+0SV-+p&Z0vY?cVu-XZA1cr)T?_}WBo@2nslLyg8 z$771H`vSD#-JuKapZN31x7e#g>yNIv*3jh&OEkg($HR9Y2`&uAO~w<(2SS?BlLLnx zq+{_dl#nABi5p!42bMa(Vlq2_JV#n-(q~zRCRK*$Yq8SEL)aOKaJ1Y{xWOm(5h@6} z7A&7AL*q1ES8l1gTm_}$Jv#V1FpX&Bd>@=zR#*_F(&ilH*|J93i39WFOpoMB~(dr2Kfo0azU z<3p|D7}O{y5oE)|@)ADQTCBqwDBcaN8)ueS;^fT*b|rCzSmJYYJ}MInDKV{f+_S5n4o7qbawY&^ZP9jiz=p5^$}8(5gf~ z>3VBXN@giUJZzW0kxIneX!S}eaDq6T_h^I%H4@Q^B*+r2jVzbArl!$3@~kgQ#> zA`0;I{?!MHZ4VBwC?$A0`z84fkqkFUo!E)=_Vnn$9?T;+h^-sq2-oP*LEny)=yFtP zh03(&^o`OsK(B`zwz$pS@7Y#OtgH+4mg?^@gJ`FDbcD z)C(GwJV9Eg)oj-&ge9D5(Jb1Byr)TopkhATm_FX#by-GL@qPG{zwv_`4sU8F+OK-P zgeP| zMRIFaf*U17=zlv{U zXS3k&Si5rQ zw~QPTCWGXKTm?m#y(ygerPQkHnlvk;AA#ci{j12JToFVZWSynj;@0j>=`OMkt(j-M zKD_D1l|5H1`r)m!<>t`D>0yl0ePgh>Te+&Iw6{Z%sPw-qGmT)n9ga#z0exS{K(1 zk@op)dn7Ak6bma&oJF3ca!W2#=NU22?h8wRfRwW^rtZ+>3KCaTOKEv;#^0v@@qax3 zdhdUDPyTlC;_6TJ*>4W$5FZRz3F*n{-PFEU)M7dBVTY%pusZ;AW%2^HLK5NA^cIARQ8Uz_=$0(dW z-J3mrzUMtqq4lhHkz&G)av4?`Y-3-9iNANZEbUS_LZGQ+c3Ax3%Hmw0z|5?DrvAa; z1Dm&$;?h_)C2|uMoG<;Zp|adGJ=j)Gy zNY5?~j%L&>T+*fPKmIg)&wW=j{nox)B4Bg^WJrx^5L-vS>A2zlw3? z7ZHUlO=T)2WqJY+ZproKfQTuWniVMQ6Nz1E!E%~N%6aLUj_ujx3 zj{RV>F5jP$^*0KeqrlP~C>qLgSged)*U?>ma8x7nzqp*Cydd&L!1$Dfq=t zHqok&n)eoRt)gHds%=Y?`cP>MQlY9L^uessz4*K?Ho;C3N*OV0tZ)L^`)rp+guojg zu^t|3Wxp=6{#0oagIp_8I1L8vpI^-K5<1Sl;JT*qxhc8o_D|Z3v~K<24ExD}}KRj*c7bSKd(n{0CxsVOB!j5% zjwmoWo5i6l|4CTtxK2*);k>IZivX(iFr*ZQO2}l5U7}jL&;v{Tm#sB2snT+qZXUi; zItAx8{xBGOCE&Vzivi<&e3Hh7?tzRTWYTMjI){-%FqGCs4#z!MErSv}lihD2`7RG$ zF&L78!0ypr*U{J0bG{@WO~|rY30n4WY(HJXpHI2-Qx*7Gxs$xK7=8;d;+;_pPAUbJ zqxgh+=@<&Y?1$u|WNxlx2*MbF%SR5QR!znm3{u6culq9AA|A}1cH+<01J-bB@#1E{ zBK-0lSiVmLI({8RJfNHZE1w^eK}QZvYys?uP~Hp6Du*F$Knadrd%SR}jLt}p>PW&u zShL3&8~mv%wQ4hgJx17!CZB1g|7?m&b1X@0FeA%MD-u(%?G(aQ^%x%J_FFnDJ3yR!eNn5k|%o>p;Bu5oGl<` z3o@e&+@@D+?f{o|A*Vi!5#lugaH@}#pH>7zJ&M&x8V70ZgT}$rXz0(Q6%VJg_xY!a zq{1v)y;YA-ube*duflRt)AAnGB|YzLkt@L*@+?3L-fDM-&S&qPL6GswlI7FY)nDS{ zaBw9^LRiNb)q_LJ6rDufViHjc0XmnsV(l@;bLX3S1Ze#?9hF@;7R$)#{|<*|y@flS z$S`;r3bF&NHa#vj7@f_5N?jKvsgp}oxK3;9PKBBXR4NcxY2J9~G)94f^5m)6Rq|6) zrGFJi-yk0LFMzI>{e$ov0e!ZUD2vtuZ<2ExULZ( zvH$}rz*|S2@?flkR*jsqv)UHj#mK)xe8wo(dL%QosGo^$Ww##9nvIcSYMZ>X>a44i zeTgeo+_-o&nGt%FC>^S`z<>EvZS-crlxWJBo#OkAEkyA$KByzHL`!4L*{5mAHf30p z{()-Rpf32a>^lBM^;#ck{g6IWI0@7)MNQLsH0D6$X9f3egxa!bd;j9igl2~Vtc>Xx zV7ZU{{rmTwgspxFt+G;}SrNA~5l1k?v-i@ifg?6^f(l-!UzJyTNRjCU#sDr`6gLYo zAe_@^?J$RE+w%Niy3zM=0%=Apq*yhssy3b~Q z&>EnY5`iYFwqbbR(oUB??3hbj>#F=4y$sbdDvS$Fj;0$8I2rP{)oy66f^0LtoIl}T z3@~5g1VRd%z3Pvd$;2zyjE-hs20hS$WHLut?m^QuV=oa972(RS5u;EZTy&1~U6%}z zB}Ry`$4*=Wt#oEIL-d`|hsTdRbwh5jahx=%Xw$HmqNDlRhg`FQ1yG)BBpypl1R(nm z)^%YEZEfX{ny5*6*IA>GD->{mLB>25jYY8$`P00R!@&AOnQRDB%TKcgPmR!F%SwuJ zwAuY&tw7o}NYwv^&lhI{LgquvdZS2$NN)P;-w<0@K%;N(-WPOTCWjWQ4b?0V~u<>f-(@M>5t$^a*>GuLL1pbaHv6XUvn*pjS) z8hly7)eiYba}G5!-_X577cb-3%dVqk4~Jpb9eEOkT|>kgV!Jr3g(>=FeG_G8Ns2aB zmg29f3;-0dEErsZ!tmrcM$L8Htx;+xZyY75K-s4eZV?~%r%#kD+CA3&PW?g>D+z~3 z(B81ukr5YyO+KHnL7}jrdzF^DjSRsK&7EYt8hBf>WGH4QEx32}_CwS%jh3O2+OBA< z=^kOl!&k#{B$wERLxTL+d@pGn_V(3l)2@Xh3;TpsjOM)A!Wff%voMyaFKvqv^z;iI zzn^ACf1bMjw)o%2-tq~*G|1qGKys(1byVmg*tKJeu+gnnaC8X_OBa{UMulTWjCuz~ z;LgTbBLrR{ns#=wHrWKL$it}q#~{>BIDR@b1cAYDD;<5$#)3X7kPnkI1_)b-*af*7 z*JZkA9+7cmQ4rH;GvqUhQ9!Fr*eDhoqugvKWn9eA$#@ zU1}^@UzVp&m-I#WevPZ{I9K{m|E_V~`rvXc&DN4DIxOViNdHK8IP3P^CyyO+!WaGe zI7&~o54zD@or2~b`Hlr~npILoGP%nFIz?S}=$eeY$v6}veqFMjBAnqu=rZo2Nt>b= z`*LEdpdL%jo69I-Vxh$bPyt7T;1YN-G%Uu`FxgfHW-N1Tn(8Jmmz-)7glgV4J1??v^~1QfI@sj`B1RY;b^-m2sd&c;pe z3HfGma(B!W+O8PU!n#BJO=7j7#(lhPOv%yEHht$({X#~M07_1sp8?DJwv02*<6@T4 zcsNVtQrp2D4;-e@aFaJRHe5bLU`&Li+88wxEvuHik|TcUS2WA7%`h2kqDO4I)2bA* z5OlSnNEZ!LOao}=;EJ<6wjMCpFZGTNHAYJX))nM!Y_=l5D9v-MQY0V>p{G5p-=l{+ zhJ9p>4eyz}ZU7vFTsG}8RUDGa=~#%#qy2insFo>)b|cVhS=kTs=9*!ySu86EQg~iz zi9FFF0TAS?b(RDQTlXh*d{`j{?Rc5?b0HxXBZR2|{UZKFoCP;$^wu1nTy3&kd1QN>p{7Kl3UClaC|E7q!JZl(2;sRC9fptU~tIY%k8ryp&oD8FGt+G zGmDt&>X+NLg`m+)lPX5gO!(fFq<4x*yNQQ!u4ulSqDQ`O6FkIRg&4q3$SLf z=A=cEXsl?Kcowu{RC^(!_{KbDK3G$CQI_j4L~d-)hTRka(dhVI4=Th`@es}(QwJVg zzgU>E>BjjRL+$nGvzPHNzy5zBquFoQ{_t;WUw*E?*Hrj5`~9yU=!Q4G{Njt>|L%9w zf0<6d{Ni_C#DBl|QvcGb!1_`_Gf`~7df)Zbrz^@rd7_Ftx7+%V=p z?I!}x^ogE+bUYuIK=^$0!T*0fU_S`%+-BRu5NK4u!L-YZqjwz25Q#p8I7Az*Lh#GA z-~S<)9idI{2i-Vr8`uN9MQ-pkqI&z;*7F&soMwBQ8~fYOpG|cQ!A{;jFxlH*-`$_J zXXpXC`y&w#&Gt}b0Y4q9_GS3rZpcYZgwfIG6>-s@JzgA1kq9>tR!zFGN6PlcMFW(9ofl=e=D2IVDT9A86 zH^sD#?~x|$F>ds*J(4*>u?<#@m-Hm&U_HY08V0!1@81l{^ zztBHl>YuOl&u{e)u-y6Mf73s|*FS%FFuC(bz46CCwoTen)6TuRXkttLu!H;$pt8f5 zl%D6W!HFUO5Fgm%w3@AK?YMoV)(YM=sV^AdHL?}t8}-u86FfqeDDktxw@6GhQu;u#wiKaEbCc$2uh@yMVEXlMoA6XImy2@WoAnZ6+m%f>tNX z>j!C!DmT?e27@%?>e~HTwQ}0RoL@yH^wQ=~kgtTPolA(AzOfXAs7FTO!WCw0+Xy3t z%SqvqbB(_oLh@laU9+DVC_te5paJ_i=|GEHu!OSAXL%VP(q%X zN2sUWnKzI)y(`uf2$P%&9)i}Rf&vH;!gUQxKl8|rcBEmVua2dgpieB`5ZH38`|Ok* zvDi5{RpBpIGyq0ISUnrW#+HS*@?DwE^zIX^ofX|2^yFE*EFFd;5SVc^nsQemuq*p{ z9Sr#5#cp6^52uIM2wp2V5*6#M%8pYK;xV%LgLy^`}iG6_algmvJkcCB+jVC5!M$Uh(#&{?UMpQ_yb%K zm_*?uDVc8MA7$M5QE&*k2!+|&a&#b0$^@G1U(_nmPm(U`>>d%c8!FpJsk5+PD5Ftj zzX~f%--(LiVceo@2eVP;SQZ)2pDD&`Ellf$u|enXEf0|9ci?ttQhCGKVOgb2T^P7JJ3c!%9_6#Ojh9|(#rVA)F9pCujhgAUm@IwG6y8T{; zgDS#RiK*?Y3q+Jq(pX6_FsVu%n0*7#yHJ5@k6MMTxOcS9bko!R{S^o&_Ru2bX%A~f zJH~LVluxye9<^I!axph-eC-~*70ADSdJCIpYg>hHuAIgu$Rf7^(KQzkx^p22-3Mpz zn{%xNcmy`!Wm$7dRc6a_gvv=)o7psGfm=mFTf^G)+ZKZ* zZ|x2!X+iF*kFLj=Y#;w?uCHvUbIi!ex?!D~Hlr=kKLGTZw(Wl~3|l zhy9HvqMqVapB>D;TBh79^jpJtNhc}0WqDxsJxNjU^s9|5i03YXuVTlU{qbgl85$c2 z!Wvwf)#cqGR@AGqh)IJoNH^Zo=b6hD1+H@p^Yshcd6~lNh>J2>{fNJl+x9Dj1BTnc zjb3IOEh|sw2UkIE%ghJ?&Trpc-xK8PdjsvqqMl(@H2kjC1#~rCn0+HK($gEzg zp149F1PrjNfEaP@lWa1j7KZ09RqZj9H74GleGEXf*#dyUSS9nb zqdWJeI{hIY9P)i*Mu8b!`4TXcKm(D|dAC~%e+midBZse_Y=6CJBtOxgd-qBvbuz%w zZ_OIf1)Mg_cqmrPYjd|~BZ%9!3?@my(CHvR-OjY0BhrLu7e^(%#8+4uvNY5w;k4cL z*kPD+CTt@8rVuVZ#A$$(!d1zhQp4ex&SBn;RRuTphsUxbyLzFQoPOzm4IeEg!zdoVX1;Ye;$5p; z7E)9&FufbxC!fT2gA{Fy!)FYol-dJF+a%8LboR$8Ci2Zf`bIwUtgH(_#%9(n>#gH(rmWig!fi ziE?=@nvxgZ*xeOh-HD#Vr}`rkfIpHU^H!~}_gM`%@TQCrUP_N*-%f;js4_uBlup0h8d)=v0W1iZLkVrGpi+-z+o``(jy& z-XiFv{jk!TPM=d?jb@hL$s93A;4wFlm@X$331jP2m^lzpzY%iE?M8|JA-d$6N=viE z7^I?Dqd3|Sh0sVN#n=K_Y22D>hcBn-xV6ja+R1e7Y`V6F)F&;Zg*{O_nJ1?&IKk(O zKLy0bgQ*0Dt2{-+OZF|Xuf}^Na9Bad@^fSzS1_#fCS!rg_S?_)&G-Db+4RkxoYL)&nOL(2h2dw?d-fz!Z=)z_i9shpA?Ow)P`4>bbUw zT(%Wnhw2J%8mEe3#+JRUIHt%w29XRXG61*i#`af_zuOiK)!+YBI>ejgp-0=>pi#Uu z~8GEqwC00n^W`fdVJ{f&>`@yxo}F!^C|De zY+P1;Je6xP14rRGjSoYRTIhd` zQFfK~SW~-(i#EBBN##a{_+dm9DruiQAjc+ZZ2_@?t1Jwrivn%}f_>R@9}p3?JZUA)qo^TI>Z5Lk zG;;vL0s{2#z_PxoN+n=NmMdW5w#Sg-j9;!75o{MpU~VXn4}3N!bah|aWQiew6IcxO zp1d~xJ%?{qQ4mnT$JFwYGQYqk2`w4rZ70+!@aoq(jz`I`w7$NAgHGOZHW>etC7m4{ zCR&+Hh8W!q32sgAfreK>)kD(oN+>G<3pN82=_6DlctNw1+0LB^OH-xxa;BN`n6mt@oQbt?*u^Q%Dy zR3~5RSQj(eYx!x!1kE5nIIqs0bHr3+xW9EfS^GDOyKTmJp z$5CSQA;RkmWVWlw`nwVatw3gUD74kajLKeY!CX@x(+0ezbJk5oGOm^}@9cx9CQ)t> zY+?(9D;0KFWZEo=e)3fu8PLg!;FqCwqjpx*EtiA~>?3x;Tg6JIOKnp5#}7D@uA7na z&O7fyh%+1bxut!BY_=&z&Z>CVjBrCKog!uTMJ1R9Ra`G26rpR@c!IxPbD9yQJwTfU zH!gn}fMvlBOpZKkkzZ?JqQ+v2WjF2p;_DDsvT0g@y`V|_hcV8wlDFX7jTFiu086<{ z+>Bk;dgV{+?zd5XB^+vY#x*LV6ZM^H^3tRf)fmE}81pTTISkcxiT(nVM@jud_}B>@ zX6G9lcf>vOb62-WVMpLJ&N=#P{f?CMtYSWN`}pj`&pSI`P%8CF32tX>+vbxjixWP7daic(KXV+Z#E$*R^)f zDyF-(%ZvbFT7hQ_kWF@+z1=X0vdJ4qMLVx!vbeY}n0Tl#Y;~#}8L^#&omdFz z8jf}PEZW;ykFGQ`HF}g}mAJ~qw6>7b`N5@B&U~FFe12;u>#em9N9xsAc@7$t75C4T zBIYG_bor&=0=+nd@Vi%GX21Hw4>!NtRrz#pzx>T_;`Qe%-p*ixVGbErL4|IF!;2VT zXJ^F-S*2nQ7xZO0%CWI{4k2cJQmuIc17R$5^Q1i8^lV!&r(nlF+u| z+MFLQpKu;SG;Z+cqB*`>{JM|OO%JuMW}2OG&E%|E21UrxpB8;9bzAZ#2a$G= zHGux*6(oc_9Xy&ieW&sbSZNam-28e2HX;^K24*8% z(KjRrdWh{3>A0K(D?lY*0yD}5Zk`8isYj#K_U1=5MXJ4mPOpx*=#283W)aHQ`wvRYmrl`xsxgyCd6Kln{ zoN7u3OfDEhEnk%0?Si-`tfFjcTTZ|yXB`xMOC2HgeM%;{e~(`^BKeCQ5JTpXOsG*B zuA=9}&~Z(v32`pDwE-~VER>i;Nu!24xYn3(bCRfbLLn&n6K5nz%UF9&eT0!EiP?!O zynTPHEe&w+w)yMBoqwHdDZ0YD;vS zJ#Kwd79~t<$YAL`m#i?AjxG@z;Q^D&aP|Ls{}_C`E#(ZzqcyG^bTTw9b0#vZaf(2%H7h+%}`U2MDbKk|Q{jOT33tcH7MuUx88#jQ2 zL4_q%^@^v96-T0ZRgn}M-7y7?z{_dAzCmb>0OUR)g0aqzZ_Gt_$y2+(R#EA z>)sjmlx!JCRTnnZPm0|G_xH7Z_lr6K#XF~v@Wmv@*1VC{=kz2j3VV>Wq@Sy>Uy>}Z z1Lij{Ol6dK0}@pN#qw!it3ZD7{wn-KYicEYM5eTn5)7ypCJAZQQ#0%EM6_Oy2iWC& zGA_&w8DvOF8BV~J;*N;r)Zh&Bxp8`@~xEm`t?W%>#O+FGS~op>B2Pf7MB!s{b4d?MN1J z6O{R5W*%6mlAlA3V^Ecj*((gWf=Sst&=x)U*%l-2RuDOY=9Zxm$hz_q9G_Cx>*~9F zcGP5Q0Rbg<@J=>2o)PD5j;)8tw#o&AnbJ+iMUNv6HBDzFOV?oeS^#a+o`ZbM9Dbn$zr?%Mvg{J zX<1$F68)7NlLF#~m29y${|s~Do-U`pk)mqM`5HOljqT^(;`PCTY`QBk=)tj|(;=cX zn?{OMTFBw;kcZW8kB2EK3N0%lq}W>V+_*C*j&^TrhRb)p zQMY#APY%D53zy@Nd{2Wenk9rjnuoe*^lm9oio24-m#0UkhwsjGIwcea_7v|)2=&;} z%J_dH%!mxbDa1IT7e;}gDF|VK0c^4m=|o#tZ&!4bl0?&};+eo5(Rmo=?Be2$q!43g z2Q52t+Wir2$C^zd>;*Wr_o{q$o-!Xl4-_2o;0VI&)4!8Iiae{$*TB^zdS4D<8k7Qh z{YXcgObhIZr8|kf?vleiwemElqSuWvUF=Q@Jn^1-t!lW4*MjXbY*vwALCJ-@^Jc@1bpu#hCXSP#(VplPmz-$3aSFu_?Y`A zr&;jjpY`np5!te#lGOoROw&z{Kc)7OS7f`n*y55q@6JE8k^?y~C-2T(WhYZJ2E&jF zi&%zW6z%W@S_>Rn2c{iJXTXEjG@+Wxe+&M;tNNOU)Wc{~+ZW*ohQ{8?iLV?x-&dy| z8~`qjcsV7D^Y-DiJpgLE-u64WIyC;}#n5Zq`B!R-Y)SfDj=MOsQ6qGyX?cyX`O5*C zfh>I2i=HEO`K_eI(yQy$c5D1jPLBC5$`B2;<6TR2HW3!hH&*{ArK2NyBjtq)KY;&K z)V&0UU`Vi&0rZZa9V)hWRhBcnxs7Fnd6 zFB&p5w2~7sau%#;Zv6A?rvIg}+LM~(WD~Sfavu}4aJ?c2DW@L|ck9}J$1=h{C;=T| zr3H~6in!z%l6nwfFl7kR>%_CAERMP)O9^Le#D7dU8yh1t3F#@rxCg15aZngRZ|*V# zHgqm=Em#i8gr!MW3E>9l>_VH;7``LU7;hAD0KAKXM{dE1=V;|FtW<)xgCnLf;-T96R zif2vCSkF5g4*ps1$Us@>yEl!vxtEEO7_T$IHUVZymvAs%sbzDP2dBw{H*KeXG%>XM z_JHFSAeNxNi@UvD<-OYrsC^ZV3eA&uir)Ilit)@&O~l2BSSAOuUKI8S^J%>{Ht_9& zY{grm-@DGYj`k}wOcvxrq>9KAYoOMS{ws10$B)B@Oa+9QVe+2BP7&(zVNZ7YWi-py z#Y{(s2bZ#Nw%;<6TRBP!&>7Piw;CoMlOSd)zkSA6{y%5nQJP;^KyM6mSN#D z#75)0Z_h2j&!It*S6TwC8@vreJV~n;6N7<@@wZaks*^R>kMQFtMVTI2wa&-%dkb7* zxaeV#5WyUCVd9Rv+z0RY{EetI=(v936)SQ_7B;V3ed$eoFC1mpt1 ze8?|XgjGQZbLuuYADHO^$!WMl<$Au`5Qme9RK>D$aSpo$x)oHEo2I)+43QILktDF{ zDR-*mjeN-Pxx;(tDTg5=2nCdaT@+*ZfeQndf<4--PVg19sY(y>e@60nNWO|lBbpsnMmi*HdOQ#oY9;=mamkTcJ0K+4VVGJC+^+{AU~~?!6a{guv#`rr|GX9&AwNP0;~Ayl!H5MdF|9BtrmGRXp5@>|0VIfLx$=r}ym82g(Z zzyU&yDlQ%m8Uje#FcqGnPZ%4HJ|yuj`VyZI1?kM*ysoi4pcV!x`BiqaDirFwUCF0O zyZB5Wn}ao3X%(BCzLEA4Qk+u2ap3BYU{?pt4u7)(X|1u#>tw@cOMmN2q8L|eN=l_Gk zqY(l8A?#MsWQu?ZWE$MC%BP%j>V=Wi5aiz@Y9Yh>^zFM$Aw<+7J4B{%Gw10YvDmm$ zGHdZk&dcRz1N4YtH*2w%c?7sQ!h>`FaN54C*7e>;I8CJ_@GJ&p9oEyB4a-wpQ3cUI zd+_rTqDQBoLG7m_mBZ37;?;$iGO&AqZOMH}QbNALz=)Xtps;-kCft^GENiO3zMP1? zluKa40#X4=TN@Tt#*QQ9ws@tK+Rl~-JF?%7C8m5LQ<0>ei$kV|S(kz-uG@eXa4jr0 zgA_FB@Pj%>csFdH zDbX^S{}2-zeE9M*+kXa(ank+gObgf=lz`$kZULCu*Y!HRBq}O|@vJn#*r+yuglq!g8 z&?~&ItCLeJ#=AT4O7}Jv=4nJ!MVcxu%rB!^svRRreGz+_`rF zY&bo%Jeu3-<_OI(-vDKtI*%d-T}6INA9FQ)r>jx;s}M+7HFy({O3xKqh@I z22B9vVbGHJyx>4O!l~F`5`FS|RUy6d=XS7Aa%C9R?sy8+=9$(*Vf(ZoNpQyg%ST?b7XGv5nHt%K!2D2}$a{8XLR$MgKd*Z^c?i4KOTpH<(CRWR9sk=YPKXT}H`tjA9(ZCJ=5Q*ksNNb+;-;I8k(yq9qB zgmACuAS%>9mCYFY5idz0)>Cm5A)Uu;4KZx8*c}^U5n`4OHG2E^i_3F|!~5zvLHj%c z{w0Gd?&bGWY~(Q;*(-exU*yD6O8E!_o*>@sXVGB|m=ae=4~+(CR8u4GvZ+F`tMG6C zd0{0H3dlf1KZVE{!jz02mGzYj$TppkseePi4h0{hIu@8-=Z=m?3=djECXQoeK^lZy zDy5mkV!Co@s_ZSAs@Sc{i? zuDuv~8yZ&Q zHA!1~#-)Lqn?EXEv&=mp3&mp~H{1$CTBFF~HCl58h1w3Gig&%eRCePBoXtp;D5{{4Wc29Sz6EF~p%WWGWLFMNYo zz+;4kjFc*LYbR&ftlVN?*7GB_b(R2RG6eQMP-CkYCW}o3f8Kq>#*K6<LnS3fhCR=1kRdn1r}nKsP-($rO&zAUmNG}ni$s&tu=o@hVNp@l zY)Y15<7@j(r+5L7M0!V3Jxvjhg|FwaFOg3DB9-K6xilTPJ~oX%kqWUqM4$od57nin zU|;L1u`8LVB!R*+Xa__rpS8$(v|V(Nz>NC-gsUiQB@7j%0fy1->Lj;`fn2Z+1U`Zg zEW`PSYYHzVwx_rMY!B^u?C#)Jl}e5Kf(gK*hIQZ~JuRb4mV>H=fZOU=s8H(Fu>&c3i266X%A#ui6$leL9>Wz&Q&JELX_xxjsE8sU4VvY0ufx$ z24AJh_LX1l;?=};Hj_$wNU9g7H!R(QCYx~8>jd-pGo%N^2gwcWE-v8)Mmsu28X z4GU;f`~u{0!rXb{qI<6O)tKd53Sw7?6Fp>Q^YTo&~+me${FLWBVi*YAk+aF|5*4dmYknwr29n7>Bixp*v+^ zIsyXi@oP}!^!8tTK?7gh*9Pgoqh&0Bo`#ks#LcU-%@Na^U@SXYj53ufzLJrfXjz%DZ(n8)3ILP%RkokbZ zsBGT9Cl>$xpM%9~y!zO&|IE4mv(5FSl!4fPSecAnR?r2ZSCdXI5frN;VWiPx#y{tb zfBvVfiYYH!y>`w}j8mZ~gZ>WSj^PlOfdX=VYS%K=jz0&iP%1 z1A5=F%m@vOv|F8dQ5!$dN3xGSO+mJK+Qr z#2IX1kzpY)1caY$-|mcGYQg4uX;_tv>^SFPJHzOL2DFLdBk6_g?aC$Wxp+F(XtVIvm#m1d&f~fydqa&Dr`|2{0$;3*wC)~QTl>-xN2bJLRQer zK@%J&Z!`32FY3W08+t+`PF3+*SOgMRN_MH_-%^wKPfim~s&-Jy&L|FpJRQdNty~d_ z0Q)~8Rd~A~7(7Y+P|)Z}RpY4c*9-nI+*dQRgXk!SxMsyk{8Rwri#k>ebQN*kIfX5KE$0|WJ7PJQNo0gfY$Wo7@z-;w+aicmt=s_ajEt*K&qKaG< zhRV@`*Ue$E(mLYseFaKFjkXut!mlHzY$p2-!5^ zqE2AE32`u4qbFVSe0rmLus|G0s=4dyI&vXA`e+nkGG(<(gBQt`e5rAQEMmtOVCTke zRTvL+9Hz51h3S~7UgI*co``!ZiyhLdr;Nz=2R6dNSC-55Ct6TXQ8-5ZoAsNusj0i6 zam`*(0j$bbfq_uvP8)11bJWs$#d%044P2mm9SafY+PeASXE=On z2o((y8rbnRWvw@BlWX)wRDf-ak76`^vXcVMFR#`q3**)syUM(*&@MxPSSEf6#3&9N zT1I;heJ0<4JS$SLW!X}6&}wl+@7xNTM@no~sE%G+fzH)nSJPX5YsNbcrrnCKL;6SM zA^PCM1j;029Z`400yYCsxW4-gausbVlPz+Om|8HQ`l3XQCsV#2GUANjDt0Uz*S%+* zwX3lOmIrES3adGSEzrVIDNU%jaty8})W@EV!&t0}0?}TD^U2ZJGHk&~*1Bcc4?Y94 zRp6TkT^&w=I~%kNCDp+y$g)+)U+IsoRnFXzPbo50<@4OASq}IyyYvXldy^$` z@vc;c-=&z4`j0aJP#K@a!Ds-pVNO^b-JS1o;4=?&D=3PL3dCSw{=^MJNeOY{J0A$$ zFdTHw@T@_y=T2kbzRh3V>HN#x+I~fV`pTz33u#5-ni#OABJVf zA#`27wGAS)mlqcx*Ijf(`|vZ{dWrbBJVI-d4mx>vsc%|!vhaf>CU!`s{`iCHL=k7X zoK*3`s035Xvxrn$HR(d~L6R3!U6!i@jJ{1FY6*13k9XfK@Pda-KRF#&AV_+u@a+t3 z-Fp(jVk#Cb>oRz%1SFOP>cp(3M8d!jaSX;3fRcb^G{yOHQ;c5TJ@{E(0qY2Hrs`Nh z%q=u#^teWdZ(YT=u$CcdQ!=El^0g15RDGs+1n`Sv4)c0@J)LxB(zS$)Phw-VfnS0>5$&VcJC}H%e8NVBi=DVm$_)Ly2!nLvitCmAl}r z^92MSo!8sT}k*akCE@mis{;@@6ijIW)q9h4Z24o(Ql%Ellm(^RAlGzid{_` z*0MpCl`w?R0zi>>s3pEqW>H-~RCSRKkjRO+G)A@FQS4OaW;_u)wWoPcHtuKFYdrjqCf=5`Mid#Pd+AJ>X%4?NQy~wcf9{+reTaPit^+(1>GPc;Sn` zghQ!VQ)wQHn(zf@7|u@a$^B}b8V;0Q7%^G!y2#J5y_C*S!suKuMuaX=?k#Tj)N5xi zHGqcJE=Zgu7&@vt5Vq}Tex&eA7n#*zyn0W;CoVp7z=wS`Oxclkf>aslQ5VDw^+Z}E zkygk@i0Dew6Qqzig;wkX^@_L_sbh@wA}OxQS%IywXb5a|vH^{|C6bPlZGn~H;G&1}aNK z40^BcT%m!2p~foS0jo>}OFEAgkS9sqGz_44lzYowyjO`;$jY$Wz)Gm0F^vwh?6E6+#C5m$RxEWfj7Xx)TuDP!o4GZr zTh4}FR=U0kS439fV$2E}&svaK%BG&LJ>J|}|MtngQa5{!6n&h$#w1nX0J0q@TB}Lv z=HgU{BvX7;F&EJlDda|E*O1q<$lB)Bg(4Z3iwZQ_(NQkaf5u%b} zV$dv14(-eWAmz{{S-)wTv^}rTE@7o3g#WDwfzGaMvV#D$*{vuVt?z=J)``)*BS4Yg z215*Hs6?j{NxG<#K#fO}D=^S|`5Br)-=-fGkAk@Eq49?Vp#9D0^`Jacbd8c6vS3Lg zy1l$_Vbh;PZ+q0sDT%{uv_p7KCbEcofU!Is%ey5YD{b0bVW3{0fXoq2M*ViR*wI3z zp&$x3M$nI0mp&O+^J(gyOys;(!^7H+(I&0lj(8*&`pwYk9pW=UZBMiwO~5xp*J0cJ`N^}B#{QGtjj zO0O5LHEnhgfG^nBRJh%6!)f$8akmDA@&+t0;L-p|_3+v6@Bd$G?XyorNCuL;FYe{Z zl%7t7MqxFw+eL=n`wX*jh-8sb?lC zF0AAjtz=s(gk*E5p0n1n;jiu|`!}sTwDbA(4{dNV_(Zyvmka!~PHhsJ!-c6QqwECV zTgWCh(Jwf)O*hrRz6sAGtv9UAjPPVmX%~H3SIr_p4!fxap(ZP4g?iZ3bz?Xy^TpTw zDiTY2lOWX9rK{X=4`&;Wy2xQm1}YU33L_Dg$lR_(G&s$yLNQ`q!Kji&r#s7z@i(NV z20$2p#AgL&ppY{Pca7rCFyW6yq|}@bIT2SJyngaz@YdTOm0U(D8H48=CybmX&OPI#_cy$d2CnC@P6^Im5Y>f(9KU zM29RsjKqX_(hKX`)Ki%m@HQ9-<^hYZJ;4R8wnR7jc)_gExfzG>N)XP#!{~XO!lS?Q z{mI(Vfx64RJ-){BRP%X*zgISh!r`#L96*T$AHJ^Ebd8;-s<{@2$vXxjajifnA2cMPa z>j{+em+Ll!vyOQfUx=fjY2@N3EUwz>(bx&OL|aiUt{+sG�^(r=9vBjex{%TD(KP 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¨zT!G~&5oWl)GF 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

2!%Na$ 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