/**
* 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;
}
/**
* tnsp_file_read_regular:
* @filename: name of file to open.
* @content: where to store the file content.
*
* Load the file into a FileContent structure.
*
* Structure content must be freed with #tifiles_content_delete_regular when
* no longer used. If error occurs, the structure content is released for you.
*
* Return value: an error code, 0 otherwise.
**/
int tnsp_file_read_regular(const char *filename, FileContent *content)
{
FILE *f;
if (!tifiles_file_is_regular(filename))
{
return ERR_INVALID_FILE;
}
if (content == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
f = g_fopen(filename, "rb");
if (f == NULL)
{
tifiles_info( "Unable to open this file: %s", filename);
return ERR_FILE_OPEN;
}
content->model = CALC_NSPIRE;
content->model_dst = content->model;
content->entries = g_malloc0((content->num_entries + 1) * sizeof(VarEntry*));
{
VarEntry *entry = content->entries[0] = g_malloc0(sizeof(VarEntry));
gchar *basename = g_path_get_basename(filename);
gchar *ext = tifiles_fext_get(basename);
entry->type = tifiles_fext2vartype(content->model, ext);
if(ext) *(ext-1) = '\0';
strcpy(entry->folder, "");
strcpy(entry->name, basename);
g_free(basename);
entry->attr = ATTRB_NONE;
fseek(f, 0, SEEK_END);
entry->size = (uint32_t)ftell(f);
fseek(f, 0, SEEK_SET);
entry->data = (uint8_t *)g_malloc0(entry->size);
if(fread(entry->data, 1, entry->size, f) < entry->size) goto tffr;
}
content->num_entries++;
fclose(f);
return 0;
tffr: // release on exit
tifiles_critical("%s: error reading / understanding file %s", __FUNCTION__, filename);
fclose(f);
tifiles_content_delete_regular(content);
return ERR_FILE_IO;
}
/**
* tifiles_file_is_ti:
* @filename: a filename as string.
*
* Check whether file is a TI file by checking the signature.
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_file_is_ti(const char *filename)
{
// bug: check that file is not a FIFO
if (!is_regfile(filename))
return 0;
if(tifiles_file_has_ti_header(filename))
return !0;
if(tifiles_file_has_tib_header(filename))
return !0;
if(tifiles_file_has_tig_header(filename))
return !0;
if(tifiles_file_has_tno_header(filename))
return !0;
{
char *e = tifiles_fext_get(filename);
if (!strcmp(e, ""))
return 0;
if(!g_ascii_strcasecmp(e, "tns"))
return !0;
}
return 0;
}
static int tifiles_file_has_tig_header(const char *filename)
{
FILE *f;
char str[5];
char *e = tifiles_fext_get(filename);
if (!strcmp(e, ""))
return 0;
if(g_ascii_strcasecmp(e, "tig"))
return 0;
f = g_fopen(filename, "rb");
if(f == NULL)
return 0;
fread_n_chars(f, strlen(TIG_SIGNATURE), str);
str[strlen(TIG_SIGNATURE)] = '\0';
if(!strcmp(str, TIG_SIGNATURE) || !strcmp(str, TIG_SIGNATURE2))
{
fclose(f);
return !0;
}
fclose(f);
return 0;
}
/**
* tifiles_file_get_model:
* @filename: a filename as string.
*
* Returns the calculator model targetted for this file.
*
* Return value: a model taken in #CalcModel.
**/
TIEXPORT2 CalcModel TICALL tifiles_file_get_model(const char *filename)
{
char *ext = tifiles_fext_get(filename);
int type = CALC_NONE;
char str[4];
if (!strcmp(ext, ""))
return CALC_NONE;
strncpy(str, ext, 2);
str[2] = '\0';
if (!g_ascii_strcasecmp(str, "73"))
type = CALC_TI73;
else if (!g_ascii_strcasecmp(str, "82"))
type = CALC_TI82;
else if (!g_ascii_strcasecmp(str, "83"))
type = CALC_TI83;
else if (!g_ascii_strcasecmp(str, "8x"))
type = CALC_TI83P;
else if (!g_ascii_strcasecmp(str, "85"))
type = CALC_TI85;
else if (!g_ascii_strcasecmp(str, "86"))
type = CALC_TI86;
else if (!g_ascii_strcasecmp(str, "89"))
type = CALC_TI89;
else if (!g_ascii_strcasecmp(str, "92"))
type = CALC_TI92;
else if (!g_ascii_strcasecmp(str, "9X"))
type = CALC_TI92P;
else if (!g_ascii_strcasecmp(str, "V2"))
type = CALC_V200;
//else if (!g_ascii_strcasecmp(str, "tib"))
//type = CALC_TI89; // consider .tib as TI89
else if (!g_ascii_strcasecmp(str, "tn") || !g_ascii_strcasecmp(str, "tc"))
type = CALC_NSPIRE;
else
type = CALC_NONE;
return type;
}
// Recv TIGroup
TILP_EXPORT void on_tilp_button7_clicked(GtkButton* button, gpointer user_data)
{
char* src_filename;
const char *dst_filename;
const char *dst_filename2;
int ret;
int mode = TIG_ALL;
ret = backup_box(_("Backup"), _("Data to backup:"), &mode);
if(ret != BUTTON1)
return;
if (tilp_calc_recv_tigroup(mode) != 0)
return;
src_filename = g_strconcat(g_get_tmp_dir(), G_DIR_SEPARATOR_S, TMPFILE_TIGROUP, NULL);
dst_filename = create_fsel(local.cwdir, "backup", "*.tig", TRUE);
if(!dst_filename)
{
g_free(src_filename);
return;
}
if (!strcmp(tifiles_fext_get(dst_filename), ""))
dst_filename2 = g_strconcat(dst_filename, ".tig", NULL);
else
dst_filename2 = g_strdup(dst_filename);
//g_free((void *)dst_filename);
if (dst_filename2)
{
tilp_file_move_with_check(src_filename, dst_filename2);
}
g_free(src_filename);
g_free((void *)dst_filename2);
tilp_dirlist_local();
clist_refresh();
labels_refresh();
}
TIEXPORT2 int TICALL tifiles_file_has_tno_header(const char *filename)
{
FILE *f;
char str[128];
char *e = tifiles_fext_get(filename);
int ret = 0;
if (!strcmp(e, ""))
{
return ret;
}
if(g_ascii_strcasecmp(e, "tno") && g_ascii_strcasecmp(e, "tnc") && g_ascii_strcasecmp(e, "tco") && g_ascii_strcasecmp(e, "tcc"))
{
return ret;
}
f = g_fopen(filename, "rb");
if(f == NULL)
{
return ret;
}
if (fread_n_chars(f, 63, str) == 0)
{
if ( !strncmp(str, TNO_SIGNATURE, 14)
|| !strncmp(str, TNC_SIGNATURE, 14)
|| !strncmp(str, TNO_NOSAMPLES_SIGNATURE, 24)
|| !strncmp(str, TCO_SIGNATURE, 14)
|| !strncmp(str, TCC_SIGNATURE, 14)
)
{
ret = !0;
}
}
fclose(f);
return ret;
}
// Backup
TILP_EXPORT void on_tilp_button3b_clicked(GtkButton* button, gpointer user_data)
{
char* src_filename;
const char *dst_filename;
const char *dst_filename2;
char *ext;
if (tilp_calc_recv_backup() != 0)
return;
src_filename = g_strconcat(g_get_tmp_dir(), G_DIR_SEPARATOR_S, TMPFILE_BACKUP, NULL);
ext = g_strconcat("*.", tifiles_fext_of_backup(options.calc_model), NULL);
dst_filename = create_fsel(local.cwdir, "backup", ext, TRUE);
g_free(ext);
if (!dst_filename)
{
g_free(src_filename);
return;
}
if (!strcmp(tifiles_fext_get(dst_filename), ""))
dst_filename2 = g_strconcat(dst_filename, ".", tifiles_fext_of_backup(options.calc_model), NULL);
else
dst_filename2 = g_strdup(dst_filename);
//g_free((void *)dst_filename);
if (dst_filename2)
{
tilp_file_move_with_check(src_filename, dst_filename2);
}
g_free(src_filename);
g_free((void *)dst_filename2);
tilp_dirlist_local();
clist_refresh();
labels_refresh();
}
static int save_group(void)
{
char* src_filename;
const char *dst_filename;
const char *dst_filename2;
char *ext;
src_filename = g_strconcat(g_get_tmp_dir(), G_DIR_SEPARATOR_S, TMPFILE_GROUP,
".", tifiles_fext_of_group(options.calc_model), NULL);
ext = g_strconcat("*.", tifiles_fext_of_group(options.calc_model), NULL);
dst_filename = create_fsel(local.cwdir, "group", ext, TRUE);
g_free(ext);
if (!dst_filename)
{
g_free(src_filename);
return -1;
}
if (!strcmp(tifiles_fext_get(dst_filename), ""))
dst_filename2 = g_strconcat(dst_filename, ".", tifiles_fext_of_group(options.calc_model), NULL);
else
dst_filename2 = g_strdup(dst_filename);
//g_free((void *)dst_filename);
if (dst_filename2)
{
tilp_file_move_with_check(src_filename, dst_filename2);
}
g_free(src_filename);
g_free((void *)dst_filename2);
tilp_dirlist_local();
clist_refresh();
labels_refresh();
return 0;
}
TILP_EXPORT void on_rom_dump1_activate(GtkMenuItem* menuitem, gpointer user_data)
{
char* src_filename;
const char *dst_filename;
const char *dst_filename2;
char filename[128];
if (tilp_calc_rom_dump())
return;
src_filename = g_strconcat(g_get_tmp_dir(), G_DIR_SEPARATOR_S, TMPFILE_ROMDUMP, NULL);
sprintf(filename, "dump%s", tifiles_model_to_string(options.calc_model));
dst_filename = create_fsel(local.cwdir, filename, "*.rom", TRUE);
if (!dst_filename)
{
g_free(src_filename);
return;
}
if (!strcmp(tifiles_fext_get(dst_filename), ""))
dst_filename2 = g_strconcat(dst_filename, ".", "rom", NULL);
else
dst_filename2 = g_strdup(dst_filename);
//g_free((void *)dst_filename);
if (dst_filename2)
{
tilp_file_move_with_check(src_filename, dst_filename2);
}
g_free(src_filename);
g_free((void *)dst_filename2);
tilp_dirlist_local();
clist_refresh();
labels_refresh();
}
/**
* 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 "";
}
/* Preload TI variables belonging with the selection */
void tilp_local_contents_load(void)
{
GList *ptr;
int err;
// TIGroups
if (local.selection5 != NULL)
{
for(ptr = local.selection5; ptr; ptr = ptr->next)
{
FileEntry *fe5 = ptr->data;
if(tifiles_file_is_tigroup(fe5->name))
{
TigContent *content = NULL;
FileContent **p, **contents1 = NULL;
FlashContent **q, **contents2 = NULL;
content = tifiles_content_create_tigroup(options.calc_model, 0);
err = tifiles_file_read_tigroup(fe5->name, content);
if(err)
{
tilp_err(err);
continue;
}
err = tifiles_untigroup_content(content, &contents1, &contents2);
if(err)
{
tilp_err(err);
tifiles_content_delete_tigroup(content);
continue;
}
tifiles_content_delete_tigroup(content);
for(p = contents1; *p; p++)
{
FileEntry *fe1 = g_memdup(ptr->data, sizeof(FileEntry));
fe1->name = g_memdup(fe1->name, strlen(fe1->name)+1);
fe1->content1 = *p;
//g_free(fe1->name);
//fe1->name = tifiles_build_filename(options.calc_model, (*p)->entries[0]);
local.selection1 = g_list_append(local.selection1, fe1);
}
for(q = contents2; *q; q++)
{
FileEntry *fe3 = g_memdup(ptr->data, sizeof(FileEntry));
fe3->name = g_memdup(fe3->name, strlen(fe3->name)+1);
fe3->content2 = *q;
/*
{
VarEntry ve;
g_free(fe3->name);
strcpy(ve.name, (*q)->name);
ve.type = (*q)->data_type;
fe3->name = tifiles_build_filename(options.calc_model, &ve);
}*/
local.selection3 = g_list_append(local.selection3, fe3);
}
}
}
}
// Variables
if (local.selection0 != NULL)
{
for(ptr = local.selection0; ptr; ptr = ptr->next)
{
FileEntry *fe0 = ptr->data;
if(!g_ascii_strcasecmp(tifiles_fext_get(fe0->name), "8xidl"))
continue; // doesn't send this pseudo-variable
if(tifiles_file_is_single(fe0->name))
{
FileEntry *fe1 = g_memdup(ptr->data, sizeof(FileEntry));
fe1->content1 = tifiles_content_create_regular(options.calc_model);
err = tifiles_file_read_regular(fe1->name, fe1->content1);
if(err)
{
// The content is already deleted by the subroutines of tifiles_file_read_regular.
//tifiles_content_delete_regular(fe1->content1);
g_free(fe1);
continue;
}
local.selection1 = g_list_append(local.selection1, fe1);
}
else if(tifiles_file_is_group(fe0->name))
{
// explode group files so that we have 1 VarEntry per item (skip/retry/cancel)
FileContent **p, **dst = NULL;
FileContent *src = NULL;
src = tifiles_content_create_regular(options.calc_model);
err = tifiles_file_read_regular(fe0->name, src);
if(err)
{
// The content is already deleted by the subroutines of tifiles_file_read_regular.
//tifiles_content_delete_regular(src);
continue;
}
err = tifiles_ungroup_content(src, &dst);
if(err)
{
tifiles_content_delete_regular(src);
continue;
}
for(p = dst; *p; p++)
{
FileEntry *fe = g_memdup(ptr->data, sizeof(FileEntry));
fe->content1 = *p;
local.selection1 = g_list_append(local.selection1, fe);
}
tifiles_content_delete_regular(src);
}
}
}
// Applications
if(local.selection2 != NULL)
{
for(ptr = local.selection2; ptr; ptr = ptr->next)
{
FileEntry *fe2 = ptr->data;
if(tifiles_file_is_app(fe2->name) || tifiles_file_test(fe2->name, TIFILE_OS, options.calc_model))
{
FileEntry *fe3 = g_memdup(ptr->data, sizeof(FileEntry));
fe3->content2 = tifiles_content_create_flash(options.calc_model);
err = tifiles_file_read_flash(fe2->name, fe3->content2);
if(err)
{
tifiles_content_delete_flash(fe3->content2);
g_free(fe3);
continue;
}
local.selection3 = g_list_append(local.selection3, fe3);
}
}
}
// Reparse variables and change target folder
if (local.selection1)
{
// replaced "" folder by "main"
if(!tifiles_has_folder(options.calc_model))
return;
for(ptr = local.selection1; ptr; ptr = ptr->next)
{
FileEntry *fe = ptr->data;
FileContent *fc = fe->content1;
unsigned int i;
if(fc == NULL)
continue;
for(i = 0; i < fc->num_entries; i++)
{
VarEntry *ve = (fc->entries)[i];
if(!strcmp(ve->folder , ""))
strcpy(ve->folder, "main");
}
}
}
}
// 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;
}
/**
* tnsp_file_read_regular:
* @filename: name of file to open.
* @content: where to store the file content.
*
* Load the file into a FileContent structure.
*
* Structure content must be freed with #tifiles_content_delete_regular when
* no longer used. If error occurs, the structure content is released for you.
*
* Return value: an error code, 0 otherwise.
**/
int tnsp_file_read_regular(const char *filename, FileContent *content)
{
FILE *f;
int ret = ERR_FILE_IO;
if (content == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
if (!tifiles_file_is_regular(filename))
{
ret = ERR_INVALID_FILE;
goto tfrr2;
}
f = g_fopen(filename, "rb");
if (f == NULL)
{
tifiles_info( "Unable to open this file: %s", filename);
ret = ERR_FILE_OPEN;
goto tfrr2;
}
content->model = CALC_NSPIRE;
content->model_dst = content->model;
content->entries = g_malloc0((content->num_entries + 1) * sizeof(VarEntry*));
{
long cur_pos;
VarEntry *entry = content->entries[0] = g_malloc0(sizeof(VarEntry));
gchar *basename = g_path_get_basename(filename);
gchar *ext = tifiles_fext_get(basename);
entry->type = tifiles_fext2vartype(content->model, ext);
if (ext && ext[0]) *(ext-1) = '\0';
entry->folder[0] = 0;
strncpy(entry->name, basename, sizeof(entry->name) - 1);
entry->name[sizeof(entry->name) - 1] = 0;
g_free(basename);
entry->attr = ATTRB_NONE;
if (fseek(f, 0, SEEK_END) < 0) goto tfrr;
cur_pos = ftell(f);
if (cur_pos < 0) goto tfrr;
if (fseek(f, 0, SEEK_SET) < 0) goto tfrr;
// The Nspire series' members have at best 128 MB of Flash (TODO: modify this code if this no longer holds).
// Regular files larger than that size are insane.
if (cur_pos >= (128L << 20))
{
ret = ERR_INVALID_FILE;
goto tfrr;
}
entry->size = (uint32_t)cur_pos;
entry->data = (uint8_t *)g_malloc0(entry->size);
if(fread(entry->data, 1, entry->size, f) < entry->size) goto tfrr;
}
content->num_entries++;
fclose(f);
return 0;
tfrr: // release on exit
tifiles_critical("%s: error reading / understanding file %s", __FUNCTION__, filename);
fclose(f);
tfrr2:
tifiles_content_delete_regular(content);
return ret;
}
/**
* tifiles_fext_dup:
* @filename: a filename as string.
*
* Returns a copy of file extension part.
*
* Return value: a file extension without dot as string (like "89g").
* Need to be freed when no longer needed.
**/
TIEXPORT2 char *TICALL tifiles_fext_dup(const char *filename)
{
return g_strdup(tifiles_fext_get(filename));
}
// Helper function for get_dirlist, it does the bulk of the work.
static int enumerate_folder(CalcHandle* handle, GNode** vars, const char * folder_name)
{
int ret;
ticalcs_info("enumerate_folder<%s>\n", folder_name);
do
{
char varname[VARNAME_MAX];
ret = nsp_cmd_s_dir_enum_init(handle, folder_name);
if (ret)
{
break;
}
ret = nsp_cmd_r_dir_enum_init(handle);
if (ret)
{
break;
}
for (;;)
{
VarEntry *fe;
GNode *node;
char *ext;
uint32_t varsize;
uint8_t vartype;
ret = nsp_cmd_s_dir_enum_next(handle);
if (ret)
{
break;
}
ret = nsp_cmd_r_dir_enum_next(handle, varname, &varsize, &vartype);
if (ret == ERR_EOT)
{
ret = 0;
break;
}
else if (ret != 0)
{
break;
}
fe = tifiles_ve_create();
ticalcs_strlcpy(fe->folder, folder_name + 1, sizeof(fe->folder)); // Skip leading /
fe->size = varsize;
fe->type = vartype;
fe->attr = ATTRB_NONE;
ext = tifiles_fext_get(varname);
// Just a sanity check
if (ext)
{
// Did the file name have any non-empty extension ?
if (*ext)
{
// Do we know about this file type ?
if (fe->type < NSP_MAXTYPES)
{
// Then we can remove the exension.
*(ext-1) = '\0';
}
// else don't remove the extension.
}
// else there is no extension to remove.
}
ticalcs_strlcpy(fe->name, varname, sizeof(fe->name));
node = dirlist_create_append_node(fe, vars);
if (!node)
{
ret = ERR_MALLOC;
break;
}
ticalcs_info(_("Name: %s | Type: %8s | Attr: %i | Size: %08X"),
fe->name,
tifiles_vartype2string(handle->model, fe->type),
fe->attr,
fe->size);
}
while (!ret)
{
int i;
ret = nsp_cmd_s_dir_enum_done(handle);
if (ret)
{
break;
}
ret = nsp_cmd_r_dir_enum_done(handle);
if (ret)
{
break;
}
// Enumerate elements of root folder.
for (i = 0; i < (int)g_node_n_children(*vars); i++)
{
char new_folder_name[FLDNAME_MAX];
const char * separator_if_any;
GNode * folder = g_node_nth_child(*vars, i);
uint8_t vartype = ((VarEntry *)(folder->data))->type;
// Don't recurse into regular files (type 0, TNS or e.g. themes.csv on OS 3.0+).
if (vartype == 0)
{
ticalcs_info(_("Not enumerating documents in %s because it's not a folder\n"), ((VarEntry *)(folder->data))->name);
continue;
}
// Prevent names from starting with "//".
if (strcmp(folder_name, "/"))
{
separator_if_any = "/";
}
else
{
separator_if_any = "";
}
ticalcs_slprintf(new_folder_name, sizeof(new_folder_name), "%s%s%s", folder_name, separator_if_any, ((VarEntry *)(folder->data))->name);
ticalcs_info(_("Directory listing in <%s>...\n"), new_folder_name);
ret = enumerate_folder(handle, &folder, new_folder_name);
if (ret)
{
break;
}
}
break;
}
} while (0);
return ret;
}
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps)
{
TreeInfo *ti;
int err;
GNode *root, *folder = NULL;
char varname[VARNAME_MAX];
uint32_t varsize;
uint8_t vartype;
int i;
(*apps) = g_node_new(NULL);
ti = (TreeInfo *)g_malloc(sizeof(TreeInfo));
ti->model = handle->model;
ti->type = APP_NODE_NAME;
(*apps)->data = ti;
(*vars) = g_node_new(NULL);
ti = (TreeInfo *)g_malloc(sizeof(TreeInfo));
ti->model = handle->model;
ti->type = VAR_NODE_NAME;
(*vars)->data = ti;
root = g_node_new(NULL);
g_node_append(*apps, root);
TRYF(nsp_session_open(handle, SID_FILE_MGMT));
TRYF(nsp_cmd_s_dir_attributes(handle, "/"));
TRYF(nsp_cmd_r_dir_attributes(handle, NULL, NULL, NULL));
TRYF(nsp_session_close(handle));
TRYF(nsp_session_open(handle, SID_FILE_MGMT));
TRYF(nsp_cmd_s_dir_enum_init(handle, "/"));
TRYF(nsp_cmd_r_dir_enum_init(handle));
for(;;)
{
VarEntry *fe;
GNode *node;
TRYF(nsp_cmd_s_dir_enum_next(handle));
err = nsp_cmd_r_dir_enum_next(handle, varname, &varsize, &vartype);
if (err == ERR_EOT)
break;
else if (err != 0)
return err;
fe = tifiles_ve_create();
strcpy(fe->folder, varname);
strcpy(fe->name, varname);
fe->size = varsize;
fe->type = vartype;
fe->attr = ATTRB_NONE;
node = g_node_new(fe);
folder = g_node_append(*vars, node);
ticalcs_info(_("Name: %s | Type: %8s | Attr: %i | Size: %08X"),
fe->name,
tifiles_vartype2string(handle->model, fe->type),
fe->attr,
fe->size);
}
TRYF(nsp_cmd_s_dir_enum_done(handle));
TRYF(nsp_cmd_r_dir_enum_done(handle));
for(i = 0; i < (int)g_node_n_children(*vars); i++)
{
char *folder_name;
char *u1, *u2;
folder = g_node_nth_child(*vars, i);
folder_name = ((VarEntry *) (folder->data))->name;
vartype = ((VarEntry *) (folder->data))->type;
// Skip entries whose type is 0 (TNS), for example themes.csv on OS 3.0+.
if (vartype == 0)
{
ticalcs_info(_("Not enumerating documents in %s because it's not a folder"), folder_name);
continue;
}
ticalcs_info(_("Directory listing in <%s>..."), folder_name);
TRYF(nsp_cmd_s_dir_enum_init(handle, folder_name));
TRYF(nsp_cmd_r_dir_enum_init(handle));
for(;;)
{
VarEntry *ve = tifiles_ve_create();
GNode *node;
char *ext;
TRYF(nsp_cmd_s_dir_enum_next(handle));
err = nsp_cmd_r_dir_enum_next(handle, varname, &varsize, &vartype);
if (err == ERR_EOT)
break;
else if (err != 0)
return err;
ext = tifiles_fext_get(varname);
strcpy(ve->folder, folder_name);
ve->size = varsize;
ve->type = tifiles_fext2vartype(handle->model, ext);
ve->attr = ATTRB_NONE;
// Just a sanity check
if (ext)
{
// Did the file name have any non-empty extension ?
if (*ext)
{
// Do we know about this file type ?
if (ve->type < NSP_MAXTYPES)
{
// Then we can remove the exension.
*(ext-1) = '\0';
}
// else don't remove the extension.
}
// else there is no extension to remove.
}
strcpy(ve->name, varname);
node = g_node_new(ve);
g_node_append(folder, node);
ticalcs_info(_("Name: %8s | Type: %8s | Attr: %i | Size: %08X"),
ve->name,
tifiles_vartype2string(handle->model, ve->type),
ve->attr,
ve->size);
u1 = ticonv_varname_to_utf8(handle->model, ((VarEntry *) (folder->data))->name, -1);
u2 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type);
g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s/%s"), u1, u2);
g_free(u1); g_free(u2);
update_label();
}
TRYF(nsp_cmd_s_dir_enum_done(handle));
TRYF(nsp_cmd_r_dir_enum_done(handle));
}
TRYF(nsp_session_close(handle));
return 0;
}
