Make undefined Unicode characters show up in a nicer way in braille.

third_party/liblouis/nacl_wrapper/liblouis_wrapper.cc

 // Copyright 2013 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
@@ skipping 91 matching lines @@
 }
 
 LibLouisWrapper::~LibLouisWrapper() {
   lou_free();
 }
 
 const char* LibLouisWrapper::tables_dir() const {
   return "/liblouis/tables";
 }
 
-bool LibLouisWrapper::CheckTable(const std::string& table_name) {
-  return lou_getTable(table_name.c_str()) != NULL;
+bool LibLouisWrapper::CheckTable(const std::string& table_names) {
+  return lou_getTable(table_names.c_str()) != NULL;
 }
 
 bool LibLouisWrapper::Translate(const TranslationParams& params,
     TranslationResult* out) {
   // Convert the character set of the input text.
   std::vector<widechar> inbuf;
   if (!DecodeUtf8(params.text, &inbuf)) {
     // TODO(jbroman): log this
     return false;
   }
@@ skipping 21 matching lines @@
   // common cases like single digits or capital letters won't always trigger
   // retranslations (see the comments above the second exit condition inside
   // the loop).  We also set an arbitrary upper bound for the allocation
   // to make sure the loop exits without running out of memory.
   for (int outalloc = (inbufsize + 1) * 2, maxoutalloc = (inbufsize + 1) * 8;
        outalloc <= maxoutalloc; outalloc *= 2) {
     int inlen = inbufsize;
     outlen = outalloc;
     outbuf.resize(outalloc);
     braille_to_text.resize(outalloc);
-    int result = lou_translate(params.table_name.c_str(),
+    int result = lou_translate(params.table_names.c_str(),
                                &inbuf[0], &inlen, &outbuf[0], &outlen,
                                NULL /* typeform */, NULL /* spacing */,
                                &text_to_braille[0], &braille_to_text[0],
                                out_cursor_position_ptr, dotsIO /* mode */);
     if (result == 0) {
       // TODO(jbroman): log this
       return false;
     }
     // If all of inbuf was not consumed, the output buffer must be too small
     // and we have to retry with a larger buffer.
@@ skipping 15 matching lines @@
   braille_to_text.resize(outlen);
 
   // Return the translation result.
   out->cells.swap(cells);
   out->text_to_braille.swap(text_to_braille);
   out->braille_to_text.swap(braille_to_text);
   out->cursor_position = out_cursor_position;
   return true;
 }
 
-bool LibLouisWrapper::BackTranslate(const std::string& table_name,
+bool LibLouisWrapper::BackTranslate(const std::string& table_names,
     const std::vector<unsigned char>& cells, std::string* out) {
   std::vector<widechar> inbuf;
   inbuf.reserve(cells.size());
   for (std::vector<unsigned char>::const_iterator it = cells.begin();
       it != cells.end(); ++it) {
     // Set the high-order bit to prevent liblouis from dropping empty cells.
     inbuf.push_back(*it | 0x8000);
   }
   // To avoid unsigned/signed comparison warnings.
   int inbufsize = inbuf.size();
   std::vector<widechar> outbuf;
   int outlen;
 
   // Invoke liblouis.  Do this in a loop since we can't precalculate the
   // translated size.  We add an extra slot in the output buffer so that
   // common cases like single digits or capital letters won't always trigger
   // retranslations (see the comments above the second exit condition inside
   // the loop).  We also set an arbitrary upper bound for the allocation
   // to make sure the loop exits without running out of memory.
   for (int outalloc = (inbufsize + 1) * 2, maxoutalloc = (inbufsize + 1) * 8;
        outalloc <= maxoutalloc; outalloc *= 2) {
     int inlen = inbufsize;
     outlen = outalloc;
     outbuf.resize(outalloc);
 
     int result = lou_backTranslateString(
-        table_name.c_str(), &inbuf[0], &inlen, &outbuf[0], &outlen,
+        table_names.c_str(), &inbuf[0], &inlen, &outbuf[0], &outlen,
       NULL /* typeform */, NULL /* spacing */, dotsIO /* mode */);
     if (result == 0) {
       // TODO(jbroman): log this
       return false;
     }
 
     // If all of inbuf was not consumed, the output buffer must be too small
     // and we have to retry with a larger buffer.
     // In addition, if all of outbuf was exhausted, there's no way to know if
     // more space was needed, so we'll have to retry the translation in that
@@ skipping 10 matching lines @@
     // TODO(jbroman): log this
     return false;
   }
 
   // Return the back translation result.
   out->swap(text);
   return true;
 }
 
 }  // namespace liblouis_nacl