Subversion Repositories pentevo

Rev

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

  1. /* codepseudo.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Haeufiger benutzte Pseudo-Befehle                                         */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. /*****************************************************************************
  12.  * Includes
  13.  *****************************************************************************/
  14.  
  15. #include "stdinc.h"
  16. #include <string.h>
  17. #include <ctype.h>
  18. #include <math.h>
  19.  
  20. #include "nls.h"
  21. #include "bpemu.h"
  22. #include "be_le.h"
  23. #include "strutil.h"
  24. #include "chunks.h"
  25. #include "asmdef.h"
  26. #include "asmsub.h"
  27. #include "asmpars.h"
  28. #include "asmallg.h"
  29. #include "asmitree.h"
  30. #include "errmsg.h"
  31.  
  32. #include "codepseudo.h"
  33. #include "motpseudo.h"
  34.  
  35. /*****************************************************************************
  36.  * Global Functions
  37.  *****************************************************************************/
  38.  
  39. /*****************************************************************************
  40.  * Function:    IsIndirect
  41.  * Purpose:     check whether argument is syntactically 'indirect', i.e.
  42.  *              enclosed in 'extra' parentheses.
  43.  * Result:      TRUE if indirect
  44.  *****************************************************************************/
  45.  
  46. Boolean IsIndirectGen(const char *Asc, const char *pBeginEnd)
  47. {
  48.   int z,Level,l;
  49.  
  50.   if (((l = strlen(Asc)) <= 2)
  51.    || (Asc[0] != pBeginEnd[0])
  52.    || (Asc[l - 1] != pBeginEnd[1]))
  53.     return False;
  54.  
  55.   Level = 0;
  56.   for (z = 1; z <= l - 2; z++)
  57.   {
  58.     if (Asc[z] == pBeginEnd[0]) Level++;
  59.     if (Asc[z] == pBeginEnd[1]) Level--;
  60.     if (Level < 0) return False;
  61.   }
  62.  
  63.   return True;
  64. }
  65.  
  66. Boolean IsIndirect(const char *Asc)
  67. {
  68.   return IsIndirectGen(Asc, "()");
  69. }
  70.  
  71. /*!------------------------------------------------------------------------
  72.  * \fn     FindDispBaseSplitWithQualifier(const char *pArg, int *pArgLen, tDispBaseSplitQualifier Qualifier, const char *pBracks)
  73.  * \brief  check for argument of type xxx(yyyy)
  74.  * \param  pArg argument to check
  75.  * \param  pArgLen returns argument length
  76.  * \param  Qualifier possible qualifier to allow more positive decisions
  77.  * \param  pBracks Opening/Closing Parentheses
  78.  * \return index to opening parenthese or -1 if not like pattern
  79.  * ------------------------------------------------------------------------ */
  80.  
  81. typedef struct
  82. {
  83.   as_quoted_iterator_cb_data_t data;
  84.   int nest, split_pos, last_nonspace_pos;
  85.   char last_nonspace;
  86.   tDispBaseSplitQualifier qualifier;
  87.   const char *p_bracks;
  88. } disp_base_split_cb_data_t;
  89.  
  90. /* We are looking for expressions of the form xxx(yyy),
  91.    but we want to avoid false positives on things like
  92.    xxx+(yyy*zzz).  So we look at the (non-blank) character
  93.    right before the opening parenthese in question.  If it is
  94.    something that might be the last letter of an identifier,
  95.    or another parenthized expression, and not an operator,
  96.    it might be OK...
  97.  
  98.    We generally look for the last candidate in the string,
  99.    i.e. we continue to search after a finding.
  100.  */
  101.  
  102. static int disp_base_split_cb(const char *p_pos, as_quoted_iterator_cb_data_t *p_cb_data)
  103. {
  104.   disp_base_split_cb_data_t *p_data = (disp_base_split_cb_data_t*)p_cb_data;
  105.   int pos = p_pos - p_cb_data->p_str;
  106.  
  107.   if (*p_pos == p_data->p_bracks[0])
  108.   {
  109.     if (!p_data->nest)
  110.     {
  111.       if ((p_data->last_nonspace_pos < 0) || as_isalnum(p_data->last_nonspace) || (p_data->last_nonspace == ')') || (p_data->last_nonspace == '\'') || (p_data->last_nonspace == '"'))
  112.         p_data->split_pos = pos;
  113.       else if (p_data->qualifier)
  114.       {
  115.         int qual = p_data->qualifier(p_cb_data->p_str, p_data->last_nonspace_pos, pos);
  116.         if (qual >= 0)
  117.           p_data->split_pos = qual;
  118.       }
  119.     }
  120.     p_data->nest++;
  121.   }
  122.   else if (*p_pos == p_data->p_bracks[1])
  123.     p_data->nest--;
  124.   if (!as_isspace(*p_pos))
  125.   {
  126.     p_data->last_nonspace_pos = pos;
  127.     p_data->last_nonspace = *p_pos;
  128.   }
  129.   return 0;
  130. }
  131.  
  132. int FindDispBaseSplitWithQualifier(const char *pArg, int *pArgLen, tDispBaseSplitQualifier Qualifier, const char *pBracks)
  133. {
  134.   disp_base_split_cb_data_t data;
  135.  
  136.   *pArgLen = strlen(pArg);
  137.  
  138.   if (!*pArgLen || (pArg[*pArgLen - 1] != pBracks[1]))
  139.     return -1;
  140.  
  141.   data.data.callback_before = False;
  142.   data.data.qualify_quote = QualifyQuote;
  143.   data.nest = 0;
  144.   data.split_pos = -1;
  145.   data.last_nonspace_pos = -1;
  146.   data.last_nonspace = ' ';
  147.   data.qualifier = Qualifier;
  148.   data.p_bracks = pBracks;
  149.  
  150.   as_iterate_str_quoted(pArg, disp_base_split_cb, &data.data);
  151.  
  152.   return data.split_pos;
  153. }
  154.  
  155. /*****************************************************************************
  156.  * Function:    CodeEquate
  157.  * Purpose:     EQU for different segment
  158.  * Result:      -
  159.  *****************************************************************************/
  160.  
  161. void CodeEquate(as_addrspace_t DestSeg, LargeInt Min, LargeInt Max)
  162. {
  163.   Boolean OK;
  164.   tSymbolFlags Flags;
  165.   LargeInt Erg;
  166.  
  167.   if (ChkArgCnt(1, 1))
  168.   {
  169.     Erg = EvalStrIntExpressionWithFlags(&ArgStr[1], Int32, &OK, &Flags);
  170.     if (OK && !mFirstPassUnknown(Flags))
  171.     {
  172.       if (Min > Erg) WrError(ErrNum_UnderRange);
  173.       else if (
  174. #ifndef HAS64
  175.         (!(Max & 0x80000000ul)) &&   /* cannot check >=2G range if LargeInt is 32 bits */
  176. #endif
  177.         (Erg > Max)) WrError(ErrNum_OverRange);
  178.       else
  179.       {
  180.         TempResult t;
  181.  
  182.         PushLocHandle(-1);
  183.         EnterIntSymbol(&LabPart, Erg, DestSeg, False);
  184.         PopLocHandle();
  185.         if (MakeUseList)
  186.           if (AddChunk(SegChunks + DestSeg, Erg, 1, False)) WrError(ErrNum_Overlap);
  187.  
  188.         as_tempres_ini(&t);
  189.         as_tempres_set_int(&t, Erg);
  190.         SetListLineVal(&t);
  191.         as_tempres_free(&t);
  192.       }
  193.     }
  194.   }
  195. }
  196.  
  197. /*!------------------------------------------------------------------------
  198.  * \fn     QualifyQuote_SingleQuoteConstant(const char *pStart, const char *pQuotePos)
  199.  * \brief  check whether ' in source is lead-in to character string or int constant
  200.  * \param  pStart complete string
  201.  * \param  pQuotePos single quote position
  202.  * \return True if this is NO lead-in of int constant
  203.  * ------------------------------------------------------------------------ */
  204.  
  205. Boolean QualifyQuote_SingleQuoteConstant(const char *pStart, const char *pQuotePos)
  206. {
  207.   const char *pRun;
  208.   Boolean OK;
  209.   int Base;
  210.  
  211.   /* previous character must be H X B O */
  212.  
  213.   if (pQuotePos == pStart)
  214.     return True;
  215.   switch (as_toupper(*(pQuotePos - 1)))
  216.   {
  217.     case 'B':
  218.       Base = 2; break;
  219.     case 'O':
  220.       Base = 8; break;
  221.     case 'X':
  222.     case 'H':
  223.       Base = 16; break;
  224.     default:
  225.       return True;
  226.   }
  227.  
  228.   /* Scan for following valid (binary/octal/hex) character(s) */
  229.  
  230.   for (pRun = pQuotePos + 1; *pRun; pRun++)
  231.   {
  232.     switch (Base)
  233.     {
  234.       case 16: OK = as_isxdigit(*pRun); break;
  235.       case 8: OK = as_isdigit(*pRun) && (*pRun < '8'); break;
  236.       case 2: OK = as_isdigit(*pRun) && (*pRun < '2'); break;
  237.       default: OK = False;
  238.     }
  239.     if (!OK)
  240.       break;
  241.   }
  242.  
  243.   /* none? -> bad */
  244.  
  245.   if (pRun <= pQuotePos + 1)
  246.     return True;
  247.  
  248.   /* If we've hit another ' after them, it is the "harmless" x'...' form,
  249.      and no special treatment is needed */
  250.  
  251.   if ('\'' == *pRun)
  252.     return True;
  253.  
  254.   /* Other token or string continues -> cannot be such a constant, otherwise we
  255.      have a match and the ' does NOT lead in a character string: */
  256.  
  257.   return as_isalnum(*pRun);
  258. }
  259.  
  260. /*!------------------------------------------------------------------------
  261.  * \fn     string_2_xasm_code(const struct as_nonz_dynstr *p_str, int bytes_per_dword, Boolean big_endian)
  262.  * \brief  put characters from string into xx bit words of machine code - translation done outside!
  263.  * \param  p_str source string
  264.  * \param  bytes_per_dword # of characters in a word
  265.  * \param  big_endian fill words starting with MSB?
  266.  * \return 0 or error code
  267.  * ------------------------------------------------------------------------ */
  268.  
  269. #define declare_string_2_xasm_code(NAME, TYPE, VAR) \
  270. int NAME(const struct as_nonz_dynstr *p_str, int bytes_per_dword, Boolean big_endian) \
  271. { \
  272.   int byte_fill, ret; \
  273.   const char *p_ch, *p_end; \
  274.   TYPE character; \
  275.  \
  276.   for (byte_fill = 0, p_ch = p_str->p_str, p_end = p_ch + p_str->len; \
  277.        p_ch < p_end; p_ch++) \
  278.   { \
  279.     if (!byte_fill) \
  280.     { \
  281.       ret = SetMaxCodeLen((CodeLen + 1) * sizeof(TYPE)); \
  282.       if (ret) \
  283.         return ret; \
  284.       VAR[CodeLen++] = 0; \
  285.     } \
  286.     character = *p_ch & 0xff; \
  287.     if (big_endian) \
  288.       VAR[CodeLen - 1] = (VAR[CodeLen - 1] << 8) | character; \
  289.     else \
  290.       VAR[CodeLen - 1] |= character << (byte_fill * 8); \
  291.     if (++byte_fill >= bytes_per_dword) \
  292.       byte_fill = 0; \
  293.   } \
  294.   if (byte_fill && big_endian) \
  295.     VAR[CodeLen - 1] <<= 8 * (bytes_per_dword - byte_fill); \
  296.   return 0; \
  297. }
  298.  
  299. declare_string_2_xasm_code(string_2_dasm_code, LongWord, DAsmCode)
  300. declare_string_2_xasm_code(string_2_wasm_code, Word, WAsmCode)
  301.  
  302. /*!------------------------------------------------------------------------
  303.  * \fn     add_null_pseudo(struct sInstTable *p_inst_table)
  304.  * \brief  add handle to ignore empty instruction
  305.  * \param  p_inst_table table to augment
  306.  * ------------------------------------------------------------------------ */
  307.  
  308. void decode_null(Word code)
  309. {
  310.   UNUSED(code);
  311. }
  312.  
  313. void add_null_pseudo(struct sInstTable *p_inst_table)
  314. {
  315.   AddInstTable(p_inst_table, "", 0, decode_null);
  316. }
  317.