Subversion Repositories pentevo

Rev

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

  1. /* code4004.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator Intel 4004                                                  */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <ctype.h>
  13. #include <string.h>
  14.  
  15. #include "bpemu.h"
  16. #include "strutil.h"
  17. #include "asmdef.h"
  18. #include "asmsub.h"
  19. #include "asmpars.h"
  20. #include "asmitree.h"
  21. #include "asmallg.h"
  22. #include "codevars.h"
  23. #include "headids.h"
  24. #include "codepseudo.h"
  25. #include "fourpseudo.h"
  26. #include "errmsg.h"
  27.  
  28. #include "code4004.h"
  29.  
  30. /*---------------------------------------------------------------------------*/
  31. /* Variablen */
  32.  
  33. static CPUVar CPU4004, CPU4040;
  34.  
  35. /*---------------------------------------------------------------------------*/
  36. /* Parser */
  37.  
  38. /*!------------------------------------------------------------------------
  39.  * \fn     RegVal(const char *pInp, int l)
  40.  * \brief  decode numeric part of register name - either single hex digit or two dec digits
  41.  * \param  pInp numberic value from argument
  42.  * \param  length of numberic value from argument
  43.  * \return register number or 0xff if invalid
  44.  * ------------------------------------------------------------------------ */
  45.  
  46. static Byte RegVal(const char *pInp, int l)
  47. {
  48.   switch (l)
  49.   {
  50.     case 1:
  51.     {
  52.       char ch = as_toupper(*pInp);
  53.       if ((ch >='0') && (ch <= '9'))
  54.         return ch - '0';
  55.       else if ((ch >='A') && (ch <= 'F'))
  56.         return ch - 'A' + 10;
  57.       else
  58.         return 0xff;
  59.     }
  60.     case 2:
  61.     {
  62.       unsigned Acc = 0, z;
  63.  
  64.       for (z = 0; z < 2; z++)
  65.       {
  66.         if (!isdigit(pInp[z]))
  67.           return 0xff;
  68.         Acc = (Acc * 10) + (pInp[z] - '0');
  69.       }
  70.       return (Acc <= 15) ? Acc : 0xff;
  71.     }
  72.     default:
  73.       return 0xff;
  74.   }
  75. }
  76.  
  77. /*!------------------------------------------------------------------------
  78.  * \fn     DecodeRegCore(const char *pArg, Byte *pValue, int l)
  79.  * \brief  decode 4 bit register
  80.  * \param  pArg potential register argument
  81.  * \param  pValue register # if it's a register
  82.  * \param  l length of argument
  83.  * \return True if it's a register
  84.  * ------------------------------------------------------------------------ */
  85.  
  86. static Boolean DecodeRegCore(const char *pAsc, Byte *pErg, int l)
  87. {
  88.   if ((l < 2) || (l > 3) || (as_toupper(*pAsc) != 'R'))
  89.     return False;
  90.  
  91.   *pErg = RegVal(pAsc + 1, l - 1);
  92.   return (*pErg != 0xff);
  93. }
  94.  
  95. /*!------------------------------------------------------------------------
  96.  * \fn     DecodeRRegCore(const char *pArg, Byte *pValue)
  97.  * \brief  decode 8 bit register pair
  98.  * \param  pArg ASCII argument of potential register
  99.  * \param  pValue register # if it's a register
  100.  * \return True if it's a register
  101.  * ------------------------------------------------------------------------ */
  102.  
  103. static Boolean DecodeRRegCore(const char *pArg, Byte *pValue)
  104. {
  105.   Byte UpperValue;
  106.   const char *pPair;
  107.   int l;
  108.  
  109.   l = strlen(pArg);
  110.  
  111.   /* syntax RnP: */
  112.  
  113.   if ((l >= 3) && (l <= 4)
  114.    && (as_toupper(pArg[l -1]) == 'P')
  115.    && DecodeRegCore(pArg, pValue, l - 1))
  116.   {
  117.     if (*pValue > 7)
  118.       return False;
  119.     *pValue <<= 1;
  120.     return True;
  121.   }
  122.  
  123.   /* syntax RnRn+1 */
  124.  
  125.   if ((l < 4) || (l > 6) || (as_toupper(*pArg) != 'R'))
  126.     return False;
  127.  
  128.   for (pPair = pArg + 1; *pPair; pPair++)
  129.     if (as_toupper(*pPair) == 'R')
  130.       break;
  131.   if ((!*pPair) || (pPair - pArg < 2) || (pPair - pArg >= l - 1))
  132.     return False;
  133.  
  134.   *pValue = RegVal(pArg + 1, pPair - pArg - 1);
  135.   UpperValue = RegVal(pPair + 1, l - (pPair - pArg + 1));
  136.   return (*pValue != 0xff) && (UpperValue != 0xff) && Odd(UpperValue) && (*pValue + 1 == UpperValue);
  137. }
  138.  
  139. /*!------------------------------------------------------------------------
  140.  * \fn     DissectReg_4004(char *pDest, size_t DestSize, tRegInt Value, tSymbolSize InpSize)
  141.  * \brief  dissect register symbols - 4004 variant
  142.  * \param  pDest destination buffer
  143.  * \param  DestSize destination buffer size
  144.  * \param  Value numeric register value
  145.  * \param  InpSize register size
  146.  * ------------------------------------------------------------------------ */
  147.  
  148. static void DissectReg_4004(char *pDest, size_t DestSize, tRegInt Value, tSymbolSize InpSize)
  149. {
  150.   switch (InpSize)
  151.   {
  152.     case eSymbolSize8Bit:
  153.       as_snprintf(pDest, DestSize, "R%u", (unsigned)Value);
  154.       break;
  155.     case eSymbolSize16Bit:
  156.       as_snprintf(pDest, DestSize, "R%uP", (unsigned)(Value >> 1));
  157.       break;
  158.     default:
  159.       as_snprintf(pDest, DestSize, "%d-%u", (int)InpSize, (unsigned)Value);
  160.   }
  161. }
  162.  
  163. /*!------------------------------------------------------------------------
  164.  * \fn     DecodeReg(const tStrComp *pArg, Byte *pValue)
  165.  * \brief  decode 4 bit register, including register aliases
  166.  * \param  pArg potential register argument
  167.  * \param  pValue register # if it's a register
  168.  * \return True if it's a register
  169.  * ------------------------------------------------------------------------ */
  170.  
  171. static Boolean DecodeReg(const tStrComp *pArg, Byte *pValue)
  172. {
  173.   tRegDescr RegDescr;
  174.   tEvalResult EvalResult;
  175.   tRegEvalResult RegEvalResult;
  176.  
  177.   if (DecodeRegCore(pArg->str.p_str, pValue, strlen(pArg->str.p_str)))
  178.     return True;
  179.  
  180.   RegEvalResult = EvalStrRegExpressionAsOperand(pArg, &RegDescr, &EvalResult, eSymbolSize8Bit, True);
  181.   *pValue = RegDescr.Reg;
  182.   return (RegEvalResult == eIsReg);
  183. }
  184.  
  185. /*!------------------------------------------------------------------------
  186.  * \fn     DecodeRReg(const tStrComp *pArg, Byte *pValue)
  187.  * \brief  decode 8 bit register pair, including register aliases
  188.  * \param  pArg potential register argument
  189.  * \param  pValue register # if it's a register
  190.  * \return True if it's a register
  191.  * ------------------------------------------------------------------------ */
  192.  
  193. static Boolean DecodeRReg(const tStrComp *pArg, Byte *pValue)
  194. {
  195.   tRegDescr RegDescr;
  196.   tEvalResult EvalResult;
  197.   tRegEvalResult RegEvalResult;
  198.  
  199.   if (DecodeRRegCore(pArg->str.p_str, pValue))
  200.     return True;
  201.  
  202.   RegEvalResult = EvalStrRegExpressionAsOperand(pArg, &RegDescr, &EvalResult, eSymbolSize16Bit, True);
  203.   *pValue = RegDescr.Reg;
  204.   return (RegEvalResult == eIsReg);
  205. }
  206.  
  207. /*---------------------------------------------------------------------------*/
  208. /* Hilfsdekoder */
  209.  
  210. static void DecodeFixed(Word Code)
  211. {
  212.   CPUVar MinCPU = CPU4004 + (CPUVar)Hi(Code);
  213.  
  214.   if (ChkArgCnt(0, 0)
  215.    && ChkMinCPU(MinCPU))
  216.   {
  217.     BAsmCode[0] = Lo(Code);
  218.     CodeLen = 1;
  219.   }
  220. }
  221.  
  222. static void DecodeOneReg(Word Code)
  223. {
  224.   Byte Erg;
  225.  
  226.   if (!ChkArgCnt(1, 1));
  227.   else if (DecodeReg(&ArgStr[1], &Erg))
  228.   {
  229.     BAsmCode[0] = Lo(Code) + Erg;
  230.     CodeLen = 1;
  231.   }
  232. }
  233.  
  234. static void DecodeOneRReg(Word Code)
  235. {
  236.   Byte Erg;
  237.  
  238.   if (!ChkArgCnt(1, 1));
  239.   else if (DecodeRReg(&ArgStr[1], &Erg))
  240.   {
  241.     BAsmCode[0] = Lo(Code) + Erg;
  242.     CodeLen = 1;
  243.   }
  244. }
  245.  
  246. static void DecodeAccReg(Word Code)
  247. {
  248.   Byte Erg;
  249.  
  250.   if (!ChkArgCnt(1, 2));
  251.   else if ((ArgCnt == 2) && (as_strcasecmp(ArgStr[1].str.p_str, "A"))) WrError(ErrNum_InvAddrMode);
  252.   else if (DecodeReg(&ArgStr[ArgCnt], &Erg))
  253.   {
  254.     BAsmCode[0] = Lo(Code) + Erg;
  255.     CodeLen = 1;
  256.   }
  257. }
  258.  
  259. static void DecodeImm4(Word Code)
  260. {
  261.   Boolean OK;
  262.  
  263.   if (ChkArgCnt(1, 1))
  264.   {
  265.     BAsmCode[0] = EvalStrIntExpression(&ArgStr[1], UInt4, &OK);
  266.     if (OK)
  267.     {
  268.       BAsmCode[0] += Lo(Code);
  269.       CodeLen = 1;
  270.     }
  271.   }
  272. }
  273.  
  274. static void DecodeFullJmp(Word Index)
  275. {
  276.   Word Adr;
  277.   Boolean OK;
  278.  
  279.   if (ChkArgCnt(1, 1))
  280.   {
  281.     Adr = EvalStrIntExpression(&ArgStr[1], UInt12, &OK);
  282.     if (OK)
  283.     {
  284.       BAsmCode[0] = 0x40 + (Index << 4) + Hi(Adr);
  285.       BAsmCode[1] = Lo(Adr);
  286.       CodeLen = 2;
  287.     }
  288.   }
  289. }
  290.  
  291. static void DecodeISZ(Word Index)
  292. {
  293.   Word Adr;
  294.   Boolean OK;
  295.   tSymbolFlags Flags;
  296.   Byte Erg;
  297.   UNUSED(Index);
  298.  
  299.   if (!ChkArgCnt(2, 2));
  300.   else if (DecodeReg(&ArgStr[1], &Erg))
  301.   {
  302.     Adr = EvalStrIntExpressionWithFlags(&ArgStr[2], UInt12, &OK, &Flags);
  303.     if (OK && ChkSamePage(EProgCounter() + 1, Adr, 8, Flags))
  304.     {
  305.       BAsmCode[0] = 0x70 + Erg;
  306.       BAsmCode[1] = Lo(Adr);
  307.       CodeLen = 2;
  308.     }
  309.   }
  310. }
  311.  
  312. static void DecodeJCN(Word Index)
  313. {
  314.   UNUSED(Index);
  315.  
  316.   if (ChkArgCnt(2, 2))
  317.   {
  318.     Boolean OK = True;
  319.     char *pCond;
  320.  
  321.     BAsmCode[0] = 0;
  322.     for (pCond = ArgStr[1].str.p_str; *pCond; pCond++)
  323.       switch (as_toupper(*pCond))
  324.       {
  325.         case 'Z': BAsmCode[0] |= 4; break;
  326.         case 'C': BAsmCode[0] |= 2; break;
  327.         case 'T': BAsmCode[0] |= 1; break;
  328.         case 'N': BAsmCode[0] |= 8; break;
  329.         default: OK = False;
  330.       }
  331.     if (!OK)
  332.       BAsmCode[0] = EvalStrIntExpression(&ArgStr[1], UInt4, &OK);
  333.  
  334.     if (OK)
  335.     {
  336.       Word AdrInt;
  337.       tSymbolFlags Flags;
  338.  
  339.       AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[2], UInt12, &OK, &Flags);
  340.       if (OK)
  341.       {
  342.         if (!mSymbolQuestionable(Flags) && (Hi(EProgCounter() + 2) != Hi(AdrInt))) WrError(ErrNum_JmpDistTooBig);
  343.         else
  344.         {
  345.           BAsmCode[0] |= 0x10;
  346.           BAsmCode[1] = Lo(AdrInt);
  347.           CodeLen = 2;
  348.         }
  349.       }
  350.     }
  351.   }
  352. }
  353.  
  354. static void DecodeFIM(Word Index)
  355. {
  356.   Boolean OK;
  357.   UNUSED(Index);
  358.  
  359.   if (!ChkArgCnt(2, 2));
  360.   else if (DecodeRReg(&ArgStr[1], BAsmCode))
  361.   {
  362.     BAsmCode[1] = EvalStrIntExpression(&ArgStr[2], Int8, &OK);
  363.     if (OK)
  364.     {
  365.       BAsmCode[0] |= 0x20;
  366.       CodeLen = 2;
  367.     }
  368.   }
  369. }
  370.  
  371. static void DecodeDATA_4004(Word Code)
  372. {
  373.   UNUSED(Code);
  374.  
  375.   DecodeDATA(Int8, Int4);
  376. }
  377.  
  378. /*---------------------------------------------------------------------------*/
  379. /* Codetabellenverwaltung */
  380.  
  381. static void AddFixed(const char *NName, Word NCode, CPUVar NMin)
  382. {
  383.   NCode |= ((Word)(NMin - CPU4004)) << 8;
  384.   AddInstTable(InstTable, NName, NCode, DecodeFixed);
  385. }
  386.  
  387. static void AddOneReg(const char *NName, Byte NCode)
  388. {
  389.   AddInstTable(InstTable, NName, NCode, DecodeOneReg);
  390. }
  391.  
  392. static void AddOneRReg(const char *NName, Byte NCode)
  393. {
  394.   AddInstTable(InstTable, NName, NCode, DecodeOneRReg);
  395. }
  396.  
  397. static void AddAccReg(const char *NName, Byte NCode)
  398. {
  399.   AddInstTable(InstTable, NName, NCode, DecodeAccReg);
  400. }
  401.  
  402. static void AddImm4(const char *NName, Byte NCode)
  403. {
  404.   AddInstTable(InstTable, NName, NCode, DecodeImm4);
  405. }
  406.  
  407. static void InitFields(void)
  408. {
  409.   InstTable = CreateInstTable(101);
  410.  
  411.   add_null_pseudo(InstTable);
  412.  
  413.   AddFixed("NOP" , 0x00, CPU4004); AddFixed("WRM" , 0xe0, CPU4004);
  414.   AddFixed("WMP" , 0xe1, CPU4004); AddFixed("WRR" , 0xe2, CPU4004);
  415.   AddFixed("WPM" , 0xe3, CPU4004); AddFixed("WR0" , 0xe4, CPU4004);
  416.   AddFixed("WR1" , 0xe5, CPU4004); AddFixed("WR2" , 0xe6, CPU4004);
  417.   AddFixed("WR3" , 0xe7, CPU4004); AddFixed("SBM" , 0xe8, CPU4004);
  418.   AddFixed("RDM" , 0xe9, CPU4004); AddFixed("RDR" , 0xea, CPU4004);
  419.   AddFixed("ADM" , 0xeb, CPU4004); AddFixed("RD0" , 0xec, CPU4004);
  420.   AddFixed("RD1" , 0xed, CPU4004); AddFixed("RD2" , 0xee, CPU4004);
  421.   AddFixed("RD3" , 0xef, CPU4004); AddFixed("CLB" , 0xf0, CPU4004);
  422.   AddFixed("CLC" , 0xf1, CPU4004); AddFixed("IAC" , 0xf2, CPU4004);
  423.   AddFixed("CMC" , 0xf3, CPU4004); AddFixed("CMA" , 0xf4, CPU4004);
  424.   AddFixed("RAL" , 0xf5, CPU4004); AddFixed("RAR" , 0xf6, CPU4004);
  425.   AddFixed("TCC" , 0xf7, CPU4004); AddFixed("DAC" , 0xf8, CPU4004);
  426.   AddFixed("TCS" , 0xf9, CPU4004); AddFixed("STC" , 0xfa, CPU4004);
  427.   AddFixed("DAA" , 0xfb, CPU4004); AddFixed("KBP" , 0xfc, CPU4004);
  428.   AddFixed("DCL" , 0xfd, CPU4004); AddFixed("AD0" , 0xec, CPU4004);
  429.   AddFixed("AD1" , 0xed, CPU4004); AddFixed("AD2" , 0xee, CPU4004);
  430.   AddFixed("AD3" , 0xef, CPU4004);
  431.  
  432.   AddFixed("HLT" , 0x01, CPU4040); AddFixed("BBS" , 0x02, CPU4040);
  433.   AddFixed("LCR" , 0x03, CPU4040); AddFixed("OR4" , 0x04, CPU4040);
  434.   AddFixed("OR5" , 0x05, CPU4040); AddFixed("AN6" , 0x06, CPU4040);
  435.   AddFixed("AN7" , 0x07, CPU4040); AddFixed("DB0" , 0x08, CPU4040);
  436.   AddFixed("DB1" , 0x09, CPU4040); AddFixed("SB0" , 0x0a, CPU4040);
  437.   AddFixed("SB1" , 0x0b, CPU4040); AddFixed("EIN" , 0x0c, CPU4040);
  438.   AddFixed("DIN" , 0x0d, CPU4040); AddFixed("RPM" , 0x0e, CPU4040);
  439.  
  440.   AddOneReg("INC" , 0x60);
  441.  
  442.   AddOneRReg("SRC" , 0x21);
  443.   AddOneRReg("FIN" , 0x30);
  444.   AddOneRReg("JIN" , 0x31);
  445.  
  446.   AddAccReg("ADD" , 0x80); AddAccReg("SUB" , 0x90);
  447.   AddAccReg("LD"  , 0xa0); AddAccReg("XCH" , 0xb0);
  448.  
  449.   AddImm4("BBL" , 0xc0); AddImm4("LDM" , 0xd0);
  450.  
  451.   AddInstTable(InstTable,"JCN", 0, DecodeJCN);
  452.   AddInstTable(InstTable,"JCM", 0, DecodeJCN);
  453.   AddInstTable(InstTable,"JUN", 0, DecodeFullJmp);
  454.   AddInstTable(InstTable,"JMS", 1, DecodeFullJmp);
  455.   AddInstTable(InstTable,"ISZ", 0, DecodeISZ);
  456.   AddInstTable(InstTable,"FIM", 0, DecodeFIM);
  457.  
  458.   AddInstTable(InstTable, "DS", 0, DecodeRES);
  459.   AddInstTable(InstTable, "DATA", 0, DecodeDATA_4004);
  460.   AddInstTable(InstTable, "REG", 0, CodeREG);
  461. }
  462.  
  463. static void DeinitFields(void)
  464. {
  465.   DestroyInstTable(InstTable);
  466. }
  467.  
  468. /*---------------------------------------------------------------------------*/
  469. /* Callbacks */
  470.  
  471. /*!------------------------------------------------------------------------
  472.  * \fn     InternSymbol_4004
  473.  * \brief  Built-in symbols for 4004
  474.  * \param  pArg source argument
  475.  * \param  pResult buffer for result
  476.  * ------------------------------------------------------------------------ */
  477.  
  478. static void InternSymbol_4004(char *pArg, TempResult *pResult)
  479. {
  480.   Byte RegValue;
  481.  
  482.   if (DecodeRegCore(pArg, &RegValue, strlen(pArg)))
  483.   {
  484.     pResult->Typ = TempReg;
  485.     pResult->DataSize = eSymbolSize8Bit;
  486.     pResult->Contents.RegDescr.Reg = RegValue;
  487.     pResult->Contents.RegDescr.Dissect = DissectReg_4004;
  488.     pResult->Contents.RegDescr.compare = NULL;
  489.   }
  490.   else if (DecodeRRegCore(pArg, &RegValue))
  491.   {
  492.     pResult->Typ = TempReg;
  493.     pResult->DataSize = eSymbolSize16Bit;
  494.     pResult->Contents.RegDescr.Reg = RegValue;
  495.     pResult->Contents.RegDescr.Dissect = DissectReg_4004;
  496.     pResult->Contents.RegDescr.compare = NULL;
  497.   }
  498. }
  499.  
  500. static void MakeCode_4004(void)
  501. {
  502.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  503.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  504. }
  505.  
  506. static Boolean IsDef_4004(void)
  507. {
  508.   return Memo("REG");
  509. }
  510.  
  511. static void SwitchFrom_4004(void)
  512. {
  513.   DeinitFields();
  514. }
  515.  
  516. static void SwitchTo_4004(void)
  517. {
  518.   const TFamilyDescr *FoundDescr;
  519.  
  520.   FoundDescr = FindFamilyByName("4004/4040");
  521.  
  522.   TurnWords = False;
  523.   SetIntConstMode(eIntConstModeIntel);
  524.  
  525.   PCSymbol = "$";
  526.   HeaderID = FoundDescr->Id;
  527.   NOPCode = 0x00;
  528.   DivideChars = ",";
  529.   HasAttrs = False;
  530.  
  531.   ValidSegs = (1 << SegCode) | (1 << SegData);
  532.   Grans[SegCode ] = 1; ListGrans[SegCode ] = 1; SegInits[SegCode ] = 0;
  533.   SegLimits[SegCode] = 0xfff;
  534.   Grans[SegData ] = 1; ListGrans[SegData ] = 1; SegInits[SegData ] = 0;
  535.   SegLimits[SegData] = 0xff;
  536.  
  537.   MakeCode = MakeCode_4004;
  538.   IsDef = IsDef_4004;
  539.   InternSymbol = InternSymbol_4004;
  540.   DissectReg = DissectReg_4004;
  541.   SwitchFrom = SwitchFrom_4004;
  542.  
  543.   InitFields();
  544. }
  545.  
  546. /*---------------------------------------------------------------------------*/
  547. /* Initialisierung */
  548.  
  549. void code4004_init(void)
  550. {
  551.   CPU4004 = AddCPU("4004", SwitchTo_4004);
  552.   CPU4040 = AddCPU("4040", SwitchTo_4004);
  553. }
  554.