compact_enc_det 0.1.0

data/ext/compact_enc_det/compact_enc_det/compact_enc_det/detail_head_string.inc

@@ -0,0 +1,152 @@
+// Copyright 2016 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+// Produced by stringify.cc on 2007-09-28 09:13 from file i18n/encodings/compact_enc_det/tools/detail_head.ps
+  "%!PS-Adobe-2.0\n\n/inch {72 mul} def\n/cshow {dup stringwidth pop -2 div"
+  " 0 rmoveto show} def\n\n/lmargin 0.5 inch def\n/rmargin 8.5 inch def\n/t"
+  "margin 10.5 inch def\n/bmargin 0.5 inch def\n\n\n% set to N>=0 to track "
+  "ranked encoding N\n/track-me -1 def\n/track-me2 -1 def\n\n/columns 2 def"
+  "\n\n/lpi 18 def                 % lines per inch\n/lpc lpi 10 mul def   "
+  "      % lines per column\n/lpp lpc columns mul def    % lines per page\n"
+  "/probw 3.0 inch def         % probability width\n/probr 50 def          "
+  "     % probability range\n/widowlines lpi 2 idiv def  % 1/2 inch widow a"
+  "t bottom\n/widowlines lpi def         % 1 inch widow at bottom\n\n/lpg l"
+  "pi 2 idiv def         % 1/2 inch spacing between groups\n\n/delc 4 inch "
+  "def\n/dell -1 inch lpi div def\n\n/next-line 0 def      % 24 lines per i"
+  "nch, 240 per column\n\n/Cfont /Courier findfont 6 scalefont def\n/Hfont "
+  "/Helvetica findfont 6 scalefont def\nHfont setfont\n\n\n% simple string "
+  "hash -- sum the characters\n/strhash {\n  /hstr exch def\n  /h 0 def\n  "
+  "0 1 hstr length 1 sub {/i exch def  /h h hstr i get add def} for\n  h\n}"
+  " def\n\n% convert pro at 30 per 2x to 0-2.5 inches spanning -50 to 0\n/p"
+  "rob2x {\n  30 idiv probr div probw mul neg probw add\n}def\n\n\n/cliptoc"
+  "olumn {\n  % ====== MUST MATCH ME ======\n  gsave\n  lmargin tmargin mov"
+  "eto\n  next-line lpc idiv delc mul 0 rmoveto\n  -1 18 rmoveto 0 -10.5 in"
+  "ch rlineto  delc 2 add 0 rlineto  0 10.5 inch rlineto closepath\n  clip\n"
+  "  newpath\n} def\n\n/endcliptocolumn {\n  grestore\n  % ====== MUST MATC"
+  "H ME ======\n} def\n\n\n\n/column-box {\n  lmargin tmargin moveto\n  nex"
+  "t-line 1 sub lpc idiv delc mul  next-line 1 sub lpc mod 1 add dell mul r"
+  "moveto\n  % box\n  gsave -1.5 0 rmoveto 0 detail-count dell mul neg rmov"
+  "eto  probw 3 add 0 rlineto 0.25 setlinewidth stroke grestore\n  gsave -1"
+  ".5 0 rmoveto 0 detail-count dell mul neg rlineto 0.25 setlinewidth strok"
+  "e grestore\n  gsave probw .8 mul 0 rmoveto 0 detail-count dell mul neg r"
+  "lineto 0.25 setlinewidth 0.8 setgray stroke grestore\n  gsave probw .6 m"
+  "ul 0 rmoveto 0 detail-count dell mul neg rlineto 0.25 setlinewidth 0.8 s"
+  "etgray stroke grestore\n  gsave probw .4 mul 0 rmoveto 0 detail-count de"
+  "ll mul neg rlineto 0.25 setlinewidth 0.8 setgray stroke grestore\n  gsav"
+  "e probw .2 mul 0 rmoveto 0 detail-count dell mul neg rlineto 0.25 setlin"
+  "ewidth 0.8 setgray stroke grestore\n  gsave probw 1.5 add 0 rmoveto 0 de"
+  "tail-count dell mul neg rlineto 0.25 setlinewidth stroke grestore\n} def"
+  "\n\n\n/IncrementLine {\n  /incr exch def\n  /next-line next-line incr ad"
+  "d def\n  next-line lpc ge   next-line incr sub lpc lt   and {\n    % We "
+  "just went to the top of column 2; redo clip\n    endcliptocolumn     % M"
+  "UST match\n    column-box\n    /next-line lpc def\n    cliptocolumn     "
+  "   % MUST match\n  } if\n  next-line lpp ge {\n    % We just went to the"
+  " top of column 3; start new page column 1\n    endcliptocolumn     % MUS"
+  "T match\n    column-box\n    showpage\n    Hfont setfont\n    /next-line"
+  " 0 def\n    show-pageno\n    cliptocolumn        % MUST match\n  } if\n}"
+  " def\n\n/IncrementLineOutside {\n  /incr exch def\n  /next-line next-lin"
+  "e incr add def\n  next-line lpc ge   next-line incr sub lpc lt   and {\n"
+  "    % We just went to the top of column 2\n    /next-line lpc def\n  } i"
+  "f\n  next-line lpp ge {\n    % We just went to the top of column 3; star"
+  "t new page column 1\n    showpage\n    Hfont setfont\n    /next-line 0 d"
+  "ef\n    show-pageno\n  } if\n} def\n\n/NextColumn {\n  lpc 1 sub Increme"
+  "ntLine\n} def\n\n/NextPage {\n    lpp 1 sub IncrementLine\n} def\n\n% Up"
+  "on entry, we are OUTSIDE the clip\n/start-detail {\n  /d-title exch def\n"
+  "\n  % align >= 1 inch at bottom of column, and/or start new column\n  lp"
+  "c next-line lpc mod sub widowlines lt {\n    % Start at top of a column\n"
+  "    next-line lpc ge {\n      % Start new page\n      showpage\n      Hf"
+  "ont setfont\n      /next-line 0 def\n      show-pageno\n    } {\n      %"
+  " Start new column\n      /next-line lpc def\n    } ifelse\n  } if\n\n  l"
+  "margin tmargin moveto\n  next-line lpc idiv delc mul  next-line lpc mod "
+  "dell mul rmoveto\n  gsave d-title show grestore\n  0 dell rmoveto\n  1 1"
+  " 4 {/j exch def gsave probw j mul 5 div -2 rmoveto 50 j 10 mul sub 20 st"
+  "ring cvs cshow grestore} for\n  2 IncrementLineOutside\n  /detail-count "
+  "1 def\n  cliptocolumn            % MUST match\n  /d-array [] def\n} def\n"
+  "\n/size-detail {\n  /d-names exch def\n  /d-size exch def\n  % zero sums"
+  "\n  /sums d-size array def\n  0 1 d-size 1 sub {/i exch def  sums i 0 pu"
+  "t} for\n  /old-d-max 0 def\n  /colors d-size array def\n  0 1 d-size 1 s"
+  "ub {/i exch def  colors i i 3 mul 17 mod 17 div put} for\n  %0 1 d-size "
+  "1 sub {/i exch def  colors i d-names i get strhash 3 mul 17 mod 17 div p"
+  "ut} for\n  %0 1 d-size 1 sub {/i exch def  ( ) show colors i get 20 stri"
+  "ng cvs show} for\n} def\n\n/count-detail {\n  /detail-total-count exch d"
+  "ef\n  % if total-count >= one column, start at top of a column\n  detail"
+  "-total-count lpp ge {\n    % Start new page\n    NextPage\n  } {\n    de"
+  "tail-total-count lpc ge {\n      % Start new column\n      NextColumn\n "
+  "   } if\n  } ifelse\n} def\n\n% highlight next entry with underbar\n/do-"
+  "flag {\ngsave\n  setrgbcolor\n  lmargin tmargin moveto\n  next-line lpc "
+  "idiv delc mul  next-line lpc mod dell mul rmoveto\n  0 -2 rmoveto\n  pro"
+  "bw 0 rlineto\n  0 dell neg rlineto\n  probw neg 0 rlineto\n  closepath\n"
+  "  fill\ngrestore\n} def\n\n/do-detail-e {\n  /d-array exch def\n  /d-enc"
+  " exch def\n  /d-label exch def\n  /d-max -999999 def\n\n  lmargin tmargi"
+  "n moveto\n  next-line lpc idiv delc mul  next-line lpc mod dell mul rmov"
+  "eto\n  0.25 setlinewidth\n\n  % show label, using encoding color\n  gsav"
+  "e\n    probw 2 add -2 rmoveto\n    detail-count 1 sub 2 mod 0.25 inch mu"
+  "l 0 rmoveto\n    % ([) show detail-count 20 string cvs show (] ) show\n "
+  "   d-enc 0 lt {\n      0 setgray\n    }{\n      colors d-enc get 1 .8 se"
+  "thsbcolor\n    } ifelse\n    d-label show\n  grestore\n  % For -prune- d"
+  "raw horizontal line\n  d-label length 8 gt {d-label 4 get (p) 0 get eq d"
+  "-label 5 get (r) 0 get eq and {\n    /prune-val d-label cvi def\n    /ne"
+  "wx prune-val 30 mul prob2x def\n    gsave newx 6 rmoveto 0 -12 rlineto 1"
+  ".5 setlinewidth 0.8 setgray stroke grestore\n    gsave probw 0 add 0 rli"
+  "neto 0.25 setlinewidth 0.8 setgray stroke grestore\n  } if } if\n\n  % t"
+  "rack max per new row\n  0 1 d-array length 1 sub {\n    /i exch def\n   "
+  " /sum sums i get d-array i get add def\n    d-max sum lt {/d-max sum def"
+  "} if\n  } for\n\n  % draw line increments\n  0 1 d-array length 1 sub {\n"
+  "    /i exch def\n    detail-count 1 gt {\n      /oldx old-d-max sums i g"
+  "et sub prob2x def\n    } {\n      /oldx 600 prob2x def\n    } ifelse\n  "
+  "  /oldy dell neg def\n    /newx d-max  sums i get d-array i get add  sub"
+  " prob2x def\n    /newy 0 def\n    gsave\n    oldx oldy rmoveto\n    newx"
+  " oldx sub  newy oldy sub rlineto\n    % if encoding is being tracked, ma"
+  "ke bold line\n    i track-me eq\n      {2 setlinewidth}\n      {i track-"
+  "me2 eq {1.25 setlinewidth} {0.25 setlinewidth} ifelse}\n      ifelse\n  "
+  "  colors i get 1 .8 sethsbcolor stroke\n    grestore\n  } for\n  /detail"
+  "-count detail-count 1 add def\n\n  % increment running total in sums, tr"
+  "ack max per row\n  0 1 d-array length 1 sub {\n    /i exch def\n    sums"
+  " i  sums i get d-array i get add  put\n  } for\n  /old-d-max d-max def\n"
+  "\n  1 IncrementLine\n} def\n\n\n/do-detail {\n  /d-array exch def\n  /d-"
+  "label exch def\n  d-label -1 d-array do-detail-e\n} def\n\n% Upon exit, "
+  "we are outside the clip\n/end-detail {\n  pop\n  endcliptocolumn        "
+  " % MUST match\n  column-box\n\n  % text labels\n  0 1 d-array length 1 s"
+  "ub {\n    /i exch def\n    gsave\n    /newx old-d-max sums i get sub pro"
+  "b2x def\n    newx 0 ge {\n      newx 0 rmoveto\n      currentpoint trans"
+  "late\n      colors i get 1 .8 sethsbcolor\n      gsave 0 dell neg  rline"
+  "to 0.25 setlinewidth stroke grestore\n      -60 rotate\n      0 -2 movet"
+  "o d-names i get show\n    } if\n    grestore\n  } for\n  d-array length "
+  "0 gt {\n    lpg IncrementLineOutside\n  } {\n    lpg 4 idiv IncrementLin"
+  "eOutside\n  } ifelse\n} def\n\n/do-src {\n/src exch def\n  lmargin tmarg"
+  "in moveto\n  next-line lpc idiv delc mul  next-line lpc mod dell mul rmo"
+  "veto\n  Cfont setfont\n  src show\n  Hfont setfont\n  1 IncrementLine\n}"
+  " def\n\n% Underline trigram in source text\n/do-highlight1 {\n  /hl-colo"
+  "r exch def\n  /hl-offset exch def\n  /hl-line exch 1 sub 2 mul def\n  gs"
+  "ave\n  lmargin tmargin moveto\n  next-line hl-line sub lpc idiv delc mul"
+  "\n  next-line hl-line sub lpc mod dell mul rmoveto\n  % Assume text is 6"
+  " chars in and 3.6 pts per char, but 2 chars per offset\n  hl-offset 2 mu"
+  "l 6 add 3.6 mul  4 rmoveto\n\n  0 setgray 0.5 setlinewidth\n  hl-color 1"
+  " eq {0 0 1 setrgbcolor} if  % Latin1 blue\n  hl-color 2 eq {1 0 1 setrgb"
+  "color} if  % Latin2 magenta\n  hl-color 3 eq {1 0.67 0 setrgbcolor} if  "
+  "% Latin7 orange\n  18 -2 rlineto stroke\n  grestore\n} def\n\n% Box trig"
+  "ram in source text\n/do-highlight2 {\n  /hl-color exch def\n  /hl-offset"
+  " exch def\n  /hl-line exch 1 sub 2 mul def\n  gsave\n  lmargin tmargin m"
+  "oveto\n  next-line hl-line sub lpc idiv delc mul\n  next-line hl-line su"
+  "b lpc mod dell mul rmoveto\n  % Assume text is 6 chars in and 3.6 pts pe"
+  "r char, but 2 chars per offset\n  hl-offset 2 mul 6 add 3.6 mul  4 rmove"
+  "to\n\n  0 setgray 0.25 setlinewidth\n  hl-color 1 eq {0 0 1 setrgbcolor}"
+  " if  % Latin1 blue\n  hl-color 2 eq {1 0 1 setrgbcolor} if  % Latin2 mag"
+  "enta\n  hl-color 3 eq {1 0.67 0 setrgbcolor} if  % Latin7 orange\n  -0.5"
+  " -0.5 rmoveto\n  22 0 rlineto\n  0 4 rlineto\n  -11 2 rlineto\n  -11 -2 "
+  "rlineto\n  closepath\n  stroke\n  grestore\n} def\n\n/show-pageno {\ngsa"
+  "ve\nlmargin bmargin moveto 0 -12 rmoveto\n(Page ) show pageno 20 string "
+  "cvs show\ngrestore\n/pageno pageno 1 add def\n} def\n\n/pageno 1 def\nsh"
+  "ow-pageno\n%=============================\n\n\n"

data/ext/compact_enc_det/compact_enc_det/util/basictypes.h

@@ -0,0 +1,331 @@
+// Copyright 2016 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef UTIL_BASICTYPES_H_
+#define UTIL_BASICTYPES_H_
+
+#include <limits.h>         // So we can set the bounds of our types
+#include <stddef.h>         // For size_t
+#include <string.h>         // for memcpy
+
+#include "util/port.h"    // Types that only need exist on certain systems
+
+#ifndef COMPILER_MSVC
+// stdint.h is part of C99 but MSVC doesn't have it.
+#include <stdint.h>         // For intptr_t.
+#endif
+
+typedef signed char         schar;
+typedef signed char         int8;
+typedef short               int16;
+// TODO(mbelshe) Remove these type guards.  These are
+//               temporary to avoid conflicts with npapi.h.
+#ifndef _INT32
+#define _INT32
+typedef int                 int32;
+#endif
+
+// The NSPR system headers define 64-bit as |long| when possible.  In order to
+// not have typedef mismatches, we do the same on LP64.
+#if __LP64__
+typedef long                int64;
+#else
+typedef long long           int64;
+#endif
+
+// NOTE: unsigned types are DANGEROUS in loops and other arithmetical
+// places.  Use the signed types unless your variable represents a bit
+// pattern (eg a hash value) or you really need the extra bit.  Do NOT
+// use 'unsigned' to express "this value should always be positive";
+// use assertions for this.
+
+typedef unsigned char      uint8;
+typedef unsigned short     uint16;
+// TODO(mbelshe) Remove these type guards.  These are
+//               temporary to avoid conflicts with npapi.h.
+#ifndef _UINT32
+#define _UINT32
+typedef unsigned int       uint32;
+#endif
+
+// See the comment above about NSPR and 64-bit.
+#if __LP64__
+typedef unsigned long uint64;
+#else
+typedef unsigned long long uint64;
+#endif
+
+// A type to represent a Unicode code-point value. As of Unicode 4.0,
+// such values require up to 21 bits.
+// (For type-checking on pointers, make this explicitly signed,
+// and it should always be the signed version of whatever int32 is.)
+typedef signed int         char32;
+
+const uint8  kuint8max  = (( uint8) 0xFF);
+const uint16 kuint16max = ((uint16) 0xFFFF);
+const uint32 kuint32max = ((uint32) 0xFFFFFFFF);
+const uint64 kuint64max = ((uint64) GG_LONGLONG(0xFFFFFFFFFFFFFFFF));
+const  int8  kint8min   = ((  int8) 0x80);
+const  int8  kint8max   = ((  int8) 0x7F);
+const  int16 kint16min  = (( int16) 0x8000);
+const  int16 kint16max  = (( int16) 0x7FFF);
+const  int32 kint32min  = (( int32) 0x80000000);
+const  int32 kint32max  = (( int32) 0x7FFFFFFF);
+const  int64 kint64min  = (( int64) GG_LONGLONG(0x8000000000000000));
+const  int64 kint64max  = (( int64) GG_LONGLONG(0x7FFFFFFFFFFFFFFF));
+
+// A macro to disallow the copy constructor and operator= functions
+// This should be used in the private: declarations for a class
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);               \
+  void operator=(const TypeName&)
+
+// An older, deprecated, politically incorrect name for the above.
+#define DISALLOW_EVIL_CONSTRUCTORS(TypeName) DISALLOW_COPY_AND_ASSIGN(TypeName)
+
+// A macro to disallow all the implicit constructors, namely the
+// default constructor, copy constructor and operator= functions.
+//
+// This should be used in the private: declarations for a class
+// that wants to prevent anyone from instantiating it. This is
+// especially useful for classes containing only static methods.
+#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
+  TypeName();                                    \
+  DISALLOW_COPY_AND_ASSIGN(TypeName)
+
+// The arraysize(arr) macro returns the # of elements in an array arr.
+// The expression is a compile-time constant, and therefore can be
+// used in defining new arrays, for example.  If you use arraysize on
+// a pointer by mistake, you will get a compile-time error.
+
+// This template function declaration is used in defining arraysize.
+// Note that the function doesn't need an implementation, as we only
+// use its type.
+template <typename T, size_t N>
+char (&ArraySizeHelper(T (&array)[N]))[N];
+
+// That gcc wants both of these prototypes seems mysterious. VC, for
+// its part, can't decide which to use (another mystery). Matching of
+// template overloads: the final frontier.
+#ifndef _MSC_VER
+template <typename T, size_t N>
+char (&ArraySizeHelper(const T (&array)[N]))[N];
+#endif
+
+#define arraysize(array) (sizeof(ArraySizeHelper(array)))
+
+
+// Use implicit_cast as a safe version of static_cast or const_cast
+// for upcasting in the type hierarchy (i.e. casting a pointer to Foo
+// to a pointer to SuperclassOfFoo or casting a pointer to Foo to
+// a const pointer to Foo).
+// When you use implicit_cast, the compiler checks that the cast is safe.
+// Such explicit implicit_casts are necessary in surprisingly many
+// situations where C++ demands an exact type match instead of an
+// argument type convertable to a target type.
+//
+// The From type can be inferred, so the preferred syntax for using
+// implicit_cast is the same as for static_cast etc.:
+//
+//   implicit_cast<ToType>(expr)
+//
+// implicit_cast would have been part of the C++ standard library,
+// but the proposal was submitted too late.  It will probably make
+// its way into the language in the future.
+template<typename To, typename From>
+inline To implicit_cast(From const &f) {
+  return f;
+}
+
+// The COMPILE_ASSERT macro can be used to verify that a compile time
+// expression is true. For example, you could use it to verify the
+// size of a static array:
+//
+//   COMPILE_ASSERT(arraysize(content_type_names) == CONTENT_NUM_TYPES,
+//                  content_type_names_incorrect_size);
+//
+// or to make sure a struct is smaller than a certain size:
+//
+//   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
+//
+// The second argument to the macro is the name of the variable. If
+// the expression is false, most compilers will issue a warning/error
+// containing the name of the variable.
+
+template <bool>
+struct CompileAssert {
+};
+
+#undef COMPILE_ASSERT
+#define COMPILE_ASSERT(expr, msg) \
+  typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1]
+
+// Implementation details of COMPILE_ASSERT:
+//
+// - COMPILE_ASSERT works by defining an array type that has -1
+//   elements (and thus is invalid) when the expression is false.
+//
+// - The simpler definition
+//
+//     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
+//
+//   does not work, as gcc supports variable-length arrays whose sizes
+//   are determined at run-time (this is gcc's extension and not part
+//   of the C++ standard).  As a result, gcc fails to reject the
+//   following code with the simple definition:
+//
+//     int foo;
+//     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
+//                               // not a compile-time constant.
+//
+// - By using the type CompileAssert<(bool(expr))>, we ensures that
+//   expr is a compile-time constant.  (Template arguments must be
+//   determined at compile-time.)
+//
+// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
+//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
+//
+//     CompileAssert<bool(expr)>
+//
+//   instead, these compilers will refuse to compile
+//
+//     COMPILE_ASSERT(5 > 0, some_message);
+//
+//   (They seem to think the ">" in "5 > 0" marks the end of the
+//   template argument list.)
+//
+// - The array size is (bool(expr) ? 1 : -1), instead of simply
+//
+//     ((expr) ? 1 : -1).
+//
+//   This is to avoid running into a bug in MS VC 7.1, which
+//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
+
+
+// MetatagId refers to metatag-id that we assign to
+// each metatag <name, value> pair..
+typedef uint32 MetatagId;
+
+// Argument type used in interfaces that can optionally take ownership
+// of a passed in argument.  If TAKE_OWNERSHIP is passed, the called
+// object takes ownership of the argument.  Otherwise it does not.
+enum Ownership {
+  DO_NOT_TAKE_OWNERSHIP,
+  TAKE_OWNERSHIP
+};
+
+// bit_cast<Dest,Source> is a template function that implements the
+// equivalent of "*reinterpret_cast<Dest*>(&source)".  We need this in
+// very low-level functions like the protobuf library and fast math
+// support.
+//
+//   float f = 3.14159265358979;
+//   int i = bit_cast<int32>(f);
+//   // i = 0x40490fdb
+//
+// The classical address-casting method is:
+//
+//   // WRONG
+//   float f = 3.14159265358979;            // WRONG
+//   int i = * reinterpret_cast<int*>(&f);  // WRONG
+//
+// The address-casting method actually produces undefined behavior
+// according to ISO C++ specification section 3.10 -15 -.  Roughly, this
+// section says: if an object in memory has one type, and a program
+// accesses it with a different type, then the result is undefined
+// behavior for most values of "different type".
+//
+// This is true for any cast syntax, either *(int*)&f or
+// *reinterpret_cast<int*>(&f).  And it is particularly true for
+// conversions betweeen integral lvalues and floating-point lvalues.
+//
+// The purpose of 3.10 -15- is to allow optimizing compilers to assume
+// that expressions with different types refer to different memory.  gcc
+// 4.0.1 has an optimizer that takes advantage of this.  So a
+// non-conforming program quietly produces wildly incorrect output.
+//
+// The problem is not the use of reinterpret_cast.  The problem is type
+// punning: holding an object in memory of one type and reading its bits
+// back using a different type.
+//
+// The C++ standard is more subtle and complex than this, but that
+// is the basic idea.
+//
+// Anyways ...
+//
+// bit_cast<> calls memcpy() which is blessed by the standard,
+// especially by the example in section 3.9 .  Also, of course,
+// bit_cast<> wraps up the nasty logic in one place.
+//
+// Fortunately memcpy() is very fast.  In optimized mode, with a
+// constant size, gcc 2.95.3, gcc 4.0.1, and msvc 7.1 produce inline
+// code with the minimal amount of data movement.  On a 32-bit system,
+// memcpy(d,s,4) compiles to one load and one store, and memcpy(d,s,8)
+// compiles to two loads and two stores.
+//
+// I tested this code with gcc 2.95.3, gcc 4.0.1, icc 8.1, and msvc 7.1.
+//
+// WARNING: if Dest or Source is a non-POD type, the result of the memcpy
+// is likely to surprise you.
+
+template <class Dest, class Source>
+inline Dest bit_cast(const Source& source) {
+  // Compile time assertion: sizeof(Dest) == sizeof(Source)
+  // A compile error here means your Dest and Source have different sizes.
+  // typedef char VerifySizesAreEqual [sizeof(Dest) == sizeof(Source) ? 1 : -1];
+
+  Dest dest;
+  memcpy(&dest, &source, sizeof(dest));
+  return dest;
+}
+
+// The following enum should be used only as a constructor argument to indicate
+// that the variable has static storage class, and that the constructor should
+// do nothing to its state.  It indicates to the reader that it is legal to
+// declare a static instance of the class, provided the constructor is given
+// the base::LINKER_INITIALIZED argument.  Normally, it is unsafe to declare a
+// static variable that has a constructor or a destructor because invocation
+// order is undefined.  However, IF the type can be initialized by filling with
+// zeroes (which the loader does for static variables), AND the destructor also
+// does nothing to the storage, AND there are no virtual methods, then a
+// constructor declared as
+//       explicit MyClass(base::LinkerInitialized x) {}
+// and invoked as
+//       static MyClass my_variable_name(base::LINKER_INITIALIZED);
+namespace base {
+enum LinkerInitialized { LINKER_INITIALIZED };
+}  // base
+
+// UnaligndLoad32 is put here instead of util/port.h to
+// avoid the circular dependency between port.h and basictypes.h
+// ARM does not support unaligned memory access.
+#if defined(ARCH_CPU_X86_FAMILY)
+// x86 and x86-64 can perform unaligned loads/stores directly;
+inline uint32 UnalignedLoad32(const void* p) {
+  return *reinterpret_cast<const uint32*>(p);
+}
+#else
+#define NEED_ALIGNED_LOADS
+// If target architecture does not support unaligned loads and stores,
+// use memcpy version of UNALIGNED_LOAD32.
+inline uint32 UnalignedLoad32(const void* p) {
+  uint32 t;
+  memcpy(&t, reinterpret_cast<const uint8*>(p), sizeof(t));
+  return t;
+}
+
+#endif
+#endif  // UTIL_BASICTYPES_H_

data/ext/compact_enc_det/compact_enc_det/util/case_insensitive_hash.h

@@ -0,0 +1,88 @@
+// Copyright 2016 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef UTIL_CASE_INSENSITIVE_HASH_H_
+#define UTIL_CASE_INSENSITIVE_HASH_H_
+
+#include <ctype.h>
+#include <stddef.h>
+#ifndef _MSC_VER
+#include <strings.h>
+#endif
+
+#include <string>
+
+#include "util/basictypes.h"
+#include "util/string_util.h"
+
+// Functors for hashing c-strings with case-insensitive semantics.
+struct CStringCaseHash {
+  size_t operator()(const char *str) const {
+    unsigned long hash_val = 0;
+    while (*str) {
+      hash_val = 5*hash_val + tolower(*str);
+      str++;
+    }
+    return (size_t)hash_val;
+  }
+};
+
+struct CStringCaseEqual {
+  bool operator()(const char *str1, const char *str2) const {
+    return !base::strcasecmp(str1, str2);
+  }
+};
+
+// These functors, in addition to being case-insensitive, ignore all
+// non-alphanumeric characters.  This is useful when we want all variants of
+// a string -- where variants can differ in puncutation and whitespace -- to
+// map to the same value.
+struct CStringAlnumCaseHash {
+  size_t operator()(const char *str) const {
+    unsigned long hash_val = 0;
+    while (*str) {
+      if (isalnum(*str)) {
+        hash_val = 5*hash_val + tolower(*str);
+      }
+      str++;
+    }
+    return (size_t)hash_val;
+  }
+};
+
+struct CStringAlnumCaseEqual {
+  bool operator()(const char *str1, const char *str2) const {
+    while (true) {
+      // Skip until each pointer is pointing to an alphanumeric char or '\0'
+      while (!isalnum(*str1) && (*str1 != '\0')) {
+        str1++;
+      }
+      while (!isalnum(*str2) && (*str2 != '\0')) {
+        str2++;
+      }
+      if (tolower(*str1) != tolower(*str2)) {
+        return false;       // mismatch on alphanumeric char or '\0'
+      }
+      if (*str1 == '\0') {  // in which case *str2 must be '\0' as well
+        return true;        // reached '\0' in both strings without mismatch
+      }
+      str1++;
+      str2++;
+    }
+  }
+};
+
+#endif  // UTIL_CASE_INSENSITIVE_HASH_H_

data/ext/compact_enc_det/compact_enc_det/util/commandlineflags.h

@@ -0,0 +1,39 @@
+// Copyright 2016 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef UTIL_COMMANDLINEFLAGS_H_
+#define UTIL_COMMANDLINEFLAGS_H_
+
+
+#undef DEFINE_bool
+#define DEFINE_bool(name, default_value, comment) \
+    bool FLAGS_##name = default_value
+#undef DEFINE_int32
+#define DEFINE_int32(name, default_value, comment) \
+    int32 FLAGS_##name = default_value
+#undef DEFINE_string
+#define DEFINE_string(name, default_value, comment) \
+    string FLAGS_##name = default_value
+
+#undef DECLARE_bool
+#define DECLARE_bool(name) extern bool FLAGS_##name
+#undef DECLARE_int32
+#define DECLARE_int32(name) extern int32 FLAGS_##name
+#undef DECLARE_string
+#define DECLARE_string(name) extern string FLAGS_##name
+
+
+#endif  // UTIL_COMMANDLINEFLAGS_H_