Subversion Repositories pentevo

Rev

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

  1. /* asmlist.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS Port                                                                   */
  6. /*                                                                           */
  7. /* Generate Listing                                                          */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <string.h>
  13. #include <assert.h>
  14. #include "be_le.h"
  15. #include "cmdarg.h"
  16. #include "strutil.h"
  17. #include "dynstr.h"
  18. #include "asmdef.h"
  19. #include "asmsub.h"
  20. #include "asmif.h"
  21. #include "asmcode.h"
  22. #include "asmlist.h"
  23.  
  24. /* NOTE: Keep this to a value of the form 8*n, so the overall 'prefix'
  25.          in front of the source line in the listing is a multiple of 8.
  26.          This way, Tabs in the source do not break up: */
  27.  
  28. #define LISTLINE_PREFIX_TOTAL 40
  29.  
  30. static unsigned SystemListLen8, SystemListLen16, SystemListLen32;
  31.  
  32. static as_dynstr_t list_buf;
  33.  
  34. static int max_pc_len;
  35.  
  36. static char *p_listline_prefix_format = NULL;
  37. static const char default_listline_prefix_format[] = "%i%n/%a";
  38.  
  39. /*!------------------------------------------------------------------------
  40.  * \fn     as_list_set_max_pc(LargeWord max_pc)
  41.  * \brief  compute maximum width of PC field in listing
  42.  * ------------------------------------------------------------------------ */
  43.  
  44. void as_list_set_max_pc(LargeWord max_pc)
  45. {
  46.   String tmp;
  47.  
  48.   as_snprintf(tmp, sizeof(tmp), "%1.*lllu", ListRadixBase, max_pc);
  49.   max_pc_len = strlen(tmp);
  50.   if (max_pc_len > 8)
  51.     max_pc_len = 8;
  52. }
  53.  
  54. /*!------------------------------------------------------------------------
  55.  * \fn     MakeList()
  56.  * \brief  generate listing for one line, including generated code
  57.  * ------------------------------------------------------------------------ */
  58.  
  59. static void list_format_error(tErrorNum num, char fmt)
  60. {
  61.   char err_str[10];
  62.  
  63.   as_snprintf(err_str, sizeof(err_str), "%%c", fmt);
  64.   WrXError(num, err_str);
  65. }
  66.  
  67. void MakeList(const char *pSrcLine)
  68. {
  69.   Word EffLen, Gran = Granularity();
  70.   Boolean ThisDoLst;
  71.  
  72.   EffLen = CodeLen * Gran;
  73.  
  74. #if 0
  75.   fprintf(stderr, "[%s] WasIF %u WasMACRO %u DoLst %u\n", OpPart.Str, WasIF, WasMACRO, DoLst);
  76. #endif
  77.   if (WasIF)
  78.     ThisDoLst = !!(DoLst & eLstMacroExpIf);
  79.   else if (WasMACRO)
  80.     ThisDoLst = !!(DoLst & eLstMacroExpMacro);
  81.   else
  82.   {
  83.     if (!IfAsm && (!(DoLst & eLstMacroExpIf)))
  84.       ThisDoLst = False;
  85.     else
  86.       ThisDoLst = !!(DoLst & eLstMacroExpRest);
  87.   }
  88.  
  89.   if (!ListToNull && ThisDoLst && (ListMask & 1) && !IFListMask())
  90.   {
  91.     LargeWord ListPC = EProgCounter() - CodeLen;
  92.     size_t sum_len;
  93.     int inc_column_len[3] = { -1, -1, -1 },
  94.         lnum_column_len[3] = { -1, -1, -1 };
  95.     Word Index = 0, CurrListGran, SystemListLen;
  96.     Boolean First = True;
  97.     LargeInt ThisWord;
  98.  
  99.     /* Not enough code to display even on 16/32 bit word?
  100.        Then start dumping bytes right away: */
  101.  
  102.     if (EffLen < ActListGran)
  103.     {
  104.       CurrListGran = 1;
  105.       SystemListLen = SystemListLen8;
  106.     }
  107.     else
  108.     {
  109.       CurrListGran = ActListGran;
  110.       switch (CurrListGran)
  111.       {
  112.         case 4:
  113.           SystemListLen = SystemListLen32;
  114.           break;
  115.         case 2:
  116.           SystemListLen = SystemListLen16;
  117.           break;
  118.         default:
  119.           SystemListLen = SystemListLen8;
  120.       }
  121.     }
  122.  
  123.     if (TurnWords && (Gran != ActListGran) && (1 == ActListGran))
  124.       DreheCodes();
  125.  
  126.     do
  127.     {
  128.       /* Print list line header: First, the part configurable via format string: */
  129.  
  130.       const char *p_format;
  131.       as_format_ctx_t format_context;
  132.       Boolean replace_space = False;
  133.       size_t num_inc_column = 0, num_lnum_column = 0;
  134.  
  135.       if (list_buf.capacity > 0)
  136.         list_buf.p_str[0] = '\0';
  137.       as_format_context_reset(&format_context);
  138.       for (p_format = p_listline_prefix_format ? p_listline_prefix_format : default_listline_prefix_format;
  139.            *p_format; p_format++)
  140.       {
  141.         Boolean next_replace_space = False;
  142.  
  143.         if (as_format_context_consume(&format_context, *p_format));
  144.         else if (format_context.in_format)
  145.         {
  146.           char tmp_buf[40];
  147.           int pad = 0;
  148.  
  149.           switch (*p_format)
  150.           {
  151.             /* Include level is printed only on the first line: */
  152.  
  153.             case 'i':
  154.               if (num_inc_column >= as_array_size(inc_column_len))
  155.                 list_format_error(ErrNum_ListHeadFormatElemTooOften, *p_format);
  156.               if (First)
  157.               {
  158.                 if ((MaxIncDepth > 0) || (format_context.arg[0] > 0))
  159.                 {
  160.                   int inc_max_digits = (format_context.arg[0] > 0)
  161.                                      ? format_context.arg[0]
  162.                                      : ((MaxIncDepth > 99) ? 3 : ((MaxIncDepth > 9) ? 2 : 1));
  163.  
  164.                   inc_column_len[num_inc_column] =
  165.                     (IncDepth > 0) ?
  166.                     as_snprintf(tmp_buf, sizeof(tmp_buf),
  167.                                 format_context.lead_zero ? "(%0*u)" : "(%*u)",
  168.                                 inc_max_digits, (unsigned)IncDepth) :
  169.                     as_snprintf(tmp_buf, sizeof(tmp_buf), "%*s", 2 + inc_max_digits, "");
  170.                   as_dynstr_append_c_str(&list_buf, tmp_buf);
  171.                 }
  172.               }
  173.               else if (inc_column_len[num_inc_column] > 0)
  174.                 as_dynstr_append_c_str(&list_buf, Blanks(inc_column_len[num_inc_column]));
  175.               num_inc_column++;
  176.               break;
  177.  
  178.             /* Source line number is printed only on the first line: */
  179.  
  180.             case 'n':
  181.               if (num_lnum_column >= as_array_size(lnum_column_len))
  182.                 list_format_error(ErrNum_ListHeadFormatElemTooOften, *p_format);
  183.               if (First)
  184.               {
  185.                 int line_max_digits = (format_context.arg[0] > 0) ? format_context.arg[0] : 5;
  186.  
  187.                 lnum_column_len[num_lnum_column] =
  188.                    DecString(tmp_buf, sizeof(tmp_buf), CurrLine,
  189.                              format_context.lead_zero ? line_max_digits : 0);
  190.                 if (lnum_column_len[num_lnum_column] < line_max_digits)
  191.                   as_dynstr_append_c_str(&list_buf, Blanks(pad = line_max_digits - lnum_column_len[num_lnum_column]));
  192.                 as_dynstr_append_c_str(&list_buf, tmp_buf);
  193.                 lnum_column_len[num_lnum_column] += pad;
  194.               }
  195.               else if (lnum_column_len[num_lnum_column] > 0)
  196.               {
  197.                 as_dynstr_append_c_str(&list_buf, Blanks(lnum_column_len[num_lnum_column]));
  198.                 next_replace_space = True;
  199.               }
  200.               num_lnum_column++;
  201.               break;
  202.  
  203.             /* Memory address is printed on all lines: */
  204.  
  205.             case 'a':
  206.             {
  207.               int pc_max_digits = (format_context.arg[0] > 0) ? format_context.arg[0] : max_pc_len;
  208.               char pc_buf[40];
  209.               int pc_len;
  210.  
  211.               pc_len = SysString(pc_buf, sizeof(pc_buf), ListPC, ListRadixBase,
  212.                                  (format_context.lead_zero || ListPCZeroPad) ? pc_max_digits : 0,
  213.                                  False, HexStartCharacter, SplitByteCharacter);
  214.               if (pc_len < pc_max_digits)
  215.                 as_dynstr_append_c_str(&list_buf, Blanks(pad = pc_max_digits - pc_len));
  216.               as_dynstr_append_c_str(&list_buf, pc_buf);
  217.               break;
  218.             }
  219.             default:
  220.               list_format_error(ErrNum_InvListHeadFormat, *p_format);
  221.           }
  222.           as_format_context_reset(&format_context);
  223.         }
  224.         else /* !format_context.in_format */
  225.           as_dynstr_append(&list_buf, replace_space ? " " : p_format, 1);
  226.  
  227.         replace_space = next_replace_space;
  228.       }
  229.  
  230.       /* Separator resp. indicator for retracted code */
  231.  
  232.       as_sdprcatf(&list_buf, Retracted ? " R" : " :");
  233.       sum_len = strlen(list_buf.p_str);
  234.       assert(sum_len + 2 < LISTLINE_PREFIX_TOTAL);
  235.  
  236.       /* Extrawurst in Listing ? */
  237.  
  238.       if (First && *ListLine)
  239.       {
  240.         size_t rem_space = LISTLINE_PREFIX_TOTAL - sum_len - 2;
  241.         int num_pad = rem_space - strlen(ListLine);
  242.  
  243.         /* If too long, truncate and add ..
  244.            If shorter than space, pad with spaces: */
  245.  
  246.         if (num_pad < 0)
  247.           ListLine[rem_space - 2] = '\0';
  248.         sum_len += as_sdprcatf(&list_buf, " %s%s", ListLine, (num_pad >= 0) ? Blanks(num_pad) : "..");
  249.       }
  250.  
  251.       /* Actual code: */
  252.  
  253.       else do
  254.       {
  255.         /* We checked initially there is at least one full word,
  256.            and we check after every word whether there is another
  257.            full one: */
  258.  
  259.         if ((Index < EffLen) && !DontPrint)
  260.         {
  261.           switch (CurrListGran)
  262.           {
  263.             case 4:
  264.               ThisWord = DAsmCode[Index >> 2];
  265.               break;
  266.             case 2:
  267.               ThisWord = WAsmCode[Index >> 1];
  268.               break;
  269.             default:
  270.               ThisWord = BAsmCode[Index];
  271.           }
  272.           as_sdprcatf(&list_buf, " %0*.*lllu", (int)SystemListLen, (int)ListRadixBase, ThisWord);
  273.         }
  274.         else
  275.           as_sdprcatf(&list_buf, "%*s", (int)(1 + SystemListLen), "");
  276.  
  277.         /* advance pointers & keep track of # of characters printed */
  278.  
  279.         ListPC += (Gran == CurrListGran) ? 1 : CurrListGran;
  280.         Index += CurrListGran;
  281.         sum_len += 1 + SystemListLen;
  282.  
  283.         /* Less than one full word remaining? Then switch to dumping bytes. */
  284.  
  285.         if (Index + CurrListGran > EffLen)
  286.         {
  287.           CurrListGran = 1;
  288.           SystemListLen = SystemListLen8;
  289.         }
  290.       }
  291.       while (sum_len + 1 + SystemListLen < LISTLINE_PREFIX_TOTAL);
  292.  
  293.       /* If first line, pad to max length and append source line */
  294.  
  295.       if (First)
  296.         as_sdprcatf(&list_buf, "%*s%s", (int)(LISTLINE_PREFIX_TOTAL - sum_len), "", pSrcLine);
  297.       WrLstLine(list_buf.p_str);
  298.       if (First && *ListLine)
  299.       {
  300.         *ListLine = '\0';
  301.         break;
  302.       }
  303.       First = False;
  304.     }
  305.     while ((Index < EffLen) && !DontPrint);
  306.  
  307.     if (TurnWords && (Gran != ActListGran) && (1 == ActListGran))
  308.       DreheCodes();
  309.   } /* if (!ListToNull... */
  310. }
  311.  
  312. /*!------------------------------------------------------------------------
  313.  *
  314.  * ------------------------------------------------------------------------ */
  315.  
  316. static as_cmd_result_t cmd_listline_prefix(Boolean negate, const char *p_arg)
  317. {
  318.   if (p_listline_prefix_format)
  319.     free(p_listline_prefix_format);
  320.   p_listline_prefix_format = negate ? NULL : as_strdup(p_arg);
  321.   return negate ? e_cmd_ok : e_cmd_arg;
  322. }
  323.  
  324. static const as_cmd_rec_t list_params[] =
  325. {
  326.   { "listline-prefix", cmd_listline_prefix }
  327. };
  328.  
  329. /*!------------------------------------------------------------------------
  330.  * \fn     asmlist_setup(void)
  331.  * \brief  setup stuff after command line args have been read
  332.  * ------------------------------------------------------------------------ */
  333.  
  334. void asmlist_setup(void)
  335. {
  336.   String Dummy;
  337.  
  338.   SysString(Dummy, sizeof(Dummy), 0xff, ListRadixBase, 0, False, HexStartCharacter, SplitByteCharacter);
  339.   SystemListLen8 = strlen(Dummy);
  340.   SysString(Dummy, sizeof(Dummy), 0xffffu, ListRadixBase, 0, False, HexStartCharacter, SplitByteCharacter);
  341.   SystemListLen16 = strlen(Dummy);
  342.   SysString(Dummy, sizeof(Dummy), 0xfffffffful, ListRadixBase, 0, False, HexStartCharacter, SplitByteCharacter);
  343.   SystemListLen32 = strlen(Dummy);
  344. }
  345.  
  346. /*!------------------------------------------------------------------------
  347.  * \fn     asmlist_init(void)
  348.  * \brief  global setup at program start
  349.  * ------------------------------------------------------------------------ */
  350.  
  351. void asmlist_init(void)
  352. {
  353.   as_dynstr_ini(&list_buf, STRINGSIZE);
  354.  
  355.   as_cmd_register(list_params, as_array_size(list_params));
  356. }
  357.