coffeecake 0.0.1

data/node_modules/jasmine-runner/node_modules/socket.io/support/expresso/deps/jscoverage/encoding.c

@@ -0,0 +1,315 @@
+/*
+    encoding.c - character encoding
+    Copyright (C) 2008 siliconforks.com
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include <config.h>
+
+#include "encoding.h"
+
+#include <assert.h>
+#include <limits.h>
+#include <string.h>
+
+#ifdef HAVE_ICONV_H
+#include <iconv.h>
+#elif defined HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+
+#include "util.h"
+
+static void skip_bom(jschar ** characters, size_t * num_characters) {
+  jschar * c = *characters;
+  size_t nc = *num_characters;
+
+  size_t i;
+  for (i = 0; i < nc; i++) {
+    if (c[i] != 0xfeff) {
+      break;
+    }
+  }
+
+  if (i == 0) {
+    return;
+  }
+
+  nc -= i;
+  jschar * old = c;
+  c = xnew(jschar, nc);
+  memcpy(c, old + i, nc * sizeof(jschar));
+  free(old);
+
+  *characters = c;
+  *num_characters = nc;
+}
+
+#ifdef HAVE_ICONV
+
+#ifdef WORDS_BIGENDIAN
+#define UTF_16_INTERNAL "UTF-16BE"
+#else
+#define UTF_16_INTERNAL "UTF-16LE"
+#endif
+
+int jscoverage_bytes_to_characters(const char * encoding, const uint8_t * bytes, size_t num_bytes, jschar ** characters, size_t * num_characters) {
+  assert(encoding != NULL);
+
+  iconv_t state = iconv_open(UTF_16_INTERNAL, encoding);
+  if (state == (iconv_t) -1) {
+    return JSCOVERAGE_ERROR_ENCODING_NOT_SUPPORTED;
+  }
+
+  ICONV_CONST char * input = (char *) bytes;
+  size_t input_bytes_left = num_bytes;
+
+  jschar * c = xnew(jschar, num_bytes);
+  char * output = (char *) c;
+  size_t output_bytes_left = sizeof(jschar) * num_bytes;
+
+  size_t result = iconv(state, &input, &input_bytes_left, &output, &output_bytes_left);
+  iconv_close(state);
+  if (result == (size_t) -1) {
+    free(c);
+    return JSCOVERAGE_ERROR_INVALID_BYTE_SEQUENCE;
+  }
+
+  assert(input_bytes_left == 0);
+
+  size_t nc = ((jschar *) output) - c;
+
+  skip_bom(&c, &nc);
+
+  *characters = c;
+  *num_characters = nc;
+  return 0;
+}
+
+#elif HAVE_MULTIBYTETOWIDECHAR
+
+/* http://msdn.microsoft.com/en-us/library/ms776446(VS.85).aspx */
+static struct CodePage {
+  UINT value;
+  LPCSTR string;
+} code_pages[] = {
+  {37,		"IBM037"},			/* IBM EBCDIC US-Canada */
+  {437,		"IBM437"},			/* OEM United States */
+  {500,		"IBM500"},			/* IBM EBCDIC International */
+  {708,		"ASMO-708"},			/* Arabic (ASMO 708) */
+  {720,		"DOS-720"},			/* Arabic (Transparent ASMO); Arabic (DOS) */
+  {737,		"ibm737"},			/* OEM Greek (formerly 437G); Greek (DOS) */
+  {775,		"ibm775"},			/* OEM Baltic; Baltic (DOS) */
+  {850,		"ibm850"},			/* OEM Multilingual Latin 1; Western European (DOS) */
+  {852,		"ibm852"},			/* OEM Latin 2; Central European (DOS) */
+  {855,		"IBM855"},			/* OEM Cyrillic (primarily Russian) */
+  {857,		"ibm857"},			/* OEM Turkish; Turkish (DOS) */
+  {858,		"IBM00858"},			/* OEM Multilingual Latin 1 + Euro symbol */
+  {860,		"IBM860"},			/* OEM Portuguese; Portuguese (DOS) */
+  {861,		"ibm861"},			/* OEM Icelandic; Icelandic (DOS) */
+  {862,		"DOS-862"},			/* OEM Hebrew; Hebrew (DOS) */
+  {863,		"IBM863"},			/* OEM French Canadian; French Canadian (DOS) */
+  {864,		"IBM864"},			/* OEM Arabic; Arabic (864) */
+  {865,		"IBM865"},			/* OEM Nordic; Nordic (DOS) */
+  {866,		"cp866"},			/* OEM Russian; Cyrillic (DOS) */
+  {869,		"ibm869"},			/* OEM Modern Greek; Greek, Modern (DOS) */
+  {870,		"IBM870"},			/* IBM EBCDIC Multilingual/ROECE (Latin 2); IBM EBCDIC Multilingual Latin 2 */
+  {874,		"windows-874"},			/* ANSI/OEM Thai (same as 28605, ISO 8859-15); Thai (Windows) */
+  {875,		"cp875"},			/* IBM EBCDIC Greek Modern */
+  {932,		"shift_jis"},			/* ANSI/OEM Japanese; Japanese (Shift-JIS) */
+  {936,		"gb2312"},			/* ANSI/OEM Simplified Chinese (PRC, Singapore); Chinese Simplified (GB2312) */
+  {949,		"ks_c_5601-1987"},		/* ANSI/OEM Korean (Unified Hangul Code) */
+  {950,		"big5"},			/* ANSI/OEM Traditional Chinese (Taiwan; Hong Kong SAR, PRC); Chinese Traditional (Big5) */
+  {1026,	"IBM1026"},			/* IBM EBCDIC Turkish (Latin 5) */
+  {1047,	"IBM01047"},			/* IBM EBCDIC Latin 1/Open System */
+  {1140,	"IBM01140"},			/* IBM EBCDIC US-Canada (037 + Euro symbol); IBM EBCDIC (US-Canada-Euro) */
+  {1141,	"IBM01141"},			/* IBM EBCDIC Germany (20273 + Euro symbol); IBM EBCDIC (Germany-Euro) */
+  {1142,	"IBM01142"},			/* IBM EBCDIC Denmark-Norway (20277 + Euro symbol); IBM EBCDIC (Denmark-Norway-Euro) */
+  {1143,	"IBM01143"},			/* IBM EBCDIC Finland-Sweden (20278 + Euro symbol); IBM EBCDIC (Finland-Sweden-Euro) */
+  {1144,	"IBM01144"},			/* IBM EBCDIC Italy (20280 + Euro symbol); IBM EBCDIC (Italy-Euro) */
+  {1145,	"IBM01145"},			/* IBM EBCDIC Latin America-Spain (20284 + Euro symbol); IBM EBCDIC (Spain-Euro) */
+  {1146,	"IBM01146"},			/* IBM EBCDIC United Kingdom (20285 + Euro symbol); IBM EBCDIC (UK-Euro) */
+  {1147,	"IBM01147"},			/* IBM EBCDIC France (20297 + Euro symbol); IBM EBCDIC (France-Euro) */
+  {1148,	"IBM01148"},			/* IBM EBCDIC International (500 + Euro symbol); IBM EBCDIC (International-Euro) */
+  {1149,	"IBM01149"},			/* IBM EBCDIC Icelandic (20871 + Euro symbol); IBM EBCDIC (Icelandic-Euro) */
+  {1200,	"utf-16"},			/* Unicode UTF-16, little endian byte order (BMP of ISO 10646); available only to managed applications */
+  {1201,	"unicodeFFFE"},			/* Unicode UTF-16, big endian byte order; available only to managed applications */
+  {1250,	"windows-1250"},		/* ANSI Central European; Central European (Windows) */
+  {1251,	"windows-1251"},		/* ANSI Cyrillic; Cyrillic (Windows) */
+  {1252,	"windows-1252"},		/* ANSI Latin 1; Western European (Windows) */
+  {1253,	"windows-1253"},		/* ANSI Greek; Greek (Windows) */
+  {1254,	"windows-1254"},		/* ANSI Turkish; Turkish (Windows) */
+  {1255,	"windows-1255"},		/* ANSI Hebrew; Hebrew (Windows) */
+  {1256,	"windows-1256"},		/* ANSI Arabic; Arabic (Windows) */
+  {1257,	"windows-1257"},		/* ANSI Baltic; Baltic (Windows) */
+  {1258,	"windows-1258"},		/* ANSI/OEM Vietnamese; Vietnamese (Windows) */
+  {1361,	"Johab"},			/* Korean (Johab) */
+  {10000,	"macintosh"},			/* MAC Roman; Western European (Mac) */
+  {10001,	"x-mac-japanese"},		/* Japanese (Mac) */
+  {10002,	"x-mac-chinesetrad"},		/* MAC Traditional Chinese (Big5); Chinese Traditional (Mac) */
+  {10003,	"x-mac-korean"},		/* Korean (Mac) */
+  {10004,	"x-mac-arabic"},		/* Arabic (Mac) */
+  {10005,	"x-mac-hebrew"},		/* Hebrew (Mac) */
+  {10006,	"x-mac-greek"},			/* Greek (Mac) */
+  {10007,	"x-mac-cyrillic"},		/* Cyrillic (Mac) */
+  {10008,	"x-mac-chinesesimp"},		/* MAC Simplified Chinese (GB 2312); Chinese Simplified (Mac) */
+  {10010,	"x-mac-romanian"},		/* Romanian (Mac) */
+  {10017,	"x-mac-ukrainian"},		/* Ukrainian (Mac) */
+  {10021,	"x-mac-thai"},			/* Thai (Mac) */
+  {10029,	"x-mac-ce"},			/* MAC Latin 2; Central European (Mac) */
+  {10079,	"x-mac-icelandic"},		/* Icelandic (Mac) */
+  {10081,	"x-mac-turkish"},		/* Turkish (Mac) */
+  {10082,	"x-mac-croatian"},		/* Croatian (Mac) */
+  {12000,	"utf-32"},			/* Unicode UTF-32, little endian byte order; available only to managed applications */
+  {12001,	"utf-32BE"},			/* Unicode UTF-32, big endian byte order; available only to managed applications */
+  {20000,	"x-Chinese_CNS"},		/* CNS Taiwan; Chinese Traditional (CNS) */
+  {20001,	"x-cp20001"},			/* TCA Taiwan */
+  {20002,	"x_Chinese-Eten"},		/* Eten Taiwan; Chinese Traditional (Eten) */
+  {20003,	"x-cp20003"},			/* IBM5550 Taiwan */
+  {20004,	"x-cp20004"},			/* TeleText Taiwan */
+  {20005,	"x-cp20005"},			/* Wang Taiwan */
+  {20105,	"x-IA5"},			/* IA5 (IRV International Alphabet No. 5, 7-bit); Western European (IA5) */
+  {20106,	"x-IA5-German"},		/* IA5 German (7-bit) */
+  {20107,	"x-IA5-Swedish"},		/* IA5 Swedish (7-bit) */
+  {20108,	"x-IA5-Norwegian"},		/* IA5 Norwegian (7-bit) */
+  {20127,	"us-ascii"},			/* US-ASCII (7-bit) */
+  {20261,	"x-cp20261"},			/* T.61 */
+  {20269,	"x-cp20269"},			/* ISO 6937 Non-Spacing Accent */
+  {20273,	"IBM273"},			/* IBM EBCDIC Germany */
+  {20277,	"IBM277"},			/* IBM EBCDIC Denmark-Norway */
+  {20278,	"IBM278"},			/* IBM EBCDIC Finland-Sweden */
+  {20280,	"IBM280"},			/* IBM EBCDIC Italy */
+  {20284,	"IBM284"},			/* IBM EBCDIC Latin America-Spain */
+  {20285,	"IBM285"},			/* IBM EBCDIC United Kingdom */
+  {20290,	"IBM290"},			/* IBM EBCDIC Japanese Katakana Extended */
+  {20297,	"IBM297"},			/* IBM EBCDIC France */
+  {20420,	"IBM420"},			/* IBM EBCDIC Arabic */
+  {20423,	"IBM423"},			/* IBM EBCDIC Greek */
+  {20424,	"IBM424"},			/* IBM EBCDIC Hebrew */
+  {20833,	"x-EBCDIC-KoreanExtended"},	/* IBM EBCDIC Korean Extended */
+  {20838,	"IBM-Thai"},			/* IBM EBCDIC Thai */
+  {20866,	"koi8-r"},			/* Russian (KOI8-R); Cyrillic (KOI8-R) */
+  {20871,	"IBM871"},			/* IBM EBCDIC Icelandic */
+  {20880,	"IBM880"},			/* IBM EBCDIC Cyrillic Russian */
+  {20905,	"IBM905"},			/* IBM EBCDIC Turkish */
+  {20924,	"IBM00924"},			/* IBM EBCDIC Latin 1/Open System (1047 + Euro symbol) */
+  {20932,	"EUC-JP"},			/* Japanese (JIS 0208-1990 and 0121-1990) */
+  {20936,	"x-cp20936"},			/* Simplified Chinese (GB2312); Chinese Simplified (GB2312-80) */
+  {20949,	"x-cp20949"},			/* Korean Wansung */
+  {21025,	"cp1025"},			/* IBM EBCDIC Cyrillic Serbian-Bulgarian */
+  {21866,	"koi8-u"},			/* Ukrainian (KOI8-U); Cyrillic (KOI8-U) */
+  {28591,	"iso-8859-1"},			/* ISO 8859-1 Latin 1; Western European (ISO) */
+  {28592,	"iso-8859-2"},			/* ISO 8859-2 Central European; Central European (ISO) */
+  {28593,	"iso-8859-3"},			/* ISO 8859-3 Latin 3 */
+  {28594,	"iso-8859-4"},			/* ISO 8859-4 Baltic */
+  {28595,	"iso-8859-5"},			/* ISO 8859-5 Cyrillic */
+  {28596,	"iso-8859-6"},			/* ISO 8859-6 Arabic */
+  {28597,	"iso-8859-7"},			/* ISO 8859-7 Greek */
+  {28598,	"iso-8859-8"},			/* ISO 8859-8 Hebrew; Hebrew (ISO-Visual) */
+  {28599,	"iso-8859-9"},			/* ISO 8859-9 Turkish */
+  {28603,	"iso-8859-13"},			/* ISO 8859-13 Estonian */
+  {28605,	"iso-8859-15"},			/* ISO 8859-15 Latin 9 */
+  {29001,	"x-Europa"},			/* Europa 3 */
+  {38598,	"iso-8859-8-i"},		/* ISO 8859-8 Hebrew; Hebrew (ISO-Logical) */
+  {50220,	"iso-2022-jp"},			/* ISO 2022 Japanese with no halfwidth Katakana; Japanese (JIS) */
+  {50221,	"csISO2022JP"},			/* ISO 2022 Japanese with halfwidth Katakana; Japanese (JIS-Allow 1 byte Kana) */
+  {50222,	"iso-2022-jp"},			/* ISO 2022 Japanese JIS X 0201-1989; Japanese (JIS-Allow 1 byte Kana - SO/SI) */
+  {50225,	"iso-2022-kr"},			/* ISO 2022 Korean */
+  {50227,	"x-cp50227"},			/* ISO 2022 Simplified Chinese; Chinese Simplified (ISO 2022) */
+  {51932,	"euc-jp"},			/* EUC Japanese */
+  {51936,	"EUC-CN"},			/* EUC Simplified Chinese; Chinese Simplified (EUC) */
+  {51949,	"euc-kr"},			/* EUC Korean */
+  {52936,	"hz-gb-2312"},			/* HZ-GB2312 Simplified Chinese; Chinese Simplified (HZ) */
+  {54936,	"GB18030"},			/* Windows XP and later: GB18030 Simplified Chinese (4 byte); Chinese Simplified (GB18030) */
+  {57002,	"x-iscii-de"},			/* ISCII Devanagari */
+  {57003,	"x-iscii-be"},			/* ISCII Bengali */
+  {57004,	"x-iscii-ta"},			/* ISCII Tamil */
+  {57005,	"x-iscii-te"},			/* ISCII Telugu */
+  {57006,	"x-iscii-as"},			/* ISCII Assamese */
+  {57007,	"x-iscii-or"},			/* ISCII Oriya */
+  {57008,	"x-iscii-ka"},			/* ISCII Kannada */
+  {57009,	"x-iscii-ma"},			/* ISCII Malayalam */
+  {57010,	"x-iscii-gu"},			/* ISCII Gujarati */
+  {57011,	"x-iscii-pa"},			/* ISCII Punjabi */
+  {65000,	"utf-7"},			/* Unicode (UTF-7) */
+  {65001,	"utf-8"},			/* Unicode (UTF-8) */
+};
+
+int find_code_page(const char * encoding, UINT * code_page) {
+  for (size_t i = 0; i < sizeof(code_pages) / sizeof(code_pages[0]); i++) {
+    if (strcasecmp(encoding, code_pages[i].string) == 0) {
+      *code_page = code_pages[i].value;
+      return 0;
+    }
+  }
+  return -1;
+}
+
+int jscoverage_bytes_to_characters(const char * encoding, const uint8_t * bytes, size_t num_bytes, jschar ** characters, size_t * num_characters) {
+  assert(encoding != NULL);
+
+  if (num_bytes == 0) {
+    *characters = xnew(jschar, 0);
+    *num_characters = 0;
+    return 0;
+  }
+
+  UINT code_page;
+  if (find_code_page(encoding, &code_page) != 0) {
+    return JSCOVERAGE_ERROR_ENCODING_NOT_SUPPORTED;
+  }
+
+  if (num_bytes > INT_MAX) {
+    fatal("overflow");
+  }
+
+  *characters = xnew(jschar, num_bytes);
+
+  int result = MultiByteToWideChar(code_page, MB_ERR_INVALID_CHARS, bytes, num_bytes, *characters, num_bytes);
+  if (result == 0) {
+    free(*characters);
+    return JSCOVERAGE_ERROR_INVALID_BYTE_SEQUENCE;
+  }
+
+  *num_characters = result;
+  skip_bom(characters, num_characters);
+  return 0;
+}
+
+#else
+
+int jscoverage_bytes_to_characters(const char * encoding, const uint8_t * bytes, size_t num_bytes, jschar ** characters, size_t * num_characters) {
+  assert(encoding != NULL);
+
+  if (strcasecmp(encoding, "us-ascii") != 0 && strcasecmp(encoding, "iso-8859-1") != 0 && strcasecmp(encoding, "utf-8") != 0) {
+    return JSCOVERAGE_ERROR_ENCODING_NOT_SUPPORTED;
+  }
+
+  jschar * c = xnew(jschar, num_bytes);
+  for (size_t i = 0; i < num_bytes; i++) {
+    if (bytes[i] > 127) {
+      free(c);
+      return JSCOVERAGE_ERROR_ENCODING_NOT_SUPPORTED;
+    }
+    c[i] = bytes[i];
+  }
+
+  *characters = c;
+  *num_characters = num_bytes;
+  return 0;
+}
+
+#endif

data/node_modules/jasmine-runner/node_modules/socket.io/support/expresso/deps/jscoverage/encoding.h

@@ -0,0 +1,33 @@
+/*
+    encoding.h - character encoding
+    Copyright (C) 2008 siliconforks.com
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef ENCODING_H_
+#define ENCODING_H_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <jsapi.h>
+
+#define JSCOVERAGE_ERROR_ENCODING_NOT_SUPPORTED (-1)
+#define JSCOVERAGE_ERROR_INVALID_BYTE_SEQUENCE (-2)
+
+int jscoverage_bytes_to_characters(const char * encoding, const uint8_t * bytes, size_t num_bytes, jschar ** characters, size_t * num_characters);
+
+#endif /* ENCODING_H_ */

data/node_modules/jasmine-runner/node_modules/socket.io/support/expresso/deps/jscoverage/generate-resources.c

@@ -0,0 +1,58 @@
+/*
+    generate-resources.c - code generator for embedded resources
+    Copyright (C) 2007, 2008 siliconforks.com
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/stat.h>
+
+int main(int argc, char ** argv) {
+  for (int i = 1; i < argc; i++) {
+    printf("const unsigned char RESOURCE%d_[] = {\n", i);
+    FILE * f = fopen(argv[i], "rb");
+    if (f == NULL) {
+      fprintf(stderr, "cannot open file %s\n", argv[i]);
+      exit(EXIT_FAILURE);
+    }
+    int c;
+    int j = 0;
+    while ((c = fgetc(f)) != EOF) {
+      if (j % 16 == 0) {
+        printf("\n  ");
+      }
+      printf("0x%02x,", c);
+      j++;
+    }
+    fclose(f);
+    printf("\n};\n");
+  }
+
+  printf("const struct Resource RESOURCES[] = {\n");
+  for (int i = 1; i < argc; i++) {
+    printf("  {\n");
+    printf("    \"%s\",\n", argv[i]);
+    printf("    RESOURCE%d_,\n", i);
+    printf("    sizeof(RESOURCE%d_)\n", i);
+    printf("  },\n");
+  }
+  printf("};\n");
+  exit(EXIT_SUCCESS);
+}

data/node_modules/jasmine-runner/node_modules/socket.io/support/expresso/deps/jscoverage/global.h

@@ -0,0 +1,29 @@
+/*
+    global.h - global variables
+    Copyright (C) 2008 siliconforks.com
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef GLOBAL_H_
+#define GLOBAL_H_
+
+#include <stdbool.h>
+
+extern const char * jscoverage_encoding;
+
+extern bool jscoverage_highlight;
+
+#endif /* GLOBAL_H_ */

data/node_modules/jasmine-runner/node_modules/socket.io/support/expresso/deps/jscoverage/highlight.c

@@ -0,0 +1,478 @@
+/*
+    highlight.c - JavaScript syntax highlighting
+    Copyright (C) 2008 siliconforks.com
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include <config.h>
+
+#include "highlight.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <jslock.h>
+#include <jsscan.h>
+
+#include "util.h"
+
+enum Class {
+  CLASS_NONE,
+  CLASS_COMMENT,
+  CLASS_REGEXP,
+  CLASS_NUMBER,
+  CLASS_STRING,
+  CLASS_SPECIALCHAR,
+  CLASS_KEYWORD,
+  CLASS_TYPE,
+  CLASS_SYMBOL,
+  CLASS_CBRACKET
+};
+
+static const char * get_class_name(enum Class class) {
+  switch (class) {
+  case CLASS_NONE:
+    abort();
+    break;
+  case CLASS_COMMENT:
+    return "c";
+    break;
+  case CLASS_REGEXP:
+    return "s";
+    break;
+  case CLASS_NUMBER:
+    return "s";
+    break;
+  case CLASS_STRING:
+    return "s";
+    break;
+  case CLASS_SPECIALCHAR:
+    return "t";
+    break;
+  case CLASS_KEYWORD:
+    return "k";
+    break;
+  case CLASS_TYPE:
+    return "k";
+    break;
+  case CLASS_SYMBOL:
+    return "k";
+    break;
+  case CLASS_CBRACKET:
+    return "k";
+    break;
+  default:
+    abort();
+    break;
+  }
+}
+
+static const char * g_id;
+static const jschar * g_characters;
+static size_t g_num_characters;
+static Stream * g_output;
+static size_t character_offset;
+static uint16_t line_num;
+static uint16_t column_num;
+static enum Class current_class;
+
+static void output_character(jschar c, enum Class class) {
+  if (c == '\r' || c == '\n' || c == 0x2028 || c == 0x2029) {
+    class = CLASS_NONE;
+  }
+
+  if (class != current_class) {
+    /* output the end tag */
+    if (current_class != CLASS_NONE) {
+      Stream_write_string(g_output, "</span>");
+    }
+
+    current_class = class;
+
+    /* output the start tag */
+    if (current_class != CLASS_NONE) {
+      Stream_printf(g_output, "<span class=\"%s\">", get_class_name(class));
+    }
+  }
+
+  if (column_num == UINT16_MAX) {
+    fatal("%s: script contains a line with more than 65,535 columns", g_id);
+  }
+  column_num++;
+  switch (c) {
+  case '&':
+    Stream_write_string(g_output, "&amp;");
+    break;
+  case '<':
+    Stream_write_string(g_output, "&lt;");
+    break;
+  case '>':
+    Stream_write_string(g_output, "&gt;");
+    break;
+  case '\t':
+    Stream_write_char(g_output, c);
+    break;
+  case '\r':
+  case '\n':
+  case 0x2028:
+  case 0x2029:
+    if (c == '\r' && character_offset + 1 < g_num_characters && g_characters[character_offset + 1] == '\n') {
+      break;
+    }
+    Stream_write_char(g_output, '\n');
+    column_num = 0;
+    if (line_num == UINT16_MAX) {
+      fatal("%s: script contains more than 65,535 lines", g_id);
+    }
+    line_num++;
+    break;
+  default:
+    if (32 <= c && c <= 126) {
+      Stream_write_char(g_output, c);
+    }
+    else {
+      Stream_printf(g_output, "&#%d;", c);
+    }
+    break;
+  }
+  character_offset++;
+}
+
+static void mark_nontoken_chars(uint16_t end_line, uint16_t end_column) {
+  enum State {
+    STATE_NORMAL,
+    STATE_LINE_COMMENT,
+    STATE_MULTILINE_COMMENT
+  };
+
+  enum State state = STATE_NORMAL;
+  while (character_offset < g_num_characters) {
+    if (end_line != 0 && line_num > end_line) {
+      break;
+    }
+    else if (line_num == end_line && column_num >= end_column) {
+      break;
+    }
+
+    jschar c = g_characters[character_offset];
+    if (c == '\0') {
+      fatal("%s: script contains NULL character", g_id);
+    }
+
+    switch (state) {
+    case STATE_NORMAL:
+      if (c == '/' && character_offset + 1 < g_num_characters && g_characters[character_offset + 1] == '/') {
+        state = STATE_LINE_COMMENT;
+      }
+      else if (c == '/' && character_offset + 1 < g_num_characters && g_characters[character_offset + 1] == '*') {
+        state = STATE_MULTILINE_COMMENT;
+        output_character('/', CLASS_COMMENT);
+        output_character('*', CLASS_COMMENT);
+        continue;
+      }
+      break;
+    case STATE_LINE_COMMENT:
+      if (c == '\r' || c == '\n' || c == 0x2028 || c == 0x2029) {
+        state = STATE_NORMAL;
+      }
+      break;
+    case STATE_MULTILINE_COMMENT:
+      if (c == '*' && character_offset + 1 < g_num_characters && g_characters[character_offset + 1] == '/') {
+        output_character('*', CLASS_COMMENT);
+        output_character('/', CLASS_COMMENT);
+        state = STATE_NORMAL;
+        continue;
+      }
+      break;
+    }
+
+    if (state == STATE_NORMAL) {
+      output_character(c, CLASS_NONE);
+    }
+    else {
+      output_character(c, CLASS_COMMENT);
+    }
+  }
+}
+
+void jscoverage_highlight_js(JSContext * context, const char * id, const jschar * characters, size_t num_characters, Stream * output) {
+  g_id = id;
+  g_characters = characters;
+  g_num_characters = num_characters;
+  g_output = output;
+
+  character_offset = 0;
+  line_num = 1;
+  column_num = 0;
+  current_class = CLASS_NONE;
+
+  /* tokenize the JavaScript */
+  JSTokenStream token_stream;
+  if (! js_InitTokenStream(context, &token_stream, characters, num_characters, NULL, NULL, 1)) {
+    fatal("cannot create token stream from JavaScript file %s", id);
+  }
+
+  for (;;) {
+    JSTokenType tt = js_GetToken(context, &token_stream);
+
+    if (tt == TOK_ERROR) {
+      fatal("JavaScript parse error: %s: line = %d, col = %d\n", id, line_num, column_num);
+    }
+
+    if (tt == TOK_EOF) {
+      mark_nontoken_chars(0, 0);
+      break;
+    }
+
+    /* mark the chars before the token */
+    JSToken t = CURRENT_TOKEN(&token_stream);
+    mark_nontoken_chars(t.pos.begin.lineno, t.pos.begin.index);
+
+    /* mark the token */
+    enum Class class;
+    switch (tt) {
+    case TOK_ERROR:
+    case TOK_EOF:
+      abort();
+    case TOK_EOL:
+      class = CLASS_NONE;
+      token_stream.flags |= TSF_OPERAND;
+      break;
+    case TOK_SEMI:
+    case TOK_COMMA:
+    case TOK_ASSIGN:
+    case TOK_HOOK:
+    case TOK_COLON:
+    case TOK_OR:
+    case TOK_AND:
+    case TOK_BITOR:
+    case TOK_BITXOR:
+    case TOK_BITAND:
+    case TOK_EQOP:
+    case TOK_RELOP:
+    case TOK_SHOP:
+    case TOK_PLUS:
+    case TOK_MINUS:
+    case TOK_STAR:
+    case TOK_DIVOP:
+      class = CLASS_SYMBOL;
+      token_stream.flags |= TSF_OPERAND;
+      break;
+    case TOK_UNARYOP:
+      switch (t.t_op) {
+      case JSOP_NEG:
+      case JSOP_POS:
+      case JSOP_NOT:
+      case JSOP_BITNOT:
+        class = CLASS_SYMBOL;
+        token_stream.flags |= TSF_OPERAND;
+        break;
+      case JSOP_TYPEOF:
+        class = CLASS_KEYWORD;
+        token_stream.flags |= TSF_OPERAND;
+        break;
+      case JSOP_VOID:
+        class = CLASS_TYPE;
+        token_stream.flags |= TSF_OPERAND;
+        break;
+      default:
+        abort();
+      }
+      break;
+    case TOK_INC:
+    case TOK_DEC:
+      class = CLASS_SYMBOL;
+      /* token_stream.flags does not change w.r.t. TSF_OPERAND */
+      break;
+    case TOK_DOT:
+    case TOK_LB:
+      class = CLASS_SYMBOL;
+      token_stream.flags |= TSF_OPERAND;
+      break;
+    case TOK_RB:
+      class = CLASS_SYMBOL;
+      token_stream.flags &= ~TSF_OPERAND;
+      break;
+    case TOK_LC:
+      class = CLASS_CBRACKET;
+      token_stream.flags |= TSF_OPERAND;
+      break;
+    case TOK_RC:
+      class = CLASS_CBRACKET;
+      token_stream.flags &= ~TSF_OPERAND;
+      break;
+    case TOK_LP:
+      class = CLASS_SYMBOL;
+      token_stream.flags |= TSF_OPERAND;
+      break;
+    case TOK_RP:
+      class = CLASS_SYMBOL;
+      token_stream.flags &= ~TSF_OPERAND;
+      break;
+    case TOK_NAME:
+      class = CLASS_NONE;
+      token_stream.flags &= ~TSF_OPERAND;
+      if (js_PeekToken(context, &token_stream) == TOK_LP) {
+        /* function */
+        class = CLASS_NONE;
+      }
+      break;
+    case TOK_NUMBER:
+      class = CLASS_NUMBER;
+      token_stream.flags &= ~TSF_OPERAND;
+      break;
+    case TOK_STRING:
+      class = CLASS_STRING;
+      token_stream.flags &= ~TSF_OPERAND;
+      break;
+    case TOK_REGEXP:
+      class = CLASS_REGEXP;
+      token_stream.flags &= ~TSF_OPERAND;
+      break;
+    case TOK_PRIMARY:
+      switch (t.t_op) {
+      case JSOP_TRUE:
+      case JSOP_FALSE:
+      case JSOP_NULL:
+      case JSOP_THIS:
+        class = CLASS_KEYWORD;
+        token_stream.flags &= ~TSF_OPERAND;
+        break;
+      default:
+        abort();
+      }
+      break;
+    case TOK_FUNCTION:
+      class = CLASS_KEYWORD;
+      token_stream.flags |= TSF_OPERAND;
+      break;
+    case TOK_IF:
+    case TOK_ELSE:
+    case TOK_SWITCH:
+    case TOK_CASE:
+    case TOK_DEFAULT:
+    case TOK_WHILE:
+    case TOK_DO:
+    case TOK_FOR:
+    case TOK_BREAK:
+    case TOK_CONTINUE:
+    case TOK_IN:
+    case TOK_VAR:
+    case TOK_WITH:
+    case TOK_RETURN:
+    case TOK_NEW:
+    case TOK_DELETE:
+      token_stream.flags |= TSF_OPERAND;
+      class = CLASS_KEYWORD;
+      break;
+    case TOK_DEFSHARP:
+    case TOK_USESHARP:
+      abort();
+      break;
+    case TOK_TRY:
+    case TOK_CATCH:
+    case TOK_FINALLY:
+    case TOK_THROW:
+    case TOK_INSTANCEOF:
+    case TOK_DEBUGGER:
+      token_stream.flags |= TSF_OPERAND;
+      class = CLASS_KEYWORD;
+      break;
+    case TOK_XMLSTAGO:
+    case TOK_XMLETAGO:
+    case TOK_XMLPTAGC:
+    case TOK_XMLTAGC:
+    case TOK_XMLNAME:
+    case TOK_XMLATTR:
+    case TOK_XMLSPACE:
+    case TOK_XMLTEXT:
+    case TOK_XMLCOMMENT:
+    case TOK_XMLCDATA:
+    case TOK_XMLPI:
+    case TOK_AT:
+    case TOK_DBLCOLON:
+    case TOK_ANYNAME:
+    case TOK_DBLDOT:
+    case TOK_FILTER:
+    case TOK_XMLELEM:
+    case TOK_XMLLIST:
+      abort();
+      break;
+    case TOK_YIELD:
+      token_stream.flags |= TSF_OPERAND;
+      class = CLASS_KEYWORD;
+      break;
+    case TOK_ARRAYCOMP:
+    case TOK_ARRAYPUSH:
+    case TOK_LEXICALSCOPE:
+      abort();
+      break;
+    case TOK_LET:
+      token_stream.flags |= TSF_OPERAND;
+      class = CLASS_KEYWORD;
+      break;
+    case TOK_SEQ:
+    case TOK_FORHEAD:
+    case TOK_RESERVED:
+    case TOK_LIMIT:
+      abort();
+      break;
+    default:
+      abort();
+      break;
+    }
+
+    uint16_t start_line = t.pos.begin.lineno;
+    uint16_t end_line = t.pos.end.lineno;
+    uint16_t start_column = t.pos.begin.index;
+    uint16_t end_column = t.pos.end.index;
+    assert(line_num == start_line);
+    assert(column_num == start_column);
+    if (start_line == end_line && start_column >= end_column) {
+      fatal("%s: script contains line with more than 65,535 characters", id);
+    }
+    for (;;) {
+      assert(character_offset < num_characters);
+      jschar c = characters[character_offset];
+      if (tt == TOK_STRING && c == '\\') {
+        output_character(c, CLASS_SPECIALCHAR);
+        assert(character_offset < num_characters);
+        c = characters[character_offset];
+        output_character(c, CLASS_SPECIALCHAR);
+      }
+      else {
+        output_character(c, class);
+      }
+
+      if (line_num > end_line) {
+        break;
+      }
+      else if (line_num == end_line && column_num >= end_column) {
+        break;
+      }
+    }
+
+    assert(line_num == end_line);
+    assert(column_num = end_column);
+  }
+
+  if (current_class != CLASS_NONE) {
+    output_character('\n', CLASS_NONE);
+  }
+
+  js_CloseTokenStream(context, &token_stream);
+}