Download Reference Manual
The Developer's Library for D
About Wiki Forums Source Search Contact

Changeset 3895

Show
Ignore:
Timestamp:
08/19/08 20:36:22 (3 months ago)
Author:
keinfarbton
Message:

Make example compile

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/experimental/D2.0/example/conduits/createzip.d

    r3724 r3895  
    66/****************************************************************************** 
    77 
    8   Simple example where the current folder is recursively scanned for .d files  
     8  Simple example where the current folder is recursively scanned for .d files 
    99  before they are zipped into tmp.zip. 
    1010 
    …… 
    1515void main() 
    1616{ 
    17         char[][] files; 
     17        Cutf8[] files; 
    1818        auto root = new FileFolder ("."); 
    1919        foreach (file; root.tree.catalog ("*.d")) 

  • branches/experimental/D2.0/example/conduits/filescanregex.d

    r3724 r3895  
    2020    } 
    2121 
    22     scope scan = new FileScan; 
    23     scope regex =  Regex(r"\.(d|obj)$"); 
     22    /+scope+/ auto scan = new FileScan; 
     23    /+scope+/ auto regex =  Regex(r"\.(d|obj)$"); 
    2424 
    2525    scan(args[1], delegate bool (FilePath fp, bool isDir) { 

  • branches/experimental/D2.0/example/dsss.conf

    r3887 r3895  
    3131[logging/multilog.d] 
    3232 
    33 [manual/chapterStorage.d] 
    34  
    3533[networking/homepage.d] 
    3634[networking/httpget.d] 

  • branches/experimental/D2.0/example/system/localtime.d

    r3724 r3895  
    22 
    33        localtime.d 
    4          
     4 
    55*******************************************************************************/ 
    66 
    …… 
    2121{ 
    2222        /// list of day names 
    23         static char[][] days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]; 
     23        static Cutf8[] days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]; 
    2424 
    2525        /// list of month names 
    26         static char[][] months = 
     26        static Cutf8[] months = 
    2727        [ 
    2828            "Jan", "Feb", "Mar", "Apr", "May", "Jun", 
    …… 
    4444                          months[dt.date.month-1], 
    4545                          dt.date.day, 
    46                           dt.time.hours,  
     46                          dt.time.hours, 
    4747                          dt.time.minutes, 
    4848                          dt.time.seconds, 

  • branches/experimental/D2.0/example/text/xmlpath.d

    r3724 r3895  
    1515        doc.header; 
    1616 
    17         // attach an element with some attributes, plus  
     17        // attach an element with some attributes, plus 
    1818        // a child element with an attached data value 
    1919        doc.root.element   (null, "element") 
    …… 
    6666} 
    6767 
    68 void result (char[] msg, double time, XmlPath!(char).NodeSet set) 
     68void result (Cutf8 msg, double time, XmlPath!(char).NodeSet set) 
    6969{ 
    7070        Stdout.newline.formatln("{} {}", time, msg); 

  • branches/experimental/D2.0/example/vfs/vfscan.d

    r3724 r3895  
    99        on each invocation of newline or formatln, but here we're using '\n' 
    1010        to illustrate how to avoid flushing many individual lines 
    11          
     11 
    1212*******************************************************************************/ 
    1313 
    14 void main(char[][] args) 
    15 {        
    16         char[] root = args.length < 2 ? "." : args[1]; 
     14void main(Cutf8[] args) 
     15{ 
     16        Cutf8 root = args.length < 2 ? "." : args[1]; 
    1717        Stdout.formatln ("Scanning '{}'", root); 
    1818 

  • branches/experimental/D2.0/example/vfs/vfscanregex.d

    r3724 r3895  
    1313import  tango.io.vfs.FileFolder; 
    1414 
    15 void main(char[][] args)  
     15void main(Cutf8[] args) 
    1616{ 
    17     if (args.length < 2)  
     17    if (args.length < 2) 
    1818       { 
    1919       Stdout("Please pass a directory to search").newline; 
    …… 
    2121       } 
    2222 
    23     scope regex =  Regex(r"\.(d|obj)$"); 
    24     scope scan = new FileFolder (args[1]); 
     23    /+scope+/auto regex =  Regex(r"\.(d|obj)$"); 
     24    /+scope+/auto scan = new FileFolder (args[1]); 
    2525 
    2626    auto tree = scan.tree; 

  • branches/experimental/D2.0/example/vfs/vfszip.d

    r3724 r3895  
    1515******************************************************************************/ 
    1616 
    17 void main(char[][] args) 
     17void main(Cutf8[] args) 
    1818{ 
    19     char[] zipname; 
     19    Cutf8 zipname; 
    2020    if (args.length == 2) 
    2121        zipname = args[1]; 

  • branches/experimental/D2.0/lib/compiler/dmd/lifetime.d

    r3724 r3895  
    416416 
    417417 
    418 /** 
    419  * 
     418/* This function is obsoleted; replaced by _d_delarray_t() 
    420419 */ 
    421420extern (C) void _d_delarray(Array *p) 
    …… 
    432431} 
    433432 
     433/* Delete an array; ti is the element type. 
     434 * Should we zero out the array when done? 
     435 */ 
     436 
     437extern (C) void _d_delarray_t(Array *p, TypeInfo ti) 
     438{ 
     439    if (p) 
     440    { 
     441        assert(!p.length || p.data); 
     442        if (p.data) 
     443        {   if (ti) 
     444            {   // Call destructors on all the sub-objects 
     445                auto sz = ti.tsize(); 
     446                auto pe = p.data; 
     447                auto pend = pe + p.length * sz; 
     448                while (pe != pend) 
     449                {   pend -= sz; 
     450                    ti.destroy(pend); 
     451                } 
     452            } 
     453            gc_free(p.data); 
     454        } 
     455        p.data = null; 
     456        p.length = 0; 
     457    } 
     458} 
     459 
    434460 
    435461/** 
    …… 
    445471} 
    446472 
     473 
     474void new_finalizer(void *p, bool dummy) 
     475{ 
     476    //printf("new_finalizer(p = %p)\n", p); 
     477    _d_callfinalizer(p); 
     478} 
    447479 
    448480/** 

  • branches/experimental/D2.0/lib/dmd-posix.mak

    r3890 r3895  
    2424CC=gcc 
    2525LC=$(AR) -qsv 
    26 DC=~/dmd-2.015/dmd/bin/dmd 
     26DC=~/tango-d2/dmd/dmd/bin/dmd 
    2727 
    2828ADD_CFLAGS=-m32 

  • branches/experimental/D2.0/std/intrinsic.di

    r745 r3895  
    5959 * Tests the bit. 
    6060 */ 
    61 int bt( uint* p, uint bitnum ); 
     61int bt( in uint* p, uint bitnum ); 
    6262 
    6363 

  • branches/experimental/D2.0/tango/io/UnicodeFile.d

    r3888 r3895  
    102102{ 
    103103        private UnicodeBom!(T)  bom; 
    104         private char[]          path_; 
     104        private Cutf8           path_; 
    105105 
    106106        /*********************************************************************** 
    …… 
    112112        ***********************************************************************/ 
    113113 
    114         this (char[] path, Encoding encoding) 
     114        this (Cutf8 path, Encoding encoding) 
    115115        { 
    116116                bom = new UnicodeBom!(T)(encoding); 
    …… 
    139139        ***********************************************************************/ 
    140140 
    141         static UnicodeFile opCall (char[] name, Encoding encoding) 
     141        static UnicodeFile opCall (Cutf8 name, Encoding encoding) 
    142142        { 
    143143                return new UnicodeFile (name, encoding); 
    …… 
    154154                return new FilePath (path_); 
    155155        } 
    156          
     156 
    157157        /*********************************************************************** 
    158158 
    …… 
    161161        ***********************************************************************/ 
    162162 
    163         char[] toString () 
     163        override Cutf8 toString () 
    164164        { 
    165165                return path_; 
    …… 
    214214        ***********************************************************************/ 
    215215 
    216         UnicodeFile write (T[] content, bool writeBom = false) 
     216        UnicodeFile write (const(T)[] content, bool writeBom = false) 
    217217        { 
    218218                return write (content, FileConduit.ReadWriteCreate, writeBom); 
    …… 
    229229        ***********************************************************************/ 
    230230 
    231         UnicodeFile append (T[] content) 
     231        UnicodeFile append (const(T)[] content) 
    232232        { 
    233233                return write (content, FileConduit.WriteAppending, false); 
    …… 
    242242        ***********************************************************************/ 
    243243 
    244         private final UnicodeFile write (T[] content, FileConduit.Style style, bool writeBom) 
     244        private final UnicodeFile write (const(T)[] content, FileConduit.Style style, bool writeBom) 
    245245        { 
    246246                // convert to external representation (may throw an exeption) 

  • branches/experimental/D2.0/tango/text/Util.d

    r3894 r3895  
    966966******************************************************************************/ 
    967967 
    968 QuoteFruct!(T) quotes(T) (T[] src, T[] set) 
     968QuoteFruct!(T) quotes(T) (const(T)[] src, const(T)[] set) 
    969969{ 
    970970        QuoteFruct!(T) quotes; 
    …… 
    14021402private struct QuoteFruct(T) 
    14031403{ 
    1404         private T[] src; 
    1405         private T[] set; 
    1406  
    1407         int opApply (int delegate (ref T[] token) dg) 
     1404        private const(T)[] src; 
     1405        private const(T)[] set; 
     1406 
     1407        int opApply (int delegate (ref const(T)[] token) dg) 
    14081408        { 
    14091409                int ret, 
    14101410                    mark; 
    1411                 T[] token; 
     1411                const(T)[] token; 
    14121412 
    14131413                if (set.length) 

  • branches/experimental/D2.0/tango/text/convert/UnicodeBom.d

    r3724 r3895  
    168168        ***********************************************************************/ 
    169169 
    170         final void[] encode (T[] content, void[] dst=null, uint* ate=null) 
     170        final void[] encode (const(T)[] content, void[] dst=null, uint* ate=null) 
    171171        { 
    172172                if (settings.test) 
    …… 
    254254        ***********************************************************************/ 
    255255 
    256         static void[] from (T[] x, uint type, void[] dst=null, uint* ate=null) 
     256        static void[] from (const(T)[] x, uint type, void[] dst=null, uint* ate=null) 
    257257        { 
    258258                void[] ret; 
    …… 
    261261                          { 
    262262                          if (type == Utf8) 
    263                               return x; 
     263                              return x.dup; 
    264264 
    265265                          if (type == Utf16) 
    …… 
    273273                          { 
    274274                          if (type == Utf16) 
    275                               return x; 
     275                              return x.dup; 
    276276 
    277277                          if (type == Utf8) 
    …… 
    285285                          { 
    286286                          if (type == Utf32) 
    287                               return x; 
     287                              return x.dup; 
    288288 
    289289                          if (type == Utf8) 
    …… 
    313313                int      type;          // type of element (char/wchar/dchar) 
    314314                Encoding encoding;      // Encoding.xx encoding 
    315                 char[]   bom;           // pattern to match for signature 
     315                Cutf8    bom;           // pattern to match for signature 
    316316                bool     test,          // should we test for this encoding? 
    317317                         endian,        // this encoding have endian concerns? 
    …… 
    326326        {Utf8,  Encoding.Unknown,  null,                    true,  false, false, Encoding.UTF_8N}, 
    327327        {Utf8,  Encoding.UTF_8,    null,                    true,  false, false, Encoding.UTF_8N}, 
    328         {Utf8,  Encoding.UTF_8N,   cast(char[])x"efbbbf",   false}, 
     328        {Utf8,  Encoding.UTF_8N,   cast(Cutf8)x"efbbbf",   false}, 
    329329        {Utf16, Encoding.UTF_16,   null,                    true,  false, false, Encoding.UTF_16BE}, 
    330         {Utf16, Encoding.UTF_16BE, cast(char[])x"feff",     false, true, true}, 
    331         {Utf16, Encoding.UTF_16LE, cast(char[])x"fffe",     false, true}, 
     330        {Utf16, Encoding.UTF_16BE, cast(Cutf8)x"feff",     false, true, true}, 
     331        {Utf16, Encoding.UTF_16LE, cast(Cutf8)x"fffe",     false, true}, 
    332332        {Utf32, Encoding.UTF_32,   null,                    true,  false, false, Encoding.UTF_32BE}, 
    333         {Utf32, Encoding.UTF_32BE, cast(char[])x"0000feff", false, true, true}, 
    334         {Utf32, Encoding.UTF_32LE, cast(char[])x"fffe0000", false, true}, 
     333        {Utf32, Encoding.UTF_32BE, cast(Cutf8)x"0000feff", false, true, true}, 
     334        {Utf32, Encoding.UTF_32LE, cast(Cutf8)x"fffe0000", false, true}, 
    335335        ]; 
    336336 

  • branches/experimental/D2.0/tango/text/xml/DocPrinter.d

    r3887 r3895  
    55        License:   BSD style: $(LICENSE) 
    66 
    7         version:   Initial release: March 2008       
     7        version:   Initial release: March 2008 
    88 
    99        Authors:   Kris 
    …… 
    1717/******************************************************************************* 
    1818 
    19         Simple Document printer, with support for serialization caching  
     19        Simple Document printer, with support for serialization caching 
    2020        where the latter avoids having to generate unchanged sub-trees 
    2121 
    …… 
    2525{ 
    2626        /*********************************************************************** 
    27          
     27 
    2828                Generate a text representation of the document tree 
    2929 
    3030        ***********************************************************************/ 
    31          
    32         final T[] print (Doc doc) 
    33         {        
    34                 T[] content; 
    3531 
    36                 print (doc.root, (T[][] s...){foreach(t; s) content ~= t;}); 
     32        final const(T)[] print (Doc doc) 
     33        { 
     34                const(T)[] content; 
     35 
     36                print (doc.root, (const(T)[][] s...){foreach(t; s) content ~= t;}); 
    3737                return content; 
    3838        } 
    39          
     39 
    4040        /*********************************************************************** 
    41          
    42                 Generate a representation of the given node-subtree  
     41 
     42                Generate a representation of the given node-subtree 
    4343 
    4444        ***********************************************************************/ 
    45          
    46         final void print (Node root, void delegate(T[][]...) emit) 
     45 
     46        final void print (Node root, void delegate(const(T)[][]...) emit) 
    4747        { 
    4848                T[256] tmp; 
    …… 
    5050 
    5151                // ignore whitespace from mixed-model values 
    52                 T[] rawValue (Node node) 
     52                const(T)[] rawValue (Node node) 
    5353                { 
    5454                        foreach (c; node.rawValue) 
    …… 
    7878                                             printNode (n, indent); 
    7979                                    break; 
    80          
     80 
    8181                               case XmlNodeType.Element: 
    8282                                    emit ("\r\n", spaces[0..indent], "<", node.name(tmp)); 
    8383                                    foreach (attr; node.attributes) 
    84                                              emit (` `, attr.name(tmp), `="`, attr.rawValue, `"`);   
     84                                             emit (` `, attr.name(tmp), `="`, attr.rawValue, `"`); 
    8585 
    8686                                    auto value = rawValue (node); 
    …… 
    9292                                       foreach (child; node.children) 
    9393                                                printNode (child, indent + 2); 
    94                                          
     94 
    9595                                       // inhibit newline if we're closing Data 
    9696                                       if (node.lastChild_.type != XmlNodeType.Data) 
    …… 
    9898                                       emit ("</", node.name(tmp), ">"); 
    9999                                       } 
    100                                     else  
     100                                    else 
    101101                                       if (value.length) 
    102102                                           emit (">", value, "</", node.name(tmp), ">"); 
    103103                                       else 
    104                                           emit ("/>");       
     104                                          emit ("/>"); 
    105105                                    break; 
    106          
     106 
    107107                                    // ingore whitespace data in mixed-model 
    108108                                    // <foo> 
    …… 
    115115                                        emit (node.rawValue); 
    116116                                    break; 
    117          
     117 
    118118                               case XmlNodeType.Comment: 
    119119                                    emit ("<!--", node.rawValue, "-->"); 
    120120                                    break; 
    121          
     121 
    122122                               case XmlNodeType.PI: 
    123123                                    emit ("<?", node.rawValue, "?>"); 
    124124                                    break; 
    125          
     125 
    126126                               case XmlNodeType.CData: 
    127127                                    emit ("<![CDATA[", node.rawValue, "]]>"); 
    128128                                    break; 
    129          
     129 
    130130                               case XmlNodeType.Doctype: 
    131131                                    emit ("<!DOCTYPE ", node.rawValue, ">"); 
    …… 
    137137                               } 
    138138                } 
    139          
     139 
    140140                printNode (root, 0); 
    141141        } 

  • branches/experimental/D2.0/tango/text/xml/Document.d

    r3887 r3895  
    11/******************************************************************************* 
    22 
    3         Copyright: Copyright (C) 2007 Aaron Craelius and Kris Bell   
     3        Copyright: Copyright (C) 2007 Aaron Craelius and Kris Bell 
    44                   All rights reserved. 
    55 
    66        License:   BSD style: $(LICENSE) 
    77 
    8         version:   Initial release: February 2008       
     8        version:   Initial release: February 2008 
    99 
    1010        Authors:   Aaron, Kris 
    …… 
    2020/******************************************************************************* 
    2121 
    22         Implements a DOM atop the XML parser, supporting document  
     22        Implements a DOM atop the XML parser, supporting document 
    2323        parsing, tree traversal and ad-hoc tree manipulation. 
    2424 
    25         The DOM API is non-conformant, yet simple and functional in  
    26         style - locate a tree node of interest and operate upon or  
    27         around it. In all cases you will need a document instance to  
    28         begin, whereupon it may be populated either by parsing an  
     25        The DOM API is non-conformant, yet simple and functional in 
     26        style - locate a tree node of interest and operate upon or 
     27        around it. In all cases you will need a document instance to 
     28        begin, whereupon it may be populated either by parsing an 
    2929        existing document or via API manipulation. 
    3030 
    …… 
    4141        is not performed internally, and becomes the responsibility 
    4242        of the client. That is, the client should perform appropriate 
    43         entity transcoding as necessary. Paying the (high) transcoding  
     43        entity transcoding as necessary. Paying the (high) transcoding 
    4444        cost for all documents doesn't seem appropriate. 
    4545 
    …… 
    6262        doc.header; 
    6363 
    64         // attach an element with some attributes, plus  
     64        // attach an element with some attributes, plus 
    6565        // a child element with an attached data value 
    6666        doc.root.element   (null, "element") 
    …… 
    7777        auto doc = new Document!(char); 
    7878 
    79         // attach an element with some attributes, plus  
     79        // attach an element with some attributes, plus 
    8080        // a child element with an attached data value 
    8181        doc.root.element   (null, "element") 
    …… 
    9696        Note that path queries are temporal - they do not retain content 
    9797        across mulitple queries. That is, the lifetime of a query result 
    98         is limited unless you explicitly copy it. For example, this will  
     98        is limited unless you explicitly copy it. For example, this will 
    9999        fail: 
    100100        --- 
    …… 
    103103        --- 
    104104 
    105         The above will lose elements because the associated document reuses  
     105        The above will lose elements because the associated document reuses 
    106106        node space for subsequent queries. In order to retain results, do this: 
    107107        --- 
    …… 
    116116        --- 
    117117 
    118         Typical usage tends to follow the following pattern, Where each query  
     118        Typical usage tends to follow the following pattern, Where each query 
    119119        result is processed before another is initiated: 
    120120        --- 
    …… 
    124124                } 
    125125        --- 
    126              
     126 
    127127*******************************************************************************/ 
    128128 
    …… 
    140140 
    141141        /*********************************************************************** 
    142          
     142 
    143143                Construct a DOM instance. The optional parameter indicates 
    144144                the initial number of nodes assigned to the freelist 
    …… 
    159159 
    160160        /*********************************************************************** 
    161          
     161 
    162162                Return an xpath handle to query this document. This starts 
    163163                at the document root. 
    …… 
    166166 
    167167        ***********************************************************************/ 
    168          
     168 
    169169        final XmlPath!(T).NodeSet query () 
    170170        { 
    …… 
    173173 
    174174        /*********************************************************************** 
    175          
    176                 Reset the freelist. Subsequent allocation of document nodes  
     175 
     176                Reset the freelist. Subsequent allocation of document nodes 
    177177                will overwrite prior instances. 
    178178 
    179179        ***********************************************************************/ 
    180          
     180 
    181181        final Document reset () 
    182182        { 
    183                 root.lastChild_ =  
     183                root.lastChild_ = 
    184184                root.firstChild_ = null; 
    185185                freelists = 0; 
    …… 
    194194 
    195195        /*********************************************************************** 
    196          
     196 
    197197               Add an XML header to the document root 
    198198 
    199199        ***********************************************************************/ 
    200          
    201         final Document header (T[] encoding = null) 
     200 
     201        final Document header (const(T)[] encoding = null) 
    202202        { 
    203203                if (encoding.length) 
    …… 
    211211 
    212212        /*********************************************************************** 
    213          
    214                 Parse the given xml content, which will reuse any existing  
     213 
     214                Parse the given xml content, which will reuse any existing 
    215215                node within this document. The resultant tree is retrieved 
    216216                via the document 'root' attribute 
    217217 
    218218        ***********************************************************************/ 
    219          
    220         final void parse(T[] xml) 
     219 
     220        final void parse(const(T)[] xml) 
    221221        { 
    222222                reset; 
    …… 
    225225                uint defNamespace; 
    226226 
    227                 while (true)  
     227                while (true) 
    228228                      { 
    229229                      auto p = text.point; 
    230                       switch (super.next)  
     230                      switch (super.next) 
    231231                             { 
    232232                             case XmlTokenType.EndElement: 
    …… 
    234234                                  assert (cur.parent_); 
    235235                                  cur.end = text.point; 
    236                                   cur = cur.parent_;                       
     236                                  cur = cur.parent_; 
    237237                                  break; 
    238          
     238 
    239239                             case XmlTokenType.Data: 
    240240version (discrete) 
    …… 
    254254} 
    255255                                  break; 
    256          
     256 
    257257                             case XmlTokenType.StartElement: 
    258258                                  auto node = allocate; 
    …… 
    262262                                  node.localName = super.localName; 
    263263                                  node.start = p; 
    264                                  
     264 
    265265                                  // inline append 
    266                                   if (cur.lastChild_)  
     266                                  if (cur.lastChild_) 
    267267                                     { 
    268268                                     cur.lastChild_.nextSibling_ = node; 
    …… 
    270270                                     cur.lastChild_ = node; 
    271271                                     } 
    272                                   else  
     272                                  else 
    273273                                     { 
    274274                                     cur.firstChild_ = node; 
    …… 
    277277                                  cur = node; 
    278278                                  break; 
    279          
     279 
    280280                             case XmlTokenType.Attribute: 
    281281                                  auto attr = allocate; 
    …… 
    286286                                  cur.attrib (attr); 
    287287                                  break; 
    288          
     288 
    289289                             case XmlTokenType.PI: 
    290290                                  cur.pi (super.rawValue, p[0..text.point-p]); 
    291291                                  break; 
    292          
     292 
    293293                             case XmlTokenType.Comment: 
    294294                                  cur.comment (super.rawValue); 
    295295                                  break; 
    296          
     296 
    297297                             case XmlTokenType.CData: 
    298298                                  cur.cdata (super.rawValue); 
    299299                                  break; 
    300          
     300 
    301301                             case XmlTokenType.Doctype: 
    302302                                  cur.doctype (super.rawValue); 
    303303                                  break; 
    304          
     304 
    305305                             case XmlTokenType.Done: 
    306306                                  return; 
    …… 
    311311                      } 
    312312        } 
    313          
     313 
    314314        /*********************************************************************** 
    315          
     315 
    316316                allocate a node from the freelist 
    317317 
    …… 
    327327                p.document = this; 
    328328                p.parent_ = 
    329                 p.prevSibling_ =  
    330                 p.nextSibling_ =  
     329                p.prevSibling_ = 
     330                p.nextSibling_ = 
    331331                p.firstChild_ = 
    332                 p.lastChild_ =  
     332                p.lastChild_ = 
    333333                p.firstAttr_ = 
    334334                p.lastAttr_ = null; 
    …… 
    338338 
    339339        /*********************************************************************** 
    340          
     340 
    341341                allocate a node from the freelist 
    342342 
    …… 
    355355 
    356356        /*********************************************************************** 
    357          
    358                 Fruct support for nodes. A fruct is a low-overhead  
     357 
     358                Fruct support for nodes. A fruct is a low-overhead 
    359359                mechanism for capturing context relating to an opApply 
    360360 
    361361        ***********************************************************************/ 
    362          
     362 
    363363        private struct Visitor 
    364364        { 
    365365                private Node node; 
    366          
    367                 /*************************************************************** 
    368                  
     366 
     367                /*************************************************************** 
     368 
    369369                        traverse sibling nodes 
    370370 
    371371                ***************************************************************/ 
    372          
     372 
    373373                int opApply (int delegate(inout Node) dg) 
    374374                { 
    …… 
    377377                        while (cur) 
    378378                              { 
    379                               if ((ret = dg (cur)) != 0)  
     379