Changeset 5281 for lang/javascript

Show
Ignore:
Timestamp:
01/22/08 17:05:02 (5 years ago)
Author:
nshuyo
Message:

lang/javascript/jsruby: deleted experimental code and files

Location:
lang/javascript/jsruby/branches/async
Files:
2 removed
5 modified

Legend:

Unmodified
Added
Removed

  • lang/javascript/jsruby/branches/async/check.html

    r4491 r5281  
    1616<body> 
    1717 
    18 <h1>JSRuby Check - Ruby for Javascript</h1> 
     18<h1>JSRuby Check</h1> 
    1919 
    2020 
    2121<textarea id='script_area' rows='8' cols='70'> 
    22 (1..10).each{|x| puts if x % 2 == 0 then "even" else "odd" end } 
    23 </textarea> 
    24 <input type='button' value='parse & execute' onclick='javascript:execute();' /><br /> 
     22o=$document.getElementById('console_area') 
     231.upto(10000) do |x| 
     24  o.innerHTML = x 
     25  sleep 100 
     26end 
     27</textarea><br /> 
     28<input type='button' value='execute' onclick='javascript:execute();' /> |  
     29<input type='button' value='async exec' onclick='javascript:execute_async();' /> 
     30<input type='button' value='stop' onclick='javascript:stop();' /> 
     31<input type='button' value='step' onclick='javascript:step();' /><br /> 
    2532&darr; parse 
    2633<div style='border:1px solid black;' id='nodetree_area'>(parsing...)</div> 
    … …  
    3542var parser = new RubyEngine.Parser(); 
    3643var ruby = new RubyEngine.Interpreter(); 
     44//ruby.writeStdout = function(st){alert(st);} 
    3745 
    38 function execute() { 
    39         $("console_area").innerHTML = ''; 
    40  
     46function step() { 
     47        if (ruby.command.length==0) { 
     48                var text = $("script_area").value.replace(/^\n+/, "").replace(/([^\n])$/, "$&\n") 
     49                var nodetree = parser.parse(text); 
     50                var div = $("nodetree_area") 
     51                if(FIREFOX){div.textContent = nodetree.toSource();}else{div.innerText = nodetree.toSource();} 
     52    ruby.compile(nodetree); 
     53  } 
     54        ruby.loop(false); 
     55        if(typeof(console)=="object"){ 
     56                console.dir(ruby.command); 
     57                console.dir(ruby.stack); 
     58        } 
     59} 
     60function parse() { 
    4161        var text = $("script_area").value.replace(/^\n+/, "").replace(/([^\n])$/, "$&\n") 
    4262        var nodetree = parser.parse(text); 
    4363        var div = $("nodetree_area") 
    4464        if(FIREFOX){div.textContent = nodetree.toSource();}else{div.innerText = nodetree.toSource();} 
    45  
    46         ruby.run(nodetree); 
     65        return text; 
     66} 
     67function execute() { 
     68        $("console_area").innerHTML = ''; 
     69        ruby.exec(parse()); 
    4770        $("console_area").innerHTML = ruby.stdout.replace(/\n/g,"<br />") 
     71} 
     72function execute_async() { 
     73        ruby.exec_async(parse()); 
     74} 
     75function stop() { 
     76        ruby.command=[]; 
    4877} 
    4978</script> 
    5079 
    51  
    52  
    53 <h1>JSirb - JSRuby Console</h1> 
    54 <div id="jsirb" style="width:640px;height:400px;overflow:auto;border:1px solid #333;"></div><br /> 
    55 <input id="jsirbinput" style="width:640px;" /> 
    56  
    57 <script type="text/javascript"> 
    58 String.prototype.toh = function(){ return this.replace(/</g, "&lt;").replace(/\n/g, "<br />"); } 
    59  
    60 function cmdentry(evt) { 
    61         if (!FIREFOX) evt = event; 
    62         if (evt.keyCode==13) { 
    63                 var jsirb = $('jsirb'); 
    64                 var cmd = $('jsirbinput').value; 
    65                 var code = parser.parse(cmd); 
    66                 if (code && parser.isfull()) { 
    67                         ruby.stdout = ""; 
    68                         var ret = ruby.run(code); 
    69                         if (typeof(ret)=="string") ret = ret.toh(); 
    70                         jsirb.innerHTML += cmd.toh() + "<br />" + ruby.stdout.toh() + "=> " + ret + "<br />"; 
    71                 } else { 
    72                         jsirb.innerHTML += cmd.toh() + "<br />" + "Syntax error.<br />"; 
    73                 } 
    74                 var h = jsirb.scrollHeight - jsirb.clientHeight; 
    75                 if (h>0) jsirb.scrollTop = h; 
    76  
    77                 $('jsirbinput').value = ''; 
    78         } 
    79  
    80 } 
    81 $('jsirbinput').onkeypress = cmdentry; 
    82 </script> 
    83  
    84  
    85 <div style="float:right">(c)2007 Nakatani Shuyo / Cybozu Labs, inc.</div> 
     80<div style="float:right">(c)2008 Nakatani Shuyo / Cybozu Labs, inc.</div> 
    8681 
    8782</body> 

  • lang/javascript/jsruby/branches/async/src/builtinmethods.js

    r4916 r5281  
    1212  }, 
    1313  "*eval": function(args) { 
    14     var src = this.run(args[0]).str; 
     14    var src = args[0].str; 
    1515    var nodes = this.parser.parse(src); 
    1616    return this.run(nodes); 
    … …  
    1818  "puts": function(args) { 
    1919    if (args && args.length > 0) { 
    20       for(var jdx=0;jdx<args.length;jdx++) { 
    21         this.writeStdout(this.run(args[jdx]) + "\n"); 
    22       } 
     20      for(var jdx=0;jdx<args.length;jdx++) this.writeStdout(args[jdx] + "\n"); 
    2321    } else { 
    2422      this.writeStdout("\n"); 
    … …  
    2725  "if": function(args) { 
    2826    for(var idx=0;idx<args.length;idx+=2) { 
    29       var cond = this.run(args[idx]); 
     27      var cond = args[idx]; 
    3028      if (cond || cond===0 || cond==="") return this.run(args[idx+1]); 
    3129    } 
    3230  }, 
    3331  "*let": function(args) { 
    34     return this.scope.substitute(args[0].name, this.run(args[1])); 
     32    return this.scope.substitute(args[0].name, args[1]); 
    3533  }, 
    3634  "*concat": function(args) { 
    3735    var st=""; 
    3836    if (args && args.length > 0) { 
    39       for(var i=0;i<args.length;i++) st+=this.run(args[i]).toString(); 
     37      for(var i=0;i<args.length;i++) st+=args[i].toString(); 
    4038    } 
    4139    return new RubyEngine.RubyObject.String(st); 
     40  }, 
     41  "sleep": function(args) { 
     42    this.sleep = args[0]; 
    4243  }, 
    4344  "p": function(args) { 
    4445    if (args && args.length > 0) { 
    4546      for (var i=0; i<args.length; i++) { 
    46         this.writeStdout(this.run(args[i]).toSource() + "\n"); 
     47        this.writeStdout(args[i].toSource() + "\n"); 
    4748      } 
    4849    } 

  • lang/javascript/jsruby/branches/async/src/builtinobjects.js

    r5005 r5281  
    8787  }, 
    8888  "upto": function(self, args, block) { 
    89     if (!block) return null; 
    90     var varname, to=this.run(args[0]).num; 
    91     if (block.vars) varname = block.vars[0].name; 
    92     this.scope.pushLevel(); 
    93     for(var i=self.num; i<=to; i++) { 
    94         if (varname) this.scope.substitute(varname, new RubyEngine.RubyObject.Numeric(i)); 
    95         this.run(block.block); 
    96     } 
    97     this.scope.popLevel(); 
     89    if (!block) return null;  // TODO: error 
     90    var b = new RubyEngine.Node.BlockIterator(block, function(b){ 
     91      if(b.now<=b.to) { 
     92        if(b.varname) this.scope.substitute(b.varname, new RubyEngine.RubyObject.Numeric(b.now)); 
     93        b.now++; 
     94        return b; 
     95      } 
     96    }); 
     97    b.to=args[0].num; 
     98    b.now=self.num; 
     99    if (block.vars) b.varname = block.vars[0].name; 
     100    this.command.push(b); 
    98101    return self; 
    99102  } 
    … …  
    320323  }, 
    321324  "method_missing": function(self, args, block) { 
    322     var name = this.run(args[0]).str; 
     325    var name = args[0].str; 
    323326    if (args.length==1) { 
    324327      return RubyEngine.RubyObject.js2r(self.obj[name]); 
    325328    } else if (name.charAt(name.length-1) == "=") { 
    326       var v=this.run(args[1]) 
    327       self.obj[name.slice(0, name.length-1)] = v.toValue(); 
    328       return v; 
     329      self.obj[name.slice(0, name.length-1)] = args[1].toValue(); 
     330      return args[1]; 
    329331    } else { 
    330332      if (name in self.obj) { 
    331333        if (RubyEngine.FIREFOX || RubyEngine.OPERA) { // Firefox, Opera 
    332334          var jsargs = []; 
    333           for (var i=1;i<args.length;i++) jsargs.push( this.run(args[i]).toValue() ); 
     335          for (var i=1;i<args.length;i++) jsargs.push( args[i].toValue() ); 
    334336          return RubyEngine.RubyObject.js2r(self.obj[name].apply(self.obj, jsargs)); 
    335337        } else { // others 
    336338          var jsargs = []; 
    337           for (var i=1;i<args.length;i++) jsargs.push( "this.run(args["+i+"]).toValue()" ); 
     339          for (var i=1;i<args.length;i++) jsargs.push( "args["+i+"].toValue()" ); 
    338340          return RubyEngine.RubyObject.js2r( eval( "self.obj[name]("+jsargs.join(',')+")" )); 
    339341        } 
    … …  
    342344      } 
    343345    } 
    344  } 
     346  } 
    345347} 
    346348 

  • lang/javascript/jsruby/branches/async/src/interpreter.js

    r4448 r5281  
    7474        this.stdout = ""; 
    7575        this.parser = new RubyEngine.Parser(); 
     76        this.command = []; 
     77        this.stack = [null]; 
    7678} 
    7779RubyEngine.Interpreter.prototype = { 
    … …  
    8082  exec: function(node){ 
    8183    if (typeof(node)=="string") node = this.parser.parse(node); 
    82     var ret = this.run(node); 
     84    this.compile(node); 
     85    while(this.command.length>0) this.loop(false); 
     86    var ret = this.stack.pop(); 
    8387    if (typeof(ret)=="object" && "toValue" in ret) return ret.toValue(); 
    8488    return ret; 
    8589  }, 
    8690 
    87   run: function(node){ 
    88 //console.log(node.toSource());console.trace();if(!confirm("continue?")) exit(); 
    89         var ret = null; 
    90         if (Array.prototype.isPrototypeOf(node)) { 
    91         for (var idx=0;idx<node.length;idx++) { 
    92                         ret = this.run(node[idx]); 
    93                 } 
    94  
    95         } else if (RubyEngine.Node.Variable.prototype.isPrototypeOf(node)) { 
    96                 ret = this.scope.reference(node.name); 
    97  
    98         } else if (RubyEngine.Node.Expression.prototype.isPrototypeOf(node)) { 
    99                 ret = this.calcExpr(node); 
    100  
    101         } else if (RubyEngine.Node.Method.prototype.isPrototypeOf(node) || RubyEngine.Node.Ref.prototype.isPrototypeOf(node)) { 
    102       var t = node.type; 
    103                 if (t=="M" && node.target!=null) { 
    104                         ret = this.objectMethod(node); 
    105                 } else { 
    106         return this.scope.call.apply(this, [node.name, node.args, node.block, (t=="R")]); 
    107       } 
    108       return ret; 
    109         } else { 
    110                 ret = node; 
    111         } 
    112         return ret; 
    113   }, 
    114   calcExpr: function(node){ 
    115         var calclist = node.list; 
    116         var stk = []; 
    117         for (var idx=0;idx<calclist.length;idx++) { 
    118                 var x = calclist[idx]; 
    119                 if (Array.prototype.isPrototypeOf(x)) { 
    120                         stk.push( this.run(x) ); 
    121                 } else if (RubyEngine.Node.Expression.prototype.isPrototypeOf(x)) { 
    122                         stk.push( this.calcExpr(x) ); 
    123                 } else if (RubyEngine.Node.Variable.prototype.isPrototypeOf(x)) { 
    124                         stk.push( this.scope.reference(x.name) ); 
    125                 } else if (RubyEngine.Node.Ref.prototype.isPrototypeOf(x)) { 
    126                         stk.push( this.run(x) ); 
    127                 } else if (RubyEngine.Node.Method.prototype.isPrototypeOf(x)) { 
    128                         stk.push( this.run(x) ); 
    129                 } else if (RubyEngine.Node.Operator.prototype.isPrototypeOf(x)) { 
    130                         switch (x.name) { 
    131                         case "-@": 
    132                                 stk.push(stk.pop().neg()); 
    133                                 break; 
    134                         case "+": 
    135                                 var a = stk.pop(); 
    136                                 stk.push(stk.pop().add(a)); 
    137                                 break; 
    138                         case "-": 
    139                                 var a = stk.pop(); 
    140                                 stk.push(stk.pop().sub(a)); 
    141                                 break; 
    142                         case "*": 
    143                                 var a = stk.pop(); 
    144                                 stk.push(stk.pop().mul(a)); 
    145                                 break; 
    146                         case "/": 
    147                                 var a = stk.pop(); 
    148                                 stk.push(stk.pop().div(a)); 
    149                                 break; 
    150                         case "%": 
    151                                 var a = stk.pop(); 
    152                                 stk.push(stk.pop().mod(a)); 
    153                                 break; 
    154                         case "**": 
    155                                 var a = stk.pop(); 
    156                                 stk.push(stk.pop().pow(a)); 
    157                                 break; 
    158                         case "..": 
    159                                 var to = stk.pop(); 
    160                                 var from = stk.pop(); 
    161           stk.push(new RubyEngine.RubyObject.Range(from.num, to.num)); 
    162                                 break; 
    163                         case "==": 
    164                                 var a = stk.pop(); 
    165                                 stk.push(stk.pop().eql(a)); 
    166                                 break; 
    167                         case "<": 
    168                                 var a = stk.pop(); 
    169                                 stk.push(stk.pop().cmp(a)<0); 
    170                                 break; 
    171                         case ">": 
    172                                 var a = stk.pop(); 
    173                                 stk.push(stk.pop().cmp(a)>0); 
    174                                 break; 
    175                         case ">=": 
    176                                 var a = stk.pop(); 
    177                                 stk.push(stk.pop().cmp(a)>=0); 
    178                                 break; 
    179                         case "<<": 
    180                                 var a = stk.pop(); 
    181                                 stk.push(stk.pop().sft(a)); 
    182                                 break; 
    183                         } 
    184                 } else { 
    185                         stk.push(x); 
    186                 } 
    187         } 
    188         return stk.pop(); 
     91  exec_async: function(node){ 
     92    if (typeof(node)=="string") node = this.parser.parse(node); 
     93    this.compile(node); 
     94    this.loop(); 
     95  }, 
     96 
     97  compile: function(x) { 
     98                if (Array.prototype.isPrototypeOf(x)) { 
     99      if (x.length==1) { 
     100        this.stack.pop();  // anxious... 
     101        this.compile(x[0]); 
     102      } else { 
     103                        this.command.push( new RubyEngine.Node.Iterator(x) ); 
     104                        } 
     105                } else if (RubyEngine.Node.Expression.prototype.isPrototypeOf(x)) { 
     106        var list = x.list; 
     107        for (var i=list.length-1;i>=0;i--) this.compile(list[i]); 
     108                } else if (RubyEngine.Node.Method.prototype.isPrototypeOf(x)) { 
     109        this.command.push(x); 
     110      if(x.target) this.compile(x.target); 
     111        var list = x.args; 
     112        for (var i=0;i<list.length;i++) this.compile(list[i]); 
     113                        this.command.push( "end of arguments" ); 
     114                } else { 
     115                        this.command.push( x ); 
     116                } 
     117  }, 
     118 
     119  loop: function(){ 
     120    this.sleep=0; 
     121    var stk=this.stack; 
     122    var x=this.command.pop(), y; 
     123                if (RubyEngine.Node.Iterator.prototype.isPrototypeOf(x)) { 
     124      if ((y=x.next())!=undefined) { 
     125        this.stack.pop();  // anxious... 
     126        this.command.push( x ); 
     127        this.compile(y); 
     128      } 
     129                } else if (RubyEngine.Node.Method.prototype.isPrototypeOf(x)) { 
     130      var obj; 
     131      if (x.target) obj=stk.pop(); 
     132      var args=[], y; 
     133      while((y=stk.pop())!="end of arguments") args.push(y); 
     134      if (obj) { 
     135        var methods = obj.clz.methods; 
     136        if (x.name in methods) { 
     137          stk.push(obj.clz.methods[x.name].apply(this, [obj, args, x.block])); 
     138        } else { 
     139          args.unshift(new RubyEngine.RubyObject.String(x.name)); 
     140          stk.push(obj.clz.methods["method_missing"].apply(this, [obj, args, x.block])); 
     141        } 
     142      } else { 
     143        stk.push(RubyEngine.Interpreter.KernelMethod[x.name].apply(this, [args])); 
     144      } 
     145                } else if (RubyEngine.Node.BlockIterator.prototype.isPrototypeOf(x)) { 
     146      x.next.apply(this, [x]); 
     147                } else if (RubyEngine.Node.Ref.prototype.isPrototypeOf(x)) { 
     148      stk.push(this.scope.reference(x.name)); 
     149                } else if (RubyEngine.Node.Operator.prototype.isPrototypeOf(x)) { 
     150                        switch (x.name) { 
     151                        case "-@": 
     152                                stk.push(stk.pop().neg()); 
     153                                break; 
     154                        case "+": 
     155                                var a = stk.pop(); 
     156                                stk.push(stk.pop().add(a)); 
     157                                break; 
     158                        case "-": 
     159                                var a = stk.pop(); 
     160                                stk.push(stk.pop().sub(a)); 
     161                                break; 
     162                        case "*": 
     163                                var a = stk.pop(); 
     164                                stk.push(stk.pop().mul(a)); 
     165                                break; 
     166                        case "/": 
     167                                var a = stk.pop(); 
     168                                stk.push(stk.pop().div(a)); 
     169                                break; 
     170                        case "%": 
     171                                var a = stk.pop(); 
     172                                stk.push(stk.pop().mod(a)); 
     173                                break; 
     174                        case "**": 
     175                                var a = stk.pop(); 
     176                                stk.push(stk.pop().pow(a)); 
     177                                break; 
     178                        case "..": 
     179                                var to = stk.pop(); 
     180                                var from = stk.pop(); 
     181        stk.push(new RubyEngine.RubyObject.Range(from.num, to.num)); 
     182                                break; 
     183                        case "==": 
     184                                var a = stk.pop(); 
     185                                stk.push(stk.pop().eql(a)); 
     186                                break; 
     187                        case "<": 
     188                                var a = stk.pop(); 
     189                                stk.push(stk.pop().cmp(a)<0); 
     190                                break; 
     191                        case ">": 
     192                                var a = stk.pop(); 
     193                                stk.push(stk.pop().cmp(a)>0); 
     194                                break; 
     195                        case ">=": 
     196                                var a = stk.pop(); 
     197                                stk.push(stk.pop().cmp(a)>=0); 
     198                                break; 
     199                        case "<<": 
     200                                var a = stk.pop(); 
     201                                stk.push(stk.pop().sft(a)); 
     202                                break; 
     203                        } 
     204                } else if(x=="pushLevel") { 
     205      this.scope.pushLevel(); 
     206                } else if(x=="popLevel") { 
     207      this.scope.popLevel(); 
     208                } else { 
     209                        stk.push(x); 
     210                } 
     211 
     212    if(arguments.length==0 && this.command.length>0){ 
     213      var r=this; 
     214      setTimeout(function(){r.loop.apply(r);}, r.sleep); 
     215    } 
     216 
    189217  }, 
    190218 

  • lang/javascript/jsruby/branches/async/src/node.js

    r4771 r5281  
    7272 
    7373 
     74RubyEngine.Node.BlockIterator = function(block, iterator) { 
     75  this.block = block; 
     76  this.iterator = iterator; 
     77  if (block.vars) varname = block.vars[0].name; 
     78} 
     79RubyEngine.Node.BlockIterator.prototype = { 
     80  "next": function(self){ 
     81    this.scope.pushLevel(); 
     82    if(self.iterator.apply(this, [self])) { 
     83      this.command.push(self); 
     84      this.command.push("popLevel"); 
     85      this.compile(self.block.block); 
     86    } 
     87  } 
     88} 
     89 
     90RubyEngine.Node.Iterator = function(list) { 
     91    this.list = list; 
     92    this.idx = 0; 
     93  }, 
     94RubyEngine.Node.Iterator.prototype = { 
     95  next: function() { 
     96    if (this.idx<this.list.length) { 
     97      return this.list[this.idx++]; 
     98    } else { 
     99      return undefined; 
     100    } 
     101  } 
     102} 
     103 
     104