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

#include <stdlib.h> // atof

#include <ctype.h> // toupper

#include "mapcoder.h"

#include "basics.h"

#define FAST_ENCODE

#ifdef FAST_ENCODE

#include "dividemaps.h"

typedef struct {

// input

int lat32, lon32;

double fraclat, fraclon;

// output

Mapcodes *mapcodes;

} encodeRec;

typedef struct {

// input

const char *orginput; // original full input string

char minput[MAX_MAPCODE_RESULT_LEN]; // room to manipulate clean copy of input

const char *mapcode; // input mapcode (first character of proper mapcode excluding territory code)

const char *extension; // input extension (or empty)

int context; // input territory context (or negative)

const char *iso; // input territory alphacode (context)

// output

double lat, lon; // result

int lat32, lon32; // result in integer arithmetic (millionts of degrees)

} decodeRec;

static int firstrec(int ccode) { return data_start[ccode]; }

static int lastrec(int ccode) { return data_start[ccode + 1] - 1; }

static int ParentLetter(int ccode) // returns parent index (>0), or 0

{

if (ccode >= usa_from && ccode <= usa_upto) { return 1; }

if (ccode >= ind_from && ccode <= ind_upto) { return 2; }

if (ccode >= can_from && ccode <= can_upto) { return 3; }

if (ccode >= aus_from && ccode <= aus_upto) { return 4; }

if (ccode >= mex_from && ccode <= mex_upto) { return 5; }

if (ccode >= bra_from && ccode <= bra_upto) { return 6; }

if (ccode >= rus_from && ccode <= rus_upto) { return 7; }

if (ccode >= chn_from && ccode <= chn_upto) { return 8; }

return 0;

}

static int ParentTerritoryOf(int ccode) // returns parent, or -1

{

return parentnr[ParentLetter(ccode)];

}

static int isSubdivision(int ccode) { return (ParentTerritoryOf(ccode) >= 0); }

static int coDex(int m) {

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

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

}

#define prefixLength(m) (((mminfo[m].flags & 31)/5))

#define postfixLength(m) ((((mminfo[m].flags & 31)%5)+1))

#define isNameless(m) ((mminfo[m].flags & 64))

#define recType(m) ((mminfo[m].flags>>7) & 3)

#define isRestricted(m) (mminfo[m].flags & 512)

#define isSpecialShape22(m) (mminfo[m].flags & 1024)

#define headerLetter(m) (encode_chars[(mminfo[m].flags>>11)&31])

#define smartDiv(m) (mminfo[m].flags>>16)

#define boundaries(m) (&mminfo[m])

static int isInRange(int x, int minx, int maxx) // returns nonzero if x in the range minx...maxx

{

if (minx <= x && x < maxx) { return 1; }

if (x < minx) { x += 360000000; } else { x -= 360000000; } // 1.32 fix FIJI edge case

if (minx <= x && x < maxx) return 1;

return 0;

}

static int fitsInside(int x, int y, int m) {

const mminforec *b = boundaries(m);

return (b->miny <= y && y < b->maxy && isInRange(x, b->minx, b->maxx));

}

static int xDivider4(int miny, int maxy) {

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 fitsInsideWithRoom(int x, int y, int m) {

const mminforec *b = boundaries(m);

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

return (b->miny - 60 <= y && y < b->maxy + 60 && isInRange(x, b->minx - xdiv8, b->maxx + xdiv8));

}

static const char *get_entity_iso3(char *entity_iso3_result, int ccode) {

if (ccode < 0 || ccode >= MAX_MAPCODE_TERRITORY_CODE) { ccode = ccode_earth; } // solve bad args

memcpy(entity_iso3_result, entity_iso + ccode * 4, 3);

entity_iso3_result[3] = 0;

return entity_iso3_result;

}

static int disambiguate_str(const char *s, int len) // returns disambiguation >=1, or negative if error

{

const char *p = (len == 2 ? parents2 : parents3);

const char *f;

char country[4];

if (s[0] == 0 || s[1] == 0) { return -27; } // solve bad args

if (len != 2 && len != 3) return -923; // solve bad args

memcpy(country, s, len);

country[len] = 0;

{

char *t;

for (t = country; *t != 0; t++)

*t = (char) toupper(*t);

}

f = strstr(p, country);

if (f == NULL)

return -23; // unknown country

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

}

static int ccode_of_iso3(const char *in_iso, int parentcode) {

const char *aliases = ALIASES;

char iso[4];

const char *s;

int hyphenated = 0;

if (in_iso && in_iso[0] && in_iso[1]) {

if (in_iso[2]) {

if (in_iso[2] == '-') {

parentcode = disambiguate_str(in_iso, 2);

hyphenated = (parentcode > 0);

in_iso += 3;

}

else if (in_iso[3] == '-') {

parentcode = disambiguate_str(in_iso, 3);

hyphenated = (parentcode > 0);

in_iso += 4;

}

}

} else { return -23; } // solve bad args

// make (uppercased) copy of at most three characters

iso[0] = (char) toupper(in_iso[0]);

if (iso[0]) iso[1] = (char) toupper(in_iso[1]);

if (iso[1]) iso[2] = (char) toupper(in_iso[2]);

iso[3] = 0;

if (iso[2] == 0 || iso[2] == ' ') // 2-letter iso code?

{

static char disambiguate_iso3[4] = {'1', '?', '?', 0}; // cache for disambiguation

if (parentcode > 0)

disambiguate_iso3[0] = (char) ('0' + parentcode);

disambiguate_iso3[1] = iso[0];

disambiguate_iso3[2] = iso[1];

s = strstr(entity_iso, disambiguate_iso3); // search disambiguated 2-letter iso

if (s == NULL) {

s = strstr(aliases, disambiguate_iso3); // search in aliases

if (s == NULL || s[3] != '=') {

s = NULL;

if (disambiguate_iso3[0] <= '9') {

disambiguate_iso3[0] = '0';

s = strstr(aliases, disambiguate_iso3); // search in aliases

}

}

if (s && s[3] == '=') {

memcpy(iso, s + 4, 3);

s = strstr(entity_iso, iso); // search disambiguated 2-letter iso

}

}

if (s == NULL) {

// find the FIRST disambiguation option, if any

for (s = entity_iso - 1; ;) {

s = strstr(s + 1, disambiguate_iso3 + 1);

if (s == NULL)

break;

if (s && s[-1] >= '1' && s[-1] <= '9') {

s--;

break;

}

}

if (s == NULL) {

// find first disambiguation option in aliases, if any

for (s = aliases - 1; ;) {

s = strstr(s + 1, disambiguate_iso3 + 1);

if (s == NULL)

break;

if (s && s[-1] >= '1' && s[-1] <= '9') {

memcpy(iso, s + 3, 3);

s = strstr(entity_iso, iso); // search disambiguated 2-letter iso

break;

}

}

}

if (s == NULL)

return -26;

}

}

else {

s = strstr(entity_iso, iso); // search 3-letter iso

if (s == NULL || hyphenated) {

const char *a = aliases;

while (a) {

a = strstr(a, iso); // search in aliases

if (a && a[3] == '=' && (a[4] > '9' || a[4] == (char) (48 + parentcode) || parentcode < 0)) {

memcpy(iso, a + 4, 3);

a = NULL;

s = strstr(entity_iso, iso);

} else {

if (a) {

a++;

}

}

}

}

if (s == NULL)

return -23;

}

// return result

return (int) ((s - entity_iso) / 4);

}

static void encodeExtension(char *result, int extrax4, int extray, int dividerx4, int dividery, int extraDigits,

int ydirection,

const encodeRec *enc) // append extra characters to result for more precision

{

#ifndef SUPPORT_HIGH_PRECISION // old integer-arithmetic version

if (extraDigits<0) extraDigits=0; else if (extraDigits>2) extraDigits=2;

while (extraDigits-->0)

{

int gx=((30*extrax4)/dividerx4);

int gy=((30*extray )/dividery );

int column1=(gx/6);

int column2=(gx%6);

int row1=(gy/5);

int row2=(gy%5);

// add postfix:

char *s = result+strlen(result);

*s++ = '-';

*s++ = encode_chars[ row1*5+column1 ];

if (extraDigits-->0)

*s++ = encode_chars[ row2*6+column2 ];

*s++ = 0;

}

#else // new floating-point version

char *s = result + strlen(result);

double encx = (extrax4 + 4 * enc->fraclon) / (dividerx4);

double ency = (extray + enc->fraclat * ydirection) / (dividery);

if (extraDigits < 0) { extraDigits = 0; } else if (extraDigits > MAX_PRECISION_DIGITS) {

extraDigits = MAX_PRECISION_DIGITS;

}

if (extraDigits > 0) {

*s++ = '-';

}

while (extraDigits-- > 0) {

int gx, gy, column1, column2, row1, row2;

encx *= 30;

gx = (int) encx;

if (gx < 0) {

gx = 0;

} else if (gx > 29) {

gx = 29;

}

ency *= 30;

gy = (int) ency;

if (gy < 0) {

gy = 0;

} else if (gy > 29) {

gy = 29;

}

column1 = (gx / 6);

column2 = (gx % 6);

row1 = (gy / 5);

row2 = (gy % 5);

// add postfix:

*s++ = encode_chars[row1 * 5 + column1];

if (extraDigits-- > 0) {

*s++ = encode_chars[row2 * 6 + column2];

}

*s = 0;

encx -= gx;

ency -= gy;

}

}

#define decodeChar(c) decode_chars[(unsigned char)c] // force c to be in range of the index, between 0 and 255

static int decodeExtension(decodeRec *dec, int dividerx4, int dividery, int ydirection) {

const char *extrapostfix = dec->extension;

#ifndef SUPPORT_HIGH_PRECISION // old integer-arithmetic version

int extrax,extray;

if (*extrapostfix) {

int column1,row1,column2,row2,c1,c2;

c1 = extrapostfix[0];

c1 = decodeChar(c1);

if (c1<0) c1=0; else if (c1>29) c1=29;

row1 =(c1/5); column1 = (c1%5);

c2 = (extrapostfix[1]) ? extrapostfix[1] : 72; // 72='H'=code 15=(3+2*6)

c2 = decodeChar(c2);

if (c2<0) c2=0; else if (c2>29) c2=29;

row2 =(c2/6); column2 = (c2%6);

extrax = ((column1*12 + 2*column2 + 1)*dividerx4+120)/240;

extray = ((row1*10 + 2*row2 + 1)*dividery +30)/ 60;

}

else {

extrax = (dividerx4/8);

extray = (dividery/2);

}

extray *= ydirection;

dec->lon32 = extrax + dec->lon32;

dec->lat32 = extray + dec->lat32;

#else // new floating-point version

double dividerx = dividerx4 / 4.0, processor = 1.0;

dec->lon = 0;

dec->lat = 0;

while (*extrapostfix) {

int column1, row1, column2, row2;

double halfcolumn = 0;

int c1 = *extrapostfix++;

c1 = decodeChar(c1);

if (c1 < 0 || c1 == 30) { return -1; } // illegal extension character

row1 = (c1 / 5);

column1 = (c1 % 5);

if (*extrapostfix) {

int c2 = decodeChar(*extrapostfix++);

if (c2 < 0 || c2 == 30) return -1; // illegal extension character

row2 = (c2 / 6);

column2 = (c2 % 6);

}

else {

row2 = 2;

halfcolumn = 0.5;

column2 = 3;

}

processor *= 30;

dec->lon += ((column1 * 6 + column2)) / processor;

dec->lat += ((row1 * 5 + row2 - halfcolumn)) / processor;

}

dec->lon += (0.5 / processor);

dec->lat += (0.5 / processor);

dec->lon *= dividerx;

dec->lat *= (dividery * ydirection);

dec->lon += dec->lon32;

dec->lat += dec->lat32;

// also convert back to int

dec->lon32 = (int) dec->lon;

dec->lat32 = (int) dec->lat;

return 0;

}

static void encodeBase31(char *result, int value, int nrchars) {

result[nrchars] = 0; // zero-terminate!

while (nrchars-- > 0) {

result[nrchars] = encode_chars[value % 31];

value /= 31;

}

}

static int decodeBase31(const char *code) {

int value = 0;

while (*code != '.' && *code != 0) {

value = value * 31 + decodeChar(*code++);

}

return value;

}

static void encode_triple(char *result, int difx, int dify) {

if (dify < 4 * 34) // first 4(x34) rows of 6(x28) wide

{

encodeBase31(result, ((difx / 28) + 6 * (dify / 34)), 1);

encodeBase31(result + 1, ((difx % 28) * 34 + (dify % 34)), 2);

}

else // bottom row

{

encodeBase31(result, (difx / 24) + 24, 1);

encodeBase31(result + 1, (difx % 24) * 40 + (dify - 136), 2);

}

} // encode_triple

static void decode_triple(const char *result, int *difx, int *dify) {

// decode the first character

int c1 = decodeChar(*result++);

if (c1 < 24) {

int m = decodeBase31(result);

*difx = (c1 % 6) * 28 + (m / 34);

*dify = (c1 / 6) * 34 + (m % 34);

}

else // bottom row

{

int x = decodeBase31(result);

*dify = (x % 40) + 136;

*difx = (x / 40) + 24 * (c1 - 24);

}

} // decode_triple

static int encodeSixWide(int x, int y, int width, int height) {

int v;

int D = 6;

int col = x / 6;

int maxcol = (width - 4) / 6;

if (col >= maxcol) {

col = maxcol;

D = width - maxcol * 6;

}

v = (height * 6 * col) + (height - 1 - y) * D + (x - col * 6);

return v;

}

static void decodeSixWide(int v, int width, int height, int *x, int *y) {

int w;

int D = 6;

int col = v / (height * 6);

int maxcol = (width - 4) / 6;

if (col >= maxcol) {

col = maxcol;

D = width - maxcol * 6;

}

w = v - (col * height * 6);

*x = col * 6 + (w % D);

*y = height - 1 - (w / D);

}

static int decodeGrid(decodeRec *dec, int m, int hasHeaderLetter) {

const char *input = (hasHeaderLetter ? dec->mapcode + 1 : dec->mapcode);

int codexlen = (int) (strlen(input) - 1);

int prelen = (int) (strchr(input, '.') - input);

char result[MAX_PROPER_MAPCODE_LEN + 1];

if (codexlen > MAX_PROPER_MAPCODE_LEN) { return -109; }

strcpy(result, input);

if (prelen == 1 && codexlen == 5) {

result[1] = result[2];

result[2] = '.';

prelen++;

}

{

int postlen = codexlen - prelen;

int divx, divy;

divy = smartDiv(m);

if (divy == 1) {

divx = xside[prelen];

divy = yside[prelen];

}

else {

int pw = nc[prelen];

divx = (pw / divy);

}

if (prelen == 4 && divx == xside[4] && divy == yside[4]) {

char t = result[1];

result[1] = result[2];

result[2] = t;

}

{

int relx = 0, rely = 0, v = 0;

if (prelen <= MAXFITLONG) {

v = decodeBase31(result);

if (divx != divy &&

prelen > 2) // D==6 special grid, useful when prefix is 3 or more, and not a nice 961x961

{ // DECODE

decodeSixWide(v, divx, divy, &relx, &rely);

}

else {

relx = (v / divy);

rely = divy - 1 - (v % divy);

}

}

{

const mminforec *b = boundaries(m);

int ygridsize = (b->maxy - b->miny + divy - 1) / divy; // lonlat per cell

int xgridsize = (b->maxx - b->minx + divx - 1) / divx; // lonlat per cell

if (relx < 0 || rely < 0 || relx >= divx || rely >= divy) {

return -111;

}

// and then encodde relative to THE CORNER of this cell

rely = b->miny + (rely * ygridsize);

relx = b->minx + (relx * xgridsize);

{

int xp = xside[postlen];

int dividerx = ((((xgridsize)) + xp - 1) / xp);

int yp = yside[postlen];

int dividery = ((((ygridsize)) + yp - 1) / yp);

// decoderelative

{

char *r = result + prelen + 1;

int difx, dify;

if (postlen == 3) // decode special

{

decode_triple(r, &difx, &dify);

}

else {

int v2;

if (postlen == 4) {

char t = r[1];

r[1] = r[2];

r[2] = t;

} // swap

v2 = decodeBase31(r);

difx = (v2 / yp);

dify = (v2 % yp);

if (postlen == 4) {

char t = r[1];

r[1] = r[2];

r[2] = t;

} // swap back

}

// reverse y-direction

dify = yp - 1 - dify;

dec->lon32 = relx + (difx * dividerx);

dec->lat32 = rely + (dify * dividery);

return decodeExtension(dec, dividerx << 2, dividery, 1); // grid

} // decoderelative

}

}

}

}

}

static void encodeGrid(char *result, const encodeRec *enc, int const m, int extraDigits, char headerLetter) {

int y = enc->lat32, x = enc->lon32;

const mminforec *b = boundaries(m);

int orgcodex = coDex(m);

int codexm = orgcodex;

if (codexm == 21) { codexm = 22; }

if (codexm == 14) { codexm = 23; }

*result = 0;

if (headerLetter) { result++; }

{ // encode

int divx, divy;

int prelen = codexm / 10;

int postlen = codexm % 10;

divy = smartDiv(m);

if (divy == 1) {

divx = xside[prelen];

divy = yside[prelen];

}

else {

int pw = nc[prelen];

divx = (pw / divy);

}

{ // grid

int ygridsize = (b->maxy - b->miny + divy - 1) / divy;

int xgridsize = (b->maxx - b->minx + divx - 1) / divx;

int rely = y - b->miny;

int relx = x - b->minx;

if (relx < 0) {

relx += 360000000;

x += 360000000;

}

else if (relx >= 360000000) // 1.32 fix FIJI edge case

{

relx -= 360000000;

x -= 360000000;

}

rely /= ygridsize;

relx /= xgridsize;

if (relx >= divx || rely >= divy) { return; }

{ // prefix

int v;

if (divx != divy && prelen > 2) {

v = encodeSixWide(relx, rely, divx, divy);

} else {

v = relx * divy + (divy - 1 - rely);

}

encodeBase31(result, v, prelen);

} // prefix

if (prelen == 4 && divx == xside[4] && divy == yside[4]) {

char t = result[1];

result[1] = result[2];

result[2] = t;

}

rely = b->miny + (rely * ygridsize);

relx = b->minx + (relx * xgridsize);

{ // postfix

int dividery = ((((ygridsize)) + yside[postlen] - 1) / yside[postlen]);

int dividerx = ((((xgridsize)) + xside[postlen] - 1) / xside[postlen]);

int extrax, extray;

{

char *resultptr = result + prelen;

int difx = x - relx;

int dify = y - rely;

*resultptr++ = '.';

extrax = difx % dividerx;

extray = dify % dividery;

difx /= dividerx;

dify /= dividery;

// reverse y-direction

dify = yside[postlen] - 1 - dify;

if (postlen == 3) // encode special

{

encode_triple(resultptr, difx, dify);

}

else {

encodeBase31(resultptr, (difx) * yside[postlen] + dify, postlen);

// swap 4-int codes for readability

if (postlen == 4) {

char t = resultptr[1];

resultptr[1] = resultptr[2];

resultptr[2] = t;

}

}

}

if (orgcodex == 14) {

result[2] = result[1];

result[1] = '.';

}

encodeExtension(result, extrax << 2, extray, dividerx << 2, dividery, extraDigits, 1, enc); // grid

if (headerLetter) {

result--;

*result = headerLetter;

}

} // postfix

} // grid

} // encode

}

static int firstNamelessRecord(int m, int firstcode) {

int i = m;

int codexm = coDex(m);

while (i >= firstcode && coDex(i) == codexm && isNameless(i)) { i--; }

return (i + 1);

}

static int countNamelessRecords(int m, int firstcode) {

int i = firstNamelessRecord(m, firstcode);

int codexm = coDex(m);

while (coDex(m) == codexm) { m++; }

return (m - i);

}

static int decodeNameless(decodeRec *dec, int m) {

int A, F;

char input[8];

int codexm = coDex(m);

int dc = (codexm != 22) ? 2 : 3;

int codexlen = (int) (strlen(dec->mapcode) - 1);

if (codexlen != 4 && codexlen != 5) {

return -2;

} // solve bad args

// copy without dot

strcpy(input, dec->mapcode);

strcpy(input + dc, dec->mapcode + dc + 1);

A = countNamelessRecords(m, firstrec(dec->context));

F = firstNamelessRecord(m, firstrec(dec->context));

{

int p = 31 / A;

int r = 31 % A;

int v = 0;

int SIDE;

int swapletters = 0;

int xSIDE;

int X;

const mminforec *b;

// make copy of input, so we can swap around letters during the decoding

char result[32];

strcpy(result, input);

// now determine X = index of first area, and SIDE

if (codexm != 21 && A <= 31) {

int offset = decodeChar(*result);

if (offset < r * (p + 1)) {

X = offset / (p + 1);

}

else {

swapletters = (p == 1 && codexm == 22);

X = r + (offset - (r * (p + 1))) / p;

}

}

else if (codexm != 21 && A < 62) {

X = decodeChar(*result);

if (X < (62 - A)) {

swapletters = (codexm == 22);

}

else {

X = X + (X - (62 - A));

}

}

else // code==21 || A>=62

{

int BASEPOWER = (codexm == 21) ? 961 * 961 : 961 * 961 * 31;

int BASEPOWERA = (BASEPOWER / A);

if (A == 62) BASEPOWERA++; else BASEPOWERA = 961 * (BASEPOWERA / 961);

v = decodeBase31(result);

X = (v / BASEPOWERA);

v %= BASEPOWERA;

}

if (swapletters) {

if (!isSpecialShape22(F + X)) {

char t = result[codexlen - 3];

result[codexlen - 3] = result[codexlen - 2];

result[codexlen - 2] = t;

}

}

if (codexm != 21 && A <= 31) {

v = decodeBase31(result);

if (X > 0) {

v -= (X * p + (X < r ? X : r)) * (961 * 961);

}

}

else if (codexm != 21 && A < 62) {

v = decodeBase31(result + 1);

if (X >= (62 - A)) {

if (v >= (16 * 961 * 31)) {

v -= (16 * 961 * 31);

X++;

}

}

}

m = (F + X);

xSIDE = SIDE = smartDiv(m);

b = boundaries(m);

if (isSpecialShape22(m)) {

xSIDE *= SIDE;

SIDE = 1 + ((b->maxy - b->miny) / 90); // side purely on y range

xSIDE = xSIDE / SIDE;

}

// decode

{

int dx, dy;

if (isSpecialShape22(m)) {

decodeSixWide(v, xSIDE, SIDE, &dx, &dy);

dy = SIDE - 1 - dy;

}

else {

dy = v % SIDE;

dx = v / SIDE;

}

if (dx >= xSIDE) {

return -123;

}

{

int dividerx4 = xDivider4(b->miny, b->maxy); // *** note: dividerx4 is 4 times too large!

int dividery = 90;

int err;

dec->lon32 = b->minx + ((dx * dividerx4) /

4); // *** note: FIRST multiply, then divide... more precise, larger rects

dec->lat32 = b->maxy - (dy * dividery);

err = decodeExtension(dec, dividerx4, dividery, -1); // nameless

#ifdef SUPPORT_HIGH_PRECISION

dec->lon += ((dx * dividerx4) % 4) / 4.0;

return err;

}

}

}

}

static void repack_if_alldigits(char *input, int aonly) {

char *s = input;

int alldigits = 1; // assume all digits

char *e;

char *dotpos = NULL;

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 &&

s > dotpos) // e is last char, s is one before, both are beyond dot, all characters are digits

{

if (aonly) // v1.50 - encode only using the letter A

{

int v = ((*input) - '0') * 100 + ((*s) - '0') * 10 + ((*e) - '0');

*input = 'A';

*s = encode_chars[v / 32];

*e = encode_chars[v % 32];

}

else // encode using A,E,U

{

int v = ((*s) - '0') * 10 + ((*e) - '0');

*s = encode_chars[(v / 34) + 31];

*e = encode_chars[v % 34];

}

}

}

static int unpack_if_alldigits(

char *input) // returns 1 if unpacked, 0 if left unchanged, negative if unchanged and an error was detected

{ // rewrite all-digit codes

char *s = input;

char *dotpos = NULL;

int aonly = (*s == 'A' || *s == 'a');

if (aonly) { s++; } //*** v1.50

for (; *s != 0 && s[2] != 0 && s[2] != '-'; s++) {

if (*s == '-')

break;

else if (*s == '.' && !dotpos)

dotpos = s;

else if (decodeChar(*s) < 0 || decodeChar(*s) > 9)

return 0; // nondigit, so stop

}

if (dotpos) {

if (aonly) // v1.50 encoded only with A's

{

int v = (s[0] == 'A' || s[0] == 'a' ? 31 : decodeChar(s[0])) * 32 +

(s[1] == 'A' || s[1] == 'a' ? 31 : decodeChar(s[1]));

*input = (char) ('0' + (v / 100));

s[0] = (char) ('0' + ((v / 10) % 10));

s[1] = (char) ('0' + (v % 10));

return 1;

} // v1.50

if (*s == 'a' || *s == 'e' || *s == 'u' || *s == 'A' || *s == 'E' ||

*s == 'U') // thus, all digits, s[2]=0, after dot

{

char *e = s + 1; // s is vowel, e is lastchar

int v = 0;

if (*s == 'e' || *s == 'E') v = 34;

else if (*s == 'u' || *s == 'U') v = 68;

if (*e == 'a' || *e == 'A') v += 31;

else if (*e == 'e' || *e == 'E') v += 32;

else if (*e == 'u' || *e == 'U') v += 33;

else if (decodeChar(*e) < 0) return -9; // invalid last character!

else v += decodeChar(*e);

if (v < 100) {

*s = encode_chars[(unsigned int) v / 10];