mix-language 1.0.0

data/bin/mix-compile

@@ -0,0 +1,26 @@
+#! /usr/bin/env ruby
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+require_relative '../lib/ruby/compiler.rb'
+
+Encoding.default_external = "UTF-8"
+
+unless name = ARGV[0]
+  puts "usage: mix-compile [filename]"
+  exit
+end
+
+basename = name.match(/(.*?)(\.mix$|$)/)[1]
+filename = basename + '.mix'
+
+unless File.exists?(filename)
+  puts "no such file #{filename}"
+  exit
+end
+
+compiler = MixCompiler.new(filename)
+js_string = compiler.compile
+
+File.open(basename + '.js','w') {|f| f.write(js_string) }

data/lib/javascript/base/array.js

@@ -0,0 +1,496 @@
+/**
+ *  Copyright © 2011 Jesse Sielaff
+ */
+
+var ARRAY =
+{
+  functions: {}
+};
+
+copy_functions(ARRAY, OBJECT);
+
+function new_array (value)
+{
+  var ary =
+  {
+    object_type: ARRAY_TYPE,
+    functions: {},
+    data: {},
+    keys: [],
+    unknown: Object_bad_key,
+    value: value
+  };
+  
+  copy_functions(ary, ARRAY);
+  
+  return ary;
+}
+
+function Array_all_q (self, args)
+{
+  var func = args[0];
+  
+  if (xself(self, ARRAY_TYPE, "#all?") || xarg(func, FUNCTION_TYPE, "Array#all?", "function"))
+  {
+    return self;
+  }
+  
+  var body = func.value;
+  var bound = func.bound;
+  var items = self.value;
+  
+  for (var i = 0, l = items.length; i < l; ++i)
+  {
+    ITERATING += 1;
+    var item_result = body(bound, [items[i]]);
+    ITERATING -= 1;
+    
+    if (BREAK_VALUE)
+    {
+      var result = BREAK_VALUE;
+      
+      BREAK_VALUE = null;
+      return result;
+    }
+    else if (RETURN_VALUE)
+    {
+      RETURN_VALUE = null;
+    }
+    
+    if (item_result === NULL || item_result === FALSE)
+    {
+      return FALSE;
+    }
+  }
+  
+  return TRUE;
+}
+
+function Array_any_q (self, args)
+{
+  var func = args[0];
+  
+  if (xself(self, ARRAY_TYPE, "#any?") || xarg(func, FUNCTION_TYPE, "Array#any?", "function"))
+  {
+    return self;
+  }
+  
+  var body = func.value;
+  var bound = func.bound;
+  var items = self.value;
+  
+  for (var i = 0, l = items.length; i < l; ++i)
+  {
+    ITERATING += 1;
+    var item_result = body(bound, [items[i]]);
+    ITERATING -= 1;
+    
+    if (BREAK_VALUE)
+    {
+      var result = BREAK_VALUE;
+      
+      BREAK_VALUE = null;
+      return result;
+    }
+    else if (RETURN_VALUE)
+    {
+      RETURN_VALUE = null;
+    }
+    
+    if (item_result !== NULL && item_result !== FALSE)
+    {
+      return TRUE;
+    }
+  }
+  
+  return FALSE;
+}
+
+function Array_each (self, args)
+{
+  var func = args[0];
+  
+  if (xself(self, ARRAY_TYPE, "#each") || xarg(func, FUNCTION_TYPE, "Array#each", "function"))
+  {
+    return self;
+  }
+  
+  var body = func.value;
+  var bound = func.bound;
+  var items = self.value;
+  
+  for (var i = 0, l = items.length; i < l; ++i)
+  {
+    ITERATING += 1;
+    body(bound, [items[i]]);
+    ITERATING -= 1;
+    
+    if (BREAK_VALUE)
+    {
+      var result = BREAK_VALUE;
+      
+      BREAK_VALUE = null;
+      return result;
+    }
+    else if (RETURN_VALUE)
+    {
+      RETURN_VALUE = null;
+    }
+  }
+  
+  return self;
+}
+
+function Array_empty_q (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#empty?"))
+  {
+    return NULL;
+  }
+  
+  return (self.value.length == 0) ? TRUE : FALSE;
+}
+
+function Array_first (self, args)
+{
+  var num = args[0];
+  var items = self.value;
+  
+  if (xself(self, ARRAY_TYPE, "#first"))
+  {
+    return NULL;
+  }
+  
+  if (!num)
+  {
+    return items[0] || NULL;
+  }
+  
+  if (xarg(num, NUMBER_TYPE, "Array#first", "number or no"))
+  {
+    return NULL;
+  }
+  
+  var n = num.value;
+  var first_n = [];
+  
+  for (var i = 0; i < n; ++i)
+  {
+    var item = items[i];
+    
+    if (!item)
+    {
+      break;
+    }
+    
+    first_n[i] = item;
+  }
+  
+  return new_array(first_n);
+}
+
+function Array_get (self, args)
+{
+  var num = args[0];
+  
+  if (xself(self, ARRAY_TYPE, "#get") || xarg(num, NUMBER_TYPE, "number"))
+  {
+    return NULL;
+  }
+  
+  var items = self.value;
+  var i = num.value;
+  var l = items.length;
+  
+  if (i < 0)
+  {
+    i += l;
+  }
+  
+  return (i < l && i >= 0) ? items[i] : NULL;
+}
+
+function Array_inspect (self, args)
+{
+  return new_string('[...]');
+}
+
+function Array_join (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#join"))
+  {
+    return NULL;
+  }
+  
+  var separator = args[0];
+  var items = self.value;
+  var s = (separator) ? call_function(separator, 'stringify', []).value : '';
+  var string = '';
+  
+  for (var i = 0, l = items.length; i < l; ++i)
+  {
+    string += call_function(items[i], 'stringify', []).value;
+    
+    if (i < l - 1)
+    {
+      string += separator;
+    }
+  }
+  
+  return new_string(string);
+}
+
+function Array_last (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#last"))
+  {
+    return NULL;
+  }
+  
+  var num = args[0];
+  var items = self.value;
+  var l = items.length;
+  
+  if (!num)
+  {
+    return (l === 0) ? NULL : items[l - 1];
+  }
+  
+  if (xarg(num, NUMBER_TYPE, "Array#last", "number or no"))
+  {
+    return NULL;
+  }
+  
+  var n = num.value;
+  var last_n = [];
+  
+  for (var i = 1; i <= n; ++i)
+  {
+    var item = items[l - i];
+    
+    if (!item)
+    {
+      break;
+    }
+    
+    last_n[n - i] = item;
+  }
+  
+  return new_array(last_n);
+}
+
+function Array_length (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#length"))
+  {
+    return NULL;
+  }
+  
+  return new_number(self.value.length);
+}
+
+function Array_pop (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#pop"))
+  {
+    return NULL;
+  }
+  
+  var num = args[0];
+  var items = self.value;
+  var l = items.length;
+  
+  if (!num)
+  {
+    return (l === 0) ? NULL : items.pop();
+  }
+  
+  if (xarg(num, NUMBER_TYPE, "Array#pop", "number or no"))
+  {
+    return NULL;
+  }
+  
+  var n = num.value;
+  var popped = [];
+  
+  for (var i = 0; i < n; ++i)
+  {
+    var item = items.pop();
+    
+    if (!item)
+    {
+      break;
+    }
+    
+    popped[i] = item;
+  }
+  
+  return new_array(popped);
+}
+
+function Array_push (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#push"))
+  {
+    return NULL;
+  }
+  
+  var obj = args[0];
+  
+  if (xarg(obj, null, "Array#push", "an"))
+  {
+    return self;
+  }
+  
+  self.value.push(obj);
+  
+  return self;
+}
+
+function Array_sample (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#sample"))
+  {
+    return NULL;
+  }
+  
+  var items = self.value;
+  var l = items.length;
+  
+  if (!l)
+  {
+    return NULL;
+  }
+  
+  var i = Math.floor(Math.random() * l);
+  
+  return items[i];
+}
+
+function Array_set (self, args)
+{
+  var num = args[0];
+  var value = args[1]
+  
+  if (xself(self, ARRAY_TYPE, "#set") || xarg(num, NUMBER_TYPE, "number") || xarg(value, null, "value"))
+  {
+    return NULL;
+  }
+  
+  var items = self.value;
+  var i = num.value;
+  var l = items.length;
+  
+  if (i < 0)
+  {
+    i += l;
+  }
+  
+  if (i < 0)
+  {
+    warn("Ignoring out-of-range array assignment");
+    return value;
+  }
+  
+  while (items.length < i)
+  {
+    items.push(NULL);
+  }
+  
+  return items[i] = value;
+}
+
+function Array_shuffle (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#shuffle"))
+  {
+    return NULL;
+  }
+  
+  var items = self.value;
+  var l = items.length;
+  
+  if (l === 0)
+  {
+    return new_array([]);
+  }
+  
+  var shuffled = [items[0]];
+  
+  for (var i = 1, j; i < l; ++i)
+  {
+    j = Math.floor(Math.random() * (i + 1));
+    shuffled[i] = shuffled[j];
+    shuffled[j] = items[i];
+  };
+  
+  return new_array(shuffled);
+}
+
+function Array_shuffle_x (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#shuffle!"))
+  {
+    return NULL;
+  }
+  
+  var items = self.value;
+  var l = items.length;
+  
+  if (l > 1)
+  {
+    for (var i = l - 1, j, x; i > 0; --i)
+    {
+      j = Math.floor(Math.random() * (i + 1));
+      x = items[i];
+      items[i] = items[j];
+      items[j] = x;
+    }
+  }
+  
+  return self;
+}
+
+function Array_stringify (self, args)
+{
+  if (xself(self, ARRAY_TYPE, "#stringify"))
+  {
+    return NULL;
+  }
+  
+  var items = self.value;
+  var string = '';
+  
+  for (var i = 0, l = items.length; i < l; ++i)
+  {
+    string += call_function(items[i], 'inspect', []).value;
+    
+    if (i < l - 1)
+    {
+      string += ', ';
+    }
+  }
+  
+  return new_string('[' + string + ']');
+}
+
+add_function(ARRAY, 'all?', Array_all_q, ['function']);
+add_function(ARRAY, 'any?', Array_any_q, ['function']);
+add_function(ARRAY, 'brackets', Array_get, ['index']);
+add_function(ARRAY, 'brackets_eq', Array_set, ['index','value']);
+add_function(ARRAY, 'each', Array_each, ['function']);
+add_function(ARRAY, 'empty?', Array_empty_q, []);
+add_function(ARRAY, 'first', Array_first, ['(n)']);
+add_function(ARRAY, 'get', Array_get, ['index']);
+add_function(ARRAY, 'inspect', Array_inspect, []);
+add_function(ARRAY, 'join', Array_join, ['(separator)']);
+add_function(ARRAY, 'last', Array_last, ['(n)']);
+add_function(ARRAY, 'length', Array_length, []);
+add_function(ARRAY, 'ltlt', Array_push, ['object']);
+add_function(ARRAY, 'pop', Array_pop, ['(n)']);
+add_function(ARRAY, 'push', Array_push, ['object']);
+add_function(ARRAY, 'sample', Array_sample, []);
+add_function(ARRAY, 'set', Array_set, ['index','value']);
+add_function(ARRAY, 'shuffle', Array_shuffle, []);
+add_function(ARRAY, 'shuffle!', Array_shuffle_x, []);
+add_function(ARRAY, 'stringify', Array_stringify, []);

data/lib/javascript/base/env.js

@@ -0,0 +1,83 @@
+/**
+ *  Copyright © 2011 Jesse Sielaff
+ */
+
+var MIXINS = [];
+var VARIABLES = {};
+var LINE = 0;
+var FILE = '';
+var APP = null;
+var SELF = null;
+var ITERATING = 0;
+var BREAK_VALUE = null;
+var RETURN_VALUE = null;
+
+var startup = function ()
+{
+  SELF = APP = new_object({}, []);
+};
+
+function add_function (obj, fname, body, parameters)
+{
+  body.parameters = parameters;
+  obj.functions[fname] = body;
+}
+
+function bug (message)
+{
+  throw(message + ':\t' + FILE + ':' + LINE);
+}
+
+function call_function (obj, fname, args)
+{
+  var body = obj.functions[fname];
+  
+  if (!body)
+  {
+    var str = call_function(obj, 'inspect', []);
+    bug("Tried to call `" + fname + "' on " + str.value +  " using call_function");
+  }
+  
+  return body(obj, args);
+}
+
+function copy_functions (obj, source)
+{
+  var functions = source.functions;
+  
+  for (var fname in functions)
+  {
+    obj.functions[fname] = functions[fname];
+  }
+}
+
+function output (message)
+{
+  if (console && console.log)
+  {
+    console.log(message)
+  }
+}
+
+function warn (message)
+{
+  output(message + ":\t" + FILE + ":" + LINE);
+}
+
+function xarg (obj, type, fname, expectation)
+{
+  if (!obj || (type && (obj.object_type !== type)))
+  {
+    warn("Ignoring " + fname + ";" + " expected " + expectation + " argument");
+    return true;
+  }
+}
+
+function xself (obj, type, fname)
+{
+  if (!obj || (type && (obj.object_type !== type)))
+  {
+    warn("Ignoring " + fname + ";" + " unexpected receiver");
+    return true;
+  }
+}