src/third_party/cld_2/src/internal/compact_lang_det_test.cc

   1 // Copyright 2013 Google Inc. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 //
  16 // Author: dsites@google.com (Dick Sites)
  17 //
  18
  19 // Test: Do encoding detection on input file
  20 //       --line treat each line as a separate detection problem
  21
  22 #include <math.h>                   // for sqrt
  23 #include <stdlib.h>                 // for exit
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <sys/time.h>               // for gettimeofday
  27 #include <string>
  28
  29 #include "cld2tablesummary.h"
  30 #include "compact_lang_det_impl.h"
  31 #include "debug.h"
  32 #include "integral_types.h"
  33 #include "lang_script.h"
  34 #include "utf8statetable.h"
  35
  36 namespace CLD2 {
  37
  38 using namespace std;
  39
  40 // Scaffolding
  41 typedef int32 Encoding;
  42 static const Encoding UNKNOWN_ENCODING = 0;
  43
  44
  45 #ifndef CLD2_DYNAMIC_MODE
  46 // Linker supplies the right tables; see ScoringTables compact_lang_det_impl.cc
  47 // These are here JUST for printing versions
  48 extern const UTF8PropObj cld_generated_CjkUni_obj;
  49 extern const CLD2TableSummary kCjkDeltaBi_obj;
  50 extern const CLD2TableSummary kDistinctBiTable_obj;
  51 extern const CLD2TableSummary kQuad_obj;
  52 extern const CLD2TableSummary kDeltaOcta_obj;
  53 extern const CLD2TableSummary kDistinctOcta_obj;
  54 extern const CLD2TableSummary kOcta2_obj;
  55 extern const short kAvgDeltaOctaScore[];
  56 #endif
  57
  58 bool FLAGS_cld_version = false;
  59 bool FLAGS_cld_html = true;
  60 int32 FLAGS_repeat = 1;
  61 bool FLAGS_plain = false;
  62 bool FLAGS_dbgscore = true;
  63
  64
  65 // Convert GetTimeOfDay output to 64-bit usec
  66 static inline uint64 Microseconds(const struct timeval& t) {
  67   // Convert to (uint64) microseconds,  not (double) seconds.
  68   return t.tv_sec * 1000000ULL + t.tv_usec;
  69 }
  70
  71 #define LF 0x0a
  72 #define CR 0x0d
  73
  74 bool Readline(FILE* infile, char* buffer) {
  75   char* p = fgets(buffer, 64 * 1024, infile);
  76   if (p == NULL) {
  77     return false;
  78   }
  79   int len = strlen(buffer);
  80
  81   // trim CR LF
  82   if (buffer[len-1] == LF) {buffer[--len] = '\0';}
  83   if (buffer[len-1] == CR) {buffer[--len] = '\0';}
  84   return true;
  85 }
  86
  87 bool IsComment(char* buffer) {
  88   int len = strlen(buffer);
  89   if (len == 0) {return true;}
  90   if (buffer[0] == '#') {return true;}
  91   if (buffer[0] == ' ') {return true;}    // Any leading space is comment
  92   return false;
  93 }
  94
  95
  96
  97 void DumpExtLang(int flags,
  98                  Language summary_lang,
  99                  Language* language3, int* percent3,
 100                  double* normalized_score3,
 101                  int text_bytes, bool is_reliable, int in_size) {
 102   char temp[160];
 103   char* tp = temp;
 104   int tp_left = sizeof(temp);
 105   snprintf(tp, tp_left, "ExtLanguage");
 106
 107   if (language3[0] != UNKNOWN_LANGUAGE) {
 108     tp = temp + strlen(temp);
 109     tp_left = sizeof(temp) - strlen(temp);
 110     snprintf(tp, tp_left, " %s(%d%% %3.0fp)",
 111              LanguageName(language3[0]),
 112              percent3[0],
 113              normalized_score3[0]);
 114
 115   }
 116   if (language3[1] != UNKNOWN_LANGUAGE) {
 117     tp = temp + strlen(temp);
 118     tp_left = sizeof(temp) - strlen(temp);
 119     snprintf(tp, tp_left, ", %s(%d%% %3.0fp)",
 120              LanguageName(language3[1]),
 121              percent3[1],
 122              normalized_score3[1]);
 123   }
 124   if (language3[2] != UNKNOWN_LANGUAGE) {
 125     tp = temp + strlen(temp);
 126     tp_left = sizeof(temp) - strlen(temp);
 127     snprintf(tp, tp_left, ", %s(%d%% %3.0fp)",
 128              LanguageName(language3[2]),
 129              percent3[2],
 130              normalized_score3[2]);
 131   }
 132
 133   if (text_bytes > 9999) {
 134     tp = temp + strlen(temp);
 135     tp_left = sizeof(temp) - strlen(temp);
 136     snprintf(tp, tp_left, ", %d/%d KB of non-tag letters",
 137             text_bytes >> 10, in_size >> 10);
 138   } else {
 139     tp = temp + strlen(temp);
 140     tp_left = sizeof(temp) - strlen(temp);
 141     snprintf(tp, tp_left, ", %d/%d bytes of non-tag letters",
 142             text_bytes, in_size);
 143   }
 144
 145   tp = temp + strlen(temp);
 146   tp_left = sizeof(temp) - strlen(temp);
 147   snprintf(tp, tp_left, ", Summary: %s%s",
 148            LanguageName(summary_lang),
 149            is_reliable ? "" : "*");
 150
 151   printf("%s\n", temp);
 152
 153   // Also put into optional HTML output
 154   if ((flags & kCLDFlagHtml) != 0) {
 155     fprintf(stderr, "%s\n", temp);
 156   }
 157 }
 158
 159 void DumpLanguages(Language summary_lang,
 160                    Language* language3, int* percent3,
 161                  int text_bytes, bool is_reliable, int in_size) {
 162   // fprintf(stderr, "</span>\n\n");
 163   int total_percent = 0;
 164   if (language3[0] != UNKNOWN_LANGUAGE) {
 165     fprintf(stderr, "\n<br>Languages %s(%d%%)",
 166             LanguageName(language3[0]),
 167             percent3[0]);
 168     total_percent += percent3[0];
 169   } else {
 170     fprintf(stderr, "\n<br>Languages ");
 171   }
 172
 173   if (language3[1] != UNKNOWN_LANGUAGE) {
 174     fprintf(stderr, ", %s(%d%%)",
 175             LanguageName(language3[1]),
 176             percent3[1]);
 177     total_percent += percent3[1];
 178   }
 179
 180   if (language3[2] != UNKNOWN_LANGUAGE) {
 181     fprintf(stderr, ", %s(%d%%)",
 182             LanguageName(language3[2]),
 183             percent3[2]);
 184     total_percent += percent3[2];
 185   }
 186
 187   fprintf(stderr, ", other(%d%%)", 100 - total_percent);
 188
 189   if (text_bytes > 9999) {
 190     fprintf(stderr, ", %d/%d KB of non-tag letters",
 191             text_bytes >> 10, in_size >> 10);
 192   } else {
 193     fprintf(stderr, ", %d/%d bytes of non-tag letters",
 194             text_bytes, in_size);
 195   }
 196
 197   fprintf(stderr, ", Summary: %s%s ",
 198           LanguageName(summary_lang),
 199           is_reliable ? "" : "*");
 200   fprintf(stderr, "<br>\n");
 201 }
 202
 203
 204 int main(int argc, char** argv) {
 205   if (FLAGS_cld_version) {
 206 #ifndef CLD2_DYNAMIC_MODE
 207     printf("%s %4dKB uni build date, bytes\n",
 208            "........",
 209            cld_generated_CjkUni_obj.total_size >> 10);
 210     printf("%d %4ldKB delta_bi build date, bytes\n",
 211            kCjkDeltaBi_obj.kCLDTableBuildDate,
 212            (kCjkDeltaBi_obj.kCLDTableSize *
 213             sizeof(IndirectProbBucket4)) >> 10);
 214     printf("%d %4ldKB quad build date, bytes\n",
 215            kQuad_obj.kCLDTableBuildDate,
 216            (kQuad_obj.kCLDTableSize *
 217             sizeof(IndirectProbBucket4)) >> 10);
 218     printf("%d %4ldKB delta_octa build date, bytes\n",
 219            kDeltaOcta_obj.kCLDTableBuildDate,
 220            (kDeltaOcta_obj.kCLDTableSize *
 221             sizeof(IndirectProbBucket4)) >> 10);
 222 #else
 223     printf("FLAGS_cld_version doesn't work with dynamic data mode\n");
 224 #endif
 225     exit(0);
 226   }     // End FLAGS_cld_version
 227
 228   int flags = 0;
 229   bool get_vector = false;
 230   const char* data_file = NULL;
 231   bool do_line = false;
 232   const char* fname = NULL;
 233   for (int i = 1; i < argc; ++i) {
 234     if (argv[i][0] != '-') {fname = argv[i];}
 235     if (strcmp(argv[i], "--scoreasquads") == 0) {flags |= kCLDFlagScoreAsQuads;}
 236     if (strcmp(argv[i], "--html") == 0) {flags |= kCLDFlagHtml;}
 237     if (strcmp(argv[i], "--cr") == 0) {flags |= kCLDFlagCr;}
 238     if (strcmp(argv[i], "--verbose") == 0) {flags |= kCLDFlagVerbose;}
 239     if (strcmp(argv[i], "--echo") == 0) {flags |= kCLDFlagEcho;}
 240     if (strcmp(argv[i], "--besteffort") == 0) {flags |= kCLDFlagBestEffort;}
 241     if (strcmp(argv[i], "--vector") == 0) {get_vector = true;}
 242     if (strcmp(argv[i], "--line") == 0) {do_line = true;}
 243     if (strcmp(argv[i], "--data-file") == 0) { data_file = argv[++i];}
 244   }
 245
 246 #ifdef CLD2_DYNAMIC_MODE
 247   if (data_file == NULL) {
 248     fprintf(stderr, "When running in dynamic mode, you must specify --data-file [FILE]\n");
 249     return -1;
 250   }
 251   fprintf(stdout, "Loading data from: %s\n", data_file);
 252   CLD2::loadDataFromFile(data_file);
 253   fprintf(stdout, "Data loaded, test commencing\n");
 254 #endif
 255
 256   FILE* fin;
 257   if (fname == NULL) {
 258     fin = stdin;
 259   } else {
 260     if (do_line) {
 261       fin = fopen(fname, "r");
 262     } else {
 263       fin = fopen(fname, "rb");
 264     }
 265     if (fin == NULL) {
 266       fprintf(stderr, "%s did not open\n", fname);
 267       exit(0);
 268     }
 269   }
 270
 271   const char* tldhint = "";
 272   Encoding enchint = UNKNOWN_ENCODING;
 273   Language langhint = UNKNOWN_LANGUAGE;
 274
 275   int bytes_consumed;
 276   int bytes_filled;
 277   int error_char_count;
 278   bool is_reliable;
 279   int usec;
 280   char* buffer = new char[10000000];  // Max 10MB of input for this test program
 281   struct timeval news, newe;
 282
 283   // Full-blown flag-bit and hints interface
 284   bool allow_extended_lang = true;
 285   Language plus_one = UNKNOWN_LANGUAGE;
 286   bool ignore_7bit = false;
 287
 288   if (do_line) {
 289     while (Readline(fin, buffer)) {
 290       if (IsComment(buffer)) {continue;}
 291
 292       // Detect language one line at a time
 293       Language summary_lang = UNKNOWN_LANGUAGE;
 294
 295       Language language3[3];
 296       int percent3[3];
 297       double normalized_score3[3];
 298       ResultChunkVector resultchunkvector;
 299       bool is_plain_text = FLAGS_plain;
 300       int text_bytes;
 301
 302       CLDHints cldhints = {NULL, tldhint, enchint, langhint};
 303
 304       summary_lang = CLD2::DetectLanguageSummaryV2(
 305                           buffer,
 306                           strlen(buffer),
 307                           is_plain_text,
 308                           &cldhints,
 309                           allow_extended_lang,
 310                           flags,
 311                           plus_one,
 312                           language3,
 313                           percent3,
 314                           normalized_score3,
 315                           get_vector ? &resultchunkvector : NULL,
 316                           &text_bytes,
 317                           &is_reliable);
 318       printf("%s%s %d%% %s\n",
 319          LanguageName(language3[0]),
 320          is_reliable ? "" : "*",
 321          percent3[0],
 322          buffer);
 323     }
 324     fclose(fin);
 325     delete[] buffer;
 326     return 0;
 327   }
 328
 329   if ((flags & kCLDFlagHtml) != 0) {
 330     // Begin HTML file
 331     fprintf(stderr, "<html><meta charset=\"UTF-8\"><body>\n");
 332     fprintf(stderr, "<style media=\"print\" type=\"text/css\"> "
 333                     ":root { -webkit-print-color-adjust: exact; } </style>\n");
 334     fprintf(stderr, "<span style=\"font-size: 7pt\">\n");
 335   }
 336
 337   if ((flags & kCLDFlagHtml) != 0) {
 338     //// fprintf(stderr, "<html><body><span style=\"font-size: 7pt\">\n");
 339     //// fprintf(stderr, "<html><body><span style=\"font-size: 6pt\"><pre>\n");
 340     fprintf(stderr, "file = %s<br>\n", fname ? fname : "stdin");
 341   }
 342
 343   // Read entire file
 344   int n = fread(buffer, 1, 10000000, fin);
 345
 346
 347   // Detect languages in entire file
 348   Language summary_lang = UNKNOWN_LANGUAGE;
 349
 350   Language language3[3];
 351   int percent3[3];
 352   double normalized_score3[3];
 353   ResultChunkVector resultchunkvector;
 354   bool is_plain_text = FLAGS_plain;
 355   int text_bytes;
 356
 357   CLDHints cldhints = {NULL, tldhint, enchint, langhint};
 358
 359   gettimeofday(&news, NULL);
 360   for (int i = 0; i < FLAGS_repeat; ++i) {
 361     summary_lang = CLD2::DetectLanguageSummaryV2(
 362                           buffer,
 363                           n,
 364                           is_plain_text,
 365                           &cldhints,
 366                           allow_extended_lang,
 367                           flags,
 368                           plus_one,
 369                           language3,
 370                           percent3,
 371                           normalized_score3,
 372                           get_vector ? &resultchunkvector : NULL,
 373                           &text_bytes,
 374                           &is_reliable);
 375   }
 376   gettimeofday(&newe, NULL);
 377
 378   if (get_vector) {
 379     DumpResultChunkVector(stderr, buffer, &resultchunkvector);
 380   }
 381
 382   DumpExtLang(flags, summary_lang, language3, percent3, normalized_score3,
 383               text_bytes, is_reliable, n);
 384
 385   if ((flags & kCLDFlagHtml) != 0) {
 386     DumpLanguages(summary_lang,
 387                   language3, percent3, text_bytes, is_reliable, n);
 388   }
 389
 390   usec = static_cast<int>(Microseconds(newe) - Microseconds(news));
 391   if (usec == 0) {usec = 1;}
 392   printf("  SummaryLanguage %s%s at %u of %d %uus (%d MB/sec), %s\n",
 393          LanguageName(summary_lang),
 394          is_reliable ? "" : "(un-reliable)",
 395          bytes_consumed,
 396          n,
 397          usec,
 398          n / usec,
 399          argv[1]);
 400
 401   if ((flags & kCLDFlagHtml) != 0) {
 402     fprintf(stderr, "\n</span></body></html><br>");
 403   }
 404
 405   fclose(fin);
 406   delete[] buffer;
 407
 408   return 0;
 409 }
 410
 411 }       // End namespace CLD2
 412
 413 int main(int argc, char *argv[]) {
 414   return CLD2::main(argc, argv);
 415 }
 416