[people/ms/u-boot.git] / tools / mingw_support.c

/*
 * Copyright 2008 Extreme Engineering Solutions, Inc.
 *
 * mmap/munmap implementation derived from:
 * Clamav Native Windows Port : mmap win32 compatibility layer
 * Copyright (c) 2005-2006 Gianluigi Tiesi <sherpya@netfarm.it>
 * Parts by Kees Zeelenberg <kzlg@users.sourceforge.net> (LibGW32C)
 *
 * 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 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 software; if not, write to the
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "mingw_support.h"
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <io.h>

int fsync(int fd)
{
	return _commit(fd);
}

void *mmap(void *addr, size_t len, int prot, int flags, int fd, int offset)
{
	void *map = NULL;
	HANDLE handle = INVALID_HANDLE_VALUE;
	DWORD cfm_flags = 0, mvf_flags = 0;

	switch (prot) {
	case PROT_READ | PROT_WRITE:
		cfm_flags = PAGE_READWRITE;
		mvf_flags = FILE_MAP_ALL_ACCESS;
		break;
	case PROT_WRITE:
		cfm_flags = PAGE_READWRITE;
		mvf_flags = FILE_MAP_WRITE;
		break;
	case PROT_READ:
		cfm_flags = PAGE_READONLY;
		mvf_flags = FILE_MAP_READ;
		break;
	default:
		return MAP_FAILED;
	}

	handle = CreateFileMappingA((HANDLE) _get_osfhandle(fd), NULL,
				cfm_flags, HIDWORD(len), LODWORD(len), NULL);
	if (!handle)
		return MAP_FAILED;

	map = MapViewOfFile(handle, mvf_flags, HIDWORD(offset),
			LODWORD(offset), len);
	CloseHandle(handle);

	if (!map)
		return MAP_FAILED;

	return map;
}

int munmap(void *addr, size_t len)
{
	if (!UnmapViewOfFile(addr))
		return -1;

	return 0;
}

/* Reentrant string tokenizer.  Generic version.
   Copyright (C) 1991,1996-1999,2001,2004,2007 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */

/* Parse S into tokens separated by characters in DELIM.
   If S is NULL, the saved pointer in SAVE_PTR is used as
   the next starting point.  For example:
	char s[] = "-abc-=-def";
	char *sp;
	x = strtok_r(s, "-", &sp);	// x = "abc", sp = "=-def"
	x = strtok_r(NULL, "-=", &sp);	// x = "def", sp = NULL
	x = strtok_r(NULL, "=", &sp);	// x = NULL
		// s = "abc\0-def\0"
*/
char *strtok_r(char *s, const char *delim, char **save_ptr)
{
	char *token;

	if (s == NULL)
		s = *save_ptr;

	/* Scan leading delimiters.  */
	s += strspn(s, delim);
	if (*s == '\0') {
		*save_ptr = s;
		return NULL;
	}

	/* Find the end of the token.  */
	token = s;
	s = strpbrk (token, delim);
	if (s == NULL) {
		/* This token finishes the string.  */
		*save_ptr = memchr(token, '\0', strlen(token));
	} else {
		/* Terminate the token and make *SAVE_PTR point past it.  */
		*s = '\0';
		*save_ptr = s + 1;
	}
	return token;
}

/* getline.c -- Replacement for GNU C library function getline

Copyright (C) 1993, 1996, 2001, 2002 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 of the
License, 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. */

/* Written by Jan Brittenson, bson@gnu.ai.mit.edu.  */

/* Always add at least this many bytes when extending the buffer.  */
#define MIN_CHUNK 64

/* Read up to (and including) a TERMINATOR from STREAM into *LINEPTR
   + OFFSET (and null-terminate it). *LINEPTR is a pointer returned from
   malloc (or NULL), pointing to *N characters of space.  It is realloc'd
   as necessary.  Return the number of characters read (not including the
   null terminator), or -1 on error or EOF.
   NOTE: There is another getstr() function declared in <curses.h>.  */
static int getstr(char **lineptr, size_t *n, FILE *stream,
		  char terminator, size_t offset)
{
	int nchars_avail;	/* Allocated but unused chars in *LINEPTR.  */
	char *read_pos;		/* Where we're reading into *LINEPTR. */
	int ret;

	if (!lineptr || !n || !stream)
		return -1;

	if (!*lineptr) {
		*n = MIN_CHUNK;
		*lineptr = malloc(*n);
		if (!*lineptr)
			return -1;
	}

	nchars_avail = *n - offset;
	read_pos = *lineptr + offset;

	for (;;) {
		register int c = getc(stream);

		/* We always want at least one char left in the buffer, since we
		   always (unless we get an error while reading the first char)
		   NUL-terminate the line buffer.  */

		assert(*n - nchars_avail == read_pos - *lineptr);
		if (nchars_avail < 2) {
			if (*n > MIN_CHUNK)
				*n *= 2;
			else
				*n += MIN_CHUNK;

			nchars_avail = *n + *lineptr - read_pos;
			*lineptr = realloc(*lineptr, *n);
			if (!*lineptr)
				return -1;
			read_pos = *n - nchars_avail + *lineptr;
			assert(*n - nchars_avail == read_pos - *lineptr);
		}

		if (c == EOF || ferror (stream)) {
			/* Return partial line, if any.  */
			if (read_pos == *lineptr)
				return -1;
			else
				break;
		}

		*read_pos++ = c;
		nchars_avail--;

		if (c == terminator)
			/* Return the line.  */
			break;
	}

	/* Done - NUL terminate and return the number of chars read.  */
	*read_pos = '\0';

	ret = read_pos - (*lineptr + offset);
	return ret;
}

int getline (char **lineptr, size_t *n, FILE *stream)
{
	return getstr(lineptr, n, stream, '\n', 0);
}
Commit	Line	Data
2f8d396b PT	1	/*
	2	* Copyright 2008 Extreme Engineering Solutions, Inc.
	3	*
	4	* mmap/munmap implementation derived from:
	5	* Clamav Native Windows Port : mmap win32 compatibility layer
	6	* Copyright (c) 2005-2006 Gianluigi Tiesi <sherpya@netfarm.it>
	7	* Parts by Kees Zeelenberg <kzlg@users.sourceforge.net> (LibGW32C)
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU Library General Public
	11	* License as published by the Free Software Foundation; either
	12	* version 2 of the License, or (at your option) any later version.
	13	*
	14	* This library is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* Library General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU Library General Public
	20	* License along with this software; if not, write to the
	21	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	22	*/
	23
	24	#include "mingw_support.h"
	25	#include <stdio.h>
	26	#include <stdint.h>
faf36c14	27	#include <string.h>
2f8d396b	28	#include <errno.h>
faf36c14	29	#include <assert.h>
2f8d396b PT	30	#include <io.h>
	31
	32	int fsync(int fd)
	33	{
	34	return _commit(fd);
	35	}
	36
	37	void mmap(void addr, size_t len, int prot, int flags, int fd, int offset)
	38	{
	39	void *map = NULL;
	40	HANDLE handle = INVALID_HANDLE_VALUE;
	41	DWORD cfm_flags = 0, mvf_flags = 0;
	42
	43	switch (prot) {
	44	case PROT_READ \| PROT_WRITE:
	45	cfm_flags = PAGE_READWRITE;
	46	mvf_flags = FILE_MAP_ALL_ACCESS;
	47	break;
	48	case PROT_WRITE:
	49	cfm_flags = PAGE_READWRITE;
	50	mvf_flags = FILE_MAP_WRITE;
	51	break;
	52	case PROT_READ:
	53	cfm_flags = PAGE_READONLY;
	54	mvf_flags = FILE_MAP_READ;
	55	break;
	56	default:
	57	return MAP_FAILED;
	58	}
	59
	60	handle = CreateFileMappingA((HANDLE) _get_osfhandle(fd), NULL,
	61	cfm_flags, HIDWORD(len), LODWORD(len), NULL);
	62	if (!handle)
	63	return MAP_FAILED;
	64
	65	map = MapViewOfFile(handle, mvf_flags, HIDWORD(offset),
	66	LODWORD(offset), len);
	67	CloseHandle(handle);
	68
	69	if (!map)
	70	return MAP_FAILED;
	71
	72	return map;
	73	}
	74
	75	int munmap(void *addr, size_t len)
	76	{
	77	if (!UnmapViewOfFile(addr))
	78	return -1;
	79
	80	return 0;
	81	}
faf36c14 RB	82
	83	/* Reentrant string tokenizer. Generic version.
	84	Copyright (C) 1991,1996-1999,2001,2004,2007 Free Software Foundation, Inc.
	85	This file is part of the GNU C Library.
	86
	87	This program is free software; you can redistribute it and/or modify
	88	it under the terms of the GNU General Public License as published by
	89	the Free Software Foundation; either version 2, or (at your option)
	90	any later version.
	91
	92	This program is distributed in the hope that it will be useful,
	93	but WITHOUT ANY WARRANTY; without even the implied warranty of
	94	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	95	GNU General Public License for more details.
	96
	97	You should have received a copy of the GNU General Public License along
	98	with this program; if not, write to the Free Software Foundation,
	99	Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
	100
	101	/* Parse S into tokens separated by characters in DELIM.
	102	If S is NULL, the saved pointer in SAVE_PTR is used as
	103	the next starting point. For example:
	104	char s[] = "-abc-=-def";
	105	char *sp;
	106	x = strtok_r(s, "-", &sp); // x = "abc", sp = "=-def"
	107	x = strtok_r(NULL, "-=", &sp); // x = "def", sp = NULL
	108	x = strtok_r(NULL, "=", &sp); // x = NULL
	109	// s = "abc\0-def\0"
	110	*/
	111	char strtok_r(char s, const char delim, char *save_ptr)
	112	{
	113	char *token;
	114
	115	if (s == NULL)
	116	s = *save_ptr;
	117
	118	/* Scan leading delimiters. */
	119	s += strspn(s, delim);
	120	if (*s == '\0') {
	121	*save_ptr = s;
	122	return NULL;
	123	}
	124
	125	/* Find the end of the token. */
	126	token = s;
	127	s = strpbrk (token, delim);
	128	if (s == NULL) {
	129	/* This token finishes the string. */
	130	*save_ptr = memchr(token, '\0', strlen(token));
	131	} else {
	132	/* Terminate the token and make SAVE_PTR point past it. /
	133	*s = '\0';
	134	*save_ptr = s + 1;
	135	}
	136	return token;
	137	}
	138
	139	/* getline.c -- Replacement for GNU C library function getline
	140
	141	Copyright (C) 1993, 1996, 2001, 2002 Free Software Foundation, Inc.
	142
	143	This program is free software; you can redistribute it and/or
	144	modify it under the terms of the GNU General Public License as
	145	published by the Free Software Foundation; either version 2 of the
146	License, or (at your option) any later version.
147
148	This program is distributed in the hope that it will be useful, but
149	WITHOUT ANY WARRANTY; without even the implied warranty of
150	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
151	General Public License for more details.
152
153	You should have received a copy of the GNU General Public License
154	along with this program; if not, write to the Free Software
155	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
156
157	/* Written by Jan Brittenson, bson@gnu.ai.mit.edu. */
158
159	/* Always add at least this many bytes when extending the buffer. */
160	#define MIN_CHUNK 64
161
162	/* Read up to (and including) a TERMINATOR from STREAM into *LINEPTR
163	+ OFFSET (and null-terminate it). *LINEPTR is a pointer returned from
164	malloc (or NULL), pointing to *N characters of space. It is realloc'd
165	as necessary. Return the number of characters read (not including the
166	null terminator), or -1 on error or EOF.
167	NOTE: There is another getstr() function declared in <curses.h>. */
168	static int getstr(char *lineptr, size_t n, FILE *stream,
169	char terminator, size_t offset)
170	{
171	int nchars_avail; /* Allocated but unused chars in LINEPTR. /
172	char read_pos; / Where we're reading into LINEPTR. /
173	int ret;
174
175	if (!lineptr \|\| !n \|\| !stream)
176	return -1;
177
178	if (!*lineptr) {
179	*n = MIN_CHUNK;
180	lineptr = malloc(n);
181	if (!*lineptr)
182	return -1;
183	}
184
185	nchars_avail = *n - offset;
186	read_pos = *lineptr + offset;
187
188	for (;;) {
189	register int c = getc(stream);
190
191	/* We always want at least one char left in the buffer, since we
192	always (unless we get an error while reading the first char)
193	NUL-terminate the line buffer. */
194
195	assert(n - nchars_avail == read_pos - lineptr);
196	if (nchars_avail < 2) {
197	if (*n > MIN_CHUNK)
198	n = 2;
199	else
200	*n += MIN_CHUNK;
201
202	nchars_avail = n + lineptr - read_pos;
203	lineptr = realloc(lineptr, *n);
204	if (!*lineptr)
205	return -1;
206	read_pos = n - nchars_avail + lineptr;
207	assert(n - nchars_avail == read_pos - lineptr);
208	}
209
210	if (c == EOF \|\| ferror (stream)) {
211	/* Return partial line, if any. */
212	if (read_pos == *lineptr)
213	return -1;
214	else
215	break;
216	}
217
218	*read_pos++ = c;
219	nchars_avail--;
220
221	if (c == terminator)
222	/* Return the line. */
223	break;
224	}
225
226	/* Done - NUL terminate and return the number of chars read. */
227	*read_pos = '\0';
228
229	ret = read_pos - (*lineptr + offset);
230	return ret;
231	}
232
233	int getline (char *lineptr, size_t n, FILE *stream)
234	{
235	return getstr(lineptr, n, stream, '\n', 0);
236	}