Menu
▾
▴
[TiLP-devel] [TiLP-commit] rev 290 - in libtifiles/trunk: . po src
|
From: <sv...@te...> - 2003-05-03 16:28:50
|
Author: roms
Date: Sat May 3 18:28:38 2003
New Revision: 290
Modified:
libtifiles/trunk/ChangeLog
libtifiles/trunk/po/fr.po
libtifiles/trunk/po/libtifiles.pot
libtifiles/trunk/src/file_int.h
libtifiles/trunk/src/trans.c
Log:
Varname translation completely reworked
Modified: libtifiles/trunk/ChangeLog
==============================================================================
--- libtifiles/trunk/ChangeLog (original)
+++ libtifiles/trunk/ChangeLog Sat May 3 18:28:38 2003
@@ -6,7 +6,9 @@
- 01/05/2003, version 0.5.6:
Added 'mu' char to TI89..V200. Unicode translation was missing for
TI92(+)/V200.
- Translation (detokenization in fact) is being reworked.
+ trans.c has been hugely reworked:
+ - varname detokenization
+ - TI-charset to user-selected charset transcoding
- 19/04/2003, version 0.5.5:
Added various varname translations (ASCII, ISO8859-1 and UTF-8).
Modified: libtifiles/trunk/po/fr.po
==============================================================================
--- libtifiles/trunk/po/fr.po (original)
+++ libtifiles/trunk/po/fr.po Sat May 3 18:28:38 2003
@@ -6,7 +6,7 @@
msgid ""
msgstr ""
"Project-Id-Version: libtifiles-0.5.1\n"
-"POT-Creation-Date: 2003-05-03 12:02+0200\n"
+"POT-Creation-Date: 2003-05-03 18:26+0200\n"
"PO-Revision-Date: 2003-04-05 21:47+0100\n"
"Last-Translator: GARSAULT Sylvain <syl...@fr...>\n"
"Language-Team: FRENCH <FR...@li...>\n"
Modified: libtifiles/trunk/po/libtifiles.pot
==============================================================================
--- libtifiles/trunk/po/libtifiles.pot (original)
+++ libtifiles/trunk/po/libtifiles.pot Sat May 3 18:28:38 2003
@@ -7,7 +7,7 @@
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
-"POT-Creation-Date: 2003-05-03 12:02+0200\n"
+"POT-Creation-Date: 2003-05-03 18:26+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL...@li...>\n"
Modified: libtifiles/trunk/src/file_int.h
==============================================================================
--- libtifiles/trunk/src/file_int.h (original)
+++ libtifiles/trunk/src/file_int.h Sat May 3 18:28:38 2003
@@ -70,8 +70,7 @@
// trans.c
TIEXPORT uint8_t TICALL *tixx_detokenize_varname(const char *varname,
char *translate,
- uint8_t vartype,
- TicalcType calc_type);
+ uint8_t vartype);
TIEXPORT char* TICALL tifiles_transcode_to_ascii(char* dst,
const char *src);
Modified: libtifiles/trunk/src/trans.c
==============================================================================
--- libtifiles/trunk/src/trans.c (original)
+++ libtifiles/trunk/src/trans.c Sat May 3 18:28:38 2003
@@ -19,6 +19,10 @@
/*
This unit is used to translate some varnames into a more readable name.
Depends on the calculator type and the variable type.
+
+ There are 2 steps:
+ - varname detokenization for some calcs (73/82/83/83+) with TI-charset
+ - TI-charset to user-defined charset (ASCII/Latin1/Unicode) conversion
*/
#include <stdio.h>
@@ -27,80 +31,733 @@
#include "typesxx.h"
#include "file_int.h"
+#include "macros.h"
-// set to ISO8859-1 for compatibility with previous releases
-static TifileEncoding encoding = ENCODING_LATIN1;
-/*
- Set/Get encoding methods
+extern int tifiles_calc_type;
+
+/*
+ Variable name detokenization. This is needed for the following calcs:
+ - 73/82/83/83+: binary-coded to TI-charset
+ - 85/86: no operation
+ - 89/92/92+: no operation
+ See the 'TI Link Guide' for more informations...
*/
-TIEXPORT void TICALL tifiles_translate_set_encoding(TifileEncoding enc)
+
+static char *ti8x_detokenize_varname(const char *varname, char *translate,
+ uint8_t vartype)
{
- encoding = enc;
+ int i;
+ uint8_t tok1 = varname[0] & 0xff;
+ uint8_t tok2 = varname[1] & 0xff;
+
+ switch (vartype)
+ {
+ case TI82_WDW:
+ strcpy(translate, "Window");
+ return translate;
+ break;
+ case TI82_ZSTO:
+ strcpy(translate, "RclWin");
+ return translate;
+ break;
+ case TI82_TAB:
+ strcpy(translate, "TblSet");
+ return translate;
+ break;
+ default:
+ break;
+ }
+
+ switch (tok1)
+ {
+ case 0x5C: /* Matrix: [A] to [E]/[J] */
+ switch(tok2)
+ {
+ case 0x00: sprintf(translate, "[A]"); break;
+ case 0x01: sprintf(translate, "[B]"); break;
+ case 0x02: sprintf(translate, "[C]"); break;
+ case 0x03: sprintf(translate, "[D]"); break;
+ case 0x04: sprintf(translate, "[E]"); break;
+ case 0x05: sprintf(translate, "[F]"); break;
+ case 0x06: sprintf(translate, "[G]"); break;
+ case 0x07: sprintf(translate, "[H]"); break;
+ case 0x08: sprintf(translate, "[I]"); break;
+ case 0x09: sprintf(translate, "[J]"); break;
+
+ default: sprintf(translate, "[?]"); break;
+ }
+ break;
+ case 0x5D: /* List: L1 to L6/L0 */
+ if(tifiles_calc_type == CALC_TI73) //TI73 != TI83 here
+ sprintf(translate, "L%c", varname[1] + '\x80');
+ else
+ {// TI73 begins at L0, others at L1
+ switch(tok2)
+ {
+ case 0x00: sprintf(translate, "L%c", '\x81'); break;
+ case 0x01: sprintf(translate, "L%c", '\x82'); break;
+ case 0x02: sprintf(translate, "L%c", '\x83'); break;
+ case 0x03: sprintf(translate, "L%c", '\x84'); break;
+ case 0x04: sprintf(translate, "L%c", '\x85'); break;
+ case 0x05: sprintf(translate, "L%c", '\x86'); break;
+ case 0x06: sprintf(translate, "L%c", '\x87'); break;
+ case 0x07: sprintf(translate, "L%c", '\x88'); break;
+ case 0x08: sprintf(translate, "L%c", '\x89'); break;
+ case 0x09: sprintf(translate, "L%c", '\x80'); break;
+
+ default: // named list
+ for (i = 0; i < 7; i++)
+ translate[i] = varname[i + 1];
+ break;
+ }
+ }
+ break;
+ case 0x5E: /* Equations: Y1 to Y0, ... */
+ switch(tok2)
+ {
+ case 0x10: sprintf(translate, "Y%c", '\x81'); break;
+ case 0x11: sprintf(translate, "Y%c", '\x82'); break;
+ case 0x12: sprintf(translate, "Y%c", '\x83'); break;
+ case 0x13: sprintf(translate, "Y%c", '\x84'); break;
+ case 0x14: sprintf(translate, "Y%c", '\x85'); break;
+ case 0x15: sprintf(translate, "Y%c", '\x86'); break;
+ case 0x16: sprintf(translate, "Y%c", '\x87'); break;
+ case 0x17: sprintf(translate, "Y%c", '\x88'); break;
+ case 0x18: sprintf(translate, "Y%c", '\x89'); break;
+ case 0x19: sprintf(translate, "Y%c", '\x80'); break;
+
+ case 0x20: sprintf(translate, "X%ct", '\x81'); break;
+ case 0x21: sprintf(translate, "Y%ct", '\x81'); break;
+ case 0x22: sprintf(translate, "X%ct", '\x82'); break;
+ case 0x23: sprintf(translate, "Y%ct", '\x82'); break;
+ case 0x24: sprintf(translate, "X%ct", '\x83'); break;
+ case 0x25: sprintf(translate, "Y%ct", '\x83'); break;
+ case 0x26: sprintf(translate, "X%ct", '\x84'); break;
+ case 0x27: sprintf(translate, "Y%ct", '\x84'); break;
+ case 0x28: sprintf(translate, "X%ct", '\x85'); break;
+ case 0x29: sprintf(translate, "Y%ct", '\x85'); break;
+ case 0x2a: sprintf(translate, "X%ct", '\x86'); break;
+ case 0x2b: sprintf(translate, "Y%ct", '\x86'); break;
+
+ case 0x40: sprintf(translate, "r%c", '\x81'); break;
+ case 0x41: sprintf(translate, "r%c", '\x82'); break;
+ case 0x42: sprintf(translate, "r%c", '\x83'); break;
+ case 0x43: sprintf(translate, "r%c", '\x84'); break;
+ case 0x44: sprintf(translate, "r%c", '\x85'); break;
+ case 0x45: sprintf(translate, "r%c", '\x86'); break;
+
+ case 0x80: sprintf(translate, "U%c", '\xd7'); break;
+ case 0x81: sprintf(translate, "V%c", '\xd7'); break;
+
+ default: sprintf(translate, "_"); break;
+ }
+ break;
+ case 0x60: /* Pictures */
+ if (tok2 != 0x09)
+ sprintf(translate, "Pic%c", tok2 + '\x81');
+ else
+ sprintf(translate, "Pic%c", '\x80');
+ break;
+ case 0x61: /* GDB */
+ if (tok2 != 0x09)
+ sprintf(translate, "GDB%c", tok2 + '\x81');
+ else
+ sprintf(translate, "GDB%c", '\x80');
+ break;
+ case 0x62:
+ switch(tok2)
+ {
+ case 0x01: sprintf(translate, "ReqEq"); break;
+ case 0x02: sprintf(translate, "n"); break;
+ case 0x03: sprintf(translate, "%c", '\xcb'); break;
+ case 0x04: sprintf(translate, "%c%c", '\xc6', 'x'); break;
+ case 0x05: sprintf(translate, "%c%c%c", '\xc6', 'x', '\x12'); break;
+ case 0x06: sprintf(translate, "%c%c", 'S', 'x'); break;
+ case 0x07: sprintf(translate, "%c%c", '\xc7', 'x'); break;
+ case 0x08: sprintf(translate, "minX"); break;
+ case 0x09: sprintf(translate, "maxX"); break;
+ case 0x0a: sprintf(translate, "minY"); break;
+ case 0x0b: sprintf(translate, "maxY"); break;
+ case 0x0c: sprintf(translate, "%c", '\xcc'); break;
+ case 0x0d: sprintf(translate, "%c%c", '\xc6', 'y'); break;
+ case 0x0e: sprintf(translate, "%c%c%c", '\xc6', 'y', '\x12'); break;
+ case 0x0f: sprintf(translate, "%c%c", 'S', 'y'); break;
+ case 0x10: sprintf(translate, "%c%c", '\xc7', 'y'); break;
+ case 0x11: sprintf(translate, "%c%c%c", '\xc6', 'x', 'y'); break;
+ case 0x12: sprintf(translate, "%c", 'r'); break;
+ case 0x13: sprintf(translate, "Med"); break;
+ case 0x14: sprintf(translate, "%c%c", 'Q', '\x81'); break;
+ case 0x15: sprintf(translate, "%c%c", 'Q', '\x83'); break;
+ case 0x16: sprintf(translate, "a"); break;
+ case 0x17: sprintf(translate, "b"); break;
+ case 0x18: sprintf(translate, "c"); break;
+ case 0x19: sprintf(translate, "d"); break;
+ case 0x1a: sprintf(translate, "e"); break;
+ case 0x1b: sprintf(translate, "%c%c", 'x', '\x81'); break;
+ case 0x1c: sprintf(translate, "%c%c", 'x', '\x82'); break;
+ case 0x1d: sprintf(translate, "%c%c", 'x', '\x83'); break;
+ case 0x1e: sprintf(translate, "%c%c", 'y', '\x81'); break;
+ case 0x1f: sprintf(translate, "%c%c", 'y', '\x82'); break;
+ case 0x20: sprintf(translate, "%c%c", 'y', '\x83'); break;
+ case 0x21: sprintf(translate, "%c", '\xd7'); break;
+ case 0x22: sprintf(translate, "p"); break;
+ case 0x23: sprintf(translate, "z"); break;
+ case 0x24: sprintf(translate, "t"); break;
+ case 0x25: sprintf(translate, "%c%c", '\xd9', '\x12'); break;
+ case 0x26: sprintf(translate, "%c", '\xda'); break;
+ case 0x27: sprintf(translate, "df"); break;
+ case 0x28: sprintf(translate, "%c", '\xbc'); break;
+ case 0x29: sprintf(translate, "%c%c", '\xbc', '\x81'); break;
+ case 0x2a: sprintf(translate, "%c%c", '\xbc', '\x82'); break;
+ case 0x2b: sprintf(translate, "%c%c", '\xcb', '\x81'); break;
+ case 0x2c: sprintf(translate, "Sx%c", '\x81'); break;
+ case 0x2d: sprintf(translate, "n%c", '\x81'); break;
+ case 0x2e: sprintf(translate, "%c%c", '\xcb', '\x82'); break;
+ case 0x2f: sprintf(translate, "Sx%c", '\x82'); break;
+ case 0x30: sprintf(translate, "n%c", '\x82'); break;
+ case 0x31: sprintf(translate, "Sxp"); break;
+ case 0x32: sprintf(translate, "lower"); break;
+ case 0x33: sprintf(translate, "upper"); break;
+ case 0x34: sprintf(translate, "s"); break;
+ case 0x35: sprintf(translate, "r%c", '\x12'); break;
+ case 0x36: sprintf(translate, "R%c", '\x12'); break;
+ case 0x37: sprintf(translate, "df"); break;
+ case 0x38: sprintf(translate, "SS"); break;
+ case 0x39: sprintf(translate, "MS"); break;
+ case 0x3a: sprintf(translate, "df"); break;
+ case 0x3b: sprintf(translate, "SS"); break;
+ case 0x3c: sprintf(translate, "MS"); break;
+ default: sprintf(translate, "_"); break;
+ }
+ break;
+ case 0x63:
+ switch(tok2)
+ {
+ case 0x00: sprintf(translate, "ZXscl"); break;
+ case 0x01: sprintf(translate, "ZYscl"); break;
+ case 0x02: sprintf(translate, "Xscl"); break;
+ case 0x03: sprintf(translate, "Yscl"); break;
+ case 0x04: sprintf(translate, "U%cStart", '\xd7'); break;
+ case 0x05: sprintf(translate, "V%cStart", '\xd7'); break;
+ case 0x06: sprintf(translate, "U%c-%c", '\xd7', '\x81'); break;
+ case 0x07: sprintf(translate, "V%c-%c", '\xd7', '\x81'); break;
+ case 0x08: sprintf(translate, "ZU%cStart", '\xd7'); break;
+ case 0x09: sprintf(translate, "ZV%cStart", '\xd7'); break;
+ case 0x0a: sprintf(translate, "Xmin"); break;
+ case 0x0b: sprintf(translate, "Xmax"); break;
+ case 0x0c: sprintf(translate, "Ymin"); break;
+ case 0x0d: sprintf(translate, "Ymax"); break;
+ case 0x0e: sprintf(translate, "Tmin"); break;
+ case 0x0f: sprintf(translate, "Tmax"); break;
+ case 0x10: sprintf(translate, "%cmin", '\x5b'); break;
+ case 0x11: sprintf(translate, "%cmax", '\x5b'); break;
+ case 0x12: sprintf(translate, "ZXmin"); break;
+ case 0x13: sprintf(translate, "ZXmax"); break;
+ case 0x14: sprintf(translate, "ZYmin"); break;
+ case 0x15: sprintf(translate, "ZYmax"); break;
+ case 0x16: sprintf(translate, "Z%cmin", '\x5b'); break;
+ case 0x17: sprintf(translate, "Z%cmax", '\x5b'); break;
+ case 0x18: sprintf(translate, "ZTmin"); break;
+ case 0x19: sprintf(translate, "ZTmax"); break;
+ case 0x1a: sprintf(translate, "TblMin"); break;
+ case 0x1b: sprintf(translate, "%cMin", '\xd7'); break;
+ case 0x1c: sprintf(translate, "Z%cMin", '\xd7'); break;
+ case 0x1d: sprintf(translate, "%cMax", '\xd7'); break;
+ case 0x1e: sprintf(translate, "Z%cMax", '\xd7'); break;
+ case 0x1f: sprintf(translate, "%cStart", '\xd7'); break;
+ case 0x20: sprintf(translate, "Z%cStart", '\xd7'); break;
+ case 0x21: sprintf(translate, "%cTbl", '\xbe'); break;
+ case 0x22: sprintf(translate, "Tstep"); break;
+ case 0x23: sprintf(translate, "%cstep", '\x5b'); break;
+ case 0x24: sprintf(translate, "ZTstep"); break;
+ case 0x25: sprintf(translate, "Z%cstep", '\x5b'); break;
+ case 0x26: sprintf(translate, "%cX", '\xbe'); break;
+ case 0x27: sprintf(translate, "%cY", '\xbe'); break;
+ case 0x28: sprintf(translate, "XFact"); break;
+ case 0x29: sprintf(translate, "YFact"); break;
+ case 0x2a: sprintf(translate, "TblInput"); break;
+ case 0x2b: sprintf(translate, "N"); break;
+ case 0x2c: sprintf(translate, "I%c", '\x25'); break;
+ case 0x2d: sprintf(translate, "PV"); break;
+ case 0x2e: sprintf(translate, "PMT"); break;
+ case 0x2f: sprintf(translate, "FV"); break;
+ case 0x30: sprintf(translate, "Xres"); break;
+ case 0x31: sprintf(translate, "ZXres"); break;
+ default: sprintf(translate, "_"); break;
+ }
+ break;
+ case 0xAA:
+ if (tok2 != 0x09)
+ sprintf(translate, "Str%c", tok2 + '\x81');
+ else
+ sprintf(translate, "Str%c", '\x80');
+ break;
+ default:
+ strcpy(translate, varname);
+ break;
+ }
+
+ return translate;
}
-TIEXPORT TifileEncoding TICALL tifiles_translate_get_encoding(void)
+
+TIEXPORT uint8_t TICALL *tixx_detokenize_varname(const char *varname,
+ char *translate,
+ uint8_t vartype)
{
- return encoding;
+ switch (tifiles_calc_type) {
+ case CALC_TI73:
+ case CALC_TI82:
+ case CALC_TI83:
+ case CALC_TI83P:
+ return ti8x_detokenize_varname(varname, translate, vartype);
+ break;
+ case CALC_TI85:
+ case CALC_TI86:
+ case CALC_TI89:
+ case CALC_TI92:
+ case CALC_TI92P:
+ case CALC_V200:
+ return strcpy(translate, varname);
+ break;
+ default:
+ return strcpy(translate, "________");
+ break;
+ }
}
-/*
- Convert string to pure ASCII.
- Note: src & dst will have the same length.
+/*
+ Charset transcoding. Required for all calcs.
+ See the 'TI Link Guide' for TI-charsets...
+ A char from the TI-charset can be converted into:
+ - ASCII charset,
+ - ISO8859-1 charset (aka Latin1),
+ - UTF-8 charset (Unicode).
+ See: www.unicode.org/charts & www.czyborra.com/utf
*/
-TIEXPORT char* TICALL tifiles_convert_to_ascii(char* dst, const char *src)
+
+/* TI82 */
+
+static char transcode_from_ti82_charset_to_ascii(const char c)
{
- char *dest = dst;
+ switch((uint8_t)c)
+ {
+ case 0x80: return '0';
+ case 0x81: return '1';
+ case 0x82: return '2';
+ case 0x83: return '3';
+ case 0x84: return '4';
+ case 0x85: return '5';
+ case 0x86: return '6';
+ case 0x87: return '7';
+ case 0x88: return '8';
+ case 0x89: return '9';
+ case 0xd8: return 'n'; // eta, u, v, w: diff between 82 and 83
+ default:
+ return (((uint8_t)c >= 0x20) && ((uint8_t)c < 0x80)) ? c : '_';
+ }
+}
- while(*src) {
- *dst++ = ((uint8_t)*src < 0x80) ? *src : '_';
- src++;
- }
- *dst = '\0';
+static char transcode_from_ti82_charset_to_latin1(const char c)
+{
+ switch((uint8_t)c)
+ {
+ case 0x80: return '0';
+ case 0x81: return '1';
+ case 0x82: return '2';
+ case 0x83: return '3';
+ case 0x84: return '4';
+ case 0x85: return '5';
+ case 0x86: return '6';
+ case 0x87: return '7';
+ case 0x88: return '8';
+ case 0x89: return '9';
+
+ case 0x8a: return 192+1;
+ case 0x8b: return 192+0;
+ case 0x8c: return 192+2;
+ case 0x8d: return 192+4;
+ case 0x8e: return 224+1;
+ case 0x8f: return 224+0;
+ case 0x90: return 224+2;
+ case 0x91: return 224+4;
+ case 0x92: return 200+1;
+ case 0x93: return 200+0;
+ case 0x94: return 200+2;
+ case 0x95: return 200+4;
+ case 0x96: return 231+1;
+ case 0x97: return 231+0;
+ case 0x98: return 231+2;
+ case 0x99: return 231+4;
+ case 0x9a: return 204+1;
+ case 0x9b: return 204+0;
+ case 0x9c: return 204+2;
+ case 0x9d: return 204+3;
+ case 0x9e: return 236+1;
+ case 0x9f: return 236+0;
+ case 0xa0: return 236+2;
+ case 0xa1: return 236+3;
+ case 0xa2: return 210+1;
+ case 0xa3: return 210+0;
+ case 0xa4: return 210+2;
+ case 0xa5: return 210+4;
+ case 0xa6: return 242+1;
+ case 0xa7: return 242+0;
+ case 0xa8: return 242+2;
+ case 0xa9: return 242+4;
+ case 0xaa: return 217+1;
+ case 0xab: return 217+0;
+ case 0xac: return 217+2;
+ case 0xad: return 217+3;
+ case 0xae: return 249+1;
+ case 0xaf: return 249+0;
+ case 0xb0: return 249+2;
+ case 0xb1: return 249+3;
+ case 0xb2: return 199;
+ case 0xb3: return 231;
+ case 0xb4: return 209;
+ case 0xb5: return 241;
- return dest;
+ case 0xd8: return 'n'; // eta, u, v, w: diff between 82 and 83
+ default:
+ return (((uint8_t)c >= 0x20) && ((uint8_t)c < 0x80)) ? c : '_';
+ }
}
-/*
- Convert string to the ISO8859-1 charset (aka Latin1).
- Note: src & dst will have the same length.
-*/
-TIEXPORT char* TICALL tifiles_convert_to_latin1(char* dst, const char *src)
+static uint16_t ti82_charset[256] = {
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ ' ', '!', '\"', '#', '_', '%', '&', '\'',
+ '(', ')', '*', '+', ',', '-', '.', '/',
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', ':', ';', '<', '=', '>', '?',
+ '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+ 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+ 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+ 'X', 'Y', 'Z', 0x3b8, '\\', ']', '^', '_',
+ '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+ 'x', 'y', 'z', '{', '|', '}', '~', '=',
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 192+1, 192+0, 192+2, 192+4, 224+1, 224+0,
+ 224+2, 224+4, 200+1, 200+0, 200+2, 200+4, 231+1, 231+0,
+ 231+2, 231+4, 204+1, 204+0, 204+2, 204+3, 236+1, 236+0,
+ 236+2, 236+3, 210+1, 210+0, 210+2, 210+4, 242+1, 242+0,
+ 242+2, 242+4, 217+1, 217+0, 217+2, 217+3, 249+1, 249+0,
+ 249+2, 249+3, 199, 231, 209, 204, '\'', '`',
+ 0x0a8, 0x0bf, 0x0a1, 0x3b1, 0x3b2, 0x3b3, 0x394, 0x3b4,
+ 0x3b5, '[', 0x3bb, 0x3bc, 0x3c0, 0x3c1, 0x3a3, 0x3c3,
+ 0x3c4, 0x3d5, 0x3a9, 'x', 'y', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', 0x3b7,
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+};
+
+static uint16_t transcode_from_ti82_charset_to_utf8(const char c)
+{
+ return ti82_charset[(int)c];
+}
+
+/* TI83/83+/73 (very similar to TI82 but different) */
+
+static char transcode_from_ti83_charset_to_ascii(const char c)
+{
+ switch((uint8_t)c)
+ {
+ case 0x80: return '0';
+ case 0x81: return '1';
+ case 0x82: return '2';
+ case 0x83: return '3';
+ case 0x84: return '4';
+ case 0x85: return '5';
+ case 0x86: return '6';
+ case 0x87: return '7';
+ case 0x88: return '8';
+ case 0x89: return '9';
+
+ case 0x01: return 'n'; // eta, u, v, w: diff between 82 and 83
+ case 0x02: return 'u';
+ case 0x03: return 'v';
+ case 0x04: return 'w';
+ default:
+ return (((uint8_t)c >= 0x20) && ((uint8_t)c < 0x80)) ? c : '_';
+ }
+}
+
+static char transcode_from_ti83_charset_to_latin1(const char c)
{
- char *dest = dst;
+ switch((uint8_t)c)
+ {
+ case 0x01: return 'n'; // eta, u, v, w: diff between 82 and 83
+ case 0x02: return 'u';
+ case 0x03: return 'v';
+ case 0x04: return 'w';
+
+ case 0x80: return '0';
+ case 0x81: return '1';
+ case 0x82: return '2';
+ case 0x83: return '3';
+ case 0x84: return '4';
+ case 0x85: return '5';
+ case 0x86: return '6';
+ case 0x87: return '7';
+ case 0x88: return '8';
+ case 0x89: return '9';
+
+ case 0x8a: return 192+1;
+ case 0x8b: return 192+0;
+ case 0x8c: return 192+2;
+ case 0x8d: return 192+4;
+ case 0x8e: return 224+1;
+ case 0x8f: return 224+0;
+ case 0x90: return 224+2;
+ case 0x91: return 224+4;
+ case 0x92: return 200+1;
+ case 0x93: return 200+0;
+ case 0x94: return 200+2;
+ case 0x95: return 200+4;
+ case 0x96: return 231+1;
+ case 0x97: return 231+0;
+ case 0x98: return 231+2;
+ case 0x99: return 231+4;
+ case 0x9a: return 204+1;
+ case 0x9b: return 204+0;
+ case 0x9c: return 204+2;
+ case 0x9d: return 204+3;
+ case 0x9e: return 236+1;
+ case 0x9f: return 236+0;
+ case 0xa0: return 236+2;
+ case 0xa1: return 236+3;
+ case 0xa2: return 210+1;
+ case 0xa3: return 210+0;
+ case 0xa4: return 210+2;
+ case 0xa5: return 210+4;
+ case 0xa6: return 242+1;
+ case 0xa7: return 242+0;
+ case 0xa8: return 242+2;
+ case 0xa9: return 242+4;
+ case 0xaa: return 217+1;
+ case 0xab: return 217+0;
+ case 0xac: return 217+2;
+ case 0xad: return 217+3;
+ case 0xae: return 249+1;
+ case 0xaf: return 249+0;
+ case 0xb0: return 249+2;
+ case 0xb1: return 249+3;
+ case 0xb2: return 199;
+ case 0xb3: return 231;
+ case 0xb4: return 209;
+ case 0xb5: return 241;
- while(*src) {
- *dst++ = (((uint8_t)*src >= 0x80) && ((uint8_t)*src < 0xA0)) ? '_' : *src;
- src++;
- }
- *dst = '\0';
+ default:
+ return (((uint8_t)c >= 0x20) && ((uint8_t)c < 0x80)) ? c : '_';
+ }
+}
- return dest;
+static uint16_t ti83_charset[256] = {
+ 0x3b7, 'u', 'v', 'w', '_', '_', '_', '_',
+ '_', 'X', '_', '_', '_', '_', '_', 'F',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ ' ', '!', '\"', '#', '_', '%', '&', '\'',
+ '(', ')', '*', '+', ',', '-', '.', '/',
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', ':', ';', '<', '=', '>', '?',
+ '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+ 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+ 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+ 'X', 'Y', 'Z', 0x3b8, '\\', ']', '^', '_',
+ '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+ 'x', 'y', 'z', '{', '|', '}', '~', '=',
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 192+1, 192+0, 192+2, 192+4, 224+1, 224+0,
+ 224+2, 224+4, 200+1, 200+0, 200+2, 200+4, 231+1, 231+0,
+ 231+2, 231+4, 204+1, 204+0, 204+2, 204+3, 236+1, 236+0,
+ 236+2, 236+3, 210+1, 210+0, 210+2, 210+4, 242+1, 242+0,
+ 242+2, 242+4, 217+1, 217+0, 217+2, 217+3, 249+1, 249+0,
+ 249+2, 249+3, 199, 231, 209, 204, '\'', '`',
+ 0x0a8, 0x0bf, 0x0a1, 0x3b1, 0x3b2, 0x3b3, 0x394, 0x3b4,
+ 0x3b5, '[', 0x3bb, 0x3bc, 0x3c0, 0x3c1, 0x3a3, 0x3c3,
+ 0x3c4, 0x3d5, 0x3a9, 'x', 'y', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', 0x3b7,
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+};
+
+static uint16_t transcode_from_ti83_charset_to_utf8(const char c)
+{
+ return ti83_charset[(int)c];
+}
+
+/* TI85/86 */
+
+static char transcode_from_ti85_charset_to_ascii(const char c)
+{
+ switch((uint8_t)c)
+ {
+ case 0x80: return '0';
+ case 0x81: return '1';
+ case 0x82: return '2';
+ case 0x83: return '3';
+ case 0x84: return '4';
+ case 0x85: return '5';
+ case 0x86: return '6';
+ case 0x87: return '7';
+ case 0x88: return '8';
+ case 0x89: return '9';
+ default:
+ return (((uint8_t)c >= 0x20) && ((uint8_t)c < 0x80)) ? c : '_';
+ }
}
-/*
- Convert string to the UTF-8 charset (Unicode).
- See: www.unicode.org/charts & www.czyborra.com/utf
- Note: dst may be up to twice the length of src.
-*/
-TIEXPORT char* TICALL tifiles_convert_to_unicode(char* dst, const char *src)
+static char transcode_from_ti85_charset_to_latin1(const char c)
+{
+ switch((uint8_t)c)
+ {
+ case 0x80: return '0';
+ case 0x81: return '1';
+ case 0x82: return '2';
+ case 0x83: return '3';
+ case 0x84: return '4';
+ case 0x85: return '5';
+ case 0x86: return '6';
+ case 0x87: return '7';
+ case 0x88: return '8';
+ case 0x89: return '9';
+
+ case 0x8a: return 192+1;
+ case 0x8b: return 192+0;
+ case 0x8c: return 192+2;
+ case 0x8d: return 192+4;
+ case 0x8e: return 224+1;
+ case 0x8f: return 224+0;
+ case 0x90: return 224+2;
+ case 0x91: return 224+4;
+ case 0x92: return 200+1;
+ case 0x93: return 200+0;
+ case 0x94: return 200+2;
+ case 0x95: return 200+4;
+ case 0x96: return 231+1;
+ case 0x97: return 231+0;
+ case 0x98: return 231+2;
+ case 0x99: return 231+4;
+ case 0x9a: return 204+1;
+ case 0x9b: return 204+0;
+ case 0x9c: return 204+2;
+ case 0x9d: return 204+3;
+ case 0x9e: return 236+1;
+ case 0x9f: return 236+0;
+ case 0xa0: return 236+2;
+ case 0xa1: return 236+3;
+ case 0xa2: return 210+1;
+ case 0xa3: return 210+0;
+ case 0xa4: return 210+2;
+ case 0xa5: return 210+4;
+ case 0xa6: return 242+1;
+ case 0xa7: return 242+0;
+ case 0xa8: return 242+2;
+ case 0xa9: return 242+4;
+ case 0xaa: return 217+1;
+ case 0xab: return 217+0;
+ case 0xac: return 217+2;
+ case 0xad: return 217+3;
+ case 0xae: return 249+1;
+ case 0xaf: return 249+0;
+ case 0xb0: return 249+2;
+ case 0xb1: return 249+3;
+ case 0xb2: return 199;
+ case 0xb3: return 231;
+ case 0xb4: return 209;
+ case 0xb5: return 241;
+
+ case 0xd8: return 'n'; // eta, u, v, w: diff between 82 and 83
+ default:
+ return (((uint8_t)c >= 0x20) && ((uint8_t)c < 0x80)) ? c : '_';
+ }
+}
+
+static uint16_t ti85_charset[256] = {
+ 0x3b7, 'u', 'v', 'w', '_', '_', '_', '_',
+ '_', 'X', '_', '_', '_', '_', '_', 'F',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ ' ', '!', '\"', '#', '_', '%', '&', '\'',
+ '(', ')', '*', '+', ',', '-', '.', '/',
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', ':', ';', '<', '=', '>', '?',
+ '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+ 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+ 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+ 'X', 'Y', 'Z', '[', '\\', ']', '^', '_',
+ '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+ 'x', 'y', 'z', '{', '|', '}', '~', '=',
+ '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 192+1, 192+0, 192+2, 192+4, 224+1, 224+0,
+ 224+2, 224+4, 200+1, 200+0, 200+2, 200+4, 231+1, 231+0,
+ 231+2, 231+4, 204+1, 204+0, 204+2, 204+3, 236+1, 236+0,
+ 236+2, 236+3, 210+1, 210+0, 210+2, 210+4, 242+1, 242+0,
+ 242+2, 242+4, 217+1, 217+0, 217+2, 217+3, 249+1, 249+0,
+ 249+2, 249+3, 199, 231, 209, 204, '\'', '`',
+ 0x0a8, 0x0bf, 0x0a1, 0x3b1, 0x3b2, 0x3b3, 0x394, 0x3b4,
+ 0x3b5, 0x3b8, 0x3bb, 0x3bc, 0x3c0, 0x3c1, 0x3a3, 0x3c3,
+ 0x3c4, 0x3d5, 0x3a9, 'x', 'y', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', 0x3b7,
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+ '_', '_', '_', '_', '_', '_', '_', '_',
+};
+
+static uint16_t transcode_from_ti85_charset_to_utf8(const char c)
+{
+ return ti85_charset[(int)c];
+}
+
+/* TI89/92/92+/V200 */
+
+static char transcode_from_ti9x_charset_to_ascii(const char c)
+{
+ return (((uint8_t)c >= 0x20) && ((uint8_t)c < 0x80)) ? c : '_';
+}
+
+static char transcode_from_ti9x_charset_to_latin1(const char c)
+{
+ return (((uint8_t)c >= 0x80) && ((uint8_t)c < 0xA0)) ? '_' : c;
+}
+
+static uint16_t transcode_from_ti9x_charset_to_utf8(const char c)
{
- char *dest = dst;
uint16_t wchar;
- while(*src) {
- if((uint8_t)*src < 0x80) // ASCII part
- wchar = *src;
- else if((uint8_t)*src >= 0xA0) // ISO8859-1 part
- switch((uint8_t)*src) {
+ if((uint8_t)c < 0x80) // ASCII part
+ wchar = c;
+ else if((uint8_t)c >= 0xA0) // ISO8859-1 part
+ switch((uint8_t)c)
+ {
case 0xb5: wchar = 0x03bc; break; // mu
- default: wchar = *src & 0xff; break;
+ default: wchar = c & 0xff; break;
}
- else
- { // greek characters
- switch((uint8_t)*src) {
+ else
+ { // greek characters
+ switch((uint8_t)c)
+ {
case 0x80: wchar = 0x03b1; break; // alpha
case 0x81: wchar = 0x03b2; break; // beta
case 0x82: wchar = 0x0393; break; // gamma (capital)
@@ -122,390 +779,179 @@
case 0x92: wchar = 0x03a8; break; // psi (capital)
case 0x93: wchar = 0x03a9; break; // omega (capital)
case 0x94: wchar = 0x03c9; break; // omega
- default: wchar = '_';
+ default: wchar = '_';
}
- }
-
- // write our wide-char
- if ((uint16_t)wchar < 0x80)
- *dst++ = wchar;
- else if ((uint16_t)wchar < 0x0800) {
- *dst++ = (0xC0 | (wchar >> 6)) & 0xff;
- *dst++ = (0x80 | (wchar & 0x3f)) & 0xff;
}
- src++;
- }
- *dst = '\0';
-
- return dest;
+
+ return wchar;
}
+/* Generic transcoding */
-/*
- Variable name translation functions.
- We have to process the varname for the following calcs:
- - 73/82/83/83+: binary-coded to ASCII charset translation
- - 85/86: no translation
- - 89/92/92+: TI's charset to user-defined charset (ASCII/Latin1/Unicode)
+typedef char (*TRANSCODE_TO_ASCII) (const char c);
+typedef char (*TRANSCODE_TO_LATIN1) (const char c);
+typedef uint16_t (*TRANSCODE_TO_UNICODE) (const char c);
- See the protocol doc for more informations
-*/
+extern int tifiles_calc_type;
-char *ti73_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
+/*
+ Convert string to pure ASCII.
+ Note: src & dst will have the same length.
+*/
+TIEXPORT char* TICALL tifiles_transcode_to_ascii(char* dst, const char *src)
{
- int i;
+ char *dest = dst;
+ TRANSCODE_TO_ASCII f = NULL;
- switch (vartype) {
- case TI73_WDW:
- strcpy(translate, "Window");
- break;
- case TI73_ZSTO:
- strcpy(translate, "RclWin");
- break;
- case TI73_TAB:
- strcpy(translate, "TblSet");
- break;
- default:
- switch (varname[0] & 0xFF) {
- case 0x5D:
- if (varname[1] > 0x09) {
- for (i = 0; i < 7; i++) {
- (translate)[i] = varname[i + 1];
- }
- break;
- }
- sprintf(translate, "L%c", varname[1] + '0'); //TI73 != TI83 here
- break;
- case 0x5C:
- sprintf(translate, "[%c]", varname[1] + 'A');
- break;
- case 0x5E:
- switch ((varname[1] & 0xF0) >> 4) {
- case 1:
- if (varname[1] != 0x19)
- sprintf(translate, "Y%c", (varname[1] & 0xFF) + '1' - 0x10);
- else
- strcpy(translate, "Y0");
- break;
- case 2:
- if (varname[1] & 0x01) {
- sprintf(translate, "X%ct", ((varname[1] - 0x20) >> 1) + '1');
- } else {
- sprintf(translate, "Y%ct", ((varname[1] - 0x20) >> 1) + '1');
- }
- break;
- case 4:
- sprintf(translate, "r%c", (varname[1] & 0xFF) - 0x40 + '1');
- break;
- case 8:
- sprintf(translate, "%c", (varname[1] & 0xFF) - 0x80 + 'u');
- break;
- }
- break;
- case 0xAA:
- if (varname[1] != 0x09)
- sprintf(translate, "Str%c", varname[1] + '1');
- else
- strcpy(translate, "Str0");
- break;
- case 0x60:
- if (varname[1] != 0x09)
- sprintf(translate, "Pic%c", varname[1] + '1');
- else
- strcpy(translate, "Pic0");
- break;
- case 0x61:
- if (varname[1] != 0x09)
- sprintf(translate, "GDB%c", varname[1] + '1');
- else
- strcpy(translate, "GDB0");
+ switch(tifiles_calc_type)
+ {
+ case CALC_TI73:
+ case CALC_TI83:
+ case CALC_TI83P: f = transcode_from_ti83_charset_to_ascii;
+ break;
+ case CALC_TI82: f = transcode_from_ti82_charset_to_ascii;
+ break;
+ case CALC_TI85:
+ case CALC_TI86: f = transcode_from_ti85_charset_to_ascii;
+ break;
+ case CALC_TI89:
+ case CALC_TI92:
+ case CALC_TI92P:
+ case CALC_V200: f = transcode_from_ti9x_charset_to_ascii;
break;
- default:
- strcpy(translate, varname);
}
- break;
- }
- return translate;
+ while(*src)
+ *dst++ = f(*src++);
+ *dst = '\0';
+
+ return dest;
}
-char *ti82_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
+/*
+ Convert string to the ISO8859-1 charset (aka Latin1).
+ Note: src & dst will have the same length.
+*/
+TIEXPORT char* TICALL tifiles_transcode_to_latin1(char* dst, const char *src)
{
- int i;
+ char *dest = dst;
+ TRANSCODE_TO_LATIN1 f = NULL;
- /*
- printf("-> <%s> ", varname);
- for(i=0; i<8; i++) { printf("%02X ", 0xFF & varname[i]); }
- printf("\n");
- */
- switch (vartype) {
- case TI82_WDW:
- strcpy(translate, "Window");
- break;
- case TI82_ZSTO:
- strcpy(translate, "RclWin");
- break;
- case TI82_TAB:
- strcpy(translate, "TblSet");
- break;
- default:
- switch (varname[0] & 0xFF) {
- case 0x5D: /* List */
- if (varname[1] > 0x09) {
- for (i = 0; i < 7; i++) {
- translate[i] = varname[i + 1];
- }
- break;
- }
- sprintf(translate, "L%c", varname[1] + '1');
- break;
- case 0x5C: /* Matrix */
- sprintf(translate, "[%c]", varname[1] + 'A');
- break;
- case 0x5E: /* Equations */
- switch ((varname[1] & 0xF0) >> 4) {
- case 1:
- if (varname[1] != 0x19)
- sprintf(translate, "Y%c", (varname[1] & 0xFF) + '1' - 0x10);
- else
- strcpy(translate, "Y0");
- break;
- case 2:
- if (varname[1] & 0x01) {
- sprintf(translate, "Y%ct", ((varname[1] - 0x20) >> 1) + '1');
- } else {
- sprintf(translate, "X%ct", ((varname[1] - 0x20) >> 1) + '1');
- }
- break;
- case 4:
- sprintf(translate, "r%c", (varname[1] & 0xFF) - 0x40 + '1');
- break;
- case 8:
- sprintf(translate, "%c", (varname[1] & 0xFF) - 0x80 + 'u');
- break;
- }
- break;
- case 0x60: /* Pictures */
- sprintf(translate, "Pic%c", varname[1] + '1');
- break;
- case 0x61: /* Gdb */
- sprintf(translate, "GDB%c", varname[1] + '1');
+ switch(tifiles_calc_type)
+ {
+ case CALC_TI73:
+ case CALC_TI83:
+ case CALC_TI83P: f = transcode_from_ti83_charset_to_latin1;
+ break;
+ case CALC_TI82: f = transcode_from_ti82_charset_to_latin1;
+ break;
+ case CALC_TI85:
+ case CALC_TI86: f = transcode_from_ti85_charset_to_latin1;
+ break;
+ case CALC_TI89:
+ case CALC_TI92:
+ case CALC_TI92P:
+ case CALC_V200: f = transcode_from_ti9x_charset_to_latin1;
break;
- default:
- strcpy(translate, varname);
}
- break;
- }
- return translate;
+ while(*src)
+ *dst++ = f(*src++);
+ *dst = '\0';
+
+ return dest;
}
-char *ti83_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
+/*
+ Convert string to the UTF-8 charset (Unicode).
+ See: www.unicode.org/charts & www.czyborra.com/utf
+ Note: dst may be up to twice the length of src.
+*/
+TIEXPORT char* TICALL tifiles_transcode_to_utf8(char* dst, const char *src)
{
- int i;
+ char *dest = dst;
+ uint16_t wchar;
+ TRANSCODE_TO_UNICODE f = NULL;
- switch (vartype) {
- case TI82_WDW:
- strcpy(translate, "Window");
- break;
- case TI82_ZSTO:
- strcpy(translate, "RclWin");
- break;
- case TI82_TAB:
- strcpy(translate, "TblSet");
- break;
- default:
- switch (varname[0] & 0xFF) {
- case 0x5D:
- if (varname[1] > 0x09) {
- for (i = 0; i < 7; i++) {
- (translate)[i] = varname[i + 1];
- }
- break;
- }
- if (varname[1] != 0x09)
- sprintf(translate, "L%c", varname[1] + '1');
- else
- strcpy(translate, "L9");
- break;
- case 0x5C:
- sprintf(translate, "[%c]", varname[1] + 'A');
- break;
- case 0x5E:
- switch ((varname[1] & 0xF0) >> 4) {
- case 1:
- if (varname[1] != 0x19)
- sprintf(translate, "Y%c", (varname[1] & 0xFF) + '1' - 0x10);
- else
- strcpy(translate, "Y0");
- break;
- case 2:
- if (varname[1] & 0x01) {
- sprintf(translate, "X%ct", ((varname[1] - 0x20) >> 1) + '1');
- } else {
- sprintf(translate, "Y%ct", ((varname[1] - 0x20) >> 1) + '1');
- }
- break;
- case 4:
- sprintf(translate, "r%c", (varname[1] & 0xFF) - 0x40 + '1');
- break;
- case 8:
- sprintf(translate, "%c", (varname[1] & 0xFF) - 0x80 + 'u');
- break;
- }
- break;
- case 0xAA:
- if (varname[1] != 0x09)
- sprintf(translate, "Str%c", varname[1] + '1');
- else
- strcpy(translate, "Str0");
- break;
- case 0x60:
- if (varname[1] != 0x09)
- sprintf(translate, "Pic%c", varname[1] + '1');
- else
- strcpy(translate, "Pic0");
- break;
- case 0x61:
- if (varname[1] != 0x09)
- sprintf(translate, "GDB%c", varname[1] + '1');
- else
- strcpy(translate, "GDB0");
+ switch(tifiles_calc_type)
+ {
+ case CALC_TI73:
+ case CALC_TI83:
+ case CALC_TI83P: f = transcode_from_ti83_charset_to_utf8;
+ break;
+ case CALC_TI82: f = transcode_from_ti82_charset_to_utf8;
+ break;
+ case CALC_TI85:
+ case CALC_TI86: f = transcode_from_ti85_charset_to_utf8;
+ break;
+ case CALC_TI89:
+ case CALC_TI92:
+ case CALC_TI92P:
+ case CALC_V200: f = transcode_from_ti9x_charset_to_utf8;
break;
- default:
- strcpy(translate, varname);
}
- break;
+
+ while(*src) {
+ wchar = f(*src++);
+
+ // write our wide-char
+ if ((uint16_t)wchar < 0x80)
+ *dst++ = wchar;
+ else if ((uint16_t)wchar < 0x0800) {
+ *dst++ = (0xC0 | (wchar >> 6)) & 0xff;
+ *dst++ = (0x80 | (wchar & 0x3f)) & 0xff;
+ }
}
+ *dst = '\0';
- return translate;
+ return dest;
}
-/* TI83+ is not supported yet */
-char *ti83p_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
-{
- return ti83_translate_varname(varname, translate, vartype);
-}
/*
- Other calc do not need varname translation but these functions are provided
- as general functions
+ Set/Get encoding methods
*/
-char *ti85_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
-{
- strcpy(translate, varname);
- return translate;
-}
-char *ti86_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
-{
- strcpy(translate, varname);
- return translate;
-}
+// set to ISO8859-1 for compatibility with previous releases
+static TifileEncoding tifiles_encoding = ENCODING_LATIN1;
-char *ti89_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
+TIEXPORT void TICALL tifiles_translate_set_encoding(TifileEncoding encoding)
{
- switch(encoding) {
- case ENCODING_ASCII: return tifiles_convert_to_ascii(translate, varname);
- case ENCODING_LATIN1: return tifiles_convert_to_latin1(translate, varname);
- case ENCODING_UNICODE: return tifiles_convert_to_unicode(translate, varname);
- }
-
- return translate;
+ tifiles_encoding = encoding;
}
-char *ti92_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
+TIEXPORT TifileEncoding TICALL tifiles_translate_get_encoding(void)
{
- switch(encoding) {
- case ENCODING_ASCII: return tifiles_convert_to_ascii(translate, varname);
- case ENCODING_LATIN1: return tifiles_convert_to_latin1(translate, varname);
- case ENCODING_UNICODE: return tifiles_convert_to_unicode(translate, varname);
- }
-
- return translate;
+ return tifiles_encoding;
}
-char *ti92p_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
-{
- switch(encoding) {
- case ENCODING_ASCII: return tifiles_convert_to_ascii(translate, varname);
- case ENCODING_LATIN1: return tifiles_convert_to_latin1(translate, varname);
- case ENCODING_UNICODE: return tifiles_convert_to_unicode(translate, varname);
- }
- return translate;
-}
+/*
+ Variable name translation: detokenization + charset transcoding.
+*/
+
-char *v200_translate_varname(const char *varname, char *translate,
- uint8_t vartype)
+TIEXPORT char *TICALL tifiles_translate_varname(const char *varname,
+ char *translate,
+ uint8_t vartype)
{
- switch(encoding) {
- case ENCODING_ASCII: return tifiles_convert_to_ascii(translate, varname);
- case ENCODING_LATIN1: return tifiles_convert_to_latin1(translate, varname);
- case ENCODING_UNICODE: return tifiles_convert_to_unicode(translate, varname);
- }
+ char detokenized[9];
+ char *src = detokenized;
+ char dst[17];
- return translate;
-}
+ tixx_detokenize_varname(varname, detokenized, vartype);
-char *tixx_translate_varname(const char *varname, char *translate,
- uint8_t vartype, TicalcType calc_type)
-{
- switch (calc_type) {
- case CALC_TI73:
- return ti73_translate_varname(varname, translate, vartype);
- break;
- case CALC_TI82:
- return ti82_translate_varname(varname, translate, vartype);
- break;
- case CALC_TI83:
- return ti83_translate_varname(varname, translate, vartype);
- break;
- case CALC_TI83P:
- return ti83p_translate_varname(varname, translate, vartype);
- break;
- case CALC_TI85:
- return ti85_translate_varname(varname, translate, vartype);
- break;
- case CALC_TI86:
- return ti86_translate_varname(varname, translate, vartype);
- break;
- case CALC_TI89:
- return ti89_translate_varname(varname, translate, vartype);
- break;
- case CALC_TI92:
- return ti92_translate_varname(varname, translate, vartype);
- break;
- case CALC_TI92P:
- return ti92p_translate_varname(varname, translate, vartype);
- break;
- case CALC_V200:
- return v200_translate_varname(varname, translate, vartype);
- break;
- default:
- return "invalid calc type !";
- break;
+ switch(tifiles_encoding)
+ {
+ case ENCODING_ASCII: tifiles_transcode_to_ascii(dst, src); break;
+ case ENCODING_LATIN1: tifiles_transcode_to_latin1(dst, src); break;
+ case ENCODING_UNICODE: tifiles_transcode_to_utf8(dst, src); break;
}
-}
-extern int tifiles_calc_type;
+ strcpy(translate, dst);
-TIEXPORT char *TICALL tifiles_translate_varname(const char *varname,
- char *translate,
- uint8_t vartype)
-{
- return tixx_translate_varname(varname, translate, vartype,
- tifiles_calc_type);
+ return translate;
}
TIEXPORT char *TICALL tifiles_translate_varname_static(const char *varname,
@@ -513,8 +959,7 @@
{
static char trans[9];
- return tixx_translate_varname(varname, trans, vartype,
- tifiles_calc_type);
+ return tifiles_translate_varname(varname, trans, vartype);
}
/* obsolete, replaced by the func below */
|
