yhara-ticketmap 0.3.1

data/public/biwascheme/lib/biwascheme.js

@@ -0,0 +1,106 @@
+//for application
+
+
+var BiwaScheme = {
+  Version: 0.5,
+
+  // load library and execute proc after loading
+  require: function(src, check, proc){
+    var script = document.createElement('script')
+    script.src = src;
+    document.body.appendChild(script);
+
+    var checker = new Function("return !!(" + check + ")");
+
+    if(checker()) proc();
+    else          setTimeout(function(){ checker() ? proc() : setTimeout(arguments.callee, 10); }, 10);
+  }
+};
+
+(function(){ //local namespace
+  var require = BiwaScheme.require;
+
+  // taken from prototype.js 1.6.0
+  var readAttribute = function(element, name) {
+    if (/*Prototype.Browser.IE*/ !!(window.attachEvent && !window.opera)){
+      var t = {
+        names: {
+          'class': 'className',
+          'for':   'htmlFor'
+        },
+        values: {
+          _getAttr: function(element, attribute) {
+            return element.getAttribute(attribute, 2);
+          },
+          _getAttrNode: function(element, attribute) {
+            var node = element.getAttributeNode(attribute);
+            return node ? node.value : "";
+          },
+          _getEv: function(element, attribute) {
+            var attribute = element.getAttribute(attribute);
+            return attribute ? attribute.toString().slice(23, -2) : null;
+          },
+          _flag: function(element, attribute) {
+            return $(element).hasAttribute(attribute) ? attribute : null;
+          },
+          style: function(element) {
+            return element.style.cssText.toLowerCase();
+          },
+          title: function(element) {
+            return element.title;
+          }
+        }
+      };
+      if (t.values[name]) return t.values[name](element, name);
+      if (t.names[name]) name = t.names[name];
+      if (name.indexOf(':') > -1){
+        return (!element.attributes || !element.attributes[name]) ? null :
+         element.attributes[name].value;
+      }
+    }
+    return element.getAttribute(name);
+  }
+
+  // main
+  var script = (function(e){ 
+    if(e.id == '_firebugConsole'){
+      return arguments.callee(document.body);
+    }
+    else if(e.nodeName.toLowerCase() == 'script'){
+      return e;
+    }
+    else{
+      return arguments.callee(e.lastChild);
+    }
+  })(document);
+
+  var src = readAttribute(script, 'src');
+  var dir = src.match(/(.*)biwascheme.js/)[1];
+
+  require(dir+'prototype.js', 'window.$$', function(){
+  require(dir+'stackbase.js',     'window.BiwaScheme.CoreEnv', function(){
+  require(dir+'r6rs_lib.js',      'window.BiwaScheme.CoreEnv["+"]', function(){
+  require(dir+'webscheme_lib.js', 'window.BiwaScheme.CoreEnv["getelem"]', function(){
+  require(dir+'extra_lib.js',     'window.BiwaScheme.CoreEnv["print"]', function(){
+  require(dir+'dumper.js',     'window.BiwaScheme.Dumper', function(){
+  require(dir+'io.js',            'window.JSIO', function(){
+    var onError = function(e, state){
+      puts(e.message); 
+      if($("biwascheme-debugger")){
+        var dumper = new BiwaScheme.Dumper($("biwascheme-debugger"));
+        dumper.dump(new Hash(state));
+        dumper.dump_move(1);
+      }
+      throw(e);
+    }
+    var intp = new BiwaScheme.Interpreter(onError);
+    try{
+      intp.evaluate(script.innerHTML, Prototype.emptyFunction);
+    }
+    catch(e){
+      onError(e);
+    }
+  })})})})})})});
+})();
+
+//vim: set ft=javascript:

data/public/biwascheme/lib/dumper.js

@@ -0,0 +1,192 @@
+//
+// Dumper - graphical state dumper
+//
+with(BiwaScheme) {
+
+BiwaScheme.Dumper = Class.create({
+  initialize: function(dumparea){
+    this.dumparea = dumparea || $("dumparea");
+  },
+
+  is_opc: function(obj){
+    return (obj instanceof Array && typeof(obj[0]) == 'string');
+  },
+
+  dump_pad: "   ",
+  dump_opc: function(obj, level){
+    var s="";
+    var pad1="", pad2="";
+    var level = level || 0;
+    level.times(function(){ pad1 += this.dump_pad; }.bind(this));
+    (level+1).times(function(){ pad2 += this.dump_pad; }.bind(this));
+
+    s += pad1 + '[<span class="dump_opecode">' + obj[0] + '</span>';
+    var i = 1;
+    while(!(obj[i] instanceof Array) && i<obj.length){
+      if(obj[0] == "constant")
+        s += "&nbsp;<span class='dump_constant'>" + 
+             this.dump_obj(obj[i]) + "</span>";
+      else
+        s += "&nbsp;" + this.dump_obj(obj[i]);
+      i++;
+    }
+    if(i < obj.length) s += '<br>\n';
+    for(; i<obj.length; i++){
+      if(this.is_opc(obj[i])){
+        s += this.dump_opc(obj[i], (i == obj.length-1 ? level : level+1));
+      }
+      else{
+        s += (i == obj.length-1) ? pad1 : pad2;
+        s += this.dump_obj(obj[i]); //String(obj[i]).escapeHTML();
+      }
+      if(i != obj.length-1) s += "<br>\n";
+    }
+    s += "]";
+    return (level==0 ? this.add_fold(s) : s);
+  },
+
+  fold_limit: 20,
+  n_folds:  0,
+  add_fold: function(s){
+    var lines = s.split(/<br>/gmi);
+
+    if(lines.length > this.fold_limit){
+      var fold_btn   = " <span style='text-decoration:underline; color:blue; cursor:pointer;'" +
+                           "onclick='BiwaScheme.Dumper.toggle_fold("+this.n_folds+")'>more</span>"
+      var fold_start = "<div style='display:none' id='fold"+this.n_folds+"'>"; 
+      var fold_end   = "</div>"
+      this.n_folds++;
+      return [
+        lines.slice(0, this.fold_limit).join("<br>"), fold_btn,
+        fold_start, lines.slice(this.fold_limit+1).join("<br>"), fold_end
+      ].join("");
+    }
+    else{
+      return s;
+    }
+  },
+
+  stack_max_len: 80,
+  dump_stack: function(stk, size){
+    if(stk === null || stk === undefined) return Object.inspect(stk)
+    var s = "<table>";
+    for(var i=stk.length-1; i >= 0; i--){
+      if(i < size){
+        s += "<tr><td class='dump_stknum'>[" + i + "]</td>" +
+             "<td>" + this.dump_obj(stk[i]).truncate(this.stack_max_len) +
+             "</td></tr>";
+      }
+      else{
+        s += "<tr><td class='dump_dead'>[" + i + "]</td>" +
+             "<td class='dump_dead'>" + 
+             this.dump_obj(stk[i]).truncate(this.stack_max_len) +
+             "</td></tr>";
+      }
+    }
+    return s + "</table>";
+  },
+
+  dump_object: function(obj){
+    var a = [];
+    for(var k in obj){
+      //if(this.prototype[k]) continue;
+      a.push( k.toString() );//+" => "+this[k].toString() );
+    }
+    return "#<Object{"+a.join(",")+"}>";
+  },
+
+  closures: [],
+  dump_closure: function(cls){
+    if(cls.length == 0) return "[]";
+
+    var cls_num = null;
+    for(var i=0; i<this.closures.length; i++){
+      if(this.closures[i] == cls) cls_num = i;
+    }
+    if(cls_num == null){
+      cls_num = this.closures.length;
+      this.closures.push(cls);
+    }
+
+    var c = cls.clone ? cls.clone() : [c];
+    var body = c.shift();
+    return [
+      "c", cls_num, " <span class='dump_closure'>free vars :</span> ",
+      this.dump_obj(c), " <span class='dump_closure'>body :</span> ",
+      this.dump_obj(body).truncate(100)
+    ].join("");
+  },
+
+  dump_obj: function(obj){
+    if(obj && typeof(obj.to_html) == 'function')
+      return obj.to_html();
+    else{
+      var s = write_ss(obj, true); //true=Array mode
+      if(s == "[object Object]") s = this.dump_object(obj);
+      return s.escapeHTML();
+    }
+  },
+
+  n_dumps: 0,
+  dump: function(obj){
+    var dumpitem = document.createElement("div"); 
+    var s = "";
+    if(obj instanceof Hash){
+      s += "<table>"
+      s += "<tr><td colspan='4'>#"+this.n_dumps+"</td></tr>"
+      obj.each(function(pair){
+        if(pair.key!="x" && pair.key != "stack"){
+          var value = (pair.key=="c" ? this.dump_closure(pair.value) 
+                                     : this.dump_obj(pair.value))
+          s += "<tr><td>" + pair.key + ": </td>" + 
+               "<td colspan='3'>" + value + "</td></tr>";
+        }
+      }.bind(this));
+      s += "<tr><td>x:</td><td>" + 
+           (this.is_opc(obj.get("x")) ? this.dump_opc(obj.get("x")) 
+                                      : this.dump_obj(obj.get("x"))) +
+           "</td>";
+      s += "<td style='border-left: 1px solid black'>stack:</td><td>" +
+           this.dump_stack(obj.get("stack"), obj.get("s")) +
+           "</td></tr>";
+      s += "</table>";
+    }
+    else{
+      s = Object.inspect(obj).escapeHTML() + "<br>\n";
+    }
+    dumpitem.id = "dump" + this.n_dumps;
+    dumpitem.innerHTML = s;
+    this.dumparea.appendChild(dumpitem);
+    Element.hide(dumpitem);
+    this.n_dumps++;
+  },
+
+  cur: -1,
+  dump_move: function(dir){
+    if(0 <= this.cur && this.cur < this.n_dumps)
+      Element.hide($("dump"+this.cur));
+
+    if(0 <= this.cur+dir && this.cur+dir < this.n_dumps)
+      this.cur += dir;
+
+    Element.show($("dump"+this.cur));
+  },
+
+  is_folded: true,
+  dump_toggle_fold: function(){
+    if(this.is_folded){ //open all
+      for(var i=0; i<this.n_dumps; i++)
+        Element.show($("dump"+i));
+    }
+    else{            //close all
+      for(var i=0; i<this.n_dumps; i++)
+        if(i!=this.cur) Element.hide($("dump"+i));
+    }
+    this.is_folded = (!this.is_folded);
+  }
+})
+} // with(BiwaScheme);
+
+BiwaScheme.Dumper.toggle_fold = function(n){
+  Element.toggle("fold"+n);
+}

data/public/biwascheme/lib/extra_lib.js

@@ -0,0 +1,534 @@
+
+if( typeof(BiwaScheme)!='object' ) BiwaScheme={}; with(BiwaScheme) {
+  define_libfunc("html-escape", 1, 1, function(ar){
+    assert_string(ar[0]);
+    return ar[0].escapeHTML();
+  });
+  BiwaScheme.inspect_objs = function(objs){
+    return objs.map(function(obj){
+      if(obj.inspect)
+        return obj.inspect();
+      else
+        return Object.inspect($H(obj));
+    }).join(" ");
+  };
+  define_libfunc("inspect", 1, null, function(ar){
+    return BiwaScheme.inspect_objs(ar);
+  });
+  define_libfunc("inspect!", 1, null, function(ar){
+    return puts(BiwaScheme.inspect_objs(ar));
+  });
+
+  //
+  // json
+  //
+  // json->sexp
+  // Array -> list
+  // Object -> alist
+  // (number, boolean, string, 
+  //
+  BiwaScheme.json2sexp = function(json){
+    switch(true){
+    case Object.isNumber(json) || 
+         Object.isString(json) ||
+         json === true || json === false:
+      return json;
+    case Object.isArray(json):
+      return json.map(function(item){ 
+               return json2sexp(item);
+             }).to_list();
+    case typeof(json) == "object":
+      var ls = nil;
+      for(key in json){
+        ls = new Pair(new Pair(key, json2sexp(json[key])),
+               ls);
+      }
+      return ls;
+    default:
+      throw new Error("json->sexp: detected invalid value for json: "+Object.inspect(json));
+    }
+    throw new Bug("must not happen");
+  }
+  define_libfunc("json->sexp", 1, 1, function(ar){
+    return json2sexp(ar[0]);
+  })
+
+  //
+  //from Gauche
+  //
+
+  define_libfunc("string-concat", 1, 1, function(ar){
+    assert_pair(ar[0]);
+    return ar[0].to_array().join("");
+  })
+  define_libfunc("string-split", 2, 2, function(ar){
+    assert_string(ar[0]);
+    assert_string(ar[1]);
+    return ar[0].split(ar[1]).to_list();
+  })
+  define_libfunc("string-join", 1, 2, function(ar){
+    assert_pair(ar[0]);
+    var delim = ""
+    if(ar[1]){
+      assert_string(ar[1]);
+      delim = ar[1];
+    }
+    return ar[0].to_array().join(delim);
+  })
+
+  define_libfunc("intersperse", 2, 2, function(ar){
+    var item = ar[0], ls = ar[1];
+    assert_pair(ls);
+
+    var ret = [];
+    ls.to_array().reverse().each(function(x){
+      ret.push(x);
+      ret.push(item);
+    });
+    ret.pop();
+    return ret.to_list();
+  });
+
+  define_libfunc("map-with-index", 2, null, function(ar){
+    var proc = ar.shift(), lists = ar;
+    lists.each(function(ls){ assert_pair(ls) });
+
+    var results = [], i = 0;
+    return Call.multi_foreach(lists, {
+      call: function(xs){ 
+        var args = xs.map(function(x){ return x.car });
+        args.unshift(i);
+        i++;
+        return new Call(proc, args);
+      },
+      result: function(res){ results.push(res); },
+      finish: function(){ return results.to_list(); }
+    });
+  });
+
+  //(define-macro (foo x) body ...)
+  //(define-macro foo lambda)
+
+  var rearrange_args = function (expected, given) {
+    var args = [];
+    var dotpos = (new Compiler).find_dot_pos(expected);
+    if (dotpos == -1)
+      args = given;
+    else {
+      for (var i = 0; i < dotpos; i++)
+	args[i] = given[i];
+      args[i] = given.slice(i).to_list();
+    }
+    return args;
+  }
+  define_syntax("define-macro", function(x){
+    var head = x.cdr.car;
+    var expected_args;
+    if(head instanceof Pair){
+      var name = head.car;
+      expected_args = head.cdr;
+      var body = x.cdr.cdr;
+      var lambda = new Pair(Sym("lambda"),
+                     new Pair(expected_args,
+                       body))
+    }
+    else{
+      var name = head;
+      var lambda = x.cdr.cdr.car;
+      expected_args = lambda.cdr.car;
+    }
+
+    //[close, n_frees, do_body, next]
+    var opc = Compiler.compile(lambda);
+    if(opc[1] != 0)
+      throw new Bug("you cannot use free variables in macro expander (or define-macro must be on toplevel)")
+    var cls = [opc[2]];
+
+    TopEnv[name.name] = new Syntax(name.name, function(sexp){
+      var given_args = sexp.to_array();
+
+      given_args.shift();
+      
+      var intp = new Interpreter();
+      var args = rearrange_args(expected_args, given_args);
+      var result = intp.invoke_closure(cls, args);
+      return result;
+    });
+
+    return BiwaScheme.undef;
+  })
+
+  var macroexpand_1 = function(x){
+    if(x instanceof Pair){
+      if(x.car instanceof Symbol && TopEnv[x.car.name] instanceof Syntax){
+        var transformer = TopEnv[x.car.name];
+        x = transformer.transform(x);
+      }
+      else
+        throw new Error("macroexpand-1: `" + to_write_ss(x) + "' is not a macro");
+    }
+    return x;
+  }
+  define_syntax("%macroexpand", function(x){
+    var expanded = (new Interpreter).expand(x.cdr.car);
+    return [Sym("quote"), expanded].to_list();
+  });
+  define_syntax("%macroexpand-1", function(x){
+    var expanded = macroexpand_1(x.cdr.car);
+    return [Sym("quote"), expanded].to_list();
+  });
+
+  define_libfunc("macroexpand", 1, 1, function(ar){
+    return (new Interpreter).expand(ar[0]);
+  });
+  define_libfunc("macroexpand-1", 1, 1, function(ar){
+    return macroexpand_1(ar[0]);
+  });
+
+  define_libfunc("print", 1, null, function(ar){
+    ar.map(function(item){
+      puts(to_display(item), true);
+    })
+    puts(""); //newline
+    return BiwaScheme.undef;
+  })
+  define_syntax("let1", function(x){
+    //(let1 vari expr body ...) 
+    //=> ((lambda (var) body ...) expr)
+    var vari = x.cdr.car; 
+    var expr = x.cdr.cdr.car;
+    var body = x.cdr.cdr.cdr;
+
+    return new Pair(new Pair(Sym("lambda"),
+                      new Pair(new Pair(vari, nil),
+                        body)),
+             new Pair(expr, nil));
+  })
+
+  define_libfunc("write-to-string", 1, 1, function(ar){
+    return to_write(ar[0]);
+  });
+  define_libfunc("read-from-string", 1, 1, function(ar){
+    assert_string(ar[0]);
+    return Interpreter.read(ar[0]);
+  });
+  
+  //
+  // srfi
+  //
+  
+  // srfi-1 (list)
+  define_libfunc("iota", 1, 3, function(ar){
+    var count = ar[0];
+    var start = ar[1] || 0;
+    var step = (ar[2]===undefined) ? 1 : ar[2];
+    assert_integer(count);
+    assert_number(start);
+    assert_number(step);
+
+    var a = [], n = start;
+    for(var i=0; i<count; i++){
+      a.push(n);
+      n += step;
+    }
+    return a.to_list();
+  });
+
+  // srfi-6 & Gauche (string port)
+  BiwaScheme.Port.StringOutput = Class.create(Port, {
+    initialize: function($super){
+      this.buffer = [];
+      $super(false, true);
+    },
+    put_string: function(str){
+      this.buffer.push(str);
+    },
+    output_string: function(str){
+      return this.buffer.join("");
+    }
+  });
+  BiwaScheme.Port.StringInput = Class.create(Port, {
+    initialize: function($super){
+      $super(true, false);
+    },
+    get_string: function(after){
+    }
+  });
+  define_libfunc("open-input-string", 1, 1, function(ar){
+    assert_string(ar[0]);
+    return new Port.StringInput(ar[0]);
+  })
+  define_libfunc("open-output-string", 0, 0, function(ar){
+    return new Port.StringOutput();
+  })
+  define_libfunc("get-output-string", 1, 1, function(ar){
+    assert_port(ar[0]);
+    if(!(ar[0] instanceof Port.StringOutput))
+      throw new Error("get-output-string: port must be made by 'open-output-string'");
+    return ar[0].output_string();
+  })
+
+  // srfi-19 (time)
+  //
+//  // constants
+//time-duration
+//time-monotonic
+//time-process
+//time-tai
+//time-thread
+//time-utc
+  // Current time and clock resolution
+  define_libfunc("current-date", 0, 1, function(ar){
+    //todo: tz-offset (ar[1])
+    return new Date();
+  })
+//
+//current-julian-day -> jdn
+//current-modified-julian-day -> mjdn
+//current-time [time-type] -> time
+//time-resolution [time-type] -> integer
+//  // Time object and accessors
+//make-time type nanosecond second -> time
+//time? object -> boolean
+//time-type time -> time-type
+//time-nanosecond time -> integer
+//time-second time -> integer
+//set-time-type! time time-type
+//set-time-nanosecond! time integer
+//set-time-second! time integer
+//copy-time time1 -> time2 
+//  // Time comparison procedures
+//time<=? time1 time2 -> boolean
+//time<? time1 time2 -> boolean
+//time=? time1 time2 -> boolean
+//time>=? time1 time2 -> boolean
+//time>? time1 time2 -> boolean
+//  // Time arithmetic procedures
+//time-difference time1 time2 -> time-duration
+//time-difference! time1 time2 -> time-duration
+//add-duration time1 time-duration -> time
+//add-duration! time1 time-duration -> time
+//subtract-duration time1 time-duration -> time
+//subtract-duration! time1 time-duration -> time
+  // Date object and accessors
+  // make-date
+  define_libfunc("date?", 1, 1, function(ar){
+    return (ar[0] instanceof Date);
+  })
+  define_libfunc("date-nanosecond", 1, 1, function(ar){
+    assert_date(ar[0]);
+    return ar[0].getMilliseconds() * 1000000;
+  })
+  define_libfunc("date-millisecond", 1, 1, function(ar){ // not srfi-19
+    assert_date(ar[0]);
+    return ar[0].getMilliseconds();
+  })
+  define_libfunc("date-second", 1, 1, function(ar){
+    assert_date(ar[0]);
+    return ar[0].getSeconds();
+  })
+  define_libfunc("date-minute", 1, 1, function(ar){
+    assert_date(ar[0]);
+    return ar[0].getMinutes();
+  })
+  define_libfunc("date-hour", 1, 1, function(ar){
+    assert_date(ar[0]);
+    return ar[0].getHours();
+  })
+  define_libfunc("date-day", 1, 1, function(ar){
+    assert_date(ar[0]);
+    return ar[0].getDate();
+  })
+  define_libfunc("date-month", 1, 1, function(ar){
+    assert_date(ar[0]);
+    return ar[0].getMonth() + 1; //Jan = 0 in javascript..
+  })
+  define_libfunc("date-year", 1, 1, function(ar){
+    assert_date(ar[0]);
+    return ar[0].getFullYear();
+  })
+  //date-zone-offset
+  //date-year-day
+  define_libfunc("date-week-day", 1, 1, function(ar){
+    assert_date(ar[0]);
+    return ar[0].getDay();
+  })
+  //date-week-number
+
+  // Time/Date/Julian Day/Modified Julian Day Converters
+  // (snipped)
+  
+  // Date to String/String to Date Converters
+  // TODO: support locale
+  //   * date_names
+  //   * ~f 5.2 sec
+  //   * ~p AM/PM
+  //   * ~X 2007/01/01
+  BiwaScheme.date_names = {
+    weekday: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+    full_weekday: ["Sunday", "Monday", "Tuesday", 
+      "Wednesday", "Thursday", "Friday", "Saturday"],
+    month: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", 
+      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
+    full_month: ["January", "February", "March", "April",
+      "May", "June", "July", "August", "September", 
+      "Octorber", "November", "December"]
+  }
+
+  BiwaScheme.date2string = function(date, format){
+    var zeropad  = function(n){ return n<10 ? "0"+n : ""+n }; 
+    var spacepad = function(n){ return n<10 ? " "+n : ""+n }; 
+    
+    var getter = {
+      a: function(x){ return date_names.weekday[x.getDay()] },
+      A: function(x){ return date_names.full_weekday[x.getDay()] },
+      b: function(x){ return date_names.month[x.getMonth()] },
+      B: function(x){ return date_names.full_month[x.getMonth()] },
+      c: function(x){ return x.toString() },
+      d: function(x){ return zeropad(x.getDate()) },
+      D: function(x){ return getter.d(x) + getter.m(x) + getter.y(x); },
+      e: function(x){ return spacepad(x.getDate()) },
+      f: function(x){ return x.getSeconds() + x.getMilliseconds()/1000; },
+      h: function(x){ return date_names.month[x.getMonth()] },
+      H: function(x){ return zeropad(x.getHours()) },
+      I: function(x){ var h = x.getHours(); return zeropad(h<13 ? h : h-12) },
+      j: function(x){ throw new Bug("not implemented: day of year") },
+      k: function(x){ return spacepad(x.getHours()) },
+      l: function(x){ var h = x.getHours(); return spacepad(h<13 ? h : h-12) },
+      m: function(x){ return zeropad(x.getMonth()) },
+      M: function(x){ return zeropad(x.getMinutes()) },
+      n: function(x){ return "\n" },
+      N: function(x){ throw new Bug("not implemented: nanoseconds") },
+      p: function(x){ return x.getHours()<13 ? "AM" : "PM" },
+      r: function(x){ return getter.I(x) + ":" + getter.M(x) + ":" + getter.S(x) + " " + getter.p(x) },
+      s: function(x){ return Math.floor(x.getTime() / 1000) },
+      S: function(x){ return zeropad(x.getSeconds()) },
+      t: function(x){ return "\t" },
+      T: function(x){ return getter.H(x) + ":" + getter.M(x) + ":" + getter.S(x) },
+      U: function(x){ throw new Bug("not implemented: weeknum(0~, Sun)") },
+      V: function(x){ throw new Bug("not implemented: weeknum(1~, Sun?)") },
+      w: function(x){ return x.getDay() },
+      W: function(x){ throw new Bug("not implemented: weeknum(0~, Mon)") },
+      x: function(x){ throw new Bug("not implemented: weeknum(1~, Mon)") },
+      X: function(x){ return getter.Y(x) + "/" + getter.m(x) + "/" + getter.d(x) },
+      y: function(x){ return x.getFullYear() % 100 },
+      Y: function(x){ return x.getFullYear() },
+      z: function(x){ throw new Bug("not implemented: time-zone") },
+      Z: function(x){ throw new Bug("not implemented: symbol time zone") },
+      1: function(x){ throw new Bug("not implemented: ISO-8601 year-month-day format") },
+      2: function(x){ throw new Bug("not implemented: ISO-8601 hour-minute-second-timezone format") },
+      3: function(x){ throw new Bug("not implemented: ISO-8601 hour-minute-second format") },
+      4: function(x){ throw new Bug("not implemented: ISO-8601 year-month-day-hour-minute-second-timezone format") },
+      5: function(x){ throw new Bug("not implemented: ISO-8601 year-month-day-hour-minute-second format") }
+    }
+
+    return format.replace(/~([\w1-5~])/g, function(_, x){
+      var func = getter[x];
+      if(func)
+        return func(date);
+      else if(x == "~")
+        return "~";
+      else
+        return x;
+    })
+  }
+  
+  // date->string
+  define_libfunc("date->string", 1, 2, function(ar){
+    assert_date(ar[0]);
+
+    if(ar[1]){
+      assert_string(ar[1]);
+      return date2string(ar[0], ar[1]);
+    }
+    else
+      return ar[0].toString();
+  })
+  // string->date
+
+  define_libfunc("parse-date", 1, 1, function(ar){ // not srfi-19
+    assert_string(ar[0]);
+    return new Date(Date.parse(ar[0]));
+  })
+
+  //
+  // srfi-38 (write/ss)
+  //
+  var user_write_ss = function(ar){
+    puts(write_ss(ar[0]), true);
+    return BiwaScheme.undef;
+  }
+  define_libfunc("write/ss", 1, 2, user_write_ss);
+  define_libfunc("write-with-shared-structure", 1, 2, user_write_ss);
+  define_libfunc("write*", 1, 2, user_write_ss); //from Gauche(STklos)
+
+  //
+  // srfi-43 (vector library)
+  //
+  define_libfunc("vector-append", 2, null, function(ar){
+    var vec = [];
+    return vec.concat.apply(vec, ar);
+  })
+
+  //
+  // Regular Expression
+  //
+  var assert_regexp = function(obj, fname){
+    if(!(obj instanceof RegExp))
+      throw new Error(fname + ": regexp required, but got " + to_write(obj));
+  }
+
+  //Function: string->regexp string &keyword case-fold 
+  define_libfunc("string->regexp", 1, 1, function(ar){
+    assert_string(ar[0], "string->regexp");
+    return new RegExp(ar[0]); //todo: case-fold
+  })
+  //Function: regexp? obj 
+  define_libfunc("regexp?", 1, 1, function(ar){
+    return (ar[0] instanceof RegExp);
+  })
+  //Function: regexp->string regexp 
+  define_libfunc("regexp->string", 1, 1, function(ar){
+    assert_regexp(ar[0], "regexp->string");
+    return ar[0].toString().slice(1, -1); //cut '/' 
+  })
+
+  define_libfunc("regexp-exec", 2, 2, function(ar){
+    var rexp = ar[0];
+    if(Object.isString(ar[0])){
+      rexp = new RegExp(ar[0]);
+    }
+    assert_regexp(rexp, "regexp-exec");
+    assert_string(ar[1], "regexp-exec");
+    var ret = rexp.exec(ar[1])
+    return (ret === null) ? false : ret.to_list();
+  })
+
+//  //Function: rxmatch regexp string 
+//  define_libfunc("rxmatch", 1, 1, function(ar){
+//    assert_regexp(ar[0], "rxmatch");
+//    assert_string(ar[1], "rxmatch");
+//    return ar[0].match(ar[1]);
+//  });
+  //Function: rxmatch-start match &optional (i 0) 
+  //Function: rxmatch-end match &optional (i 0) 
+  //Function: rxmatch-substring match &optional (i 0) 
+  //Function: rxmatch-num-matches match   
+  //Function: rxmatch-after match &optional (i 0) 
+  //Function: rxmatch-before match &optional (i 0) 
+  //Generic application: regmatch &optional index 
+  //Generic application: regmatch 'before &optional index 
+  //Generic application: regmatch 'after &optional index 
+  //Function: regexp-replace regexp string substitution 
+  //Function: regexp-replace-all regexp string substitution 
+  //Function: regexp-replace* string rx1 sub1 rx2 sub2 ... 
+  //Function: regexp-replace-all* string rx1 sub1 rx2 sub2 ... 
+  //Function: regexp-quote string 
+  //Macro: rxmatch-let match-expr (var ...) form ... 
+  //Macro: rxmatch-if match-expr (var ...) then-form else-form 
+  //Macro: rxmatch-cond clause ... 
+  //Macro: rxmatch-case string-expr clause ... 
+
+}
+
+