/**
* tifiles_calc_are_compat:
* @model: a calculator model.
* @ref: a calculator model.
*
* Check whether %model is compatible (in term of file types) with %ref.
* Example: a .92t can be sent to a TI92 (of course) as well as a
* TI89, 92+, V200 and a Titanium.
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_calc_are_compat(CalcModel model, CalcModel ref)
{
if(tifiles_calc_is_ti8x(model) && tifiles_calc_is_ti8x(ref))
return !0;
else if(tifiles_calc_is_ti9x(model) && tifiles_calc_is_ti9x(ref))
return !0;
else if((model == CALC_NSPIRE) && (ref == CALC_NSPIRE))
return !0;
return 0;
}
GLADE_CB void
on_mkdir_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
gchar *ret;
GNode *node;
VarEntry *ve;
if(GFMFile.trees.vars == NULL)
return;
if(tifiles_calc_is_ti8x(GFMFile.model))
return;
ret = msgbox_input(_("New Folder"), _("folder"), _("Name of folder to create:"));
if(ret == NULL)
return;
ret[8] = '\0';
ve = tifiles_ve_create();
strcpy(ve->name, ret);
ve->type = tifiles_folder_type(GFMFile.model);
node = g_node_new(ve);
g_node_append(GFMFile.trees.vars, node);
ctree_refresh();
labels_refresh();
}
/**
* tifiles_file_display_regular:
* @content: the file content to show.
*
* Display file content information.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int TICALL tifiles_file_display_regular(FileContent *content)
{
if (content == NULL)
{
tifiles_critical("%s(NULL)", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(content->model))
return ti8x_content_display_regular(content);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(content->model))
return ti9x_content_display_regular(content);
else
#endif
if(content->model == CALC_NSPIRE)
return tnsp_content_display_regular(content);
else
return ERR_BAD_CALC;
return 0;
}
/**
* tifiles_file_read_flash:
* @filename: name of FLASH file to open.
* @content: where to store the file content.
*
* Load the FLASH file into a FlashContent structure.
*
* Structure content must be freed with #tifiles_content_delete_flash when
* no longer used.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int tifiles_file_read_flash(const char *filename, FlashContent *content)
{
if (filename == NULL || content == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(tifiles_file_get_model(filename)))
return ti8x_file_read_flash(filename, content);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(tifiles_file_get_model(filename)) || tifiles_file_is_tib(filename))
return ti9x_file_read_flash(filename, content);
else
#endif
if(content->model == CALC_NSPIRE)
return tnsp_file_read_flash(filename, content);
else
return ERR_BAD_CALC;
return 0;
}
/**
* tifiles_file_write_regular:
* @filename: name of single/group file where to write or NULL.
* @content: the file content to write.
* @real_fname: pointer address or NULL. Must be freed if needed when no longer needed.
*
* Write one (or several) variable(s) into a single (group) file. If filename is set to NULL,
* the function build a filename from varname and allocates resulting filename in %real_fname.
* %filename and %real_filename can be NULL but not both !
*
* %real_filename must be freed when no longer used.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int tifiles_file_write_regular(const char *filename, FileContent *content, char **real_fname)
{
if (content == NULL || (filename == NULL && real_fname == NULL))
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(content->model))
return ti8x_file_write_regular(filename, (Ti8xRegular *)content, real_fname);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(content->model))
return ti9x_file_write_regular(filename, (Ti9xRegular *)content, real_fname);
else
#endif
if(content->model == CALC_NSPIRE)
return tnsp_file_write_regular(filename, (FileContent *)content, real_fname);
else
return ERR_BAD_CALC;
return 0;
}
/**
* ticalcs_clock_format2date:
* @model: a calculator model
* @value: a format type
*
* Convert a format type into a format string.
* Example: 1 -> "MM/DD/YY"
*
* Return value: a format string.
**/
TIEXPORT3 const char *TICALL ticalcs_clock_format2date(CalcModel model, int value)
{
int v;
if(tifiles_calc_is_ti9x(model))
{
if (value < 1)
v = 1;
else if (value > MAX_FORMAT_89)
v = MAX_FORMAT_89;
else
v = value;
return TI_CLOCK_89[v];
}
else if(tifiles_calc_is_ti8x(model))
{
if (value < 1)
v = 1;
else if (value > MAX_FORMAT_84)
v = MAX_FORMAT_84;
else
v = value;
return TI_CLOCK_84[v];
}
return "";
}
/**
* ticalcs_clock_date2format:
* @model: a calculator model
* @format: a format string
*
* Convert a format string into a format type.
* Example: "MM/DD/YY" -> 1
*
* Return value: a format string.
**/
TIEXPORT3 int TICALL ticalcs_clock_date2format(CalcModel model, const char *format)
{
int i = 1;
if (format == NULL)
{
ticalcs_critical("ticalcs_clock_date2format: format is NULL");
return 0;
}
if(tifiles_calc_is_ti9x(model))
{
for (i = 1; i <= MAX_FORMAT_89; i++)
{
if (!strcasecmp(TI_CLOCK_89[i], format))
break;
}
if (i > MAX_FORMAT_89)
return 1;
}
else if(tifiles_calc_is_ti8x(model))
{
for (i = 1; i <= MAX_FORMAT_84; i++)
{
if (!strcasecmp(TI_CLOCK_84[i], format))
break;
}
if (i > MAX_FORMAT_84)
return 1;
}
return i;
}
/**
* tifiles_calc_are_compat:
* @model: a calculator model.
* @ref: a calculator model.
*
* Check whether %model is compatible (in term of file types) with %ref.
* Example: a .92t can be sent to a TI92 (of course) as well as a
* TI89, 92+, V200 and a Titanium.
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_calc_are_compat(CalcModel model, CalcModel ref)
{
if (tifiles_calc_is_ti8x(model) && tifiles_calc_is_ti8x(ref))
{
return !0;
}
else if (tifiles_calc_is_ti9x(model) && tifiles_calc_is_ti9x(ref))
{
return !0;
}
else if (ticonv_model_is_tinspire(model) && ticonv_model_is_tinspire(ref))
{
return !0;
}
return 0;
}
/**
* tifiles_content_dup_flash:
*
* Allocates and copies a new FlashContent structure.
*
* Return value: none.
**/
TIEXPORT2 FlashContent* TICALL tifiles_content_dup_flash(FlashContent *content)
{
FlashContent *dup = NULL;
FlashContent *p, *q;
if (content != NULL)
{
dup = tifiles_content_create_flash(content->model);
if (dup != NULL)
{
for(p = content, q = dup; p; p = p->next, q = q->next)
{
memcpy(q, p, sizeof(FlashContent));
// TI9x part
if(tifiles_calc_is_ti9x(content->model))
{
if(p->data_part)
{
q->data_part = (uint8_t *)g_malloc0(p->data_length+1);
memcpy(q->data_part, p->data_part, p->data_length+1);
}
}
// TI8x part
if(tifiles_calc_is_ti8x(content->model))
{
int i;
// copy pages
q->pages = tifiles_fp_create_array(p->num_pages);
for(i = 0; i < content->num_pages; i++)
{
q->pages[i] = (FlashPage *)g_malloc0(sizeof(FlashPage));
memcpy(q->pages[i], p->pages[i], sizeof(FlashPage));
q->pages[i]->data = (uint8_t *) g_malloc0(p->pages[i]->size);
memcpy(q->pages[i]->data, p->pages[i]->data, p->pages[i]->size);
}
}
if(p->next)
q->next = tifiles_content_create_flash(p->model);
}
}
}
else
{
tifiles_critical("%s(NULL)", __FUNCTION__);
}
return dup;
}
/**
* tifiles_build_filename:
* @model: a calculator model.
* @ve: a #VarEntry structure.
*
* Build a valid filename from folder name, variable name and variable type.
* Example: real number x on TI89 in the 'main' folder will give 'main.x.89e'.
* Note: this function is useable with FLASH apps, too (but you have to fill the #VarEntry structure yourself).
*
* Return value: a newly allocated string which must be freed when no longer used.
**/
TIEXPORT2 char* TICALL tifiles_build_filename(CalcModel model, const VarEntry *ve)
{
char *filename;
if (ve == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return NULL;
}
if(tifiles_calc_is_ti8x(model) || !strcmp(ve->folder, "") ||
(ve->type == tifiles_flash_type(model)))
{
char *part2;
const char *part3;
char *tmp;
part2 = ticonv_varname_to_filename(model, ve->name, ve->type);
part3 = tifiles_vartype2fext(model, ve->type);
tmp = g_strconcat(part2, ".", part3, NULL);
g_free(part2);
filename = g_strdup(tmp);
g_free(tmp);
}
else
{
char *part1;
char *part2;
const char *part3;
char *tmp;
part1 = ticonv_varname_to_filename(model, ve->folder, -1);
part2 = ticonv_varname_to_filename(model, ve->name, ve->type);
part3 = tifiles_vartype2fext(model, ve->type);
tmp = g_strconcat(part1, ".", part2, ".", part3, NULL);
g_free(part1);
g_free(part2);
filename = strdup(tmp);
g_free(tmp);
}
return filename;
}
/**
* tifiles_file_display:
* @filename: a TI file.
*
* Determine file class and display internal content.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int TICALL tifiles_file_display(const char *filename)
{
if (tifiles_file_is_tigroup(filename))
return tifiles_file_display_tigroup(filename);
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(tifiles_file_get_model(filename)))
return ti8x_file_display(filename);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(tifiles_file_get_model(filename)))
return ti9x_file_display(filename);
else
#endif
return ERR_BAD_CALC;
return 0;
}
/**
* tifiles_file_write_flash2:
* @filename: name of flash file where to write or NULL.
* @content: the file content to write.
* @real_fname: pointer address or NULL. Must be freed if needed when no longer needed.
*
* Write a FLASH content to a file. If filename is set to NULL, the function build a filename
* from appname and allocates resulting filename in %real_fname.
* %filename and %real_fname can be NULL but not both !
*
* %real_fname must be freed when no longer used.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int tifiles_file_write_flash2(const char *filename, FlashContent *content, char **real_fname)
{
if (content == NULL || (filename == NULL && real_fname == NULL))
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(content->model))
return ti8x_file_write_flash(filename, content, real_fname);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(content->model))
return ti9x_file_write_flash(filename, content, real_fname);
else
#endif
return ERR_BAD_CALC;
return 0;
}
/**
* tifiles_file_write_backup:
* @filename: name of backup file where to write.
* @content: the file content to write.
*
* Write backup into file.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int tifiles_file_write_backup(const char *filename, BackupContent *content)
{
if (filename == NULL || content == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(content->model))
return ti8x_file_write_backup(filename, content);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(content->model))
return ti9x_file_write_backup(filename, content);
else
#endif
return ERR_BAD_CALC;
return 0;
}
/**
* tifiles_content_delete_backup:
*
* Free the whole content of a BackupContent structure.
*
* Return value: none.
**/
TIEXPORT2 int TICALL tifiles_content_delete_backup(BackupContent *content)
{
if (content != NULL)
{
if (tifiles_calc_is_ti9x(content->model))
g_free(content->data_part);
else if (tifiles_calc_is_ti8x(content->model))
{
g_free(content->data_part1);
g_free(content->data_part2);
g_free(content->data_part3);
g_free(content->data_part4);
}
g_free(content);
}
else
{
tifiles_critical("%s(NULL)", __FUNCTION__);
}
return 0;
}
/**
* ticonv_utf16_to_gfe:
* @model: a calculator model taken in #CalcModel.
* @src: the name of variable to convert from UTF-16
*
* This function converts a varname into a valid filename (depends on locale).
* Example: 'foobar' => foobar, 'alpha' => _alpha_.
*
* Greeks characters need conversion if the locale is not UTF-8 (Windows for sure, Linux
* if locale is different of UTF-8) because greek characters are often missed or mis-converted
* when converting to locale.
*
* Return value: %dst as a newly allocated string.
**/
TIEXPORT4 char* TICALL ticonv_utf16_to_gfe(CalcModel model, const unsigned short *src)
{
#ifdef __WIN32__
int is_utf8 = G_WIN32_HAVE_WIDECHAR_API();
#else
int is_utf8 = g_get_charset(NULL);
#endif
const char *str;
unsigned short *utf16_src, *p;
unsigned short *utf16_dst, *q;
char *dst;
// detokenization to UTF-16
p = utf16_src = (unsigned short *)src;
q = utf16_dst = g_malloc0(18*ticonv_utf16_strlen(utf16_src)+2);
// conversion from UTF-16 to UTF-16
if(tifiles_calc_is_ti9x(model) && !is_utf8)
{
while(*p)
{
unsigned long msb = *p & 0xff00;
if(!msb)
{
*q++ = *p++ & 0xff;
}
else
{
gunichar2 *str2;
glong ir, iw;
switch(*p)
{
case 0x03bc: str = "_mu_"; break;
case 0x03b1: str = "_alpha_"; break;
case 0x03b2: str = "_beta_"; break;
case 0x0393: str = "_GAMMA_"; break;
case 0x03b3: str = "_gamma_"; break;
case 0x0394: str = "_DELTA_"; break;
case 0x03b4: str = "_delta_"; break;
case 0x03b5: str = "_epsilon_";break;
case 0x03b6: str = "_zeta_"; break;
case 0x03b8: str = "_theta_"; break;
case 0x03bb: str = "_lambda_"; break;
case 0x03be: str = "_ksi_"; break;
case 0x03a0: str = "_PI_"; break;
case 0x03c0: str = "_pi_"; break;
case 0x03c1: str = "_rho_"; break;
case 0x03a3: str = "_SIGMA_"; break;
case 0x03c3: str = "_sigma_"; break;
case 0x03c4: str = "_tau_"; break;
case 0x03d5: str = "_PHI_"; break;
case 0x03a8: str = "_PSI_"; break;
case 0x03a9: str = "_OMEGA_"; break;
case 0x03c9: str = "_omega_"; break;
default: str = ""; break;
}
str2 = g_utf8_to_utf16(str, -1, &ir, &iw, NULL);
memcpy(q, str2, (iw+1) * sizeof(unsigned short));
g_free(str2);
q += iw;
p++;
}
}
*q = '\0';
}
else if(tifiles_calc_is_ti8x(model) && !is_utf8)
{
while(*p)
{
unsigned long msb = *p & 0xff00;
if(!msb)
{
*q++ = *p++ & 0xff;
}
else
{
if(*p >= 0x2080 && *p <= 0x2089)
{
*q++ = (*p++ - 0x2080) + '0';
}
else
{
gunichar2 *str2;
glong ir, iw;
switch(*p)
{
case 0x03bc: str = "_mu_"; break;
case 0x03b1: str = "_alpha_"; break;
case 0x03b2: str = "_beta_"; break;
case 0x0393: str = "_GAMMA_"; break;
case 0x03b3: str = "_gamma_"; break;
case 0x0394: str = "_DELTA_"; break;
case 0x03b4: str = "_delta_"; break;
case 0x03b5: str = "_epsilon_";break;
case 0x03b6: str = "_zeta_"; break;
case 0x03b8: str = "_theta_"; break;
case 0x03bb: str = "_lambda_"; break;
case 0x03be: str = "_ksi_"; break;
case 0x03a0: str = "_PI_"; break;
case 0x03c0: str = "_pi_"; break;
case 0x03c1: str = "_rho_"; break;
case 0x03a3: str = "_SIGMA_"; break;
case 0x03c3: str = "_sigma_"; break;
case 0x03c4: str = "_tau_"; break;
case 0x03d5: str = "_PHI_"; break;
case 0x03a8: str = "_PSI_"; break;
case 0x03a9: str = "_OMEGA_"; break;
case 0x03c9: str = "_omega_"; break;
default: str = ""; break;
}
str2 = g_utf8_to_utf16(str, -1, &ir, &iw, NULL);
memcpy(q, str2, (iw+1) * sizeof(gunichar2));
g_free(str2);
q += iw;
p++;
}
}
}
*q = '\0';
}
else
{
while(*p)
{
#ifdef __WIN32__
if(*p >= 0x2080 && *p <= 0x2089)
{
*q++ = (*p++ - 0x2080) + '0';
}
else
#endif
*q++ = *p++;
}
*q = '\0';
}
// '/' is not allowed in filenames
for(q = utf16_dst; *q; q++)
{
if(*q == '/')
*q = '_';
}
// UTF-16 to UTF-8 to GFE encoding
{
gchar *utf8;
utf8 = g_utf16_to_utf8(utf16_dst, -1, NULL, NULL, NULL);
g_free(utf16_dst);
dst = g_filename_from_utf8(utf8, -1, NULL, NULL, NULL);
g_free(utf8);
}
return dst;
}
// The main function
int main(int argc, char **argv)
{
char *msg = NULL;
char buffer[256];
int i;
int ret;
// init library
tifiles_library_init();
// test tifiles.c
printf("Library version : <%s>\n", tifiles_version_get());
printf("--\n");
// test error.c
tifiles_error_get(515, &msg);
printf("Error message: <%s>\n", msg);
#ifndef __WIN32__
free(msg);
#endif
printf("--\n");
// test type2str.c
printf("tifiles_string_to_model: <%i> <%i>\n", CALC_TI92,
tifiles_string_to_model(tifiles_model_to_string(CALC_TI92)));
printf("tifiles_string_to_attribute: <%i> <%i>\n", ATTRB_LOCKED,
tifiles_string_to_attribute(tifiles_attribute_to_string(ATTRB_LOCKED)));
printf("tifiles_string_to_class: <%i> <%i>\n", TIFILE_SINGLE,
tifiles_string_to_class(tifiles_class_to_string(TIFILE_SINGLE)));
printf("--\n");
// test filetypes.c
for(i = CALC_TI73; i <= CALC_V200; i++)
{
printf("%s (%i) ", tifiles_fext_of_group(i), i);
}
printf("\n");
for(i = CALC_TI73; i <= CALC_V200; i++)
{
printf("%s ", tifiles_fext_of_backup(i));
}
printf("\n");
for(i = CALC_TI73; i <= CALC_V200; i++)
{
printf("%s ", tifiles_fext_of_flash_os(i));
}
printf("\n");
for(i = CALC_TI73; i <= CALC_V200; i++)
{
printf("%s ", tifiles_fext_of_flash_app(i));
}
printf("\n");
printf("--\n");
printf("<%s> <%s>\n", "foo.bar", tifiles_fext_get("foo.bar"));
ret = tifiles_file_is_ti(PATH("misc/str.92s"));
printf("tifiles_file_is_ti: %i\n", ret);
ret = tifiles_file_is_single(PATH("misc/str.92s"));
printf("tifiles_file_is_single: %i\n", ret);
ret = tifiles_file_is_group(PATH("misc/group.92g"));
printf("tifiles_file_is_group: %i\n", ret);
ret = tifiles_file_is_regular(PATH("misc/str.92s"));
printf("tifiles_file_is_regular: %i\n", ret);
ret = tifiles_file_is_regular(PATH("misc/group.92g"));
printf("tifiles_file_is_regular: %i\n", ret);
ret = tifiles_file_is_backup(PATH("misc/backup.83b"));
printf("tifiles_file_is_backup: %i\n", ret);
ret = tifiles_file_is_flash(PATH("misc/ticabfra.89k"));
printf("tifiles_file_is_flash: %i\n", ret);
ret = tifiles_file_is_flash(PATH("misc/TI73_OS160.73U"));
printf("tifiles_file_is_flash: %i\n", ret);
ret = tifiles_file_is_tib(PATH("misc/ams100.tib"));
printf("tifiles_file_is_tib: %i\n", ret);
ret = tifiles_file_is_tigroup(PATH("misc/test.tig"));
printf("tifiles_file_is_tigroup: %i\n", ret);
printf("--\n");
// test typesxx.c
printf("tifiles_file_get_model: %s\n",
tifiles_model_to_string(tifiles_file_get_model(PATH("misc/str.92s"))));
printf("tifiles_file_get_class: %s\n",
tifiles_class_to_string(tifiles_file_get_class(PATH("misc/group.92g"))));
printf("tifiles_file_get_type: %s\n",
tifiles_file_get_type(PATH("misc/TI73_OS160.73U")));
printf("tifiles_file_get_icon: %s\n",
tifiles_file_get_icon(PATH("misc/str.92s")));
printf("--\n");
// test misc.c
printf("tifiles_calc_is_ti8x: %i\n", tifiles_calc_is_ti8x(CALC_TI83));
printf("tifiles_calc_is_ti9x: %i\n", tifiles_calc_is_ti9x(CALC_TI89));
printf("tifiles_has_folder: %i\n", tifiles_has_folder(CALC_TI92));
printf("tifiles_is_flash: %i\n", tifiles_is_flash(CALC_TI73));
printf("tifiles_get_varname: <%s>\n", tifiles_get_varname("fld\\var"));
printf("tifiles_get_fldname: <%s>\n", tifiles_get_fldname("fld\\var"));
tifiles_build_fullname(CALC_TI89, buffer, "fld", "var");
printf("tifiles_build_fullname: <%s>\n", buffer);
printf("--\n");
// test filesxx.c & grouped.c
do
{
// TI73 support
change_dir(PATH("ti73"));
ret = test_ti73_backup_support(); if (ret) break;
ret = test_ti73_regular_support(); if (ret) break;
ret = test_ti73_group_support(); if (ret) break;
ret = test_ti73_ungroup_support(); if (ret) break;
// TI82 support
change_dir(PATH("ti82"));
ret = test_ti82_backup_support(); if (ret) break;
ret = test_ti82_regular_support(); if (ret) break;
ret = test_ti82_group_support(); if (ret) break;
ret = test_ti82_ungroup_support(); if (ret) break;
// TI83 support
change_dir(PATH("ti83"));
ret = test_ti83_backup_support(); if (ret) break;
ret = test_ti83_regular_support(); if (ret) break;
ret = test_ti83_group_support(); if (ret) break;
ret = test_ti83_ungroup_support(); if (ret) break;
// TI84+ support
change_dir(PATH("ti84p"));
ret = test_ti84p_regular_support(); if (ret) break;
ret = test_ti84p_group_support(); if (ret) break;
ret = test_ti84p_ungroup_support(); if (ret) break;
ret = test_ti84p_flash_support(); if (ret) break;
// TI85 support
change_dir(PATH("ti85"));
ret = test_ti85_regular_support(); if (ret) break;
// TI86 support
change_dir(PATH("ti86"));
ret = test_ti86_backup_support(); if (ret) break;
ret = test_ti86_regular_support(); if (ret) break;
ret = test_ti86_group_support(); if (ret) break;
ret = test_ti86_ungroup_support(); if (ret) break;
// TI89 support
change_dir(PATH("ti89"));
ret = test_ti89_regular_support(); if (ret) break;
ret = test_ti89_flash_support(); if (ret) break;
ret = test_v200_regular_support(); if (ret) break;
// TI92 support
change_dir(PATH("ti92"));
ret = test_ti92_backup_support(); if (ret) break;
ret = test_ti92_regular_support(); if (ret) break;
ret = test_ti92_group_support(); if (ret) break;
ret = test_ti92_ungroup_support(); if (ret) break;
// TIXX certificates
change_dir(PATH("certs"));
ret = test_ti8x_cert_support(); if (ret) break;
ret = test_ti9x_cert_support(); if (ret) break;
// Add/Del files
change_dir(PATH("misc"));
ret = test_ti8x_group_merge(); if (ret) break;
change_dir(PATH("tig"));
ret = test_tigroup();
} while(0);
// end of test
tifiles_library_exit();
return ret;
}
