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}' | $< $(XARGS) wc -l | grep total | awk '{print $$1}' | $<
COSMOPOLITAN_OBJECTS = \ COSMOPOLITAN_OBJECTS = \
NET_HTTP \
LIBC_DNS \ LIBC_DNS \
LIBC_SOCK \ LIBC_SOCK \
LIBC_NT_WS2_32 \ LIBC_NT_WS2_32 \
@ -331,6 +332,7 @@ COSMOPOLITAN_HEADERS = \
LIBC_UNICODE \ LIBC_UNICODE \
LIBC_X \ LIBC_X \
LIBC_ZIPOS \ LIBC_ZIPOS \
NET_HTTP \
THIRD_PARTY_DLMALLOC \ THIRD_PARTY_DLMALLOC \
THIRD_PARTY_GDTOA \ THIRD_PARTY_GDTOA \
THIRD_PARTY_GETOPT \ 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 -*-│ #if 0
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│ /*─────────────────────────────────────────────────────────────────╗
╞══════════════════════════════════════════════════════════════════════════════╡ │ To the extent possible under law, Justine Tunney has waived │
│ Copyright 2022 Justine Alexandra Roberts Tunney │ │ all copyright and related or neighboring rights to this file, │
│ │ │ as it is written in the following disclaimers: │
│ Permission to use, copy, modify, and/or distribute this software for │ │ • http://unlicense.org/ │
│ any purpose with or without fee is hereby granted, provided that the │ │ • http://creativecommons.org/publicdomain/zero/1.0/ │
│ above copyright notice and this permission notice appear in all copies. │ ╚─────────────────────────────────────────────────────────────────*/
│ │ #endif
│ 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. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/assert.h" #include "libc/assert.h"
#include "libc/bits/atomic.h" #include "libc/bits/atomic.h"
#include "libc/calls/calls.h" #include "libc/calls/calls.h"
@ -24,6 +15,7 @@
#include "libc/calls/struct/timespec.h" #include "libc/calls/struct/timespec.h"
#include "libc/calls/struct/timeval.h" #include "libc/calls/struct/timeval.h"
#include "libc/dce.h" #include "libc/dce.h"
#include "libc/fmt/conv.h"
#include "libc/fmt/itoa.h" #include "libc/fmt/itoa.h"
#include "libc/intrin/kprintf.h" #include "libc/intrin/kprintf.h"
#include "libc/log/check.h" #include "libc/log/check.h"
@ -31,7 +23,7 @@
#include "libc/macros.internal.h" #include "libc/macros.internal.h"
#include "libc/mem/mem.h" #include "libc/mem/mem.h"
#include "libc/runtime/runtime.h" #include "libc/runtime/runtime.h"
#include "libc/sock/goodsocket.internal.h" #include "libc/runtime/sysconf.h"
#include "libc/sock/sock.h" #include "libc/sock/sock.h"
#include "libc/str/str.h" #include "libc/str/str.h"
#include "libc/sysv/consts/af.h" #include "libc/sysv/consts/af.h"
@ -93,7 +85,6 @@
*/ */
#define PORT 8080 #define PORT 8080
#define THREADS 10000
#define HEARTBEAT 100 #define HEARTBEAT 100
#define KEEPALIVE 5000 #define KEEPALIVE 5000
#define LOGGING 0 #define LOGGING 0
@ -135,7 +126,7 @@ int Worker(void *id) {
goto WorkerFinished; goto WorkerFinished;
} }
listen(server, 10); listen(server, 1);
// connection loop // connection loop
while (!closingtime) { while (!closingtime) {
@ -150,6 +141,8 @@ int Worker(void *id) {
char inbuf[1500], outbuf[512], *p, *q; char inbuf[1500], outbuf[512], *p, *q;
int clientip, client, inmsglen, outmsglen; 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() && if (!IsLinux() &&
poll(&(struct pollfd){server, POLLIN}, 1, HEARTBEAT) < 1) { poll(&(struct pollfd){server, POLLIN}, 1, HEARTBEAT) < 1) {
continue; continue;
@ -258,9 +251,9 @@ void OnCtrlC(int sig) {
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int i; int i, threads;
uint32_t *hostips; uint32_t *hostips;
ShowCrashReports(); // ShowCrashReports();
sigaction(SIGINT, &(struct sigaction){.sa_handler = OnCtrlC}, 0); sigaction(SIGINT, &(struct sigaction){.sa_handler = OnCtrlC}, 0);
for (hostips = GetHostIps(), i = 0; hostips[i]; ++i) { for (hostips = GetHostIps(), i = 0; hostips[i]; ++i) {
kprintf("listening on http://%d.%d.%d.%d:%d\n", 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, (hostips[i] & 0x0000ff00) >> 010, (hostips[i] & 0x000000ff) >> 000,
PORT); PORT);
} }
workers = THREADS; threads = argc > 1 ? atoi(argv[1]) : 0;
for (i = 0; i < THREADS; ++i) { if (!threads) threads = GetCpuCount();
workers = threads;
for (i = 0; i < threads; ++i) {
void *stack = mmap(0, 65536, PROT_READ | PROT_WRITE, void *stack = mmap(0, 65536, PROT_READ | PROT_WRITE,
MAP_STACK | MAP_ANONYMOUS, -1, 0); MAP_STACK | MAP_ANONYMOUS, -1, 0);
clone(Worker, stack, 65536, 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 * inclusive of DOS drive paths, DOS rooted paths, in addition to the
* New Technology UNC paths, then you may do the following: * 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: * 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` * Please note the above check includes rooted paths such as `\foo`
* which is considered absolute by MSDN and we consider it absolute * which is considered absolute by MSDN and we consider it absolute
@ -52,14 +52,14 @@
* *
* @return integer value that's one of following: * @return integer value that's one of following:
* - `0` if non-weird relative path e.g. `c` * - `0` if non-weird relative path e.g. `c`
* - `_PATH_ABS` if absolute (or rooted dos) path e.g. `/⋯` * - `_kPathAbs` if absolute (or rooted dos) path e.g. `/⋯`
* - `_PATH_DOS` if `c:`, `d:foo` i.e. drive-relative path * - `_kPathDos` if `c:`, `d:foo` i.e. drive-relative path
* - `_PATH_ABS|_PATH_DOS` if proper dos path e.g. `c:/foo` * - `_kPathAbs|_kPathDos` if proper dos path e.g. `c:/foo`
* - `_PATH_DOS|_PATH_DEV` if dos device path e.g. `nul`, `conin$` * - `_kPathDos|_kPathDev` if dos device path e.g. `nul`, `conin$`
* - `_PATH_ABS|_PATH_WIN` if `//c`, `//?c`, etc. * - `_kPathAbs|_kPathWin` if `//c`, `//?c`, etc.
* - `_PATH_ABS|_PATH_WIN|_PATH_DEV` if `//./⋯`, `//?/⋯` * - `_kPathAbs|_kPathWin|_kPathDev` if `//./⋯`, `//?/⋯`
* - `_PATH_ABS|_PATH_WIN|_PATH_DEV|_PATH_ROOT` if `//.` or `//?` * - `_kPathAbs|_kPathWin|_kPathDev|_kPathRoot` if `//.` or `//?`
* - `_PATH_ABS|_PATH_NT` e.g. `\??\\⋯` (undoc. strict backslash) * - `_kPathAbs|_kPathNt` e.g. `\??\\⋯` (undoc. strict backslash)
* @see "The Definitive Guide on Win32 to NT Path Conversion", James * @see "The Definitive Guide on Win32 to NT Path Conversion", James
* Forshaw, Google Project Zero Blog, 2016-02-29 * Forshaw, Google Project Zero Blog, 2016-02-29
* @see "Naming Files, Paths, and Namespaces", MSDN 01/04/2021 * @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'))) && // (s[2] == 'm' || s[2] == 'M'))) && //
('1' <= s[3] && s[3] <= '9') && // ('1' <= s[3] && s[3] <= '9') && //
!s[4])) { !s[4])) {
return _PATH_DOS | _PATH_DEV; return _kPathDos | _kPathDev;
} }
switch (s[1]) { switch (s[1]) {
case ':': case ':':
switch (s[2]) { switch (s[2]) {
case 0: // c: case 0: // c:
default: // c:wut⋯ default: // c:wut⋯
return _PATH_DOS; return _kPathDos;
case '/': // c:/⋯ case '/': // c:/⋯
case '\\': // c:\⋯ case '\\': // c:\⋯
return _PATH_ABS | _PATH_DOS; return _kPathAbs | _kPathDos;
} }
default: default:
return 0; return 0;
@ -113,37 +113,37 @@ int _classifypath(const char *s) {
if (SupportsWindows()) { if (SupportsWindows()) {
if (s[1] == '?' && s[2] == '?') { if (s[1] == '?' && s[2] == '?') {
if (!s[3]) { if (!s[3]) {
return _PATH_ABS | _PATH_NT | _PATH_ROOT; // \??\⋯ return _kPathAbs | _kPathNt | _kPathRoot; // \??\⋯
} else if (s[3] == '\\') { } else if (s[3] == '\\') {
return _PATH_ABS | _PATH_NT; // \??\⋯ return _kPathAbs | _kPathNt; // \??\⋯
} }
} }
} }
// fallthrough // fallthrough
case '/': case '/':
if (!SupportsWindows()) { if (!SupportsWindows()) {
return _PATH_ABS; return _kPathAbs;
} }
switch (s[1]) { switch (s[1]) {
case 0: // / case 0: // /
default: // /⋯ default: // /⋯
return _PATH_ABS; return _kPathAbs;
case '/': case '/':
case '\\': case '\\':
switch (s[2]) { switch (s[2]) {
case 0: // // case 0: // //
default: // //⋯ default: // //⋯
return _PATH_ABS | _PATH_WIN; return _kPathAbs | _kPathWin;
case '.': case '.':
case '?': case '?':
switch (s[3]) { switch (s[3]) {
case 0: // //? or //. case 0: // //? or //.
return _PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT; return _kPathAbs | _kPathWin | _kPathDev | _kPathRoot;
default: // //?⋯ or //.⋯ default: // //?⋯ or //.⋯
return _PATH_ABS | _PATH_WIN; return _kPathAbs | _kPathWin;
case '/': case '/':
case '\\': // //?/⋯ or //./⋯ 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) { 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_ #ifndef COSMOPOLITAN_LIBC_STR_PATH_H_
#define COSMOPOLITAN_LIBC_STR_PATH_H_ #define COSMOPOLITAN_LIBC_STR_PATH_H_
#define _PATH_ABS 1 #define _kPathAbs 1
#define _PATH_DEV 2 #define _kPathDev 2
#define _PATH_ROOT 4 #define _kPathRoot 4
#define _PATH_DOS 8 #define _kPathDos 8
#define _PATH_WIN 16 #define _kPathWin 16
#define _PATH_NT 32 #define _kPathNt 32
#if !(__ASSEMBLER__ + __LINKER__ + 0) #if !(__ASSEMBLER__ + __LINKER__ + 0)
COSMOPOLITAN_C_START_ 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; if (!SupportsWindows()) return;
EXPECT_EQ(0, _classifypath("")); EXPECT_EQ(0, _classifypath(""));
EXPECT_EQ(0, _classifypath("xyz")); EXPECT_EQ(0, _classifypath("xyz"));
EXPECT_EQ(_PATH_DOS | _PATH_DEV, _classifypath("CON")); EXPECT_EQ(_kPathDos | _kPathDev, _classifypath("CON"));
EXPECT_EQ(_PATH_DOS | _PATH_DEV, _classifypath("NUL")); EXPECT_EQ(_kPathDos | _kPathDev, _classifypath("NUL"));
EXPECT_EQ(0, _classifypath(":")); EXPECT_EQ(0, _classifypath(":"));
EXPECT_EQ(_PATH_DOS, _classifypath("::")); EXPECT_EQ(_kPathDos, _classifypath("::"));
EXPECT_EQ(_PATH_DOS, _classifypath(":::")); EXPECT_EQ(_kPathDos, _classifypath(":::"));
EXPECT_EQ(_PATH_DOS, _classifypath("::::")); EXPECT_EQ(_kPathDos, _classifypath("::::"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("::\\")); EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("::\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\")); EXPECT_EQ(_kPathAbs, _classifypath("\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\:")); EXPECT_EQ(_kPathAbs, _classifypath("\\:"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\C:")); EXPECT_EQ(_kPathAbs, _classifypath("\\C:"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\C:\\")); EXPECT_EQ(_kPathAbs, _classifypath("\\C:\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("/")); EXPECT_EQ(_kPathAbs, _classifypath("/"));
EXPECT_EQ(_PATH_ABS, _classifypath("/:")); EXPECT_EQ(_kPathAbs, _classifypath("/:"));
EXPECT_EQ(_PATH_ABS, _classifypath("/C:")); EXPECT_EQ(_kPathAbs, _classifypath("/C:"));
EXPECT_EQ(_PATH_ABS, _classifypath("/C:/")); EXPECT_EQ(_kPathAbs, _classifypath("/C:/"));
EXPECT_EQ(0, _classifypath("C")); EXPECT_EQ(0, _classifypath("C"));
EXPECT_EQ(_PATH_DOS, _classifypath("C:")); EXPECT_EQ(_kPathDos, _classifypath("C:"));
EXPECT_EQ(_PATH_DOS, _classifypath("C:a")); EXPECT_EQ(_kPathDos, _classifypath("C:a"));
EXPECT_EQ(_PATH_DOS, _classifypath("C:a\\")); EXPECT_EQ(_kPathDos, _classifypath("C:a\\"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:\\")); EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:\\"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:/")); EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:/"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:\\a")); EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:\\a"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:/a")); EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:/a"));
EXPECT_EQ(_PATH_ABS | _PATH_DOS, _classifypath("C:\\\\")); EXPECT_EQ(_kPathAbs | _kPathDos, _classifypath("C:\\\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\\\")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\;")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\;"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\f\\b\\")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f\\b\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\f\\b")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f\\b"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\f\\")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\f")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\f"));
EXPECT_EQ(_PATH_ABS | _PATH_NT, _classifypath("\\??\\")); EXPECT_EQ(_kPathAbs | _kPathNt, _classifypath("\\??\\"));
EXPECT_EQ(_PATH_ABS | _PATH_NT, _classifypath("\\??\\UNC")); EXPECT_EQ(_kPathAbs | _kPathNt, _classifypath("\\??\\UNC"));
EXPECT_EQ(_PATH_ABS | _PATH_NT, _classifypath("\\??\\UNC\\")); EXPECT_EQ(_kPathAbs | _kPathNt, _classifypath("\\??\\UNC\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\?")); EXPECT_EQ(_kPathAbs, _classifypath("\\?"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\?\\")); EXPECT_EQ(_kPathAbs, _classifypath("\\?\\"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\?\\UNC")); EXPECT_EQ(_kPathAbs, _classifypath("\\?\\UNC"));
EXPECT_EQ(_PATH_ABS, _classifypath("\\?\\UNC\\")); EXPECT_EQ(_kPathAbs, _classifypath("\\?\\UNC\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("\\\\?\\UNC\\")); EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("\\\\?\\UNC\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT, EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\\\?")); _classifypath("\\\\?"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\??")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\??"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\??\\")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\??\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\\\??\\C:\\")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\\\??\\C:\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT, EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\\\.")); _classifypath("\\\\."));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("\\\\.\\")); EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("\\\\.\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("\\\\.\\C:\\")); EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("\\\\.\\C:\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("\\/")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("\\/"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("/\\")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("/\\"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("//")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("//"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("///")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("///"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("//;")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("//;"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT, EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("//?")); _classifypath("//?"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT, EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("/\\?")); _classifypath("/\\?"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT, EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\/?")); _classifypath("\\/?"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN, _classifypath("//??")); EXPECT_EQ(_kPathAbs | _kPathWin, _classifypath("//??"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT, EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("//.")); _classifypath("//."));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT, EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("\\/.")); _classifypath("\\/."));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV | _PATH_ROOT, EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev | _kPathRoot,
_classifypath("/\\.")); _classifypath("/\\."));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("//./")); EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("//./"));
EXPECT_EQ(_PATH_ABS | _PATH_WIN | _PATH_DEV, _classifypath("//./C:/")); EXPECT_EQ(_kPathAbs | _kPathWin | _kPathDev, _classifypath("//./C:/"));
} }