Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /* toolutils.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Unterroutinen fuer die AS-Tools                                           */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include "be_le.h"
  13. #include <string.h>
  14. #include <stdarg.h>
  15.  
  16. #include "strutil.h"
  17. #include "stringlists.h"
  18. #include "cmdarg.h"
  19. #include "stdhandl.h"
  20. #include "ioerrs.h"
  21.  
  22. #include "nls.h"
  23. #include "nlmessages.h"
  24. #include "tools.rsc"
  25. #ifdef _USE_MSH
  26. # include "tools.msh"
  27. #endif
  28.  
  29. #include "toolutils.h"
  30.  
  31. #include "version.h"
  32.  
  33. /****************************************************************************/
  34.  
  35. static Boolean DoFilter;
  36. static int FilterCnt;
  37. static Byte FilterBytes[100];
  38.  
  39. Word FileID = 0x1489;       /* Dateiheader Eingabedateien */
  40. const char *OutName = "STDOUT";   /* Pseudoname Output */
  41.  
  42. static TMsgCat MsgCat;
  43.  
  44. Boolean QuietMode, Verbose;
  45.  
  46. /****************************************************************************/
  47.  
  48. void WrCopyRight(const char *Msg)
  49. {
  50.   printf("%s\n%s\n", Msg, InfoMessCopyright);
  51. }
  52.  
  53. void DelSuffix(char *Name)
  54. {
  55.   char *p,*z,*Part;
  56.  
  57.   p = NULL;
  58.   for (z = Name; *z != '\0'; z++)
  59.     if (*z == '\\')
  60.       p = z;
  61.   Part = (p != NULL) ? p : Name;
  62.   Part = strchr(Part, '.');
  63.   if (Part != NULL)
  64.     *Part = '\0';
  65. }
  66.  
  67. void AddSuffix(char *pName, unsigned NameSize, const char *Suff)
  68. {
  69.   char *p, *z, *Part;
  70.  
  71.   p = NULL;
  72.   for (z = pName; *z != '\0'; z++)
  73.     if (*z == '\\')
  74.       p = z;
  75.   Part = (p != NULL) ? p : pName;
  76.   if (strchr(Part, '.') == NULL)
  77.     strmaxcat(pName, Suff, NameSize);
  78. }
  79.  
  80. void FormatError(const char *Name, const char *Detail)
  81. {
  82.   fprintf(stderr, "%s%s%s (%s)\n",
  83.           catgetmessage(&MsgCat, Num_FormatErr1aMsg),
  84.           Name,
  85.           catgetmessage(&MsgCat, Num_FormatErr1bMsg),
  86.           Detail);
  87.   fprintf(stderr, "%s\n",
  88.           catgetmessage(&MsgCat, Num_FormatErr2Msg));
  89.   exit(3);
  90. }
  91.  
  92. static void wr_io_str(const char *p_name, const char *p_error_msg)
  93. {
  94.   fprintf(stderr, "%s%s%s\n",
  95.           catgetmessage(&MsgCat, Num_IOErrAHeaderMsg),
  96.           p_name,
  97.           catgetmessage(&MsgCat, Num_IOErrBHeaderMsg));
  98.  
  99.   fprintf(stderr, "%s.\n", p_error_msg);
  100.  
  101.   fprintf(stderr, "%s\n",
  102.           catgetmessage(&MsgCat, Num_ErrMsgTerminating));
  103.  
  104.   exit(2);
  105. }
  106.  
  107. void ChkIO(const char *Name)
  108. {
  109.   if (errno)
  110.     wr_io_str(Name, GetErrorMsg(errno));
  111. }
  112.  
  113. void chk_wr_read_error(const char *p_name)
  114. {
  115.   wr_io_str(p_name, errno ? GetErrorMsg(errno) : GetReadErrorMsg());
  116. }
  117.  
  118. int chkio_fprintf(FILE *p_file, const char *p_name, const char *p_fmt, ...)
  119. {
  120.   va_list ap;
  121.   int ret;
  122.  
  123.   va_start(ap, p_fmt);
  124.   ret = vfprintf(p_file, p_fmt, ap);
  125.   va_end(ap);
  126.   if (ret < 0)
  127.     ChkIO(p_name);
  128.   return ret;
  129. }
  130.  
  131. int chkio_printf(const char *p_name, const char *p_fmt, ...)
  132. {
  133.   va_list ap;
  134.   int ret;
  135.  
  136.   va_start(ap, p_fmt);
  137.   ret = vprintf(p_fmt, ap);
  138.   va_end(ap);
  139.   if (ret < 0)
  140.     ChkIO(p_name);
  141.   return ret;
  142. }
  143.  
  144. Word Granularity(Byte Header, Byte Segment)
  145. {
  146.   switch (Header)
  147.   {
  148.     case 0x09:
  149.     case 0x76:
  150.     case 0x7d:
  151.       return 4;
  152.     case 0x36: /* MN161x */
  153.     case 0x70:
  154.     case 0x71:
  155.     case 0x72:
  156.     case 0x74:
  157.     case 0x75:
  158.     case 0x77:
  159.     case 0x12:
  160.     case 0x6d:
  161.       return 2;
  162.     case 0x3b: /* AVR */
  163.     case 0x1a: /* PDK13..16 */
  164.     case 0x1b:
  165.     case 0x1c:
  166.     case 0x1d:
  167.       return (Segment == SegCode) ? 2 : 1;
  168.     default:
  169.       return 1;
  170.   }
  171. }
  172.  
  173. void ReadRecordHeader(Byte *Header, Byte *CPU, Byte* Segment,
  174.                       Byte *Gran, const char *Name, FILE *f)
  175. {
  176. #ifdef _WIN32
  177.    /* CygWin B20 seems to mix up the file pointer under certain
  178.       conditions. Difficult to reproduce, so we reposition it. */
  179.  
  180.   long pos;
  181.  
  182.   pos = ftell(f);
  183.   fflush(f);
  184.   rewind(f);
  185.   fseek(f, pos, SEEK_SET);
  186. #endif
  187.  
  188.   if (fread(Header, 1, 1, f) != 1)
  189.     chk_wr_read_error(Name);
  190.   if ((*Header != FileHeaderEnd) && (*Header != FileHeaderStartAdr))
  191.   {
  192.     if ((*Header == FileHeaderDataRec) || (*Header == FileHeaderRDataRec) ||
  193.         (*Header == FileHeaderRelocRec) || (*Header == FileHeaderRRelocRec))
  194.     {
  195.       if (fread(CPU, 1, 1, f) != 1)
  196.         chk_wr_read_error(Name);
  197.       if (fread(Segment, 1, 1, f) != 1)
  198.         chk_wr_read_error(Name);
  199.       if (fread(Gran, 1, 1, f) != 1)
  200.         chk_wr_read_error(Name);
  201.     }
  202.     else if (*Header <= 0x7f)
  203.     {
  204.       *CPU = *Header;
  205.       *Header = FileHeaderDataRec;
  206.       *Segment = SegCode;
  207.       *Gran = Granularity(*CPU, *Segment);
  208.     }
  209.   }
  210. }
  211.  
  212. void WriteRecordHeader(Byte *Header, Byte *CPU, Byte *Segment,
  213.                        Byte *Gran, const char *Name, FILE *f)
  214. {
  215.   if ((*Header == FileHeaderEnd) || (*Header == FileHeaderStartAdr))
  216.   {
  217.     if (fwrite(Header, 1, 1, f) != 1)
  218.       ChkIO(Name);
  219.   }
  220.   else if ((*Header == FileHeaderDataRec) || (*Header == FileHeaderRDataRec))
  221.   {
  222.     if ((*Segment != SegCode) || (*Gran != Granularity(*CPU, *Segment)) || (*CPU >= 0x80))
  223.     {
  224.       if (fwrite(Header, 1, 1, f))
  225.         ChkIO(Name);
  226.       if (fwrite(CPU, 1, 1, f))
  227.         ChkIO(Name);
  228.       if (fwrite(Segment, 1, 1, f))
  229.         ChkIO(Name);
  230.       if (fwrite(Gran, 1, 1, f))
  231.         ChkIO(Name);
  232.     }
  233.     else
  234.     {
  235.       if (fwrite(CPU, 1, 1, f))
  236.         ChkIO(Name);
  237.     }
  238.   }
  239.   else
  240.   {
  241.     if (fwrite(CPU, 1, 1, f))
  242.       ChkIO(Name);
  243.   }
  244. }
  245.  
  246. void SkipRecord(Byte Header, const char *Name, FILE *f)
  247. {
  248.   int Length;
  249.   LongWord Addr, RelocCount, ExportCount, StringLen;
  250.   Word Len;
  251.  
  252.   switch (Header)
  253.   {
  254.     case FileHeaderStartAdr:
  255.       Length = 4;
  256.       break;
  257.     case FileHeaderEnd:
  258.       Length = 0;
  259.       break;
  260.     case FileHeaderRelocInfo:
  261.       if (!Read4(f, &RelocCount))
  262.         ChkIO(Name);
  263.       if (!Read4(f, &ExportCount))
  264.         ChkIO(Name);
  265.       if (!Read4(f, &StringLen))
  266.         ChkIO(Name);
  267.       Length = (16 * RelocCount) + (16 * ExportCount) + StringLen;
  268.       break;
  269.     default:
  270.       if (!Read4(f, &Addr))
  271.         ChkIO(Name);
  272.       if (!Read2(f, &Len))
  273.         ChkIO(Name);
  274.       Length = Len;
  275.       break;
  276.   }
  277.  
  278.   if (fseek(f, Length, SEEK_CUR) != 0) ChkIO(Name);
  279. }
  280.  
  281. PRelocInfo ReadRelocInfo(FILE *f)
  282. {
  283.   PRelocInfo PInfo;
  284.   PRelocEntry PEntry;
  285.   PExportEntry PExp;
  286.   Boolean OK = FALSE;
  287.   LongWord StringLen, StringPos;
  288.   LongInt z;
  289.  
  290.   /* get memory for structure */
  291.  
  292.   PInfo = (PRelocInfo) malloc(sizeof(TRelocInfo));
  293.   if (PInfo != NULL)
  294.   {
  295.     PInfo->RelocEntries = NULL;
  296.     PInfo->ExportEntries = NULL;
  297.     PInfo->Strings = NULL;
  298.  
  299.     /* read global numbers */
  300.  
  301.     if ((Read4(f, &PInfo->RelocCount))
  302.      && (Read4(f, &PInfo->ExportCount))
  303.      && (Read4(f, &StringLen)))
  304.     {
  305.       /* allocate memory */
  306.  
  307.       PInfo->RelocEntries = (PRelocEntry) malloc(sizeof(TRelocEntry) * PInfo->RelocCount);
  308.       if ((PInfo->RelocCount == 0) || (PInfo->RelocEntries != NULL))
  309.       {
  310.         PInfo->ExportEntries = (PExportEntry) malloc(sizeof(TExportEntry) * PInfo->ExportCount);
  311.         if ((PInfo->ExportCount == 0) || (PInfo->ExportEntries != NULL))
  312.         {
  313.           PInfo->Strings = (char*) malloc(sizeof(char) * StringLen);
  314.           if ((StringLen == 0) || (PInfo->Strings != NULL))
  315.           {
  316.             /* read relocation entries */
  317.  
  318.             for (z = 0, PEntry = PInfo->RelocEntries; z < PInfo->RelocCount; z++, PEntry++)
  319.             {
  320.               if (!Read8(f, &PEntry->Addr))
  321.                 break;
  322.               if (!Read4(f, &StringPos))
  323.                 break;
  324.               PEntry->Name = PInfo->Strings + StringPos;
  325.               if (!Read4(f, &PEntry->Type))
  326.                 break;
  327.             }
  328.  
  329.             /* read export entries */
  330.  
  331.             for (z = 0, PExp = PInfo->ExportEntries; z < PInfo->ExportCount; z++, PExp++)
  332.             {
  333.               if (!Read4(f, &StringPos))
  334.                 break;
  335.               PExp->Name = PInfo->Strings + StringPos;
  336.               if (!Read4(f, &PExp->Flags))
  337.                 break;
  338.               if (!Read8(f, &PExp->Value))
  339.                 break;
  340.             }
  341.  
  342.             /* read strings */
  343.  
  344.             if (z == PInfo->ExportCount)
  345.               OK = ((fread(PInfo->Strings, 1, StringLen, f)) == StringLen);
  346.           }
  347.         }
  348.       }
  349.     }
  350.   }
  351.  
  352.   if (!OK)
  353.   {
  354.     if (PInfo != NULL)
  355.     {
  356.       DestroyRelocInfo(PInfo);
  357.       PInfo = NULL;
  358.     }
  359.   }
  360.  
  361.   return PInfo;
  362. }
  363.  
  364. void DestroyRelocInfo(PRelocInfo PInfo)
  365. {
  366.   if (PInfo->Strings != NULL)
  367.   {
  368.     free(PInfo->Strings);
  369.     PInfo->Strings = NULL;
  370.   }
  371.   if ((PInfo->ExportCount > 0) && (PInfo->RelocEntries != NULL))
  372.   {
  373.     free(PInfo->RelocEntries);
  374.     PInfo->RelocEntries = NULL;
  375.   }
  376.   if ((PInfo->RelocCount > 0) && (PInfo->ExportEntries != NULL))
  377.   {
  378.     free(PInfo->ExportEntries);
  379.     PInfo->ExportEntries = NULL;
  380.   }
  381.   free (PInfo);
  382. }
  383.  
  384. as_cmd_result_t CMD_FilterList(Boolean Negate, const char *Arg)
  385. {
  386.   Byte FTemp;
  387.   Boolean err;
  388.   char *p;
  389.   int Search;
  390.   String Copy;
  391.  
  392.   if (*Arg == '\0')
  393.     return e_cmd_err;
  394.   strmaxcpy(Copy, Arg, STRINGSIZE);
  395.  
  396.   do
  397.   {
  398.     p = strchr(Copy,',');
  399.     if (p != NULL)
  400.       *p = '\0';
  401.     FTemp = ConstLongInt(Copy, &err, 10);
  402.     if (!err)
  403.       return e_cmd_err;
  404.  
  405.     for (Search = 0; Search < FilterCnt; Search++)
  406.       if (FilterBytes[Search] == FTemp)
  407.         break;
  408.  
  409.     if ((Negate) && (Search < FilterCnt))
  410.       FilterBytes[Search] = FilterBytes[--FilterCnt];
  411.  
  412.     else if ((!Negate) && (Search >= FilterCnt))
  413.       FilterBytes[FilterCnt++] = FTemp;
  414.  
  415.     if (p != NULL)
  416.       strmov(Copy, p + 1);
  417.   }
  418.   while (p != NULL);
  419.  
  420.   DoFilter = (FilterCnt != 0);
  421.  
  422.   return e_cmd_arg;
  423. }
  424.  
  425. as_cmd_result_t CMD_Range(LongWord *pStartAddr, LongWord *pStopAddr,
  426.                           Boolean *pStartAuto, Boolean *pStopAuto,
  427.                           const char *Arg)
  428. {
  429.   const char *p;
  430.   String StartStr;
  431.   Boolean ok;
  432.  
  433.   p = strchr(Arg, '-');
  434.   if (!p) return e_cmd_err;
  435.  
  436.   strmemcpy(StartStr, sizeof(StartStr), Arg, p - Arg);
  437.   *pStartAuto = AddressWildcard(StartStr);
  438.   if (*pStartAuto)
  439.     ok = True;
  440.   else
  441.     *pStartAddr = ConstLongInt(StartStr, &ok, 10);
  442.   if (!ok)
  443.     return e_cmd_err;
  444.  
  445.   *pStopAuto = AddressWildcard(p + 1);
  446.   if (*pStopAuto)
  447.     ok = True;
  448.   else
  449.     *pStopAddr = ConstLongInt(p + 1, &ok, 10);
  450.   if (!ok)
  451.     return e_cmd_err;
  452.  
  453.   if (!*pStartAuto && !*pStopAuto && (*pStartAddr > *pStopAddr))
  454.     return e_cmd_err;
  455.  
  456.   return e_cmd_arg;
  457. }
  458.  
  459. as_cmd_result_t CMD_QuietMode(Boolean Negate, const char *Arg)
  460. {
  461.   UNUSED(Arg);
  462.  
  463.   QuietMode = !Negate;
  464.   return e_cmd_ok;
  465. }
  466.  
  467. as_cmd_result_t CMD_Verbose(Boolean Negate, const char *Arg)
  468. {
  469.   UNUSED(Arg);
  470.  
  471.   Verbose = !Negate;
  472.   return e_cmd_ok;
  473. }
  474.  
  475. Boolean FilterOK(Byte Header)
  476. {
  477.   int z;
  478.  
  479.   if (DoFilter)
  480.   {
  481.     for (z = 0; z < FilterCnt; z++)
  482.      if (Header == FilterBytes[z])
  483.        return True;
  484.     return False;
  485.   }
  486.   else
  487.     return True;
  488. }
  489.  
  490. Boolean RemoveOffset(char *Name, LongWord *Offset)
  491. {
  492.   int z, Nest;
  493.   Boolean err;
  494.  
  495.   *Offset = 0;
  496.   if ((*Name) && (Name[strlen(Name)-1] == ')'))
  497.   {
  498.     z = strlen(Name) - 2;
  499.     Nest = 0;
  500.     while ((z >= 0) && (Nest >= 0))
  501.     {
  502.       switch (Name[z])
  503.       {
  504.         case '(': Nest--; break;
  505.         case ')': Nest++; break;
  506.       }
  507.       if (Nest != -1)
  508.         z--;
  509.     }
  510.     if (Nest != -1)
  511.       return False;
  512.     else
  513.     {
  514.       Name[strlen(Name) - 1] = '\0';
  515.       *Offset = ConstLongInt(Name + z + 1, &err, 10);
  516.       Name[z] = '\0';
  517.       return err;
  518.     }
  519.   }
  520.   else
  521.     return True;
  522. }
  523.  
  524. void EraseFile(const char *FileName, LongWord Offset)
  525. {
  526.   UNUSED(Offset);
  527.  
  528.   if (unlink(FileName) == -1)
  529.     ChkIO(FileName);
  530. }
  531.  
  532. void toolutils_init(const char *ProgPath)
  533. {
  534.   version_init();
  535.  
  536. #ifdef _USE_MSH
  537.   msg_catalog_open_buffer(&MsgCat, tools_msh_data, sizeof(tools_msh_data), MsgId1, MsgId2);
  538.   UNUSED(ProgPath);
  539. #else
  540.   msg_catalog_open_file(&MsgCat, "tools.msg", ProgPath, MsgId1, MsgId2);
  541. #endif
  542.  
  543.   FilterCnt = 0;
  544.   DoFilter = False;
  545. }
  546.  
  547. Boolean AddressWildcard(const char *addr)
  548. {
  549.   return ((strcmp(addr, "$") == 0) || (as_strcasecmp(addr, "0x") == 0));
  550. }
  551.  
  552. #ifdef CKMALLOC
  553. #undef malloc
  554. #undef realloc
  555.  
  556. void *ckmalloc(size_t s)
  557. {
  558.   void *tmp = malloc(s);
  559.   if (tmp == NULL)
  560.   {
  561.     fprintf(stderr,"allocation error(malloc): out of memory");
  562.     exit(255);
  563.   }
  564.   return tmp;
  565. }
  566.  
  567. void *ckrealloc(void *p, size_t s)
  568. {
  569.   void *tmp = realloc(p,s);
  570.   if (tmp == NULL)
  571.   {
  572.     fprintf(stderr,"allocation error(realloc): out of memory");
  573.     exit(255);
  574.   }
  575.   return tmp;
  576. }
  577. #endif
  578.  
  579. void WrError(Word Num)
  580. {
  581.   UNUSED(Num);
  582. }
  583.