Consistent error messages ending in . without newline

And a few other minor formatting changes for error messages.

Author: joto

src/flex-table-column.cpp

@@ -97,8 +97,8 @@ void flex_table_column_t::set_projection(char const *projection)
     m_srid = static_cast<int>(std::strtoul(projection, &end, 10));
 
     if (*end != '\0') {
-        throw std::runtime_error{std::string{"Unknown projection: "} +
-                                 projection};
+        throw std::runtime_error{
+            "Unknown projection: '{}'."_format(projection)};
     }
 }
 
@@ -144,7 +144,7 @@ std::string flex_table_column_t::sql_type_name() const
     case table_column_type::id_num:
         return "int8";
     }
-    throw std::runtime_error{"Unknown column type"};
+    throw std::runtime_error{"Unknown column type."};
 }
 
 std::string flex_table_column_t::sql_modifiers() const

src/gazetteer-style.cpp

@@ -192,7 +192,7 @@ void gazetteer_style_t::add_style_entry(std::string const &key,
         }
         if (!value.empty()) {
             throw std::runtime_error{
-                "Style error. Prefix key can only be used with empty value.\n"};
+                "Style error. Prefix key can only be used with empty value."};
         }
         m_matcher.emplace_back(key.substr(0, key.size() - 1), flags,
                                matcher_t::MT_PREFIX);
@@ -203,7 +203,7 @@ void gazetteer_style_t::add_style_entry(std::string const &key,
     if (key[0] == '*') {
         if (!value.empty()) {
             throw std::runtime_error{
-                "Style error. Suffix key can only be used with empty value.\n"};
+                "Style error. Suffix key can only be used with empty value."};
         }
         m_matcher.emplace_back(key.substr(1), flags, matcher_t::MT_SUFFIX);
         return;
@@ -218,12 +218,12 @@ void gazetteer_style_t::add_style_entry(std::string const &key,
     if (add_metadata_style_entry(key)) {
         if (!value.empty()) {
             throw std::runtime_error{"Style error. Rules for OSM metadata "
-                                     "attributes must have an empty value.\n"};
+                                     "attributes must have an empty value."};
         }
         if (flags != SF_EXTRA) {
             throw std::runtime_error{"Style error. Rules for OSM metadata "
                                      "attributes must have the style flag "
-                                     "\"extra\" and no other flag.\n"};
+                                     "\"extra\" and no other flag."};
         }
         return;
     }

src/geom-transform.cpp

@@ -31,7 +31,7 @@ bool geom_transform_line_t::set_param(char const *name, lua_State *lua_state)
     if (lua_type(lua_state, -1) != LUA_TNUMBER) {
         throw std::runtime_error{
             "The 'split_at' field in a geometry transformation "
-            "description must be a number"};
+            "description must be a number."};
     }
     m_split_at = lua_tonumber(lua_state, -1);
 
@@ -75,7 +75,7 @@ bool geom_transform_area_t::set_param(char const *name, lua_State *lua_state)
     if (lua_type(lua_state, -1) != LUA_TBOOLEAN) {
         throw std::runtime_error{
             "The 'multi' field in a geometry transformation "
-            "description must be a boolean"};
+            "description must be a boolean."};
     }
     m_multi = lua_toboolean(lua_state, -1);
 
@@ -140,7 +140,7 @@ std::unique_ptr<geom_transform_t> create_geom_transform(char const *type)
     }
 
     throw std::runtime_error{
-        "Unknown geometry transformation '{}'"_format(type)};
+        "Unknown geometry transformation '{}'."_format(type)};
 }
 
 void init_geom_transform(geom_transform_t *transform, lua_State *lua_state)
@@ -155,7 +155,7 @@ void init_geom_transform(geom_transform_t *transform, lua_State *lua_state)
         char const *const field = lua_tostring(lua_state, -2);
         if (field == nullptr) {
             throw std::runtime_error{"All fields in geometry transformation "
-                                     "description must have string keys"};
+                                     "description must have string keys."};
         }
 
         if (std::strcmp(field, "create") != 0) {

src/lua-utils.cpp

@@ -111,7 +111,7 @@ char const *luaX_get_table_string(lua_State *lua_state, char const *key,
     lua_getfield(lua_state, table_index, key);
     if (!lua_isstring(lua_state, -1)) {
         throw std::runtime_error{
-            "{} must contain a '{}' string field"_format(error_msg, key)};
+            "{} must contain a '{}' string field."_format(error_msg, key)};
     }
     return lua_tostring(lua_state, -1);
 }
@@ -134,7 +134,7 @@ bool luaX_get_table_bool(lua_State *lua_state, char const *key, int table_index,
     }
 
     throw std::runtime_error{
-        "{} must contain a '{}' boolean field"_format(error_msg, key)};
+        "{} must contain a '{}' boolean field."_format(error_msg, key)};
 }
 
 

src/node-persistent-cache.cpp

@@ -59,7 +59,7 @@ node_persistent_cache::node_persistent_cache(
     if (m_fd < 0) {
         fmt::print(stderr, "Cannot open location cache file '{}': {}\n",
                    m_fname, std::strerror(errno));
-        throw std::runtime_error{"Unable to open flatnode file\n"};
+        throw std::runtime_error{"Unable to open flatnode file."};
     }
 
     m_index.reset(new index_t{m_fd});

src/node-ram-cache.cpp

@@ -95,7 +95,7 @@ void node_ram_cache::set_sparse(osmid_t id, osmium::Location location)
             }
             throw std::runtime_error{
                 "Node cache size is too small to fit all nodes. Please "
-                "increase cache size\n"};
+                "increase cache size."};
         }
     }
     maxSparseId = id;
@@ -174,7 +174,7 @@ void node_ram_cache::set_dense(osmid_t id, osmium::Location location)
             blocks[block].reset_used();
             blocks[block].block_offset = block;
             if (!blocks[block].nodes) {
-                throw std::runtime_error{"Error allocating nodes"};
+                throw std::runtime_error{"Error allocating nodes."};
             }
             queue[usedBlocks] = &blocks[block];
             ++usedBlocks;
@@ -190,7 +190,7 @@ void node_ram_cache::set_dense(osmid_t id, osmium::Location location)
             if ((allocStrategy & ALLOC_LOSSY) == 0) {
                 throw std::runtime_error{
                     "Node cache size is too small to fit all nodes. "
-                    "Please increase cache size"};
+                    "Please increase cache size."};
             }
             /* We've reached the maximum number of blocks, so now we push the
              * current head of the tree down to the right level to restore the
@@ -313,7 +313,7 @@ node_ram_cache::node_ram_cache(int strategy, int cacheSizeMB)
         if (!blocks) {
             throw std::runtime_error{
                 "Out of memory for node cache dense index, try using "
-                "\"--cache-strategy sparse\" instead"};
+                "\"--cache-strategy sparse\" instead."};
         }
         queue = (ramNodeBlock **)calloc(maxBlocks, sizeof(ramNodeBlock *));
         /* Use this method of allocation if virtual memory is limited,
@@ -324,15 +324,15 @@ node_ram_cache::node_ram_cache(int strategy, int cacheSizeMB)
             fprintf(stderr,
                     "Allocating dense node cache in block sized chunks\n");
             if (!queue) {
-                throw std::runtime_error{"Out of memory, reduce --cache size"};
+                throw std::runtime_error{"Out of memory, reduce --cache size."};
             }
         } else {
             fprintf(stderr, "Allocating dense node cache in one big chunk\n");
             blockCache = (char *)malloc((maxBlocks + 1024) * per_block() *
                                         sizeof(osmium::Location));
             if (!queue || !blockCache) {
                 throw std::runtime_error{
-                    "Out of memory for dense node cache, reduce --cache size"};
+                    "Out of memory for dense node cache, reduce --cache size."};
             }
         }
     }
@@ -356,7 +356,7 @@ node_ram_cache::node_ram_cache(int strategy, int cacheSizeMB)
         }
         if (!sparseBlock) {
             throw std::runtime_error{
-                "Out of memory for sparse node cache, reduce --cache size"};
+                "Out of memory for sparse node cache, reduce --cache size."};
         }
     }
 
@@ -414,7 +414,7 @@ void node_ram_cache::set(osmid_t id, osmium::Location location)
     if ((id > 0 && id >> BLOCK_SHIFT >> 32U) ||
         (id < 0 && ~id >> BLOCK_SHIFT >> 32U)) {
         throw std::runtime_error{"Absolute node IDs must not be larger than {}"
-                                 " (got {})"_format(1ULL << 42U, id)};
+                                 " (got {})."_format(1ULL << 42U, id)};
     }
     ++totalNodes;
     /* if ALLOC_DENSE and ALLOC_SPARSE are set, send it through
@@ -429,7 +429,7 @@ void node_ram_cache::set(osmid_t id, osmium::Location location)
         // Command line options always have ALLOC_DENSE | ALLOC_SPARSE
         throw std::logic_error{
             "Unexpected cache strategy in node_ram_cache::set with "
-            "allocStrategy {}"_format(allocStrategy)};
+            "allocStrategy {}."_format(allocStrategy)};
     }
 }
 

src/options.cpp

@@ -84,8 +84,8 @@ const struct option long_options[] = {
 
 void short_usage(char *arg0)
 {
-    throw std::runtime_error{"Usage error. For further information see:\n"
-                             "\t{} -h|--help\n"_format(program_name(arg0))};
+    throw std::runtime_error{"Usage error. For further information call:"
+                             " {} --help"_format(program_name(arg0))};
 }
 
 void long_usage(char const *arg0, bool verbose)
@@ -332,17 +332,17 @@ static osmium::Box parse_bbox(char const *bbox)
     int const n = sscanf(bbox, "%lf,%lf,%lf,%lf", &minx, &miny, &maxx, &maxy);
     if (n != 4) {
         throw std::runtime_error{"Bounding box must be specified like: "
-                                 "minlon,minlat,maxlon,maxlat\n"};
+                                 "minlon,minlat,maxlon,maxlat."};
     }
 
     if (maxx <= minx) {
         throw std::runtime_error{
-            "Bounding box failed due to maxlon <= minlon\n"};
+            "Bounding box failed due to maxlon <= minlon."};
     }
 
     if (maxy <= miny) {
         throw std::runtime_error{
-            "Bounding box failed due to maxlat <= minlat\n"};
+            "Bounding box failed due to maxlat <= minlat."};
     }
 
     fmt::print(stderr, "Applying Bounding box: {},{} to {},{}\n", minx, miny,
@@ -442,7 +442,7 @@ options_t::options_t(int argc, char *argv[]) : options_t()
             if (!optarg || optarg[0] == '-') {
                 throw std::runtime_error{
                     "Missing argument for option --expire-tiles. Zoom "
-                    "levels must be positive.\n"};
+                    "levels must be positive."};
             }
             char *next_char;
             expire_tiles_zoom_min =
@@ -451,7 +451,7 @@ options_t::options_t(int argc, char *argv[]) : options_t()
                 throw std::runtime_error{
                     "Bad argument for option --expire-tiles. "
                     "Minimum zoom level must be larger "
-                    "than 0.\n"};
+                    "than 0."};
             }
             // The first character after the number is ignored because that is the separating hyphen.
             if (*next_char == '-') {
@@ -463,19 +463,19 @@ options_t::options_t(int argc, char *argv[]) : options_t()
                         std::strtoul(next_char, &after_maxzoom, 10));
                     if (expire_tiles_zoom == 0 || *after_maxzoom != '\0') {
                         throw std::runtime_error{"Invalid maximum zoom level "
-                                                 "given for tile expiry.\n"};
+                                                 "given for tile expiry."};
                     }
                 } else {
                     throw std::runtime_error{
-                        "Invalid maximum zoom level given for tile expiry.\n"};
+                        "Invalid maximum zoom level given for tile expiry."};
                 }
             } else if (*next_char == '\0') {
                 // end of string, no second zoom level given
                 expire_tiles_zoom = expire_tiles_zoom_min;
             } else {
                 throw std::runtime_error{"Minimum and maximum zoom level for "
                                          "tile expiry must be separated by "
-                                         "'-'.\n"};
+                                         "'-'."};
             }
             break;
         case 'o':
@@ -498,7 +498,7 @@ options_t::options_t(int argc, char *argv[]) : options_t()
         case 'k':
             if (hstore_mode != hstore_column::none) {
                 throw std::runtime_error{"You can not specify both --hstore "
-                                         "(-k) and --hstore-all (-j)\n"};
+                                         "(-k) and --hstore-all (-j)."};
             }
             hstore_mode = hstore_column::norm;
             break;
@@ -508,7 +508,7 @@ options_t::options_t(int argc, char *argv[]) : options_t()
         case 'j':
             if (hstore_mode != hstore_column::none) {
                 throw std::runtime_error{"You can not specify both --hstore "
-                                         "(-k) and --hstore-all (-j)\n"};
+                                         "(-k) and --hstore-all (-j)."};
             }
             hstore_mode = hstore_column::all;
             break;
@@ -540,7 +540,7 @@ options_t::options_t(int argc, char *argv[]) : options_t()
                 alloc_chunkwise = ALLOC_DENSE | ALLOC_SPARSE;
             } else {
                 throw std::runtime_error{
-                    "Unrecognized cache strategy {}.\n"_format(optarg)};
+                    "Unrecognized cache strategy {}."_format(optarg)};
             }
             break;
         case 205:
@@ -627,15 +627,15 @@ void options_t::check_options()
 {
     if (append && create) {
         throw std::runtime_error{"--append and --create options can not be "
-                                 "used at the same time!\n"};
+                                 "used at the same time!"};
     }
 
     if (append && !slim) {
-        throw std::runtime_error{"--append can only be used with slim mode!\n"};
+        throw std::runtime_error{"--append can only be used with slim mode!"};
     }
 
     if (droptemp && !slim) {
-        throw std::runtime_error{"--drop only makes sense with --slim.\n"};
+        throw std::runtime_error{"--drop only makes sense with --slim."};
     }
 
     if (hstore_mode == hstore_column::none && hstore_columns.empty() &&
@@ -662,7 +662,7 @@ void options_t::check_options()
     if (cache == 0) {
         if (!slim) {
             throw std::runtime_error{
-                "Ram node cache can only be disable in slim mode.\n"};
+                "Ram node cache can only be disable in slim mode."};
         }
         if (!flat_node_cache_enabled) {
             fprintf(stderr, "WARNING: ram cache is disabled. This will likely "