Subversion Repositories pentevo

Rev

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

  1. /* intpseudo.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS                                                                        */
  6. /*                                                                           */
  7. /* Commonly Used Intel-Style Pseudo Instructions                             */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. /*****************************************************************************
  12.  * Includes
  13.  *****************************************************************************/
  14.  
  15. #include "stdinc.h"
  16. #include <ctype.h>
  17. #include <string.h>
  18. #include <assert.h>
  19. #include <math.h>
  20.  
  21. #include "bpemu.h"
  22. #include "be_le.h"
  23. #include "strutil.h"
  24. #include "nls.h"
  25. #include "asmdef.h"
  26. #include "asmsub.h"
  27. #include "asmpars.h"
  28. #include "asmitree.h"
  29. #include "onoff_common.h"
  30. #include "chartrans.h"
  31. #include "errmsg.h"
  32. #include "ieeefloat.h"
  33. #include "decfloat.h"
  34.  
  35. #include "intpseudo.h"
  36.  
  37. #define LEAVE goto func_exit
  38.  
  39. /*****************************************************************************
  40.  * Local Types
  41.  *****************************************************************************/
  42.  
  43. struct sLayoutCtx;
  44.  
  45. typedef Boolean (*TLayoutFunc)(
  46. #ifdef __PROTOS__
  47.                                const tStrComp *pArg, struct sLayoutCtx *pCtx
  48. #endif
  49.                                );
  50.  
  51. typedef enum
  52. {
  53.   DSNone, DSConstant, DSSpace
  54. } tDSFlag;
  55.  
  56. struct sCurrCodeFill
  57. {
  58.   LongInt FullWordCnt;
  59.   int LastWordFill;
  60. };
  61. typedef struct sCurrCodeFill tCurrCodeFill;
  62.  
  63. struct sLayoutCtx
  64. {
  65.   tDSFlag DSFlag;
  66.   int_pseudo_flags_t flags;
  67.   TLayoutFunc LayoutFunc;
  68.   int BaseElemLenBits, FullWordSize, ElemsPerFullWord, ListGran;
  69.   Boolean (*Put4I)(Byte b, struct sLayoutCtx *pCtx);
  70.   Boolean (*Put8I)(Byte b, struct sLayoutCtx *pCtx);
  71.   Boolean (*Put16I)(Word w, struct sLayoutCtx *pCtx);
  72.   Boolean (*Put16F)(as_float_t f, struct sLayoutCtx *pCtx);
  73.   Boolean (*Put32I)(LongWord l, struct sLayoutCtx *pCtx);
  74.   Boolean (*Put32F)(as_float_t f, struct sLayoutCtx *pCtx);
  75.   Boolean (*Put48I)(LargeWord q, struct sLayoutCtx *pCtx);
  76.   Boolean (*Put48F)(as_float_t f, struct sLayoutCtx *pCtx);
  77.   Boolean (*Put64I)(LargeWord q, struct sLayoutCtx *pCtx);
  78.   Boolean (*Put64F)(as_float_t f, struct sLayoutCtx *pCtx);
  79.   Boolean (*Put80I)(LargeWord t, Boolean orig_negative, struct sLayoutCtx *pCtx);
  80.   Boolean (*Put80F)(as_float_t t, struct sLayoutCtx *pCtx);
  81.   Boolean (*Put128I)(LargeWord q, Boolean orig_negative, struct sLayoutCtx *pCtx);
  82.   Boolean (*Put128F)(as_float_t t, struct sLayoutCtx *pCtx);
  83.   Boolean (*Replicate)(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx);
  84.   tCurrCodeFill CurrCodeFill, FillIncPerElem;
  85.   const tStrComp *pCurrComp;
  86.   int LoHiMap;
  87. };
  88. typedef struct sLayoutCtx tLayoutCtx;
  89.  
  90. /*****************************************************************************
  91.  * Global Variables
  92.  *****************************************************************************/
  93.  
  94. static char Z80SyntaxName[] = "Z80SYNTAX";
  95. tZ80Syntax CurrZ80Syntax;
  96.  
  97. /*****************************************************************************
  98.  * Local Functions
  99.  *****************************************************************************/
  100.  
  101. void _DumpCodeFill(const char *pTitle, const tCurrCodeFill *pFill)
  102. {
  103.   fprintf(stderr, "%s %u %d\n", pTitle, (unsigned)pFill->FullWordCnt, pFill->LastWordFill);
  104. }
  105.  
  106. /*!------------------------------------------------------------------------
  107.  * \fn     Boolean SetDSFlag(struct sLayoutCtx *pCtx, tDSFlag Flag)
  108.  * \brief  check set data disposition/reservation flag in context
  109.  * \param  pCtx context
  110.  * \param  Flag operation to be set
  111.  * \return True if operation could be set or was alreday set
  112.  * ------------------------------------------------------------------------ */
  113.  
  114. static Boolean SetDSFlag(struct sLayoutCtx *pCtx, tDSFlag Flag)
  115. {
  116.   if ((pCtx->DSFlag != DSNone) && (pCtx->DSFlag != Flag))
  117.   {
  118.     WrStrErrorPos(ErrNum_MixDBDS, pCtx->pCurrComp);
  119.     return False;
  120.   }
  121.   pCtx->DSFlag = Flag;
  122.   return True;
  123. }
  124.  
  125. /*!------------------------------------------------------------------------
  126.  * \fn     IncMaxCodeLen(struct sLayoutCtx *pCtx, LongWord NumFullWords)
  127.  * \brief  assure xAsmCode has space for at moleast n more full words
  128.  * \param  pCtxcontext
  129.  * \param  NumFullWords # of additional words intended to write
  130.  * \return True if success
  131.  * ------------------------------------------------------------------------ */
  132.  
  133. static Boolean IncMaxCodeLen(struct sLayoutCtx *pCtx, LongWord NumFullWords)
  134. {
  135.   if (SetMaxCodeLen((pCtx->CurrCodeFill.FullWordCnt + NumFullWords) * pCtx->FullWordSize))
  136.   {
  137.     WrStrErrorPos(ErrNum_CodeOverflow, pCtx->pCurrComp);
  138.     return False;
  139.   }
  140.   else
  141.     return True;
  142. }
  143.  
  144. static Byte NibbleInByte(Byte n, int Pos)
  145. {
  146.   return (n & 15) << (Pos << 2);
  147. }
  148.  
  149. static Word NibbleInWord(Byte n, int Pos)
  150. {
  151.   return ((Word)(n & 15)) << (Pos << 2);
  152. }
  153.  
  154. static LongWord NibbleInDWord(Byte n, int Pos)
  155. {
  156.   return ((LongWord)(n & 15)) << (Pos << 2);
  157. }
  158.  
  159. static Word ByteInWord(Byte b, int Pos)
  160. {
  161.   return ((Word)b) << (Pos << 3);
  162. }
  163.  
  164. static LongWord ByteInDWord(Byte b, int Pos)
  165. {
  166.   return ((LongWord)b) << (Pos << 3);
  167. }
  168.  
  169. static LongWord WordInDWord(Word b, int Pos)
  170. {
  171.   return ((LongWord)b) << (Pos << 4);
  172. }
  173.  
  174. static Byte NibbleFromByte(Byte b, int Pos)
  175. {
  176.   return (b >> (Pos << 2)) & 0x0f;
  177. }
  178.  
  179. static Byte NibbleFromWord(Word w, int Pos)
  180. {
  181.   return (w >> (Pos << 2)) & 0x0f;
  182. }
  183.  
  184. static Byte NibbleFromDWord(LongWord w, int Pos)
  185. {
  186.   return (w >> (Pos << 2)) & 0x0f;
  187. }
  188.  
  189. static Byte ByteFromWord(Word w, int Pos)
  190. {
  191.   return (w >> (Pos << 3)) & 0xff;
  192. }
  193.  
  194. static Byte ByteFromDWord(LongWord w, int Pos)
  195. {
  196.   return (w >> (Pos << 3)) & 0xff;
  197. }
  198.  
  199. static Word WordFromDWord(LongWord w, int Pos)
  200. {
  201.   return (w >> (Pos << 4)) & 0xffff;
  202. }
  203.  
  204. /*!------------------------------------------------------------------------
  205.  * \fn     SubCodeFill
  206.  * \brief  perform 'c = a - b' on tCurrCodeFill structures
  207.  * \param  c result
  208.  * \param  b, c arguments
  209.  * ------------------------------------------------------------------------ */
  210.  
  211. static void SubCodeFill(tCurrCodeFill *c, const tCurrCodeFill *a, const tCurrCodeFill *b, struct sLayoutCtx *pCtx)
  212. {
  213.   c->FullWordCnt = a->FullWordCnt - b->FullWordCnt;
  214.   if ((c->LastWordFill = a->LastWordFill - b->LastWordFill) < 0)
  215.   {
  216.     c->LastWordFill += pCtx->ElemsPerFullWord;
  217.     c->FullWordCnt--;
  218.   }
  219. }
  220.  
  221. /*!------------------------------------------------------------------------
  222.  * \fn     MultCodeFill(tCurrCodeFill *b, LongWord a, struct sLayoutCtx *pCtx)
  223.  * \brief  perform 'b *= a' on tCurrCodeFill structures
  224.  * \param  b what to multiply
  225.  * \param  a scaling factor
  226.  * ------------------------------------------------------------------------ */
  227.  
  228. static void MultCodeFill(tCurrCodeFill *b, LongWord a, struct sLayoutCtx *pCtx)
  229. {
  230.   b->FullWordCnt *= a;
  231.   b->LastWordFill *= a;
  232.   if (pCtx->ElemsPerFullWord > 1)
  233.   {
  234.     LongWord div = b->LastWordFill / pCtx->ElemsPerFullWord,
  235.              mod = b->LastWordFill % pCtx->ElemsPerFullWord;
  236.     b->FullWordCnt += div;
  237.     b->LastWordFill = mod;
  238.   }
  239. }
  240.  
  241. /*!------------------------------------------------------------------------
  242.  * \fn     IncCodeFill(tCurrCodeFill *a, struct sLayoutCtx *pCtx)
  243.  * \brief  advance tCurrCodeFill pointer by one base element
  244.  * \param  a pointer to increment
  245.  * \param  pCtx context
  246.  * ------------------------------------------------------------------------ */
  247.  
  248. static void IncCodeFill(tCurrCodeFill *a, struct sLayoutCtx *pCtx)
  249. {
  250.   if (++a->LastWordFill >= pCtx->ElemsPerFullWord)
  251.   {
  252.     a->LastWordFill -= pCtx->ElemsPerFullWord;
  253.     a->FullWordCnt++;
  254.   }
  255. }
  256.  
  257. /*!------------------------------------------------------------------------
  258.  * \fn     IncCurrCodeFill(struct sLayoutCtx *pCtx)
  259.  * \brief  advance CodeFill pointer in context and reserve memory
  260.  * \param  pCtx context
  261.  * \return True if success
  262.  * ------------------------------------------------------------------------ */
  263.  
  264. static Boolean IncCurrCodeFill(struct sLayoutCtx *pCtx)
  265. {
  266.   LongInt OldFullWordCnt = pCtx->CurrCodeFill.FullWordCnt;
  267.  
  268.   IncCodeFill(&pCtx->CurrCodeFill, pCtx);
  269.   if (OldFullWordCnt == pCtx->CurrCodeFill.FullWordCnt)
  270.     return True;
  271.   else if (!IncMaxCodeLen(pCtx, 1))
  272.     return False;
  273.   else
  274.   {
  275.     switch (pCtx->FullWordSize)
  276.     {
  277.       case 8:
  278.         BAsmCode[pCtx->CurrCodeFill.FullWordCnt] = 0;
  279.         break;
  280.       case 16:
  281.         WAsmCode[pCtx->CurrCodeFill.FullWordCnt] = 0;
  282.         break;
  283.       case 32:
  284.         DAsmCode[pCtx->CurrCodeFill.FullWordCnt] = 0;
  285.         break;
  286.     }
  287.     return True;
  288.   }
  289. }
  290.  
  291. /*!------------------------------------------------------------------------
  292.  * \fn     IncCodeFillBy(tCurrCodeFill *a, const tCurrCodeFill *inc, struct sLayoutCtx *pCtx)
  293.  * \brief  perform 'a += inc' on tCurrCodeFill structures
  294.  * \param  a what to advance
  295.  * \param  inc by what to advance
  296.  * \param  pCtx context
  297.  * ------------------------------------------------------------------------ */
  298.  
  299. static void IncCodeFillBy(tCurrCodeFill *a, const tCurrCodeFill *inc, struct sLayoutCtx *pCtx)
  300. {
  301.   a->LastWordFill += inc->LastWordFill;
  302.   if ((pCtx->ElemsPerFullWord > 1) && (a->LastWordFill >= pCtx->ElemsPerFullWord))
  303.   {
  304.     a->LastWordFill -= pCtx->ElemsPerFullWord;
  305.     a->FullWordCnt++;
  306.   }
  307.   a->FullWordCnt += inc->FullWordCnt;
  308. }
  309.  
  310. /*****************************************************************************
  311.  * Function:    LayoutNibble
  312.  * Purpose:     parse argument, interprete as nibble,
  313.  *              and put into result buffer
  314.  * Result:      TRUE if no errors occured
  315.  *****************************************************************************/
  316.  
  317. static Boolean Put4I_To_8(Byte b, struct sLayoutCtx *pCtx)
  318. {
  319.   tCurrCodeFill Pos = pCtx->CurrCodeFill;
  320.   if (!IncCurrCodeFill(pCtx))
  321.     return False;
  322.   if (!Pos.LastWordFill)
  323.     BAsmCode[Pos.FullWordCnt] = NibbleInByte(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  324.   else
  325.     BAsmCode[Pos.FullWordCnt] |= NibbleInByte(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  326.   return True;
  327. }
  328.  
  329. static Boolean Replicate4_To_8(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx)
  330. {
  331.   Byte b;
  332.   tCurrCodeFill CurrPos;
  333.  
  334.   CurrPos = *pStartPos;
  335.   while ((CurrPos.FullWordCnt != pEndPos->FullWordCnt) || (CurrPos.LastWordFill != pEndPos->LastWordFill))
  336.   {
  337.     b = NibbleFromByte(BAsmCode[CurrPos.FullWordCnt], CurrPos.LastWordFill ^ pCtx->LoHiMap);
  338.     if (!Put4I_To_8(b, pCtx))
  339.       return False;
  340.     IncCodeFill(&CurrPos, pCtx);
  341.   }
  342.  
  343.   return True;
  344. }
  345.  
  346. static Boolean Put4I_To_16(Byte b, struct sLayoutCtx *pCtx)
  347. {
  348.   tCurrCodeFill Pos = pCtx->CurrCodeFill;
  349.   if (!IncCurrCodeFill(pCtx))
  350.     return False;
  351.   if (!Pos.LastWordFill)
  352.     WAsmCode[Pos.FullWordCnt] = NibbleInWord(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  353.   else
  354.     WAsmCode[Pos.FullWordCnt] |= NibbleInWord(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  355.   return True;
  356. }
  357.  
  358. static Boolean Replicate4_To_16(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx)
  359. {
  360.   Byte b;
  361.   tCurrCodeFill CurrPos;
  362.  
  363.   CurrPos = *pStartPos;
  364.   while ((CurrPos.FullWordCnt != pEndPos->FullWordCnt) || (CurrPos.LastWordFill != pEndPos->LastWordFill))
  365.   {
  366.     b = NibbleFromWord(WAsmCode[CurrPos.FullWordCnt], CurrPos.LastWordFill ^ pCtx->LoHiMap);
  367.     if (!Put4I_To_16(b, pCtx))
  368.       return False;
  369.     IncCodeFill(&CurrPos, pCtx);
  370.   }
  371.  
  372.   return True;
  373. }
  374.  
  375. static Boolean Put4I_To_32(Byte b, struct sLayoutCtx *pCtx)
  376. {
  377.   tCurrCodeFill Pos = pCtx->CurrCodeFill;
  378.   if (!IncCurrCodeFill(pCtx))
  379.     return False;
  380.   if (!Pos.LastWordFill)
  381.     DAsmCode[Pos.FullWordCnt] = NibbleInDWord(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  382.   else
  383.     DAsmCode[Pos.FullWordCnt] |= NibbleInDWord(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  384.   return True;
  385. }
  386.  
  387. static Boolean Replicate4_To_32(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx)
  388. {
  389.   Byte b;
  390.   tCurrCodeFill CurrPos;
  391.  
  392.   CurrPos = *pStartPos;
  393.   while ((CurrPos.FullWordCnt != pEndPos->FullWordCnt) || (CurrPos.LastWordFill != pEndPos->LastWordFill))
  394.   {
  395.     b = NibbleFromDWord(DAsmCode[CurrPos.FullWordCnt], CurrPos.LastWordFill ^ pCtx->LoHiMap);
  396.     if (!Put4I_To_32(b, pCtx))
  397.       return False;
  398.     IncCodeFill(&CurrPos, pCtx);
  399.   }
  400.  
  401.   return True;
  402. }
  403.  
  404. static Boolean LayoutNibble(const tStrComp *pExpr, struct sLayoutCtx *pCtx)
  405. {
  406.   Boolean Result = False;
  407.   TempResult t;
  408.  
  409.   as_tempres_ini(&t);
  410.   EvalStrExpression(pExpr, &t);
  411.   switch (t.Typ)
  412.   {
  413.     case TempInt:
  414.       if (mFirstPassUnknown(t.Flags)) t.Contents.Int &= 0xf;
  415.       if (!mSymbolQuestionable(t.Flags) && !RangeCheck(t.Contents.Int, Int4)) WrStrErrorPos(ErrNum_OverRange, pExpr);
  416.       else
  417.       {
  418.         if (!pCtx->Put4I(t.Contents.Int, pCtx))
  419.           LEAVE;
  420.         Result = True;
  421.       }
  422.       break;
  423.     case TempFloat:
  424.       WrStrErrorPos(ErrNum_IntButFloat, pExpr);
  425.       break;
  426.     case TempString:
  427.       WrStrErrorPos(ErrNum_IntButString, pExpr);
  428.       break;
  429.     default:
  430.       break;
  431.   }
  432.  
  433. func_exit:
  434.   as_tempres_free(&t);
  435.   return Result;
  436. }
  437.  
  438. /*****************************************************************************
  439.  * Function:    LayoutByte
  440.  * Purpose:     parse argument, interprete as byte,
  441.  *              and put into result buffer
  442.  * Result:      TRUE if no errors occured
  443.  *****************************************************************************/
  444.  
  445. static Boolean Put8I_To_8(Byte b, struct sLayoutCtx *pCtx)
  446. {
  447.   if (!IncMaxCodeLen(pCtx, 1))
  448.     return False;
  449.   if ((pCtx->ListGran == 1) || !(pCtx->CurrCodeFill.FullWordCnt & 1))
  450.     BAsmCode[pCtx->CurrCodeFill.FullWordCnt] = b;
  451.   else if (pCtx->flags & eIntPseudoFlag_Turn)
  452.     WAsmCode[pCtx->CurrCodeFill.FullWordCnt >> 1] = (((Word)BAsmCode[pCtx->CurrCodeFill.FullWordCnt - 1]) << 8) | b;
  453.   else
  454.     WAsmCode[pCtx->CurrCodeFill.FullWordCnt >> 1] = (((Word)b) << 8) | BAsmCode[pCtx->CurrCodeFill.FullWordCnt - 1];
  455.   pCtx->CurrCodeFill.FullWordCnt++;
  456.   return True;
  457. }
  458.  
  459. static Boolean Put8I_To_16(Byte b, struct sLayoutCtx *pCtx)
  460. {
  461.   tCurrCodeFill Pos = pCtx->CurrCodeFill;
  462.   if (!IncCurrCodeFill(pCtx))
  463.     return False;
  464.   if (!Pos.LastWordFill)
  465.     WAsmCode[Pos.FullWordCnt] = ByteInWord(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  466.   else
  467.     WAsmCode[Pos.FullWordCnt] |= ByteInWord(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  468.   return True;
  469. }
  470.  
  471. static Boolean Put8I_To_32(Byte b, struct sLayoutCtx *pCtx)
  472. {
  473.   tCurrCodeFill Pos = pCtx->CurrCodeFill;
  474.   if (!IncCurrCodeFill(pCtx))
  475.     return False;
  476.   if (!Pos.LastWordFill)
  477.     DAsmCode[Pos.FullWordCnt] = ByteInDWord(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  478.   else
  479.     DAsmCode[Pos.FullWordCnt] |= ByteInDWord(b, Pos.LastWordFill ^ pCtx->LoHiMap);
  480.   return True;
  481. }
  482.  
  483. static Boolean Replicate8ToN_To_8(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx)
  484. {
  485.   tCurrCodeFill Pos;
  486.  
  487.   if (!IncMaxCodeLen(pCtx, pEndPos->FullWordCnt - pStartPos->FullWordCnt))
  488.     return False;
  489.  
  490.   for (Pos = *pStartPos; Pos.FullWordCnt < pEndPos->FullWordCnt; Pos.FullWordCnt += pCtx->BaseElemLenBits / 8)
  491.   {
  492.     memcpy(&BAsmCode[pCtx->CurrCodeFill.FullWordCnt], &BAsmCode[Pos.FullWordCnt], pCtx->BaseElemLenBits / 8);
  493.     pCtx->CurrCodeFill.FullWordCnt += pCtx->BaseElemLenBits / 8;
  494.   }
  495.   if (Pos.FullWordCnt != pEndPos->FullWordCnt)
  496.   {
  497.     WrXError(ErrNum_InternalError, "DUP replication inconsistency");
  498.     return False;
  499.   }
  500.  
  501.   return True;
  502. }
  503.  
  504. static Boolean Replicate8_To_16(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx)
  505. {
  506.   Byte b;
  507.   tCurrCodeFill CurrPos;
  508.  
  509.   CurrPos = *pStartPos;
  510.   while ((CurrPos.FullWordCnt != pEndPos->FullWordCnt) || (CurrPos.LastWordFill != pEndPos->LastWordFill))
  511.   {
  512.     b = ByteFromWord(WAsmCode[CurrPos.FullWordCnt], CurrPos.LastWordFill ^ pCtx->LoHiMap);
  513.     if (!Put8I_To_16(b, pCtx))
  514.       return False;
  515.     IncCodeFill(&CurrPos, pCtx);
  516.   }
  517.  
  518.   return True;
  519. }
  520.  
  521. static Boolean Replicate8_To_32(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx)
  522. {
  523.   Byte b;
  524.   tCurrCodeFill CurrPos;
  525.  
  526.   CurrPos = *pStartPos;
  527.   while ((CurrPos.FullWordCnt != pEndPos->FullWordCnt) || (CurrPos.LastWordFill != pEndPos->LastWordFill))
  528.   {
  529.     b = ByteFromDWord(DAsmCode[CurrPos.FullWordCnt], CurrPos.LastWordFill ^ pCtx->LoHiMap);
  530.     if (!Put8I_To_32(b, pCtx))
  531.       return False;
  532.     IncCodeFill(&CurrPos, pCtx);
  533.   }
  534.  
  535.   return True;
  536. }
  537.  
  538. static Boolean LayoutByte(const tStrComp *pExpr, struct sLayoutCtx *pCtx)
  539. {
  540.   Boolean Result = False;
  541.   const Boolean allow_int = !!(pCtx->flags & eIntPseudoFlag_AllowInt),
  542.                 allow_string = !!(pCtx->flags & eIntPseudoFlag_AllowString);
  543.   TempResult t;
  544.  
  545.   as_tempres_ini(&t);
  546.   EvalStrExpression(pExpr, &t);
  547.   switch (t.Typ)
  548.   {
  549.     case TempInt:
  550.     ToInt:
  551.       if (mFirstPassUnknown(t.Flags)) t.Contents.Int &= 0xff;
  552.       if (!allow_int) WrStrErrorPos(ErrNum_StringButInt, pExpr);
  553.       else if (!mSymbolQuestionable(t.Flags) && !RangeCheck(t.Contents.Int, Int8)) WrStrErrorPos(ErrNum_OverRange, pExpr);
  554.       else
  555.       {
  556.         if (!pCtx->Put8I(t.Contents.Int, pCtx))
  557.           LEAVE;
  558.         Result = True;
  559.       }
  560.       break;
  561.     case TempFloat:
  562.       WrStrErrorPos((allow_int && allow_string)
  563.                    ? ErrNum_StringOrIntButFloat
  564.                    : (allow_int ? ErrNum_IntButFloat : ErrNum_IntButString), pExpr);
  565.       break;
  566.     case TempString:
  567.     {
  568.       unsigned ch;
  569.       const char *p_run;
  570.       size_t run_len;
  571.       int ret;
  572.       unsigned ascii_flags = pCtx->flags & eIntPseudoFlag_ASCIAll;
  573.  
  574.       if (allow_int && MultiCharToInt(&t, 1))
  575.         goto ToInt;
  576.  
  577.       if (!allow_string)
  578.       {
  579.         WrStrErrorPos(ErrNum_IntButString, pExpr);
  580.         LEAVE;
  581.       }
  582.  
  583.       p_run = t.Contents.str.p_str;
  584.       run_len = t.Contents.str.len;
  585.       if (ascii_flags == eIntPseudoFlag_ASCIC)
  586.       {
  587.         if (run_len > 255)
  588.         {
  589.           WrStrErrorPos(ErrNum_StringTooLong, pExpr);
  590.           LEAVE;
  591.         }
  592.         if (!pCtx->Put8I(run_len, pCtx))
  593.           LEAVE;
  594.       }
  595.       while (!(ret = as_chartrans_xlate_next(CurrTransTable->p_table, &ch, &p_run, &run_len)))
  596.       {
  597.         if (!pCtx->Put8I(ch, pCtx))
  598.           LEAVE;
  599.       }
  600.       if (ENOENT == ret)
  601.       {
  602.         WrStrErrorPos(ErrNum_UnmappedChar, pExpr);
  603.         LEAVE;
  604.       }
  605.       if (ascii_flags == eIntPseudoFlag_ASCIZ)
  606.       {
  607.         if (!pCtx->Put8I('\0', pCtx))
  608.           LEAVE;
  609.       }
  610.  
  611.       Result = True;
  612.       break;
  613.     }
  614.     default:
  615.       break;
  616.   }
  617.  
  618. func_exit:
  619.   as_tempres_free(&t);
  620.   return Result;
  621. }
  622.  
  623. /*****************************************************************************
  624.  * Function:    LayoutWord
  625.  * Purpose:     parse argument, interprete as 16-bit word,
  626.  *              and put into result buffer
  627.  * Result:      TRUE if no errors occured
  628.  *****************************************************************************/
  629.  
  630. static Boolean Put16I_To_8(Word w, struct sLayoutCtx *pCtx)
  631. {
  632.   if (!IncMaxCodeLen(pCtx, 2))
  633.     return False;
  634.   if (pCtx->ListGran == 2)
  635.     WAsmCode[pCtx->CurrCodeFill.FullWordCnt >> 1] = w;
  636.   else
  637.   {
  638.     BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)] = Lo(w);
  639.     BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = Hi(w);
  640.   }
  641.   pCtx->CurrCodeFill.FullWordCnt += 2;
  642.   return True;
  643. }
  644.  
  645. static Boolean Put16F_To_8(as_float_t t, struct sLayoutCtx *pCtx)
  646. {
  647.   int ret;
  648.  
  649.   if (!IncMaxCodeLen(pCtx, 2))
  650.     return False;
  651.   if ((ret = as_float_2_ieee2(t, BAsmCode + pCtx->CurrCodeFill.FullWordCnt, !!pCtx->LoHiMap)) < 0)
  652.   {
  653.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  654.     return False;
  655.   }
  656.   pCtx->CurrCodeFill.FullWordCnt += 2;
  657.   return True;
  658. }
  659.  
  660. static Boolean Put16I_To_16(Word w, struct sLayoutCtx *pCtx)
  661. {
  662.   if (!IncMaxCodeLen(pCtx, 1))
  663.     return False;
  664.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt++] = w;
  665.   return True;
  666. }
  667.  
  668. static Boolean Put16F_To_16(as_float_t t, struct sLayoutCtx *pCtx)
  669. {
  670.   Byte Tmp[2];
  671.   int ret;
  672.  
  673.   if (!IncMaxCodeLen(pCtx, 1))
  674.     return False;
  675.  
  676.   if ((ret = as_float_2_ieee2(t, Tmp, !!pCtx->LoHiMap)) < 0)
  677.   {
  678.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  679.     return False;
  680.   }
  681.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = ByteInWord(Tmp[0], 0 ^ pCtx->LoHiMap) | ByteInWord(Tmp[1], 1 ^ pCtx->LoHiMap);
  682.   pCtx->CurrCodeFill.FullWordCnt += 1;
  683.   return True;
  684. }
  685.  
  686. static Boolean Put16I_To_32(Word w, struct sLayoutCtx *pCtx)
  687. {
  688.   tCurrCodeFill Pos = pCtx->CurrCodeFill;
  689.   if (!IncCurrCodeFill(pCtx))
  690.     return False;
  691.   if (!Pos.LastWordFill)
  692.     DAsmCode[Pos.FullWordCnt] = WordInDWord(w, Pos.LastWordFill ^ pCtx->LoHiMap);
  693.   else
  694.     DAsmCode[Pos.FullWordCnt] |= WordInDWord(w, Pos.LastWordFill ^ pCtx->LoHiMap);
  695.   return True;
  696. }
  697.  
  698. static Boolean Put16F_To_32(as_float_t t, struct sLayoutCtx *pCtx)
  699. {
  700.   Byte Tmp[2];
  701.   int ret;
  702.  
  703.   if ((ret = as_float_2_ieee2(t, Tmp, False)) < 0)
  704.   {
  705.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  706.     return False;
  707.   }
  708.   return Put16I_To_32((((Word) Tmp[1]) << 8) | Tmp[0], pCtx);
  709. }
  710.  
  711. static Boolean Replicate16_To_32(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx)
  712. {
  713.   Word w;
  714.   tCurrCodeFill CurrPos;
  715.  
  716.   CurrPos = *pStartPos;
  717.   while ((CurrPos.FullWordCnt != pEndPos->FullWordCnt) || (CurrPos.LastWordFill != pEndPos->LastWordFill))
  718.   {
  719.     w = WordFromDWord(DAsmCode[CurrPos.FullWordCnt], CurrPos.LastWordFill ^ pCtx->LoHiMap);
  720.     if (!Put16I_To_32(w, pCtx))
  721.       return False;
  722.     IncCodeFill(&CurrPos, pCtx);
  723.   }
  724.  
  725.   return True;
  726. }
  727.  
  728. static Boolean Replicate16ToN_To_16(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx)
  729. {
  730.   tCurrCodeFill Pos;
  731.  
  732.   if (!IncMaxCodeLen(pCtx, pEndPos->FullWordCnt - pStartPos->FullWordCnt))
  733.     return False;
  734.  
  735.   for (Pos = *pStartPos; Pos.FullWordCnt < pEndPos->FullWordCnt; Pos.FullWordCnt += pCtx->BaseElemLenBits / 16)
  736.   {
  737.     memcpy(&WAsmCode[pCtx->CurrCodeFill.FullWordCnt], &WAsmCode[Pos.FullWordCnt], pCtx->BaseElemLenBits / 8);
  738.     pCtx->CurrCodeFill.FullWordCnt += pCtx->BaseElemLenBits / 16;
  739.   }
  740.   if (Pos.FullWordCnt != pEndPos->FullWordCnt)
  741.   {
  742.     WrXError(ErrNum_InternalError, "DUP replication inconsistency");
  743.     return False;
  744.   }
  745.  
  746.   return True;
  747. }
  748.  
  749. static Boolean LayoutWord(const tStrComp *pExpr, struct sLayoutCtx *pCtx)
  750. {
  751.   Boolean Result = False;
  752.   const Boolean allow_string = !!(pCtx->flags & eIntPseudoFlag_AllowString),
  753.                 allow_int = !!(pCtx->flags & eIntPseudoFlag_AllowInt),
  754.                 allow_float = !!pCtx->Put16F;
  755.   TempResult t;
  756.  
  757.   as_tempres_ini(&t);
  758.   EvalStrExpression(pExpr, &t);
  759.   Result = True;
  760.   switch (t.Typ)
  761.   {
  762.     case TempInt:
  763.     ToInt:
  764.       if (pCtx->Put16I)
  765.       {
  766.         if (mFirstPassUnknown(t.Flags)) t.Contents.Int &= 0xffff;
  767.         if (!mSymbolQuestionable(t.Flags) && !RangeCheck(t.Contents.Int, Int16)) WrStrErrorPos(ErrNum_OverRange, pExpr);
  768.         else
  769.         {
  770.           if (!pCtx->Put16I(t.Contents.Int, pCtx))
  771.             LEAVE;
  772.           Result = True;
  773.         }
  774.         break;
  775.       }
  776.       else
  777.         TempResultToFloat(&t);
  778.       /* fall-through */
  779.     case TempFloat:
  780.       if (!allow_float) WrStrErrorPos(allow_string ? ErrNum_StringOrIntButFloat : ErrNum_IntButFloat, pExpr);
  781.       else
  782.       {
  783.         if (!pCtx->Put16F(t.Contents.Float, pCtx))
  784.           LEAVE;
  785.         Result = True;
  786.       }
  787.       break;
  788.     case TempString:
  789.       if (allow_int && MultiCharToInt(&t, 2))
  790.         goto ToInt;
  791.  
  792.       if (!allow_string) WrStrErrorPos(allow_float ? ErrNum_IntOrFloatButString : ErrNum_IntButString, pExpr);
  793.       else
  794.       {
  795.         unsigned z;
  796.  
  797.         if (as_chartrans_xlate_nonz_dynstr(CurrTransTable->p_table, &t.Contents.str, pExpr))
  798.           LEAVE;
  799.  
  800.         for (z = 0; z < t.Contents.str.len; z++)
  801.           if (!pCtx->Put16I(t.Contents.str.p_str[z], pCtx))
  802.             LEAVE;
  803.  
  804.         Result = True;
  805.       }
  806.       break;
  807.     case TempReg:
  808.       if (allow_float && allow_string)
  809.         WrStrErrorPos(ErrNum_StringOrIntOrFloatButReg, pExpr);
  810.       else if (allow_float)
  811.         WrStrErrorPos(ErrNum_IntOrFloatButReg, pExpr);
  812.       else if (allow_string)
  813.         WrStrErrorPos(ErrNum_IntOrStringButReg, pExpr);
  814.       else
  815.         WrStrErrorPos(ErrNum_IntButReg, pExpr);
  816.       break;
  817.     default:
  818.       break;
  819.   }
  820.  
  821. func_exit:
  822.   as_tempres_free(&t);
  823.   return Result;
  824. }
  825.  
  826. /*****************************************************************************
  827.  * Function:    LayoutDoubleWord
  828.  * Purpose:     parse argument, interprete as 32-bit word or
  829.                 single precision float, and put into result buffer
  830.  * Result:      TRUE if no errors occured
  831.  *****************************************************************************/
  832.  
  833. static Boolean Put32I_To_8(LongWord l, struct sLayoutCtx *pCtx)
  834. {
  835.   if (!IncMaxCodeLen(pCtx, 4))
  836.     return False;
  837.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)] = (l      ) & 0xff;
  838.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = (l >>  8) & 0xff;
  839.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ pCtx->LoHiMap)] = (l >> 16) & 0xff;
  840.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ pCtx->LoHiMap)] = (l >> 24) & 0xff;
  841.   pCtx->CurrCodeFill.FullWordCnt += 4;
  842.   return True;
  843. }
  844.  
  845. static Boolean Put32F_To_8(as_float_t t, struct sLayoutCtx *pCtx)
  846. {
  847.   int ret;
  848.  
  849.   if (!IncMaxCodeLen(pCtx, 4))
  850.     return False;
  851.  
  852.   if (pCtx->flags & eIntPseudoFlag_DECFormat)
  853.   {
  854.     Word *p_dest = WAsmCode + (pCtx->CurrCodeFill.FullWordCnt / 2);
  855.  
  856.     ret = as_float_2_dec_f(t, p_dest);
  857.     if ((ret >= 0) && (HostBigEndian && (ListGran() == 1)))
  858.       WSwap(p_dest, 4);
  859.   }
  860.   else
  861.     ret = as_float_2_ieee4(t, BAsmCode + pCtx->CurrCodeFill.FullWordCnt, !!pCtx->LoHiMap);
  862.  
  863.   if (ret < 0)
  864.   {
  865.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  866.     return False;
  867.   }
  868.  
  869.   pCtx->CurrCodeFill.FullWordCnt += 4;
  870.   return True;
  871. }
  872.  
  873. static Boolean Put32I_To_16(LongWord l, struct sLayoutCtx *pCtx)
  874. {
  875.   if (!IncMaxCodeLen(pCtx, 2))
  876.     return False;
  877.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)] = LoWord(l);
  878.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = HiWord(l);
  879.   pCtx->CurrCodeFill.FullWordCnt += 2;
  880.   return True;
  881. }
  882.  
  883. static Boolean Put32F_To_16(as_float_t t, struct sLayoutCtx *pCtx)
  884. {
  885.   Byte Tmp[4];
  886.   int ret;
  887.  
  888.   if (!IncMaxCodeLen(pCtx, 2))
  889.     return False;
  890.   if ((ret = as_float_2_ieee4(t, Tmp, !!pCtx->LoHiMap)) < 0)
  891.   {
  892.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  893.     return False;
  894.   }
  895.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = ByteInWord(Tmp[0], 0 ^ pCtx->LoHiMap) | ByteInWord(Tmp[1], 1 ^ pCtx->LoHiMap);
  896.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 1] = ByteInWord(Tmp[2], 0 ^ pCtx->LoHiMap) | ByteInWord(Tmp[3], 1 ^ pCtx->LoHiMap);
  897.   pCtx->CurrCodeFill.FullWordCnt += 2;
  898.   return True;
  899. }
  900.  
  901. static Boolean Put32I_To_32(LongWord w, struct sLayoutCtx *pCtx)
  902. {
  903.   if (!IncMaxCodeLen(pCtx, 1))
  904.     return False;
  905.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt++] = w;
  906.   return True;
  907. }
  908.  
  909. static Boolean Put32F_To_32(as_float_t t, struct sLayoutCtx *pCtx)
  910. {
  911.   Byte Tmp[4];
  912.   int ret;
  913.  
  914.   if (!IncMaxCodeLen(pCtx, 1))
  915.     return False;
  916.  
  917.   if ((ret = as_float_2_ieee4(t, Tmp, False)) < 0)
  918.   {
  919.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  920.     return False;
  921.   }
  922.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] =
  923.     ByteInDWord(Tmp[0], 0) |
  924.     ByteInDWord(Tmp[1], 1) |
  925.     ByteInDWord(Tmp[2], 2) |
  926.     ByteInDWord(Tmp[3], 3);
  927.   pCtx->CurrCodeFill.FullWordCnt += 1;
  928.   return True;
  929. }
  930.  
  931. static Boolean Replicate32ToN_To_32(const tCurrCodeFill *pStartPos, const tCurrCodeFill *pEndPos, struct sLayoutCtx *pCtx)
  932. {
  933.   tCurrCodeFill Pos;
  934.   /* need roundup for DT since 80 bit value needs 3 dwords: */
  935.   size_t roundup_words_per_element = (pCtx->BaseElemLenBits + 31) / 32,
  936.          roundup_bytes_per_element = roundup_words_per_element * 4;
  937.  
  938.   if (!IncMaxCodeLen(pCtx, pEndPos->FullWordCnt - pStartPos->FullWordCnt))
  939.     return False;
  940.  
  941.   for (Pos = *pStartPos; Pos.FullWordCnt < pEndPos->FullWordCnt; Pos.FullWordCnt += roundup_words_per_element)
  942.   {
  943.     memcpy(&DAsmCode[pCtx->CurrCodeFill.FullWordCnt], &DAsmCode[Pos.FullWordCnt], roundup_bytes_per_element);
  944.     pCtx->CurrCodeFill.FullWordCnt += roundup_words_per_element;
  945.   }
  946.   if (Pos.FullWordCnt != pEndPos->FullWordCnt)
  947.   {
  948.     WrXError(ErrNum_InternalError, "DUP replication inconsistency");
  949.     return False;
  950.   }
  951.  
  952.   return True;
  953. }
  954.  
  955. static Boolean LayoutDoubleWord(const tStrComp *pExpr, struct sLayoutCtx *pCtx)
  956. {
  957.   TempResult erg;
  958.   Boolean Result = False;
  959.   const Boolean allow_string = !!(pCtx->flags & eIntPseudoFlag_AllowString),
  960.                 allow_float = !!pCtx->Put32F;
  961.   Word Cnt = 0;
  962.  
  963.   as_tempres_ini(&erg);
  964.   EvalStrExpression(pExpr, &erg);
  965.   Result = False;
  966.   switch (erg.Typ)
  967.   {
  968.     case TempNone:
  969.       break;
  970.     case TempInt:
  971.     ToInt:
  972.       if (pCtx->Put32I)
  973.       {
  974.         if (mFirstPassUnknown(erg.Flags)) erg.Contents.Int &= 0xfffffffful;
  975.         if (!mSymbolQuestionable(erg.Flags) && !RangeCheck(erg.Contents.Int, Int32)) WrStrErrorPos(ErrNum_OverRange, pExpr);
  976.         else
  977.         {
  978.           if (!pCtx->Put32I(erg.Contents.Int, pCtx))
  979.             LEAVE;
  980.           Cnt = 4;
  981.           Result = True;
  982.         }
  983.         break;
  984.       }
  985.       else
  986.         TempResultToFloat(&erg);
  987.       /* fall-through */
  988.     case TempFloat:
  989.       if (!allow_float) WrStrErrorPos(allow_string ? ErrNum_StringOrIntButFloat : ErrNum_IntButFloat, pExpr);
  990.       else
  991.       {
  992.         if (!pCtx->Put32F(erg.Contents.Float, pCtx))
  993.           LEAVE;
  994.         Cnt = 4;
  995.         Result = True;
  996.       }
  997.       break;
  998.     case TempString:
  999.       if (!allow_string) WrStrErrorPos(allow_float ? ErrNum_IntOrFloatButString : ErrNum_IntButString, pExpr);
  1000.       else
  1001.       {
  1002.         unsigned z;
  1003.  
  1004.         if (MultiCharToInt(&erg, 4))
  1005.           goto ToInt;
  1006.  
  1007.         if (as_chartrans_xlate_nonz_dynstr(CurrTransTable->p_table, &erg.Contents.str, pExpr))
  1008.           WrStrErrorPos(ErrNum_UnmappedChar, pExpr);
  1009.  
  1010.         for (z = 0; z < erg.Contents.str.len; z++)
  1011.           if (!pCtx->Put32I(erg.Contents.str.p_str[z], pCtx))
  1012.             LEAVE;
  1013.  
  1014.         Cnt = erg.Contents.str.len * 4;
  1015.         Result = True;
  1016.       }
  1017.       break;
  1018.     case TempReg:
  1019.       if (allow_float && allow_string)
  1020.         WrStrErrorPos(ErrNum_StringOrIntOrFloatButReg, pExpr);
  1021.       else if (allow_float)
  1022.         WrStrErrorPos(ErrNum_IntOrFloatButReg, pExpr);
  1023.       else if (allow_string)
  1024.         WrStrErrorPos(ErrNum_IntOrStringButReg, pExpr);
  1025.       else
  1026.         WrStrErrorPos(ErrNum_IntButReg, pExpr);
  1027.       break;
  1028.     case TempAll:
  1029.       assert(0);
  1030.   }
  1031.   (void)Cnt;
  1032.  
  1033. func_exit:
  1034.   as_tempres_free(&erg);
  1035.   return Result;
  1036. }
  1037.  
  1038.  
  1039. /*****************************************************************************
  1040.  * Function:    LayoutMacAddr
  1041.  * Purpose:     parse argument, interprete as 48-bit word or
  1042.                 float, and put into result buffer
  1043.  * Result:      TRUE if no errors occured
  1044.  *****************************************************************************/
  1045.  
  1046. static Boolean Put48I_To_8(LargeWord l, struct sLayoutCtx *pCtx)
  1047. {
  1048.   if (!IncMaxCodeLen(pCtx, 6))
  1049.     return False;
  1050.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)      ] = (l      ) & 0xff;
  1051.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)      ] = (l >>  8) & 0xff;
  1052.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ (pCtx->LoHiMap & 1))] = (l >> 16) & 0xff;
  1053.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ (pCtx->LoHiMap & 1))] = (l >> 24) & 0xff;
  1054. #ifdef HAS64
  1055.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (4 ^ pCtx->LoHiMap)      ] = (l >> 32) & 0xff;
  1056.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (5 ^ pCtx->LoHiMap)      ] = (l >> 40) & 0xff;
  1057. #else
  1058.   /* TempResult is TempInt, so sign-extend */
  1059.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (4 ^ pCtx->LoHiMap)      ] =
  1060.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (5 ^ pCtx->LoHiMap)      ] = (l & 0x80000000ul) ? 0xff : 0x00;
  1061. #endif
  1062.   pCtx->CurrCodeFill.FullWordCnt += 6;
  1063.   return True;
  1064. }
  1065.  
  1066. static Boolean Put48F_To_8(as_float_t t, struct sLayoutCtx *pCtx)
  1067. {
  1068.   /* make space for 8 bytes - last word of D format float is truncated */
  1069.   if (!IncMaxCodeLen(pCtx, 8))
  1070.     return False;
  1071.   if (pCtx->flags & eIntPseudoFlag_DECFormat)
  1072.   {
  1073.     /* LoHiMap (endianess) is ignored */
  1074.     int ret = as_float_2_dec_d(t, WAsmCode + (pCtx->CurrCodeFill.FullWordCnt / 2));
  1075.     if (ret < 0)
  1076.     {
  1077.       asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1078.       return False;
  1079.     }
  1080.   }
  1081.   else
  1082.     assert(0);  /* no 6 byte IEEE float format */
  1083.   pCtx->CurrCodeFill.FullWordCnt += 6;
  1084.   return True;
  1085. }
  1086.  
  1087. static Boolean Put48I_To_16(LargeWord l, struct sLayoutCtx *pCtx)
  1088. {
  1089.   int LoHiMap = pCtx->LoHiMap ? 2 : 0; /* 5 or 0 -> 2 or 0 */
  1090.  
  1091.   if (!IncMaxCodeLen(pCtx, 3))
  1092.     return False;
  1093.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ LoHiMap)      ] = (l      ) & 0xffff;
  1094.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ (LoHiMap & 1))] = (l >> 16) & 0xffff;
  1095. #ifdef HAS64
  1096.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ LoHiMap)      ] = (l >> 32) & 0xffff;
  1097. #else
  1098.   /* TempResult is TempInt, so sign-extend */
  1099.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ LoHiMap)      ] = (l & 0x80000000ul) ? 0xffff : 0x0000;
  1100. #endif
  1101.   pCtx->CurrCodeFill.FullWordCnt += 3;
  1102.   return True;
  1103. }
  1104.  
  1105. static Boolean Put48F_To_16(as_float_t t, struct sLayoutCtx *pCtx)
  1106. {
  1107.   if (!IncMaxCodeLen(pCtx, 3))
  1108.     return False;
  1109.   if (pCtx->flags & eIntPseudoFlag_DECFormat)
  1110.   {
  1111.     Word Tmp[4];
  1112.     int ret = as_float_2_dec_d(t, Tmp);
  1113.     if (ret < 0)
  1114.     {
  1115.       asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1116.       return False;
  1117.     }
  1118.     /* LoHiMap (endianess) is ignored */
  1119.     memcpy(&WAsmCode[pCtx->CurrCodeFill.FullWordCnt], Tmp, 6);
  1120.   }
  1121.   else
  1122.     assert(0);  /* no 6 byte IEEE float format */
  1123.   pCtx->CurrCodeFill.FullWordCnt += 3;
  1124.   return True;
  1125. }
  1126.  
  1127. static Boolean Put48I_To_32(LargeWord l, struct sLayoutCtx *pCtx)
  1128. {
  1129.   int LoHiMap = pCtx->LoHiMap ? 2 : 0; /* 5 or 0 -> 2 or 0 */
  1130.  
  1131.   if (!IncMaxCodeLen(pCtx, 2))
  1132.     return False;
  1133.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ LoHiMap)] = (l      ) & 0xfffffffful;
  1134. #ifdef HAS64
  1135.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ LoHiMap)] = (l >> 32) & 0x0000fffful;
  1136. #else
  1137.   /* TempResult is TempInt, so sign-extend */
  1138.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ LoHiMap)] = (l & 0x80000000ul) ? 0xfffful : 0x0000ul;
  1139. #endif
  1140.   pCtx->CurrCodeFill.FullWordCnt += 2;
  1141.   return True;
  1142. }
  1143.  
  1144. static Boolean Put48F_To_32(as_float_t t, struct sLayoutCtx *pCtx)
  1145. {
  1146.   if (!IncMaxCodeLen(pCtx, 2))
  1147.     return False;
  1148.   if (pCtx->flags & eIntPseudoFlag_DECFormat)
  1149.   {
  1150.     Word Tmp[4];
  1151.     int ret = as_float_2_dec_d(t, Tmp);
  1152.     if (ret < 0)
  1153.     {
  1154.       asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1155.       return False;
  1156.     }
  1157.     /* LoHiMap (endianess) is ignored */
  1158.     DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = WordInDWord(Tmp[0], 0);
  1159.     DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 1] = WordInDWord(Tmp[1], 1) | WordInDWord(Tmp[2], 2);
  1160.   }
  1161.   else
  1162.     assert(0);  /* no 6 byte IEEE float format */
  1163.   pCtx->CurrCodeFill.FullWordCnt += 2;
  1164.   return True;
  1165. }
  1166.  
  1167. static Boolean LayoutMacAddr(const tStrComp *pExpr, struct sLayoutCtx *pCtx)
  1168. {
  1169.   Boolean Result = False;
  1170.   TempResult erg;
  1171.   Word Cnt  = 0;
  1172.  
  1173.   as_tempres_ini(&erg);
  1174.   EvalStrExpression(pExpr, &erg);
  1175.   Result = False;
  1176.   switch(erg.Typ)
  1177.   {
  1178.     case TempNone:
  1179.       break;
  1180.     case TempInt:
  1181.     ToInt:
  1182.       if (pCtx->Put48I)
  1183.       {
  1184.         if (!pCtx->Put64I(erg.Contents.Int, pCtx))
  1185.           LEAVE;
  1186.         Cnt = 6;
  1187.         Result = True;
  1188.         break;
  1189.       }
  1190.       else
  1191.         TempResultToFloat(&erg);
  1192.       /* fall-through */
  1193.     case TempFloat:
  1194.       if (!pCtx->Put48F) WrStrErrorPos(ErrNum_StringOrIntButFloat, pExpr);
  1195.       else if (!pCtx->Put48F(erg.Contents.Float, pCtx))
  1196.         LEAVE;
  1197.       Cnt = 6;
  1198.       Result = True;
  1199.       break;
  1200.     case TempString:
  1201.     {
  1202.       unsigned z;
  1203.  
  1204.       if (MultiCharToInt(&erg, 6))
  1205.         goto ToInt;
  1206.  
  1207.       if (as_chartrans_xlate_nonz_dynstr(CurrTransTable->p_table, &erg.Contents.str, pExpr))
  1208.         LEAVE;
  1209.  
  1210.       for (z = 0; z < erg.Contents.str.len; z++)
  1211.         if (!pCtx->Put48I(erg.Contents.str.p_str[z], pCtx))
  1212.           LEAVE;
  1213.  
  1214.       Cnt = erg.Contents.str.len * 6;
  1215.       Result = True;
  1216.       break;
  1217.     }
  1218.     case TempReg:
  1219.       WrStrErrorPos(ErrNum_StringOrIntOrFloatButReg, pExpr);
  1220.       break;
  1221.     case TempAll:
  1222.       assert(0);
  1223.   }
  1224.   (void)Cnt;
  1225.  
  1226. func_exit:
  1227.   as_tempres_free(&erg);
  1228.   return Result;
  1229. }
  1230.  
  1231. /*****************************************************************************
  1232.  * Function:    LayoutQuadWord
  1233.  * Purpose:     parse argument, interprete as 64-bit word or
  1234.                 double precision float, and put into result buffer
  1235.  * Result:      TRUE if no errors occured
  1236.  *****************************************************************************/
  1237.  
  1238. static Boolean Put64I_To_8(LargeWord l, struct sLayoutCtx *pCtx)
  1239. {
  1240.   if (!IncMaxCodeLen(pCtx, 8))
  1241.     return False;
  1242.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)] = (l      ) & 0xff;
  1243.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = (l >>  8) & 0xff;
  1244.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ pCtx->LoHiMap)] = (l >> 16) & 0xff;
  1245.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ pCtx->LoHiMap)] = (l >> 24) & 0xff;
  1246. #ifdef HAS64
  1247.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (4 ^ pCtx->LoHiMap)] = (l >> 32) & 0xff;
  1248.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (5 ^ pCtx->LoHiMap)] = (l >> 40) & 0xff;
  1249.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (6 ^ pCtx->LoHiMap)] = (l >> 48) & 0xff;
  1250.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (7 ^ pCtx->LoHiMap)] = (l >> 56) & 0xff;
  1251. #else
  1252.   /* TempResult is TempInt, so sign-extend */
  1253.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (4 ^ pCtx->LoHiMap)] =
  1254.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (5 ^ pCtx->LoHiMap)] =
  1255.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (6 ^ pCtx->LoHiMap)] =
  1256.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (7 ^ pCtx->LoHiMap)] = (l & 0x80000000ul) ? 0xff : 0x00;
  1257. #endif
  1258.   pCtx->CurrCodeFill.FullWordCnt += 8;
  1259.   return True;
  1260. }
  1261.  
  1262. static Boolean Put64F_To_8(as_float_t t, struct sLayoutCtx *pCtx)
  1263. {
  1264.   int ret;
  1265.  
  1266.   if (!IncMaxCodeLen(pCtx, 8))
  1267.     return False;
  1268.  
  1269.   if (pCtx->flags & eIntPseudoFlag_DECFormats)
  1270.   {
  1271.     Word *p_dest = WAsmCode + (pCtx->CurrCodeFill.FullWordCnt / 2);
  1272.     ret = (pCtx->flags & eIntPseudoFlag_DECGFormat)
  1273.         ? as_float_2_dec_g(t, p_dest)
  1274.         : as_float_2_dec_d(t, p_dest);
  1275.     if ((ret >= 0) && (HostBigEndian && (ListGran() == 1)))
  1276.       WSwap(p_dest, 8);
  1277.   }
  1278.   else
  1279.     ret = as_float_2_ieee8(t, BAsmCode + pCtx->CurrCodeFill.FullWordCnt, !!pCtx->LoHiMap);
  1280.  
  1281.   if (ret < 0)
  1282.   {
  1283.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1284.     return False;
  1285.   }
  1286.  
  1287.   pCtx->CurrCodeFill.FullWordCnt += 8;
  1288.   return True;
  1289. }
  1290.  
  1291. static Boolean Put64I_To_16(LargeWord l, struct sLayoutCtx *pCtx)
  1292. {
  1293.   if (!IncMaxCodeLen(pCtx, 4))
  1294.     return False;
  1295.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)] = (l      ) & 0xffff;
  1296.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = (l >> 16) & 0xffff;
  1297. #ifdef HAS64
  1298.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ pCtx->LoHiMap)] = (l >> 32) & 0xffff;
  1299.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ pCtx->LoHiMap)] = (l >> 48) & 0xffff;
  1300. #else
  1301.   /* TempResult is TempInt, so sign-extend */
  1302.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ pCtx->LoHiMap)] =
  1303.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ pCtx->LoHiMap)] = (l & 0x80000000ul) ? 0xffff : 0x0000;
  1304. #endif
  1305.   pCtx->CurrCodeFill.FullWordCnt += 4;
  1306.   return True;
  1307. }
  1308.  
  1309. static Boolean Put64F_To_16(as_float_t t, struct sLayoutCtx *pCtx)
  1310. {
  1311.   Byte Tmp[8];
  1312.   int ret;
  1313.   int LoHiMap = pCtx->LoHiMap & 1;
  1314.  
  1315.   if (!IncMaxCodeLen(pCtx, 4))
  1316.     return False;
  1317.   if ((ret = as_float_2_ieee8(t, Tmp, !!pCtx->LoHiMap)) < 0)
  1318.   {
  1319.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1320.     return False;
  1321.   }
  1322.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = ByteInWord(Tmp[0], 0 ^ LoHiMap) | ByteInWord(Tmp[1], 1 ^ LoHiMap);
  1323.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 1] = ByteInWord(Tmp[2], 0 ^ LoHiMap) | ByteInWord(Tmp[3], 1 ^ LoHiMap);
  1324.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 2] = ByteInWord(Tmp[4], 0 ^ LoHiMap) | ByteInWord(Tmp[5], 1 ^ LoHiMap);
  1325.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 3] = ByteInWord(Tmp[6], 0 ^ LoHiMap) | ByteInWord(Tmp[7], 1 ^ LoHiMap);
  1326.   pCtx->CurrCodeFill.FullWordCnt += 4;
  1327.   return True;
  1328. }
  1329.  
  1330. static Boolean Put64I_To_32(LargeWord l, struct sLayoutCtx *pCtx)
  1331. {
  1332.   if (!IncMaxCodeLen(pCtx, 2))
  1333.     return False;
  1334.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)] = (l      ) & 0xfffffffful;
  1335. #ifdef HAS64
  1336.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = (l >> 32) & 0xfffffffful;
  1337. #else
  1338.   /* TempResult is TempInt, so sign-extend */
  1339.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = (l & 0x80000000ul) ? 0xfffffffful : 0x00000000ul;
  1340. #endif
  1341.   pCtx->CurrCodeFill.FullWordCnt += 2;
  1342.   return True;
  1343. }
  1344.  
  1345. static Boolean Put64F_To_32(as_float_t t, struct sLayoutCtx *pCtx)
  1346. {
  1347.   Byte Tmp[8];
  1348.   int ret;
  1349.   int LoHiMap = pCtx->LoHiMap ? 3 : 0;
  1350.  
  1351.   if (!IncMaxCodeLen(pCtx, 2))
  1352.     return False;
  1353.   if ((ret = as_float_2_ieee8(t, Tmp, !!pCtx->LoHiMap)) < 0)
  1354.   {
  1355.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1356.     return False;
  1357.   }
  1358.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = ByteInDWord(Tmp[0], 0 ^ LoHiMap) | ByteInDWord(Tmp[1], 1 ^ LoHiMap) | ByteInDWord(Tmp[2], 2 ^ LoHiMap) | ByteInDWord(Tmp[3], 3 ^ LoHiMap);
  1359.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 1] = ByteInDWord(Tmp[4], 0 ^ LoHiMap) | ByteInDWord(Tmp[5], 1 ^ LoHiMap) | ByteInDWord(Tmp[6], 2 ^ LoHiMap) | ByteInDWord(Tmp[7], 3 ^ LoHiMap);
  1360.   pCtx->CurrCodeFill.FullWordCnt += 2;
  1361.   return True;
  1362. }
  1363.  
  1364. static Boolean LayoutQuadWord(const tStrComp *pExpr, struct sLayoutCtx *pCtx)
  1365. {
  1366.   Boolean Result = False;
  1367.   const Boolean allow_string = !!(pCtx->flags & eIntPseudoFlag_AllowString),
  1368.                 allow_float = !!pCtx->Put64F;
  1369.   TempResult erg;
  1370.   Word Cnt  = 0;
  1371.  
  1372.   as_tempres_ini(&erg);
  1373.   EvalStrExpression(pExpr, &erg);
  1374.   Result = False;
  1375.   switch (erg.Typ)
  1376.   {
  1377.     case TempNone:
  1378.       break;
  1379.     case TempInt:
  1380.     ToInt:
  1381.       if (pCtx->Put64I)
  1382.       {
  1383.         if (!pCtx->Put64I(erg.Contents.Int, pCtx))
  1384.           LEAVE;
  1385.         Cnt = 8;
  1386.         Result = True;
  1387.         break;
  1388.       }
  1389.       else
  1390.         TempResultToFloat(&erg);
  1391.       /* fall-through */
  1392.     case TempFloat:
  1393.       if (!allow_float) WrStrErrorPos(ErrNum_StringOrIntButFloat, pExpr);
  1394.       else if (!pCtx->Put64F(erg.Contents.Float, pCtx))
  1395.         LEAVE;
  1396.       Cnt = 8;
  1397.       Result = True;
  1398.       break;
  1399.     case TempString:
  1400.       if (!allow_string) WrStrErrorPos(allow_float ? ErrNum_IntOrFloatButString : ErrNum_IntButString, pExpr);
  1401.       else
  1402.       {
  1403.          unsigned z;
  1404.  
  1405.         if (MultiCharToInt(&erg, 8))
  1406.           goto ToInt;
  1407.  
  1408.         if (as_chartrans_xlate_nonz_dynstr(CurrTransTable->p_table, &erg.Contents.str, pExpr))
  1409.           LEAVE;
  1410.  
  1411.         for (z = 0; z < erg.Contents.str.len; z++)
  1412.           if (!pCtx->Put64I(erg.Contents.str.p_str[z], pCtx))
  1413.             LEAVE;
  1414.  
  1415.         Cnt = erg.Contents.str.len * 8;
  1416.         Result = True;
  1417.       }
  1418.       break;
  1419.     case TempReg:
  1420.       WrStrErrorPos(ErrNum_StringOrIntOrFloatButReg, pExpr);
  1421.       break;
  1422.     case TempAll:
  1423.       assert(0);
  1424.   }
  1425.   (void)Cnt;
  1426.  
  1427. func_exit:
  1428.   as_tempres_free(&erg);
  1429.   return Result;
  1430. }
  1431.  
  1432. /*****************************************************************************
  1433.  * Function:    LayoutTenBytes
  1434.  * Purpose:     parse argument, interprete extended precision float,
  1435.  *              and put into result buffer
  1436.  * Result:      TRUE if no errors occured
  1437.  *****************************************************************************/
  1438.  
  1439. static Boolean Put80I_To_8(LargeWord t, Boolean orig_negative, struct sLayoutCtx *p_ctx)
  1440. {
  1441.   unsigned dest, bit_pos;
  1442.   Byte digit;
  1443.  
  1444.   if (!IncMaxCodeLen(p_ctx, 10))
  1445.     return False;
  1446.   memset(&BAsmCode[p_ctx->CurrCodeFill.FullWordCnt], 0, 10);
  1447.  
  1448.   if (orig_negative)
  1449.     t = (LargeWord)(0 - ((LargeInt)t));
  1450.   dest = bit_pos = 0;
  1451.   while (t)
  1452.   {
  1453.     digit = (t % 10) << bit_pos;
  1454.     t /= 10;
  1455.     if (p_ctx->LoHiMap)
  1456.       BAsmCode[p_ctx->CurrCodeFill.FullWordCnt + (9 - dest)] |= digit;
  1457.     else
  1458.       BAsmCode[p_ctx->CurrCodeFill.FullWordCnt + dest] |= digit;
  1459.     if ((bit_pos += 4) >= 8)
  1460.     {
  1461.       bit_pos = 0;
  1462.       dest++;
  1463.     }
  1464.     if ((dest >= 9) && t)
  1465.     {
  1466.       WrError(orig_negative ? ErrNum_UnderRange : ErrNum_OverRange);
  1467.       return False;
  1468.     }
  1469.   }
  1470.   digit = !!orig_negative << 7;
  1471.   if (p_ctx->LoHiMap)
  1472.     BAsmCode[p_ctx->CurrCodeFill.FullWordCnt + 0] |= digit;
  1473.   else
  1474.     BAsmCode[p_ctx->CurrCodeFill.FullWordCnt + 9] |= digit;
  1475.   p_ctx->CurrCodeFill.FullWordCnt += 10;
  1476.   return True;
  1477. }
  1478.  
  1479. static Boolean Put80I_To_16(LargeWord t, Boolean orig_negative, struct sLayoutCtx *p_ctx)
  1480. {
  1481.   unsigned dest, bit_pos;
  1482.   Word digit;
  1483.  
  1484.   if (!IncMaxCodeLen(p_ctx, 5))
  1485.     return False;
  1486.   memset(&WAsmCode[p_ctx->CurrCodeFill.FullWordCnt], 0, 10);
  1487.  
  1488.   if (orig_negative)
  1489.     t = (LargeWord)(0 - ((LargeInt)t));
  1490.   dest = bit_pos = 0;
  1491.   while (t)
  1492.   {
  1493.     digit = (t % 10) << bit_pos;
  1494.     t /= 10;
  1495.     if (p_ctx->LoHiMap)
  1496.       WAsmCode[p_ctx->CurrCodeFill.FullWordCnt + (4 - dest)] |= digit;
  1497.     else
  1498.       WAsmCode[p_ctx->CurrCodeFill.FullWordCnt + dest] |= digit;
  1499.     if ((bit_pos += 4) >= 16)
  1500.     {
  1501.       bit_pos = 0;
  1502.       dest++;
  1503.     }
  1504.     if ((dest >= 4) && (bit_pos >= 8) && t)
  1505.     {
  1506.       WrError(orig_negative ? ErrNum_UnderRange : ErrNum_OverRange);
  1507.       return False;
  1508.     }
  1509.   }
  1510.   digit = !!orig_negative << 15;
  1511.   if (p_ctx->LoHiMap)
  1512.     WAsmCode[p_ctx->CurrCodeFill.FullWordCnt + 0] |= digit;
  1513.   else
  1514.     WAsmCode[p_ctx->CurrCodeFill.FullWordCnt + 4] |= digit;
  1515.   p_ctx->CurrCodeFill.FullWordCnt += 5;
  1516.   return True;
  1517. }
  1518.  
  1519. static Boolean Put80I_To_32(LargeWord t, Boolean orig_negative, struct sLayoutCtx *p_ctx)
  1520. {
  1521.   unsigned dest, bit_pos;
  1522.   LongWord digit;
  1523.  
  1524.   if (!IncMaxCodeLen(p_ctx, 3))
  1525.     return False;
  1526.   memset(&DAsmCode[p_ctx->CurrCodeFill.FullWordCnt], 0, 12);
  1527.  
  1528.   if (orig_negative)
  1529.     t = (LargeWord)(0 - ((LargeInt)t));
  1530.   dest = bit_pos = 0;
  1531.   while (t)
  1532.   {
  1533.     digit = (t % 10) << bit_pos;
  1534.     t /= 10;
  1535.     if (p_ctx->LoHiMap)
  1536.       DAsmCode[p_ctx->CurrCodeFill.FullWordCnt + (2 - dest)] |= digit;
  1537.     else
  1538.       DAsmCode[p_ctx->CurrCodeFill.FullWordCnt + dest] |= digit;
  1539.     if ((bit_pos += 4) >= 32)
  1540.     {
  1541.       bit_pos = 0;
  1542.       dest++;
  1543.     }
  1544.     if ((dest >= 2) && (bit_pos >= 8) && t)
  1545.     {
  1546.       WrError(orig_negative ? ErrNum_UnderRange : ErrNum_OverRange);
  1547.       return False;
  1548.     }
  1549.   }
  1550.   digit = ((LongWord)!!orig_negative) << 15;
  1551.   if (p_ctx->LoHiMap)
  1552.     DAsmCode[p_ctx->CurrCodeFill.FullWordCnt + 0] |= digit;
  1553.   else
  1554.     DAsmCode[p_ctx->CurrCodeFill.FullWordCnt + 2] |= digit;
  1555.   p_ctx->CurrCodeFill.FullWordCnt += 3;
  1556.   return True;
  1557. }
  1558.  
  1559. static Boolean Put80F_To_8(as_float_t t, struct sLayoutCtx *pCtx)
  1560. {
  1561.   int ret;
  1562.  
  1563.   if (!IncMaxCodeLen(pCtx, 10))
  1564.     return False;
  1565.   if ((ret = as_float_2_ieee10(t, BAsmCode + pCtx->CurrCodeFill.FullWordCnt, !!pCtx->LoHiMap)) < 0)
  1566.   {
  1567.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1568.     return False;
  1569.   }
  1570.   pCtx->CurrCodeFill.FullWordCnt += 10;
  1571.   return True;
  1572. }
  1573.  
  1574. static Boolean Put80F_To_16(as_float_t t, struct sLayoutCtx *pCtx)
  1575. {
  1576.   int ret;
  1577.   Byte Tmp[10];
  1578.   int LoHiMap = pCtx->LoHiMap & 1;
  1579.  
  1580.   if (!IncMaxCodeLen(pCtx, 5))
  1581.     return False;
  1582.   if ((ret = as_float_2_ieee10(t, Tmp, !!pCtx->LoHiMap)) < 0)
  1583.   {
  1584.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1585.     return False;
  1586.   }
  1587.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = ByteInWord(Tmp[0], 0 ^ LoHiMap) | ByteInWord(Tmp[1], 1 ^ LoHiMap);
  1588.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 1] = ByteInWord(Tmp[2], 0 ^ LoHiMap) | ByteInWord(Tmp[3], 1 ^ LoHiMap);
  1589.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 2] = ByteInWord(Tmp[4], 0 ^ LoHiMap) | ByteInWord(Tmp[5], 1 ^ LoHiMap);
  1590.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 3] = ByteInWord(Tmp[6], 0 ^ LoHiMap) | ByteInWord(Tmp[7], 1 ^ LoHiMap);
  1591.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 4] = ByteInWord(Tmp[8], 0 ^ LoHiMap) | ByteInWord(Tmp[9], 1 ^ LoHiMap);
  1592.   pCtx->CurrCodeFill.FullWordCnt += 5;
  1593.   return True;
  1594. }
  1595.  
  1596. static Boolean Put80F_To_32(as_float_t t, struct sLayoutCtx *pCtx)
  1597. {
  1598.   int ret;
  1599.   Byte Tmp[10];
  1600.  
  1601.   if (!IncMaxCodeLen(pCtx, 3))
  1602.     return False;
  1603.   if ((ret = as_float_2_ieee10(t, Tmp, !!pCtx->LoHiMap)) < 0)
  1604.   {
  1605.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1606.     return False;
  1607.   }
  1608.   if (pCtx->LoHiMap)
  1609.   {
  1610.     DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = ByteInDWord(Tmp[0], 1) | ByteInDWord(Tmp[1], 0);
  1611.     DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 1] = ByteInDWord(Tmp[2], 3) | ByteInDWord(Tmp[3], 2) | ByteInDWord(Tmp[4], 1) | ByteInDWord(Tmp[5], 0);
  1612.     DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 2] = ByteInDWord(Tmp[6], 3) | ByteInDWord(Tmp[7], 2) | ByteInDWord(Tmp[8], 1) | ByteInDWord(Tmp[9], 0);
  1613.   }
  1614.   else
  1615.   {
  1616.     DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = ByteInDWord(Tmp[0], 0) | ByteInDWord(Tmp[1], 1) | ByteInDWord(Tmp[2], 2) | ByteInDWord(Tmp[3], 3);
  1617.     DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 1] = ByteInDWord(Tmp[4], 0) | ByteInDWord(Tmp[5], 1) | ByteInDWord(Tmp[6], 2) | ByteInDWord(Tmp[7], 3);
  1618.     DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 2] = ByteInDWord(Tmp[8], 0) | ByteInDWord(Tmp[9], 1);
  1619.   }
  1620.   pCtx->CurrCodeFill.FullWordCnt += 3;
  1621.   return True;
  1622. }
  1623.  
  1624. static Boolean LayoutTenBytes(const tStrComp *pExpr, struct sLayoutCtx *pCtx)
  1625. {
  1626.   Boolean Result = False;
  1627.   TempResult erg;
  1628.   Word Cnt;
  1629.  
  1630.   as_tempres_ini(&erg);
  1631.   EvalStrExpression(pExpr, &erg);
  1632.   Result = False;
  1633.   switch(erg.Typ)
  1634.   {
  1635.     case TempNone:
  1636.       break;
  1637.     case TempInt:
  1638.     ToInt:
  1639.       if (pCtx->flags & eIntPseudoFlag_AllowInt)
  1640.       {
  1641.         if (!pCtx->Put80I(erg.Contents.Int, erg.Contents.Int < 0, pCtx))
  1642.           LEAVE;
  1643.         Cnt = 10;
  1644.         Result = True;
  1645.         break;
  1646.       }
  1647.       else
  1648.       {
  1649.         TempResultToFloat(&erg);
  1650.         goto ToFloat;
  1651.       }
  1652.     case TempFloat:
  1653.     ToFloat:
  1654.       if (!pCtx->Put80F(erg.Contents.Float, pCtx))
  1655.         LEAVE;
  1656.       Cnt = 10;
  1657.       Result = True;
  1658.       break;
  1659.     case TempString:
  1660.     {
  1661.       Boolean ret;
  1662.       unsigned z;
  1663.  
  1664.       if (MultiCharToInt(&erg, 4))
  1665.         goto ToInt;
  1666.  
  1667.       if (as_chartrans_xlate_nonz_dynstr(CurrTransTable->p_table, &erg.Contents.str, pExpr))
  1668.         LEAVE;
  1669.  
  1670.       for (z = 0; z < erg.Contents.str.len; z++)
  1671.       {
  1672.         ret = (pCtx->flags & eIntPseudoFlag_AllowInt)
  1673.             ? pCtx->Put80I(erg.Contents.str.p_str[z], False, pCtx)
  1674.             : pCtx->Put80F(erg.Contents.str.p_str[z], pCtx);
  1675.         if (!ret)
  1676.           LEAVE;
  1677.       }
  1678.  
  1679.       Cnt = erg.Contents.str.len * 10;
  1680.       Result = True;
  1681.       break;
  1682.     }
  1683.     case TempReg:
  1684.       WrStrErrorPos(ErrNum_StringOrIntOrFloatButReg, pExpr);
  1685.       break;
  1686.     case TempAll:
  1687.       assert(0);
  1688.   }
  1689.   (void)Cnt;
  1690.  
  1691. func_exit:
  1692.   as_tempres_free(&erg);
  1693.   return Result;
  1694. }
  1695.  
  1696. /*****************************************************************************
  1697.  * Function:    LayoutOctaWord
  1698.  * Purpose:     parse argument, interprete as 128-bit word or
  1699.                 double precision float, and put into result buffer
  1700.  * Result:      TRUE if no errors occured
  1701.  *****************************************************************************/
  1702.  
  1703. static Boolean Put128I_To_8(LargeWord l, Boolean orig_negative, struct sLayoutCtx *pCtx)
  1704. {
  1705.   if (!IncMaxCodeLen(pCtx, 16))
  1706.     return False;
  1707.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)] = (l      ) & 0xff;
  1708.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = (l >>  8) & 0xff;
  1709.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ pCtx->LoHiMap)] = (l >> 16) & 0xff;
  1710.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ pCtx->LoHiMap)] = (l >> 24) & 0xff;
  1711. #ifdef HAS64
  1712.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (4 ^ pCtx->LoHiMap)] = (l >> 32) & 0xff;
  1713.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (5 ^ pCtx->LoHiMap)] = (l >> 40) & 0xff;
  1714.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (6 ^ pCtx->LoHiMap)] = (l >> 48) & 0xff;
  1715.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (7 ^ pCtx->LoHiMap)] = (l >> 56) & 0xff;
  1716.   /* TempResult is TempInt, so sign-extend */
  1717.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (8 ^ pCtx->LoHiMap)] =
  1718.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (9 ^ pCtx->LoHiMap)] =
  1719.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (10 ^ pCtx->LoHiMap)] =
  1720.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (11 ^ pCtx->LoHiMap)] =
  1721.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (12 ^ pCtx->LoHiMap)] =
  1722.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (13 ^ pCtx->LoHiMap)] =
  1723.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (14 ^ pCtx->LoHiMap)] =
  1724.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (15 ^ pCtx->LoHiMap)] = orig_negative ? 0xff : 0x00;
  1725. #else
  1726.   /* TempResult is TempInt, so sign-extend */
  1727.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (4 ^ pCtx->LoHiMap)] =
  1728.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (5 ^ pCtx->LoHiMap)] =
  1729.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (6 ^ pCtx->LoHiMap)] =
  1730.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (7 ^ pCtx->LoHiMap)] =
  1731.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (8 ^ pCtx->LoHiMap)] =
  1732.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (9 ^ pCtx->LoHiMap)] =
  1733.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (10 ^ pCtx->LoHiMap)] =
  1734.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (11 ^ pCtx->LoHiMap)] =
  1735.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (12 ^ pCtx->LoHiMap)] =
  1736.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (13 ^ pCtx->LoHiMap)] =
  1737.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (14 ^ pCtx->LoHiMap)] =
  1738.   BAsmCode[pCtx->CurrCodeFill.FullWordCnt + (15 ^ pCtx->LoHiMap)] = orig_negative ? 0xff : 0x00;
  1739. #endif
  1740.   pCtx->CurrCodeFill.FullWordCnt += 16;
  1741.   return True;
  1742. }
  1743.  
  1744. static Boolean Put128F_To_8(as_float_t t, struct sLayoutCtx *pCtx)
  1745. {
  1746.   int ret;
  1747.  
  1748.   if (!IncMaxCodeLen(pCtx, 16))
  1749.     return False;
  1750.   if (pCtx->flags & eIntPseudoFlag_DECFormats)
  1751.   {
  1752.     Word *p_dest = WAsmCode + (pCtx->CurrCodeFill.FullWordCnt / 2);
  1753.     ret = as_float_2_dec_h(t, p_dest);
  1754.     if ((ret >= 0) && (HostBigEndian && (ListGran() == 1)))
  1755.       WSwap(p_dest, 16);
  1756.   }
  1757.   else
  1758.     ret = as_float_2_ieee16(t, BAsmCode + pCtx->CurrCodeFill.FullWordCnt, !!pCtx->LoHiMap);
  1759.  
  1760.   if (ret < 0)
  1761.   {
  1762.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1763.     return False;
  1764.   }
  1765.  
  1766.   pCtx->CurrCodeFill.FullWordCnt += 16;
  1767.   return True;
  1768. }
  1769.  
  1770. static Boolean Put128I_To_16(LargeWord l, Boolean orig_negative, struct sLayoutCtx *pCtx)
  1771. {
  1772.   if (!IncMaxCodeLen(pCtx, 8))
  1773.     return False;
  1774.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)] = (l      ) & 0xffff;
  1775.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = (l >> 16) & 0xffff;
  1776. #ifdef HAS64
  1777.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ pCtx->LoHiMap)] = (l >> 32) & 0xffff;
  1778.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ pCtx->LoHiMap)] = (l >> 48) & 0xffff;
  1779.   /* TempResult is TempInt, so sign-extend */
  1780.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (4 ^ pCtx->LoHiMap)] =
  1781.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (5 ^ pCtx->LoHiMap)] =
  1782.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (6 ^ pCtx->LoHiMap)] =
  1783.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (7 ^ pCtx->LoHiMap)] = orig_negative ? 0xffff : 0x0000;
  1784. #else
  1785.   /* TempResult is TempInt, so sign-extend */
  1786.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ pCtx->LoHiMap)] =
  1787.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ pCtx->LoHiMap)] =
  1788.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (4 ^ pCtx->LoHiMap)] =
  1789.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (5 ^ pCtx->LoHiMap)] =
  1790.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (6 ^ pCtx->LoHiMap)] =
  1791.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + (7 ^ pCtx->LoHiMap)] = orig_negative ? 0xffff : 0x0000;
  1792. #endif
  1793.   pCtx->CurrCodeFill.FullWordCnt += 8;
  1794.   return True;
  1795. }
  1796.  
  1797. static Boolean Put128F_To_16(as_float_t t, struct sLayoutCtx *pCtx)
  1798. {
  1799.   Byte Tmp[16];
  1800.   int LoHiMap = pCtx->LoHiMap & 1;
  1801.   int ret;
  1802.  
  1803.   if (!IncMaxCodeLen(pCtx, 8))
  1804.     return False;
  1805.   if ((ret = as_float_2_ieee16(t, Tmp, !!pCtx->LoHiMap)) < 0)
  1806.   {
  1807.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1808.     return False;
  1809.   }
  1810.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = ByteInWord(Tmp[ 0], 0 ^ LoHiMap) | ByteInWord(Tmp[ 1], 1 ^ LoHiMap);
  1811.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 1] = ByteInWord(Tmp[ 2], 0 ^ LoHiMap) | ByteInWord(Tmp[ 3], 1 ^ LoHiMap);
  1812.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 2] = ByteInWord(Tmp[ 4], 0 ^ LoHiMap) | ByteInWord(Tmp[ 5], 1 ^ LoHiMap);
  1813.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 3] = ByteInWord(Tmp[ 6], 0 ^ LoHiMap) | ByteInWord(Tmp[ 7], 1 ^ LoHiMap);
  1814.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 4] = ByteInWord(Tmp[ 8], 0 ^ LoHiMap) | ByteInWord(Tmp[ 9], 1 ^ LoHiMap);
  1815.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 5] = ByteInWord(Tmp[10], 0 ^ LoHiMap) | ByteInWord(Tmp[11], 1 ^ LoHiMap);
  1816.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 6] = ByteInWord(Tmp[12], 0 ^ LoHiMap) | ByteInWord(Tmp[13], 1 ^ LoHiMap);
  1817.   WAsmCode[pCtx->CurrCodeFill.FullWordCnt + 7] = ByteInWord(Tmp[14], 0 ^ LoHiMap) | ByteInWord(Tmp[15], 1 ^ LoHiMap);
  1818.   pCtx->CurrCodeFill.FullWordCnt += 8;
  1819.   return True;
  1820. }
  1821.  
  1822. static Boolean Put128I_To_32(LargeWord l, Boolean orig_negative, struct sLayoutCtx *pCtx)
  1823. {
  1824.   if (!IncMaxCodeLen(pCtx, 4))
  1825.     return False;
  1826.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (0 ^ pCtx->LoHiMap)] = (l      ) & 0xfffffffful;
  1827. #ifdef HAS64
  1828.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] = (l >> 32) & 0xfffffffful;
  1829.   /* TempResult is TempInt, so sign-extend */
  1830.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ pCtx->LoHiMap)] =
  1831.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ pCtx->LoHiMap)] = orig_negative ? 0xfffffffful : 0x00000000ul;
  1832. #else
  1833.   /* TempResult is TempInt, so sign-extend */
  1834.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (1 ^ pCtx->LoHiMap)] =
  1835.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (2 ^ pCtx->LoHiMap)] =
  1836.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + (3 ^ pCtx->LoHiMap)] = orig_negative ? 0xfffffffful : 0x00000000ul;
  1837. #endif
  1838.   pCtx->CurrCodeFill.FullWordCnt += 4;
  1839.   return True;
  1840. }
  1841.  
  1842. static Boolean Put128F_To_32(as_float_t t, struct sLayoutCtx *pCtx)
  1843. {
  1844.   Byte Tmp[16];
  1845.   int LoHiMap = pCtx->LoHiMap ? 3 : 0;
  1846.   int ret;
  1847.  
  1848.   if (!IncMaxCodeLen(pCtx, 4))
  1849.     return False;
  1850.   if ((ret = as_float_2_ieee16(t, Tmp, !!pCtx->LoHiMap)) < 0)
  1851.   {
  1852.     asmerr_check_fp_dispose_result(ret, pCtx->pCurrComp);
  1853.     return False;
  1854.   }
  1855.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 0] = ByteInDWord(Tmp[ 0], 0 ^ LoHiMap) | ByteInDWord(Tmp[ 1], 1 ^ LoHiMap) | ByteInDWord(Tmp[ 2], 2 ^ LoHiMap) | ByteInDWord(Tmp[ 3], 3 ^ LoHiMap);
  1856.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 1] = ByteInDWord(Tmp[ 4], 0 ^ LoHiMap) | ByteInDWord(Tmp[ 5], 1 ^ LoHiMap) | ByteInDWord(Tmp[ 6], 2 ^ LoHiMap) | ByteInDWord(Tmp[ 7], 3 ^ LoHiMap);
  1857.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 2] = ByteInDWord(Tmp[ 8], 0 ^ LoHiMap) | ByteInDWord(Tmp[ 9], 1 ^ LoHiMap) | ByteInDWord(Tmp[10], 2 ^ LoHiMap) | ByteInDWord(Tmp[11], 3 ^ LoHiMap);
  1858.   DAsmCode[pCtx->CurrCodeFill.FullWordCnt + 3] = ByteInDWord(Tmp[12], 0 ^ LoHiMap) | ByteInDWord(Tmp[13], 1 ^ LoHiMap) | ByteInDWord(Tmp[14], 2 ^ LoHiMap) | ByteInDWord(Tmp[15], 3 ^ LoHiMap);
  1859.   pCtx->CurrCodeFill.FullWordCnt += 4;
  1860.   return True;
  1861. }
  1862.  
  1863. static Boolean LayoutOctaWord(const tStrComp *pExpr, struct sLayoutCtx *pCtx)
  1864. {
  1865.   Boolean Result = False;
  1866.   const Boolean allow_string = !!(pCtx->flags & eIntPseudoFlag_AllowString),
  1867.                 allow_float = !!pCtx->Put128F;
  1868.   TempResult erg;
  1869.   Word Cnt  = 0;
  1870.  
  1871.   as_tempres_ini(&erg);
  1872.   EvalStrExpression(pExpr, &erg);
  1873.   Result = False;
  1874.   switch (erg.Typ)
  1875.   {
  1876.     case TempNone:
  1877.       break;
  1878.     case TempInt:
  1879.     ToInt:
  1880.       if (pCtx->Put128I)
  1881.       {
  1882.         if (!pCtx->Put128I(erg.Contents.Int, erg.Contents.Int < 0, pCtx))
  1883.           LEAVE;
  1884.         Cnt = 16;
  1885.         Result = True;
  1886.         break;
  1887.       }
  1888.       else
  1889.         TempResultToFloat(&erg);
  1890.       /* fall-through */
  1891.     case TempFloat:
  1892.       if (!allow_float) WrStrErrorPos(ErrNum_StringOrIntButFloat, pExpr);
  1893.       else if (!pCtx->Put128F(erg.Contents.Float, pCtx))
  1894.         LEAVE;
  1895.       Cnt = 16;
  1896.       Result = True;
  1897.       break;
  1898.     case TempString:
  1899.       if (!allow_string) WrStrErrorPos(allow_float ? ErrNum_IntOrFloatButString : ErrNum_IntButString, pExpr);
  1900.       else
  1901.       {
  1902.          unsigned z;
  1903.  
  1904.         if (MultiCharToInt(&erg, 16))
  1905.           goto ToInt;
  1906.  
  1907.         if (as_chartrans_xlate_nonz_dynstr(CurrTransTable->p_table, &erg.Contents.str, pExpr))
  1908.           LEAVE;
  1909.  
  1910.         for (z = 0; z < erg.Contents.str.len; z++)
  1911.           if (!pCtx->Put128I(erg.Contents.str.p_str[z], False, pCtx))
  1912.             LEAVE;
  1913.  
  1914.         Cnt = erg.Contents.str.len * 16;
  1915.         Result = True;
  1916.       }
  1917.       break;
  1918.     case TempReg:
  1919.       WrStrErrorPos(ErrNum_StringOrIntOrFloatButReg, pExpr);
  1920.       break;
  1921.     case TempAll:
  1922.       assert(0);
  1923.   }
  1924.   (void)Cnt;
  1925.  
  1926. func_exit:
  1927.   as_tempres_free(&erg);
  1928.   return Result;
  1929. }
  1930.  
  1931. /*****************************************************************************
  1932.  * Global Functions
  1933.  *****************************************************************************/
  1934.  
  1935. /*****************************************************************************
  1936.  * Function:    DecodeIntelPseudo
  1937.  * Purpose:     handle Intel-style pseudo instructions
  1938.  * Result:      TRUE if mnemonic was handled
  1939.  *****************************************************************************/
  1940.  
  1941. static Boolean DecodeIntelPseudo_ValidSymChar(char ch)
  1942. {
  1943.   ch = as_toupper(ch);
  1944.  
  1945.   return (((ch >= 'A') && (ch <= 'Z'))
  1946.        || ((ch >= '0') && (ch <= '9'))
  1947.        || (ch == '_')
  1948.        || (ch == '.'));
  1949. }
  1950.  
  1951. static void DecodeIntelPseudo_HandleQuote(int *pDepth, Byte *pQuote, char Ch)
  1952. {
  1953.   switch (Ch)
  1954.   {
  1955.     case '(':
  1956.       if (!(*pQuote))
  1957.         (*pDepth)++;
  1958.       break;
  1959.     case ')':
  1960.       if (!(*pQuote))
  1961.         (*pDepth)--;
  1962.       break;
  1963.     case '\'':
  1964.       if (!((*pQuote) & 2))
  1965.         (*pQuote) ^= 1;
  1966.       break;
  1967.     case '"':
  1968.       if (!((*pQuote) & 1))
  1969.         (*pQuote) ^= 2;
  1970.       break;
  1971.   }
  1972. }
  1973.  
  1974. static Boolean DecodeIntelPseudo_LayoutMult(const tStrComp *pArg, struct sLayoutCtx *pCtx)
  1975. {
  1976.   int z, Depth, Len, LastNonBlank;
  1977.   Boolean OK, LastValid, Result, DupIsRep;
  1978.   Byte Quote;
  1979.   const char *pDupFnd, *pRun;
  1980.   const tStrComp *pSaveComp;
  1981.  
  1982.   pSaveComp = pCtx->pCurrComp;
  1983.   pCtx->pCurrComp = pArg;
  1984.  
  1985.   /* search for DUP:
  1986.      - Exclude parts in parentheses, and parts in quotation marks.
  1987.      - Assure there is some (non-blank) token before DUP, so if there
  1988.        is e.g. a plain DUP as argument, it will not be interpreted as
  1989.        DUP operator. */
  1990.  
  1991.   Depth = Quote = 0;
  1992.   LastValid = FALSE;
  1993.   LastNonBlank = -1;
  1994.   pDupFnd = NULL; DupIsRep = False;
  1995.   Len = strlen(pArg->str.p_str);
  1996.   for (pRun = pArg->str.p_str; pRun < pArg->str.p_str + Len - 2; pRun++)
  1997.   {
  1998.     DecodeIntelPseudo_HandleQuote(&Depth, &Quote, *pRun);
  1999.     if (!Depth && !Quote)
  2000.     {
  2001.       if (!LastValid
  2002.        && (LastNonBlank >= 0)
  2003.        && !DecodeIntelPseudo_ValidSymChar(pRun[3])
  2004.        && !as_strncasecmp(pRun, "DUP", 3))
  2005.       {
  2006.         pDupFnd = pRun;
  2007.         break;
  2008.       }
  2009.       if (!as_isspace(*pRun))
  2010.         LastNonBlank = pRun - pArg->str.p_str;
  2011.     }
  2012.     LastValid = DecodeIntelPseudo_ValidSymChar(*pRun);
  2013.   }
  2014.  
  2015.   if (!pDupFnd && (pCtx->flags & eIntPseudoFlag_MotoRep))
  2016.   {
  2017.     if (*pArg->str.p_str == '[')
  2018.     {
  2019.       pDupFnd = QuotPos(pArg->str.p_str + 1, ']');
  2020.       if (pDupFnd)
  2021.         DupIsRep = True;
  2022.     }
  2023.   }
  2024.  
  2025.   /* found DUP: */
  2026.  
  2027.   if (pDupFnd)
  2028.   {
  2029.     LongInt DupCnt;
  2030.     char *pSep, *pRun;
  2031.     String CopyStr;
  2032.     tStrComp Copy, DupArg, RemArg, ThisRemArg;
  2033.     tCurrCodeFill DUPStartFill, DUPEndFill;
  2034.     tSymbolFlags Flags;
  2035.  
  2036.     /* operate on copy */
  2037.  
  2038.     StrCompMkTemp(&Copy, CopyStr, sizeof(CopyStr));
  2039.     StrCompCopy(&Copy, pArg);
  2040.     pSep = Copy.str.p_str + (pDupFnd - pArg->str.p_str);
  2041.     StrCompSplitRef(&DupArg, &RemArg, &Copy, pSep);
  2042.     if (DupIsRep)
  2043.       StrCompIncRefLeft(&DupArg, 1);
  2044.     else
  2045.       StrCompIncRefLeft(&RemArg, 2);
  2046.  
  2047.     /* evaluate count */
  2048.  
  2049.     DupCnt = EvalStrIntExpressionWithFlags(&DupArg, Int32, &OK, &Flags);
  2050.     if (mFirstPassUnknown(Flags))
  2051.     {
  2052.       WrStrErrorPos(ErrNum_FirstPassCalc, &DupArg); return False;
  2053.     }
  2054.     if (!OK)
  2055.     {
  2056.       Result = False;
  2057.       goto func_exit;
  2058.     }
  2059.  
  2060.     /* catch invalid counts */
  2061.  
  2062.     if (DupCnt <= 0)
  2063.     {
  2064.       if (DupCnt < 0)
  2065.         WrStrErrorPos(ErrNum_NegDUP, &DupArg);
  2066.       Result = True;
  2067.       goto func_exit;
  2068.     }
  2069.  
  2070.     /* split into parts and evaluate */
  2071.  
  2072.     KillPrefBlanksStrCompRef(&RemArg);
  2073.     Len = strlen(RemArg.str.p_str);
  2074.     if ((Len >= 2) && (*RemArg.str.p_str == '(') && (RemArg.str.p_str[Len - 1] == ')'))
  2075.     {
  2076.       StrCompIncRefLeft(&RemArg, 1);
  2077.       StrCompShorten(&RemArg, 1);
  2078.       Len -= 2;
  2079.     }
  2080.     DUPStartFill = pCtx->CurrCodeFill;
  2081.     do
  2082.     {
  2083.       pSep = NULL; Quote = Depth = 0;
  2084.       for (pRun = RemArg.str.p_str; *pRun; pRun++)
  2085.       {
  2086.         DecodeIntelPseudo_HandleQuote(&Depth, &Quote, *pRun);
  2087.         if (!Depth && !Quote && (*pRun == ','))
  2088.         {
  2089.           pSep = pRun;
  2090.           break;
  2091.         }
  2092.       }
  2093.       if (pSep)
  2094.         StrCompSplitRef(&RemArg, &ThisRemArg, &RemArg, pSep);
  2095.       KillPrefBlanksStrCompRef(&RemArg);
  2096.       KillPostBlanksStrComp(&RemArg);
  2097.       if (!DecodeIntelPseudo_LayoutMult(&RemArg, pCtx))
  2098.       {
  2099.         Result = False;
  2100.         goto func_exit;
  2101.       }
  2102.       if (pSep)
  2103.         RemArg = ThisRemArg;
  2104.     }
  2105.     while (pSep);
  2106.     DUPEndFill = pCtx->CurrCodeFill;
  2107.  
  2108.     /* replicate result (data or reserve) */
  2109.  
  2110.     switch (pCtx->DSFlag)
  2111.     {
  2112.       case DSConstant:
  2113.         for (z = 1; z <= DupCnt - 1; z++)
  2114.           if (!pCtx->Replicate(&DUPStartFill, &DUPEndFill, pCtx))
  2115.           {
  2116.             Result = False;
  2117.             goto func_exit;
  2118.           }
  2119.         break;
  2120.       case DSSpace:
  2121.       {
  2122.         tCurrCodeFill Diff;
  2123.  
  2124.         SubCodeFill(&Diff, &DUPEndFill, &DUPStartFill, pCtx);
  2125.         MultCodeFill(&Diff, DupCnt - 1, pCtx);
  2126.         IncCodeFillBy(&pCtx->CurrCodeFill, &Diff, pCtx);
  2127.         break;
  2128.       }
  2129.       default:
  2130.         Result = False;
  2131.         goto func_exit;
  2132.     }
  2133.  
  2134.     Result = True;
  2135.   }
  2136.  
  2137.   /* no DUP: simple expression.  Differentiate space reservation & data disposition */
  2138.  
  2139.   else if (!strcmp(pArg->str.p_str, "?"))
  2140.   {
  2141.     Result = SetDSFlag(pCtx, DSSpace);
  2142.     if (Result)
  2143.       IncCodeFillBy(&pCtx->CurrCodeFill, &pCtx->FillIncPerElem, pCtx);
  2144.   }
  2145.  
  2146.   else
  2147.     Result = SetDSFlag(pCtx, DSConstant) && pCtx->LayoutFunc(pArg, pCtx);
  2148.  
  2149. func_exit:
  2150.   pCtx->pCurrComp = pSaveComp;
  2151.   return Result;
  2152. }
  2153.  
  2154. /*!------------------------------------------------------------------------
  2155.  * \fn     DecodeIntelDx(tLayoutCtx *pLayoutCtx)
  2156.  * \brief  Intel-style constant disposition
  2157.  * \param  pLayoutCtx layout infos & context
  2158.  * ------------------------------------------------------------------------ */
  2159.  
  2160. static void DecodeIntelDx(tLayoutCtx *pLayoutCtx)
  2161. {
  2162.   tStrComp *pArg;
  2163.   Boolean OK;
  2164.  
  2165.   pLayoutCtx->DSFlag = DSNone;
  2166.   pLayoutCtx->FullWordSize = Grans[ActPC];
  2167.   if ((pLayoutCtx->FullWordSize == 1) && !(pLayoutCtx->flags & eIntPseudoFlag_DECFormats))
  2168.     pLayoutCtx->ListGran = 1;
  2169.   else
  2170.     pLayoutCtx->ListGran = ActListGran;
  2171.   pLayoutCtx->ElemsPerFullWord = (8 * pLayoutCtx->FullWordSize) / pLayoutCtx->BaseElemLenBits;
  2172.   if (pLayoutCtx->ElemsPerFullWord > 1)
  2173.   {
  2174.     pLayoutCtx->FillIncPerElem.FullWordCnt = 0;
  2175.     pLayoutCtx->FillIncPerElem.LastWordFill = 1;
  2176.   }
  2177.   else
  2178.   {
  2179.     pLayoutCtx->FillIncPerElem.FullWordCnt = pLayoutCtx->BaseElemLenBits / (8 * pLayoutCtx->FullWordSize);
  2180.     pLayoutCtx->FillIncPerElem.LastWordFill = 0;
  2181.   }
  2182.  
  2183.   OK = True;
  2184.   forallargs(pArg, OK)
  2185.   {
  2186.     if (!*pArg->str.p_str)
  2187.     {
  2188.       OK = FALSE;
  2189.       WrStrErrorPos(ErrNum_EmptyArgument, pArg);
  2190.     }
  2191.     else
  2192.       OK = DecodeIntelPseudo_LayoutMult(pArg, pLayoutCtx);
  2193.   }
  2194.  
  2195.   /* Finalize: add optional padding if fractions of full words
  2196.      remain unused & set code length */
  2197.  
  2198.   if (OK)
  2199.   {
  2200.     if (pLayoutCtx->CurrCodeFill.LastWordFill)
  2201.     {
  2202.       WrError(ErrNum_PaddingAdded);
  2203.       pLayoutCtx->CurrCodeFill.LastWordFill = 0;
  2204.       pLayoutCtx->CurrCodeFill.FullWordCnt++;
  2205.     }
  2206.     CodeLen = pLayoutCtx->CurrCodeFill.FullWordCnt;
  2207.   }
  2208.  
  2209.   DontPrint = (pLayoutCtx->DSFlag == DSSpace);
  2210.   if (DontPrint)
  2211.   {
  2212.     BookKeeping();
  2213.     if (!CodeLen && OK) WrError(ErrNum_NullResMem);
  2214.   }
  2215.   if (OK)
  2216.     ActListGran = pLayoutCtx->ListGran;
  2217. }
  2218.  
  2219. /*!------------------------------------------------------------------------
  2220.  * \fn     resolve_flags(int_pseudo_flags_t flags)
  2221.  * \brief  resolve actual endianess
  2222.  * \param  flags given by caller
  2223.  * \return effective flags
  2224.  * ------------------------------------------------------------------------ */
  2225.  
  2226. static int_pseudo_flags_t resolve_flags(int_pseudo_flags_t flags)
  2227. {
  2228.   switch (flags & eIntPseudoFlag_EndianMask)
  2229.   {
  2230.     case eIntPseudoFlag_DynEndian:
  2231.       flags &= ~eIntPseudoFlag_EndianMask;
  2232.       flags |= TargetBigEndian ? eIntPseudoFlag_BigEndian : eIntPseudoFlag_LittleEndian;
  2233.       break;
  2234.     case eIntPseudoFlag_LittleEndian:
  2235.     case eIntPseudoFlag_BigEndian:
  2236.       break;
  2237.     default:
  2238.       fprintf(stderr, "%s: undefined endianess\n", OpPart.str.p_str);
  2239.       abort();
  2240.   }
  2241.   return flags;
  2242. }
  2243.  
  2244. /*!------------------------------------------------------------------------
  2245.  * \fn     DecodeIntelDN(Word Flags)
  2246.  * \brief  Intel-style constant disposition - nibbles
  2247.  * \param  Flags Data Type & Endianess Flags
  2248.  * ------------------------------------------------------------------------ */
  2249.  
  2250. void DecodeIntelDN(Word Flags)
  2251. {
  2252.   tLayoutCtx LayoutCtx;
  2253.  
  2254.   memset(&LayoutCtx, 0, sizeof(LayoutCtx));
  2255.   LayoutCtx.LayoutFunc = LayoutNibble;
  2256.   LayoutCtx.BaseElemLenBits = 4;
  2257.   LayoutCtx.flags = resolve_flags((int_pseudo_flags_t)Flags);
  2258.   switch (Grans[ActPC])
  2259.   {
  2260.     case 1:
  2261.       LayoutCtx.Put4I = Put4I_To_8;
  2262.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2263.       LayoutCtx.Replicate = Replicate4_To_8;
  2264.       break;
  2265.     case 2:
  2266.       LayoutCtx.Put4I = Put4I_To_16;
  2267.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 3 : 0;
  2268.       LayoutCtx.Replicate = Replicate4_To_16;
  2269.       break;
  2270.     case 4:
  2271.       LayoutCtx.Put4I = Put4I_To_32;
  2272.       LayoutCtx.LoHiMap = (Flags & eIntPseudoFlag_BigEndian) ? 7 : 0;
  2273.       LayoutCtx.Replicate = Replicate4_To_32;
  2274.       break;
  2275.     default:
  2276.       fprintf(stderr, "implement DN for %u-bytes words\n", (unsigned)Grans[ActPC]);
  2277.       exit(255);
  2278.   }
  2279.   DecodeIntelDx(&LayoutCtx);
  2280. }
  2281.  
  2282. /*!------------------------------------------------------------------------
  2283.  * \fn     DecodeIntelDB(Word BigEndian)
  2284.  * \brief  Intel-style constant disposition - bytes
  2285.  * \param  Flags Data Type & Endianess Flags
  2286.  * ------------------------------------------------------------------------ */
  2287.  
  2288. void DecodeIntelDB(Word Flags)
  2289. {
  2290.   tLayoutCtx LayoutCtx;
  2291.  
  2292.   memset(&LayoutCtx, 0, sizeof(LayoutCtx));
  2293.   LayoutCtx.LayoutFunc = LayoutByte;
  2294.   LayoutCtx.BaseElemLenBits = 8;
  2295.   LayoutCtx.flags = resolve_flags((int_pseudo_flags_t)Flags);
  2296.   switch (Grans[ActPC])
  2297.   {
  2298.     case 1:
  2299.       LayoutCtx.Put8I = Put8I_To_8;
  2300.       LayoutCtx.Replicate = Replicate8ToN_To_8;
  2301.       break;
  2302.     case 2:
  2303.       LayoutCtx.Put8I = Put8I_To_16;
  2304.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2305.       LayoutCtx.Replicate = Replicate8_To_16;
  2306.       break;
  2307.     case 4:
  2308.       LayoutCtx.Put8I = Put8I_To_32;
  2309.       LayoutCtx.LoHiMap = (Flags & eIntPseudoFlag_BigEndian) ? 3 : 0;
  2310.       LayoutCtx.Replicate = Replicate8_To_32;
  2311.       break;
  2312.     default:
  2313.       fprintf(stderr, "implement DB for %u-bytes words\n", (unsigned)Grans[ActPC]);
  2314.       exit(255);
  2315.   }
  2316.   if (*LabPart.str.p_str)
  2317.     SetSymbolOrStructElemSize(&LabPart, eSymbolSize8Bit);
  2318.   DecodeIntelDx(&LayoutCtx);
  2319. }
  2320.  
  2321. /*!------------------------------------------------------------------------
  2322.  * \fn     DecodeIntelDW(Word Flags)
  2323.  * \brief  Intel-style constant disposition - words
  2324.  * \param  Flags Data Type & Endianess Flags
  2325.  * ------------------------------------------------------------------------ */
  2326.  
  2327. void DecodeIntelDW(Word Flags)
  2328. {
  2329.   tLayoutCtx LayoutCtx;
  2330.  
  2331.   memset(&LayoutCtx, 0, sizeof(LayoutCtx));
  2332.   LayoutCtx.LayoutFunc = LayoutWord;
  2333.   LayoutCtx.BaseElemLenBits = 16;
  2334.   LayoutCtx.flags = resolve_flags((int_pseudo_flags_t)Flags);
  2335.   switch (Grans[ActPC])
  2336.   {
  2337.     case 1:
  2338.       LayoutCtx.Put16I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put16I_To_8 : NULL;
  2339.       LayoutCtx.Put16F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put16F_To_8 : NULL;
  2340.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2341.       LayoutCtx.Replicate = Replicate8ToN_To_8;
  2342.       break;
  2343.     case 2:
  2344.       LayoutCtx.Put16I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put16I_To_16 : NULL;
  2345.       LayoutCtx.Put16F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put16F_To_16 : NULL;
  2346.       LayoutCtx.Replicate = Replicate16ToN_To_16;
  2347.       break;
  2348.     case 4:
  2349.       LayoutCtx.Put16I = (Flags & eIntPseudoFlag_AllowInt) ? Put16I_To_32 : NULL;
  2350.       LayoutCtx.Put16F = (Flags & eIntPseudoFlag_AllowFloat) ? Put16F_To_32 : NULL;
  2351.       LayoutCtx.LoHiMap = (Flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2352.       LayoutCtx.Replicate = Replicate16_To_32;
  2353.       break;
  2354.     default:
  2355.       fprintf(stderr, "implement DW for %u-bytes words\n", (unsigned)Grans[ActPC]);
  2356.       exit(255);
  2357.   }
  2358.   if (*LabPart.str.p_str)
  2359.     SetSymbolOrStructElemSize(&LabPart, eSymbolSize16Bit);
  2360.   DecodeIntelDx(&LayoutCtx);
  2361. }
  2362.  
  2363. /*!------------------------------------------------------------------------
  2364.  * \fn     DecodeIntelDD(Word Flags)
  2365.  * \brief  Intel-style constant disposition - 32-bit words
  2366.  * \param  Flags Data Type & Endianess Flags
  2367.  * ------------------------------------------------------------------------ */
  2368.  
  2369. void DecodeIntelDD(Word Flags)
  2370. {
  2371.   tLayoutCtx LayoutCtx;
  2372.  
  2373.   memset(&LayoutCtx, 0, sizeof(LayoutCtx));
  2374.   LayoutCtx.LayoutFunc = LayoutDoubleWord;
  2375.   LayoutCtx.BaseElemLenBits = 32;
  2376.   LayoutCtx.flags = resolve_flags((int_pseudo_flags_t)Flags);
  2377.   switch (Grans[ActPC])
  2378.   {
  2379.     case 1:
  2380.       LayoutCtx.Put32I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put32I_To_8 : NULL;
  2381.       LayoutCtx.Put32F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put32F_To_8 : NULL;
  2382.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 3 : 0;
  2383.       LayoutCtx.Replicate = Replicate8ToN_To_8;
  2384.       break;
  2385.     case 2:
  2386.       LayoutCtx.Put32I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put32I_To_16 : NULL;
  2387.       LayoutCtx.Put32F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put32F_To_16 : NULL;
  2388.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2389.       LayoutCtx.Replicate = Replicate16ToN_To_16;
  2390.       break;
  2391.     case 4:
  2392.       LayoutCtx.Put32I = (Flags & eIntPseudoFlag_AllowInt) ? Put32I_To_32 : NULL;
  2393.       LayoutCtx.Put32F = (Flags & eIntPseudoFlag_AllowFloat) ? Put32F_To_32 : NULL;
  2394.       LayoutCtx.Replicate = Replicate32ToN_To_32;
  2395.       break;
  2396.     default:
  2397.       fprintf(stderr, "implement DD for %u-bytes words\n", (unsigned)Grans[ActPC]);
  2398.       exit(255);
  2399.   }
  2400.   if (*LabPart.str.p_str)
  2401.     SetSymbolOrStructElemSize(&LabPart, eSymbolSize32Bit);
  2402.   DecodeIntelDx(&LayoutCtx);
  2403. }
  2404.  
  2405. /*!------------------------------------------------------------------------
  2406.  * \fn     DecodeIntelDM(Word Flags)
  2407.  * \brief  Intel-style constant disposition - 48-bit words
  2408.  * \param  Flags Data Type & Endianess Flags
  2409.  * ------------------------------------------------------------------------ */
  2410.  
  2411. void DecodeIntelDM(Word Flags)
  2412. {
  2413.   tLayoutCtx LayoutCtx;
  2414.  
  2415.   memset(&LayoutCtx, 0, sizeof(LayoutCtx));
  2416.   LayoutCtx.LayoutFunc = LayoutMacAddr;
  2417.   LayoutCtx.BaseElemLenBits = 48;
  2418.   LayoutCtx.flags = resolve_flags((int_pseudo_flags_t)Flags);
  2419.   switch (Grans[ActPC])
  2420.   {
  2421.     case 1:
  2422.       LayoutCtx.Put48I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put48I_To_8 : NULL;
  2423.       LayoutCtx.Put48F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put48F_To_8 : NULL;
  2424.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 5 : 0;
  2425.       LayoutCtx.Replicate = Replicate8ToN_To_8;
  2426.       break;
  2427.     case 2:
  2428.       LayoutCtx.Put48I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put48I_To_16 : NULL;
  2429.       LayoutCtx.Put48F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put48F_To_16 : NULL;
  2430.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 2 : 0;
  2431.       LayoutCtx.Replicate = Replicate16ToN_To_16;
  2432.       break;
  2433.     case 4:
  2434.       LayoutCtx.Put48I = (Flags & eIntPseudoFlag_AllowInt) ? Put48I_To_32 : NULL;
  2435.       LayoutCtx.Put48F = (Flags & eIntPseudoFlag_AllowFloat) ? Put48F_To_32 : NULL;
  2436.       LayoutCtx.LoHiMap = (Flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2437.       LayoutCtx.Replicate = Replicate32ToN_To_32;
  2438.       break;
  2439.     default:
  2440.       fprintf(stderr, "implement DM for %u-bytes words\n", (unsigned)Grans[ActPC]);
  2441.       exit(255);
  2442.   }
  2443.   if (*LabPart.str.p_str)
  2444.     SetSymbolOrStructElemSize(&LabPart, eSymbolSize48Bit);
  2445.   DecodeIntelDx(&LayoutCtx);
  2446. }
  2447.  
  2448. /*!------------------------------------------------------------------------
  2449.  * \fn     DecodeIntelDQ(Word Flags)
  2450.  * \brief  Intel-style constant disposition - 64-bit words
  2451.  * \param  Flags Data Type & Endianess Flags
  2452.  * ------------------------------------------------------------------------ */
  2453.  
  2454. void DecodeIntelDQ(Word Flags)
  2455. {
  2456.   tLayoutCtx LayoutCtx;
  2457.  
  2458.   memset(&LayoutCtx, 0, sizeof(LayoutCtx));
  2459.   LayoutCtx.LayoutFunc = LayoutQuadWord;
  2460.   LayoutCtx.BaseElemLenBits = 64;
  2461.   LayoutCtx.flags = resolve_flags((int_pseudo_flags_t)Flags);
  2462.   switch (Grans[ActPC])
  2463.   {
  2464.     case 1:
  2465.       LayoutCtx.Put64I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put64I_To_8 : NULL;
  2466.       LayoutCtx.Put64F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put64F_To_8 : NULL;
  2467.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 7 : 0;
  2468.       LayoutCtx.Replicate = Replicate8ToN_To_8;
  2469.       break;
  2470.     case 2:
  2471.       LayoutCtx.Put64I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put64I_To_16 : NULL;
  2472.       LayoutCtx.Put64F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put64F_To_16 : NULL;
  2473.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 3 : 0;
  2474.       LayoutCtx.Replicate = Replicate16ToN_To_16;
  2475.       break;
  2476.     case 4:
  2477.       LayoutCtx.Put64I = (Flags & eIntPseudoFlag_AllowInt) ? Put64I_To_32 : NULL;
  2478.       LayoutCtx.Put64F = (Flags & eIntPseudoFlag_AllowFloat) ? Put64F_To_32 : NULL;
  2479.       LayoutCtx.LoHiMap = (Flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2480.       LayoutCtx.Replicate = Replicate32ToN_To_32;
  2481.       break;
  2482.     default:
  2483.       fprintf(stderr, "implement DQ for %u-bytes words\n", (unsigned)Grans[ActPC]);
  2484.       exit(255);
  2485.   }
  2486.   if (*LabPart.str.p_str)
  2487.     SetSymbolOrStructElemSize(&LabPart, eSymbolSize64Bit);
  2488.   DecodeIntelDx(&LayoutCtx);
  2489. }
  2490.  
  2491. /*!------------------------------------------------------------------------
  2492.  * \fn     DecodeIntelDT(Word Flags)
  2493.  * \brief  Intel-style constant disposition - 80-bit words
  2494.  * \param  Flags Data Type & Endianess Flags
  2495.  * ------------------------------------------------------------------------ */
  2496.  
  2497. void DecodeIntelDT(Word Flags)
  2498. {
  2499.   tLayoutCtx LayoutCtx;
  2500.  
  2501.   memset(&LayoutCtx, 0, sizeof(LayoutCtx));
  2502.   LayoutCtx.LayoutFunc = LayoutTenBytes;
  2503.   LayoutCtx.BaseElemLenBits = 80;
  2504.   LayoutCtx.flags = resolve_flags((int_pseudo_flags_t)Flags);
  2505.   switch (Grans[ActPC])
  2506.   {
  2507.     case 1:
  2508.       LayoutCtx.Put80F = Put80F_To_8;
  2509.       LayoutCtx.Put80I = Put80I_To_8;
  2510.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2511.       LayoutCtx.Replicate = Replicate8ToN_To_8;
  2512.       break;
  2513.     case 2:
  2514.       LayoutCtx.Put80F = Put80F_To_16;
  2515.       LayoutCtx.Put80I = Put80I_To_16;
  2516.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2517.       LayoutCtx.Replicate = Replicate16ToN_To_16;
  2518.       break;
  2519.     case 4:
  2520.       LayoutCtx.Put80F = Put80F_To_32;
  2521.       LayoutCtx.Put80I = Put80I_To_32;
  2522.       LayoutCtx.LoHiMap = (Flags & eIntPseudoFlag_BigEndian) ? 1 : 0;
  2523.       LayoutCtx.Replicate = Replicate32ToN_To_32;
  2524.       break;
  2525.     default:
  2526.       fprintf(stderr, "implement DT for %u-bytes words\n", (unsigned)Grans[ActPC]);
  2527.       exit(255);
  2528.   }
  2529.   if (*LabPart.str.p_str)
  2530.     SetSymbolOrStructElemSize(&LabPart, eSymbolSize80Bit);
  2531.   DecodeIntelDx(&LayoutCtx);
  2532. }
  2533.  
  2534. /*!------------------------------------------------------------------------
  2535.  * \fn     DecodeIntelDO(Word Flags)
  2536.  * \brief  Intel-style constant disposition - 128-bit words
  2537.  * \param  Flags Data Type & Endianess Flags
  2538.  * ------------------------------------------------------------------------ */
  2539.  
  2540. void DecodeIntelDO(Word Flags)
  2541. {
  2542.   tLayoutCtx LayoutCtx;
  2543.  
  2544.   memset(&LayoutCtx, 0, sizeof(LayoutCtx));
  2545.   LayoutCtx.LayoutFunc = LayoutOctaWord;
  2546.   LayoutCtx.BaseElemLenBits = 128;
  2547.   LayoutCtx.flags = resolve_flags((int_pseudo_flags_t)Flags);
  2548.   switch (Grans[ActPC])
  2549.   {
  2550.     case 1:
  2551.       LayoutCtx.Put128I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put128I_To_8 : NULL;
  2552.       LayoutCtx.Put128F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put128F_To_8 : NULL;
  2553.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 15 : 0;
  2554.       LayoutCtx.Replicate = Replicate8ToN_To_8;
  2555.       break;
  2556.     case 2:
  2557.       LayoutCtx.Put128I = (LayoutCtx.flags & eIntPseudoFlag_AllowInt) ? Put128I_To_16 : NULL;
  2558.       LayoutCtx.Put128F = (LayoutCtx.flags & eIntPseudoFlag_AllowFloat) ? Put128F_To_16 : NULL;
  2559.       LayoutCtx.LoHiMap = (LayoutCtx.flags & eIntPseudoFlag_BigEndian) ? 7 : 0;
  2560.       LayoutCtx.Replicate = Replicate16ToN_To_16;
  2561.       break;
  2562.     case 4:
  2563.       LayoutCtx.Put128I = (Flags & eIntPseudoFlag_AllowInt) ? Put128I_To_32 : NULL;
  2564.       LayoutCtx.Put128F = (Flags & eIntPseudoFlag_AllowFloat) ? Put128F_To_32 : NULL;
  2565.       LayoutCtx.LoHiMap = (Flags & eIntPseudoFlag_BigEndian) ? 3 : 0;
  2566.       LayoutCtx.Replicate = Replicate32ToN_To_32;
  2567.       break;
  2568.     default:
  2569.       fprintf(stderr, "implement DO for %u-bytes words\n", (unsigned)Grans[ActPC]);
  2570.       exit(255);
  2571.   }
  2572.   if (*LabPart.str.p_str)
  2573.     SetSymbolOrStructElemSize(&LabPart, eSymbolSize128Bit);
  2574.   DecodeIntelDx(&LayoutCtx);
  2575. }
  2576.  
  2577. /*!------------------------------------------------------------------------
  2578.  * \fn     DecodeIntelDS(Word item_size)
  2579.  * \brief  Intel-style memory reservation
  2580.  * \param  item_size # of bytes per reserved item
  2581.  * ------------------------------------------------------------------------ */
  2582.  
  2583. void DecodeIntelDS(Word item_size)
  2584. {
  2585.   if (ChkArgCnt(1, 1))
  2586.   {
  2587.     tSymbolFlags Flags;
  2588.     Boolean OK;
  2589.     LongInt HVal = EvalStrIntExpressionWithFlags(&ArgStr[1], Int32, &OK, &Flags);
  2590.  
  2591.     if (mFirstPassUnknown(Flags)) WrError(ErrNum_FirstPassCalc);
  2592.     else if (OK)
  2593.     {
  2594.       DontPrint = True;
  2595.       CodeLen = HVal * (LongInt)item_size;
  2596.       if (!HVal)
  2597.         WrError(ErrNum_NullResMem);
  2598.       BookKeeping();
  2599.     }
  2600.   }
  2601. }
  2602.  
  2603. /*!------------------------------------------------------------------------
  2604.  * \fn     AddIntelPseudo(PInstTable p_inst_table, int_pseudo_flags_t flags)
  2605.  * \brief  add Intelstyle pseudo instructions to hash table
  2606.  * \param  p_inst_table table to augment
  2607.  * \param  flags additional flags to parse to functions
  2608.  * ------------------------------------------------------------------------ */
  2609.  
  2610. void AddIntelPseudo(PInstTable p_inst_table, int_pseudo_flags_t flags)
  2611. {
  2612.   AddInstTable(p_inst_table, "DN", flags | eIntPseudoFlag_AllowInt, DecodeIntelDN);
  2613.   AddInstTable(p_inst_table, "DB", flags | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString, DecodeIntelDB);
  2614.   AddInstTable(p_inst_table, "DW", flags | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_AllowFloat, DecodeIntelDW);
  2615.   AddInstTable(p_inst_table, "DD", flags | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_AllowFloat, DecodeIntelDD);
  2616.   AddInstTable(p_inst_table, "DQ", flags | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_AllowFloat, DecodeIntelDQ);
  2617.   AddInstTable(p_inst_table, "DT", flags | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_AllowFloat, DecodeIntelDT);
  2618.   AddInstTable(p_inst_table, "DO", flags | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString | eIntPseudoFlag_AllowFloat, DecodeIntelDO);
  2619.   AddInstTable(p_inst_table, "DS", 1, DecodeIntelDS);
  2620. }
  2621.  
  2622. /*!------------------------------------------------------------------------
  2623.  * \fn     DecodeZ80SYNTAX(Word Code)
  2624.  * \brief  change Z80 syntax support for target
  2625.  * ------------------------------------------------------------------------ */
  2626.  
  2627. static void DecodeZ80SYNTAX(Word Code)
  2628. {
  2629.   UNUSED(Code);
  2630.  
  2631.   if (ChkArgCnt(1, 1))
  2632.   {
  2633.     tStrComp TmpComp;
  2634.  
  2635.     StrCompMkTemp(&TmpComp, Z80SyntaxName, 0);
  2636.     NLS_UpString(ArgStr[1].str.p_str);
  2637.     if (!as_strcasecmp(ArgStr[1].str.p_str, "OFF"))
  2638.     {
  2639.       CurrZ80Syntax = eSyntax808x;
  2640.       EnterIntSymbol(&TmpComp, 0, SegNone, True);
  2641.     }
  2642.     else if (!as_strcasecmp(ArgStr[1].str.p_str, "ON"))
  2643.     {
  2644.       CurrZ80Syntax = eSyntaxBoth;
  2645.       EnterIntSymbol(&TmpComp, 1, SegNone, True);
  2646.     }
  2647.     else if (!as_strcasecmp(ArgStr[1].str.p_str, "EXCLUSIVE"))
  2648.     {
  2649.       CurrZ80Syntax = eSyntaxZ80;
  2650.       EnterIntSymbol(&TmpComp, 2, SegNone, True);
  2651.     }
  2652.     else
  2653.       WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  2654.   }
  2655. }
  2656.  
  2657. /*!------------------------------------------------------------------------
  2658.  * \fn     ChkZ80Syntax(tZ80Syntax InstrSyntax)
  2659.  * \brief  check whether instruction's syntax (808x/Z80) fits to selected one
  2660.  * \param  InstrSyntax instruction syntax
  2661.  * \return True if all fine
  2662.  * ------------------------------------------------------------------------ */
  2663.  
  2664. Boolean ChkZ80Syntax(tZ80Syntax InstrSyntax)
  2665. {
  2666.   if ((InstrSyntax == eSyntax808x) && (!(CurrZ80Syntax & eSyntax808x)))
  2667.   {
  2668.     WrStrErrorPos(ErrNum_Z80SyntaxExclusive, &OpPart);
  2669.     return False;
  2670.   }
  2671.   else if ((InstrSyntax == eSyntaxZ80) && (!(CurrZ80Syntax & eSyntaxZ80)))
  2672.   {
  2673.     WrStrErrorPos(ErrNum_Z80SyntaxNotEnabled, &OpPart);
  2674.     return False;
  2675.   }
  2676.   else
  2677.     return True;
  2678. }
  2679.  
  2680. /*!------------------------------------------------------------------------
  2681.  * \fn     AddZ80Syntax(struct sInstTable *InstTable)
  2682.  * \brief  add Z80SYNTAX instruction to list & possibly set default
  2683.  * \param  InstTable table to add to
  2684.  * ------------------------------------------------------------------------ */
  2685.  
  2686. void AddZ80Syntax(struct sInstTable *InstTable)
  2687. {
  2688.   if (!onoff_test_and_set(e_onoff_reg_z80syntax))
  2689.   {
  2690.     tStrComp TmpComp;
  2691.  
  2692.     CurrZ80Syntax = eSyntax808x;
  2693.     StrCompMkTemp(&TmpComp, Z80SyntaxName, 0);
  2694.     EnterIntSymbol(&TmpComp, 0, SegNone, True);
  2695.   }
  2696.   AddInstTable(InstTable, "Z80SYNTAX", 0, DecodeZ80SYNTAX);
  2697. }
  2698.