/** * 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; }