Note: This website is archived. For up-to-date information about D projects and development, please visit wiki.dlang.org.

Changeset 853

Show
Ignore:
Timestamp:
10/11/08 00:56:40 (16 years ago)
Author:
sean
Message:

This commit includes all the changes necessary for Phobos to run against druntime. Here is a sucinct list of the changes made:

  • Removed gcstats. Garbage collector statistics will be avaialable in durintime's 'memory' module.
  • Removed object.d. This module is replaced by the object.d provided by druntime.
  • Removed std.array. To trap an array bounds error, import 'exception' from druntime and catch ArrayBoundsException?.
  • Removed std.asserterror. To trap an asertion failure, import 'exception' from druntime and catch AssertException?.
  • Removed std.gc. To interact with the garbage collector, import 'memory' from druntime.
  • Removed std.hiddenfunc. No equivalent exception is currently exposed by druntime, but if one is exposed it will be called HiddenFuncException? and be declared in 'exception'.
  • Removed std.moduleinit. druntime declares ModuleInfo? in object.d, so it is implicitly availble without importing.
  • Removed std.outofmemory. To trap an out of memory error, import 'exception' from druntime and catch OutOfMemoryException?.
  • Removed std.switcherr. To trap a switch error, import 'exception' from druntime and catch SwitchException?.
  • Removed std.synchro. This functionality will exist within druintime.
  • Removed std.thread. A Thread class is available within druntime's 'thread' module. An interface comparison will be provided separately.
  • Removed std.typeinfo. The classes defined in this package are for runtime use and should not be visible to the user.

The prior version of Phobos has been archived in tags/phobos-2.019 if needed.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/phobos/etc/gamma.d

    r697 r853  
    407407    q = ( x - 0.5L ) * log(x) - x + LOGSQRT2PI; 
    408408    if (x > 1.0e10L) return q; 
    409409    real p = 1.0L/(x*x); 
    410410    q += poly( p, logGammaStirlingCoeffs ) / x; 
    411411    return q ; 
    412412} 
    413413 
    414414unittest 
    415415{ 
    416416    // return true if x is +0.0 
    417     bit isPosZero(real x) 
     417    bool isPosZero(real x) 
    418418    { 
    419419       return (x==0) && (signbit(x)==0); 
    420420    } 
    421421 
    422422    assert(isnan(lgamma(real.nan))); 
    423423    assert(lgamma(real.infinity) == real.infinity); 
    424424    assert(lgamma(-1.0) == real.infinity); 
    425425    assert(lgamma(0.0) == real.infinity); 
    426426    assert(isPosZero(lgamma(1.0L))); 
    427427    assert(isPosZero(lgamma(2.0L))); 
  • trunk/phobos/linux.mak

    r829 r853  
    8383    DFLAGS := $(DFLAGS) -O -release 
    8484    OBJDIR = none 
    8585endif 
    8686 
    8787ifndef OBJDIR 
    8888    $(error Cannot make $(MAKECMDGOALS). Please make either all,    \ 
    8989debug, release, unittest/debug, unittest/release, clean, or html) 
    9090endif 
    9191 
    9292ifneq (none,$(OBJDIR)) 
    93       DUMMY := $(shell mkdir --parents $(OBJDIR) $(OBJDIR)/etc/c/zlib   \ 
    94             $(OBJDIR)/internal $(OBJDIR)/internal/gc) 
     93      DUMMY := $(shell mkdir --parents $(OBJDIR) $(OBJDIR)/etc/c/zlib) 
    9594endif 
    9695 
    9796LIB=$(OBJDIR)/libphobos2.$(LIBEXT) 
    9897DOC_OUTPUT_DIR=../web/phobos 
    9998 
    10099.SUFFIXES: .d 
    101100$(OBJDIR)/%.$(OBJEXT) : %.c 
    102101    $(CC) -c $(CFLAGS) -o$@ $< 
    103102 
    104103$(OBJDIR)/%.$(OBJEXT) : %.cpp 
     
    131130endif 
    132131ifeq (release,$(MAKECMDGOALS)) 
    133132    ln -sf `pwd`/$(OBJDIR)/libphobos2.$(LIBEXT) ../../lib 
    134133endif 
    135134 
    136135$(OBJDIR)/unittest.$(OBJEXT) : unittest.d all_std_modules_generated.d 
    137136 
    138137all_std_modules_generated.d : $(MAKEFILE_LIST) 
    139138    for m in $(STD_MODULES); do echo public import std.$$m\;; done > $@ 
    140139 
    141 INTERNAL_MODULES = aApply aApplyR aaA adi alloca arraycast arraycat \ 
    142     cast cmath2 deh2 dmain2 invariant llmath memset monitor obj     \ 
    143     object qsort switch trace arrayassign \ 
    144     arrayfloat arraydouble arrayreal \ 
    145     arraybyte arrayshort arrayint 
    146 INTERNAL_CMODULES = complex critical 
    147 INTERNAL_CMODULES_NOTBUILT = deh 
    148 INTERNAL_EXTRAFILES = internal/mars.h internal/minit.asm 
    149  
    150 INTERNAL_GC_MODULES = gc gcold gcx gcbits gclinux 
    151 INTERNAL_GC_EXTRAFILES = \ 
    152     internal/gc/gcstub.d \ 
    153     internal/gc/win32.d \ 
    154     internal/gc/testgc.d \ 
    155     internal/gc/win32.mak \ 
    156     internal/gc/linux.mak 
    157  
    158 STD_MODULES = algorithm array asserterror atomics base64 bigint bind bitarray   \ 
     140STD_MODULES = algorithm atomics base64 bigint bind bitarray         \ 
    159141        bitmanip boxer compiler complex contracts conv cover cpuid  \ 
    160142        cstream ctype date dateparse demangle encoding file format  \ 
    161         functional  getopt hiddenfunc intrinsic iterator loader math   
    162         md5 metastrings mmfile moduleinit numeric openrj outbuffer
    163         outofmemory path perf process random regexp signals socket
    164         socketstream stdint stdio stream string switcherr syserror
    165         synchro system thread traits typecons typetuple uni uri utf     \ 
     143        functional  getopt intrinsic iterator loader math         
     144        md5 metastrings mmfile numeric openrj outbuffer                   
     145        path perf process random regexp signals socket                 
     146        socketstream stdint stdio stream string syserror           
     147        system traits typecons typetuple uni uri utf                    \ 
    166148        variant xml zip zlib 
    167 STD_MODULES_NOTBUILT = stdarg gc 
     149STD_MODULES_NOTBUILT = stdarg 
    168150 
    169151STD_C_MODULES = stdarg stdio 
    170152STD_C_MODULES_NOTBUILT = fenv math process stddef stdlib string time locale \ 
    171153    wcharh 
    172154 
    173155STD_C_LINUX_MODULES = linux socket 
    174156STD_C_LINUX_MODULES_NOTBUILT = linuxextern pthread termios 
    175157 
    176158STD_C_WINDOWS_MODULES_NOTBUILT = windows com winsock stat 
    177159 
     
    200182    win32.mak zconf.h zconf.in.h zlib.3 zlib.h zutil.c zutil.h 
    201183SRC_ZLIB := $(addprefix etc/c/zlib/,$(SRC_ZLIB)) 
    202184 
    203185SRC_DOCUMENTABLES = phobos.d $(addprefix std/, $(addsuffix .d,      \ 
    204186    $(STD_MODULES) $(STD_MODULES_NOTBUILT))) $(addprefix std/c/,    \ 
    205187    $(addsuffix .d, $(STD_C_MODULES) $(STD_C_MODULES_NOTBUILT)))    \ 
    206188    $(addprefix std/c/linux/,$(addsuffix .d,            \ 
    207189    $(STD_C_LINUX_MODULES) $(STD_C_LINUX_MODULES_NOTBUILT))) 
    208190 
    209191SRC_RELEASEZIP = linux.mak win32.mak phoboslicense.txt $(SRC)       \ 
    210     $(SRC_ZLIB) $(INTERNAL_EXTRAFILES) $(INTERNAL_GC_EXTRAFILES)    \ 
    211     $(addprefix internal/,$(addsuffix .c,               \ 
    212     $(INTERNAL_CMODULES_NOTBUILT))) $(addprefix internal/,      \ 
    213     $(addsuffix .c, $(INTERNAL_CMODULES))) $(addprefix internal/,   \ 
    214     $(addsuffix .d, $(INTERNAL_MODULES))) $(addprefix       \ 
    215     internal/gc/, $(addsuffix .d, $(INTERNAL_GC_MODULES)))      \ 
    216     $(addprefix std/, $(addsuffix .d, $(STD_MODULES)        \ 
     192    $(SRC_ZLIB) $(addprefix std/, $(addsuffix .d, $(STD_MODULES)    \ 
    217193    $(STD_MODULES_NOTBUILT))) $(addprefix std/c/, $(addsuffix .d,   \ 
    218194    $(STD_C_MODULES) $(STD_C_MODULES_NOTBUILT))) $(addprefix    \ 
    219195    std/c/linux/, $(addsuffix .d, $(STD_C_LINUX_MODULES)        \ 
    220196    $(STD_C_LINUX_MODULES_NOTBUILT))) $(addprefix std/c/windows/,   \ 
    221197    $(addsuffix .d, $(STD_C_WINDOWS_MODULES_NOTBUILT)))     \ 
    222     $(addprefix std/typeinfo/, $(addsuffix .d,          \ 
    223     $(TYPEINFO_MODULES))) $(addprefix std/windows/, $(addsuffix \ 
     198    $(addprefix std/windows/, $(addsuffix                           \ 
    224199    .d, $(STD_WINDOWS_MODULES_NOTBUILT))) $(addprefix etc/,     \ 
    225200    $(addsuffix .d, $(ETC_MODULES_NOTBUILT))) $(addprefix etc/c/,   \ 
    226201    $(addsuffix .d, $(ETC_C_MODULES))) 
    227202 
    228 OBJS = errno $(addprefix internal/, $(INTERNAL_MODULES)     \ 
    229     $(INTERNAL_CMODULES)) $(addprefix internal/gc/,     \ 
    230     $(INTERNAL_GC_MODULES)) $(addprefix etc/c/zlib/,    \ 
    231     $(ZLIB_CMODULES)) 
     203OBJS = errno 
    232204 
    233205OBJS := $(addsuffix .$(OBJEXT),$(addprefix $(OBJDIR)/,$(OBJS))) 
    234206 
    235 SRC2LIB = crc32 gcstats $(addprefix std/, $(STD_MODULES)) $(addprefix   \ 
    236 std/typeinfo/, $(TYPEINFO_MODULES)) $(addprefix std/c/,         \ 
     207SRC2LIB = crc32 $(addprefix std/, $(STD_MODULES)) $(addprefix std/c/,   \ 
    237208$(STD_C_MODULES)) $(addprefix std/c/linux/, $(STD_C_LINUX_MODULES)) \ 
    238209$(addprefix etc/c/, $(ETC_C_MODULES)) 
    239210 
    240211SRC2LIB := $(addsuffix .d,$(SRC2LIB)) 
    241212 
    242213$(LIB) : $(SRC2LIB) $(OBJS) $(MAKEFILE_LIST) 
    243214    @echo $(DMD) $(DFLAGS) -lib -of$@ "[...tons of files...]" 
    244215    @$(DMD) $(DFLAGS) -lib -of$@ $(SRC2LIB) $(OBJS) 
    245216 
    246217########################################################### 
     
    267238zip : $(SRC_RELEASEZIP) 
    268239    $(RM) phobos.zip 
    269240    zip phobos $(SRC_RELEASEZIP) 
    270241 
    271242clean: 
    272243    $(RM) libphobos2.$(LIBEXT) all_std_modules_generated.d 
    273244    $(RM) -r $(DOC_OUTPUT_DIR) obj 
    274245 
    275246 
    276247HEADERDIR = include 
    277 HEADERS = object.d \ 
    278     $(addprefix std/,$(addsuffix .d,$(STD_MODULES))) \ 
     248HEADERS = $(addprefix std/,$(addsuffix .d,$(STD_MODULES))) \ 
    279249    $(addprefix std/,$(addsuffix .d,$(STD_MODULES_NOTBUILT))) \ 
    280250    $(addprefix std/c/,$(addsuffix .d,$(STD_C_MODULES))) \ 
    281251    $(addprefix std/c/,$(addsuffix .d,$(STD_C_MODULES_NOTBUILT))) \ 
    282252    $(addprefix std/c/linux/,$(addsuffix .d,$(STD_C_LINUX_MODULES))) \ 
    283253    $(addprefix std/c/linux/,$(addsuffix .d,$(STD_C_LINUX_MODULES_NOTBUILT)))  
    284254 
    285255HEADERS := $(addprefix $(HEADERDIR)/,$(HEADERS)) 
    286256 
    287257$(HEADERDIR)/%.d : %.d 
    288258    $(DMD) -I$(dir $<) -o- -c -H $(DFLAGS) -Hf$@ $< 
  • trunk/phobos/std/c/stdio.d

    r689 r853  
    188188int  fflush(FILE *);    /// 
    189189int  fclose(FILE *);    /// 
    190190int  fputs(in char *,FILE *);   /// 
    191191char *   gets(char *);  /// 
    192192int  fputc(int,FILE *); /// 
    193193int  _fputchar(int);    /// 
    194194int  puts(in char *);   /// 
    195195int  ungetc(int,FILE *);    /// 
    196196size_t   fread(void *,size_t,size_t,FILE *);    /// 
    197197size_t   fwrite(in void *,size_t,size_t,FILE *);    /// 
    198 //int  printf(in char *,...); /// 
     198int    printf(in char *,...); /// 
    199199int  fprintf(FILE *,in char *,...); /// 
    200200int  vfprintf(FILE *,in char *,va_list);    /// 
    201201int  vprintf(in char *,va_list);    /// 
    202202int  sprintf(char *,in char *,...); /// 
    203203int  vsprintf(char *,in char *,va_list);    /// 
    204204int  scanf(in char *,...);  /// 
    205205int  fscanf(FILE *,in char *,...);  /// 
    206206int  sscanf(char *,in char *,...);  /// 
    207207void     setbuf(FILE *,char *); /// 
    208208int  setvbuf(FILE *,char *,int,size_t); /// 
  • trunk/phobos/std/encoding.d

    r693 r853  
    20662066     * { 
    20672067     *     static this() 
    20682068     *     { 
    20692069     *         EncodingScheme.register("path.to.Amiga1251"); 
    20702070     *     } 
    20712071     * } 
    20722072     * ---------------------------------------------- 
    20732073     */ 
    20742074    static void register(string className) 
    20752075    { 
    2076         auto scheme = cast(EncodingScheme)Object.factory(className); 
     2076        auto scheme = cast(EncodingScheme)ClassInfo.find(className).create(); 
    20772077        if (scheme is null) 
    20782078            throw new EncodingException("Unable to create class "~className); 
    20792079        foreach(encodingName;scheme.names()) 
    20802080        { 
    20812081            supported[tolower(encodingName)] = className; 
    20822082        } 
    20832083    } 
    20842084 
    20852085    /** 
    20862086     * Obtains a subclass of EncodingScheme which is capable of encoding 
     
    20932093     * --------------------------------------------------- 
    20942094     * auto scheme = EncodingScheme.create("Amiga-1251"); 
    20952095     * --------------------------------------------------- 
    20962096     */ 
    20972097    static EncodingScheme create(string encodingName) 
    20982098    { 
    20992099        auto p = std.string.tolower(encodingName) in supported; 
    21002100        if (p is null) 
    21012101            throw new EncodingException("Unrecognized Encoding: "~encodingName); 
    21022102        string className = *p; 
    2103         auto scheme = cast(EncodingScheme)Object.factory(className); 
     2103        auto scheme = cast(EncodingScheme)ClassInfo.find(className).create(); 
    21042104        if (scheme is null) throw new EncodingException("Unable to create class "~className); 
    21052105        return scheme; 
    21062106    } 
    21072107 
    21082108    const 
    21092109    { 
    21102110        /** 
    21112111         * Returns the standard name of the encoding scheme 
    21122112         */ 
    21132113        abstract override string toString(); 
  • trunk/phobos/std/file.d

    r840 r853  
    3030 *     in a product, an acknowledgment in the product documentation would be 
    3131 *     appreciated but is not required. 
    3232 *  o  Altered source versions must be plainly marked as such, and must not 
    3333 *     be misrepresented as being the original software. 
    3434 *  o  This notice may not be removed or altered from any source 
    3535 *     distribution. 
    3636 */ 
    3737 
    3838module std.file; 
    3939 
     40private import memory; 
    4041private import std.c.stdio; 
    4142private import std.c.stdlib; 
    4243private import std.path; 
    4344private import std.string; 
    4445private import std.regexp; 
    45 private import std.gc; 
    4646private import std.c.string; 
    4747private import std.traits; 
    4848private import std.conv; 
    4949private import std.contracts; 
    5050private import std.utf; 
    5151version (unittest) { 
    5252    private import std.stdio; // for testing only 
    5353} 
    5454 
    5555/* =========================== Win32 ======================= */ 
     
    124124        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,cast(HANDLE)null); 
    125125    } 
    126126 
    127127    if (h == INVALID_HANDLE_VALUE) 
    128128    goto err1; 
    129129 
    130130    auto size = GetFileSize(h, null); 
    131131    if (size == INVALID_FILE_SIZE) 
    132132    goto err2; 
    133133 
    134     auto buf = std.gc.malloc(size); 
    135     if (buf) 
    136     std.gc.hasNoPointers(buf.ptr); 
     134    auto buf = GC.malloc(size, GC.BlkAttr.NO_SCAN)[0 .. size]; 
    137135 
    138136    if (ReadFile(h,buf.ptr,size,&numread,null) != 1) 
    139137    goto err2; 
    140138 
    141139    if (numread != size) 
    142140    goto err2; 
    143141 
    144142    if (!CloseHandle(h)) 
    145143    goto err; 
    146144 
     
    947945void[] read(string name) 
    948946{ 
    949947    invariant fd = std.c.linux.linux.open(toStringz(name), O_RDONLY); 
    950948    cenforce(fd != -1, name); 
    951949    scope(exit) std.c.linux.linux.close(fd); 
    952950 
    953951    struct_stat statbuf = void; 
    954952    cenforce(std.c.linux.linux.fstat(fd, &statbuf) == 0, name); 
    955953    invariant size = statbuf.st_size; 
    956954    if (!size) return null; 
    957     auto buf = std.gc.malloc(size); 
     955    auto buf = GC.malloc(size, GC.BlkAttr.NO_SCAN); 
    958956    enforce(buf, "Out of memory"); 
    959957    scope(failure) delete buf; 
    960     std.gc.hasNoPointers(buf.ptr); 
    961958 
    962959    cenforce(std.c.linux.linux.read(fd, buf.ptr, size) == size, name); 
    963960 
    964961    return buf[0 .. size]; 
    965962} 
    966963 
    967964/******************************************** 
    968965 * Read and validates (using $(XREF utf, validate)) a text file. $(D 
    969966 * S) can be a type of array of characters of any width and constancy. 
    970967 * 
  • trunk/phobos/std/md5.d

    r689 r853  
    8181These notices must be retained in any copies of any part of this 
    8282documentation and/or software. 
    8383 */ 
    8484 
    8585module std.md5; 
    8686 
    8787//debug=md5;        // uncomment to turn on debugging printf's 
    8888 
    8989import std.string; 
    9090import std.contracts; 
     91import std.c.stdio : printf; 
    9192 
    9293/*************************************** 
    9394 * Computes MD5 digest of several arrays of data. 
    9495 */ 
    9596 
    9697void sum(ubyte[16] digest, in void[][] data...) 
    9798{ 
    9899    MD5_CTX context; 
    99100    context.start(); 
    100101    foreach (datum; data) 
  • trunk/phobos/std/outbuffer.d

    r689 r853  
    1111 *  www.digitalmars.com 
    1212 */ 
    1313 
    1414 
    1515// Written by Walter Bright 
    1616 
    1717module std.outbuffer; 
    1818 
    1919private 
    2020{ 
     21    import memory; 
    2122    import std.string; 
    22     import std.gc; 
    2323    import std.c.stdio; 
    2424    import std.c.stdlib; 
    2525    import std.c.stdarg; 
    2626} 
    2727 
    2828/********************************************* 
    2929 * OutBuffer provides a way to build up an array of bytes out 
    3030 * of raw data. It is useful for things like preparing an 
    3131 * array of bytes to write out to a file. 
    3232 * OutBuffer's byte order is the format native to the computer. 
     
    7373    out 
    7474    { 
    7575        assert(offset + nbytes <= data.length); 
    7676    } 
    7777    body 
    7878    { 
    7979        //c.stdio.printf("OutBuffer.reserve: length = %d, offset = %d, nbytes = %d\n", data.length, offset, nbytes); 
    8080        if (data.length < offset + nbytes) 
    8181        { 
    8282        data.length = (offset + nbytes) * 2; 
    83         std.gc.hasPointers(data.ptr); 
     83        GC.clrAttr(data.ptr, GC.BlkAttr.NO_SCAN); 
    8484        } 
    8585    } 
    8686 
    8787    /************************************* 
    8888     * Append data to the internal buffer. 
    8989     */ 
    9090 
    9191    void write(const(ubyte)[] bytes) 
    9292    { 
    9393        reserve(bytes.length); 
  • trunk/phobos/std/path.d

    r849 r853  
    2727//private import std.stdio; 
    2828 
    2929private import std.string; 
    3030private import std.file; 
    3131private import std.contracts; 
    3232 
    3333version(linux) 
    3434{ 
    3535    private import std.c.stdlib; 
    3636    private import std.c.linux.linux; 
    37     private import std.outofmemory
     37    private import exception : onOutOfMemoryError
    3838} 
    3939 
    4040version(Windows) 
    4141{ 
    4242 
    4343    /** String used to separate directory names in a path. Under 
    4444     *  Windows this is a backslash, under Linux a slash. */ 
    4545    invariant char[1] sep = "\\"; 
    4646    /** Alternate version of sep[] used in Windows (a slash). Under 
    4747     *  Linux this is empty. */ 
     
    12501250    path = combineCPathWithDPath(result.pw_dir, path, last_char); 
    12511251 
    12521252Lnotfound: 
    12531253    std.c.stdlib.free(extra_memory); 
    12541254    return path; 
    12551255 
    12561256Lerror: 
    12571257    // Errors are going to be caused by running out of memory 
    12581258    if (extra_memory) 
    12591259    std.c.stdlib.free(extra_memory); 
    1260     _d_OutOfMemory(); 
     1260    onOutOfMemoryError(); 
    12611261    return null; 
    12621262} 
    12631263 
    12641264} 
  • trunk/phobos/std/random.d

    r846 r853  
    459459auto n = rnd.next; 
    460460... 
    461461----    
    462462*/ 
    463463 
    464464uint unpredictableSeed() 
    465465{ 
    466466    static bool seeded; 
    467467    static MinstdRand0 rand; 
    468468    if (!seeded) { 
    469         rand.seed(getpid ^ getUTCtime); 
     469        rand.seed(getpid ^ cast(uint)getUTCtime); 
    470470        seeded = true; 
    471471    } 
    472472    return cast(uint) (getUTCtime ^ rand.next); 
    473473} 
    474474 
    475475unittest 
    476476{ 
    477477    // not much to test here 
    478478    auto a = unpredictableSeed; 
    479479    static assert(is(typeof(a) == uint)); 
  • trunk/phobos/std/signals.d

    r464 r853  
    5151 *  SIGNALS=signals 
    5252 * Copyright: 
    5353 *  Public Domain 
    5454 * Author: Walter Bright, Digital Mars, www.digitalmars.com 
    5555 */ 
    5656 
    5757module std.signals; 
    5858 
    5959import std.stdio; 
    6060import std.c.stdlib : calloc, realloc, free; 
    61 import std.outofmemory : _d_OutOfMemory
     61import exception : onOutOfMemoryError
    6262 
    6363// Special function for internal use only. 
    6464// Use of this is where the slot had better be a delegate 
    6565// to an object or an interface that is part of an object. 
    6666extern (C) Object _d_toObject(void* p); 
    6767 
     68// Used in place of Object.notifyRegister and Object.notifyUnRegister. 
     69alias void delegate(Object) DisposeEvt; 
     70extern (C) void  rt_attachDisposeEvent( Object obj, DisposeEvt evt ); 
     71extern (C) void  rt_detachDisposeEvent( Object obj, DisposeEvt evt ); 
    6872//debug=signal; 
    6973 
    7074/************************ 
    7175 * Mixin to create a signal within a class object. 
    7276 * 
    7377 * Different signals can be added to a class by naming the mixins. 
    7478 * 
    7579 * Example: 
    7680--- 
    7781import std.signals; 
     
    163167     * but use malloc() and friends instead 
    164168     */ 
    165169    auto len = slots.length; 
    166170    if (slots_idx == len) 
    167171    { 
    168172        if (slots.length == 0) 
    169173        { 
    170174        len = 4; 
    171175        auto p = std.signals.calloc(slot_t.sizeof, len); 
    172176        if (!p) 
    173             std.signals._d_OutOfMemory(); 
     177            onOutOfMemoryError(); 
    174178        slots = (cast(slot_t*)p)[0 .. len]; 
    175179        } 
    176180        else 
    177181        { 
    178182        len = len * 2 + 4; 
    179183        auto p = std.signals.realloc(slots.ptr, slot_t.sizeof * len); 
    180184        if (!p) 
    181             std.signals._d_OutOfMemory(); 
     185            onOutOfMemoryError(); 
    182186        slots = (cast(slot_t*)p)[0 .. len]; 
    183187        slots[slots_idx + 1 .. length] = null; 
    184188        } 
    185189    } 
    186190    slots[slots_idx++] = slot; 
    187191 
    188192     L1: 
    189193    Object o = _d_toObject(slot.ptr); 
    190     o.notifyRegister(&unhook); 
     194    rt_attachDisposeEvent(o, &unhook); 
    191195    } 
    192196 
    193197    /*** 
    194198     * Remove a slot from the list of slots to be called when emit() is called. 
    195199     */ 
    196200    void disconnect( slot_t slot) 
    197201    { 
    198202    debug (signal) writefln("Signal.disconnect(slot)"); 
    199203    for (size_t i = 0; i < slots_idx; ) 
    200204    { 
    201205        if (slots[i] == slot) 
    202206        {   slots_idx--; 
    203207        slots[i] = slots[slots_idx]; 
    204208        slots[slots_idx] = null;    // not strictly necessary 
    205209 
    206210        Object o = _d_toObject(slot.ptr); 
    207         o.notifyUnRegister(&unhook); 
     211        rt_detachDisposeEvent(o, &unhook); 
    208212        } 
    209213        else 
    210214        i++; 
    211215    } 
    212216    } 
    213217 
    214218    /* ** 
    215219     * Special function called when o is destroyed. 
    216220     * It causes any slots dependent on o to be removed from the list 
    217221     * of slots to be called by emit(). 
     
    240244     * When this object is destroyed, need to let every slot 
    241245     * know that this object is destroyed so they are not left 
    242246     * with dangling references to it. 
    243247     */ 
    244248    if (slots) 
    245249    { 
    246250        foreach (slot; slots[0 .. slots_idx]) 
    247251        { 
    248252        if (slot) 
    249253        {   Object o = _d_toObject(slot.ptr); 
    250             o.notifyUnRegister(&unhook); 
     254            rt_detachDisposeEvent(o, &unhook); 
    251255        } 
    252256        } 
    253257        std.signals.free(slots.ptr); 
    254258        slots = null; 
    255259    } 
    256260    } 
    257261 
    258262  private: 
    259263    slot_t[] slots;     // the slots to call from emit() 
    260264    size_t slots_idx;       // used length of slots[] 
  • trunk/phobos/std/socket.d

    r851 r853  
    3131 * Example: See /dmd/samples/d/listener.d. 
    3232 * Authors: Christopher E. Miller  
    3333 * Macros: 
    3434 *  WIKI=Phobos/StdSocket 
    3535 */ 
    3636 
    3737module std.socket; 
    3838 
    3939private import std.string, std.stdint, std.c.string, std.c.stdlib; 
    4040 
     41version(unittest) 
     42{ 
     43    private import std.c.stdio : printf; 
     44} 
     45 
    4146 
    4247version(linux) 
    4348{ 
    4449    version = BsdSockets; 
    4550} 
    4651 
    4752version(Win32) 
    4853{ 
    4954 
    5055    pragma (lib, "ws2_32.lib"); 
  • trunk/phobos/std/stdio.d

    r819 r853  
    1717Alexandrescu) 
    1818 *  
    1919 * Macros: 
    2020 *  WIKI=Phobos/StdStdio 
    2121 */ 
    2222 
    2323module std.stdio; 
    2424 
    2525public import std.c.stdio; 
    2626 
     27import memory; 
    2728import std.format; 
    2829import std.utf; 
    2930import std.string; 
    30 import std.gc; 
    3131import std.c.stdlib; 
    3232import std.c.string; 
    3333import std.c.stddef; 
    3434import std.conv; 
    3535import std.traits; 
    3636import std.contracts; 
    3737import std.file; 
    3838import std.typetuple; 
    3939 
    4040version (DigitalMars) 
     
    560560            c = ((c - 0xD7C0) << 10) + (c2 - 0xDC00); 
    561561            } 
    562562            std.utf.encode(buf, c); 
    563563        } 
    564564        } 
    565565        if (ferror(fp)) 
    566566        StdioException(); 
    567567        return buf.length; 
    568568    } 
    569569 
    570     auto sz = std.gc.capacity(buf.ptr); 
     570    auto sz = GC.sizeOf(buf.ptr); 
    571571    //auto sz = buf.length; 
    572572    buf = buf.ptr[0 .. sz]; 
    573573    if (fp._flag & _IONBF) 
    574574    { 
    575575        /* Use this for unbuffered I/O, when running 
    576576         * across buffer boundaries, or for any but the common 
    577577         * cases. 
    578578         */ 
    579579        L1: 
    580580        char *p; 
    581581 
    582582        if (sz) 
    583583        { 
    584584        p = buf.ptr; 
    585585        } 
    586586        else 
    587587        { 
    588588        sz = 64; 
    589         p = cast(char*) std.gc.malloc(sz); 
    590         std.gc.hasNoPointers(p); 
     589        p = cast(char*) GC.malloc(sz, GC.BlkAttr.NO_SCAN); 
    591590        buf = p[0 .. sz]; 
    592591        } 
    593592        size_t i = 0; 
    594593        for (int c; (c = FGETC(fp)) != -1; ) 
    595594        { 
    596595        if ((p[i] = c) != terminator) 
    597596        { 
    598597            i++; 
    599598            if (i < sz) 
    600599            continue; 
     
    637636            goto L1; 
    638637            } 
    639638            else 
    640639            {   if (i != u && p[i] == terminator) 
    641640                break; 
    642641            goto L1; 
    643642            } 
    644643        } 
    645644        if (i > sz) 
    646645        { 
    647             buf = cast(char[])std.gc.malloc(i); 
    648             std.gc.hasNoPointers(buf.ptr); 
     646            buf = cast(char[])GC.malloc(i, GC.BlkAttr.NO_SCAN)[0 .. i]; 
    649647        } 
    650648        if (i - 1) 
    651649            memcpy(buf.ptr, p, i - 1); 
    652650        buf[i - 1] = terminator; 
    653651        buf = buf[0 .. i]; 
    654652        if (terminator == '\n' && c == '\r') 
    655653            i++; 
    656654        } 
    657655        else 
    658656        { 
     
    660658        { 
    661659            if (i == u)     // if end of buffer 
    662660            goto L1;    // give up 
    663661            auto c = p[i]; 
    664662            i++; 
    665663            if (c == terminator) 
    666664            break; 
    667665        } 
    668666        if (i > sz) 
    669667        { 
    670             buf = cast(char[])std.gc.malloc(i); 
    671             std.gc.hasNoPointers(buf.ptr); 
     668            buf = cast(char[])GC.malloc(i, GC.BlkAttr.NO_SCAN)[0 .. i]; 
    672669        } 
    673670        memcpy(buf.ptr, p, i); 
    674671        buf = buf[0 .. i]; 
    675672        } 
    676673        fp._cnt -= i; 
    677674        fp._ptr += i; 
    678675        return i; 
    679676    } 
    680677    } 
    681678    else version (GCC_IO) 
     
    741738             size_t n = 0; 
    742739             auto s = getdelim(&lineptr, &n, terminator, fp); 
    743740             scope(exit) free(lineptr); 
    744741             if (s < 0) 
    745742             { 
    746743                 if (ferror(fp)) 
    747744                     StdioException(); 
    748745                 buf.length = 0;        // end of file 
    749746                 return 0; 
    750747             } 
    751              buf = buf.ptr[0 .. std.gc.capacity(buf.ptr)]; 
     748             buf = buf.ptr[0 .. GC.sizeOf(buf.ptr)]; 
    752749             if (s <= buf.length) 
    753750             { 
    754751                 buf.length = s; 
    755752                 buf[] = lineptr[0 .. s]; 
    756753             } 
    757754             else 
    758755             { 
    759756                 buf = lineptr[0 .. s].dup; 
    760757             } 
    761758             return s; 
  • trunk/phobos/std/string.d

    r826 r853  
    3232//debug=string;     // uncomment to turn on debugging printf's 
    3333 
    3434private import std.algorithm; 
    3535private import std.stdio; 
    3636private import std.c.stdio; 
    3737private import std.c.stdlib; 
    3838private import std.c.string; 
    3939private import std.utf; 
    4040private import std.encoding; 
    4141private import std.uni; 
    42 private import std.array; 
    4342private import std.format; 
    4443private import std.ctype; 
    4544private import std.stdarg; 
    4645private import std.contracts; 
    4746private import std.typetuple; 
    4847private import std.conv; 
    4948private import std.traits; 
     49private import exception : onArrayBoundsError; 
    5050 
    5151extern (C) 
    5252{ 
    5353 
    5454    size_t wcslen(in wchar *); 
    5555    int wcscmp(in wchar *, in wchar *); 
    5656} 
    5757 
    5858/* ************* Exceptions *************** */ 
    5959 
     
    30363036 * Returns: s 
    30373037 */ 
    30383038char[] sformat(char[] s, ...) 
    30393039{   size_t i; 
    30403040 
    30413041    void putc(dchar c) 
    30423042    { 
    30433043    if (c <= 0x7F) 
    30443044    { 
    30453045        if (i >= s.length) 
    3046         throw new ArrayBoundsError("std.string.sformat", 0); 
     3046        onArrayBoundsError("std.string.sformat", 0); 
    30473047        s[i] = cast(char)c; 
    30483048        ++i; 
    30493049    } 
    30503050    else 
    30513051    {   char[4] buf; 
    30523052        auto b = std.utf.toUTF8(buf, c); 
    30533053        if (i + b.length > s.length) 
    3054         throw new ArrayBoundsError("std.string.sformat", 0); 
     3054        onArrayBoundsError("std.string.sformat", 0); 
    30553055        s[i..i+b.length] = b[]; 
    30563056        i += b.length; 
    30573057    } 
    30583058    } 
    30593059 
    30603060    std.format.doFormat(&putc, _arguments, _argptr); 
    30613061    return s[0 .. i]; 
    30623062} 
    30633063 
    30643064 
  • trunk/phobos/std/variant.d

    r816 r853  
    7676 *     in a product, an acknowledgment in the product documentation would be 
    7777 *     appreciated but is not required. 
    7878 *  o  Altered source versions must be plainly marked as such, and must not 
    7979 *     be misrepresented as being the original software. 
    8080 *  o  This notice may not be removed or altered from any source 
    8181 *     distribution. 
    8282 */ 
    8383 
    8484module std.variant; 
    8585 
    86 import std.traits, std.conv, std.c.string, std.typetuple, std.gc
     86import std.traits, std.conv, std.c.string, std.typetuple
    8787import std.stdio; // for testing only 
    8888import std.contracts; // for testing only 
    8989 
    9090private template maxSize(T...) 
    9191{ 
    9292    static if (T.length == 1) 
    9393    { 
    9494        static const size_t maxSize = T[0].sizeof; 
    9595    } 
    9696    else 
  • trunk/phobos/unittest.d

    r719 r853  
    1818 *  o  Altered source versions must be plainly marked as such, and must not 
    1919 *     be misrepresented as being the original software. 
    2020 *  o  This notice may not be removed or altered from any source 
    2121 *     distribution. 
    2222 */ 
    2323 
    2424// This test program pulls in all the library modules in order 
    2525// to run the unit tests on them. 
    2626// Then, it prints out the arguments passed to main(). 
    2727 
    28 public import std.array; 
    29 public import std.asserterror; 
    3028public import std.base64; 
    3129public import std.bind; 
    3230public import std.bitarray; 
    3331public import std.boxer; 
    3432public import std.compiler; 
    3533public import std.contracts; 
    3634public import std.conv; 
    3735public import std.cover; 
    3836public import std.cpuid; 
    3937public import std.cstream; 
    4038public import std.ctype; 
    4139public import std.date; 
    4240public import std.dateparse; 
    4341public import std.demangle; 
    4442public import std.file; 
    4543public import std.format; 
    46 public import std.gc; 
    4744public import std.getopt; 
    48 public import std.hiddenfunc; 
    4945public import std.intrinsic; 
    5046public import std.loader; 
    5147public import std.math; 
    5248public import std.md5; 
    5349public import std.metastrings; 
    5450public import std.mmfile; 
    55 public import std.moduleinit; 
    5651public import std.openrj; 
    5752public import std.outbuffer; 
    58 public import std.outofmemory; 
    5953public import std.path; 
    6054public import std.perf; 
    6155public import std.process; 
    6256public import std.random; 
    6357public import std.regexp; 
    6458public import std.signals; 
    6559//public import std.slist; 
    6660public import std.socket; 
    6761public import std.socketstream; 
    6862public import std.stdint; 
    6963public import std.stdio; 
    7064public import std.stream; 
    7165public import std.string; 
    72 public import std.switcherr; 
    7366public import std.syserror; 
    7467public import std.system; 
    75 public import std.thread; 
    7668public import std.traits; 
    7769public import std.typetuple; 
    7870public import std.uni; 
    7971public import std.uri; 
    8072public import std.utf; 
    8173public import std.variant; 
    8274public import std.zip; 
    8375public import std.zlib; 
    8476 
    8577int main(char[][] args) 
  • trunk/phobos/win32.mak

    r850 r853  
    6363 
    6464.cpp.obj: 
    6565    $(CC) -c $(CFLAGS) $* 
    6666 
    6767.d.obj: 
    6868    $(DMD) -c $(DFLAGS) $* 
    6969 
    7070.asm.obj: 
    7171    $(CC) -c $* 
    7272 
    73 targets : phobos.lib gcstub.obj 
     73targets : phobos.lib 
    7474 
    7575test : test.exe 
    7676 
    7777test.obj : test.d 
    7878    $(DMD) -c test -g -unittest 
    7979 
    8080test.exe : test.obj phobos.lib 
    8181    $(DMD) test.obj -g -L/map 
    8282 
    83 OBJS= deh.obj icomplex.obj \ 
    84     object.obj monitor.obj \ 
    85     critical.obj process.obj \ 
    86     Czlib.obj Dzlib.obj \ 
     83OBJS= Czlib.obj Dzlib.obj \ 
    8784    oldsyserror.obj \ 
    8885    errno.obj \ 
    89     c_stdio.obj \ 
    90     complex.obj 
     86    c_stdio.obj 
    9187 
    9288#   ti_bit.obj ti_Abit.obj 
    9389 
    9490SRCS= std\math.d std\stdio.d std\dateparse.d std\date.d std\uni.d std\string.d \ 
    9591    std\atomics.d std\base64.d std\md5.d std\xml.d std\bigint.d std\regexp.d \ 
    9692    std\compiler.d std\cpuid.d std\format.d std\demangle.d \ 
    9793    std\path.d std\file.d std\outbuffer.d std\utf.d std\uri.d \ 
    98     std\ctype.d std\random.d std\array.d std\mmfile.d \ 
     94    std\ctype.d std\random.d std\mmfile.d \ 
    9995    std\bitarray.d std\algorithm.d std\numeric.d std\functional.d \ 
    100     std\metastrings.d std\hiddenfunc.d std\contracts.d std\getopt.d \ 
     96    std\metastrings.d std\contracts.d std\getopt.d \ 
    10197    std\signals.d std\typetuple.d std\traits.d std\bind.d \ 
    102     std\bitmanip.d std\typecons.d std\switcherr.d
    103     std\thread.d std\synchro.d std\moduleinit.d std\boxer.d \ 
    104     std\asserterror.d std\outofmemory.d std\system.d \ 
     98    std\bitmanip.d std\typecons.d
     99    std\boxer.d \ 
     100    std\system.d \ 
    105101    std\iterator.d std\encoding.d std\variant.d \ 
    106102    std\stream.d std\socket.d std\socketstream.d \ 
    107     std\perf.d std\openrj.d std\conv.d std\cover.d
     103    std\perf.d std\openrj.d std\conv.d
    108104    std\zip.d std\cstream.d std\loader.d \ 
    109     crc32.d gcstats.d \ 
    110     internal\aaA.d internal\adi.d internal\arrayassign.d \ 
    111     internal\aApply.d internal\aApplyR.d internal\memset.d \ 
    112     internal\arraycast.d internal\arraycat.d \ 
    113     internal\switch.d internal\qsort.d internal\invariant.d \ 
    114     internal\dmain2.d internal\cast.d internal\obj.d \ 
    115     internal\arrayfloat.d internal\arraydouble.d internal\arrayreal.d \ 
    116     internal\arraybyte.d internal\arrayshort.d internal\arrayint.d \ 
     105    crc32.d \ 
    117106    etc\gamma.d \ 
    118107    std\c\stdarg.d \ 
    119108    std\c\windows\com.d \ 
    120109    std\c\windows\stat.d \ 
    121110    std\c\windows\windows.d \ 
    122111    std\c\windows\winsock.d \ 
    123112    std\windows\charset.d \ 
    124113    std\windows\iunknown.d \ 
    125114    std\windows\registry.d \ 
    126     std\windows\syserror.d \ 
    127     std\typeinfo\ti_ptr.d \ 
    128     std\typeinfo\ti_delegate.d \ 
    129     std\typeinfo\ti_void.d \ 
    130     std\typeinfo\ti_C.d \ 
    131     std\typeinfo\ti_byte.d \ 
    132     std\typeinfo\ti_ubyte.d \ 
    133     std\typeinfo\ti_short.d \ 
    134     std\typeinfo\ti_ushort.d \ 
    135     std\typeinfo\ti_int.d \ 
    136     std\typeinfo\ti_uint.d \ 
    137     std\typeinfo\ti_long.d \ 
    138     std\typeinfo\ti_ulong.d \ 
    139     std\typeinfo\ti_char.d \ 
    140     std\typeinfo\ti_wchar.d \ 
    141     std\typeinfo\ti_dchar.d \ 
    142     std\typeinfo\ti_cdouble.d \ 
    143     std\typeinfo\ti_double.d \ 
    144     std\typeinfo\ti_idouble.d \ 
    145     std\typeinfo\ti_cfloat.d \ 
    146     std\typeinfo\ti_float.d \ 
    147     std\typeinfo\ti_ifloat.d \ 
    148     std\typeinfo\ti_creal.d \ 
    149     std\typeinfo\ti_real.d \ 
    150     std\typeinfo\ti_ireal.d \ 
    151     std\typeinfo\ti_AC.d \ 
    152     std\typeinfo\ti_Ag.d \ 
    153     std\typeinfo\ti_Ashort.d \ 
    154     std\typeinfo\ti_Aint.d \ 
    155     std\typeinfo\ti_Along.d \ 
    156     std\typeinfo\ti_Afloat.d \ 
    157     std\typeinfo\ti_Adouble.d \ 
    158     std\typeinfo\ti_Areal.d \ 
    159     std\typeinfo\ti_Acfloat.d \ 
    160     std\typeinfo\ti_Acdouble.d \ 
    161     std\typeinfo\ti_Acreal.d 
     115    std\windows\syserror.d 
    162116 
    163117 
    164118 
    165119DOCS=   $(DOC)\std_path.html $(DOC)\std_math.html $(DOC)\std_outbuffer.html \ 
    166120    $(DOC)\std_stream.html $(DOC)\std_string.html $(DOC)\std_base64.html \ 
    167121    $(DOC)\object.html $(DOC)\std_compiler.html $(DOC)\std_format.html \ 
    168122    $(DOC)\std_random.html $(DOC)\std_file.html $(DOC)\std_date.html \ 
    169123    $(DOC)\std_md5.html $(DOC)\std_zip.html $(DOC)\std_zlib.html \ 
    170124    $(DOC)\std_algorithm.html \ 
    171     $(DOC)\std_array.html \ 
    172125    $(DOC)\std_bigint.html \ 
    173126    $(DOC)\std_bind.html \ 
    174127    $(DOC)\std_bitarray.html \ 
    175128    $(DOC)\std_bitmanip.html \ 
    176129    $(DOC)\std_boxer.html \ 
    177130    $(DOC)\std_complex.html \ 
    178131    $(DOC)\std_contracts.html \ 
    179132    $(DOC)\std_conv.html \ 
    180133    $(DOC)\std_cover.html \ 
    181134    $(DOC)\std_cpuid.html \ 
     
    220173    $(DOC)\std_c_process.html \ 
    221174    $(DOC)\std_c_stdarg.html \ 
    222175    $(DOC)\std_c_stddef.html \ 
    223176    $(DOC)\std_c_stdio.html \ 
    224177    $(DOC)\std_c_stdlib.html \ 
    225178    $(DOC)\std_c_string.html \ 
    226179    $(DOC)\std_c_time.html \ 
    227180    $(DOC)\std_c_wcharh.html \ 
    228181    $(DOC)\phobos.html 
    229182 
    230 SRC=    errno.c object.d unittest.d crc32.d gcstats.d phobos.d 
     183SRC=    errno.c unittest.d crc32.d phobos.d 
    231184 
    232185SRC_STD= std\zlib.d std\zip.d std\stdint.d std\conv.d std\utf.d std\uri.d \ 
    233     std\gc.d std\math.d std\string.d std\path.d std\date.d \ 
     186    std\math.d std\string.d std\path.d std\date.d \ 
    234187    std\ctype.d std\file.d std\compiler.d std\system.d std\moduleinit.d \ 
    235     std\outbuffer.d std\thread.d std\synchro.d std\md5.d std\atomics.d std\base64.d \ 
    236     std\asserterror.d std\dateparse.d std\outofmemory.d std\mmfile.d \ 
    237     std\intrinsic.d std\array.d std\switcherr.d std\syserror.d \ 
     188    std\outbuffer.d std\thread.d std\md5.d std\atomics.d std\base64.d \ 
     189    std\dateparse.d std\outofmemory.d std\mmfile.d \ 
     190    std\intrinsic.d std\switcherr.d std\syserror.d \ 
    238191    std\regexp.d std\random.d std\stream.d std\process.d \ 
    239192    std\socket.d std\socketstream.d std\loader.d std\stdarg.d std\format.d \ 
    240193    std\stdio.d std\perf.d std\openrj.d std\uni.d std\boxer.d \ 
    241194    std\cstream.d std\demangle.d std\cover.d std\bitarray.d \ 
    242195    std\signals.d std\cpuid.d std\typetuple.d std\traits.d std\bind.d \ 
    243     std\metastrings.d std\hiddenfunc.d std\contracts.d std\getopt.d \ 
     196    std\metastrings.d std\contracts.d std\getopt.d \ 
    244197    std\variant.d std\numeric.d std\bitmanip.d std\complex.d \ 
    245198    std\functional.d std\algorithm.d std\typecons.d std\iterator.d \ 
    246199    std\xml.d std\encoding.d std\bigint.d 
    247200 
    248201SRC_STD_C= std\c\process.d std\c\stdlib.d std\c\time.d std\c\stdio.d \ 
    249202    std\c\math.d std\c\stdarg.d std\c\stddef.d std\c\fenv.d std\c\string.d \ 
    250203    std\c\locale.d std\c\wcharh.d 
    251  
    252 SRC_TI= \ 
    253     std\typeinfo\ti_wchar.d std\typeinfo\ti_uint.d \ 
    254     std\typeinfo\ti_short.d std\typeinfo\ti_ushort.d \ 
    255     std\typeinfo\ti_byte.d std\typeinfo\ti_ubyte.d \ 
    256     std\typeinfo\ti_long.d std\typeinfo\ti_ulong.d \ 
    257     std\typeinfo\ti_ptr.d std\typeinfo\ti_dchar.d \ 
    258     std\typeinfo\ti_float.d std\typeinfo\ti_double.d \ 
    259     std\typeinfo\ti_real.d std\typeinfo\ti_delegate.d \ 
    260     std\typeinfo\ti_creal.d std\typeinfo\ti_ireal.d \ 
    261     std\typeinfo\ti_cfloat.d std\typeinfo\ti_ifloat.d \ 
    262     std\typeinfo\ti_cdouble.d std\typeinfo\ti_idouble.d \ 
    263     std\typeinfo\ti_Ashort.d \ 
    264     std\typeinfo\ti_Ag.d \ 
    265     std\typeinfo\ti_AC.d std\typeinfo\ti_C.d \ 
    266     std\typeinfo\ti_int.d std\typeinfo\ti_char.d \ 
    267     std\typeinfo\ti_Aint.d \ 
    268     std\typeinfo\ti_Along.d \ 
    269     std\typeinfo\ti_Afloat.d std\typeinfo\ti_Adouble.d \ 
    270     std\typeinfo\ti_Areal.d \ 
    271     std\typeinfo\ti_Acfloat.d std\typeinfo\ti_Acdouble.d \ 
    272     std\typeinfo\ti_Acreal.d \ 
    273     std\typeinfo\ti_void.d 
    274  
    275 SRC_INT=    \ 
    276     internal\switch.d internal\complex.c internal\critical.c \ 
    277     internal\minit.asm internal\alloca.d internal\llmath.d internal\deh.c \ 
    278     internal\arraycat.d internal\invariant.d internal\monitor.d \ 
    279     internal\memset.d internal\arraycast.d internal\aaA.d internal\adi.d \ 
    280     internal\dmain2.d internal\cast.d internal\qsort.d internal\deh2.d \ 
    281     internal\cmath2.d internal\obj.d internal\mars.h internal\aApply.d \ 
    282     internal\aApplyR.d internal\object.d internal\trace.d \ 
    283     internal\qsort2.d internal\arrayassign.d \ 
    284     internal\arrayfloat.d internal\arraydouble.d internal\arrayreal.d \ 
    285     internal\arraybyte.d internal\arrayshort.d internal\arrayint.d 
    286  
    287204 
    288205SRC_STD_WIN= std\windows\registry.d \ 
    289206    std\windows\iunknown.d std\windows\syserror.d std\windows\charset.d 
    290207 
    291208SRC_STD_C_WIN= std\c\windows\windows.d std\c\windows\com.d \ 
    292209    std\c\windows\winsock.d std\c\windows\stat.d 
    293210 
    294211SRC_STD_C_LINUX= std\c\linux\linux.d std\c\linux\linuxextern.d \ 
    295212    std\c\linux\socket.d std\c\linux\pthread.d std\c\linux\termios.d \ 
    296213    std\c\linux\tipc.d 
     
    324241    etc\c\zlib\inftrees.c \ 
    325242    etc\c\zlib\zutil.h \ 
    326243    etc\c\zlib\zlib.3 \ 
    327244    etc\c\zlib\zlib.h \ 
    328245    etc\c\zlib\adler32.c \ 
    329246    etc\c\zlib\ChangeLog \ 
    330247    etc\c\zlib\README \ 
    331248    etc\c\zlib\win32.mak \ 
    332249    etc\c\zlib\linux.mak 
    333250 
    334 SRC_GC= internal\gc\gc.d \ 
    335     internal\gc\gcold.d \ 
    336     internal\gc\gcx.d \ 
    337     internal\gc\gcstub.d \ 
    338     internal\gc\gcbits.d \ 
    339     internal\gc\win32.d \ 
    340     internal\gc\gclinux.d \ 
    341     internal\gc\testgc.d \ 
    342     internal\gc\win32.mak \ 
    343     internal\gc\linux.mak 
    344  
    345 phobos.lib : $(OBJS) $(SRCS) minit.obj internal\gc\dmgc.lib \ 
     251phobos.lib : $(OBJS) $(SRCS) minit.obj \ 
    346252    etc\c\zlib\zlib.lib win32.mak 
    347 #   lib -c -p64 phobos.lib $(OBJS) minit.obj internal\gc\dmgc.lib \ 
    348 #       etc\c\zlib\zlib.lib 
    349253    $(DMD) -lib -ofphobos.lib $(DFLAGS) $(SRCS) $(OBJS) minit.obj \ 
    350         internal\gc\dmgc.lib etc\c\zlib\zlib.lib 
     254        etc\c\zlib\zlib.lib 
    351255 
    352256unittest : $(SRCS) phobos.lib 
    353257    $(DMD) $(UDFLAGS) -L/co -unittest unittest.d $(SRCS) phobos.lib 
    354258    unittest 
    355259 
    356260#unittest : unittest.exe 
    357261#   unittest 
    358262# 
    359263#unittest.exe : unittest.d phobos.lib 
    360264#   $(DMD) unittest -g 
    361265#   dmc unittest.obj -g 
    362266 
    363267cov : $(SRCS) phobos.lib 
    364268    $(DMD) -cov -unittest -ofcov.exe unittest.d $(SRCS) phobos.lib 
    365269    cov 
    366270 
    367271html : $(DOCS) 
    368272 
    369273###################################################### 
    370274 
    371 internal\gc\dmgc.lib: 
    372     cd internal\gc 
    373     make -f win32.mak dmgc.lib 
    374     cd ..\.. 
    375  
    376275etc\c\zlib\zlib.lib: 
    377276    cd etc\c\zlib 
    378277    make -f win32.mak zlib.lib 
    379278    cd ..\..\.. 
    380279 
    381280errno.obj : errno.c 
    382281 
    383 ### internal 
    384  
    385 aaA.obj : internal\aaA.d 
    386     $(DMD) -c $(DFLAGS) internal\aaA.d 
    387  
    388 aApply.obj : internal\aApply.d 
    389     $(DMD) -c $(DFLAGS) internal\aApply.d 
    390  
    391 aApplyR.obj : internal\aApplyR.d 
    392     $(DMD) -c $(DFLAGS) internal\aApplyR.d 
    393  
    394 adi.obj : internal\adi.d 
    395     $(DMD) -c $(DFLAGS) internal\adi.d 
    396  
    397 arrayassign.obj : internal\arrayassign.d 
    398     $(DMD) -c $(DFLAGS) internal\arrayassign.d 
    399  
    400 arraycast.obj : internal\arraycast.d 
    401     $(DMD) -c $(DFLAGS) internal\arraycast.d 
    402  
    403 arraycat.obj : internal\arraycat.d 
    404     $(DMD) -c $(DFLAGS) internal\arraycat.d 
    405  
    406 cast.obj : internal\cast.d 
    407     $(DMD) -c $(DFLAGS) internal\cast.d 
    408  
    409 icomplex.obj : internal\complex.c 
    410     $(CC) -c $(CFLAGS) internal\complex.c -oicomplex.obj 
    411  
    412 critical.obj : internal\critical.c 
    413     $(CC) -c $(CFLAGS) internal\critical.c 
    414  
    415 deh.obj : internal\mars.h internal\deh.c 
    416     $(CC) -c $(CFLAGS) internal\deh.c 
    417  
    418 dmain2.obj : internal\dmain2.d 
    419     $(DMD) -c $(DFLAGS) internal\dmain2.d 
    420  
    421 gcstub.obj : internal\gc\gcstub.d 
    422     $(DMD) -c $(DFLAGS) -Iinternal\gc internal\gc\gcstub.d 
    423  
    424 invariant.obj : internal\invariant.d 
    425     $(DMD) -c $(DFLAGS) internal\invariant.d 
    426  
    427 memset.obj : internal\memset.d 
    428     $(DMD) -c $(DFLAGS) internal\memset.d 
    429  
    430 minit.obj : internal\minit.asm 
    431     $(CC) -c internal\minit.asm 
    432  
    433 monitor.obj : internal\mars.h internal\monitor.d 
    434     $(DMD) -c $(DFLAGS) internal\monitor.d 
    435  
    436 obj.obj : internal\obj.d 
    437     $(DMD) -c $(DFLAGS) internal\obj.d 
    438  
    439 object.obj : internal\object.d 
    440     $(DMD) -c $(DFLAGS) internal\object.d 
    441  
    442 qsort.obj : internal\qsort.d 
    443     $(DMD) -c $(DFLAGS) internal\qsort.d 
    444  
    445 switch.obj : internal\switch.d 
    446     $(DMD) -c $(DFLAGS) internal\switch.d 
    447  
    448282### std 
    449283 
    450284algorithm.obj : std\algorithm.d 
    451285    $(DMD) -c $(DFLAGS) std\algorithm.d 
    452286 
    453 array.obj : std\array.d 
    454     $(DMD) -c $(DFLAGS) std\array.d 
    455  
    456 asserterror.obj : std\asserterror.d 
    457     $(DMD) -c $(DFLAGS) std\asserterror.d 
    458  
    459287atomics.obj : std\atomics.d 
    460288    $(DMD) -c $(DFLAGS) -inline std\atomics.d 
    461289 
    462290base64.obj : std\base64.d 
    463291    $(DMD) -c $(DFLAGS) -inline std\base64.d 
    464292 
    465293bind.obj : std\bind.d 
    466294    $(DMD) -c $(DFLAGS) -inline std\bind.d 
    467295 
    468296bitarray.obj : std\bitarray.d 
     
    509337 
    510338file.obj : std\file.d 
    511339    $(DMD) -c $(DFLAGS) std\file.d 
    512340 
    513341format.obj : std\format.d 
    514342    $(DMD) -c $(DFLAGS) std\format.d 
    515343 
    516344functional.obj : std\functional.d 
    517345    $(DMD) -c $(DFLAGS) std\functional.d 
    518346 
    519 gc.obj : std\gc.d 
    520     $(DMD) -c $(DFLAGS) std\gc.d 
    521  
    522347getopt.obj : std\getopt.d 
    523348    $(DMD) -c $(DFLAGS) std\getopt.d 
    524349 
    525 hiddenfunc.obj : std\hiddenfunc.d 
    526     $(DMD) -c $(DFLAGS) std\hiddenfunc.d 
    527  
    528350iterator.obj : std\iterator.d 
    529351    $(DMD) -c $(DFLAGS) std\iterator.d 
    530352 
    531353loader.obj : std\loader.d 
    532354    $(DMD) -c $(DFLAGS) std\loader.d 
    533355 
    534356math.obj : std\math.d 
    535357    $(DMD) -c $(DFLAGS) std\math.d 
    536358 
    537359md5.obj : std\md5.d 
     
    542364 
    543365mmfile.obj : std\mmfile.d 
    544366    $(DMD) -c $(DFLAGS) std\mmfile.d 
    545367 
    546368moduleinit.obj : std\moduleinit.d 
    547369    $(DMD) -c $(DFLAGS) std\moduleinit.d 
    548370 
    549371numeric.obj : std\numeric.d 
    550372    $(DMD) -c $(DFLAGS) std\numeric.d 
    551373 
    552 #object.obj : object.d 
    553 #   $(DMD) -c $(DFLAGS) object.d 
    554  
    555374openrj.obj : std\openrj.d 
    556375    $(DMD) -c $(DFLAGS) std\openrj.d 
    557376 
    558377outbuffer.obj : std\outbuffer.d 
    559378    $(DMD) -c $(DFLAGS) std\outbuffer.d 
    560379 
    561380outofmemory.obj : std\outofmemory.d 
    562381    $(DMD) -c $(DFLAGS) std\outofmemory.d 
    563382 
    564383path.obj : std\path.d 
     
    599418 
    600419oldsyserror.obj : std\syserror.d 
    601420    $(DMD) -c $(DFLAGS) std\syserror.d -ofoldsyserror.obj 
    602421 
    603422system.obj : std\system.d 
    604423    $(DMD) -c $(DFLAGS) std\system.d 
    605424 
    606425thread.obj : std\thread.d 
    607426    $(DMD) -c $(DFLAGS) std\thread.d 
    608427 
    609 synchro.obj : std\synchro.d 
    610     $(DMD) -c $(DFLAGS) std\synchro.d 
    611  
    612428traits.obj : std\traits.d 
    613429    $(DMD) -c $(DFLAGS) std\traits.d -oftraits.obj 
    614430 
    615431typecons.obj : std\typecons.d 
    616432    $(DMD) -c $(DFLAGS) std\typecons.d -oftypecons.obj 
    617433 
    618434typetuple.obj : std\typetuple.d 
    619435    $(DMD) -c $(DFLAGS) std\typetuple.d -oftypetuple.obj 
    620436 
    621437uni.obj : std\uni.d 
     
    681497 
    682498stat.obj : std\c\windows\stat.d 
    683499    $(DMD) -c $(DFLAGS) std\c\windows\stat.d 
    684500 
    685501winsock.obj : std\c\windows\winsock.d 
    686502    $(DMD) -c $(DFLAGS) std\c\windows\winsock.d 
    687503 
    688504windows.obj : std\c\windows\windows.d 
    689505    $(DMD) -c $(DFLAGS) std\c\windows\windows.d 
    690506 
    691 ### std\typeinfo 
    692  
    693 ti_void.obj : std\typeinfo\ti_void.d 
    694     $(DMD) -c $(DFLAGS) std\typeinfo\ti_void.d 
    695  
    696 ti_bit.obj : std\typeinfo\ti_bit.d 
    697     $(DMD) -c $(DFLAGS) std\typeinfo\ti_bit.d 
    698  
    699 ti_wchar.obj : std\typeinfo\ti_wchar.d 
    700     $(DMD) -c $(DFLAGS) std\typeinfo\ti_wchar.d 
    701  
    702 ti_dchar.obj : std\typeinfo\ti_dchar.d 
    703     $(DMD) -c $(DFLAGS) std\typeinfo\ti_dchar.d 
    704  
    705 ti_uint.obj : std\typeinfo\ti_uint.d 
    706     $(DMD) -c $(DFLAGS) std\typeinfo\ti_uint.d 
    707  
    708 ti_short.obj : std\typeinfo\ti_short.d 
    709     $(DMD) -c $(DFLAGS) std\typeinfo\ti_short.d 
    710  
    711 ti_ushort.obj : std\typeinfo\ti_ushort.d 
    712     $(DMD) -c $(DFLAGS) std\typeinfo\ti_ushort.d 
    713  
    714 ti_byte.obj : std\typeinfo\ti_byte.d 
    715     $(DMD) -c $(DFLAGS) std\typeinfo\ti_byte.d 
    716  
    717 ti_ubyte.obj : std\typeinfo\ti_ubyte.d 
    718     $(DMD) -c $(DFLAGS) std\typeinfo\ti_ubyte.d 
    719  
    720 ti_long.obj : std\typeinfo\ti_long.d 
    721     $(DMD) -c $(DFLAGS) std\typeinfo\ti_long.d 
    722  
    723 ti_ulong.obj : std\typeinfo\ti_ulong.d 
    724     $(DMD) -c $(DFLAGS) std\typeinfo\ti_ulong.d 
    725  
    726 ti_ptr.obj : std\typeinfo\ti_ptr.d 
    727     $(DMD) -c $(DFLAGS) std\typeinfo\ti_ptr.d 
    728  
    729 ti_float.obj : std\typeinfo\ti_float.d 
    730     $(DMD) -c $(DFLAGS) std\typeinfo\ti_float.d 
    731  
    732 ti_double.obj : std\typeinfo\ti_double.d 
    733     $(DMD) -c $(DFLAGS) std\typeinfo\ti_double.d 
    734  
    735 ti_real.obj : std\typeinfo\ti_real.d 
    736     $(DMD) -c $(DFLAGS) std\typeinfo\ti_real.d 
    737  
    738 ti_delegate.obj : std\typeinfo\ti_delegate.d 
    739     $(DMD) -c $(DFLAGS) std\typeinfo\ti_delegate.d 
    740  
    741 ti_creal.obj : std\typeinfo\ti_creal.d 
    742     $(DMD) -c $(DFLAGS) std\typeinfo\ti_creal.d 
    743  
    744 ti_ireal.obj : std\typeinfo\ti_ireal.d 
    745     $(DMD) -c $(DFLAGS) std\typeinfo\ti_ireal.d 
    746  
    747 ti_cfloat.obj : std\typeinfo\ti_cfloat.d 
    748     $(DMD) -c $(DFLAGS) std\typeinfo\ti_cfloat.d 
    749  
    750 ti_ifloat.obj : std\typeinfo\ti_ifloat.d 
    751     $(DMD) -c $(DFLAGS) std\typeinfo\ti_ifloat.d 
    752  
    753 ti_cdouble.obj : std\typeinfo\ti_cdouble.d 
    754     $(DMD) -c $(DFLAGS) std\typeinfo\ti_cdouble.d 
    755  
    756 ti_idouble.obj : std\typeinfo\ti_idouble.d 
    757     $(DMD) -c $(DFLAGS) std\typeinfo\ti_idouble.d 
    758  
    759 ti_AC.obj : std\typeinfo\ti_AC.d 
    760     $(DMD) -c $(DFLAGS) std\typeinfo\ti_AC.d 
    761  
    762 ti_Ag.obj : std\typeinfo\ti_Ag.d 
    763     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Ag.d 
    764  
    765 ti_Abit.obj : std\typeinfo\ti_Abit.d 
    766     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Abit.d 
    767  
    768 ti_Ashort.obj : std\typeinfo\ti_Ashort.d 
    769     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Ashort.d 
    770  
    771 ti_Aint.obj : std\typeinfo\ti_Aint.d 
    772     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Aint.d 
    773  
    774 ti_Along.obj : std\typeinfo\ti_Along.d 
    775     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Along.d 
    776  
    777 ti_Afloat.obj : std\typeinfo\ti_Afloat.d 
    778     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Afloat.d 
    779  
    780 ti_Adouble.obj : std\typeinfo\ti_Adouble.d 
    781     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Adouble.d 
    782  
    783 ti_Areal.obj : std\typeinfo\ti_Areal.d 
    784     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Areal.d 
    785  
    786 ti_Acfloat.obj : std\typeinfo\ti_Acfloat.d 
    787     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Acfloat.d 
    788  
    789 ti_Acdouble.obj : std\typeinfo\ti_Acdouble.d 
    790     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Acdouble.d 
    791  
    792 ti_Acreal.obj : std\typeinfo\ti_Acreal.d 
    793     $(DMD) -c $(DFLAGS) std\typeinfo\ti_Acreal.d 
    794  
    795 ti_C.obj : std\typeinfo\ti_C.d 
    796     $(DMD) -c $(DFLAGS) std\typeinfo\ti_C.d 
    797  
    798 ti_char.obj : std\typeinfo\ti_char.d 
    799     $(DMD) -c $(DFLAGS) std\typeinfo\ti_char.d 
    800  
    801 ti_int.obj : std\typeinfo\ti_int.d 
    802     $(DMD) -c $(DFLAGS) std\typeinfo\ti_int.d 
    803  
    804  
    805507################## DOCS #################################### 
    806508 
    807509$(DOC)\phobos.html : std.ddoc phobos.d 
    808510    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\phobos.html std.ddoc phobos.d 
    809511 
    810512$(DOC)\std_algorithm.html : std.ddoc std\algorithm.d 
    811513    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_algorithm.html std.ddoc std\algorithm.d 
    812514 
    813 $(DOC)\std_array.html : std.ddoc std\array.d 
    814     $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_array.html std.ddoc std\array.d 
    815  
    816515$(DOC)\std_atomics.html : std.ddoc std\atomics.d 
    817516    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_atomics.html std.ddoc std\atomics.d 
    818517 
    819518$(DOC)\std_base64.html : std.ddoc std\base64.d 
    820519    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_base64.html std.ddoc std\base64.d 
    821520 
    822521$(DOC)\std_bigint.html : std.ddoc std\bigint.d 
    823522    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_bigint.html std.ddoc std\bigint.d 
    824523 
    825524$(DOC)\std_bind.html : std.ddoc std\bind.d 
     
    866565 
    867566$(DOC)\std_file.html : std.ddoc std\file.d 
    868567    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_file.html std.ddoc std\file.d 
    869568 
    870569$(DOC)\std_format.html : std.ddoc std\format.d 
    871570    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_format.html std.ddoc std\format.d 
    872571 
    873572$(DOC)\std_functional.html : std.ddoc std\functional.d 
    874573    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_functional.html std.ddoc std\functional.d 
    875574 
    876 $(DOC)\std_gc.html : std.ddoc std\gc.d 
    877     $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_gc.html std.ddoc std\gc.d 
    878  
    879575$(DOC)\std_getopt.html : std.ddoc std\getopt.d 
    880576    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_getopt.html std.ddoc std\getopt.d 
    881577 
    882 $(DOC)\std_hiddenfunc.html : std.ddoc std\hiddenfunc.d 
    883     $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_hiddenfunc.html std.ddoc std\hiddenfunc.d 
    884  
    885578$(DOC)\std_iterator.html : std.ddoc std\iterator.d 
    886579    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_iterator.html std.ddoc std\iterator.d 
    887580 
    888581$(DOC)\std_intrinsic.html : std.ddoc std\intrinsic.d 
    889582    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_intrinsic.html std.ddoc std\intrinsic.d 
    890583 
    891584$(DOC)\std_math.html : std.ddoc std\math.d 
    892585    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_math.html std.ddoc std\math.d 
    893586 
    894587$(DOC)\std_md5.html : std.ddoc std\md5.d 
     
    947640 
    948641$(DOC)\std_string.html : std.ddoc std\string.d 
    949642    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_string.html std.ddoc std\string.d 
    950643 
    951644$(DOC)\std_system.html : std.ddoc std\system.d 
    952645    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_system.html std.ddoc std\system.d 
    953646 
    954647$(DOC)\std_thread.html : std.ddoc std\thread.d 
    955648    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_thread.html std.ddoc std\thread.d 
    956649 
    957 $(DOC)\std_synchro.html : std.ddoc std\synchro.d 
    958     $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_synchro.html std.ddoc std\synchro.d 
    959  
    960650$(DOC)\std_traits.html : std.ddoc std\traits.d 
    961651    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_traits.html std.ddoc std\traits.d 
    962652 
    963653$(DOC)\std_typecons.html : std.ddoc std\typecons.d 
    964654    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_typecons.html std.ddoc std\typecons.d 
    965655 
    966656$(DOC)\std_typetuple.html : std.ddoc std\typetuple.d 
    967657    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_typetuple.html std.ddoc std\typetuple.d 
    968658 
    969659$(DOC)\std_uni.html : std.ddoc std\uni.d 
     
    985675    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_encoding.html std.ddoc std\encoding.d 
    986676 
    987677$(DOC)\std_zip.html : std.ddoc std\zip.d 
    988678    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_zip.html std.ddoc std\zip.d 
    989679 
    990680$(DOC)\std_zlib.html : std.ddoc std\zlib.d 
    991681    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_zlib.html std.ddoc std\zlib.d 
    992682 
    993683$(DOC)\std_windows_charset.html : std.ddoc std\windows\charset.d 
    994684    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_windows_charset.html std.ddoc std\windows\charset.d 
    995  
    996 $(DOC)\object.html : std.ddoc internal\object.d 
    997     $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\object.html std.ddoc internal\object.d 
    998685 
    999686$(DOC)\std_c_fenv.html : std.ddoc std\c\fenv.d 
    1000687    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_c_fenv.html std.ddoc std\c\fenv.d 
    1001688 
    1002689$(DOC)\std_c_locale.html : std.ddoc std\c\locale.d 
    1003690    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_c_locale.html std.ddoc std\c\locale.d 
    1004691 
    1005692$(DOC)\std_c_math.html : std.ddoc std\c\math.d 
    1006693    $(DMD) -c -o- $(DFLAGS) -Df$(DOC)\std_c_math.html std.ddoc std\c\math.d 
    1007694 
     
    1044731    zip32 -u phobos $(SRC_STD_C) 
    1045732    zip32 -u phobos $(SRC_STD_WIN) 
    1046733    zip32 -u phobos $(SRC_STD_C_WIN) 
    1047734    zip32 -u phobos $(SRC_STD_C_LINUX) 
    1048735    zip32 -u phobos $(SRC_ETC) 
    1049736    zip32 -u phobos $(SRC_ETC_C) 
    1050737    zip32 -u phobos $(SRC_ZLIB) 
    1051738    zip32 -u phobos $(SRC_GC) 
    1052739 
    1053740clean: 
    1054     cd internal\gc 
    1055     make -f win32.mak clean 
    1056     cd ..\.. 
    1057741    cd etc\c\zlib 
    1058742    make -f win32.mak clean 
    1059743    cd ..\..\.. 
    1060744    del $(OBJS) 
    1061745    del $(DOCS) 
    1062746    del unittest.obj unittest.map unittest.exe 
    1063     del phobos.lib gcstub.obj 
     747    del phobos.lib 
    1064748 
    1065749cleanhtml: 
    1066750    del $(DOCS) 
    1067751 
    1068752install: 
    1069753    $(CP) phobos.lib gcstub.obj $(DIR)\lib 
    1070754    $(CP) win32.mak linux.mak phoboslicense.txt minit.obj std.ddoc $(DIR)\src\phobos 
    1071755    $(CP) $(SRC) $(DIR)\src\phobos 
    1072756    $(CP) $(SRC_STD) $(DIR)\src\phobos\std 
    1073757    $(CP) $(SRC_STD_C) $(DIR)\src\phobos\std\c 
    1074     $(CP) $(SRC_TI) $(DIR)\src\phobos\std\typeinfo 
    1075     $(CP) $(SRC_INT) $(DIR)\src\phobos\internal 
    1076758    $(CP) $(SRC_STD_WIN) $(DIR)\src\phobos\std\windows 
    1077759    $(CP) $(SRC_STD_C_WIN) $(DIR)\src\phobos\std\c\windows 
    1078760    $(CP) $(SRC_STD_C_LINUX) $(DIR)\src\phobos\std\c\linux 
    1079761    $(CP) $(SRC_ETC) $(DIR)\src\phobos\etc 
    1080762    $(CP) $(SRC_ETC_C) $(DIR)\src\phobos\etc\c 
    1081763    $(CP) $(SRC_ZLIB) $(DIR)\src\phobos\etc\c\zlib 
    1082     $(CP) $(SRC_GC) $(DIR)\src\phobos\internal\gc 
    1083