export.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720
  1. /* export.c: Routines for file exports
  2. Copyright (C) 2002-2004 Sebastian Reichelt
  3. Copyright (C) 2003-2007 Kevin Kofler
  4. Copyright (C) 2004 Billy Charvet
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2, or (at your option)
  8. any later version.
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. GNU General Public License for more details.
  13. You should have received a copy of the GNU General Public License
  14. along with this program; if not, write to the Free Software Foundation,
  15. Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
  16. #include "export.h"
  17. #ifdef TIOS_SUPPORT
  18. #include "exp_tios.h"
  19. #endif /* TIOS_SUPPORT */
  20. #ifdef FLASH_OS_SUPPORT
  21. #include "exp_os.h"
  22. #endif /* FLASH_OS_SUPPORT */
  23. #ifdef NOSTUB_DLL_SUPPORT
  24. #include "exp_ndll.h"
  25. #endif /* NOSTUB_DLL_SUPPORT */
  26. #ifdef FARGO_SUPPORT
  27. #include "exp_farg.h"
  28. #endif /* FARGO_SUPPORT */
  29. #ifdef DATA_VAR_SUPPORT
  30. #include "exp_data.h"
  31. #endif /* DATA_VAR_SUPPORT */
  32. #ifdef DEBUGGING_INFO_SUPPORT
  33. #include "exp_dbg.h"
  34. #endif /* DEBUGGING_INFO_SUPPORT */
  35. #include "../formats/tios.h"
  36. #include "../formats/tiosupgd.h"
  37. #include "../special.h"
  38. #include <string.h>
  39. typedef struct {
  40. OUTPUT_FILE_FUNCTION GetOutputFile;
  41. OUTPUT_FILE_FINALIZE_FUNCTION FinalizeOutputFile;
  42. GET_FILE_SIZE_FUNCTION GetFileSize;
  43. EXPORT_FILE_FUNCTION ExportFile, ExportDataFile;
  44. FileFormats FileFormat, DataFileFormat;
  45. unsigned int FileType, DataFileType;
  46. const char *Extension;
  47. } EXPORT_STRUCT;
  48. // Return the maximum file size allowed for a given format
  49. // (without header and footer).
  50. static SIZE GetMaxFileSize (FileFormats FileFormat, ProgramCalcs Calc)
  51. {
  52. switch (FileFormat)
  53. {
  54. case FF_TIOS:
  55. return MAX_TIOS_FILE_SIZE;
  56. case FF_TIOS_UPGRADE:
  57. if (Calc == CALC_V200 || (Calc == (CALC_TI89 | CALC_FLAG_TITANIUM)))
  58. return MAX_TIOS_UPGRADE_FILE_SIZE_NEW;
  59. else
  60. return MAX_TIOS_UPGRADE_FILE_SIZE_OLD;
  61. default:
  62. return 0;
  63. }
  64. }
  65. // Export the internal data structures to an external file for the given
  66. // calculator.
  67. static BOOLEAN ExportProgramToFormat (const PROGRAM *Program, const EXPORT_STRUCT *ExportStruct, ProgramCalcs Calc)
  68. {
  69. BOOLEAN Success;
  70. EXP_FILE File;
  71. SIZE Size, MaxSize;
  72. I4 EffectiveSize = 0;
  73. // Fill the output file struct with zeroes.
  74. memset (&File, 0, sizeof (File));
  75. // Get the file size needed to export the file.
  76. Size = ExportStruct->GetFileSize (Program);
  77. // A size of 0 indicates an error.
  78. if (Size <= 0)
  79. return FALSE;
  80. // Check for maximum file size.
  81. MaxSize = GetMaxFileSize (ExportStruct->FileFormat, Calc);
  82. if (Size > MaxSize)
  83. {
  84. Error (NULL, "Program size of %ld bytes exceeds maximum by %ld.", (long) Size, (long) (Size - MaxSize));
  85. return FALSE;
  86. }
  87. // Create an output file with the specified format.
  88. if (!(ExportStruct->GetOutputFile (&(File.File), Size, Calc, FR_MAIN, ExportStruct->FileFormat, ExportStruct->FileType, ExportStruct->Extension, !(Program->Library), &EffectiveSize)))
  89. return FALSE;
  90. // Export the program into the output file.
  91. Success = ExportStruct->ExportFile (Program, &File, Size, Calc);
  92. // Finalize and close the output file.
  93. if (ExportStruct->FinalizeOutputFile)
  94. ExportStruct->FinalizeOutputFile (&(File.File));
  95. if (Success)
  96. {
  97. if (Program->OptimizeInfo->ProgramSize < (SI4) EffectiveSize)
  98. Program->OptimizeInfo->ProgramSize = (SI4) EffectiveSize;
  99. }
  100. else
  101. return FALSE;
  102. #ifdef DATA_VAR_SUPPORT
  103. // Write the data file, if any.
  104. if (Program->DataVarInfo->Name && Program->DataSection)
  105. {
  106. if (ExportStruct->DataFileFormat == FF_NONE)
  107. {
  108. Error (NULL, "Data variable is not supported in this file format.");
  109. return FALSE;
  110. }
  111. // Fill the output file struct with zeroes.
  112. memset (&File, 0, sizeof (File));
  113. // Get the file size needed to export the file.
  114. Size = GetDataFileSize (Program);
  115. // A size of 0 indicates an error.
  116. if (Size <= 0)
  117. return FALSE;
  118. MaxSize = GetMaxFileSize (ExportStruct->DataFileFormat, Calc);
  119. // Check for maximum file size.
  120. if (Size > MaxSize)
  121. {
  122. Error (NULL, "Data variable size of %ld bytes exceeds maximum by %ld.", (long) Size, (long) (MaxSize - Size));
  123. return FALSE;
  124. }
  125. // Create an output file with the specified format.
  126. if (!(ExportStruct->GetOutputFile (&(File.File), Size, Calc, FR_DATA, ExportStruct->DataFileFormat, ExportStruct->DataFileType, "DAT", FALSE, &EffectiveSize)))
  127. return FALSE;
  128. // Export the program into the output file.
  129. Success = ExportStruct->ExportDataFile (Program, &File, Size, Calc);
  130. // Finalize and close the output file.
  131. if (ExportStruct->FinalizeOutputFile)
  132. ExportStruct->FinalizeOutputFile (&(File.File));
  133. if (Success)
  134. {
  135. if (Program->OptimizeInfo->DataSize < (SI4) EffectiveSize)
  136. Program->OptimizeInfo->DataSize = (SI4) EffectiveSize;
  137. }
  138. else
  139. return FALSE;
  140. }
  141. #endif /* DATA_VAR_SUPPORT */
  142. return TRUE;
  143. }
  144. #ifdef PUCRUNCH_SUPPORT
  145. // Specifies whether to pack the main file with pucrunch.
  146. BOOLEAN Pack = FALSE;
  147. #endif /* PUCRUNCH_SUPPORT */
  148. // Export the internal data structures to external files, creating as many
  149. // files as needed.
  150. BOOLEAN ExportProgram (const PROGRAM *Program, OUTPUT_FILE_FUNCTION GetOutputFile, OUTPUT_FILE_FINALIZE_FUNCTION FinalizeOutputFile)
  151. {
  152. EXPORT_STRUCT ExportStruct = {GetOutputFile, FinalizeOutputFile, NULL, NULL, NULL, FF_TIOS, FF_TIOS, TIOS_TAG_ASM, TIOS_TAG_OTH, NULL};
  153. if (!GetOutputFile)
  154. return FALSE;
  155. #ifdef DEBUGGING_INFO_SUPPORT
  156. // If we have debugging information to export, do it.
  157. if (Program->HaveDebuggingInfo)
  158. {
  159. if (!ExportDebuggingInfo (Program, GetOutputFile, FinalizeOutputFile))
  160. return FALSE;
  161. }
  162. #endif
  163. switch (Program->Type)
  164. {
  165. #ifdef FLASH_OS_SUPPORT
  166. case PT_FLASH_OS:
  167. ExportStruct.GetFileSize = GetFlashOSFileSize;
  168. ExportStruct.ExportFile = ExportFlashOSFile;
  169. ExportStruct.FileFormat = FF_TIOS_UPGRADE;
  170. ExportStruct.FileType = 0; // Different types for Flash OSs do not exist.
  171. ExportStruct.DataFileFormat = FF_NONE;
  172. ExportStruct.DataFileType = 0;
  173. break;
  174. #endif /* FLASH_OS_SUPPORT */
  175. #ifdef NOSTUB_DLL_SUPPORT
  176. case PT_NOSTUB_DLL:
  177. ExportStruct.GetFileSize = GetNostubDLLFileSize;
  178. ExportStruct.ExportFile = ExportNostubDLLFile;
  179. ExportStruct.FileType = TIOS_TAG_OTH;
  180. ExportStruct.Extension = "DLL";
  181. break;
  182. #endif /* NOSTUB_DLL_SUPPORT */
  183. #ifdef FARGO_SUPPORT
  184. case PT_FARGO:
  185. ExportStruct.GetFileSize = GetFargoFileSize;
  186. ExportStruct.ExportFile = ExportFargoFile;
  187. ExportStruct.FileType = TIOS_TAG_PRGM;
  188. break;
  189. #endif /* FARGO_SUPPORT */
  190. default:
  191. #ifdef TIOS_SUPPORT
  192. ExportStruct.GetFileSize = GetTIOSFileSize;
  193. ExportStruct.ExportFile = ExportTIOSFile;
  194. #ifdef PUCRUNCH_SUPPORT
  195. if (Pack)
  196. {
  197. ExportStruct.ExportFile = ExportPackedTIOSFile;
  198. ExportStruct.FileType = TIOS_TAG_OTH;
  199. ExportStruct.Extension = "ppg";
  200. }
  201. #endif /* !PUCRUNCH_SUPPORT */
  202. #else /* !TIOS_SUPPORT */
  203. Error (NULL, "No default export target for this program type.");
  204. return FALSE;
  205. #endif /* !TIOS_SUPPORT */
  206. }
  207. #ifdef DATA_VAR_SUPPORT
  208. ExportStruct.ExportDataFile = ExportDataFile;
  209. #endif /* DATA_VAR_SUPPORT */
  210. {
  211. ProgramCalcs CurCalc;
  212. // For all calculators...
  213. for (CurCalc = 1; CurCalc <= HIGHEST_CALC; CurCalc <<= 1)
  214. {
  215. if (Program->Calcs & CurCalc)
  216. {
  217. if (!(ExportProgramToFormat (Program, &ExportStruct, CurCalc)))
  218. return FALSE;
  219. if (Program->Type == PT_FLASH_OS && CurCalc == CALC_TI89 && (Program->Calcs & CALC_FLAG_TITANIUM))
  220. {
  221. if (!(ExportProgramToFormat (Program, &ExportStruct, CurCalc | CALC_FLAG_TITANIUM)))
  222. return FALSE;
  223. }
  224. }
  225. }
  226. }
  227. Program->OptimizeInfo->RelocCount += Program->OptimizeInfo->NativeRelocCount;
  228. return TRUE;
  229. }
  230. // Non-embedded file output functions as defined in intrface.h.
  231. #ifndef TARGET_EMBEDDED
  232. #include <stdio.h>
  233. // Destination file name without extension.
  234. const char *DestFile = NULL;
  235. SIZE DestFileSize = 0;
  236. // Folder and variable name for main file.
  237. char ProgramFolder[MAX_NAME_LEN+1] = "main", ProgramName[MAX_NAME_LEN+1] = "program";
  238. #ifdef DATA_VAR_SUPPORT
  239. // Destination file name without extension for the data file.
  240. // If NULL, a default name is picked (either DestFile or DestFile+"-data").
  241. const char *DestDataFile = NULL;
  242. SIZE DestDataFileSize = 0;
  243. // Folder and variable name for data file.
  244. char DataFolder[MAX_NAME_LEN+1] = "", DataName[MAX_NAME_LEN+1] = "data";
  245. #endif /* DATA_VAR_SUPPORT */
  246. // Specifies whether to output only the binary image of the program.
  247. BOOLEAN OutputBin = FALSE;
  248. // Specifies whether to output only the binary image of the main file.
  249. BOOLEAN OutputBinMainOnly = FALSE;
  250. // Maximum length of a file extension.
  251. #define MAX_FILE_EXT_LEN 3
  252. BOOLEAN GetOutputFile (INT_EXP_FILE *File, SIZE FileSize, unsigned int DestCalc, unsigned int FileRole, unsigned int FileFormat, unsigned int FileType, const char *Extension, BOOLEAN Executable ATTRIBUTE_UNUSED, I4 *EffectiveSize)
  253. {
  254. // Keep some of the parameters for finalization.
  255. File->OutputBin = OutputBin || (OutputBinMainOnly && FileRole == FR_MAIN);
  256. File->FileFormat = FileFormat;
  257. File->FileType = FileType;
  258. File->Extension = Extension;
  259. // Determine the destination file format and act accordingly.
  260. switch (FileFormat)
  261. {
  262. #ifdef TIOS_FILE_SUPPORT
  263. case FF_TIOS:
  264. {
  265. const char *FolderName, *VarName;
  266. const char *FileExtCalc, *FileExtType;
  267. unsigned int LinkType;
  268. // Calculate the size needed for the two size bytes and the
  269. // tag.
  270. SIZE VarFileSize = 2 + FileSize + 1;
  271. // If the file has an extension, add the size needed for it.
  272. #ifdef PUCRUNCH_SUPPORT
  273. if (!Pack || FileRole != FR_MAIN)
  274. #endif /* !PUCRUNCH_SUPPORT */
  275. if (Extension)
  276. VarFileSize += 1 + strlen (Extension) + 1;
  277. // The variable size is what the user will see.
  278. *EffectiveSize = VarFileSize;
  279. // Determine the role of the file and set the folder and
  280. // variable names according to the user settings.
  281. switch (FileRole)
  282. {
  283. case FR_MAIN:
  284. FolderName = ProgramFolder;
  285. VarName = ProgramName;
  286. break;
  287. #ifdef DATA_VAR_SUPPORT
  288. case FR_DATA:
  289. if (*DataFolder)
  290. FolderName = DataFolder;
  291. else
  292. FolderName = ProgramFolder;
  293. VarName = DataName;
  294. break;
  295. #endif /* DATA_VAR_SUPPORT */
  296. default:
  297. Error (NULL, "Unknown file role.");
  298. return FALSE;
  299. }
  300. // Determine the destination calculator and set part of the
  301. // file extension.
  302. switch (DestCalc)
  303. {
  304. case CALC_TI92:
  305. FileExtCalc = "92";
  306. break;
  307. case CALC_TI89:
  308. FileExtCalc = "89";
  309. break;
  310. case CALC_TI92PLUS:
  311. FileExtCalc = "9x";
  312. break;
  313. case CALC_V200:
  314. FileExtCalc = "v2";
  315. break;
  316. default:
  317. Error (NULL, "Unknown calculator.");
  318. return FALSE;
  319. }
  320. // Determine the file type and set the other part of the file
  321. // extension.
  322. switch (FileType)
  323. {
  324. case TIOS_TAG_STR:
  325. FileExtType = "s";
  326. LinkType = TIOS_LINK_TYPE_STR;
  327. break;
  328. case TIOS_TAG_PRGM:
  329. FileExtType = "p";
  330. LinkType = TIOS_LINK_TYPE_PRGM;
  331. break;
  332. case TIOS_TAG_ASM:
  333. FileExtType = "z";
  334. LinkType = TIOS_LINK_TYPE_ASM;
  335. break;
  336. case TIOS_TAG_OTH:
  337. FileExtType = "y";
  338. LinkType = TIOS_LINK_TYPE_OTH;
  339. break;
  340. default:
  341. Error (NULL, "Unknown file type.");
  342. return FALSE;
  343. }
  344. {
  345. SIZE FileNameSize = DestFileSize;
  346. const char *DestFileName = DestFile;
  347. #ifdef DATA_VAR_SUPPORT
  348. if (FileRole == FR_DATA && DestDataFile)
  349. {
  350. FileNameSize = DestDataFileSize;
  351. DestFileName = DestDataFile;
  352. }
  353. #endif /* DATA_VAR_SUPPORT */
  354. // Create a temporary file name string.
  355. char CurOutputFileName[FileNameSize+5+1+MAX_FILE_EXT_LEN+1];
  356. strncpy (CurOutputFileName, DestFileName, FileNameSize);
  357. #if defined(DATA_VAR_SUPPORT) && defined(PUCRUNCH_SUPPORT)
  358. if (Pack && FileRole == FR_DATA && !DestDataFile)
  359. {
  360. strncpy (CurOutputFileName + FileNameSize, "-data", 5);
  361. FileNameSize += 5;
  362. }
  363. #endif /* defined(DATA_VAR_SUPPORT) && defined(PUCRUNCH_SUPPORT) */
  364. // Insert the dot into the file name.
  365. CurOutputFileName [FileNameSize++] = '.';
  366. // Insert the extension. Reverse in binary mode.
  367. if (File->OutputBin)
  368. {
  369. strcpy (CurOutputFileName + FileNameSize, FileExtType);
  370. FileNameSize += strlen (FileExtType);
  371. strcpy (CurOutputFileName + FileNameSize, FileExtCalc);
  372. FileNameSize += strlen (FileExtCalc);
  373. }
  374. else
  375. {
  376. strcpy (CurOutputFileName + FileNameSize, FileExtCalc);
  377. FileNameSize += strlen (FileExtCalc);
  378. strcpy (CurOutputFileName + FileNameSize, FileExtType);
  379. FileNameSize += strlen (FileExtType);
  380. }
  381. // Zero-terminate the string.
  382. CurOutputFileName [FileNameSize] = 0;
  383. // Open a file with the specified name.
  384. if (!(File->File = fopen (CurOutputFileName, "wb")))
  385. {
  386. Error (CurOutputFileName, "Could not open file for writing.");
  387. return FALSE;
  388. }
  389. // Write the host file header, if desired.
  390. if (!File->OutputBin)
  391. {
  392. TIOS_HOST_FILE_HEADER Header;
  393. memset (&Header, 0, sizeof (Header));
  394. // Write the signature.
  395. switch (DestCalc)
  396. {
  397. case CALC_TI92:
  398. strncpy (Header.Signature, "**TI92**", 8);
  399. break;
  400. case CALC_TI89:
  401. strncpy (Header.Signature, "**TI89**", 8);
  402. break;
  403. case CALC_TI92PLUS:
  404. case CALC_V200:
  405. strncpy (Header.Signature, "**TI92P*", 8);
  406. break;
  407. default:
  408. Error (NULL, "Unknown calculator.");
  409. return FALSE;
  410. }
  411. // Write folder name.
  412. strncpy (Header.FolderName, FolderName, sizeof (Header.FolderName));
  413. // Write variable name.
  414. strncpy (Header.VarName, VarName, sizeof (Header.VarName));
  415. // Write link type.
  416. WriteHI1 (Header.LinkType, LinkType);
  417. // Write file size.
  418. WriteHI4 (Header.FileSize, VarFileSize + sizeof (TIOS_HOST_FILE_HEADER) + sizeof (TIOS_HOST_FILE_FOOTER));
  419. // Write reserved bytes.
  420. Header.Reserved1 [0] = 0x01;
  421. Header.Reserved2 [0] = 0x01;
  422. Header.Reserved2 [2] = 0x52;
  423. Header.Reserved4 [0] = 0xA5;
  424. Header.Reserved4 [1] = 0x5A;
  425. // Export the header.
  426. fwrite (&Header, sizeof (Header), 1, File->File);
  427. }
  428. // Write the on-calc file header.
  429. #ifdef PUCRUNCH_SUPPORT
  430. if (!Pack || FileRole != FR_MAIN)
  431. #endif /* !PUCRUNCH_SUPPORT */
  432. {
  433. TI2 EncVarFileSize;
  434. // Encode the embedded size into the target
  435. // endianness.
  436. WriteTI2 (EncVarFileSize, VarFileSize - 2);
  437. // Export the file size.
  438. fwrite (&EncVarFileSize, 2, 1, File->File);
  439. // Update the checksum, since this is still included
  440. // in the on-calc file image.
  441. File->CheckSum += ReadTI1 (EncVarFileSize.Hi) + ReadTI1 (EncVarFileSize.Lo);
  442. }
  443. return TRUE;
  444. }
  445. }
  446. break;
  447. #endif /* TIOS_FILE_SUPPORT */
  448. #ifdef TIOS_UPGRADE_FILE_SUPPORT
  449. case FF_TIOS_UPGRADE:
  450. *EffectiveSize = FileSize + sizeof (TIOS_UPGRADE_CALC_FOOTER);
  451. if (File->OutputBin)
  452. {
  453. const char *FileExtCalc;
  454. // Determine the destination calculator and set part of the
  455. // file extension.
  456. switch (DestCalc)
  457. {
  458. case CALC_TI92:
  459. FileExtCalc = "92";
  460. break;
  461. case CALC_TI89:
  462. FileExtCalc = "89";
  463. break;
  464. case CALC_TI89 | CALC_FLAG_TITANIUM:
  465. FileExtCalc = "89ti";
  466. break;
  467. case CALC_TI92PLUS:
  468. FileExtCalc = "9x";
  469. break;
  470. case CALC_V200:
  471. FileExtCalc = "v2";
  472. break;
  473. default:
  474. Error (NULL, "Unknown calculator.");
  475. return FALSE;
  476. }
  477. {
  478. SIZE FileNameSize = DestFileSize;
  479. // Create a temporary file name string.
  480. char CurOutputFileName[FileNameSize+1+4+1+sizeof("tib")];
  481. strncpy (CurOutputFileName, DestFile, FileNameSize);
  482. // Insert a dash into the file name.
  483. CurOutputFileName [FileNameSize++] = '-';
  484. // Insert the calculator model into the file name.
  485. strcpy (CurOutputFileName + FileNameSize, FileExtCalc);
  486. FileNameSize += strlen (FileExtCalc);
  487. // Insert the dot into the file name.
  488. CurOutputFileName [FileNameSize++] = '.';
  489. // Insert the .tib extension.
  490. strcpy (CurOutputFileName + FileNameSize, "tib");
  491. FileNameSize += sizeof ("tib") - 1;
  492. // Zero-terminate the string.
  493. CurOutputFileName [FileNameSize] = 0;
  494. // Open a file with the specified name.
  495. if (!(File->File = fopen (CurOutputFileName, "wb")))
  496. {
  497. Error (CurOutputFileName, "Could not open file for writing.");
  498. return FALSE;
  499. }
  500. return TRUE;
  501. }
  502. }
  503. else
  504. Error (NULL, "Support for `.??u' files is not implemented yet. Use `--outputbin'.");
  505. break;
  506. #endif /* TIOS_UPGRADE_FILE_SUPPORT */
  507. #ifdef DEBUGGING_INFO_SUPPORT
  508. case FF_GDB_COFF:
  509. *EffectiveSize = FileSize;
  510. {
  511. SIZE FileNameSize = DestFileSize+4;
  512. // Create a temporary file name string.
  513. char CurOutputFileName[FileNameSize+1];
  514. strncpy (CurOutputFileName, DestFile, DestFileSize);
  515. // Append ".dbg" to the file name.
  516. strcpy (CurOutputFileName + DestFileSize, ".dbg");
  517. // Zero-terminate the string.
  518. CurOutputFileName [FileNameSize] = 0;
  519. // Open a file with the specified name.
  520. if (!(File->File = fopen (CurOutputFileName, "wb")))
  521. {
  522. Error (CurOutputFileName, "Could not open file for writing.");
  523. return FALSE;
  524. }
  525. return TRUE;
  526. }
  527. break;
  528. #endif /* DEBUGGING_INFO_SUPPORT */
  529. default:
  530. Error (NULL, "Unrecognized output file format.");
  531. }
  532. return FALSE;
  533. }
  534. void FinalizeOutputFile (INT_EXP_FILE *File)
  535. {
  536. // Determine the destination file format and finish it.
  537. switch (File->FileFormat)
  538. {
  539. #ifdef TIOS_FILE_SUPPORT
  540. case FF_TIOS:
  541. {
  542. // Write the on-calc file footer.
  543. {
  544. TI1 EncFileTag;
  545. // Export the possible file extension.
  546. if (File->Extension)
  547. {
  548. // Export the leading 0 byte.
  549. WriteTI1 (EncFileTag, 0);
  550. fwrite (&EncFileTag, 1, 1, File->File);
  551. // Export the extension string and terminating 0
  552. // byte.
  553. fwrite (File->Extension, 1, strlen (File->Extension) + 1, File->File);
  554. // Update the checksum.
  555. while (*(File->Extension))
  556. File->CheckSum += (*(File->Extension++));
  557. }
  558. // Encode the file tag.
  559. WriteTI1 (EncFileTag, File->FileType);
  560. // Export the file tag.
  561. fwrite (&EncFileTag, 1, 1, File->File);
  562. File->CheckSum += (I1) (File->FileType);
  563. }
  564. // Write the host file footer, if desired.
  565. if (!File->OutputBin)
  566. {
  567. TIOS_HOST_FILE_FOOTER Footer;
  568. memset (&Footer, 0, sizeof (Footer));
  569. // Write the checksum.
  570. WriteHI2 (Footer.CheckSum, File->CheckSum);
  571. // Export the footer.
  572. fwrite (&Footer, sizeof (Footer), 1, File->File);
  573. }
  574. }
  575. break;
  576. #endif /* TIOS_FILE_SUPPORT */
  577. #ifdef TIOS_UPGRADE_FILE_SUPPORT
  578. case FF_TIOS_UPGRADE:
  579. {
  580. // Write the on-calc upgrade file footer.
  581. {
  582. TIOS_UPGRADE_CALC_FOOTER Footer;
  583. // Since we do not have TI's private key, we cannot
  584. // write a real checksum and signature.
  585. memset (&Footer, 0, sizeof (Footer));
  586. // Encode the fixed data we know.
  587. WriteTI2 (Footer.SignatureHeader, 0x020D);
  588. WriteTI1 (Footer.SignatureType, 0x40);
  589. // Export the footer.
  590. fwrite (&Footer, sizeof (Footer), 1, File->File);
  591. }
  592. }
  593. break;
  594. #endif /* TIOS_UPGRADE_FILE_SUPPORT */
  595. #ifdef DEBUGGING_INFO_SUPPORT
  596. case FF_GDB_COFF:
  597. // Do nothing.
  598. break;
  599. #endif /* DEBUGGING_INFO_SUPPORT */
  600. }
  601. // Close the file.
  602. fclose (File->File);
  603. }
  604. #endif /* !TARGET_EMBEDDED */