Steigerwald

steigerwald.js

impress_src = read("test.js");
program = Reflect.parse(impress_src);
print(node_varrefs(program));


// Accepts any number of Node objects or arrays of node objects defined by the Parser API
// Returns an array of all varrefs declared in those nodes
function node_varrefs() {
   // Step through the array of nodes
   var args = Array.prototype.slice.call(arguments); 
   if (args.length > 1) {
      varrefs = node_varrefs(args.shift());
      varrefs.concat(node_varrefs(args));
   } else if (args.length == 0) {
      return [];
   }

   // The node we intend to examine
   node = args[0];
   if (node == null)
      return [];

   // If instead of a node we get an array, recurse with the array
   if ( Object.prototype.toString.call(node) === '[object Array]')
      return node_varrefs.apply(this,node);

   // Ok, we got a node, now recurse sub-nodes using the API
   switch (node.type) {
      case "Program": return node_varrefs(node.body);
      case "Function": return node_varrefs(node.id, node.params, node.body);

      case "EmptyStatement": return [];
      case "BlockStatement": return node_varrefs(node.body);
      case "ExpressionStatement": return node_varrefs(node.expression);
      case "IfStatement": return node_varrefs(node.consequest, node.alternate, node.node);
      case "BreakStatement": return node_varrefs(node.label);
      case "ContinueStatement": return node_varrefs(node.label);
      case "WithStatement": return node_varrefs(node.object, node.body);
      case "SwitchStatement": return node_varrefs(node.discriminant, node.cases);
      case "ReturnStatement": return node_varrefs(node.argument);
      case "ThrowStatement": return node_varrefs(node.argument);
      case "TryStatement": return node_varrefs(node.block, node.handlers, node.finalizer);
      case "WhileStatement": return node_varrefs(node.test, node.body);
      case "DoWhileStatement": return node_varrefs(node.test, node.body);
      case "ForStatement": return node_varrefs(node.init, node.test, node.update, node.body);
      case "ForInStatement": return node_varrefs(node.left, node.right, node.body);

      case "FunctionDeclaration": return node_varrefs(node.id, node.body, node.params);
      case "VariableDeclaration": return node_varrefs(node.declarations);
      case "VariableDeclarator": return node_varrefs(node.id, node.init);
 
      case "ThisExpression": return [];
      case "ArrayExpression": return node_varrefs(node.elements);
      case "ObjectExpression": return node_varrefs([[a.key, a.value] for (a in node.properties)]);
      case "FunctionExpression": return node_varrefs(node.id, node.params, node.body);
      case "SequenceExpression": return node_varrefs(node.expressions);
      case "UnaryExpression": return node_varrefs(node.argument);
      case "BinaryExpression": return node_varrefs(node.left, node.right);
      case "AssignmentExpression": return node_varrefs(node.left, node.right);
      case "UpdateExpression": return node_varrefs(node.argument);
      case "LogicalExpression": return node_varrefs(node.left, node.right); 
      case "ConditionalExpression": return node_varrefs(node.test, node.alternate, node.consequent);
      case "NewExpression": return node_varrefs(node.constructor, node.arguments);
      case "CallExpression": return node_varrefs(node.callee,node.arguments);
      case "MemberExpression": return node_varrefs(node.object, node.property);

      case "ObjectPattern": return node_varrefs([[a.key, a.value] for (a in node.properties)]);
      case "ArrayPattern": return node_varrefs(node.elements);

      case "SwitchCase": return node_varrefs(node.test,node.consequent);
      case "CatchClause": return node_varrefs(node.param, node.guard, node.body);

      case "Identifier": 
         print(node.name);
         return [node.name];
      case "Literal": return [];

      default: print("!!!"+node.type);
      return [];
   }
}