spider-src 0.1.5

data/lib/spider-src/support/spider/src/ast/expressions/UpdateExpression.spider

@@ -0,0 +1,28 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn UpdateExpression(argument, operator, prefix)
+  extends Node {
+  
+  this.type = 'UpdateExpression';
+  this.operator = operator;
+  this.prefix = prefix;
+  
+  this.argument = argument;
+  this.argument.parent = this;
+}
+
+UpdateExpression.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  return this;
+};
+
+UpdateExpression.prototype.hasCallExpression = () -> {
+  return this.argument != null && this.left.hasCallExpression();
+};
+
+exports.UpdateExpression = UpdateExpression;

data/lib/spider-src/support/spider/src/ast/literals/BooleanLiteral.spider

@@ -0,0 +1,23 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn BooleanLiteral(text)
+  extends Node {
+  
+  this.type = 'Literal';
+  this.value = text == "true";
+  this.raw = text;
+}
+
+BooleanLiteral.prototype.codegen = () -> { 
+  if !super.codegen() {
+    return;
+  }
+  
+  return this; 
+};
+
+BooleanLiteral.prototype.hasCallExpression = () -> false;
+
+exports.BooleanLiteral = BooleanLiteral;

data/lib/spider-src/support/spider/src/ast/literals/Identifier.spider

@@ -0,0 +1,68 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn Identifier(name)
+  extends Node {
+  
+  this.type = 'Identifier';
+  this.global = false;
+  
+  ::Object.defineProperty(this, 'name', { 
+    value: name, 
+    enumerable: true 
+  });  
+}
+
+Identifier.prototype.codegen = (undefinedCheck = true) -> {
+  if !super.codegen() {
+    return;
+  }
+    
+  // Compile-time undefined check
+  if (undefinedCheck && !this.global) {
+    // If this is not a new identifier, ...
+    if !(this.parent?.type in ["FunctionDeclaration", "VariableDeclarator"] &&
+         this.parent.id == this) {
+      // ... and this identifier is undefined, raise an error
+      if (!this.parent.isIdentifierDefined(this.name)) {
+        Node.getErrorManager().error({
+          type: "UndefinedIdentifier",
+          identifier: this.name,
+          message: "undefined " + this.name,
+          loc: this.loc
+        });
+      }
+    } else {
+      // If this is a new identifier, and this identifier 
+      // is already defined, raise an error
+      if (this.parent.isIdentifierDefined(this.name)) {
+        Node.getErrorManager().error({
+          type: "AlreadyDefinedIdentifier",
+          identifier: this.name,
+          message: this.name + " is already defined",
+          loc: this.loc
+        });
+      } else {
+        // otherwise, define this identifier
+        this.parent.getContext().node.defineIdentifier(this);
+      }
+    }
+  }
+  
+  return this;
+};
+
+Identifier.prototype.hasCallExpression = () -> false;
+
+Identifier.prototype.asGlobal = () -> {
+  this.global = true;
+  return this;
+};
+
+Identifier.prototype.asPredefinedCollection = () -> {
+  this.predefinedCollection = true;
+  return this;
+};
+
+exports.Identifier = Identifier;

data/lib/spider-src/support/spider/src/ast/literals/NullLiteral.spider

@@ -0,0 +1,23 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn NullLiteral()
+  extends Node {
+  
+  this.type = 'Literal';
+  this.value = null;
+  this.raw = "null";
+}
+
+NullLiteral.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  return this;
+};
+
+NullLiteral.prototype.hasCallExpression = () -> false;
+
+exports.NullLiteral = NullLiteral;

data/lib/spider-src/support/spider/src/ast/literals/NumberLiteral.spider

@@ -0,0 +1,23 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn NumberLiteral(text)
+  extends Node {
+  
+  this.type = 'Literal';
+  this.value = ::Number(text);
+  this.raw = text;
+}
+
+NumberLiteral.prototype.codegen = () -> { 
+  if !super.codegen() {
+    return;
+  }
+  
+  return this; 
+};
+
+NumberLiteral.prototype.hasCallExpression = () -> false;
+
+exports.NumberLiteral = NumberLiteral;

data/lib/spider-src/support/spider/src/ast/literals/RegularExpressionLiteral.spider

@@ -0,0 +1,24 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn RegularExpressionLiteral(pattern, flags)
+  extends Node {
+  
+  this.type = 'Literal';
+  this.pattern = pattern;
+  this.flags = flags;
+}
+
+RegularExpressionLiteral.prototype.codegen = () -> { 
+  if !super.codegen() {
+    return;
+  }
+  
+  this.value = new ::RegExp(this.pattern, this.flags);
+  return this; 
+};
+
+RegularExpressionLiteral.prototype.hasCallExpression = () -> false;
+
+exports.RegularExpressionLiteral = RegularExpressionLiteral;

data/lib/spider-src/support/spider/src/ast/literals/StringLiteral.spider

@@ -0,0 +1,91 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn StringLiteral(chars, column)
+  extends Node {
+  
+  this.type = 'StringLiteral';
+  this.chars = chars;
+  this.column = column;
+}
+
+StringLiteral.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var elements = [];
+  
+  for value in this.chars {
+    var lastElement;
+    
+    if typeof value == 'string' {
+      lastElement = elements[elements.length - 1];
+      if lastElement?.type == 'Literal' {
+        lastElement.value += value;
+      } else {
+        elements.push({
+          type: 'Literal',
+          value: value
+        });
+      }
+    } else if value?.type == "StringLiteralNewLine" {
+      lastElement = elements[elements.length - 1];
+      if lastElement?.type == 'Literal' {
+        lastElement.value += value.toString(this.column - 1);
+      } else {
+        elements.push({
+          type: 'Literal',
+          value: value.toString(this.column - 1)
+        });
+      }
+    } else {
+      value.parent = this;
+      elements.push(value.codegen());
+    }
+  }
+  
+  if elements.length == 0 {
+    return {
+      "type": "Literal",
+      "value": ""
+    };
+  } else if elements.length == 1 {
+    return elements[0];
+  }
+  
+  var reduced = elements.reduce((left, right) -> {
+    return {
+      type: 'BinaryExpression',
+      operator: '+',
+      left: left,
+      right: right
+    };
+  });
+    
+  this.type = reduced.type;
+  this.operator = reduced.operator;
+  this.left = reduced.left;
+  this.right = reduced.right;
+  
+  return this;
+};
+
+StringLiteral.prototype.hasCallExpression = () -> false;
+
+StringLiteral.NewLine = fn (text) {
+  this.type = "StringLiteralNewLine";
+  
+  this.toString = (column) -> {
+	var t = text.replace(/\r\n/g, '').replace(/\t/g, '    ');
+	
+    if t.length < column {
+      return '';
+    }
+    
+    return t.substring(column);
+  };
+};
+
+exports.StringLiteral = StringLiteral;

data/lib/spider-src/support/spider/src/ast/literals/UndefinedLiteral.spider

@@ -0,0 +1,30 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn UndefinedLiteral()
+  extends Node {
+  
+  this.type = 'UndefinedLiteral';
+}
+
+UndefinedLiteral.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.type = "UnaryExpression";
+  this.operator = "void";
+  this.argument = {
+    "type": "Literal",
+    "value": 0,
+    "raw": "0"
+  };
+  this.prefix = true;
+  
+  return this;
+};
+
+UndefinedLiteral.prototype.hasCallExpression = () -> false;
+
+exports.UndefinedLiteral = UndefinedLiteral;

data/lib/spider-src/support/spider/src/ast/statements/BlockStatement.spider

@@ -0,0 +1,45 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn BlockStatement(body)
+  extends Node {
+  
+  this.type = 'BlockStatement';
+  this.body = body;
+  
+  for statement, i in body {
+    if statement {
+      statement.parent = this;
+    } else {
+      body[i] = { type: 'EmptyStatement' };
+    }
+  }
+}
+
+BlockStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var i = 0;
+  while (i < this.body.length) {
+    var statement = this.body[i];
+    
+    if !statement || statement.codeGenerated {
+      i++;
+      continue;
+    }
+    
+    if statement.codegen?() {
+      this.body[this.body.indexOf(statement)] = statement;
+      i++;
+    } else {
+      this.body.splice(i, 1);
+    }
+  }
+  
+  return this;
+};
+
+exports.BlockStatement = BlockStatement;

data/lib/spider-src/support/spider/src/ast/statements/BreakStatement.spider

@@ -0,0 +1,19 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn BreakStatement()
+  extends Node {
+  
+  this.type = 'BreakStatement';
+}
+
+BreakStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  return this;
+};
+
+exports.BreakStatement = BreakStatement;

data/lib/spider-src/support/spider/src/ast/statements/ContinueStatement.spider

@@ -0,0 +1,19 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ContinueStatement()
+  extends Node {
+  
+  this.type = 'ContinueStatement';
+}
+
+ContinueStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  return this;
+};
+
+exports.ContinueStatement = ContinueStatement;

data/lib/spider-src/support/spider/src/ast/statements/DebuggerStatement.spider

@@ -0,0 +1,19 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn DebuggerStatement()
+  extends Node {
+  
+  this.type = 'DebuggerStatement';
+}
+
+DebuggerStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  return this;
+};
+
+exports.DebuggerStatement = DebuggerStatement;

data/lib/spider-src/support/spider/src/ast/statements/DoWhileStatement.spider

@@ -0,0 +1,28 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn DoWhileStatement(test, body)
+  extends Node {
+  
+  this.type = 'DoWhileStatement';
+  
+  this.test = test;
+  this.test.parent = this;
+  
+  this.body = body;
+  this.body.parent = this;
+}
+
+DoWhileStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.test = this.test.codegen();
+  this.body = this.body.blockWrap().codegen();
+  
+  return this;
+};
+
+exports.DoWhileStatement = DoWhileStatement;

data/lib/spider-src/support/spider/src/ast/statements/ExportDeclarationStatement.spider

@@ -0,0 +1,46 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ExportDeclarationStatement(specifiers, source, declaration, isDefault)
+  extends Node {
+  
+  this.type = "ExportDeclaration";
+  this['default'] = isDefault;
+  
+  this.specifiers = specifiers;
+  if specifiers? {
+    for specifier in this.specifiers {
+      specifier.parent = this;
+    }
+  }
+  
+  this.source = source;
+  if source? {
+    this.source.parent = this;
+  }
+  
+  this.declaration = declaration;
+  if declaration? {
+    this.declaration.parent = this;
+  }
+}
+
+ExportDeclarationStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  if this.specifiers? {
+    for specifier, i in this.specifiers {
+      this.specifiers[i] = specifier.codegen();
+    }
+  }
+  
+  this.source = this.source?.codegen();
+  this.declaration = this.declaration?.codegen();
+    
+  return this;
+};
+
+exports.ExportDeclarationStatement = ExportDeclarationStatement;

data/lib/spider-src/support/spider/src/ast/statements/ExpressionStatement.spider

@@ -0,0 +1,22 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ExpressionStatement(expression)
+  extends Node {
+  
+  this.type = 'ExpressionStatement';
+  this.expression = expression;
+  this.expression.parent = this;
+}
+
+ExpressionStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+    
+  this.expression = this.expression.codegen();
+  return this;
+};
+
+exports.ExpressionStatement = ExpressionStatement;

data/lib/spider-src/support/spider/src/ast/statements/FallthroughStatement.spider

@@ -0,0 +1,85 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn FallthroughStatement()
+  extends Node {
+  
+  this.type = 'FallthroughStatement';
+}
+
+FallthroughStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  var parent = this.parent;
+  var iterations = 0;
+  
+  while parent? and !parent.switchCase {
+    parent = parent.parent;
+    iterations++;
+  }
+  
+  if parent? {
+    parent.fallthrough = true;
+  } else {
+    Node.getErrorManager().error({
+      type: "InvalidFallthroughContext",
+      message: "fallthrough statement is only allowed in a switch case clause.",
+      loc: this.loc
+    });
+  }
+  
+  var switchStatement = parent.parent;
+  
+  if !switchStatement.fallthroughId {
+    switchStatement.fallthroughId = {
+      "type": "Identifier",
+      "name": FallthroughStatement.getNextVariableName()
+    };
+  }
+  
+  switchStatement.branchFallthrough = true;
+  
+  parent.body.body = [{
+    "type": "ExpressionStatement",
+    "codeGenerated": true,
+    "expression": {
+      "type": "AssignmentExpression",
+      "operator": "=",
+      "left": switchStatement.fallthroughId,
+      "right": {
+        "type": "Literal",
+        "value": 2
+      }
+    }
+  }].concat(parent.body.body);
+    
+  this.type = "ExpressionStatement";
+  this.expression = {
+    "type": "AssignmentExpression",
+    "operator": "=",
+    "left": switchStatement.fallthroughId,
+    "right": {
+      "type": "Literal",
+      "value": 1
+    }
+  };
+  
+  return this;
+};
+
+FallthroughStatement.getNextVariableName = () -> {
+  if (!this.fallthroughIndex?) { 
+    this.fallthroughIndex = 0; 
+  }
+
+  return "fallthrough" + this.fallthroughIndex++;
+};
+
+FallthroughStatement.resetVariableNames = () -> {
+  this.fallthroughIndex = 0;
+};
+
+exports.FallthroughStatement = FallthroughStatement;

data/lib/spider-src/support/spider/src/ast/statements/ForInStatement.spider

@@ -0,0 +1,92 @@
+use :node;
+
+var Node = module.require('../Node').Node;
+
+fn ForInStatement(item, index, array, body)
+  extends Node {
+  
+  this.type = 'ForInStatement';
+  
+  this.item = item;
+  this.item.parent = this;
+  
+  this.index = index;
+  if this.index? {
+    this.index.parent = this;
+  }
+  
+  this.array = array;
+  this.array.parent = this;
+  
+  this.body = body;
+  this.body.parent = this;
+}
+
+ForInStatement.prototype.codegen = () -> {
+  if !super.codegen() {
+    return;
+  }
+  
+  this.item = this.item.codegen(false);
+  
+  if this.index? {
+    var context = this.getContext();
+    this.index = this.index.codegen(false);
+    
+    context.node.body.splice(context.position, 0, {
+      "type": "VariableDeclaration",
+      "declarations": [{
+        "type": "VariableDeclarator",
+        "id": this.index,
+        "init": {
+          "type": "Literal",
+          "value": 0
+        }
+      }],
+      "kind": "let"
+    });
+  }
+
+  if !this.array.codeGenerated {
+    this.array = this.array.codegen();
+  }
+ 
+  this.body = this.body.blockWrap();
+  this.body.defineIdentifier(this.item);
+  
+  if this.index? {
+    this.body.defineIdentifier(this.index);
+  }
+  
+  this.body = this.body.codegen();
+  
+  if this.index? {
+    this.body.body.push({
+      "type": "ExpressionStatement",
+      "codeGenerated": true,
+      "expression": {
+        "type": "UpdateExpression",
+        "operator": "++",
+        "argument": this.index,
+        "prefix": false
+      }
+    });
+  }
+  
+  this.type = "ForOfStatement";
+  this.right = this.array;
+  this.left = {
+    "type": "VariableDeclaration",
+    "declarations": [{
+      "type": "VariableDeclarator",
+      "id": this.item,
+      "init": null
+    }],
+    "kind": "let"
+  };
+  this.each = false;
+    
+  return this;
+};
+
+exports.ForInStatement = ForInStatement;