Subversion Repositories pentevo

Rev

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

  1. /* intpseudo.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Pseudo Instructions used by some 4 bit devices                            */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. /*****************************************************************************
  12.  * Includes
  13.  *****************************************************************************/
  14.  
  15. #include "stdinc.h"
  16. #include <ctype.h>
  17. #include <string.h>
  18. #include <math.h>
  19.  
  20. #include "bpemu.h"
  21. #include "be_le.h"
  22. #include "strutil.h"
  23. #include "asmdef.h"
  24. #include "asmsub.h"
  25. #include "asmpars.h"
  26. #include "errmsg.h"
  27. #include "chartrans.h"
  28.  
  29. #include "fourpseudo.h"
  30.  
  31. void DecodeRES(Word Code)
  32. {
  33.   UNUSED(Code);
  34.  
  35.   if (ChkArgCnt(1, 1))
  36.   {
  37.     Boolean ValOK;
  38.     tSymbolFlags Flags;
  39.     Word Size;
  40.  
  41.     Size = EvalStrIntExpressionWithFlags(&ArgStr[1], Int16, &ValOK, &Flags);
  42.     if (mFirstPassUnknown(Flags)) WrError(ErrNum_FirstPassCalc);
  43.     if (ValOK && !mFirstPassUnknown(Flags))
  44.     {
  45.       DontPrint = True;
  46.       if (!Size) WrError(ErrNum_NullResMem);
  47.       CodeLen = Size;
  48.       BookKeeping();
  49.     }
  50.   }
  51. }
  52.  
  53. void DecodeDATA(IntType CodeIntType, IntType DataIntType)
  54. {
  55.   TempResult t;
  56.   IntType ValIntType = (ActPC == SegData) ? DataIntType : CodeIntType;
  57.   LargeWord ValMask = IntTypeDefs[ValIntType].Mask;
  58.   Word MaxMultCharLen = (Lo(IntTypeDefs[ValIntType].SignAndWidth) + 7) / 8;
  59.   LargeWord UnknownMask = ValMask / 2;
  60.  
  61.   as_tempres_ini(&t);
  62.   if (ChkArgCnt(1, ArgCntMax))
  63.   {
  64.     Boolean ValOK = True;
  65.     tStrComp *pArg;
  66.  
  67.     forallargs(pArg, ValOK)
  68.     {
  69.       EvalStrExpression(pArg, &t);
  70.       if ((t.Typ == TempInt) && mFirstPassUnknown(t.Flags))
  71.         t.Contents.Int &= UnknownMask;
  72.  
  73.       switch (t.Typ)
  74.       {
  75.         case TempFloat:
  76.           WrStrErrorPos(ErrNum_StringOrIntButFloat, pArg);
  77.           ValOK = False;
  78.           break;
  79.         case TempString:
  80.         {
  81.           unsigned char *cp;
  82.           unsigned z2;
  83.           int bpos;
  84.           LongWord TransCh;
  85.  
  86.           if (MultiCharToInt(&t, MaxMultCharLen))
  87.             goto ToInt;
  88.  
  89.           if (as_chartrans_xlate_nonz_dynstr(CurrTransTable->p_table, &t.Contents.str, pArg))
  90.             ValOK = False;
  91.           else
  92.             for (z2 = 0, cp = (unsigned char *)t.Contents.str.p_str, bpos = 0;
  93.                  z2 < t.Contents.str.len;
  94.                  z2++, cp++)
  95.             {
  96.               TransCh = *cp & 0xff;
  97.  
  98.               /* word width 24..31 bits: pack three characters into one dword */
  99.  
  100.               if (ValMask >= 0xfffffful)
  101.               {
  102.                 if (!bpos)
  103.                   DAsmCode[CodeLen++] = TransCh;
  104.                 else if (1 == bpos)
  105.                   DAsmCode[CodeLen - 1] |= TransCh << 8;
  106.                 else
  107.                   DAsmCode[CodeLen - 1] |= TransCh << 16;
  108.                 if (++bpos >= 3)
  109.                   bpos = 0;
  110.               }
  111.  
  112.               /* word width 17..23 bits: pack two characters into one dword */
  113.  
  114.               else if (ValMask > 0xfffful)
  115.               {
  116.                 if (!bpos)
  117.                   DAsmCode[CodeLen++] = TransCh;
  118.                 else
  119.                   DAsmCode[CodeLen - 1] |= TransCh << 8;
  120.                 if (++bpos >= 2)
  121.                   bpos = 0;
  122.               }
  123.  
  124.               /* word width 16 bits: pack two characters into one word */
  125.  
  126.               else if (ValMask == 0xfffful)
  127.               {
  128.                 if (!bpos)
  129.                   WAsmCode[CodeLen++] = TransCh;
  130.                 else
  131.                   WAsmCode[CodeLen - 1] |= TransCh << 8;
  132.                 if (++bpos >= 2)
  133.                   bpos = 0;
  134.               }
  135.  
  136.               /* word width 9..15 bits: pack one character into one word */
  137.  
  138.               else if (ValMask > 0xff)
  139.                 WAsmCode[CodeLen++] = TransCh;
  140.  
  141.               /* word width 8 bits: pack one character into one byte */
  142.  
  143.               else if (ValMask == 0xff)
  144.                 BAsmCode[CodeLen++] = TransCh;
  145.  
  146.               /* word width 4...7 bits: pack one character into two nibbles */
  147.  
  148.               else
  149.               {
  150.                 BAsmCode[CodeLen++] = TransCh >> 4;
  151.                 BAsmCode[CodeLen++] = TransCh & 15;
  152.               }
  153.             }
  154.           break;
  155.         }
  156.         case TempInt:
  157.         ToInt:
  158.           if (!mSymbolQuestionable(t.Flags) && !RangeCheck(t.Contents.Int, ValIntType))
  159.           {
  160.             WrStrErrorPos(ErrNum_OverRange, pArg);
  161.             ValOK = False;
  162.           }
  163.           else if (ValMask <= 0xff)
  164.             BAsmCode[CodeLen++] = t.Contents.Int & ValMask;
  165.           else if (ValMask <= 0xfffful)
  166.             WAsmCode[CodeLen++] = t.Contents.Int & ValMask;
  167.           else
  168.             DAsmCode[CodeLen++] = t.Contents.Int & ValMask;
  169.           break;
  170.         default:
  171.           ValOK = False;
  172.       }
  173.     }
  174.     if (!ValOK)
  175.       CodeLen = 0;
  176.   }
  177.   as_tempres_free(&t);
  178. }
  179.