Building look(v2.23) for MinGW

building_look2.23_for_mingw.md

1. git clone git://git.kernel.org/pub/scm/utils/util-linux/util-linux.git
2. cd util-linux
3. git checkout v2.23
4. put util_linux-2.23-look.patch.
5. patch -p0 < util_linux-2.23-look.patch
6. cd misc-utils
7. gcc look.c mman.c -I../include -I../include/sys -olook
8. words and web2 put in location of look.exe.

this patch are using mman-win32

util_linux-2.23-look.patch

diff --git include/c.h include/c.h
index a50e8a5..6425a2a 100644
--- include/c.h
+++ include/c.h
@@ -236,39 +236,6 @@ static inline int dirfd(DIR *d)
 #endif
 
 /*
- * MAXHOSTNAMELEN replacement
- */
-static inline size_t get_hostname_max(void)
-{
-	long len = sysconf(_SC_HOST_NAME_MAX);
-
-	if (0 < len)
-		return len;
-
-#ifdef MAXHOSTNAMELEN
-	return MAXHOSTNAMELEN;
-#elif HOST_NAME_MAX
-	return HOST_NAME_MAX;
-#endif
-	return 64;
-}
-
-#ifndef HAVE_USLEEP
-/*
- * This function is marked obsolete in POSIX.1-2001 and removed in
- * POSIX.1-2008. It is replaced with nanosleep().
- */
-static inline int usleep(useconds_t usec)
-{
-	struct timespec waittime = {
-		.tv_sec   =  usec / 1000000L,
-		.tv_nsec  = (usec % 1000000L) * 1000
-	};
-	return nanosleep(&waittime, NULL);
-}
-#endif
-
-/*
  * Constant strings for usage() functions. For more info see
  * Documentation/howto-usage-function.txt and disk-utils/delpart.c
  */
diff --git include/pathnames.h include/pathnames.h
index d7b36ef..3265c6f 100644
--- include/pathnames.h
+++ include/pathnames.h
@@ -68,8 +68,8 @@
 #define _PATH_LOGINDEFS		"/etc/login.defs"
 
 /* used in misc-utils/look.c */
-#define _PATH_WORDS             "/usr/share/dict/words"
-#define _PATH_WORDS_ALT         "/usr/share/dict/web2"
+#define _PATH_WORDS             "words"
+#define _PATH_WORDS_ALT         "web2"
 
 /* mount paths */
 #define _PATH_UMOUNT		"/bin/umount"
diff --git include/sys/mman.h include/sys/mman.h
new file mode 100644
index 0000000..96f68b2
--- /dev/null
+++ include/sys/mman.h
@@ -0,0 +1,55 @@
+/*
+ * sys/mman.h
+ * mman-win32
+ */
+
+#ifndef _SYS_MMAN_H_
+#define _SYS_MMAN_H_
+
+#ifndef _WIN32_WINNT		// Allow use of features specific to Windows XP or later.                   
+#define _WIN32_WINNT 0x0501	// Change this to the appropriate value to target other versions of Windows.
+#endif						
+
+/* All the headers include this file. */
+#ifndef _MSC_VER
+#include <_mingw.h>
+#endif
+
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PROT_NONE       0
+#define PROT_READ       1
+#define PROT_WRITE      2
+#define PROT_EXEC       4
+
+#define MAP_FILE        0
+#define MAP_SHARED      1
+#define MAP_PRIVATE     2
+#define MAP_TYPE        0xf
+#define MAP_FIXED       0x10
+#define MAP_ANONYMOUS   0x20
+#define MAP_ANON        MAP_ANONYMOUS
+
+#define MAP_FAILED      ((void *)-1)
+
+/* Flags for msync. */
+#define MS_ASYNC        1
+#define MS_SYNC         2
+#define MS_INVALIDATE   4
+
+void*   mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);
+int     munmap(void *addr, size_t len);
+int     mprotect(void *addr, size_t len, int prot);
+int     msync(void *addr, size_t len, int flags);
+int     mlock(const void *addr, size_t len);
+int     munlock(const void *addr, size_t len);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /*  _SYS_MMAN_H_ */
diff --git misc-utils/look.c misc-utils/look.c
index 502168b..ee19677 100644
--- misc-utils/look.c
+++ misc-utils/look.c
@@ -56,6 +56,7 @@
 #include <string.h>
 #include <ctype.h>
 #include <getopt.h>
+#include <windows.h>
 
 #include "nls.h"
 #include "xalloc.h"
@@ -65,6 +66,7 @@
 #define	EQUAL		0
 #define	GREATER		1
 #define	LESS		(-1)
+#define PACKAGE_STRING	"util-linux 2.23"
 
 int dflag, fflag;
 /* uglified the source a bit with globals, so that we only need
@@ -86,6 +88,7 @@ main(int argc, char *argv[])
 	struct stat sb;
 	int ch, fd, termchar;
 	char *back, *file, *front, *p;
+	char exe[1024], drive[8], dir[1024], *c;
 
 	static const struct option longopts[] = {
 		{"alternative", no_argument, NULL, 'a'},
@@ -104,14 +107,20 @@ main(int argc, char *argv[])
 
 	setlocale(LC_ALL, "");
 
-	file = _PATH_WORDS;
+	GetModuleFileName(NULL, exe, sizeof(exe));
+	_splitpath(exe, drive, dir, NULL, NULL);
+	while((c = strchr(dir, '\\')) != NULL) {
+		*c = '/';
+	}
+
+	sprintf(file, "%s%s%s", drive, dir, _PATH_WORDS);
 	termchar = '\0';
 	string = NULL;		/* just for gcc */
 
 	while ((ch = getopt_long(argc, argv, "adft:Vh", longopts, NULL)) != -1)
 		switch(ch) {
 		case 'a':
-			file = _PATH_WORDS_ALT;
+			sprintf(file, "%s%s%s", drive, dir, _PATH_WORDS_ALT);
 			break;
 		case 'd':
 			dflag = 1;
diff --git misc-utils/mman.c misc-utils/mman.c
new file mode 100644
index 0000000..5b0bc78
--- /dev/null
+++ misc-utils/mman.c
@@ -0,0 +1,180 @@
+
+#include <windows.h>
+#include <errno.h>
+#include <io.h>
+
+#include "mman.h"
+
+#ifndef FILE_MAP_EXECUTE
+#define FILE_MAP_EXECUTE    0x0020
+#endif /* FILE_MAP_EXECUTE */
+
+static int __map_mman_error(const DWORD err, const int deferr)
+{
+    if (err == 0)
+        return 0;
+    //TODO: implement
+    return err;
+}
+
+static DWORD __map_mmap_prot_page(const int prot)
+{
+    DWORD protect = 0;
+    
+    if (prot == PROT_NONE)
+        return protect;
+        
+    if ((prot & PROT_EXEC) != 0)
+    {
+        protect = ((prot & PROT_WRITE) != 0) ? 
+                    PAGE_EXECUTE_READWRITE : PAGE_EXECUTE_READ;
+    }
+    else
+    {
+        protect = ((prot & PROT_WRITE) != 0) ?
+                    PAGE_READWRITE : PAGE_READONLY;
+    }
+    
+    return protect;
+}
+
+static DWORD __map_mmap_prot_file(const int prot)
+{
+    DWORD desiredAccess = 0;
+    
+    if (prot == PROT_NONE)
+        return desiredAccess;
+        
+    if ((prot & PROT_READ) != 0)
+        desiredAccess |= FILE_MAP_READ;
+    if ((prot & PROT_WRITE) != 0)
+        desiredAccess |= FILE_MAP_WRITE;
+    if ((prot & PROT_EXEC) != 0)
+        desiredAccess |= FILE_MAP_EXECUTE;
+    
+    return desiredAccess;
+}
+
+void* mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off)
+{
+    HANDLE fm, h;
+    
+    void * map = MAP_FAILED;
+    
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4293)
+#endif
+
+    const DWORD dwFileOffsetLow = (sizeof(off_t) <= sizeof(DWORD)) ? 
+                    (DWORD)off : (DWORD)(off & 0xFFFFFFFFL);
+    const DWORD dwFileOffsetHigh = (sizeof(off_t) <= sizeof(DWORD)) ?
+                    (DWORD)0 : (DWORD)((off >> 32) & 0xFFFFFFFFL);
+    const DWORD protect = __map_mmap_prot_page(prot);
+    const DWORD desiredAccess = __map_mmap_prot_file(prot);
+
+    const off_t maxSize = off + (off_t)len;
+
+    const DWORD dwMaxSizeLow = (sizeof(off_t) <= sizeof(DWORD)) ? 
+                    (DWORD)maxSize : (DWORD)(maxSize & 0xFFFFFFFFL);
+    const DWORD dwMaxSizeHigh = (sizeof(off_t) <= sizeof(DWORD)) ?
+                    (DWORD)0 : (DWORD)((maxSize >> 32) & 0xFFFFFFFFL);
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+    errno = 0;
+    
+    if (len == 0 
+        /* Unsupported flag combinations */
+        || (flags & MAP_FIXED) != 0
+        /* Usupported protection combinations */
+        || prot == PROT_EXEC)
+    {
+        errno = EINVAL;
+        return MAP_FAILED;
+    }
+    
+    h = ((flags & MAP_ANONYMOUS) == 0) ? 
+                    (HANDLE)_get_osfhandle(fildes) : INVALID_HANDLE_VALUE;
+
+    if ((flags & MAP_ANONYMOUS) == 0 && h == INVALID_HANDLE_VALUE)
+    {
+        errno = EBADF;
+        return MAP_FAILED;
+    }
+
+    fm = CreateFileMapping(h, NULL, protect, dwMaxSizeHigh, dwMaxSizeLow, NULL);
+
+    if (fm == NULL)
+    {
+        errno = __map_mman_error(GetLastError(), EPERM);
+        return MAP_FAILED;
+    }
+  
+    map = MapViewOfFile(fm, desiredAccess, dwFileOffsetHigh, dwFileOffsetLow, len);
+
+    CloseHandle(fm);
+  
+    if (map == NULL)
+    {
+        errno = __map_mman_error(GetLastError(), EPERM);
+        return MAP_FAILED;
+    }
+
+    return map;
+}
+
+int munmap(void *addr, size_t len)
+{
+    if (UnmapViewOfFile(addr))
+        return 0;
+        
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}
+
+int mprotect(void *addr, size_t len, int prot)
+{
+    DWORD newProtect = __map_mmap_prot_page(prot);
+    DWORD oldProtect = 0;
+    
+    if (VirtualProtect(addr, len, newProtect, &oldProtect))
+        return 0;
+    
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}
+
+int msync(void *addr, size_t len, int flags)
+{
+    if (FlushViewOfFile(addr, len))
+        return 0;
+    
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}
+
+int mlock(const void *addr, size_t len)
+{
+    if (VirtualLock((LPVOID)addr, len))
+        return 0;
+        
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}
+
+int munlock(const void *addr, size_t len)
+{
+    if (VirtualUnlock((LPVOID)addr, len))
+        return 0;
+        
+    errno =  __map_mman_error(GetLastError(), EPERM);
+    
+    return -1;
+}