function Word(vocab, name, source, func) {
  this.vocab = vocab;
  this.name = name;
  this.source = source;
  this.func = func;
}

Word.prototype.execute = function(next) {
  this.func(next);
}

Word.prototype.toString = function() {
  var html = [];
  html.push("<a href='/responder/browser/browse?vocab=")
  html.push(this.vocab);
  html.push("&amp;word=")
  html.push(this.name);
  html.push("'>")
  html.push(this.name);
  html.push("</a>");
  return html.join("");
}

function Hashtable() {
  this.table = { }
}

Hashtable.prototype.fromAlist = function(alist) {
  var obj = { }
  for(var i=0;i<alist.length;++i) {  
    var item = alist[i];
    obj[item[0]] = item[1];
  }
  this.table = obj;
  return this;
}

Hashtable.prototype.toAlist = function() {
  var table = this.table;
  var alist = [ ];
  for(k in table) {
    var v = table[k];
    alist.push([k,v]);
  }
  return alist;
}

Hashtable.prototype.get = function(key) {
  var table = this.table;
  if(table.hasOwnProperty(key)) {
    return table[key];
  }
  return false;
}

Hashtable.prototype.set = function(key, value) {
  this.table[key] = value;
}

Hashtable.prototype.toString = function() {
  var table = this.table;
  var result = [];
  result.push("H{")
  for(k in table) {
    var v = table[k];
    result.push(" { ");
    result.push(k);
    result.push(" ");
    result.push(v);
    result.push(" }");
  }
  result.push("}");
  return result.join("");    
}

function Continuation() {
  this.data_stack = [ ];
  this.retain_stack = [ ];
  this.name_stack = [ ];
  this.next = false;
  this.nesting = 0;
}

Continuation.prototype.clone = function() {
  var c = new Continuation();
  c.data_stack = this.data_stack.slice(0);
  c.retain_stack = this.retain_stack.slice(0);
  c.name_stack = this.name_stack.slice(0);
  c.nesting = this.nesting;
  c.next = this.next;
  return c;
}

function Factor() {
  this.vocabs = { scratchpad: { }, io: { } };
  this.in_vocab = "scratchpad";
  this.using_vocabs = [ "scratchpad", "kernel","math","sequences","parser","alien","browser-dom", "words", "io", "hashtables" ];
  this.cont = new Continuation();
}

var factor = new Factor();

Factor.prototype.call_next = function(next) {
  if(next) {
    if(this.cont.nesting++ > 150) {
      this.cont.nesting = 0;
      setTimeout(next, 0);
   }
    else {
      next();
    }
  }
}

Factor.prototype.push_data = function(v, next) {
  factor.cont.data_stack.push(v);
  factor.call_next(next);
}

Factor.prototype.use = function(v, next) {
  factor.cont.data_stack.push(v);
  factor.get_word("kernel", "use+").execute(next);
}

Factor.prototype.using = function(v, next) {
  factor.cont.data_stack.push(v);
  factor.get_word("kernel", "using").execute(next);
}

Factor.prototype.set_in = function(v, next) {
  factor.cont.data_stack.push(v);
  factor.get_word("kernel", "set-in").execute(next);
}

Factor.prototype.get_word = function(vocab,name) {
  return factor.vocabs[vocab][name];
}

Factor.prototype.find_word = function(name) {
  for(var v = 0; v<factor.using_vocabs.length; ++v) {
    var w = factor.vocabs[factor.using_vocabs[v]][name];
    if(w)
      return w;
  }
  return false;
}

Factor.prototype.add_word = function(vocab,name, source, func) {
  var v = factor.vocabs[vocab];
  if(!v) {
    v = { };
    factor.vocabs[vocab] = v;
  }
  v[name] = new Word(vocab,name,source,func);
}

Factor.prototype.remove_word = function(vocab,name) {
  var v = factor.vocabs[vocab];
  if(!v) {
    v = { };
    factor.vocabs[vocab] = v;
  }
  delete v[name];
}
    
Factor.prototype.define_word = function(name, source, func, next) {
  factor.vocabs[factor.in_vocab][name] = new Word(factor.in_vocab, name, source, function(next) {
    var old = factor.cont.next;
    factor.cont.next = function() {
      factor.cont.next = old;
      factor.call_next(next);
    }
    func();
  });
  factor.call_next(next);
}

Factor.prototype.make_quotation = function(source, func) {
  return new Word("quotations", "quotation", source, function(next) {
    var old = factor.cont.next;
    factor.cont.next = function() {
      factor.cont.next = old;
      factor.call_next(next);
    }
    func();
  });
}

Factor.prototype.server_eval = function(text, handler, next) {
   var self = this;
   $.post("/responder/fjsc/compile", { code: text }, function(result) {
     factor.run_eval = function(func) {
       factor.cont.next = function() { handler(text,result); } 
       try {
         func(factor);
       } catch(ex) {
         alert("Error Parsing Javascript: " + ex); 
         handler(text, result);
       }
       if(next) 
         factor.call_next(next);
     }
     try {
       eval("factor.run_eval" + result);
     } catch(e) {
       factor.run_eval(function() { alert("Error Parsing Javascript: " + e); });
     }
   });
}

/* kernel-internals vocabulary */
factor.add_word("kernel-internals", ">n", "primitive", function(next) {
  var data_stack = factor.cont.data_stack;
  var name_stack = factor.cont.name_stack;
  name_stack.push(data_stack.pop());
  factor.call_next(next);
});

factor.add_word("kernel-internals", "n>", "primitive", function(next) {
  var data_stack = factor.cont.data_stack;
  var name_stack = factor.cont.name_stack;
  data_stack.push(name_stack.pop());
  factor.call_next(next);
});

/* Kernel Vocabulary */
factor.add_word("kernel","dup", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  stack[stack.length] = stack[stack.length-1];
  factor.call_next(next);
});

factor.add_word("kernel", "drop", "primitive", function(next) {
  factor.cont.data_stack.pop();
  factor.call_next(next);
});

factor.add_word("kernel", "nip", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  stack[stack.length-2] = stack[stack.length-1];
  stack.pop();
  factor.call_next(next);
});

factor.add_word("kernel", "over", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  stack[stack.length] = stack[stack.length-2];
  factor.call_next(next);
});

factor.add_word("kernel", "pick", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  stack[stack.length] = stack[stack.length-3];
  factor.call_next(next);
});

factor.add_word("kernel", "swap", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  var temp = stack[stack.length-2];
  stack[stack.length-2] = stack[stack.length-1];
  stack[stack.length-1] = temp;
  factor.call_next(next);
});

factor.add_word("kernel", ">r", "primitive", function(next) {
  var data_stack = factor.cont.data_stack;
  var retain_stack = factor.cont.retain_stack;
  retain_stack.push(data_stack.pop());
  factor.call_next(next);
});

factor.add_word("kernel", "r>", "primitive", function(next) {
  var data_stack = factor.cont.data_stack;
  var retain_stack = factor.cont.retain_stack;
  data_stack.push(retain_stack.pop());
  factor.call_next(next);
});

factor.add_word("kernel", "call", "primitive", function(next) {
  var quot = factor.cont.data_stack.pop();
  quot.execute(next);
});

factor.add_word("kernel", "execute", "primitive", function(next) {
  var quot = factor.cont.data_stack.pop();
  quot.execute(next);
});

factor.add_word("kernel", "clear", "primitive", function(next) {
  factor.cont.data_stack = [];
  factor.cont.retain_stack = [];
  factor.call_next(next);
});

factor.add_word("kernel", "if", "primitive", function(next) {  
  var stack = factor.cont.data_stack;
  var else_quot = stack.pop();
  var then_quot = stack.pop();
  var condition = stack.pop();
  if(condition) {
    then_quot.execute(next);
  } else {
    else_quot.execute(next);
  }
});

factor.add_word("kernel", "f", "primitive", function(next) {  
  factor.cont.data_stack.push(false);
  factor.call_next(next);
});

factor.add_word("kernel", "t", "primitive", function(next) {  
  factor.cont.data_stack.push(true);
  factor.call_next(next);
});

factor.add_word("kernel", "=", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  stack.push(stack.pop()==stack.pop());
  factor.call_next(next);
});

factor.add_word("kernel", "bootstrap", "primitive", function(next) {  
  factor.cont.data_stack.push("/responder/fjsc-resources/bootstrap.factor");
  factor.get_word("parser", "run-file").execute(next);
});

factor.add_word("kernel", "callcc0", "primitive", function(next) {  
  var data_stack = factor.cont.data_stack;
  var quot = data_stack.pop();
  var new_cont = factor.cont.clone();  
  var old_next = factor.cont.next;
  factor.cont.next = function() {
      factor.cont.next = old_next;
      factor.call_next(next);
  }
  new_cont.data_stack.push(factor.cont);
  factor.cont = new_cont;
  quot.execute(next);  
});

factor.add_word("kernel", "callcc1", "primitive", function(next) {  
  factor.get_word("kernel", "callcc0").execute(next);
});

factor.add_word("kernel", "continue", "primitive", function(next) {  
  var data_stack = factor.cont.data_stack;
  var cont = data_stack.pop(); 
  factor.cont = cont.clone();
  factor.call_next(cont.next);
});

factor.add_word("kernel", "continue-with", "primitive", function(next) {  
  var data_stack = factor.cont.data_stack;
  var cont = data_stack.pop(); 
  var data = data_stack.pop(); 
  factor.cont = cont.clone();
  factor.cont.data_stack.push(data);
  factor.call_next(cont.next);
});

factor.add_word("kernel", "set-in", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var vocab = stack.pop();
  var v = factor.vocabs[vocab];
  if(!v) {
    v = { };
    factor.vocabs[vocab] = v;
  }
  factor.in_vocab = vocab;
  factor.call_next(next);  
});

factor.add_word("kernel", "current-vocab", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  stack.push(factor.in_vocab);
  factor.call_next(next);  
});

factor.add_word("kernel", "use+", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var vocab = stack.pop();
  var v = factor.vocabs[vocab];
  if(!v) {
    v = { };
    factor.vocabs[vocab] = v;
  }
  factor.using_vocabs.push(vocab);
  factor.call_next(next);  
});

factor.add_word("kernel", "using", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var vocabs = stack.pop();

  for(var i=0;i<vocabs.length;++i) {  
    var v = factor.vocabs[vocabs[i]];
    if(!v) {
      v = { };
      factor.vocabs[vocabs[i]] = v;
    }
    factor.using_vocabs.push(vocabs[i]);
  }
  factor.call_next(next);  
});

factor.add_word("kernel", "current-using", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  stack.push(factor.using_vocabs);
  factor.call_next(next);  
});

factor.add_word("kernel", "forget", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var word = stack.pop();
  factor.remove_word(word.vocab, word.name);
  factor.call_next(next);  
});

factor.add_word("kernel", ">function", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var word = stack.pop();
  stack.push(function() { word.func(function() { }) });
  factor.call_next(next);  
});

factor.add_word("kernel", "curry", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var quot = stack.pop();
  var value = stack.pop();
  
  stack.push(factor.make_quotation("quotation", function(next) {
    factor.cont.data_stack.push(value);   
    quot.execute(factor.cont.next);
  }));
  factor.call_next(next);
});

/* Math vocabulary */
factor.add_word("math", "*", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  stack.push(stack.pop() * stack.pop());
  factor.call_next(next);
});

factor.add_word("math", "+", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  stack.push(stack.pop() + stack.pop());
  factor.call_next(next);
});

factor.add_word("math", "-", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  var v1 = stack.pop();
  var v2 = stack.pop();
  stack.push(v2 - v1);
  factor.call_next(next);
});

factor.add_word("math", "/", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  var v1 = stack.pop();
  var v2 = stack.pop();
  stack.push(v2 / v1);
  factor.call_next(next);
});

factor.add_word("parser", "run-file", "primitive", function(next) {  
  var stack = factor.cont.data_stack;
  var url = stack.pop();
  $.get(url, function(result) {
    factor.server_eval(result, function() { }, next);
  });
});


factor.add_word("alien", "alien-invoke", "primitive", function(next) {  
  var stack = factor.cont.data_stack;
  var arg_types = stack.pop();
  var method_name = stack.pop();
  var library_name = stack.pop();
  var return_values = stack.pop();
  var obj = stack.pop();
  var args = [ ];
  for(var i = 0; i < arg_types.length; ++i) {
    args[i] = stack.pop();
  }
  var func = obj[method_name];
  if(method_name=="alert") {
    func = function(a) { alert(a); }
  }
  var v = func.apply(obj, args.reverse());
  if(return_values.length > 0)
    stack.push(v);
  factor.call_next(next);
});

factor.add_word("alien", "alien-property", "primitive", function(next) {  
  var stack = factor.cont.data_stack;
  var obj = stack.pop();
  var property_name = stack.pop();
  var v = obj[property_name];
  stack.push(v);
  factor.call_next(next);
});

factor.add_word("alien", "set-alien-property", "primitive", function(next) {  
  var stack = factor.cont.data_stack;
  var obj = stack.pop();
  var property_name = stack.pop();
  var data = stack.pop();
  obj[property_name] = v;
  factor.call_next(next);
});

factor.add_word("alien", "uneval", "primitive", function(next) {
  var stack = factor.cont.data_stack;
  stack.push(uneval(stack.pop()));
  factor.call_next(next);
});

factor.add_word("words", "vocabs", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var result = [];
  for(v in factor.vocabs) {
    result.push(v);
  }
  stack.push(result);
  factor.call_next(next);
});

factor.add_word("words", "words", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var vocab = factor.vocabs[stack.pop()];
  var result = [];
  for(w in vocab) {
    result.push(vocab[w]);
  }
  stack.push(result);
  factor.call_next(next);
});

factor.add_word("words", "all-words", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var result = [];
  for(v in factor.vocabs) {
    for(w in factor.vocabs[v]) {
      result.push(factor.vocabs[v][w]);
    }
  }
  stack.push(result);
  factor.call_next(next);
});

/* Sequences vocabulary */
factor.add_word("sequences", "nth", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var seq = stack.pop();
  var index = stack.pop();
  stack.push(seq[index]);
  factor.call_next(next);
});

factor.add_word("sequences", "first", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var seq = stack.pop();
  stack.push(seq[0]);
  factor.call_next(next);
});

factor.add_word("sequences", "second", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var seq = stack.pop();
  stack.push(seq[1]);
  factor.call_next(next);
});

factor.add_word("sequences", "third", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var seq = stack.pop();
  stack.push(seq[2]);
  factor.call_next(next);
});

factor.add_word("sequences", "fourth", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var seq = stack.pop();
  stack.push(seq[0]);
  factor.call_next(next);
});

factor.add_word("sequences", "first2", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var seq = stack.pop();
  stack.push(seq[0],seq[1]);
  factor.call_next(next);
});

factor.add_word("sequences", "first3", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var seq = stack.pop();
  stack.push(seq[0],seq[1],seq[2]);
  factor.call_next(next);
});

factor.add_word("sequences", "first4", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var seq = stack.pop();
  stack.push(seq[0],seq[1],seq[2],seq[3]);
  factor.call_next(next);
});

factor.add_word("sequences", "each", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var quot = stack.pop();
  var seq = stack.pop();
  for(var i=0;i<seq.length;++i) {  
    stack.push(seq[i]);
    quot.execute();
  }
  factor.call_next(next);
});

factor.add_word("sequences", "map", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var quot = stack.pop();
  var seq = stack.pop();
  var result = [ ];
  for(var i=0;i<seq.length;++i) {  
    stack.push(seq[i]);
    quot.execute();
    result[i]=stack.pop();
  }
  stack.push(result);
  factor.call_next(next);
});

factor.add_word("sequences", "reduce", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var quot = stack.pop();
  var prev = stack.pop();
  var seq = stack.pop();
  for(var i=0;i<seq.length;++i) {  
    stack.push(prev);
    stack.push(seq[i]);
    quot.execute();
    prev=stack.pop();Al
  }
  stack.push(prev);
  factor.call_next(next);
});

/* hashtables vocabulary */
factor.add_word("hashtables", "alist>hash", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var alist = stack.pop();
  stack.push(new Hashtable().fromAlist(alist));
  factor.call_next(next);
});

factor.add_word("hashtables", "hash>alist", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var hashtable = stack.pop();
  stack.push(hashtable.toAlist());
  factor.call_next(next);
});

factor.add_word("hashtables", "hash", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var hashtable = stack.pop();
  var key = stack.pop();
  stack.push(hashtable.get(key));
  factor.call_next(next);
});

factor.add_word("hashtables", "set-hash", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var hashtable = stack.pop();
  var key = stack.pop();
  var value = stack.pop();
  hashtable.set(key, value);
  factor.call_next(next);
});

factor.add_word("sequences", "hash-each", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var quot = stack.pop();
  var hashtable = stack.pop().table;
  for(k in hashtable) {  
    var v = hashtable[k]; 
    stack.push(k, v);
    quot.execute();
  }
  factor.call_next(next);
});

factor.add_word("sequences", "hash-map", "primitive", function(next) {   
  var stack = factor.cont.data_stack;
  var quot = stack.pop();
  var hashtable = stack.pop().table;
  var result = [ ];
  for(k in hashtable) {  
    var v = hashtable[k];
    stack.push(k,v);
    quot.execute();
    result.push(stack.pop());
  }
  stack.push(result);
  factor.call_next(next);
});

/* browser-dom vocab */
factor.add_word("browser-dom", "window", "primitive", function(next) {  
  factor.cont.data_stack.push(window);
  factor.call_next(next);
});

factor.add_word("browser-dom", "document", "primitive", function(next) {  
  factor.cont.data_stack.push(document);
  factor.call_next(next);
});

factor.add_word("browser-dom", "load-script", "primitive", function(next) {  
  var stack = factor.cont.data_stack;
  $("head/script#jsonrequest").remove();
  var script = document.createElement("script");
  script.id = "jsonrequest";    
  script.type = "text/javascript";
  script.src = stack.pop();
  $("head").append(script);
  factor.call_next(next); 
});

var handle_json = false;
factor.add_word("browser-dom", "json-request", "primitive", function(next) {  
  var stack = factor.cont.data_stack;
  handle_json = function(data) { 
    factor.cont.data_stack.push(data);
    factor.call_next(next);
  }
  factor.get_word("browser-dom", "load-script").execute();
});