Subversion Repositories pentevo

Rev

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

  1. /* codescmp.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator National SC/MP                                              */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <ctype.h>
  13. #include <string.h>
  14.  
  15. #include "nls.h"
  16. #include "strutil.h"
  17. #include "bpemu.h"
  18. #include "chunks.h"
  19. #include "asmdef.h"
  20. #include "asmsub.h"
  21. #include "asmpars.h"
  22. #include "asmitree.h"
  23. #include "asmallg.h"
  24. #include "onoff_common.h"
  25. #include "intpseudo.h"
  26. #include "codevars.h"
  27. #include "codepseudo.h"
  28. #include "errmsg.h"
  29.  
  30. #include "codescmp.h"
  31.  
  32. /*---------------------------------------------------------------------------*/
  33.  
  34. #define REG_PC 0
  35. #define REG_E 0x80
  36.  
  37. static CPUVar CPUSCMP;
  38.  
  39. /*---------------------------------------------------------------------------*/
  40.  
  41. /*!------------------------------------------------------------------------
  42.  * \fn     DecodeRegCore(const char *p_arg, tRegInt *p_result, tSymbolSize *p_size)
  43.  * \brief  check whether argument is a CPU register
  44.  * \param  p_arg source argument
  45.  * \param  p_result resulting register #
  46.  * \param  p_size register's size
  47.  * \return True if argument is a register
  48.  * ------------------------------------------------------------------------ */
  49.  
  50. static Boolean DecodeRegCore(const char *p_arg, tRegInt *p_result, tSymbolSize *p_size)
  51. {
  52.   int l = strlen(p_arg);
  53.  
  54.   switch (l)
  55.   {
  56.     case 2:
  57.       if (as_toupper(*p_arg) != 'P')
  58.         return False;
  59.       p_arg++;
  60.       switch (as_toupper(*p_arg))
  61.       {
  62.         case '0':
  63.         case '1':
  64.         case '2':
  65.         case '3':
  66.           *p_result = *p_arg - '0';
  67.           *p_size = eSymbolSize16Bit;
  68.           return True;
  69.         case 'C':
  70.           *p_result = REG_PC | REGSYM_FLAG_ALIAS;
  71.           *p_size = eSymbolSize16Bit;
  72.           return True;
  73.         default:
  74.           break;
  75.       }
  76.       break;
  77.     case 1:
  78.       if (as_toupper(*p_arg) == 'E')
  79.       {
  80.         *p_result = REG_E;
  81.         *p_size = eSymbolSize8Bit;
  82.         return True;
  83.       }
  84.       break;
  85.   }
  86.   return False;
  87. }
  88.  
  89. /*!------------------------------------------------------------------------
  90.  * \fn     DecodeReg(const tStrComp *p_arg, Byte *p_value, tSymbolSize *p_size, tSymbolSize req_size, Boolean must_be_reg)
  91.  * \brief  check whether argument is a CPU register
  92.  * \param  p_arg source argument
  93.  * \param  p_value resulting register # if yes
  94.  * \param  p_size resulting register's size
  95.  * \param  req_size size of requested register
  96.  * \param  must_be_reg is a register argument expected?
  97.  * \return eval result
  98.  * ------------------------------------------------------------------------ */
  99.  
  100. static Boolean ChkRegSize(tSymbolSize req_size, tSymbolSize act_size)
  101. {
  102.   return (req_size == eSymbolSizeUnknown)
  103.       || (req_size == act_size);
  104. }
  105.  
  106. static tRegEvalResult DecodeReg(const tStrComp *p_arg, Byte *p_value, tSymbolSize *p_size, tSymbolSize req_size, Boolean must_be_reg)
  107. {
  108.   tRegDescr reg_descr;
  109.   tEvalResult eval_result;
  110.   tRegEvalResult reg_eval_result;
  111.  
  112.   if (DecodeRegCore(p_arg->str.p_str, &reg_descr.Reg, &eval_result.DataSize))
  113.     reg_eval_result = eIsReg;
  114.   else
  115.     reg_eval_result = EvalStrRegExpressionAsOperand(p_arg, &reg_descr, &eval_result, eSymbolSizeUnknown, must_be_reg);
  116.  
  117.   if (reg_eval_result == eIsReg)
  118.   {
  119.     if (!ChkRegSize(req_size, eval_result.DataSize))
  120.     {
  121.       WrStrErrorPos(ErrNum_InvOpSize, p_arg);
  122.       reg_eval_result = must_be_reg ? eIsNoReg : eRegAbort;
  123.     }
  124.   }
  125.  
  126.   *p_value = reg_descr.Reg;
  127.   if (eval_result.DataSize == eSymbolSize16Bit)
  128.     *p_value &= ~REGSYM_FLAG_ALIAS;
  129.   if (p_size) *p_size = eval_result.DataSize;
  130.   return reg_eval_result;
  131. }
  132.  
  133. /*!------------------------------------------------------------------------
  134.  * \fn     decode_ptr_reg(const tStrComp *p_arg, Byte *p_result)
  135.  * \brief  parse pointer register expression
  136.  * \param  p_arg source argument
  137.  * \param  p_result result buffer
  138.  * \return eIsReg/eRegAbort
  139.  * ------------------------------------------------------------------------ */
  140.  
  141. static tRegEvalResult decode_ptr_reg(const tStrComp *p_arg, Byte *p_result)
  142. {
  143.   tRegEvalResult result = DecodeReg(p_arg, p_result, NULL, eSymbolSize16Bit, False);
  144.  
  145.   /* Pointer register may be named or plain number from 0..3: */
  146.  
  147.   if (eIsNoReg == result)
  148.   {
  149.     Boolean ok;
  150.  
  151.     *p_result = EvalStrIntExpression(p_arg, UInt2, &ok);
  152.     result = ok ? eIsReg : eRegAbort;
  153.   }
  154.  
  155.   return result;
  156. }
  157.  
  158. /*!------------------------------------------------------------------------
  159.  * \fn     DissectReg_SCMP(char *p_dest, size_t dest_dize, tRegInt value, tSymbolSize inp_size)
  160.  * \brief  dissect register symbols - SC/MP variant
  161.  * \param  p_dest destination buffer
  162.  * \param  dest_size destination buffer size
  163.  * \param  value numeric register value
  164.  * \param  inp_size register size
  165.  * ------------------------------------------------------------------------ */
  166.  
  167. static void DissectReg_SCMP(char *p_dest, size_t dest_size, tRegInt value, tSymbolSize inp_size)
  168. {
  169.   switch (inp_size)
  170.   {
  171.     case eSymbolSize8Bit:
  172.       if (value == REG_E)
  173.       {
  174.         strmaxcpy(p_dest, "E", dest_size);
  175.         break;
  176.       }
  177.       else
  178.         goto unknown;
  179.     case eSymbolSize16Bit:
  180.       if (value == (REG_PC | REGSYM_FLAG_ALIAS))
  181.         strmaxcpy(p_dest, "PC", dest_size);
  182.       else
  183.         as_snprintf(p_dest, dest_size, "P%u", (unsigned)value);
  184.       break;
  185.     unknown:
  186.     default:
  187.       as_snprintf(p_dest, dest_size, "%d-%u", (int)inp_size, (unsigned)value);
  188.   }
  189. }
  190.  
  191. /*!------------------------------------------------------------------------
  192.  * \fn     DecodeAdr(const tStrComp *pArg, Boolean MayInc, Byte PCDisp, Byte *Arg)
  193.  * \brief  decode address expression
  194.  * \param  pArg source argument
  195.  * \param  MayInc allow auto-increment?
  196.  * \param  PCDisp additional offset to take into account for PC-relative addressing
  197.  * \param  Arg returns m|ptr for opcode byte
  198.  * \return True if success
  199.  * ------------------------------------------------------------------------ */
  200.  
  201. static Boolean DecodeAdr(const tStrComp *pArg, Boolean MayInc, Byte PCDisp, Byte *Arg)
  202. {
  203.   Word Target;
  204.   Boolean OK;
  205.   int l, SplitPos;
  206.   tSymbolFlags Flags;
  207.   String ArgStr;
  208.   tStrComp ArgCopy;
  209.  
  210.   StrCompMkTemp(&ArgCopy, ArgStr, sizeof(ArgStr));
  211.   StrCompCopy(&ArgCopy, pArg);
  212.   if (((SplitPos = FindDispBaseSplit(ArgCopy.str.p_str, &l)) >= 0) && (l >= 4))
  213.   {
  214.     tStrComp Left, Right;
  215.  
  216.     StrCompSplitRef(&Left, &Right, &ArgCopy, ArgCopy.str.p_str + SplitPos);
  217.     StrCompShorten(&Right, 1);
  218.  
  219.     if (decode_ptr_reg(&Right, Arg) != eIsReg)
  220.       return False;
  221.  
  222.     if (*Left.str.p_str == '@')
  223.     {
  224.       if (!MayInc)
  225.       {
  226.         WrError(ErrNum_InvAddrMode);
  227.         return False;
  228.       }
  229.       StrCompIncRefLeft(&Left, 1);
  230.       *Arg += 4;
  231.     }
  232.     /* Programmer's manual says that 'Auto-indexing requires ..., and a pointer register (other than PC)...' : */
  233.     if (*Arg == (4 | REG_PC))
  234.     {
  235.       WrStrErrorPos(ErrNum_InvReg, &Right);
  236.       return False;
  237.     }
  238.     switch (DecodeReg(&Left, &BAsmCode[1], NULL, eSymbolSize8Bit, False))
  239.     {
  240.       case eIsReg:
  241.         /* 0x80 -> use E register only applies if pointer register is not P0(PC): */
  242.         if (*Arg == REG_PC)
  243.         {
  244.           WrStrErrorPos(ErrNum_InvAddrMode, &Left);
  245.           return False;
  246.         }
  247.         break;
  248.       case eRegAbort:
  249.         return False;
  250.       default:
  251.       {
  252.         tEvalResult result;
  253.         BAsmCode[1] = EvalStrIntExpressionWithResult(&Left, SInt8, &result);
  254.         if (!result.OK)
  255.           return False;
  256.         /* Depending on pointer register, valid range is -128...+127 or -127...+127: */
  257.         if ((*Arg != REG_PC) && (BAsmCode[1] == 0x80) && !mFirstPassUnknownOrQuestionable(result.Flags))
  258.           WrStrErrorPos(ErrNum_MeansE, &Left);
  259.       }
  260.     }
  261.     return True;
  262.   }
  263.  
  264.   /* no carry in PC from bit 11 to 12; additionally handle preincrement */
  265.  
  266.   Target = EvalStrIntExpressionWithFlags(pArg, UInt16, &OK, &Flags);
  267.   if (OK)
  268.   {
  269.     Word PCVal = (EProgCounter() & 0xf000) + ((EProgCounter() + 1 + PCDisp) & 0xfff);
  270.     Word Disp = (Target - PCVal) & 0xfff;
  271.  
  272.     if (mSymbolQuestionable(Flags))
  273.       Target = PCVal;
  274.  
  275.     if (!ChkSamePage(Target, PCVal, 12, Flags));
  276.  
  277.     /* Since the pointer register is P0(PC) in this case, a displacement of 0x80
  278.        (-128) does not signify usage of E register, and can be used at
  279.        this place: */
  280.  
  281.     else if ((Disp > 0x7f) && (Disp < 0xf80)) WrError(ErrNum_DistTooBig);
  282.     else
  283.     {
  284.       BAsmCode[1] = Disp & 0xff;
  285.       *Arg = REG_PC;
  286.       return True;
  287.     }
  288.   }
  289.   return False;
  290. }
  291.  
  292. static void ChkPage(void)
  293. {
  294.   if (((EProgCounter()) & 0xf000) != ((EProgCounter() + CodeLen) & 0xf000))
  295.     WrError(ErrNum_PageCrossing);
  296. }
  297.  
  298. /*---------------------------------------------------------------------------*/
  299.  
  300. static void DecodeFixed(Word Index)
  301. {
  302.   if (ChkArgCnt(0, 0))
  303.   {
  304.     BAsmCode[0] = Index; CodeLen = 1;
  305.   }
  306. }
  307.  
  308. static void DecodeImm(Word Index)
  309. {
  310.   if (ChkArgCnt(1, 1))
  311.   {
  312.     Boolean OK;
  313.  
  314.     BAsmCode[1] = EvalStrIntExpression(&ArgStr[1], Int8, &OK);
  315.     if (OK)
  316.     {
  317.       BAsmCode[0] = Index; CodeLen = 2; ChkPage();
  318.     }
  319.   }
  320. }
  321.  
  322. static void DecodeRegOrder(Word Index)
  323. {
  324.   if (!ChkArgCnt(1, 1));
  325.   else if (decode_ptr_reg(&ArgStr[1], BAsmCode + 0) != eIsReg) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  326.   else
  327.   {
  328.     BAsmCode[0] |= Index; CodeLen = 1;
  329.   }
  330. }
  331.  
  332. static void DecodeMem(Word Index)
  333. {
  334.   if (ChkArgCnt(1, 1))
  335.   if (DecodeAdr(&ArgStr[1], True, 0, BAsmCode + 0))
  336.   {
  337.     BAsmCode[0] |= Index; CodeLen = 2; ChkPage();
  338.   }
  339. }
  340.  
  341. static void DecodeJmp(Word Index)
  342. {
  343.   if (ChkArgCnt(1, 1))
  344.   if (DecodeAdr(&ArgStr[1], False, 1, BAsmCode + 0))
  345.   {
  346.     BAsmCode[0] |= Index; CodeLen = 2; ChkPage();
  347.   }
  348. }
  349.  
  350. /*!------------------------------------------------------------------------
  351.  * \fn     decode_js(Word Index)
  352.  * \brief  decode JS (macro) instruction
  353.  * \return
  354.  * ------------------------------------------------------------------------ */
  355.  
  356. static void decode_js(Word Index)
  357. {
  358.   Byte reg;
  359.  
  360.   UNUSED(Index);
  361.  
  362.   if (!ChkArgCnt(2, 2));
  363.   else if (decode_ptr_reg(&ArgStr[1], &reg) != eIsReg) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  364.   else
  365.   {
  366.     Boolean ok;
  367.     Word address = EvalStrIntExpression(&ArgStr[2], UInt16, &ok);
  368.  
  369.     if (ok)
  370.     {
  371.       address--;
  372.       /* LDI H(address) */
  373.       BAsmCode[CodeLen++] = 0xc4;
  374.       BAsmCode[CodeLen++] = Hi(address);
  375.       /* XPAH Pn */
  376.       BAsmCode[CodeLen++] = 0x34 + reg;
  377.       /* LDI L(address) */
  378.       BAsmCode[CodeLen++] = 0xc4;
  379.       BAsmCode[CodeLen++] = Lo(address);
  380.       /* XPAL Pn */
  381.       BAsmCode[CodeLen++] = 0x30 + reg;
  382.       /* XPPC Pn */
  383.       BAsmCode[CodeLen++] = 0x3c + reg;
  384.     }
  385.   }
  386. }
  387.  
  388. static void DecodeLD(Word Index)
  389. {
  390.   if (ChkArgCnt(1, 1))
  391.   if (DecodeAdr(&ArgStr[1], False, 0, BAsmCode + 0))
  392.   {
  393.     BAsmCode[0] |= Index; CodeLen = 2; ChkPage();
  394.   }
  395. }
  396.  
  397. /*---------------------------------------------------------------------------*/
  398.  
  399. static void AddFixed(const char *NName, Byte NCode)
  400. {
  401.   AddInstTable(InstTable, NName, NCode, DecodeFixed);
  402. }
  403.  
  404. static void AddImm(const char *NName, Byte NCode)
  405. {
  406.   AddInstTable(InstTable, NName, NCode, DecodeImm);
  407. }
  408.  
  409. static void AddReg(const char *NName, Byte NCode)
  410. {
  411.   AddInstTable(InstTable, NName, NCode, DecodeRegOrder);
  412. }
  413.  
  414. static void AddMem(const char *NName, Byte NCode)
  415. {
  416.   AddInstTable(InstTable, NName, NCode, DecodeMem);
  417. }
  418.  
  419. static void AddJmp(const char *NName, Byte NCode)
  420. {
  421.   AddInstTable(InstTable, NName, NCode, DecodeJmp);
  422. }
  423.  
  424. static void InitFields(void)
  425. {
  426.   InstTable = CreateInstTable(201);
  427.  
  428.   add_null_pseudo(InstTable);
  429.  
  430.   AddFixed("LDE" ,0x40); AddFixed("XAE" ,0x01); AddFixed("ANE" ,0x50);
  431.   AddFixed("ORE" ,0x58); AddFixed("XRE" ,0x60); AddFixed("DAE" ,0x68);
  432.   AddFixed("ADE" ,0x70); AddFixed("CAE" ,0x78); AddFixed("SIO" ,0x19);
  433.   AddFixed("SR"  ,0x1c); AddFixed("SRL" ,0x1d); AddFixed("RR"  ,0x1e);
  434.   AddFixed("RRL" ,0x1f); AddFixed("HALT",0x00); AddFixed("CCL" ,0x02);
  435.   AddFixed("SCL" ,0x03); AddFixed("DINT",0x04); AddFixed("IEN" ,0x05);
  436.   AddFixed("CSA" ,0x06); AddFixed("CAS" ,0x07); AddFixed("NOP" ,0x08);
  437.  
  438.   AddImm("LDI" , 0xc4); AddImm("ANI" , 0xd4); AddImm("ORI" , 0xdc);
  439.   AddImm("XRI" , 0xe4); AddImm("DAI" , 0xec); AddImm("ADI" , 0xf4);
  440.   AddImm("CAI" , 0xfc); AddImm("DLY" , 0x8f);
  441.  
  442.   AddReg("XPAL", 0x30); AddReg("XPAH", 0x34); AddReg("XPPC", 0x3c);
  443.  
  444.   AddMem("LD"  , 0xc0); AddMem("ST"  , 0xc8); AddMem("AND" , 0xd0);
  445.   AddMem("OR"  , 0xd8); AddMem("XOR" , 0xe0); AddMem("DAD" , 0xe8);
  446.   AddMem("ADD" , 0xf0); AddMem("CAD" , 0xf8);
  447.  
  448.   AddJmp("JMP" , 0x90); AddJmp("JP"  , 0x94); AddJmp("JZ"  , 0x98);
  449.   AddJmp("JNZ" , 0x9c);
  450.   AddInstTable(InstTable, "JS", 0x00, decode_js);
  451.  
  452.   AddInstTable(InstTable, "ILD", 0xa8, DecodeLD);
  453.   AddInstTable(InstTable, "DLD", 0xb8, DecodeLD);
  454.   AddInstTable(InstTable, "REG" , 0, CodeREG);
  455.  
  456.   AddIntelPseudo(InstTable, eIntPseudoFlag_DynEndian);
  457.   AddInstTable(InstTable, "BYTE", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt, DecodeIntelDB);
  458.   AddInstTable(InstTable, "DBYTE", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt, DecodeIntelDW);
  459.   AddInstTable(InstTable, ".BYTE", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt, DecodeIntelDB);
  460.   AddInstTable(InstTable, ".DBYTE", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt, DecodeIntelDW);
  461.   AddInstTable(InstTable, "ASCII", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowString, DecodeIntelDB);
  462.   AddInstTable(InstTable, ".ASCII", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowString, DecodeIntelDB);
  463. }
  464.  
  465. static void DeinitFields(void)
  466. {
  467.   DestroyInstTable(InstTable);
  468. }
  469.  
  470. /*---------------------------------------------------------------------------*/
  471.  
  472. /*!------------------------------------------------------------------------
  473.  * \fn     InternSymbol_SCMP(char *pArg, TempResult *pResult)
  474.  * \brief  handle built-in (register) symbols for SC/MP
  475.  * \param  pArg source argument
  476.  * \param  pResult result buffer
  477.  * ------------------------------------------------------------------------ */
  478.  
  479. static void InternSymbol_SCMP(char *pArg, TempResult *pResult)
  480. {
  481.   if (DecodeRegCore(pArg, &pResult->Contents.RegDescr.Reg, &pResult->DataSize))
  482.   {
  483.     pResult->Typ = TempReg;
  484.     pResult->Contents.RegDescr.Dissect = DissectReg_SCMP;
  485.     pResult->Contents.RegDescr.compare = NULL;
  486.   }
  487. }
  488.  
  489. static void MakeCode_SCMP(void)
  490. {
  491.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  492.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  493. }
  494.  
  495. static Boolean IsDef_SCMP(void)
  496. {
  497.   return Memo("REG");
  498. }
  499.  
  500. static void SwitchTo_SCMP(void)
  501. {
  502.   TurnWords = False;
  503.   SetIntConstMode(eIntConstModeC);
  504.  
  505.   PCSymbol = "$"; HeaderID = 0x6e; NOPCode = 0x08;
  506.   DivideChars = ",";
  507.   HasAttrs = False; AttrChars = ".";
  508.  
  509.   ValidSegs = 1 << SegCode;
  510.   Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0;
  511.   SegLimits[SegCode] = 0xffff;
  512.  
  513.   MakeCode = MakeCode_SCMP; IsDef = IsDef_SCMP;
  514.   SwitchFrom = DeinitFields; InitFields();
  515.  
  516.   onoff_bigendian_add();
  517.  
  518.   QualifyQuote = QualifyQuote_SingleQuoteConstant;
  519.   DissectReg = DissectReg_SCMP;
  520.   InternSymbol = InternSymbol_SCMP;
  521.  
  522.   IntConstModeIBMNoTerm = True;
  523. }
  524.  
  525. void codescmp_init(void)
  526. {
  527.   CPUSCMP = AddCPU("SC/MP", SwitchTo_SCMP);
  528. }
  529.