#include <string.h> // strlen strcpy strcat memcpy memmove strstr strchr memcmp

#include <stdlib.h> // atof

#include <ctype.h> // toupper

#include <math.h> // floor fabs

#include "mapcoder.h"

#include "internal_data.h"

#include "internal_iso3166_data.h"

#include "internal_territory_alphabets.h"

#include "internal_territory_names_local.h"

#include "internal_alphabet_recognizer.h"

#include "internal_territory_names_af.h"

#include "internal_territory_names_ar.h"

#include "internal_territory_names_be.h"

#include "internal_territory_names_cn.h"

#include "internal_territory_names_cs.h"

#include "internal_territory_names_da.h"

#include "internal_territory_names_de.h"

#include "internal_territory_names_en.h"

#include "internal_territory_names_es.h"

#include "internal_territory_names_fi.h"

#include "internal_territory_names_fr.h"

#include "internal_territory_names_he.h"

#include "internal_territory_names_hi.h"

#include "internal_territory_names_hr.h"

#include "internal_territory_names_id.h"

#include "internal_territory_names_it.h"

#include "internal_territory_names_ja.h"

#include "internal_territory_names_ko.h"

#include "internal_territory_names_nl.h"

#include "internal_territory_names_no.h"

#include "internal_territory_names_pl.h"

#include "internal_territory_names_pt.h"

#include "internal_territory_names_ru.h"

#include "internal_territory_names_sv.h"

#include "internal_territory_names_sw.h"

#include "internal_territory_names_tr.h"

#include "internal_territory_names_uk.h"

char* _MAPCODE_C_VERSION = MAPCODE_C_VERSION; // Version string of the mapcode library

int _MAX_NR_OF_MAPCODE_RESULTS = MAX_NR_OF_MAPCODE_RESULTS; // Maximum number of mapcode results returned

int _MAX_PRECISION_DIGITS = MAX_PRECISION_DIGITS; // Maximum extra precision digits supported

int _MAX_PROPER_MAPCODE_ASCII_LEN = MAX_PROPER_MAPCODE_ASCII_LEN; // Maximum length of a proper mapcode in ASCII

int _MAX_ISOCODE_ASCII_LEN = MAX_ISOCODE_ASCII_LEN; // Maximum length of ISO territory code

int _MAX_CLEAN_MAPCODE_ASCII_LEN = MAX_CLEAN_MAPCODE_ASCII_LEN; // Maximum length of clean mapcode (no territory)

int _MAX_MAPCODE_RESULT_ASCII_LEN = MAX_MAPCODE_RESULT_ASCII_LEN; // Maximum length of complete result string

int _MAX_TERRITORY_FULLNAME_UTF8_LEN = MAX_TERRITORY_FULLNAME_UTF8_LEN; // Maximum territory name length in UTF-8

int _MAX_MAPCODE_RESULT_UTF8_LEN = MAX_MAPCODE_RESULT_UTF8_LEN; // Maximum result length in UTF-8

int _MAX_MAPCODE_RESULT_UTF16_LEN = MAX_MAPCODE_RESULT_UTF16_LEN; // Maximum result length in UTF-16

int _MAX_ALPHABETS_PER_TERRITORY = MAX_ALPHABETS_PER_TERRITORY; // Maximum alphabets supported per territory

#ifdef DEBUG

#include <stdio.h>

void _TestAssert(int iCondition, const char* cstrFile, int iLine) {

static int nrAsserts = 0;

if (!iCondition) {

fprintf(stderr, "** Assertion failed: file \"%s\", line %d\n", cstrFile, iLine);

++nrAsserts;

if (nrAsserts >= 25) {

fprintf(stderr, "** Stopped execution after %d assertions!\n", nrAsserts);

exit(-1);

}

}

}

#define ASSERT(condition) _TestAssert((int) (condition), __FILE__, (int) __LINE__)

#define ASSERT(condition)

#ifndef NO_FAST_ENCODE

#include "internal_territory_search.h"

#define IS_NAMELESS(m) (TERRITORY_BOUNDARIES[m].flags & 64) // Territory uses nameless encoding (bit 6)

#define IS_RESTRICTED(m) (TERRITORY_BOUNDARIES[m].flags & 512) // Territory has access restrictions (bit 9)

#define IS_SPECIAL_SHAPE(m) (TERRITORY_BOUNDARIES[m].flags & 1024) // Territory has non-standard shape (bit 10)

#define REC_TYPE(m) ((TERRITORY_BOUNDARIES[m].flags >> 7) & 3) // Record type (bits 7-8): grid encoding method

#define SMART_DIV(m) ((int)((unsigned int)(TERRITORY_BOUNDARIES[m].flags) >> 16)) // Smart divider value (bits 16+): grid subdivision

#define HEADER_LETTER(m) (ENCODE_CHARS[(TERRITORY_BOUNDARIES[m].flags >> 11) & 31]) // Header letter for encoding (bits 11-15)

#define TOKENSEP 0 // Separator character (space, hyphen, etc.)

#define TOKENDOT 1 // Dot character '.'

#define TOKENCHR 2 // Regular character (consonant or digit)

#define TOKENVOWEL 3 // Vowel character (A, E, U)

#define TOKENZERO 4 // Zero digit '0'

#define TOKENHYPH 5 // Hyphen character '-'

#define STATE_GO 31 // Active parsing state identifier

#define MATH_PI 3.14159265358979323846 // High-precision value of π

#define MAX_PRECISION_FACTOR 810000 // 30^(MAX_PRECISION_DIGITS/2) - base precision factor

#define EARTH_RADIUS_X_METERS 6378137 // Equatorial radius (semi-major axis)

#define EARTH_RADIUS_Y_METERS 6356752 // Polar radius (semi-minor axis)

#define EARTH_CIRCUMFERENCE_X (EARTH_RADIUS_X_METERS * 2 * MATH_PI) // Equatorial circumference

#define EARTH_CIRCUMFERENCE_Y (EARTH_RADIUS_Y_METERS * 2 * MATH_PI) // Meridional circumference

#define MICROLAT_TO_FRACTIONS_FACTOR ((double) MAX_PRECISION_FACTOR) // Convert latitude microdegrees to fractions

#define MICROLON_TO_FRACTIONS_FACTOR (4.0 * MAX_PRECISION_FACTOR) // Convert longitude microdegrees to fractions

#define GRID_SIZE_31 31 // Base grid size: 31x31 grid cells (base-31 encoding)

#define GRID_SIZE_961 961 // 31^2 = 961 - second level grid size

#define GRID_SIZE_962 962 // 961 + 1 - used for boundary calculations

#define GRID_SIZE_SQUARED (961 * 961) // 961^2 - third level grid size for fine precision

#define MAX_NAMELESS_RECORDS 62 // Maximum nameless territory records in subdivision

#define Y_DIVIDER 90 // Standard latitude divider for grid calculations

#define SPECIAL_CODEX_21 21 // Special encoding method identifier (type 21)

#define SPECIAL_CODEX_22 22 // Special encoding method identifier (type 22)

#define SPECIAL_CODEX_13 13 // Special encoding method identifier (type 13)

#define SPECIAL_CODEX_14 14 // Special encoding method identifier (type 14)

#define GRID_MULTIPLIER_16 16 // Multiplier for grid offset calculations

#define FLAG_UTF8_STRING 0 // Interpret string pointer as UTF-8 characters

#define FLAG_UTF16_STRING 1 // Interpret string pointer as UTF-16 characters

static const double METERS_PER_DEGREE_LAT = EARTH_CIRCUMFERENCE_Y / 360.0; // ~111,319 meters per degree latitude

static const double METERS_PER_DEGREE_LON = EARTH_CIRCUMFERENCE_X / 360.0; // ~111,320 meters per degree longitude at equator

static const int DEBUG_STOP_AT = -1; // Internal debug limit for encoding tests (do not use in production!)

typedef struct {

const char* locale; // Language/locale identifier

const char** territoryFullNames; // Array of territory names in this language

} LocaleRegistryItem;

static const LocaleRegistryItem LOCALE_REGISTRY[] = {

{"AF", TERRITORY_FULL_NAME_AF}, // Afrikaans

{"AR", TERRITORY_FULL_NAME_AR}, // Arabic

{"BE", TERRITORY_FULL_NAME_BE}, // Belarusian

{"CN", TERRITORY_FULL_NAME_CN}, // Chinese (Simplified)

{"CS", TERRITORY_FULL_NAME_CS}, // Czech

{"DA", TERRITORY_FULL_NAME_DA}, // Danish

{"DE", TERRITORY_FULL_NAME_DE}, // German

{"EN", TERRITORY_FULL_NAME_EN}, // English

{"ES", TERRITORY_FULL_NAME_ES}, // Spanish

{"FI", TERRITORY_FULL_NAME_FI}, // Finnish

{"FR", TERRITORY_FULL_NAME_FR}, // French

{"HE", TERRITORY_FULL_NAME_HE}, // Hebrew

{"HI", TERRITORY_FULL_NAME_HI}, // Hindi

{"HR", TERRITORY_FULL_NAME_HR}, // Croatian

{"ID", TERRITORY_FULL_NAME_ID}, // Indonesian

{"IT", TERRITORY_FULL_NAME_IT}, // Italian

{"JA", TERRITORY_FULL_NAME_JA}, // Japanese

{"KO", TERRITORY_FULL_NAME_KO}, // Korean

{"NL", TERRITORY_FULL_NAME_NL}, // Dutch

{"NO", TERRITORY_FULL_NAME_NO}, // Norwegian

{"PT", TERRITORY_FULL_NAME_PT}, // Portuguese

{"PL", TERRITORY_FULL_NAME_PL}, // Polish

{"RU", TERRITORY_FULL_NAME_RU}, // Russian

{"SV", TERRITORY_FULL_NAME_SV}, // Swedish

{"SW", TERRITORY_FULL_NAME_SW}, // Swahili

{"TR", TERRITORY_FULL_NAME_TR}, // Turkish

{"UK", TERRITORY_FULL_NAME_UK} // Ukrainian

};

static const char* PARENTS_3 = "USA,IND,CAN,AUS,MEX,BRA,RUS,CHN,";

static const char* PARENTS_2 = "US,IN,CA,AU,MX,BR,RU,CN,";

static const enum Territory PARENT_NR[9] = {

TERRITORY_NONE, // 0 - no parent

TERRITORY_USA, // 1 - United States of America

TERRITORY_IND, // 2 - India

TERRITORY_CAN, // 3 - Canada

TERRITORY_AUS, // 4 - Australia

TERRITORY_MEX, // 5 - Mexico

TERRITORY_BRA, // 6 - Brazil

TERRITORY_RUS, // 7 - Russia

TERRITORY_CHN // 8 - China

};

static const char ENCODE_CHARS[34] = {

'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', // Digits (0-9)

'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M', // Consonants (10-19)

'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z', // Consonants (20-30)

'A', 'E', 'U' // Vowels (31-33)

};

#define KIND_BIT_NAMELESS 0x01u

#define KIND_BIT_RESTRICTED 0x02u

#define KIND_BIT_SPECIAL_SHAPE 0x04u

static unsigned char RECORD_CODEX[MAPCODE_BOUNDARY_MAX + 1];

static unsigned char RECORD_REC_TYPE[MAPCODE_BOUNDARY_MAX + 1];

static unsigned char RECORD_KIND[MAPCODE_BOUNDARY_MAX + 1];

static unsigned char RECORD_HEADER_LETTER[MAPCODE_BOUNDARY_MAX + 1];

static unsigned short RECORD_SMART_DIV[MAPCODE_BOUNDARY_MAX + 1];

#define TERRITORY_TABLE_SIZE (_TERRITORY_MAX - _TERRITORY_MIN)

static int TERRITORY_FIRST_NAMELESS[TERRITORY_TABLE_SIZE];

static int TERRITORY_NAMELESS_COUNT[TERRITORY_TABLE_SIZE];

static int companion_initialized = 0;

static void initCompanionTables(void) {

int m;

int t;

if (companion_initialized) {

return;

}

for (m = 0; m <= MAPCODE_BOUNDARY_MAX; m++) {

const int flags = TERRITORY_BOUNDARIES[m].flags;

const int c = flags & 31;

const int codex_val = 10 * (c / 5) + ((c % 5) + 1);

const int rec_type = (flags >> 7) & 3;

unsigned char kind = 0;

if (flags & 64) { kind |= KIND_BIT_NAMELESS; }

if (flags & 512) { kind |= KIND_BIT_RESTRICTED; }

if (flags & 1024) { kind |= KIND_BIT_SPECIAL_SHAPE; }

RECORD_CODEX[m] = (unsigned char) codex_val;

RECORD_REC_TYPE[m] = (unsigned char) rec_type;

RECORD_KIND[m] = kind;

RECORD_HEADER_LETTER[m] = (unsigned char) ENCODE_CHARS[(flags >> 11) & 31];

RECORD_SMART_DIV[m] = (unsigned short) ((unsigned int) flags >> 16);

}

for (t = 0; t < TERRITORY_TABLE_SIZE; t++) {

TERRITORY_FIRST_NAMELESS[t] = -1;

TERRITORY_NAMELESS_COUNT[t] = 0;

}

for (t = 0; t < TERRITORY_TABLE_SIZE - 1; t++) {

const int from = DATA_START[t];

const int upto_excl = DATA_START[t + 1];

int i;

int first = -1;

int count = 0;

for (i = from; i < upto_excl; i++) {

if (RECORD_KIND[i] & KIND_BIT_NAMELESS) {

if (first < 0) {

first = i;

}

count++;

}

}

TERRITORY_FIRST_NAMELESS[t] = first;

TERRITORY_NAMELESS_COUNT[t] = count;

}

#ifdef DEBUG

for (m = 0; m <= MAPCODE_BOUNDARY_MAX; m++) {

const int flagsDbg = TERRITORY_BOUNDARIES[m].flags;

const int cDbg = flagsDbg & 31;

const int codex_valDbg = 10 * (cDbg / 5) + ((cDbg % 5) + 1);

ASSERT(RECORD_CODEX[m] == (unsigned char) codex_valDbg);

ASSERT(RECORD_REC_TYPE[m] == (unsigned char) ((flagsDbg >> 7) & 3));

ASSERT(((RECORD_KIND[m] & KIND_BIT_NAMELESS) != 0) == ((flagsDbg & 64) != 0));

ASSERT(((RECORD_KIND[m] & KIND_BIT_RESTRICTED) != 0) == ((flagsDbg & 512) != 0));

ASSERT(((RECORD_KIND[m] & KIND_BIT_SPECIAL_SHAPE) != 0) == ((flagsDbg & 1024) != 0));

ASSERT(RECORD_HEADER_LETTER[m] == (unsigned char) ENCODE_CHARS[(flagsDbg >> 11) & 31]);

ASSERT(RECORD_SMART_DIV[m] == (unsigned short) ((unsigned int) flagsDbg >> 16));

}

companion_initialized = 1;

}

static signed char decodeChar(const char ch) {

// Lookup table for base-31 value of ASCII character (negative for illegal characters)

// Special cases -2, -3, -4 for vowels; 'O' and 'I' interpreted as '0' and '1'.

static const signed char decode_chars[256] = {

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 16

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 32

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, // 48

-1, -2, 10, 11, 12, -3, 13, 14, 15, 1, 16, 17, 18, 19, 20, 0, // 64

21, 22, 23, 24, 25, -4, 26, 27, 28, 29, 30, -1, -1, -1, -1, -1, // 80

-1, -2, 10, 11, 12, -3, 13, 14, 15, 1, 16, 17, 18, 19, 20, 0, // 96

21, 22, 23, 24, 25, -4, 26, 27, 28, 29, 30, -1, -1, -1, -1, -1, // 112

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 128

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 144

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 160

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 176

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 192

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 208

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 224

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 // 240

};

return decode_chars[(unsigned char)ch]; // ch can be negative, must be fit to range 0-255.

}

double distanceInMeters(double latDeg1, double lonDeg1, double latDeg2, double lonDeg2) {

double dx;

double dy;

double deltaLonDegrees;

double deltaLatDegrees;

int wrapped = lonDeg1 > lonDeg2;

ASSERT((-90.0 <= latDeg1) && (latDeg1 <= 90.0));

ASSERT((-90.0 <= latDeg2) && (latDeg2 <= 90.0));

if (wrapped) {

deltaLonDegrees = 360.0 - (lonDeg1 - lonDeg2);

}

else {

deltaLonDegrees = lonDeg2 - lonDeg1;

}

if (deltaLonDegrees > 180.0) {

deltaLonDegrees = 360.0 - deltaLonDegrees;

}

deltaLatDegrees = fabs(latDeg1 - latDeg2);

dy = deltaLatDegrees * METERS_PER_DEGREE_LAT;

dx = deltaLonDegrees * METERS_PER_DEGREE_LON * cos((latDeg1 + (latDeg2 - latDeg1) / 2.0) * MATH_PI / 180.0);

return sqrt(dx * dx + dy * dy);

}

static const double MAX_ERROR_IN_METERS[MAX_PRECISION_DIGITS + 1] = {

7.49, // 0 extra digits - base precision

1.39, // 1 extra digit

0.251, // 2 extra digits

0.0462, // 3 extra digits

0.00837, // 4 extra digits

0.00154, // 5 extra digits

0.000279, // 6 extra digits

0.0000514, // 7 extra digits

0.0000093 // 8 extra digits (maximum supported)

};

double maxErrorInMeters(int extraDigits) {

ASSERT(extraDigits >= 0);

if ((extraDigits < 0) || (extraDigits > MAX_PRECISION_DIGITS)) {

return 0.0;

}

return MAX_ERROR_IN_METERS[extraDigits];

}

typedef struct {

int latMicroDeg; // Latitude in microdegrees (±90,000,000 for ±90°)

int lonMicroDeg; // Longitude in microdegrees (±180,000,000 for ±180°)

} Point32;

typedef struct {

double lat; // Latitude (units depend on usage context)

double lon; // Longitude (units depend on usage context)

} Point;

static Point32 convertFractionsToCoord32(const Point* p) {

Point32 p32;

p32.latMicroDeg = (int)floor(p->lat / 810000); // Convert latitude fractions to microdegrees

p32.lonMicroDeg = (int)floor(p->lon / 3240000); // Convert longitude fractions to microdegrees

return p32;

}

static Point convertFractionsToDegrees(const Point* p) {

Point pd;

pd.lat = p->lat / (810000 * 1000000.0); // Convert latitude fractions to degrees

pd.lon = p->lon / (3240000 * 1000000.0); // Convert longitude fractions to degrees

return pd;

}

static enum MapcodeError

convertCoordsToMicrosAndFractions(Point32* coord32, int* fracLat, int* fracLon, double latDeg, double lonDeg) {

double frac;

ASSERT(coord32);

if (isnan(lonDeg) || isinf(lonDeg) || isnan(latDeg) || isinf(latDeg)) {

return ERR_BAD_COORDINATE;

}

if (latDeg < -90) {

latDeg = -90;

}

else if (latDeg > 90) {

latDeg = 90;

}

latDeg += 90; // lat now [0..180]

ASSERT((0.0 <= latDeg) && (latDeg <= 180.0));

latDeg *= (double)810000000000;

frac = floor(latDeg + 0.1);

coord32->latMicroDeg = (int)(frac / (double)810000);

if (fracLat) {

frac -= ((double)coord32->latMicroDeg * (double)810000);

*fracLat = (int)frac;

}

coord32->latMicroDeg -= 90000000;

lonDeg -= (360.0 * floor(lonDeg / 360)); // lon now in [0..360>

ASSERT((0.0 <= lonDeg) && (lonDeg < 360.0));

lonDeg *= (double)3240000000000;

frac = floor(lonDeg + 0.1);

coord32->lonMicroDeg = (int)(frac / (double)3240000);

if (fracLon) {

frac -= (double)coord32->lonMicroDeg * (double)3240000;

*fracLon = (int)frac;

}

if (coord32->lonMicroDeg >= 180000000) {

coord32->lonMicroDeg -= 360000000;

}

return ERR_OK;

}

static int isInRange(int lonMicroDeg, const int minLonMicroDeg, const int maxLonMicroDeg) {

if (minLonMicroDeg <= lonMicroDeg && lonMicroDeg < maxLonMicroDeg) {

return 1;

}

if (lonMicroDeg < minLonMicroDeg) {

lonMicroDeg += 360000000;

}

else {

lonMicroDeg -= 360000000;

} // 1.32 fix FIJI edge case

if (minLonMicroDeg <= lonMicroDeg && lonMicroDeg < maxLonMicroDeg) {

return 1;

}

return 0;

}

static int fitsInsideBoundaries(const Point32* coord32, const TerritoryBoundary* b) {

ASSERT(coord32);

ASSERT(b);

return (b->miny <= coord32->latMicroDeg &&

coord32->latMicroDeg < b->maxy &&

isInRange(coord32->lonMicroDeg, b->minx, b->maxx));

}

static TerritoryBoundary* getExtendedBoundaries(TerritoryBoundary* target, const TerritoryBoundary* source,

const int deltaLatMicroDeg, const int deltaLonMicroDeg) {

ASSERT(target);

ASSERT(source);

target->miny = source->miny - deltaLatMicroDeg;

target->minx = source->minx - deltaLonMicroDeg;

target->maxy = source->maxy + deltaLatMicroDeg;

target->maxx = source->maxx + deltaLonMicroDeg;

return target;

}

typedef struct {

// latitudes in "810 billionths", range [-729 E11 .. +720 E11), is well within (-2^47 ... +2^47)

double fminy;

double fmaxy;

// latitudes in "3240 billionths", range [-2916 E13 .. +2916 E13), is well within (-2^49 ... +2^49)

double fminx;

double fmaxx;

} MapcodeZone;

static void setFromFractions(MapcodeZone* z,

const double y, const double x,

const double yDelta, const double xDelta) {

ASSERT(z);

z->fminx = x;

z->fmaxx = x + xDelta;

if (yDelta < 0) {

z->fminy = y + 1 + yDelta; // y+yDelta can NOT be represented

z->fmaxy = y + 1; // y CAN be represented

}

else {

z->fminy = y;

z->fmaxy = y + yDelta;

}

}

static int isEmpty(const MapcodeZone* z) {

ASSERT(z);

return ((z->fmaxx <= z->fminx) || (z->fmaxy <= z->fminy));

}

static Point getMidPointFractions(const MapcodeZone* z) {

Point p;

ASSERT(z);

p.lon = floor((z->fminx + z->fmaxx) / 2);

p.lat = floor((z->fminy + z->fmaxy) / 2);

return p;

}

static void zoneCopyFrom(MapcodeZone* target, const MapcodeZone* source) {

ASSERT(target);

ASSERT(source);

target->fminy = source->fminy;

target->fmaxy = source->fmaxy;

target->fminx = source->fminx;

target->fmaxx = source->fmaxx;

}

static int restrictZoneTo(MapcodeZone* z, const MapcodeZone* zone, const TerritoryBoundary* b) {

ASSERT(z);

ASSERT(zone);

ASSERT(b);

z->fminy = zone->fminy;

z->fmaxy = zone->fmaxy;

if (z->fminy < b->miny * MICROLAT_TO_FRACTIONS_FACTOR) {

z->fminy = b->miny * MICROLAT_TO_FRACTIONS_FACTOR;

}

if (z->fmaxy > b->maxy * MICROLAT_TO_FRACTIONS_FACTOR) {

z->fmaxy = b->maxy * MICROLAT_TO_FRACTIONS_FACTOR;

}

if (z->fminy < z->fmaxy) {

double bminx = b->minx * MICROLON_TO_FRACTIONS_FACTOR;

double bmaxx = b->maxx * MICROLON_TO_FRACTIONS_FACTOR;

z->fminx = zone->fminx;

z->fmaxx = zone->fmaxx;

if (bmaxx < 0 && z->fminx > 0) {

bminx += (360000000 * MICROLON_TO_FRACTIONS_FACTOR);

bmaxx += (360000000 * MICROLON_TO_FRACTIONS_FACTOR);

}

else if (bminx > 0 && z->fmaxx < 0) {

bminx -= (360000000 * MICROLON_TO_FRACTIONS_FACTOR);

bmaxx -= (360000000 * MICROLON_TO_FRACTIONS_FACTOR);

}

if (z->fminx < bminx) {

z->fminx = bminx;

}

if (z->fmaxx > bmaxx) {

z->fmaxx = bmaxx;

}

return (z->fminx < z->fmaxx);

}

return 0;

}

static char* lengthCopy(char* targetString, const char* sourceString, int nrCharacters, int targetSize) {

if (nrCharacters >= targetSize) {

nrCharacters = targetSize - 1;

}

memcpy(targetString, sourceString, (size_t)nrCharacters);

targetString[nrCharacters] = 0;

return targetString;

}

static char* safeCopy(char* targetString, const char* sourceString, const int targetSize) {

int sourceLength = (int)strlen(sourceString);

return lengthCopy(targetString, sourceString, sourceLength, targetSize);

}

static int firstRec(const enum Territory ccode) {

ASSERT((_TERRITORY_MIN < ccode) && (ccode < _TERRITORY_MAX));

return DATA_START[INDEX_OF_TERRITORY(ccode)];

}

static int lastRec(const enum Territory ccode) {

ASSERT((_TERRITORY_MIN < ccode) && (ccode < _TERRITORY_MAX));

return DATA_START[INDEX_OF_TERRITORY(ccode) + 1] - 1;

}

static enum Territory parentTerritoryOf(const enum Territory ccode) {

if (ccode <= _TERRITORY_MIN || ccode >= _TERRITORY_MAX) {

return TERRITORY_NONE;

}

return PARENT_NR[(int)PARENT_LETTER[INDEX_OF_TERRITORY(ccode)]];

}

static int coDex(const int m) {

int c = TERRITORY_BOUNDARIES[m].flags & 31;

ASSERT((0 <= m) && (m <= MAPCODE_BOUNDARY_MAX));

return 10 * (c / 5) + ((c % 5) + 1);

}

static int xDivider4(const int miny, const int maxy) {

// 360 * cos(microdegrees>>19)

static const int xdivider19[172] = {

360, 360, 360, 360, 360, 360, 361, 361, 361, 361,

362, 362, 362, 363, 363, 363, 364, 364, 365, 366,

366, 367, 367, 368, 369, 370, 370, 371, 372, 373,

374, 375, 376, 377, 378, 379, 380, 382, 383, 384,

386, 387, 388, 390, 391, 393, 394, 396, 398, 399,

401, 403, 405, 407, 409, 411, 413, 415, 417, 420,

422, 424, 427, 429, 432, 435, 437, 440, 443, 446,

449, 452, 455, 459, 462, 465, 469, 473, 476, 480,

484, 488, 492, 496, 501, 505, 510, 515, 520, 525,

530, 535, 540, 546, 552, 558, 564, 570, 577, 583,

590, 598, 605, 612, 620, 628, 637, 645, 654, 664,

673, 683, 693, 704, 715, 726, 738, 751, 763, 777,

791, 805, 820, 836, 852, 869, 887, 906, 925, 946,

968, 990, 1014, 1039, 1066, 1094, 1123, 1154, 1187, 1223,

1260, 1300, 1343, 1389, 1438, 1490, 1547, 1609, 1676, 1749,

1828, 1916, 2012, 2118, 2237, 2370, 2521, 2691, 2887, 3114,

3380, 3696, 4077, 4547, 5139, 5910, 6952, 8443, 10747, 14784,

23681, 59485

};

if (miny >= 0) {

// both above equator? then miny is closest

return xdivider19[(miny) >> 19];

}

if (maxy >= 0) {

// opposite sides? then equator is worst

return xdivider19[0];

}

return xdivider19[(-maxy) >> 19]; // both negative, so maxy is closest to equator

}

static int isSubdivision(const enum Territory ccode) {

return parentTerritoryOf(ccode) != TERRITORY_NONE;

}

static int firstNamelessRecord(const int m, const int firstcode) {

int i = m;

const int codexm = (int) RECORD_CODEX[m];

ASSERT((0 <= m) && (m <= MAPCODE_BOUNDARY_MAX));

ASSERT((0 <= firstcode) && (firstcode <= MAPCODE_BOUNDARY_MAX));

while (i >= firstcode && (int) RECORD_CODEX[i] == codexm && (RECORD_KIND[i] & KIND_BIT_NAMELESS)) {

i--;

}

return (i + 1);

}

static int countNamelessRecords(const int m, const int firstcode) {

const int first = firstNamelessRecord(m, firstcode);

const int codexm = (int) RECORD_CODEX[m];

int last = m;

ASSERT((0 <= m) && (m <= MAPCODE_BOUNDARY_MAX));

ASSERT((0 <= firstcode) && (firstcode <= MAPCODE_BOUNDARY_MAX));

while ((int) RECORD_CODEX[last] == codexm) {

last++;

}

ASSERT((0 <= last) && (last <= MAPCODE_BOUNDARY_MAX));

ASSERT(last >= first);

return (last - first);

}

static int isNearBorderOf(const Point32* coord32, const TerritoryBoundary* b) {

int xdiv8 = xDivider4(b->miny, b->maxy) / 4; // should be /8 but there's some extra margin

TerritoryBoundary tmp;

ASSERT(coord32);

ASSERT(b);

return (fitsInsideBoundaries(coord32, getExtendedBoundaries(&tmp, b, +60, +xdiv8)) &&

(!fitsInsideBoundaries(coord32, getExtendedBoundaries(&tmp, b, -60, -xdiv8))));

}

static void makeUppercase(char* s) {

ASSERT(s);

while (*s) {

*s = (char)toupper(*s);

s++;

}

}

static int getParentNumber(const char* s, const int len) {

const char* p = ((len == 2) ? PARENTS_2 : PARENTS_3);

const char* f;

char country[4];

ASSERT(s[0] && s[1]);

ASSERT((2 <= len) && (len <= 3));

ASSERT(s && ((int) strlen(s) >= len));

lengthCopy(country, s, len, 4);

makeUppercase(country);

f = strstr(p, country);

if (!f) {

return -1;

}

return 1 + (int)((f - p) / (len + 1));

}

static void repackIfAllDigits(char* input, const int aonly) {

char* s = input;

int alldigits = 1; // assume all digits

char* e;

char* dotpos = NULL;

ASSERT(input);

for (e = s; *e != 0 && *e != '-'; e++) {

if (*e < '0' || *e > '9') {

if (*e == '.' && !dotpos) {

dotpos = e;

}

else {

alldigits = 0;

break;

}

}

}

e--;

s = e - 1;

if (alldigits && dotpos &&