/**
* tifiles_file_is_os:
* @filename: a filename as string.
*
* Check whether file is a FLASH OS file (tib or XXu)
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_file_is_os(const char *filename)
{
int i;
char *e = tifiles_fext_get(filename);
if (!strcmp(e, ""))
return 0;
if (!tifiles_file_is_ti(filename))
return 0;
if(tifiles_file_is_tib(filename))
return !0;
if(tifiles_file_is_tno(filename))
return !0;
for (i = 1; i < CALC_MAX + 1; i++)
{
if (!g_ascii_strcasecmp(e, FLASH_OS_FILE_EXT[i]))
return !0;
}
return 0;
}
/**
* tifiles_file_is_regular:
* @filename: a filename as string.
*
* Check whether file is a single or group file.
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_file_is_regular(const char *filename)
{
if (!tifiles_file_is_ti(filename))
return 0;
return (tifiles_file_is_single(filename) ||
tifiles_file_is_group(filename));
}
/**
* tifiles_file_is_single:
* @filename: a filename as string.
*
* Check whether file is a single TI file (like program, function, ...).
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_file_is_single(const char *filename)
{
if (!tifiles_file_is_ti(filename))
return 0;
if (!tifiles_file_is_group(filename) &&
!tifiles_file_is_backup(filename) &&
!tifiles_file_is_flash(filename) &&
!tifiles_file_is_tigroup(filename))
return !0;
return 0;
}
gint display_debug_dbox(void)
{
const gchar *filename;
const gchar *ext;
static gchar *folder = NULL;
// set mask
switch(tihw.calc_type)
{
case TI92:
ext = "*.92?";
break;
default:
ext = "*.89?;*.92?;*.9x?;*.v2?";
break;
}
// get filename
if(folder == NULL)
folder = g_strdup(inst_paths.base_dir);
filename = (char *)create_fsel(folder, NULL, (char *)ext, FALSE);
if (!filename)
{
return 0;
}
// keep folder
g_free(folder);
folder = g_path_get_dirname(filename);
// check extension
if(!tifiles_file_is_ti(filename) ||
!tifiles_calc_is_ti9x(tifiles_file_get_model(filename)))
{
msg_box1(_("Error"), _("This file is not a valid TI file."));
return -1;
}
fs_send_file_and_debug_info(filename);
return 0;
}
GLADE_CB void
qs_filechooserbutton1_current_folder_changed
(GtkFileChooser *filechooser,
gpointer user_data)
{
gchar *fname = gtk_file_chooser_get_filename (filechooser);
if(!fname)
return;
if(!tifiles_file_is_ti(fname) || !tifiles_calc_is_ti9x(tifiles_file_get_model(fname)) ||
!tifiles_file_test(fname, TIFILE_REGULAR, CALC_NONE))
{
g_free(tmp_file); tmp_file = NULL;
msg_box1(_("Error"), _("This file is not a valid TI file."));
return;
}
g_free(tmp_file);
tmp_file = g_strdup(fname); // dup or copy???
}
int fs_send_files(gchar **filenames)
{
gchar **ptr;
int i, l;
// check extension and send
for(ptr = filenames, l = 0; *ptr; ptr++, l++);
for(ptr = filenames, i = 0; *ptr; ptr++, i++)
{
if(!tifiles_file_is_ti(*ptr) || (!tifiles_calc_is_ti9x(tifiles_file_get_model(*ptr)) &&
!tifiles_file_is_tigroup(*ptr)))
{
msg_box1(_("Error"), _("This file is not a valid TI file."));
g_strfreev(filenames);
return -1;
}
fs_send_file(*ptr);
}
return 0;
}
/**
* tifiles_file_test:
* @filename: a filename as string.
* @type: type to check
* @target: hand-held model or CALC_NONE for no filtering
*
* Check whether #filename is a TI file of type #type useable on a #target model.
* This function is a generic one which overwrap and extends the tifiles_file_is_*
* functions.
*
* This is a powerful function which allows checking of a specific file type for
* a given target.
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_file_test(const char *filename, FileClass type, CalcModel target)
{
char *e = tifiles_fext_get(filename);
if (!tifiles_file_is_ti(filename))
return 0;
if (!strcmp(e, ""))
return 0;
if(target > CALC_MAX)
{
tifiles_critical("tifiles_file_test: invalid target argument! This is a bug.");
return 0;
}
if(type & TIFILE_SINGLE)
{
if(target && !g_ascii_strncasecmp(e, GROUP_FILE_EXT[target], 2))
return !0;
else
return tifiles_file_is_single(filename);
}
if(type & TIFILE_GROUP)
{
if(target && !g_ascii_strcasecmp(e, GROUP_FILE_EXT[target]))
return !0;
else
return tifiles_file_is_group(filename);
}
if(type & TIFILE_REGULAR)
{
return tifiles_file_test(filename, TIFILE_SINGLE, target) ||
tifiles_file_test(filename, TIFILE_GROUP, target);
}
if(type & TIFILE_BACKUP)
{
if(target && !g_ascii_strcasecmp(e, BACKUP_FILE_EXT[target]))
return !0;
else
return tifiles_file_is_backup(filename);
}
if(type & TIFILE_OS)
{
if(target && !g_ascii_strcasecmp(e, FLASH_OS_FILE_EXT[target]))
return !0;
else if(target && tifiles_file_is_tib(filename))
{
FILE *f;
uint8_t data[16];
f = g_fopen(filename, "rb");
if(f == NULL)
return 0;
fread_n_chars(f, 16, (char *)data);
fclose(f);
switch(data[8])
{
case 1: if(target != CALC_TI92P) return 0;
case 3: if(target != CALC_TI89) return 0;
case 8: if(target != CALC_V200) return 0;
case 9: if(target != CALC_TI89T) return 0;
}
return !0;
}
else
return tifiles_file_is_os(filename);
}
if(type & TIFILE_APP)
{
if(target && !g_ascii_strcasecmp(e, FLASH_APP_FILE_EXT[target]))
return !0;
else
return tifiles_file_is_app(filename);
}
if(type & TIFILE_FLASH)
{
return tifiles_file_test(filename, TIFILE_OS, target) ||
tifiles_file_test(filename, TIFILE_APP, target);
}
if(type & TIFILE_TIGROUP)
{
if(target)
{
// No easy/light way for this part: we have to load the whole file
// and to parse the TigEntry structures.
TigContent *content;
int ret, ok=0;
int k;
if(!tifiles_file_has_tig_header(filename))
return 0;
content = tifiles_content_create_tigroup(CALC_NONE, 0);
ret = tifiles_file_read_tigroup(filename, content);
if(ret) return 0;
for (k = 0; k < content->n_apps; k++)
{
TigEntry *te = content->app_entries[k];
if(tifiles_calc_are_compat(te->content.regular->model, target))
ok++;
}
for (k = 0; k < content->n_vars; k++)
{
TigEntry *te = content->var_entries[k];
if(tifiles_calc_are_compat(te->content.regular->model, target))
ok++;
}
tifiles_content_delete_tigroup(content);
return ok;
}
else
return tifiles_file_is_tigroup(filename);
}
return 0;
}
/**
* tifiles_file_get_icon:
* @filename: a filename as string.
*
* Returns the type of file (function, program, ...).
*
* Return value: a string like "Assembly Program" (non localized).
**/
TIEXPORT2 const char *TICALL tifiles_file_get_icon(const char *filename)
{
char *ext;
ext = tifiles_fext_get(filename);
if (!strcmp(ext, ""))
return "";
if (!g_ascii_strcasecmp(ext, "tib"))
return "OS upgrade";
if (!g_ascii_strcasecmp(ext, "tno") || !g_ascii_strcasecmp(ext, "tnc") || !g_ascii_strcasecmp(ext, "tco") || !g_ascii_strcasecmp(ext, "tcc"))
return "OS upgrade";
if (!tifiles_file_is_ti(filename))
return "";
if(tifiles_file_is_tigroup(filename))
return "TiGroup";
if (tifiles_file_is_group(filename))
{
switch (tifiles_file_get_model(filename))
{
case CALC_TI89:
case CALC_TI89T:
case CALC_TI89T_USB:
case CALC_TI92P:
case CALC_V200:
return "Group/Backup";
default:
return "Group";
}
}
switch (tifiles_file_get_model(filename))
{
#ifndef DISABLE_TI8X
case CALC_TI73:
return ti73_byte2icon(ti73_fext2byte(ext));
case CALC_TI82:
return ti82_byte2icon(ti82_fext2byte(ext));
case CALC_TI83:
return ti83_byte2icon(ti83_fext2byte(ext));
case CALC_TI83P:
case CALC_TI84P:
case CALC_TI84P_USB:
return ti83p_byte2icon(ti83p_fext2byte(ext));
case CALC_TI85:
return ti85_byte2icon(ti85_fext2byte(ext));
case CALC_TI86:
return ti86_byte2icon(ti86_fext2byte(ext));
#endif
#ifndef DISABLE_TI9X
case CALC_TI89:
case CALC_TI89T:
case CALC_TI89T_USB:
return ti89_byte2icon(ti89_fext2byte(ext));
case CALC_TI92:
return ti92_byte2icon(ti92_fext2byte(ext));
case CALC_TI92P:
return ti92p_byte2icon(ti92p_fext2byte(ext));
case CALC_V200:
return v200_byte2icon(v200_fext2byte(ext));
#endif
case CALC_NSPIRE:
return nsp_byte2icon(nsp_fext2byte(ext));
case CALC_NONE:
default:
return "";
break;
}
return "";
}
// 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;
}
/*
Get some information on the FLASH upgrade:
- size
- ROM base address
- os version
- calc type
*/
int ti68k_get_tib_infos(const char *filename, IMG_INFO *tib, int preload)
{
FlashContent *content;
FlashContent *ptr;
int nheaders = 0;
int i;
// No filename, exits
if(!strcmp(g_basename(filename), ""))
return ERR_CANT_OPEN;
// Check valid file
if(!tifiles_file_is_ti(filename))
return ERR_NOT_TI_FILE;
if(!tifiles_file_is_os(filename))
return ERR_INVALID_UPGRADE;
// Load file
content = tifiles_content_create_flash(CALC_TI89);
if(tifiles_file_read_flash(filename, content) != 0)
return ERR_INVALID_UPGRADE;
// count headers
for (ptr = content; ptr != NULL; ptr = ptr->next)
nheaders++;
// keep the last one (data)
for (i = 0, ptr = content; i < nheaders - 1; i++)
ptr = ptr->next;
// Load TIB into memory and relocate at SPP
if(tib->data == NULL)
tib->data = malloc(SPP + ptr->data_length + 4);
if(tib->data == NULL)
return ERR_MALLOC;
memset(tib->data + SPP, 0xff, ptr->data_length);
memcpy(tib->data + SPP, ptr->data_part, ptr->data_length);
// Update current rom infos
tib->rom_base = tib->data[BO+5 + SPP] & 0xf0;
// libtifiles can't distinguish TI89/TI89t and 92+/V200. We need to look.
switch(ptr->device_type & 0xff)
{
case DEVICE_TYPE_89: // can be a Titanium, too
switch(tib->rom_base & 0xff)
{
case 0x20: tib->calc_type = TI89; break;
case 0x80: tib->calc_type = TI89t; break;
default: return ERR_INVALID_UPGRADE;
}
break;
case DEVICE_TYPE_92P:
switch(tib->rom_base & 0xff)
{
case 0x20: tib->calc_type = V200; break;
case 0x40: tib->calc_type = TI92p; break;
default: return ERR_INVALID_UPGRADE;
}
break;
default:
tiemu_info("TIB problem: %02x!\n", 0xff & ptr->device_type);
return ERR_INVALID_UPGRADE;
break;
}
tib->flash = FLASH_ROM;
tib->has_boot = 0;
tib->size = ptr->data_length + SPP;
get_rom_version(tib->data, tib->size, tib->version);
tifiles_content_delete_flash(content);
if(!preload)
free(tib->data);
return 0;
}
/**
* tifiles_group_files:
* @src_filenames: a NULL-terminated array of strings (list of files to group).
* @dst_filename: the filename where to store the group.
*
* Group several TI files into a single one (group file).
*
* Return value: an error code if unsuccessful, 0 otherwise.
**/
TIEXPORT2 int TICALL tifiles_group_files(char **src_filenames, const char *dst_filename)
{
int i, n;
FileContent **src = NULL;
FileContent *dst = NULL;
int ret = 0;
if (src_filenames == NULL || dst_filename == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
// count number of files to group, while performing several checks
for (n = 0; src_filenames[n] != NULL; n++)
{
if (!tifiles_file_is_ti(src_filenames[n]))
{
return ERR_INVALID_FILE;
}
if (tifiles_file_get_model(src_filenames[n]) == CALC_NSPIRE)
{
return ERR_BAD_CALC;
}
}
// allocate space for that
src = (FileContent **)g_malloc0((n + 1) * sizeof(FileContent *));
if (src == NULL)
{
return ERR_MALLOC;
}
// allocate each structure and load file content
for (i = 0; i < n; i++)
{
src[i] = (FileContent *)g_malloc0(sizeof(FileContent));
if (src[i] == NULL)
{
ret = ERR_MALLOC;
goto tgf2;
}
ret = tifiles_file_read_regular(src_filenames[i], src[i]);
if(ret)
{
goto tgf2;
}
}
src[i] = NULL;
// group the array of structures
ret = tifiles_group_contents(src, &dst);
if(ret)
{
goto tgf;
}
// write grouped file
ret = tifiles_file_write_regular(dst_filename, dst, NULL);
if(ret)
{
goto tgf;
}
ret = 0;
// release allocated memory
tgf:
tifiles_content_delete_regular(dst);
tgf2:
tifiles_content_delete_group(src);
return ret;
}
