mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-03-03 07:29:23 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Add NET_HTTP to the amalgamation

Browse source 
This also fixes some POSIX header warnings.
This commit is contained in:
Justine Tunney 2022-05-16 14:33:19 -07:00
parent 55de4ca6b5
commit 59b6ae1cbd
7 changed files with 108 additions and 145 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Makefile
View file

@ -258,6 +258,7 @@ loc: o/$(MODE)/tool/build/summy.com
$(XARGS) wc -l | grep total | awk '{print $$1}' | $<
COSMOPOLITAN_OBJECTS = \
NET_HTTP \
LIBC_DNS \
LIBC_SOCK \
LIBC_NT_WS2_32 \
@ -331,6 +332,7 @@ COSMOPOLITAN_HEADERS = \
LIBC_UNICODE \
LIBC_X \
LIBC_ZIPOS \
NET_HTTP \
THIRD_PARTY_DLMALLOC \
THIRD_PARTY_GDTOA \
THIRD_PARTY_GETOPT \

45
examples/greenbean.c
View file

@ -1,21 +1,12 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2022 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#if 0
/*─────────────────────────────────────────────────────────────────╗
│ To the extent possible under law, Justine Tunney has waived │
│ all copyright and related or neighboring rights to this file, │
│ as it is written in the following disclaimers: │
│ • http://unlicense.org/ │
│ • http://creativecommons.org/publicdomain/zero/1.0/ │
╚─────────────────────────────────────────────────────────────────*/
#endif
#include "libc/assert.h"
#include "libc/bits/atomic.h"
#include "libc/calls/calls.h"
@ -24,6 +15,7 @@
#include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timeval.h"
#include "libc/dce.h"
#include "libc/fmt/conv.h"
#include "libc/fmt/itoa.h"
#include "libc/intrin/kprintf.h"
#include "libc/log/check.h"
@ -31,7 +23,7 @@
#include "libc/macros.internal.h"
#include "libc/mem/mem.h"
#include "libc/runtime/runtime.h"
#include "libc/sock/goodsocket.internal.h"
#include "libc/runtime/sysconf.h"
#include "libc/sock/sock.h"
#include "libc/str/str.h"
#include "libc/sysv/consts/af.h"
@ -93,7 +85,6 @@
*/
#define PORT 8080
#define THREADS 10000
#define HEARTBEAT 100
#define KEEPALIVE 5000
#define LOGGING 0
@ -135,7 +126,7 @@ int Worker(void *id) {
goto WorkerFinished;
}
listen(server, 10);
listen(server, 1);
// connection loop
while (!closingtime) {
@ -150,6 +141,8 @@ int Worker(void *id) {
char inbuf[1500], outbuf[512], *p, *q;
int clientip, client, inmsglen, outmsglen;
// this slows the server down a lot but is needed on non-Linux to
// react to keyboard ctrl-c
if (!IsLinux() &&
poll(&(struct pollfd){server, POLLIN}, 1, HEARTBEAT) < 1) {
continue;
@ -258,9 +251,9 @@ void OnCtrlC(int sig) {
}
int main(int argc, char *argv[]) {
int i;
int i, threads;
uint32_t *hostips;
ShowCrashReports();
// ShowCrashReports();
sigaction(SIGINT, &(struct sigaction){.sa_handler = OnCtrlC}, 0);
for (hostips = GetHostIps(), i = 0; hostips[i]; ++i) {
kprintf("listening on http://%d.%d.%d.%d:%d\n",
@ -268,8 +261,10 @@ int main(int argc, char *argv[]) {
(hostips[i] & 0x0000ff00) >> 010, (hostips[i] & 0x000000ff) >> 000,
PORT);
}
workers = THREADS;
for (i = 0; i < THREADS; ++i) {
threads = argc > 1 ? atoi(argv[1]) : 0;
if (!threads) threads = GetCpuCount();
workers = threads;
for (i = 0; i < threads; ++i) {
void *stack = mmap(0, 65536, PROT_READ | PROT_WRITE,
MAP_STACK | MAP_ANONYMOUS, -1, 0);
clone(Worker, stack, 65536,

42
libc/str/classifypath.c
View file

@ -36,11 +36,11 @@
* inclusive of DOS drive paths, DOS rooted paths, in addition to the
* New Technology UNC paths, then you may do the following:
*
* if (_classifypath(str) & _PATH_ABS) { ... }
* if (_classifypath(str) & _kPathAbs) { ... }
*
* To check if path is a relative path:
*
* if (~_classifypath(str) & _PATH_ABS) { ... }
* if (~_classifypath(str) & _kPathAbs) { ... }
*
* Please note the above check includes rooted paths such as `\foo`
* which is considered absolute by MSDN and we consider it absolute
@ -52,14 +52,14 @@
*
* @return integer value that's one of following:
* - `0` if non-weird relative path e.g. `c`
* - `_PATH_ABS` if absolute (or rooted dos) path e.g. `/⋯`
* - `_PATH_DOS` if `c:`, `d:foo` i.e. drive-relative path
* - `_PATH_ABS|_PATH_DOS` if proper dos path e.g. `c:/foo`
* - `_PATH_DOS|_PATH_DEV` if dos device path e.g. `nul`, `conin$`
* - `_PATH_ABS|_PATH_WIN` if `//c`, `//?c`, etc.
* - `_PATH_ABS|_PATH_WIN|_PATH_DEV` if `//./⋯`, `//?/⋯`
* - `_PATH_ABS|_PATH_WIN|_PATH_DEV|_PATH_ROOT` if `//.` or `//?`
* - `_PATH_ABS|_PATH_NT` e.g. `\??\\⋯` (undoc. strict backslash)
* - `_kPathAbs` if absolute (or rooted dos) path e.g. `/⋯`
* - `_kPathDos` if `c:`, `d:foo` i.e. drive-relative path
* - `_kPathAbs|_kPathDos` if proper dos path e.g. `c:/foo`
* - `_kPathDos|_kPathDev` if dos device path e.g. `nul`, `conin$`
* - `_kPathAbs|_kPathWin` if `//c`, `//?c`, etc.
* - `_kPathAbs|_kPathWin|_kPathDev` if `//./⋯`, `//?/⋯`
* - `_kPathAbs|_kPathWin|_kPathDev|_kPathRoot` if `//.` or `//?`
* - `_kPathAbs|_kPathNt` e.g. `\??\\⋯` (undoc. strict backslash)
* @see "The Definitive Guide on Win32 to NT Path Conversion", James
* Forshaw, Google Project Zero Blog, 2016-02-29
* @see "Naming Files, Paths, and Namespaces", MSDN 01/04/2021
@ -94,17 +94,17 @@ int _classifypath(const char *s) {
(s[2] == 'm' || s[2] == 'M'))) && //
('1' <= s[3] && s[3] <= '9') && //
!s[4])) {
return _PATH_DOS | _PATH_DEV;
return _kPathDos | _kPathDev;
}
switch (s[1]) {
case ':':
switch (s[2]) {
case 0: // c:
default: // c:wut⋯
return _PATH_DOS;
return _kPathDos;
case '/': // c:/⋯
case '\\': // c:\⋯
return _PATH_ABS | _PATH_DOS;
return _kPathAbs | _kPathDos;
}
default:
return 0;
@ -113,37 +113,37 @@ int _classifypath(const char *s) {
if (SupportsWindows()) {
if (s[1] == '?' && s[2] == '?') {
if (!s[3]) {
return _PATH_ABS | _PATH_NT | _PATH_ROOT; // \??\⋯
return _kPathAbs | _kPathNt | _kPathRoot; // \??\⋯
} else if (s[3] == '\\') {
return _PATH_ABS | _PATH_NT; // \??\⋯
return _kPathAbs | _kPathNt; // \??\⋯
}
}
}
// fallthrough
case '/':
if (!SupportsWindows()) {
return _PATH_ABS;
return _kPathAbs;
}
switch (s[1]) {
case 0: // /
default: // /⋯
return _PATH_ABS;
return _kPathAbs;
case '/':
case '\\':
switch (s[2]) {
case 0: // //
default: // //⋯
return _PATH_ABS | _PATH_WIN;
return _kPathAbs | _kPathWin;
case '.':
case '?':
switch (s[3]) {
case 0: // //? or //.
return _PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT;
return _kPathAbs | _kPathWin | _kPathDev | _kPathRoot;
default: // //?⋯ or //.⋯
return _PATH_ABS | _PATH_WIN;
return _kPathAbs | _kPathWin;
case '/':
case '\\': // //?/⋯ or //./⋯
return _PATH_ABS | _PATH_WIN | _PATH_DEV;
return _kPathAbs | _kPathWin | _kPathDev;
}
}
}

2
libc/str/isabspath.c
View file

@ -32,5 +32,5 @@
*
*/
bool _isabspath(const char *path) {
return _classifypath(path) & _PATH_ABS;
return _classifypath(path) & _kPathAbs;
}

12
libc/str/path.h
View file

@ -1,12 +1,12 @@
#ifndef COSMOPOLITAN_LIBC_STR_PATH_H_
#define COSMOPOLITAN_LIBC_STR_PATH_H_
#define _PATH_ABS 1
#define _PATH_DEV 2
#define _PATH_ROOT 4
#define _PATH_DOS 8
#define _PATH_WIN 16
#define _PATH_NT 32
#define _kPathAbs 1
#define _kPathDev 2
#define _kPathRoot 4
#define _kPathDos 8
#define _kPathWin 16
#define _kPathNt 32
#if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_

34
libc/sysv/consts/_posix2.h
View file

@ -1,34 +0,0 @@
#ifndef COSMOPOLITAN_LIBC_SYSV_CONSTS__POSIX2_H_
#define COSMOPOLITAN_LIBC_SYSV_CONSTS__POSIX2_H_
#include "libc/runtime/symbolic.h"
#define _POSIX2_BC_BASE_MAX SYMBOLIC(_POSIX2_BC_BASE_MAX)
#define _POSIX2_BC_DIM_MAX SYMBOLIC(_POSIX2_BC_DIM_MAX)
#define _POSIX2_BC_SCALE_MAX SYMBOLIC(_POSIX2_BC_SCALE_MAX)
#define _POSIX2_BC_STRING_MAX SYMBOLIC(_POSIX2_BC_STRING_MAX)
#define _POSIX2_CHARCLASS_NAME_MAX SYMBOLIC(_POSIX2_CHARCLASS_NAME_MAX)
#define _POSIX2_COLL_WEIGHTS_MAX SYMBOLIC(_POSIX2_COLL_WEIGHTS_MAX)
#define _POSIX2_C_BIND SYMBOLIC(_POSIX2_C_BIND)
#define _POSIX2_EXPR_NEST_MAX SYMBOLIC(_POSIX2_EXPR_NEST_MAX)
#define _POSIX2_LINE_MAX SYMBOLIC(_POSIX2_LINE_MAX)
#define _POSIX2_RE_DUP_MAX SYMBOLIC(_POSIX2_RE_DUP_MAX)
#define _POSIX2_VERSION SYMBOLIC(_POSIX2_VERSION)
#if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_
extern const long _POSIX2_BC_BASE_MAX;
extern const long _POSIX2_BC_DIM_MAX;
extern const long _POSIX2_BC_SCALE_MAX;
extern const long _POSIX2_BC_STRING_MAX;
extern const long _POSIX2_CHARCLASS_NAME_MAX;
extern const long _POSIX2_COLL_WEIGHTS_MAX;
extern const long _POSIX2_C_BIND;
extern const long _POSIX2_EXPR_NEST_MAX;
extern const long _POSIX2_LINE_MAX;
extern const long _POSIX2_RE_DUP_MAX;
extern const long _POSIX2_VERSION;
COSMOPOLITAN_C_END_
#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
#endif /* COSMOPOLITAN_LIBC_SYSV_CONSTS__POSIX2_H_ */

116
test/libc/str/classifypath_test.c
View file

@ -50,72 +50,72 @@ TEST(_classifypath, test) {
if (!SupportsWindows()) return;
EXPECT_EQ(0, _classifypath(""));
EXPECT_EQ(0, _classifypath("xyz"));
EXPECT_EQ(_PATH_DOS | _PATH_DEV, _classifypath("CON"));
EXPECT_EQ(_PATH_DOS | _PATH_DEV, _classifypath("NUL"));
EXPECT_EQ(_kPathDos | _kPathDev, _classifypath("CON"));
EXPECT_EQ(_kPathDos | _kPathDev, _classifypath("NUL"));
EXPECT_EQ(0, _classifypath(":"));
EXPECT_EQ(_PATH_DOS, _classifypath("::"));
EXPECT_EQ(_PATH_DOS, _classifypath(":::"));
EXPECT_EQ(_PATH_DOS, _classifypath("::::"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("::\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\:"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\C:"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\C:\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("/"));
EXPECT_EQ(_PATH_ABS, _classifypath("/:"));
EXPECT_EQ(_PATH_ABS, _classifypath("/C:"));
EXPECT_EQ(_PATH_ABS, _classifypath("/C:/"));
EXPECT_EQ(_kPathDos, _classifypath("::"));
EXPECT_EQ(_kPathDos, _classifypath(":::"));
EXPECT_EQ(_kPathDos, _classifypath("::::"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("::\\"));
EXPECT_EQ(_kPathAbs, _classifypath("\\"));
EXPECT_EQ(_kPathAbs, _classifypath("\\:"));
EXPECT_EQ(_kPathAbs, _classifypath("\\C:"));
EXPECT_EQ(_kPathAbs, _classifypath("\\C:\\"));
EXPECT_EQ(_kPathAbs, _classifypath("/"));
EXPECT_EQ(_kPathAbs, _classifypath("/:"));
EXPECT_EQ(_kPathAbs, _classifypath("/C:"));
EXPECT_EQ(_kPathAbs, _classifypath("/C:/"));
EXPECT_EQ(0, _classifypath("C"));
EXPECT_EQ(_PATH_DOS, _classifypath("C:"));
EXPECT_EQ(_PATH_DOS, _classifypath("C:a"));
EXPECT_EQ(_PATH_DOS, _classifypath("C:a\\"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:\\"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:/"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:\\a"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:/a"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:\\\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\;"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\f\\b\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\f\\b"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\f\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\f"));
EXPECT_EQ(_PATH_ABS | _PATH_NT, _classifypath("\\??\\"));
EXPECT_EQ(_PATH_ABS | _PATH_NT, _classifypath("\\??\\UNC"));
EXPECT_EQ(_PATH_ABS | _PATH_NT, _classifypath("\\??\\UNC\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\?"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\?\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\?\\UNC"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\?\\UNC\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("\\\\?\\UNC\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT,
EXPECT_EQ(_kPathDos, _classifypath("C:"));
EXPECT_EQ(_kPathDos, _classifypath("C:a"));
EXPECT_EQ(_kPathDos, _classifypath("C:a\\"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:\\"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:/"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:\\a"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:/a"));
EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:\\\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\;"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f\\b\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f\\b"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f"));
EXPECT_EQ(_kPathAbs | _kPathNt, _classifypath("\\??\\"));
EXPECT_EQ(_kPathAbs | _kPathNt, _classifypath("\\??\\UNC"));
EXPECT_EQ(_kPathAbs | _kPathNt, _classifypath("\\??\\UNC\\"));
EXPECT_EQ(_kPathAbs, _classifypath("\\?"));
EXPECT_EQ(_kPathAbs, _classifypath("\\?\\"));
EXPECT_EQ(_kPathAbs, _classifypath("\\?\\UNC"));
EXPECT_EQ(_kPathAbs, _classifypath("\\?\\UNC\\"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("\\\\?\\UNC\\"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\\\?"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\??"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\??\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\??\\C:\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT,
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\??"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\??\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\??\\C:\\"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\\\."));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("\\\\.\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("\\\\.\\C:\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\/"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("/\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("//"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("///"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("//;"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT,
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("\\\\.\\"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("\\\\.\\C:\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\/"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("/\\"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("//"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("///"));
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("//;"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("//?"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT,
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("/\\?"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT,
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\/?"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("//??"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT,
EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("//??"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("//."));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT,
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\/."));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT,
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("/\\."));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("//./"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("//./C:/"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("//./"));
EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("//./C:/"));
}