/*
							 | 
						|
								  Copyright (C) 2013 Yusuke Suzuki <utatane.tea@gmail.com>
							 | 
						|
								
							 | 
						|
								  Redistribution and use in source and binary forms, with or without
							 | 
						|
								  modification, are permitted provided that the following conditions are met:
							 | 
						|
								
							 | 
						|
								    * Redistributions of source code must retain the above copyright
							 | 
						|
								      notice, this list of conditions and the following disclaimer.
							 | 
						|
								    * Redistributions in binary form must reproduce the above copyright
							 | 
						|
								      notice, this list of conditions and the following disclaimer in the
							 | 
						|
								      documentation and/or other materials provided with the distribution.
							 | 
						|
								
							 | 
						|
								  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
							 | 
						|
								  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
							 | 
						|
								  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
							 | 
						|
								  ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
							 | 
						|
								  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
							 | 
						|
								  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
							 | 
						|
								  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
							 | 
						|
								  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
							 | 
						|
								  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
							 | 
						|
								  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
							 | 
						|
								*/
							 | 
						|
								
							 | 
						|
								(function () {
							 | 
						|
								    'use strict';
							 | 
						|
								
							 | 
						|
								    function isExpression(node) {
							 | 
						|
								        if (node == null) { return false; }
							 | 
						|
								        switch (node.type) {
							 | 
						|
								            case 'ArrayExpression':
							 | 
						|
								            case 'AssignmentExpression':
							 | 
						|
								            case 'BinaryExpression':
							 | 
						|
								            case 'CallExpression':
							 | 
						|
								            case 'ConditionalExpression':
							 | 
						|
								            case 'FunctionExpression':
							 | 
						|
								            case 'Identifier':
							 | 
						|
								            case 'Literal':
							 | 
						|
								            case 'LogicalExpression':
							 | 
						|
								            case 'MemberExpression':
							 | 
						|
								            case 'NewExpression':
							 | 
						|
								            case 'ObjectExpression':
							 | 
						|
								            case 'SequenceExpression':
							 | 
						|
								            case 'ThisExpression':
							 | 
						|
								            case 'UnaryExpression':
							 | 
						|
								            case 'UpdateExpression':
							 | 
						|
								                return true;
							 | 
						|
								        }
							 | 
						|
								        return false;
							 | 
						|
								    }
							 | 
						|
								
							 | 
						|
								    function isIterationStatement(node) {
							 | 
						|
								        if (node == null) { return false; }
							 | 
						|
								        switch (node.type) {
							 | 
						|
								            case 'DoWhileStatement':
							 | 
						|
								            case 'ForInStatement':
							 | 
						|
								            case 'ForStatement':
							 | 
						|
								            case 'WhileStatement':
							 | 
						|
								                return true;
							 | 
						|
								        }
							 | 
						|
								        return false;
							 | 
						|
								    }
							 | 
						|
								
							 | 
						|
								    function isStatement(node) {
							 | 
						|
								        if (node == null) { return false; }
							 | 
						|
								        switch (node.type) {
							 | 
						|
								            case 'BlockStatement':
							 | 
						|
								            case 'BreakStatement':
							 | 
						|
								            case 'ContinueStatement':
							 | 
						|
								            case 'DebuggerStatement':
							 | 
						|
								            case 'DoWhileStatement':
							 | 
						|
								            case 'EmptyStatement':
							 | 
						|
								            case 'ExpressionStatement':
							 | 
						|
								            case 'ForInStatement':
							 | 
						|
								            case 'ForStatement':
							 | 
						|
								            case 'IfStatement':
							 | 
						|
								            case 'LabeledStatement':
							 | 
						|
								            case 'ReturnStatement':
							 | 
						|
								            case 'SwitchStatement':
							 | 
						|
								            case 'ThrowStatement':
							 | 
						|
								            case 'TryStatement':
							 | 
						|
								            case 'VariableDeclaration':
							 | 
						|
								            case 'WhileStatement':
							 | 
						|
								            case 'WithStatement':
							 | 
						|
								                return true;
							 | 
						|
								        }
							 | 
						|
								        return false;
							 | 
						|
								    }
							 | 
						|
								
							 | 
						|
								    function isSourceElement(node) {
							 | 
						|
								      return isStatement(node) || node != null && node.type === 'FunctionDeclaration';
							 | 
						|
								    }
							 | 
						|
								
							 | 
						|
								    function trailingStatement(node) {
							 | 
						|
								        switch (node.type) {
							 | 
						|
								        case 'IfStatement':
							 | 
						|
								            if (node.alternate != null) {
							 | 
						|
								                return node.alternate;
							 | 
						|
								            }
							 | 
						|
								            return node.consequent;
							 | 
						|
								
							 | 
						|
								        case 'LabeledStatement':
							 | 
						|
								        case 'ForStatement':
							 | 
						|
								        case 'ForInStatement':
							 | 
						|
								        case 'WhileStatement':
							 | 
						|
								        case 'WithStatement':
							 | 
						|
								            return node.body;
							 | 
						|
								        }
							 | 
						|
								        return null;
							 | 
						|
								    }
							 | 
						|
								
							 | 
						|
								    function isProblematicIfStatement(node) {
							 | 
						|
								        var current;
							 | 
						|
								
							 | 
						|
								        if (node.type !== 'IfStatement') {
							 | 
						|
								            return false;
							 | 
						|
								        }
							 | 
						|
								        if (node.alternate == null) {
							 | 
						|
								            return false;
							 | 
						|
								        }
							 | 
						|
								        current = node.consequent;
							 | 
						|
								        do {
							 | 
						|
								            if (current.type === 'IfStatement') {
							 | 
						|
								                if (current.alternate == null)  {
							 | 
						|
								                    return true;
							 | 
						|
								                }
							 | 
						|
								            }
							 | 
						|
								            current = trailingStatement(current);
							 | 
						|
								        } while (current);
							 | 
						|
								
							 | 
						|
								        return false;
							 | 
						|
								    }
							 | 
						|
								
							 | 
						|
								    module.exports = {
							 | 
						|
								        isExpression: isExpression,
							 | 
						|
								        isStatement: isStatement,
							 | 
						|
								        isIterationStatement: isIterationStatement,
							 | 
						|
								        isSourceElement: isSourceElement,
							 | 
						|
								        isProblematicIfStatement: isProblematicIfStatement,
							 | 
						|
								
							 | 
						|
								        trailingStatement: trailingStatement
							 | 
						|
								    };
							 | 
						|
								}());
							 | 
						|
								/* vim: set sw=4 ts=4 et tw=80 : */
							 |