Changeset 291

Show
Ignore:
Timestamp:
04/27/08 16:19:26 (7 months ago)
Author:
JarrettBillingsley
Message:

Closes #50.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/v2/minid/baselib.d

    r278 r291  
    3434import tango.io.Print; 
    3535import tango.io.Stdout; 
     36import tango.stdc.ctype; 
    3637import utf = tango.text.convert.Utf; 
    3738 
     
    4041static: 
    4142    private MDString[] typeStrings; 
     43    private MDString toStringStr; 
    4244 
    4345    static this() 
     
    4749        for(uint i = MDValue.Type.min; i <= MDValue.Type.max; i++) 
    4850            typeStrings[i] = new MDString(MDValue.typeString(cast(MDValue.Type)i)); 
     51             
     52        toStringStr = new MDString("toString"d); 
    4953    } 
    5054 
     
    109113        globals["write"d] =           new MDClosure(globals.ns, &write,                 "write"); 
    110114        globals["readln"d] =          new MDClosure(globals.ns, &readln,                "readln"); 
     115        globals["dumpVal"d] =         new MDClosure(globals.ns, &dumpVal,               "dumpVal"); 
    111116 
    112117        // Dynamic compilation stuff 
     
    228233 
    229234        Stdout.flush; 
     235        return 0; 
     236    } 
     237 
     238    int dumpVal(MDState s, uint numParams) 
     239    { 
     240        void outputRepr(ref MDValue v) 
     241        { 
     242            if(s.hasPendingHalt()) 
     243                throw new MDHaltException(); 
     244     
     245            static bool[MDBaseObject] shown; 
     246     
     247            void escape(dchar c) 
     248            { 
     249                switch(c) 
     250                { 
     251                    case '\'': Stdout(`\'`); break; 
     252                    case '\"': Stdout(`\"`); break; 
     253                    case '\\': Stdout(`\\`); break; 
     254                    case '\a': Stdout(`\a`); break; 
     255                    case '\b': Stdout(`\b`); break; 
     256                    case '\f': Stdout(`\f`); break; 
     257                    case '\n': Stdout(`\n`); break; 
     258                    case '\r': Stdout(`\r`); break; 
     259                    case '\t': Stdout(`\t`); break; 
     260                    case '\v': Stdout(`\v`); break; 
     261     
     262                    default: 
     263                        if(c <= 0x7f && isprint(c)) 
     264                            Stdout(c); 
     265                        else if(c <= 0xFFFF) 
     266                            Stdout.format("\\u{:x4}", cast(uint)c); 
     267                        else 
     268                            Stdout.format("\\U{:x8}", cast(uint)c); 
     269                        break; 
     270                } 
     271            } 
     272             
     273            void delegate(MDArray) outputArray; 
     274            void delegate(MDTable) outputTable; 
     275     
     276            void outputArray_(MDArray a) 
     277            { 
     278                if(a in shown) 
     279                { 
     280                    Stdout("[...]"); 
     281                    return; 
     282                } 
     283     
     284                shown[a] = true; 
     285                 
     286                scope(exit) 
     287                    shown.remove(a); 
     288     
     289                Stdout('['); 
     290     
     291                if(a.length > 0) 
     292                { 
     293                    outputRepr(*a[0]); 
     294     
     295                    for(int i = 1; i < a.length; i++) 
     296                    { 
     297                        if(s.hasPendingHalt()) 
     298                            throw new MDHaltException(); 
     299     
     300                        Stdout(", "); 
     301                        outputRepr(*a[i]); 
     302                    } 
     303                } 
     304     
     305                Stdout(']'); 
     306            } 
     307     
     308            void outputTable_(MDTable t) 
     309            { 
     310                if(t in shown) 
     311                { 
     312                    Stdout("{...}"); 
     313                    return; 
     314                } 
     315     
     316                shown[t] = true; 
     317     
     318                Stdout('{'); 
     319     
     320                if(t.length > 0) 
     321                { 
     322                    if(t.length == 1) 
     323                    { 
     324                        foreach(k, v; t) 
     325                        { 
     326                            if(s.hasPendingHalt()) 
     327                                throw new MDHaltException(); 
     328                     
     329                            Stdout('['); 
     330                            outputRepr(k); 
     331                            Stdout("] = "); 
     332                            outputRepr(v); 
     333                        } 
     334                    } 
     335                    else 
     336                    { 
     337                        bool first = true; 
     338     
     339                        foreach(k, v; t) 
     340                        { 
     341                            if(first) 
     342                                first = !first; 
     343                            else 
     344                                Stdout(", "); 
     345                                 
     346                            if(s.hasPendingHalt()) 
     347                                throw new MDHaltException(); 
     348     
     349                            Stdout('['); 
     350                            outputRepr(k); 
     351                            Stdout("] = "); 
     352                            outputRepr(v); 
     353                        } 
     354                    } 
     355                } 
     356     
     357                Stdout('}'); 
     358 
     359                shown.remove(t); 
     360            } 
     361     
     362            outputArray = &outputArray_; 
     363            outputTable = &outputTable_; 
     364     
     365            if(v.isString) 
     366            { 
     367                Stdout('"'); 
     368                 
     369                auto s = v.as!(MDString); 
     370     
     371                for(int i = 0; i < s.length; i++) 
     372                    escape(s[i]); 
     373     
     374                Stdout('"'); 
     375            } 
     376            else if(v.isChar) 
     377            { 
     378                Stdout("'"); 
     379                escape(v.as!(dchar)); 
     380                Stdout("'"); 
     381            } 
     382            else if(v.isArray) 
     383                outputArray(v.as!(MDArray)); 
     384            else if(v.isTable) 
     385            { 
     386                if(s.hasMethod(v, toStringStr)) 
     387                    Stdout(s.valueToString(v)); 
     388                else 
     389                    outputTable(v.as!(MDTable)); 
     390            } 
     391            else 
     392                Stdout(s.valueToString(v)); 
     393        } 
     394 
     395        outputRepr(s.getParam(0u)); 
    230396        return 0; 
    231397    } 
  • branches/v2/minid/commandline.d

    r277 r291  
    7979    private Print!(char) mOutput; 
    8080    private LineIterator!(char) mInput; 
    81     private MDString mToStringStr; 
    8281 
    8382    public this(Print!(char) output, InputStream inputStream) 
     
    8584        mOutput = output; 
    8685        mInput = new LineIterator!(char)(inputStream); 
    87         mToStringStr = new MDString("toString"d); 
    8886    } 
    8987 
     
    107105    } 
    108106 
    109     private void outputRepr(MDState state, ref MDValue v) 
    110     { 
    111         if(state.hasPendingHalt()) 
    112             throw new MDHaltException(); 
    113  
    114         static bool[MDBaseObject] shown; 
    115  
    116         void escape(dchar c) 
    117         { 
    118             switch(c) 
    119             { 
    120                 case '\'': mOutput(`\'`); break; 
    121                 case '\"': mOutput(`\"`); break; 
    122                 case '\\': mOutput(`\\`); break; 
    123                 case '\a': mOutput(`\a`); break; 
    124                 case '\b': mOutput(`\b`); break; 
    125                 case '\f': mOutput(`\f`); break; 
    126                 case '\n': mOutput(`\n`); break; 
    127                 case '\r': mOutput(`\r`); break; 
    128                 case '\t': mOutput(`\t`); break; 
    129                 case '\v': mOutput(`\v`); break; 
    130  
    131                 default: 
    132                     if(c <= 0x7f && isprint(c)) 
    133                         mOutput(c); 
    134                     else if(c <= 0xFFFF) 
    135                         mOutput.format("\\u{:x4}", cast(uint)c); 
    136                     else 
    137                         mOutput.format("\\U{:x8}", cast(uint)c); 
    138                     break; 
    139             } 
    140         } 
    141          
    142         void delegate(MDArray) outputArray; 
    143         void delegate(MDTable) outputTable; 
    144  
    145         void outputArray_(MDArray a) 
    146         { 
    147             if(a in shown) 
    148             { 
    149                 mOutput("[...]"); 
    150                 return; 
    151             } 
    152              
    153             shown[a] = true; 
    154  
    155             mOutput('['); 
    156  
    157             if(a.length > 0) 
    158             { 
    159                 outputRepr(state, *a[0]); 
    160                  
    161                 for(int i = 1; i < a.length; i++) 
    162                 { 
    163                     if(state.hasPendingHalt()) 
    164                         throw new MDHaltException(); 
    165  
    166                     mOutput(", "); 
    167                     outputRepr(state, *a[i]); 
    168                 } 
    169             } 
    170  
    171             mOutput(']'); 
    172              
    173             shown.remove(a); 
    174         } 
    175  
    176         void outputTable_(MDTable t) 
    177         { 
    178             if(t in shown) 
    179             { 
    180                 mOutput("{...}"); 
    181                 return; 
    182             } 
    183  
    184             shown[t] = true; 
    185  
    186             mOutput('{'); 
    187  
    188             if(t.length > 0) 
    189             { 
    190                 if(t.length == 1) 
    191                 { 
    192                     foreach(k, v; t) 
    193                     { 
    194                         if(state.hasPendingHalt()) 
    195                             throw new MDHaltException(); 
    196                  
    197                         mOutput('['); 
    198                         outputRepr(state, k); 
    199                         mOutput("] = "); 
    200                         outputRepr(state, v); 
    201                     } 
    202                 } 
    203                 else 
    204                 { 
    205                     bool first = true; 
    206  
    207                     foreach(k, v; t) 
    208                     { 
    209                         if(first) 
    210                             first = !first; 
    211                         else 
    212                             mOutput(", "); 
    213                              
    214                         if(state.hasPendingHalt()) 
    215                             throw new MDHaltException(); 
    216  
    217                         mOutput('['); 
    218                         outputRepr(state, k); 
    219                         mOutput("] = "); 
    220                         outputRepr(state, v); 
    221                     } 
    222                 } 
    223             } 
    224  
    225             mOutput('}'); 
    226  
    227             shown.remove(t); 
    228         } 
    229  
    230         outputArray = &outputArray_; 
    231         outputTable = &outputTable_; 
    232  
    233         if(v.isString) 
    234         { 
    235             mOutput('"'); 
    236              
    237             auto s = v.as!(MDString); 
    238  
    239             for(int i = 0; i < s.length; i++) 
    240                 escape(s[i]); 
    241  
    242             mOutput('"'); 
    243         } 
    244         else if(v.isChar) 
    245         { 
    246             mOutput("'"); 
    247             escape(v.as!(dchar)); 
    248             mOutput("'"); 
    249         } 
    250         else if(v.isArray) 
    251             outputArray(v.as!(MDArray)); 
    252         else if(v.isTable) 
    253         { 
    254             if(state.hasMethod(v, mToStringStr)) 
    255                 mOutput(state.valueToString(v)); 
    256             else 
    257                 outputTable(v.as!(MDTable)); 
    258         } 
    259         else 
    260             mOutput(state.valueToString(v)); 
    261     } 
    262  
    263107    void run(char[][] args = null, MDContext ctx = null) 
    264108    { 
     
    389233                }, "exit" 
    390234            ); 
    391  
    392             MDClosure reprFunc = ctx.newClosure 
    393             ( 
    394                 (MDState s, uint numParams) 
    395                 { 
    396                     outputRepr(s, s.getParam(0u)); 
    397                      
    398                     if(numParams == 1 || (numParams > 1 && s.getParam!(bool)(1))) 
    399                         mOutput.newline; 
    400  
    401                     return 0; 
    402                 }, "repr" 
    403             ); 
    404235             
    405             ctx.globals["repr"d] = reprFunc
     236            auto reprFunc = ctx.globals["dumpVal"d]
    406237 
    407238            mOutput("Use the \"exit()\" function to end.").newline;