mirrors/phobos
1
0
Fork 0
mirror of https://github.com/dlang/phobos.git synced 2025-05-03 16:40:48 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

phobos 0.79

Browse source
This commit is contained in:
Brad Roberts 2007-09-10 03:46:34 +00:00
parent 224c570c1b
commit 50a73fee64
6 changed files with 644 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

387
internal/aApply.d Normal file
View file

@ -0,0 +1,387 @@
//_ aApply.d
// Copyright (c) 2004 by Digital Mars
// Written by Walter Bright
/* This code handles decoding UTF strings for foreach loops.
* There are 6 combinations of conversions between char, wchar,
* and dchar, and 2 of each of those.
*/
import std.utf;
//debug=apply;
/**********************************************
* 'apply' for associative arrays - to support foreach
*/
// dg is D, but _aApplycd() is C
extern (D) typedef int delegate(void *) dg_t;
extern (C) int _aApplycd1(char[] aa, dg_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplycd1(), len = %d\n", len);
for (i = 0; i < len; )
{ dchar d;
d = aa[i];
if (d & 0x80)
d = std.utf.decode(aa, i);
else
i++;
result = dg((void *)&d);
if (result)
break;
}
return result;
}
extern (C) int _aApplywd1(wchar[] aa, dg_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplywd1(), len = %d\n", len);
for (i = 0; i < len; )
{ dchar d;
d = aa[i];
if (d & ~0x7F)
d = std.utf.decode(aa, i);
else
i++;
result = dg((void *)&d);
if (result)
break;
}
return result;
}
extern (C) int _aApplycw1(char[] aa, dg_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplycw1(), len = %d\n", len);
for (i = 0; i < len; )
{ dchar d;
wchar w;
w = aa[i];
if (w & 0x80)
{ d = std.utf.decode(aa, i);
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = (((d - 0x10000) >> 10) & 0x3FF) + 0xD800;
result = dg((void *)&w);
if (result)
break;
w = ((d - 0x10000) & 0x3FF) + 0xDC00;
}
}
else
i++;
result = dg((void *)&w);
if (result)
break;
}
return result;
}
extern (C) int _aApplywc1(wchar[] aa, dg_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplywc1(), len = %d\n", len);
for (i = 0; i < len; )
{ dchar d;
wchar w;
char c;
w = aa[i];
if (w & ~0x7F)
{
char[4] buf;
char[] b;
d = std.utf.decode(aa, i);
b = std.utf.toUTF8(buf, d);
foreach (char c; b)
{
result = dg((void *)&c);
if (result)
return result;
}
continue;
}
else
{ c = cast(char)w;
i++;
}
result = dg((void *)&c);
if (result)
break;
}
return result;
}
extern (C) int _aApplydc1(dchar[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplydc1(), len = %d\n", aa.length);
foreach (dchar d; aa)
{
char c;
if (d & ~0x7F)
{
char[4] buf;
char[] b;
b = std.utf.toUTF8(buf, d);
foreach (char c; b)
{
result = dg((void *)&c);
if (result)
return result;
}
continue;
}
else
{
c = cast(char)d;
}
result = dg((void *)&c);
if (result)
break;
}
return result;
}
extern (C) int _aApplydw1(dchar[] aa, dg_t dg)
{ int result;
debug(apply) printf("_aApplydw1(), len = %d\n", aa.length);
foreach (dchar d; aa)
{
wchar w;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = (((d - 0x10000) >> 10) & 0x3FF) + 0xD800;
result = dg((void *)&w);
if (result)
break;
w = ((d - 0x10000) & 0x3FF) + 0xDC00;
}
result = dg((void *)&w);
if (result)
break;
}
return result;
}
/****************************************************************************/
// dg is D, but _aApplycd2() is C
extern (D) typedef int delegate(void *, void *) dg2_t;
extern (C) int _aApplycd2(char[] aa, dg2_t dg)
{ int result;
size_t i;
size_t n;
size_t len = aa.length;
debug(apply) printf("_aApplycd2(), len = %d\n", len);
for (i = 0; i < len; i += n)
{ dchar d;
d = aa[i];
if (d & 0x80)
{
n = i;
d = std.utf.decode(aa, n);
n -= i;
}
else
n = 1;
result = dg(&i, (void *)&d);
if (result)
break;
}
return result;
}
extern (C) int _aApplywd2(wchar[] aa, dg2_t dg)
{ int result;
size_t i;
size_t n;
size_t len = aa.length;
debug(apply) printf("_aApplywd2(), len = %d\n", len);
for (i = 0; i < len; i += n)
{ dchar d;
d = aa[i];
if (d & ~0x7F)
{
n = i;
d = std.utf.decode(aa, n);
n -= i;
}
else
n = 1;
result = dg(&i, (void *)&d);
if (result)
break;
}
return result;
}
extern (C) int _aApplycw2(char[] aa, dg2_t dg)
{ int result;
size_t i;
size_t n;
size_t len = aa.length;
debug(apply) printf("_aApplycw2(), len = %d\n", len);
for (i = 0; i < len; i += n)
{ dchar d;
wchar w;
w = aa[i];
if (w & 0x80)
{ n = i;
d = std.utf.decode(aa, n);
n -= i;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = (((d - 0x10000) >> 10) & 0x3FF) + 0xD800;
result = dg(&i, (void *)&w);
if (result)
break;
w = ((d - 0x10000) & 0x3FF) + 0xDC00;
}
}
else
n = 1;
result = dg(&i, (void *)&w);
if (result)
break;
}
return result;
}
extern (C) int _aApplywc2(wchar[] aa, dg2_t dg)
{ int result;
size_t i;
size_t n;
size_t len = aa.length;
debug(apply) printf("_aApplywc2(), len = %d\n", len);
for (i = 0; i < len; i += n)
{ dchar d;
wchar w;
char c;
w = aa[i];
if (w & ~0x7F)
{
char[4] buf;
char[] b;
n = i;
d = std.utf.decode(aa, n);
n -= i;
b = std.utf.toUTF8(buf, d);
foreach (char c; b)
{
result = dg(&i, (void *)&c);
if (result)
return result;
}
continue;
}
else
{ c = cast(char)w;
n = 1;
}
result = dg(&i, (void *)&c);
if (result)
break;
}
return result;
}
extern (C) int _aApplydc2(dchar[] aa, dg2_t dg)
{ int result;
size_t i;
size_t len = aa.length;
debug(apply) printf("_aApplydc2(), len = %d\n", len);
for (i = 0; i < len; i++)
{ dchar d;
char c;
d = aa[i];
if (d & ~0x7F)
{
char[4] buf;
char[] b;
b = std.utf.toUTF8(buf, d);
foreach (char c; b)
{
result = dg(&i, (void *)&c);
if (result)
return result;
}
continue;
}
else
{ c = cast(char)d;
}
result = dg(&i, (void *)&c);
if (result)
break;
}
return result;
}
extern (C) int _aApplydw2(dchar[] aa, dg2_t dg)
{ int result;
debug(apply) printf("_aApplydw2(), len = %d\n", aa.length);
foreach (size_t i, dchar d; aa)
{
wchar w;
if (d <= 0xFFFF)
w = cast(wchar) d;
else
{
w = (((d - 0x10000) >> 10) & 0x3FF) + 0xD800;
result = dg(&i, (void *)&w);
if (result)
break;
w = ((d - 0x10000) & 0x3FF) + 0xDC00;
}
result = dg(&i, (void *)&w);
if (result)
break;
}
return result;
}

14
linux.mak
View file

@ -47,8 +47,8 @@ unittest.o : unittest.d
OBJS= asserterror.o deh2.o switch.o complex.o gcstats.o \
critical.o object.o monitor.o arraycat.o invariant.o \
dmain2.o outofmemory.o aaA.o adi.o file.o \
compiler.o system.o moduleinit.o md5.o \
dmain2.o outofmemory.o aaA.o adi.o aApply.o file.o \
compiler.o system.o moduleinit.o md5.o base64.o \
cast.o path.o string.o memset.o math.o \
outbuffer.o ctype.o regexp.o random.o linux.o \
stream.o switcherr.o array.o gc.o \
@ -83,7 +83,7 @@ SRC= errno.c object.d unittest.d crc32.d gcstats.d
SRC_STD= std/zlib.d std/zip.d std/stdint.d std/conv.d std/utf.d std/uri.d \
std/gc.d std/math.d std/string.d std/path.d std/date.d \
std/ctype.d std/file.d std/compiler.d std/system.d std/moduleinit.d \
std/outbuffer.d std/math2.d std/thread.d std/md5.d \
std/outbuffer.d std/math2.d std/thread.d std/md5.d std/base64.d \
std/asserterror.d std/dateparse.d std/outofmemory.d \
std/intrinsic.d std/array.d std/switcherr.d std/syserror.d \
std/regexp.d std/random.d std/stream.d std/process.d std/recls.d
@ -116,7 +116,7 @@ SRC_INT= \
internal/arraycat.d internal/invariant.d internal/monitor.c \
internal/memset.d internal/arraycast.d internal/aaA.d internal/adi.d \
internal/dmain2.d internal/cast.d internal/qsort.d internal/deh2.d \
internal/cmath2.d internal/obj.d internal/mars.h
internal/cmath2.d internal/obj.d internal/mars.h internal/aApply.d
SRC_STD_WIN= std/windows/registry.d \
std/windows/iunknown.d
@ -261,6 +261,9 @@ gcstats.o : gcstats.d
aaA.o : internal/aaA.d
$(DMD) -c $(DFLAGS) internal/aaA.d
aApply.o : internal/aApply.d
$(DMD) -c $(DFLAGS) internal/aApply.d
adi.o : internal/adi.d
$(DMD) -c $(DFLAGS) internal/adi.d
@ -326,6 +329,9 @@ array.o : std/array.d
asserterror.o : std/asserterror.d
$(DMD) -c $(DFLAGS) std/asserterror.d
base64.o : std/base64.d
$(DMD) -c $(DFLAGS) std/base64.d
compiler.o : std/compiler.d
$(DMD) -c $(DFLAGS) std/compiler.d

232
std/base64.d Normal file
View file

@ -0,0 +1,232 @@
/* base64.d
* Modified from C. Miller's version, his copyright is below.
*/
/*
Copyright (C) 2004 Christopher E. Miller
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
module std.base64;
class Base64Exception: Exception
{
this(char[] msg)
{
super(msg);
}
}
class Base64CharException: Base64Exception
{
this(char[] msg)
{
super(msg);
}
}
const char[] array = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
uint encodeLength(uint slen) //returns the number of bytes needed to encode a string of this length
{
uint result;
result = slen / 3;
if(slen % 3)
result++;
return result * 4;
}
char[] encode(char[] str, char[] buf) //buf must be large enough
in
{
assert(buf.length >= encodeLength(str.length));
}
body
{
if(!str.length)
return buf[0 .. 0];
uint stri;
uint strmax = str.length / 3;
uint strleft = str.length % 3;
uint x;
char* sp, bp;
bp = &buf[0];
sp = &str[0];
for(stri = 0; stri != strmax; stri++)
{
x = (*sp++ << 16) | (*sp++ << 8) | (*sp++);
*bp++ = array[(x & 0b11111100_00000000_00000000) >> 18];
*bp++ = array[(x & 0b00000011_11110000_00000000) >> 12];
*bp++ = array[(x & 0b00000000_00001111_11000000) >> 6];
*bp++ = array[(x & 0b00000000_00000000_00111111)];
}
switch(strleft)
{
case 2:
x = (*sp++ << 16) | (*sp++ << 8);
*bp++ = array[(x & 0b11111100_00000000_00000000) >> 18];
*bp++ = array[(x & 0b00000011_11110000_00000000) >> 12];
*bp++ = array[(x & 0b00000000_00001111_11000000) >> 6];
*bp++ = '=';
break;
case 1:
x = *sp++ << 16;
*bp++ = array[(x & 0b11111100_00000000_00000000) >> 18];
*bp++ = array[(x & 0b00000011_11110000_00000000) >> 12];
*bp++ = '=';
*bp++ = '=';
break;
case 0:
break;
}
return buf[0 .. (bp - &buf[0])];
}
char[] encode(char[] str)
{
return encode(str, new char[encodeLength(str.length)]);
}
unittest
{
assert(encode("f") == "Zg==");
assert(encode("fo") == "Zm8=");
assert(encode("foo") == "Zm9v");
assert(encode("foos") == "Zm9vcw==");
assert(encode("all your base64 are belong to foo") == "YWxsIHlvdXIgYmFzZTY0IGFyZSBiZWxvbmcgdG8gZm9v");
}
uint decodeLength(uint elen) //returns the number of bytes needed to decode an encoded string of this length
{
return elen / 4 * 3;
}
char[] decode(char[] estr, char[] buf) //buf must be large enough to store decoded string
in
{
assert(buf.length + 2 >= decodeLength(estr.length)); //account for '=' padding
}
body
{
void badc(char ch)
{
throw new Base64CharException("Invalid base64 character '" ~ (&ch)[0 .. 1] ~ "'");
}
uint arrayIndex(char ch)
out(result)
{
assert(ch == array[result]);
}
body
{
if(ch >= 'A' && ch <= 'Z')
return ch - 'A';
if(ch >= 'a' && ch <= 'z')
return 'Z' - 'A' + 1 + ch - 'a';
if(ch >= '0' && ch <= '9')
return 'Z' - 'A' + 1 + 'z' - 'a' + 1 + ch - '0';
if(ch == '+')
return 'Z' - 'A' + 1 + 'z' - 'a' + 1 + '9' - '0' + 1;
if(ch == '/')
return 'Z' - 'A' + 1 + 'z' - 'a' + 1 + '9' - '0' + 1 + 1;
badc(ch);
}
if(!estr.length)
return buf[0 .. 0];
if(estr.length % 4)
throw new Base64Exception("Invalid encoded base64 string");
uint estri;
uint estrmax = estr.length / 4;
uint x;
char* sp, bp;
char ch;
sp = &estr[0];
bp = &buf[0];
for(estri = 0; estri != estrmax; estri++)
{
x = arrayIndex(*sp++) << 18 | arrayIndex(*sp++) << 12;
ch = *sp++;
if(ch == '=')
{
if(*sp++ != '=')
badc('=');
*bp++ = x >> 16;
break;
}
x |= arrayIndex(ch) << 6;
ch = *sp++;
if(ch == '=')
{
*bp++ = x >> 16;
*bp++ = (x >> 8) & 0xFF;
break;
}
x |= arrayIndex(ch);
*bp++ = x >> 16;
*bp++ = (x >> 8) & 0xFF;
*bp++ = x & 0xFF;
}
return buf[0 .. (bp - &buf[0])];
}
char[] decode(char[] estr)
{
return decode(estr, new char[decodeLength(estr.length)]);
}
unittest
{
assert(decode(encode("f")) == "f");
assert(decode(encode("fo")) == "fo");
assert(decode(encode("foo")) == "foo");
assert(decode(encode("foos")) == "foos");
assert(decode(encode("all your base64 are belong to foo")) == "all your base64 are belong to foo");
assert(decode(encode("testing some more")) == "testing some more");
assert(decode(encode("asdf jkl;")) == "asdf jkl;");
assert(decode(encode("base64 stuff")) == "base64 stuff");
assert(decode(encode("\1\2\3\4\5\6\7foo\7\6\5\4\3\2\1!")) == "\1\2\3\4\5\6\7foo\7\6\5\4\3\2\1!");
}

2
std/file.d
View file

@ -52,7 +52,7 @@ private int useWfuncs = 1;
static this()
{
// Win 95, 98, ME do not implement the W functions
useWfuncs = (GetVersion() >= 0x80000000);
useWfuncs = (GetVersion() < 0x80000000);
}
/********************************************

4
std/regexp.d
View file

@ -1,6 +1,6 @@
// Regular Expressions
// Copyright (c) 2000-2003 by Digital Mars
// Copyright (c) 2000-2004 by Digital Mars
// All Rights Reserved
// Written by Walter Bright
// www.digitalmars.com
@ -510,7 +510,7 @@ public tchar[][] exec()
public int test(tchar[] string)
{
return test(string, pmatch[0].rm_eo);
return test(string, 0 /*pmatch[0].rm_eo*/);
}
/************************************************

18
win32.mak
View file

@ -15,8 +15,8 @@
CP=cp
CFLAGS=-g -mn -6 -r
#DFLAGS=-O -release
DFLAGS=-unittest -g
DFLAGS=-O -release
#DFLAGS=-unittest -g
CC=sc
#DMD=\dmd\bin\dmd
@ -53,8 +53,8 @@ unittest.exe : unittest.d phobos.lib
OBJS= asserterror.obj deh.obj switch.obj complex.obj gcstats.obj \
critical.obj object.obj monitor.obj arraycat.obj invariant.obj \
dmain2.obj outofmemory.obj aaA.obj adi.obj file.obj \
compiler.obj system.obj moduleinit.obj md5.obj \
dmain2.obj outofmemory.obj aaA.obj adi.obj aApply.obj file.obj \
compiler.obj system.obj moduleinit.obj md5.obj base64.obj \
cast.obj syserror.obj path.obj string.obj memset.obj math.obj \
outbuffer.obj ctype.obj regexp.obj random.obj windows.obj \
stream.obj switcherr.obj com.obj array.obj gc.obj \
@ -78,7 +78,7 @@ SRC= errno.c object.d unittest.d crc32.d gcstats.d
SRC_STD= std\zlib.d std\zip.d std\stdint.d std\conv.d std\utf.d std\uri.d \
std\gc.d std\math.d std\string.d std\path.d std\date.d \
std\ctype.d std\file.d std\compiler.d std\system.d std\moduleinit.d \
std\outbuffer.d std\math2.d std\thread.d std\md5.d \
std\outbuffer.d std\math2.d std\thread.d std\md5.d std\base64.d \
std\asserterror.d std\dateparse.d std\outofmemory.d \
std\intrinsic.d std\array.d std\switcherr.d std\syserror.d \
std\regexp.d std\random.d std\stream.d std\process.d std\recls.d
@ -111,7 +111,7 @@ SRC_INT= \
internal\arraycat.d internal\invariant.d internal\monitor.c \
internal\memset.d internal\arraycast.d internal\aaA.d internal\adi.d \
internal\dmain2.d internal\cast.d internal\qsort.d internal\deh2.d \
internal\cmath2.d internal\obj.d internal\mars.h
internal\cmath2.d internal\obj.d internal\mars.h internal\aApply.d
SRC_STD_WIN= std\windows\registry.d \
std\windows\iunknown.d
@ -245,6 +245,9 @@ phobos.lib : $(OBJS) minit.obj internal\gc\dmgc.lib etc\c\zlib\zlib.lib \
aaA.obj : internal\aaA.d
$(DMD) -c $(DFLAGS) internal\aaA.d
aApply.obj : internal\aApply.d
$(DMD) -c $(DFLAGS) internal\aApply.d
adi.obj : internal\adi.d
$(DMD) -c $(DFLAGS) internal\adi.d
@ -298,6 +301,9 @@ array.obj : std\array.d
asserterror.obj : std\asserterror.d
$(DMD) -c $(DFLAGS) std\asserterror.d
base64.obj : std\base64.d
$(DMD) -c $(DFLAGS) -inline std\base64.d
compiler.obj : std\compiler.d
$(DMD) -c $(DFLAGS) std\compiler.d