mix-language 1.0.0

data/lib/javascript/base/eval.js

@@ -0,0 +1,419 @@
+/**
+ *  Copyright © 2011 Jesse Sielaff
+ */
+
+function evaluate (node)
+{
+  if (BREAK_VALUE || RETURN_VALUE)
+  {
+    return BREAK_VALUE || RETURN_VALUE;
+  }
+  
+  switch (node[0])
+  {
+    case access_brackets:
+      var obj = evaluate(node[1]);
+      var key = evaluate(node[2]);
+      
+      return call_function(obj, 'brackets', [key]);
+    
+    case access_colon:
+      var obj = evaluate(node[1]);
+      var name = SYMBOLS[node[2]];
+      
+      return obj.data[name] || obj.unknown(obj, [new_string(name)]);
+    
+    case access_hash:
+      var bound = evaluate(node[1]);
+      var name = SYMBOLS[node[2]];
+      
+      if (!bound)
+      {
+        bug("Tried to call " + name + " on a non-Mix value");
+      }
+      
+      var body = bound.functions[name];
+      
+      if (!body)
+      {
+        warn("Ignoring unknown function " + name);
+        body = function (self, args) { return NULL; };
+        body.parameters = [];
+      }
+      
+      return new_function(body, bound);
+    
+    case and:
+      var left = evaluate(node[1]);
+      return (left === NULL || left === FALSE) ? left : evaluate(node[2]);
+    
+    case app:
+      return APP;
+    
+    case array:
+      var items = [];
+      var item_nodes = node[1];
+      
+      for (var i = 0, l = item_nodes.length; i < l; ++i)
+      {
+        items[i] = evaluate(item_nodes[i]);
+      }
+      
+      return new_array(items);
+    
+    case break:
+      if (!ITERATING)
+      {
+        warn("Ignoring break outside of iteration context");
+        return NULL;
+      }
+      
+      BREAK_VALUE = evaluate(node[1]);
+      return NULL;
+    
+    case call:
+      var func = evaluate(node[1]);
+      
+      if (func.object_type !== FUNCTION_TYPE)
+      {
+        warn("Ignoring function call to a non-function object");
+        return func;
+      }
+      
+      var argument_nodes = node[2];
+      var arguments = [];
+      
+      for (var i = 0, l = argument_nodes.length; i < l; ++i)
+      {
+        arguments[i] = evaluate(argument_nodes[i]);
+      }
+      
+      var result = func.value(func.bound, arguments);
+      
+      if (RETURN_VALUE)
+      {
+        result = RETURN_VALUE;
+        RETURN_VALUE = null;
+      }
+      
+      return result;
+    
+    case false:
+      return FALSE;
+    
+    case function:
+      var variables = node[1];
+      var body_statement = node[2];
+      var parameters = variables[0];
+      var embedded = variables[1];
+      var embedded_values = [];
+      
+      for (var name, i = 0, l = embedded.length; i < l; ++i)
+      {
+        name = SYMBOLS[embedded[i]];
+        embedded_values[name] = VARIABLES[name];
+      }
+      
+      var body = function (self, args)
+      {
+        var old_self = SELF;
+        var old_variables = VARIABLES;
+        
+        SELF = self;
+        VARIABLES = {};
+        
+        for (var name, i = 0, l = embedded.length; i < l; ++i)
+        {
+          name = SYMBOLS[embedded[i]];
+          VARIABLES[name] = embedded_values[name];
+        }
+        
+        for (var name, i = 0, l = parameters.length; i < l; ++i)
+        {
+          name = SYMBOLS[parameters[i]];
+          VARIABLES[name] = args[i];
+        }
+        
+        var result = evaluate(body_statement);
+        
+        SELF = old_self;
+        VARIABLES = old_variables;
+        
+        return result;
+      };
+      
+      for (var p = [], i = 0, l = parameters.length; i < l; ++i)
+      {
+        p[i] = SYMBOLS[parameters[i]];
+      }
+      
+      body.parameters = p;
+      
+      return new_function(body, SELF);
+    
+    case if:
+      var condition = evaluate(node[1]);
+      
+      if (condition !== NULL && condition !== FALSE)
+      {
+        return evaluate(node[2]);
+      }
+      else
+      {
+        return evaluate(node[3]);
+      }
+    
+    case mix:
+      var obj = evaluate(node[1]);
+      var name = SYMBOLS[node[2]];
+      var mixin = (MIXINS[name] = MIXINS[name] || {functions: {}});
+      
+      copy_functions(obj, mixin);
+      
+      if (init_function = mixin.init)
+      {
+        init_function(obj);
+      }
+      
+      return obj;
+    
+    case mixin:
+      var name = SYMBOLS[node[1]];
+      var mixin = (MIXINS[name] = MIXINS[name] || {functions: {}});
+      var init_statement = node[2];
+      var function_defs = node[3];
+      
+      var old_self = SELF;
+      SELF = mixin;
+      
+      for (var i = 0, l = function_defs.length; i < l; ++i)
+      {
+        evaluate(function_defs[i]);
+      }
+      
+      SELF = old_self;
+      
+      mixin.init = function (obj)
+      {
+        var old_self = SELF;
+        SELF = obj;
+        
+        evaluate(init_statement);
+        
+        SELF = old_self;
+      }
+      
+      return NULL;
+    
+    case newline:
+      FILE = SYMBOLS[node[1]];
+      LINE = node[2]
+      
+      return evaluate(node[3]);
+    
+    case not:
+      var value = evaluate(node[1]);
+      return (value === NULL || value === FALSE) ? TRUE : FALSE;
+    
+    case null:
+      return NULL;
+    
+    case number:
+      return new_number(node[1]);
+    
+    case object:
+      var kv_pairs = node[1];
+      var mixins = node[2];
+      var mixin_names = [];
+      var fields = {};
+      var keys = [];
+      
+      for (var kv, key, i = 0, l = kv_pairs.length; i < l; ++i)
+      {
+        kv = kv_pairs[i];
+        key = SYMBOLS[kv[0]];
+        keys.push(key);
+        fields[key] = evaluate(kv[1]);
+      }
+      
+      for (var i = 0, l = mixins.length; i < l; ++i)
+      {
+        mixin_names[i] = SYMBOLS[mixins[i]];
+      }
+      
+      var element_type = HTML_TYPES[mixin_names[0]];
+      
+      if (element_type)
+      {
+        mixin_names.shift();
+        var obj = new_element(element_type, fields, keys);
+      }
+      else if (mixin_names[0] === 'Text')
+      {
+        mixin_names.shift();
+        var obj = new_text(fields, keys);
+      }
+      else
+      {
+        var obj = new_object(fields, keys);
+      }
+      
+      for (var m, i = 0, l = mixin_names.length; i < l; ++i)
+      {
+        if (m = MIXINS[mixin_names[i]])
+        {
+          copy_functions(obj, m);
+          
+          if (init_function = m.init)
+          {
+            init_function(obj);
+          }
+        }
+        else
+        {
+          warn("Ignoring unknown mixin `" + mixin_names[i] + "'");
+        }
+      }
+      
+      return obj;
+    
+    case op:
+      var name = SYMBOLS[node[1]];
+      var left = evaluate(node[2]);
+      var right = evaluate(node[3]);
+      
+      return call_function(left, name, [right]);
+    
+    case or:
+      var left = evaluate(node[1]);
+      return (left !== NULL && left !== FALSE) ? left : evaluate(node[2]);
+    
+    case return:
+      RETURN_VALUE = evaluate(node[1]);
+      return NULL;
+    
+    case self:
+      return SELF;
+    
+    case set:
+      var lhs_node = node[1];
+      var value = evaluate(node[2]);
+      
+      switch (lhs_node[0])
+      {
+        case access_brackets:
+          var obj = evaluate(lhs_node[1]);
+          var key = evaluate(lhs_node[2]);
+          
+          return call_function(obj, 'brackets_eq', [key, value]);
+        
+        case access_colon:
+          var obj = evaluate(lhs_node[1]);
+          var name = SYMBOLS[lhs_node[2]];
+          
+          if (!obj.data[name])
+          {
+            obj.keys.push(name);
+          }
+          
+          return obj.data[name] = value;
+        
+        case access_hash:
+          var obj = evaluate(lhs_node[1]);
+          var name = SYMBOLS[lhs_node[2]];
+          
+          if (value.object_type === FUNCTION_TYPE)
+          {
+            var func = value;
+            func.bound = obj;
+          }
+          else
+          {
+            warn("Assigning a non-function object as a function");
+            var func = new_function(function (self, args) { return value; }, obj);
+            func.value.parameters = [];
+          }
+          
+          obj.functions[name] = func.value;
+          
+          return func;
+        
+        case variable:
+          return VARIABLES[SYMBOLS[lhs_node[1]]] = value;
+      }
+    
+    case statement:
+      var statement = node[1];
+      var next_statement = node[2];
+      
+      var result = evaluate(statement);
+      
+      return (next_statement) ? evaluate(next_statement) : result;
+    
+    case string:
+      return new_string(SYMBOLS[node[1]]);
+    
+    case switch:
+      var condition = evaluate(node[1]);
+      var cases = node[2];
+      var else_case = node[3];
+      
+      for (var c, test, i = 0, l = cases.length; i < l; ++i)
+      {
+        c = cases[i];
+        test = call_function(condition, 'eq', [evaluate(c[0])]);
+        
+        if (test !== FALSE && test !== NULL)
+        {
+          return evaluate(c[1]);
+        }
+      }
+      
+      return (else_case) ? evaluate(else_case) : NULL;
+    
+    case true:
+      return TRUE;
+    
+    case variable:
+      var name = SYMBOLS[node[1]];
+      var value = VARIABLES[name];
+      
+      if (!value)
+      {
+        warn("Ignoring unknown variable `" + name + "'");
+        return NULL;
+      }
+      
+      return value;
+    
+    case while:
+      var test = function (value)
+      {
+        return (value !== FALSE) && (value !== NULL);
+      };
+      
+      while (test(evaluate(node[1])))
+      {
+        ITERATING += 1;
+        evaluate(node[2]);
+        ITERATING -= 1;
+        
+        if (BREAK_VALUE)
+        {
+          var result = BREAK_VALUE;
+          
+          BREAK_VALUE = null;
+          return result;
+        }
+        else if (RETURN_VALUE)
+        {
+          return RETURN_VALUE;
+        }
+      }
+      
+      return NULL;
+    
+    default:
+      bug("Unable to evaluate a node:\t" + node[0] || node);
+  }
+}

data/lib/javascript/base/false.js

@@ -0,0 +1,23 @@
+/**
+ *  Copyright © 2011 Jesse Sielaff
+ */
+
+var FALSE =
+{
+  object_type: FALSE_TYPE,
+  functions: {},
+  data: {},
+  keys: [],
+  unknown: Object_bad_key,
+  value: false
+}
+
+copy_functions(FALSE, OBJECT);
+
+function False_stringify (self, args)
+{
+  return new_string('false');
+}
+
+add_function(FALSE, 'inspect', False_stringify, []);
+add_function(FALSE, 'stringify', False_stringify, []);

data/lib/javascript/base/function.js

@@ -0,0 +1,95 @@
+/**
+ *  Copyright © 2011 Jesse Sielaff
+ */
+
+var FUNCTION =
+{
+  functions: {}
+};
+
+copy_functions(FUNCTION, OBJECT);
+
+function new_function (body, bound)
+{
+  var func =
+  {
+    object_type: FUNCTION_TYPE,
+    functions: {},
+    data: {},
+    keys: [],
+    unknown: Object_bad_key,
+    value: body,
+    bound: bound
+  };
+  
+  copy_functions(func, FUNCTION);
+  
+  return func;
+}
+
+function Function_bind (self, args)
+{
+  if (xself(self, FUNCTION_TYPE, "#bind"))
+  {
+    return NULL;
+  }
+  
+  var obj = args[0];
+  
+  if (xarg(obj, null, "Function#bind", "an"))
+  {
+    return self;
+  }
+  
+  self.bound = obj;
+  
+  return self;
+}
+
+function Function_bound (self, args)
+{
+  if (xself(self, FUNCTION_TYPE, "#bound"))
+  {
+    return NULL;
+  }
+  
+  return self.bound;
+}
+
+function Function_parameters (self, args)
+{
+  if (xself(self, FUNCTION_TYPE, "#parameters"))
+  {
+    return NULL;
+  }
+  
+  var parameters = self.body.parameters;
+  var names = [];
+  
+  for (var i = 0, l = parameters.length; i < l; ++i)
+  {
+    names[i] = new_string(parameters[i]);
+  }
+  
+  return new_array(names);
+}
+
+function Function_stringify (self, args)
+{
+  if (xself(self, FUNCTION_TYPE, "#stringify"))
+  {
+    return NULL;
+  }
+  
+  var body = self.value;
+  var parameters = body.parameters;
+  var string = (parameters.length == 0) ? '# {...}' : '|' + parameters + '| {...}';
+  
+  return new_string(string);
+}
+
+add_function(FUNCTION, 'bind', Function_bind, ['object']);
+add_function(FUNCTION, 'bound', Function_bound, []);
+add_function(FUNCTION, 'inspect', Function_stringify, []);
+add_function(FUNCTION, 'parameters', Function_parameters, []);
+add_function(FUNCTION, 'stringify', Function_stringify, []);

data/lib/javascript/base/null.js

@@ -0,0 +1,23 @@
+/**
+ *  Copyright © 2011 Jesse Sielaff
+ */
+
+var NULL =
+{
+  object_type: NULL_TYPE,
+  functions: {},
+  data: {},
+  keys: [],
+  unknown: Object_bad_key,
+  value: null
+}
+
+copy_functions(NULL, OBJECT);
+
+function Null_stringify (self, args)
+{
+  return new_string('null');
+}
+
+add_function(NULL, 'inspect', Null_stringify, []);
+add_function(NULL, 'stringify', Null_stringify, []);