distil 0.7.0

data/vendor/jsl-0.3.0/src/JavaScriptLintAPI.cpp

@@ -0,0 +1,333 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is JavaScript Lint code.
+ *
+ * The Initial Developer of the Original Code is Matthias Miller.
+ * Portions created by the Initial Developer are Copyright (C) 2006
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+ * JavaScript Lint API
+ * Developed by Matthias Miller (http://www.JavaScriptLint.com/)
+ *
+ * Suggestions or revisions can be sent to Info@JavaScriptLint.com
+ */
+#include "JavaScriptLintAPI.h"
+
+#include <assert.h>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <xstring>
+
+#include <windows.h>
+
+// see header
+#pragma warning(push, 4)
+#pragma warning(disable: 4786)
+
+using namespace std;
+
+string GetLastErrorString()
+{
+   if (GetLastError() == ERROR_SUCCESS)
+      return "";
+
+   LPVOID lpMsgBuf;
+   FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
+                 GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                 (LPTSTR) &lpMsgBuf, 0, NULL);
+   string error = (char *)lpMsgBuf;
+   LocalFree(lpMsgBuf);
+   return error;
+}
+
+bool ExecuteProcess(string commandline, string input, string& output, string& error)
+{
+   // SEE http://msdn.microsoft.com/library/en-us/dllproc/base/creating_a_child_process_with_redirected_input_and_output.asp?frame=true
+   output.empty();
+
+   // Set the bInheritHandle flag so pipe handles are inherited. 
+   SECURITY_ATTRIBUTES saAttr;
+   saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 
+   saAttr.bInheritHandle = TRUE; 
+   saAttr.lpSecurityDescriptor = NULL; 
+
+   // Create a pipe for the child process's STDOUT that is not inherited
+   HANDLE hChildStdoutRd, hChildStdoutWr;
+   if (!CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) 
+   {
+      error = GetLastErrorString();
+      return false;
+   }
+   SetHandleInformation(hChildStdoutRd, HANDLE_FLAG_INHERIT, 0);
+
+   // Create a pipe for the child process's STDIN that is not inherited
+   HANDLE hChildStdinRd, hChildStdinWr;
+   if (!CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0))
+   {
+      error = GetLastErrorString();
+      return false;
+   }
+   SetHandleInformation(hChildStdinWr, HANDLE_FLAG_INHERIT, 0);
+
+   // Create the child process
+   PROCESS_INFORMATION piProcInfo;
+   ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));
+
+   STARTUPINFO siStartInfo;
+   ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));
+   siStartInfo.cb = sizeof(STARTUPINFO); 
+   siStartInfo.hStdError = hChildStdoutWr;
+   siStartInfo.hStdOutput = hChildStdoutWr;
+   siStartInfo.hStdInput = hChildStdinRd;
+   siStartInfo.dwFlags |= STARTF_USESTDHANDLES;
+   siStartInfo.dwFlags |= STARTF_USESHOWWINDOW;
+
+   if (!CreateProcess(NULL,
+      (char*)commandline.c_str(), // command line 
+      NULL,          // process security attributes 
+      NULL,          // primary thread security attributes 
+      TRUE,          // handles are inherited 
+      0,             // creation flags 
+      NULL,          // use parent's environment 
+      NULL,          // use parent's current directory 
+      &siStartInfo,  // STARTUPINFO pointer 
+      &piProcInfo))  // receives PROCESS_INFORMATION 
+   {
+      error = GetLastErrorString();
+      return false;
+   }
+   CloseHandle(piProcInfo.hProcess);
+   CloseHandle(piProcInfo.hThread);
+
+   // write the result and close the file so the client stops reading
+   DWORD dwBytesWritten = 0;
+   if (!WriteFile(hChildStdinWr, input.c_str(), input.length(), &dwBytesWritten, NULL))
+   {
+      error = GetLastErrorString();
+      return false;
+   }
+   if (!CloseHandle(hChildStdinWr))
+   {
+      error = GetLastErrorString();
+      return false;
+   }
+
+   // Close the write end of the pipe before reading from the read end of the pipe. 
+   if (!CloseHandle(hChildStdoutWr)) 
+   {
+      error = GetLastErrorString();
+      return false;
+   }
+ 
+   // Read output from the child process, and write to parent's STDOUT. 
+   DWORD dwBytesRead;
+   CHAR chBuf[415];
+   for (;;)
+   {
+      if (!ReadFile(hChildStdoutRd, chBuf, sizeof(chBuf), &dwBytesRead, NULL))
+      {
+         if (GetLastError() == ERROR_BROKEN_PIPE)
+            break;
+
+         error = "The output pipe could not be read. " + GetLastErrorString();
+         return false;
+      }
+      if (!dwBytesRead)
+         break;
+      output.append(chBuf, dwBytesRead);
+   }
+   return true;
+}
+
+namespace JSLStrings
+{
+   void ReplaceString(string& str, const char *lookfor, const char *replacewith)
+   {
+      // get the length of the old and new items
+      int oldTextLen = strlen(lookfor);
+      int newTextLen = strlen(replacewith);
+
+      // find each occurrence of the old text
+      string::size_type pos = 0;
+      while ((pos = str.find(lookfor, pos)) != string::npos)
+      {
+         // replace the old text with the new
+         str.replace(pos, oldTextLen, replacewith);
+         // jump past the newly inserted text
+         pos += newTextLen;
+      }
+   }
+
+   string EscapeAndQuoteParameter(string parameter)
+   {
+      string escapedParameter = parameter;
+      ReplaceString(escapedParameter, "\\", "\\\\");
+      ReplaceString(escapedParameter, "\"", "\\\"");
+      escapedParameter.insert(0, '"');
+      escapedParameter += '"';
+      return escapedParameter;
+   }
+
+   void SplitString(string source, string delimiter, vector<string>& results)
+   {
+      assert(delimiter.length() > 0);
+
+      string::size_type lastpos = 0, curpos = 0;
+      while ((curpos = source.find(delimiter, lastpos)) != string::npos)
+      {
+         results.push_back(source.substr(lastpos, curpos-lastpos));
+         lastpos = curpos + delimiter.length();
+      }
+
+      if (lastpos)
+         results.push_back(source.substr(lastpos));
+   }
+
+   bool GetIntFromString(int& i, const string& s)
+   {
+      istringstream stream(s);
+      return !(stream >> std::dec >> i).fail();
+   }
+
+   string StripCSlashes(const string& encoded)
+   {
+      string decoded = encoded;
+      ReplaceString(decoded, "\\n", "\n");
+      ReplaceString(decoded, "\\r", "\r");
+      ReplaceString(decoded, "\\t", "\t");
+      ReplaceString(decoded, "\\\'", "\'");
+      ReplaceString(decoded, "\\\"", "\"");
+      ReplaceString(decoded, "\\\\", "\\");
+      return decoded;
+   }
+}
+
+
+
+JavaScriptLint::JavaScriptLint(string binaryPath, string configPath)
+{
+   m_binaryPath = binaryPath;
+   m_configPath = configPath;
+}
+
+bool JavaScriptLint::LintString(string code, JSL_OUT vector<JSLMessage>& messages, JSL_OUT string& error)
+{
+   return RunLint(vector<string>(), true, code, messages, error);
+}
+
+bool JavaScriptLint::LintFile(string file, JSL_OUT vector<JSLMessage>& messages, JSL_OUT string& error)
+{
+   vector<string> files;
+   files.push_back(file);
+   return LintFiles(files, messages, error);
+}
+
+bool JavaScriptLint::LintFiles(vector<string> files, JSL_OUT vector<JSLMessage>& messages, JSL_OUT string& error)
+{
+   return RunLint(files, false, "", messages, error);
+}
+
+bool JavaScriptLint::RunLint(const vector<string>& files, bool useStdin, string code,
+                             JSL_OUT vector<JSLMessage>& messages, string& error)
+{
+   assert(useStdin || !code.length());
+
+   // Construct the command line
+   string commandline;
+   commandline += JSLStrings::EscapeAndQuoteParameter(m_binaryPath);
+   if (m_configPath.length())
+   {
+      commandline += " -conf ";
+      commandline += JSLStrings::EscapeAndQuoteParameter(m_configPath);
+   }
+   for (vector<string>::const_iterator file_iter = files.begin(); file_iter != files.end(); file_iter++)
+   {
+      commandline += " -process ";
+      commandline += JSLStrings::EscapeAndQuoteParameter(*file_iter);
+   }
+   if (useStdin)
+      commandline += " -stdin";
+   commandline += " -context -nologo -nofilelisting -nosummary";
+   commandline += " -output-format \"encode:__FILE__\t__LINE__\t__COL__\t__ERROR_NAME__\t__ERROR_PREFIX__\t__ERROR_MSG__\"";
+
+   // Run the Lint
+   string results;
+   if (!ExecuteProcess(commandline, code, results, error))
+   {
+      error = "Unable to run JavaScript Lint. " + error;
+      return false;
+   }
+
+   JSLStrings::ReplaceString(results, "\r\n", "\n");
+
+   // Parse the messages
+   vector<string> lines;
+   JSLStrings::SplitString(results, "\n", lines);
+   for (vector<string>::const_iterator line_iter = lines.begin(); line_iter != lines.end(); line_iter++)
+   {
+      // Skip blank lines
+      if (!line_iter->length())
+         continue;
+
+      // The fields are tab delimited
+      vector<string> fields;
+      JSLStrings::SplitString(*line_iter, "\t", fields);
+      if (fields.size() != 6)
+      {
+         error = "JavaScript Lint returned unreadable information.";
+         return false;
+      }
+
+      // Decode fields
+      for (vector<string>::iterator field_iter = fields.begin(); field_iter != fields.end(); field_iter++)
+         *field_iter = JSLStrings::StripCSlashes(*field_iter);
+
+      JSLMessage msg;
+      msg.filename = fields.at(0);
+      if (!JSLStrings::GetIntFromString(msg.line, fields.at(1)))
+         msg.line = 0;
+      if (!JSLStrings::GetIntFromString(msg.col, fields.at(2)))
+         msg.col = 0;
+      msg.errName = fields.at(3);
+      msg.errType = fields.at(4);
+      msg.errMessage = fields.at(5);
+
+      // convert line and col number to 0-based
+      msg.line--;
+      msg.col--;
+      messages.push_back(msg);
+   }
+
+   return true;
+}

data/vendor/jsl-0.3.0/src/JavaScriptLintAPI.h

@@ -0,0 +1,86 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is JavaScript Lint code.
+ *
+ * The Initial Developer of the Original Code is Matthias Miller.
+ * Portions created by the Initial Developer are Copyright (C) 2006
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef _JAVASCRIPTLINTAPI_H__
+#define _JAVASCRIPTLINTAPI_H__
+
+#define JSL_IN
+#define JSL_OUT
+
+#include <xstring>
+
+bool ExecuteProcess(std::string commandline, std::string input,
+                    JSL_OUT std::string& output, JSL_OUT std::string& error);
+
+// The Visual C++ compiler gives a warning when including <vector> because of debug symbols.
+#pragma warning(push)
+#pragma warning(disable: 4786)
+#include <vector>
+#pragma warning(pop)
+
+// The return line and column is 0-based and may be -1 if the message does not apply to a specific
+// line/column. The caller is responsible to do bounds-checking on the line/column.
+struct JSLMessage
+{
+   std::string filename;
+   int line, col;
+   std::string errName, errType, errMessage;
+};
+
+class JavaScriptLint
+{
+public:
+   // The path to the configuration file may be blank. 
+   JavaScriptLint(std::string sBinaryPath, std::string sConfigPath);
+
+   bool LintString(std::string code, JSL_OUT std::vector<JSLMessage>& messages,
+      JSL_OUT std::string& error);
+   bool LintFile(std::string file, JSL_OUT std::vector<JSLMessage>& messages,
+      JSL_OUT std::string& error);
+   bool LintFiles(std::vector<std::string> files, JSL_OUT std::vector<JSLMessage>& messages,
+      JSL_OUT std::string& error);
+
+private:
+   bool RunLint(const std::vector<std::string>& files, bool useStdin, std::string code,
+      JSL_OUT std::vector<JSLMessage>& messages, JSL_OUT std::string& error);
+
+   std::string m_binaryPath, m_configPath;
+};
+
+
+#endif
+