* Makefile.in: Use variables rather than configure constructs where

appropriate.
(LIBCOS): Find additional stub library stuff in their own subdirectory.
* dcrt0.cc: Convert user_data pointer to static __cygwin_user_data area.
(do_global_ctors): Check magic_bisquit for initialization.
(dll_crt0_1): First group of premain functions prior to fd initialization.  Run
second group before calling main.
(dll_crt0 ()): New function, called from new initialization code.
(dll_crt0 (per_process *uptr)): Call new dll_crt0 () function on
initialization.
* debug.cc (thread_stub): Initialize bottom of stack with per-thread info.
* environ.cc (parse_thing): Use binmode global to control CYGWIN=binmode
behavior.
* fhandler.cc (fhandler_base::open): Allow explicit setting of __fmode to
O_BINARY or O_TEXT to override disk mount settings.
* libcmain.cc: Move to lib subdirectory.
* libccrt0.cc: Ditto.
* dll_main.cc: Ditto.
* dll_entry.cc: Ditto.
* getopt.c: Ditto.
* thread.cc (thread_init_wrapper): Call ExitThread explicitly rather than
returning, as a preliminary step towards placing per thread info at the bottom
of the stack.
* winsup.h: Move per_process class to include/sys/cygwin.h.  Declare new
dll_crt0().
* include/cygwin/version.h: Bump API minor version.
* binmode.c: New file.
* textmode.c: Ditto.
* lib/_cygwin_crt0_common.cc: Ditto.
* lib/crt0.h: Ditto.
* lib/cygwin_attach_dll.c: Ditto.
* lib/cygwin_crt0.c: Ditto.
* lib/dll_entry.cc: Ditto.
* lib/dll_main.cc: Ditto.
* lib/getopt.c: Ditto.
* lib/libcmain.c: Ditto.
* lib/premain0.c: Ditto.
* lib/premain1.c: Ditto.
* lib/premain2.c: Ditto.
* lib/premain3.c: Ditto.

winsup/cygwin/lib/_cygwin_crt0_common.cc

@@ -0,0 +1,76 @@
+/* common.cc: common crt0 function for cygwin crt0's.
+
+   Copyright 2000 Cygnus Solutions.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include "winsup.h"
+#include "crt0.h"
+#include <reent.h>
+#include <stdlib.h>
+
+extern __declspec(dllimport) per_process __cygwin_user_data;
+
+extern "C"
+{
+char **environ;
+void cygwin_crt0 (MainFunc);
+int cygwin_attach_dll (HMODULE, MainFunc);
+int cygwin_attach_noncygwin_dll (HMODULE, MainFunc);
+int main (int, char **, char **);
+struct _reent *_impure_ptr;
+int _fmode;
+
+/* Set up pointers to various pieces so the dll can then use them,
+   and then jump to the dll.  */
+
+void
+_cygwin_crt0_common (MainFunc f)
+{
+  /* This is used to record what the initial sp was.  The value is needed
+     when copying the parent's stack to the child during a fork.  */
+  int onstack;
+
+  /* The version numbers are the main source of compatibility checking.
+     As a backup to them, we use the size of the per_process struct.  */
+  __cygwin_user_data.magic_biscuit = sizeof (per_process);
+
+  /* cygwin.dll version number in effect at the time the app was created.  */
+  __cygwin_user_data.dll_major = CYGWIN_VERSION_DLL_MAJOR;
+  __cygwin_user_data.dll_minor = CYGWIN_VERSION_DLL_MINOR;
+  __cygwin_user_data.api_major = CYGWIN_VERSION_API_MAJOR;
+  __cygwin_user_data.api_minor = CYGWIN_VERSION_API_MINOR;
+
+  __cygwin_user_data.ctors = &__CTOR_LIST__;
+  __cygwin_user_data.dtors = &__DTOR_LIST__;
+  __cygwin_user_data.envptr = &environ;
+  __cygwin_user_data.impure_ptr_ptr = &_impure_ptr;
+  __cygwin_user_data.main = f;
+  __cygwin_user_data.premain[0] = cygwin_premain0;
+  __cygwin_user_data.premain[1] = cygwin_premain1;
+  __cygwin_user_data.premain[2] = cygwin_premain2;
+  __cygwin_user_data.premain[3] = cygwin_premain3;
+  __cygwin_user_data.fmode_ptr = &_fmode;
+  __cygwin_user_data.initial_sp = (char *) &onstack;
+
+  /* Remember whatever the user linked his application with - or
+     point to entries in the dll.  */
+  __cygwin_user_data.malloc = &malloc;
+  __cygwin_user_data.free = &free;
+  __cygwin_user_data.realloc = &realloc;
+  __cygwin_user_data.calloc = &calloc;
+
+  /* Setup the module handle so fork can get the path name. */
+  __cygwin_user_data.hmodule = GetModuleHandle (0);
+
+  /* variables for fork */
+  __cygwin_user_data.data_start = &_data_start__;
+  __cygwin_user_data.data_end = &_data_end__;
+  __cygwin_user_data.bss_start = &_bss_start__;
+  __cygwin_user_data.bss_end = &_bss_end__;
+}
+} /* "C" */

winsup/cygwin/lib/crt0.h

@@ -0,0 +1,22 @@
+/* crt0.h: header file for crt0.
+
+   Copyright 2000 Cygnus Solutions.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct per_process;
+typedef int (*MainFunc) (int argc, char *argv[], char **env);
+void _cygwin_crt0_common (MainFunc);
+int dll_dllcrt0 (HMODULE, struct per_process *);
+
+#ifdef __cplusplus
+}
+#endif

winsup/cygwin/lib/cygwin_attach_dll.c

@@ -0,0 +1,22 @@
+/* attach_dll.cc: crt0 for attaching cygwin DLL from a non-cygwin app.
+
+   Copyright 2000 Cygnus Solutions.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include <windows.h>
+#include "crt0.h"
+
+/* for a loaded dll */
+int
+cygwin_attach_dll (HMODULE h, MainFunc f)
+{
+  _cygwin_crt0_common (f);
+
+  /* jump into the dll. */
+  return dll_dllcrt0 (h, NULL);
+}

winsup/cygwin/lib/cygwin_crt0.c

@@ -0,0 +1,24 @@
+/* crt0.cc: crt0 for libc
+
+   Copyright 2000 Cygnus Solutions.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include <windows.h>
+#include "crt0.h"
+
+extern void __stdcall dll_crt0 (void)  __declspec (dllimport);
+
+/* for main module */
+void
+cygwin_crt0 (MainFunc f)
+{
+  _cygwin_crt0_common (f);
+
+ /* Jump into the dll. */
+  dll_crt0 ();
+}

winsup/cygwin/lib/dll_entry.c

@@ -0,0 +1,17 @@
+/* dll_entry.cc: Provide the default user DLL linker entry point.
+
+   Copyright 1998, 2000 Cygnus Solutions.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+/* Here we simply instantiate the DECLARE_CYGWIN_DLL to define the
+   linker entry point, __cygwin_dll_entry@12, which in turn calls
+   _DllMain@12 to do user-specific initialization, if any. There is a
+   default DllMain stub in the library if there is no user supplied
+   one. */
+
+#include "cygwin/cygwin_dll.h"
+
+DECLARE_CYGWIN_DLL (DllMain);

winsup/cygwin/lib/dll_main.cc

@@ -0,0 +1,41 @@
+/* dll_main.cc: Provide the DllMain stub that the user can override.
+
+   Copyright 1998, 2000 Cygnus Solutions.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include <windows.h>
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+#include <stdio.h>
+
+extern "C"
+BOOL APIENTRY DllMain (HINSTANCE hInst, DWORD reason,
+                       LPVOID reserved /* Not used. */ );
+
+BOOL APIENTRY
+DllMain (
+	 HINSTANCE hInst /* Library instance handle. */ ,
+	 DWORD reason /* Reason this function is being called. */ ,
+	 LPVOID reserved /* Not used. */ )
+{
+  switch (reason)
+    {
+    case DLL_PROCESS_ATTACH:
+      break;
+
+    case DLL_PROCESS_DETACH:
+      break;
+
+    case DLL_THREAD_ATTACH:
+      break;
+
+    case DLL_THREAD_DETACH:
+      break;
+    }
+  return TRUE;
+}

winsup/cygwin/lib/getopt.c

@@ -0,0 +1,391 @@
+/*
+ * Copyright (c) 1987, 1993, 1994, 1996
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "getopt.h"
+
+int	  opterr = 1;	/* if error message should be printed */
+int	  optind = 1;	/* index into parent argv vector */
+int	  optopt;	/* character checked for validity */
+int	  optreset;	/* reset getopt */
+char 	  *optarg;	/* argument associated with option */
+
+static char * __progname (char *);
+int getopt_internal (int, char * const *, const char *);
+
+static char * __progname(nargv0)
+    char * nargv0;
+{
+    char * tmp = strrchr(nargv0, '/');
+    if (tmp) tmp++; else tmp = nargv0;
+    return(tmp);
+}
+
+#define	BADCH	(int)'?'
+#define	BADARG	(int)':'
+#define	EMSG	""
+
+/*
+ * getopt --
+ *	Parse argc/argv argument vector.
+ */
+int
+getopt_internal(nargc, nargv, ostr)
+	int nargc;
+	char * const *nargv;
+	const char *ostr;
+{
+	static const char *place = EMSG;	/* option letter processing */
+	char *oli;				/* option letter list index */
+
+	if (optreset || !*place) {		/* update scanning pointer */
+		optreset = 0;
+		if (optind >= nargc || *(place = nargv[optind]) != '-') {
+			place = EMSG;
+			return (-1);
+		}
+		if (place[1] && *++place == '-') {	/* found "--" */
+			/* ++optind; */
+			place = EMSG;
+			return (-2);
+		}
+	}					/* option letter okay? */
+	if ((optopt = (int)*place++) == (int)':' ||
+	    !(oli = strchr(ostr, optopt))) {
+		/*
+		 * if the user didn't specify '-' as an option,
+		 * assume it means -1.
+		 */
+		if (optopt == (int)'-')
+			return (-1);
+		if (!*place)
+			++optind;
+		if (opterr && *ostr != ':')
+			(void)fprintf(stderr,
+			    "%s: illegal option -- %c\n", __progname(nargv[0]), optopt);
+		return (BADCH);
+	}
+	if (*++oli != ':') {			/* don't need argument */
+		optarg = NULL;
+		if (!*place)
+			++optind;
+	} else {				/* need an argument */
+		if (*place)			/* no white space */
+			optarg = (char *)place;
+		else if (nargc <= ++optind) {	/* no arg */
+			place = EMSG;
+			if ((opterr) && (*ostr != ':'))
+				(void)fprintf(stderr,
+				    "%s: option requires an argument -- %c\n",
+				    __progname(nargv[0]), optopt);
+			return (BADARG);
+		} else				/* white space */
+			optarg = nargv[optind];
+		place = EMSG;
+		++optind;
+	}
+	return (optopt);			/* dump back option letter */
+}
+
+/*
+ * getopt --
+ *	Parse argc/argv argument vector.
+ */
+int
+getopt(nargc, nargv, ostr)
+	int nargc;
+	char * const *nargv;
+	const char *ostr;
+{
+	int retval;
+
+	if ((retval = getopt_internal(nargc, nargv, ostr)) == -2) {
+		retval = -1;
+		++optind;
+	}
+	return(retval);
+}
+
+/*
+ * getopt_long --
+ *	Parse argc/argv argument vector.
+ */
+int
+getopt_long(nargc, nargv, options, long_options, index)
+     int nargc;
+     char ** nargv;
+     char * options;
+     struct option * long_options;
+     int * index;
+{
+	int retval;
+
+	if ((retval = getopt_internal(nargc, nargv, options)) == -2) {
+		char *current_argv = nargv[optind++] + 2, *has_equal;
+		int i, match = -1;
+		size_t current_argv_len;
+
+		if (*current_argv == '\0') {
+			return(-1);
+		}
+		if ((has_equal = strchr(current_argv, '='))) {
+			current_argv_len = has_equal - current_argv;
+			has_equal++;
+		} else
+			current_argv_len = strlen(current_argv);
+
+		for (i = 0; long_options[i].name; i++) {
+			if (strncmp(current_argv, long_options[i].name, current_argv_len))
+				continue;
+
+			if (strlen(long_options[i].name) == current_argv_len) {
+				match = i;
+				break;
+			}
+			if (match == -1)
+				match = i;
+		}
+		if (match != -1) {
+			if (long_options[match].has_arg) {
+				if (has_equal)
+					optarg = has_equal;
+				else
+					optarg = nargv[optind++];
+			}
+			if ((long_options[match].has_arg == 1) && (optarg == NULL)) {
+				/* Missing option, leading : indecates no error */
+				if ((opterr) && (*options != ':'))
+					(void)fprintf(stderr,
+				      "%s: option requires an argument -- %s\n",
+				      __progname(nargv[0]), current_argv);
+				return (BADARG);
+			}
+		} else { /* No matching argument */
+			if ((opterr) && (*options != ':'))
+				(void)fprintf(stderr,
+				    "%s: illegal option -- %s\n", __progname(nargv[0]), current_argv);
+			return (BADCH);
+		}
+		if (long_options[match].flag) {
+			*long_options[match].flag = long_options[match].val;
+			retval = 0;
+		} else
+			retval = long_options[match].val;
+		if (index)
+			*index = match;
+	}
+	return(retval);
+}
+/*****************************************************************/
+
+
+
+
+
+
+#include <stdio.h>
+#include "getopt.h"
+
+/* Stuff for getopt */
+static struct option long_options[] = {
+	{ (char *)"simple", 0, NULL, 's' },
+	{ (char *)"t", 0, NULL, 't' },
+	{ (char *)"u", 1, NULL, 'u' },
+	{ (char *)"v", 0, NULL, 'v' },
+	/* Do not reorder the following */
+	{ (char *)"yy", 0, NULL, 'Y' },
+	{  (char *)"y", 0, NULL, 'y' },
+	{ (char *)"zz", 0, NULL, 'z' },
+	{ (char *)"zzz", 0, NULL, 'Z' },
+	{ NULL, 0, NULL, 0 }
+};
+extern char * optarg;
+extern int optreset;
+extern int optind;
+
+int test_getopt_long(args, expected_result)
+    char ** args, * expected_result;
+{
+	char actual_result[256];
+	int count, pass, i;
+
+	pass = 0;
+	optind = 1;
+	optreset = 1;
+	for (count = 0; args[count]; count++);
+	while ((i = getopt_long(count, args, (char *)"ab:", long_options, NULL)) != EOF) {
+		switch(i) {
+		case 'u':
+			if (strcmp(optarg, "bogus")) {
+				printf("--u option does not have bogus optarg.\n");
+				return(1);
+			}
+		case 'Y':
+		case 's':
+		case 't':
+		case 'v':
+		case 'y':
+		case 'z':
+			actual_result[pass++] = i;
+			break;
+		default:
+			actual_result[pass++] = '?';
+			break;
+		}
+	}
+
+	actual_result[pass] = '\0';
+	return(strcmp(actual_result, expected_result));
+	
+}
+
+#if 0
+int usage(value)
+	int value;
+{
+	printf("test_getopt [-d]\n");
+	exit(value);
+}
+#endif
+
+#if 0
+
+/*
+ * Static arglists for individual tests
+ * This is ugly and maybe I should just use a variable arglist
+ */
+const char *argv1[] = { "Test simple", "--s", NULL };
+const char *argv2[] = { "Test multiple", "--s", "--t", NULL };
+const char *argv3[] = { "Test optarg with space", "--u", "bogus", NULL };
+const char *argv4[] = { "Test optarg with equal", "--u=bogus", NULL };
+const char *argv5[] = { "Test complex", "--s", "--t", "--u", "bogus", "--v", NULL };
+const char *argv6[] = { "Test exact", "--y", NULL };
+const char *argv7[] = { "Test abbr", "--z", NULL };
+const char *argv8[] = { "Test simple termination", "--z", "foo", "--z", NULL };
+const char *argv9[] = { "Test -- termination", "--z", "--", "--z", NULL };
+
+int debug = 0;
+int main(argc, argv)
+    int argc;
+    char ** argv;
+{
+	int i;
+
+	/* Of course if getopt() has a bug this won't work */
+	while ((i = getopt(argc, argv, "d")) != EOF) {
+		switch(i) {
+		case 'd':
+			debug++;
+			break;
+		default:
+			usage(1);
+			break;
+		}
+	}
+
+	/* Test getopt_long() */
+	{
+		if (test_getopt_long(argv1, "s")) {
+			printf("Test simple failed.\n");
+			exit(1);
+		}
+	}
+
+	/* Test multiple arguments */
+	{
+		if (test_getopt_long(argv2, "st")) {
+			printf("Test multiple failed.\n");
+			exit(1);
+		}
+	}
+
+	/* Test optarg with space */
+	{
+		if (test_getopt_long(argv3, "u")) {
+			printf("Test optarg with space failed.\n");
+			exit(1);
+		}
+	}
+
+	/* Test optarg with equal */
+	{
+		if (test_getopt_long(argv4, "u")) {
+			printf("Test optarg with equal failed.\n");
+			exit(1);
+		}
+	}
+
+	/* Test complex */
+	{
+		if (test_getopt_long(argv5, "stuv")) {
+			printf("Test complex failed.\n");
+			exit(1);
+		}
+	}
+
+	/* Test that exact matches override abbr matches */
+	{
+		if (test_getopt_long(argv6, "y")) {
+			printf("Test exact failed.\n");
+			exit(1);
+		}
+	}
+
+	/* Test that abbr matches are first match. */
+	{
+		if (test_getopt_long(argv7, "z")) {
+			printf("Test abbr failed.\n");
+			exit(1);
+		}
+	}
+
+	/* Test that option termination succeeds */
+	{
+		if (test_getopt_long(argv8, "z")) {
+			printf("Test simple termination failed.\n");
+			exit(1);
+		}
+	}
+
+	/* Test that "--" termination succeeds */
+	{
+		if (test_getopt_long(argv9, "z")) {
+			printf("Test -- termination failed.\n");
+			exit(1);
+		}
+	}
+	exit(0);
+}
+#endif

winsup/cygwin/lib/libcmain.c

@@ -0,0 +1,35 @@
+/* libcmain.c
+
+   Copyright 1996, 1997, 1998, 2000 Cygnus Solutions.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+#include <windows.h>
+
+/* Allow apps which don't have a main work, as long as they define WinMain */
+int
+main ()
+{
+  HMODULE x = GetModuleHandleA(0);
+  char *s = GetCommandLineA ();
+  STARTUPINFO si;
+
+  /* GetCommandLineA returns the entire command line including the
+     program name, but WinMain is defined to accept the command
+     line without the program name.  */
+  while (*s != ' ' && *s != '\0')
+    ++s;
+  while (*s == ' ')
+    ++s;
+
+  GetStartupInfo (&si);
+
+  return WinMain (x, 0, s,
+		  ((si.dwFlags & STARTF_USESHOWWINDOW) != 0
+		   ? si.wShowWindow
+		   : SW_SHOWNORMAL));
+}

winsup/cygwin/lib/premain0.c

@@ -0,0 +1,14 @@
+/* premain0.c
+
+   Copyright 2000 Red Hat, Inc.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+void
+cygwin_premain0(int argc, char **argv)
+{
+}

winsup/cygwin/lib/premain1.c

@@ -0,0 +1,14 @@
+/* premain1.c
+
+   Copyright 2000 Red Hat, Inc.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+void
+cygwin_premain1(int argc, char **argv)
+{
+}

winsup/cygwin/lib/premain2.c

@@ -0,0 +1,14 @@
+/* premain2.c
+
+   Copyright 2000 Red Hat, Inc.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+void
+cygwin_premain2(int argc, char **argv)
+{
+}

winsup/cygwin/lib/premain3.c

@@ -0,0 +1,14 @@
+/* premain3.c
+
+   Copyright 2000 Red Hat, Inc.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+void
+cygwin_premain3(int argc, char **argv)
+{
+}