Subversion Repositories pentevo

Rev

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

  1. /* code8008.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator Intel 8008                                                  */
  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 "headids.h"
  22. #include "codevars.h"
  23. #include "codepseudo.h"
  24. #include "intpseudo.h"
  25. #include "errmsg.h"
  26.  
  27. #include "code8008.h"
  28.  
  29. /*---------------------------------------------------------------------------*/
  30. /* Types */
  31.  
  32. typedef enum
  33. {
  34.   eModNone = 0,
  35.   eModReg8 = 1,
  36.   eModIHL = 2,
  37.   eModImm = 3,
  38.   eModReg16 = 4
  39. } tAdrMode;
  40.  
  41. #define AccReg 0
  42.  
  43. #define MModReg8 (1 << eModReg8)
  44. #define MModReg16 (1 << eModReg16)
  45. #define MModImm (1 << eModImm)
  46. #define MModIHL (1 << eModIHL)
  47. #define MModReg16 (1 << eModReg16)
  48.  
  49. typedef struct
  50. {
  51.   tAdrMode Mode;
  52.   Byte Val;
  53. } tAdrVals;
  54.  
  55. /*---------------------------------------------------------------------------*/
  56. /* Variablen */
  57.  
  58. static CPUVar CPU8008, CPU8008New;
  59.  
  60. static const char RegNames[] = "ABCDEHLM";
  61.  
  62. /*---------------------------------------------------------------------------*/
  63. /* Parser */
  64.  
  65. static Boolean DecodeReg(char *Asc, tZ80Syntax Syntax, Byte *pErg)
  66. {
  67.   const char *p;
  68.  
  69.   if (strlen(Asc) != 1)
  70.     return False;
  71.  
  72.   p = strchr(RegNames, as_toupper(*Asc));
  73.   if (!p)
  74.     return False;
  75.  
  76.   *pErg = p - RegNames;
  77.   if ((!(Syntax & eSyntax808x)) && (*pErg == 7))
  78.     return False;
  79.   return True;
  80. }
  81.  
  82. static Boolean DecodeReg16(char *Asc, Byte *pErg)
  83. {
  84.   if (strlen(Asc) != 2)
  85.     return False;
  86.  
  87.   for (*pErg = 1; *pErg < 7; *pErg += 2)
  88.     if ((as_toupper(Asc[0]) == RegNames[*pErg])
  89.      && (as_toupper(Asc[1]) == RegNames[*pErg + 1]))
  90.     {
  91.       *pErg /= 2;
  92.       return True;
  93.     }
  94.  
  95.   return False;
  96. }
  97.  
  98. /*!------------------------------------------------------------------------
  99.  * \fn     DecodeCondition_Z80(const char *pAsc, Byte *pResult)
  100.  * \brief  decode Z80-style conditions for JP CALL RET
  101.  * \param  pAsc source argument
  102.  * \param  dest buffer
  103.  * \return True if success
  104.  * ------------------------------------------------------------------------ */
  105.  
  106. static const char Conditions[][4] =
  107. {
  108.   "NC", "NZ", "P", "PO", "C", "Z", "M", "PE"
  109. };
  110.  
  111. static Boolean DecodeCondition_Z80(const char *pAsc, Byte *pResult)
  112. {
  113.   for (*pResult = 0; *pResult < sizeof(Conditions) / sizeof(*Conditions); (*pResult)++)
  114.     if (!as_strcasecmp(pAsc, Conditions[*pResult]))
  115.     {
  116.       *pResult = *pResult << 3;
  117.       return True;
  118.     }
  119.   return False;
  120. }
  121.  
  122. /*!------------------------------------------------------------------------
  123.  * \fn     DecodeAdr_Z80(const tStrComp *pArg, Word Mask, tAdrVals *pVals)
  124.  * \brief  decode address expression in Z80 style syntax
  125.  * \param  pArg source argument
  126.  * \param  Mask bit mask of allowed addressig modes
  127.  * \param  pVals dest buffer
  128.  * \return resulting addressing mode
  129.  * ------------------------------------------------------------------------ */
  130.  
  131. static void ResetAdrVals(tAdrVals *pVals)
  132. {
  133.   pVals->Mode = eModNone;
  134.   pVals->Val = 0;
  135. }
  136.  
  137. static tAdrMode DecodeAdr_Z80(const tStrComp *pArg, Word Mask, tAdrVals *pVals)
  138. {
  139.   Boolean OK;
  140.  
  141.   ResetAdrVals(pVals);
  142.  
  143.   if (DecodeReg(pArg->str.p_str, eSyntaxZ80, &pVals->Val))
  144.   {
  145.     pVals->Mode = eModReg8;
  146.     goto AdrFound;
  147.   }
  148.  
  149.   if (DecodeReg16(pArg->str.p_str, &pVals->Val))
  150.   {
  151.     pVals->Mode = eModReg16;
  152.     goto AdrFound;
  153.   }
  154.  
  155.   if (!as_strcasecmp(pArg->str.p_str, "(HL)"))
  156.   {
  157.     pVals->Mode = eModIHL;
  158.     goto AdrFound;
  159.   }
  160.  
  161.   pVals->Val = EvalStrIntExpression(pArg, Int8, &OK);
  162.   if (OK)
  163.     pVals->Mode = eModImm;
  164.  
  165. AdrFound:
  166.  
  167.   if ((pVals->Mode != eModNone) && (!(Mask & (1 << pVals->Mode))))
  168.   {
  169.     WrStrErrorPos(ErrNum_InvAddrMode, pArg);
  170.     ResetAdrVals(pVals);
  171.   }
  172.   return pVals->Mode;
  173. }
  174.  
  175. /*!------------------------------------------------------------------------
  176.  * \fn     CheckAcc_Z80(const tStrComp *pArg)
  177.  * \brief  check whether (optional first) argument is accumulator
  178.  * \param  pArg source argument
  179.  * \return True if it is
  180.  * ------------------------------------------------------------------------ */
  181.  
  182. static Boolean CheckAcc_Z80(const tStrComp *pArg)
  183. {
  184.   tAdrVals AdrVals;
  185.  
  186.   switch (DecodeAdr_Z80(pArg, MModReg8, &AdrVals))
  187.   {
  188.     case eModReg8:
  189.       if (AdrVals.Val != AccReg)
  190.       {
  191.         WrStrErrorPos(ErrNum_InvReg, pArg);
  192.         return False;
  193.       }
  194.       break;
  195.     default:
  196.       return False;
  197.   }
  198.   return True;
  199. }
  200.  
  201. /*---------------------------------------------------------------------------*/
  202. /* Instruction Decoders */
  203.  
  204. /*!------------------------------------------------------------------------
  205.  * \fn     DecodeFixed(Word Code)
  206.  * \brief  handle instructions without argument
  207.  * \param  Word instruction code & syntax flag
  208.  * ------------------------------------------------------------------------ */
  209.  
  210. static void DecodeFixed(Word Code)
  211. {
  212.   if (ChkArgCnt(0, 0)
  213.    && ChkZ80Syntax((tZ80Syntax)Hi(Code)))
  214.   {
  215.     BAsmCode[0] = Lo(Code);
  216.     CodeLen = 1;
  217.   }
  218. }
  219.  
  220. /*!------------------------------------------------------------------------
  221.  * \fn     DecodeFixed(Word Code)
  222.  * \brief  handle instructions with one (8 bit) immediate argument
  223.  * \param  Index machine code
  224.  * ------------------------------------------------------------------------ */
  225.  
  226. static void DecodeImm(Word Code)
  227. {
  228.   if (ChkArgCnt(1, 1)
  229.    && ChkZ80Syntax((tZ80Syntax)Hi(Code)))
  230.   {
  231.     Boolean OK;
  232.  
  233.     BAsmCode[1] = EvalStrIntExpression(&ArgStr[1], Int8, &OK);
  234.     if (OK)
  235.     {
  236.       BAsmCode[0] = Lo(Code);
  237.       CodeLen = 2;
  238.     }
  239.   }
  240. }
  241.  
  242. /*!------------------------------------------------------------------------
  243.  * \fn     DecodeJmp(Word Index)
  244.  * \brief  decode jump/call instructions taking one address argument
  245.  * \param  Index machine code
  246.  * ------------------------------------------------------------------------ */
  247.  
  248. static void DecodeJmpCore(Byte Code)
  249. {
  250.   tEvalResult EvalResult;
  251.   Word AdrWord;
  252.  
  253.   AdrWord = EvalStrIntExpressionWithResult(&ArgStr[ArgCnt], UInt14, &EvalResult);
  254.   if (EvalResult.OK)
  255.   {
  256.     BAsmCode[0] = Code;
  257.     BAsmCode[1] = Lo(AdrWord);
  258.     BAsmCode[2] = Hi(AdrWord) & 0x3f;
  259.     CodeLen = 3;
  260.     ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  261.   }
  262. }
  263.  
  264. static void DecodeJmp(Word Index)
  265. {
  266.   if (ChkArgCnt(1, 1)
  267.    && ChkZ80Syntax(eSyntax808x))
  268.     DecodeJmpCore(Lo(Index));
  269. }
  270.  
  271. /*!------------------------------------------------------------------------
  272.  * \fn     DecodeJP(Word Code)
  273.  * \brief  decode JP instruction
  274.  * ------------------------------------------------------------------------ */
  275.  
  276. static void DecodeJP(Word Code)
  277. {
  278.   UNUSED(Code);
  279.  
  280.   /* one argument, new 8008 insn set & not exclusively Z80: -> jump on positive or parity even */
  281.  
  282.   if ((CurrZ80Syntax != eSyntaxZ80) && (ArgCnt == 1))
  283.   {
  284.     DecodeJmp((MomCPU == CPU8008New) ? 0x50 : 0x78);
  285.     return;
  286.   }
  287.  
  288.   /* for all other stuff, Z80 syntax must be enabled */
  289.  
  290.   if (!ChkArgCnt(1, 2)
  291.    || !ChkZ80Syntax(eSyntaxZ80))
  292.     return;
  293.  
  294.   if (ArgCnt == 2)
  295.   {
  296.     Byte Cond;
  297.  
  298.     if (DecodeCondition_Z80(ArgStr[1].str.p_str, &Cond))
  299.       DecodeJmpCore(0x40 | Cond);
  300.   }
  301.   else
  302.     DecodeJmpCore(0x44);
  303. }
  304.  
  305. /*!------------------------------------------------------------------------
  306.  * \fn     DecodeJ(Word Code)
  307.  * \brief  decode J instruction
  308.  * ------------------------------------------------------------------------ */
  309.  
  310. static void DecodeJ(Word Code)
  311. {
  312.   UNUSED(Code);
  313.  
  314.   if (!ChkZ80Syntax(eSyntaxZ80))
  315.     return;
  316.  
  317.   switch (ArgCnt)
  318.   {
  319.     /* if two arguments, first one is (Z80) condition */
  320.  
  321.     case 2:
  322.     {
  323.       Byte Condition;
  324.  
  325.       if (DecodeCondition_Z80(ArgStr[1].str.p_str, &Condition))
  326.         DecodeJmpCore(0x40 | Condition);
  327.       break;
  328.     }
  329.  
  330.     /* if one argument, it's unconditional JP */
  331.  
  332.     case 1:
  333.      
  334.       DecodeJmpCore(0x44);
  335.       break;
  336.  
  337.     default:
  338.       (void)ChkArgCnt(1, 2);
  339.       return;
  340.   }
  341. }
  342.  
  343. /*!------------------------------------------------------------------------
  344.  * \fn     DecodeCALL(Word Code)
  345.  * \brief  decode CALL instruction
  346.  * ------------------------------------------------------------------------ */
  347.  
  348. static void DecodeCALL(Word Code)
  349. {
  350.   UNUSED(Code);
  351.  
  352.   /* single-arg CALL is only NOT allowed on old 8008 in pure  808x mode : */
  353.  
  354.   if ((CurrZ80Syntax != eSyntaxZ80) && (ArgCnt == 1) && (MomCPU == CPU8008New))
  355.   {
  356.     DecodeJmp(0x46);
  357.     return;
  358.   }
  359.  
  360.   if (!ChkArgCnt(1, 2)
  361.    || !ChkZ80Syntax(eSyntaxZ80))
  362.     return;
  363.  
  364.   if (ArgCnt == 2)
  365.   {
  366.     Byte Cond;
  367.  
  368.     if (DecodeCondition_Z80(ArgStr[1].str.p_str, &Cond))
  369.       DecodeJmpCore(0x42 | Cond);
  370.   }
  371.   else
  372.     DecodeJmpCore(0x46);
  373. }
  374.  
  375. /*!------------------------------------------------------------------------
  376.  * \fn     DecodeRET(Word Code)
  377.  * \brief  handle RET instruction
  378.  * ------------------------------------------------------------------------ */
  379.  
  380. static void DecodeRET(Word Code)
  381. {
  382.   UNUSED(Code);
  383.  
  384.   if (ChkArgCnt(0, (CurrZ80Syntax != eSyntax808x) ? 1 : 0))
  385.   {
  386.     if (1 == ArgCnt)
  387.     {
  388.       Byte Cond;
  389.  
  390.       if (DecodeCondition_Z80(ArgStr[1].str.p_str, &Cond))
  391.         BAsmCode[CodeLen++] = 0x03 | Cond;
  392.     }
  393.     else
  394.       BAsmCode[CodeLen++] = 0x07;
  395.   }
  396. }
  397.  
  398. /*!------------------------------------------------------------------------
  399.  * \fn     DecodeRST(Word Index)
  400.  * \brief  handle RST instruction
  401.  * ------------------------------------------------------------------------ */
  402.  
  403. static void DecodeRST(Word Index)
  404. {
  405.   UNUSED(Index);
  406.  
  407.   if (ChkArgCnt(1, 1))
  408.   {
  409.     Word AdrWord;
  410.     tEvalResult EvalResult;
  411.  
  412.     AdrWord = EvalStrIntExpressionWithResult(&ArgStr[1], UInt14, &EvalResult);
  413.     if (mFirstPassUnknown(EvalResult.Flags)) AdrWord &= 0x38;
  414.     if (EvalResult.OK)
  415.     {
  416.       if (ChkRange(AdrWord, 0, 0x38))
  417.       {
  418.         if (AdrWord < 8)
  419.         {
  420.           BAsmCode[0] = 0x05 | (AdrWord << 3);
  421.           CodeLen = 1;
  422.           ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  423.         }
  424.         else if ((AdrWord & 7) != 0) WrError(ErrNum_NotAligned);
  425.         else
  426.         {
  427.           BAsmCode[0] = AdrWord + 0x05;
  428.           CodeLen = 1;
  429.           ChkSpace(SegCode, EvalResult.AddrSpaceMask);
  430.         }
  431.       }
  432.     }
  433.   }
  434. }
  435.  
  436. /*!------------------------------------------------------------------------
  437.  * \fn     DecodeINP_OUT(Word Index)
  438.  * \brief  Handle IN(P)/OUT Instructions
  439.  * \param  IsIN True if IN
  440.  * ------------------------------------------------------------------------ */
  441.  
  442. static void DecodeINP_OUT(Word IsIN)
  443. {
  444.   tEvalResult EvalResult;
  445.   Byte Addr, AddrArgIdx;
  446.  
  447.   if (Memo("INP") && !ChkZ80Syntax(eSyntax808x))
  448.     return;
  449.   if (Memo("IN") && (MomCPU == CPU8008) && !ChkZ80Syntax(eSyntaxZ80))
  450.     return;
  451.  
  452.   if (!ChkArgCnt((CurrZ80Syntax & eSyntax808x) ? 1 : 2, (CurrZ80Syntax & eSyntaxZ80) ? 2 : 1))
  453.     return;
  454.  
  455.   if ((ArgCnt == 2) /* Z80-style with A */
  456.    && !CheckAcc_Z80(&ArgStr[IsIN ? 1 : 2]))
  457.     return;
  458.  
  459.   AddrArgIdx = ((ArgCnt == 2) && IsIN) ? 2 : 1;
  460.   if (IsIN)
  461.     Addr = EvalStrIntExpressionWithResult(&ArgStr[AddrArgIdx], UInt3, &EvalResult);
  462.   else
  463.   {
  464.     Addr = EvalStrIntExpressionWithResult(&ArgStr[AddrArgIdx], UInt5, &EvalResult);
  465.     if (mFirstPassUnknown(EvalResult.Flags))
  466.       Addr |= 0x08;
  467.     if ((EvalResult.OK) && (Addr < 8))
  468.     {
  469.       WrStrErrorPos(ErrNum_UnderRange, &ArgStr[AddrArgIdx]);
  470.       EvalResult.OK = False;
  471.     }
  472.   }
  473.  
  474.   if (EvalResult.OK)
  475.   {
  476.     BAsmCode[0] = 0x41 | (Addr << 1);
  477.     CodeLen = 1;
  478.     ChkSpace(SegIO, EvalResult.AddrSpaceMask);
  479.   }
  480. }
  481.  
  482. /*!------------------------------------------------------------------------
  483.  * \fn     DecodeMOV(Word Index)
  484.  * \brief  handle MOV instruction
  485.  * ------------------------------------------------------------------------ */
  486.  
  487. static void DecodeMOV(Word Index)
  488. {
  489.   Byte SReg, DReg;
  490.  
  491.   UNUSED(Index);
  492.  
  493.   if (!ChkArgCnt(2, 2));
  494.   else if (!ChkZ80Syntax(eSyntax808x));
  495.   else if (!DecodeReg(ArgStr[1].str.p_str, eSyntax808x, &DReg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  496.   else if (!DecodeReg(ArgStr[2].str.p_str, eSyntax808x, &SReg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  497.   else if ((DReg == 7) && (SReg == 7)) WrError(ErrNum_InvRegPair); /* MOV M,M not allowed - asame opcode as HLT */
  498.   else
  499.   {
  500.     BAsmCode[0] = 0xc0 | (DReg << 3) | SReg;
  501.     CodeLen = 1;
  502.   }
  503. }
  504.  
  505. /*!------------------------------------------------------------------------
  506.  * \fn     DecodeMVI(Word Index)
  507.  * \brief  handle MVI instruction
  508.  * ------------------------------------------------------------------------ */
  509.  
  510. static void DecodeMVI(Word Index)
  511. {
  512.   Byte DReg;
  513.  
  514.   UNUSED(Index);
  515.  
  516.   if (!ChkArgCnt(2, 2));
  517.   else if (!ChkZ80Syntax(eSyntax808x));
  518.   else if (!DecodeReg(ArgStr[1].str.p_str, eSyntax808x, &DReg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  519.   else
  520.   {
  521.     Boolean OK;
  522.  
  523.     BAsmCode[1] = EvalStrIntExpression(&ArgStr[2], Int8, &OK);
  524.     if (OK)
  525.     {
  526.       BAsmCode[0] = 0x06 | (DReg << 3);
  527.       CodeLen = 2;
  528.     }
  529.   }
  530. }
  531.  
  532. /*!------------------------------------------------------------------------
  533.  * \fn     DecodeLXI(Word Index)
  534.  * \brief  handle (pseudo) LXI instruction
  535.  * ------------------------------------------------------------------------ */
  536.  
  537. static void BuildLXI(Byte DReg, Word Val)
  538. {
  539.   BAsmCode[2] = 0x06 | ((DReg + 1) << 3);
  540.   BAsmCode[3] = Lo(Val);
  541.   BAsmCode[0] = 0x06 | (DReg << 3);
  542.   BAsmCode[1] = Hi(Val);
  543.   CodeLen = 4;
  544. }
  545.  
  546. static void DecodeLXI(Word Index)
  547. {
  548.   Byte DReg;
  549.  
  550.   UNUSED(Index);
  551.  
  552.   if (!ChkArgCnt(2, 2));
  553.   else if (!ChkZ80Syntax(eSyntax808x));
  554.   else if (!DecodeReg(ArgStr[1].str.p_str, eSyntax808x, &DReg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  555.   else if ((DReg != 1) && (DReg != 3) && (DReg != 5)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  556.   else
  557.   {
  558.     Boolean OK;
  559.     Word Val;
  560.  
  561.     Val = EvalStrIntExpression(&ArgStr[2], Int16, &OK);
  562.     if (OK)
  563.       BuildLXI(DReg, Val);
  564.   }
  565. }
  566.  
  567. /*!------------------------------------------------------------------------
  568.  * \fn     DecodeLD(Word Index)
  569.  * \brief  handle LD instruction
  570.  * ------------------------------------------------------------------------ */
  571.  
  572. static void DecodeLD(Word Index)
  573. {
  574.   UNUSED(Index);
  575.   if (ChkArgCnt(2, 2)
  576.    && ChkZ80Syntax(eSyntaxZ80))
  577.   {
  578.     tAdrVals DestAdrVals, SrcAdrVals;
  579.  
  580.     switch (DecodeAdr_Z80(&ArgStr[1], MModReg8 | MModReg16 | MModIHL, &DestAdrVals))
  581.     {
  582.       case eModReg8:
  583.         switch (DecodeAdr_Z80(&ArgStr[2], MModReg8 | MModReg16 | MModIHL | MModImm, &SrcAdrVals))
  584.         {
  585.           case eModReg8:
  586.             BAsmCode[CodeLen++] = 0xc0 | (DestAdrVals.Val << 3) | SrcAdrVals.Val;
  587.             break;
  588.           case eModIHL:
  589.             BAsmCode[CodeLen++] = 0xc7 | (DestAdrVals.Val << 3);
  590.             break;
  591.           case eModImm:
  592.             BAsmCode[CodeLen++] = 0x06 | (DestAdrVals.Val << 3);
  593.             BAsmCode[CodeLen++] = SrcAdrVals.Val;
  594.             break;
  595.           default:
  596.             break;
  597.         }
  598.         break;
  599.       case eModReg16:
  600.       {
  601.         Boolean OK;
  602.         Word Arg = EvalStrIntExpression(&ArgStr[2], Int16, &OK);
  603.  
  604.         if (OK)
  605.           BuildLXI((DestAdrVals.Val << 1) + 1, Arg);
  606.         break;
  607.       }
  608.       case eModIHL:
  609.         switch (DecodeAdr_Z80(&ArgStr[2], MModReg8 | MModImm, &SrcAdrVals))
  610.         {
  611.           case eModReg8:
  612.             BAsmCode[CodeLen++] = 0xf8 | SrcAdrVals.Val;
  613.             break;
  614.           case eModImm:
  615.             BAsmCode[CodeLen++] = 0x3e;
  616.             BAsmCode[CodeLen++] = SrcAdrVals.Val;
  617.             break;
  618.           default:
  619.             break;
  620.         }
  621.         break;
  622.       default:
  623.         break;
  624.     }
  625.   }
  626. }
  627.  
  628. /*!------------------------------------------------------------------------
  629.  * \fn     DecodeADD(Word Code)
  630.  * \brief  handle ADD instruction
  631.  * \param  Code machine code
  632.  * ------------------------------------------------------------------------ */
  633.  
  634. static void DecodeADD(Word Code)
  635. {
  636.   int MinArgCnt = (CurrZ80Syntax & eSyntax808x) ? ((MomCPU == CPU8008New) ? 1 : 0) : 2,
  637.       MaxArgCnt = (CurrZ80Syntax & eSyntaxZ80) ? 2 : ((MomCPU == CPU8008New) ? 1 : 0);
  638.  
  639.   if (!ChkArgCnt(MinArgCnt, MaxArgCnt))
  640.     return;
  641.  
  642.   switch (ArgCnt)
  643.   {
  644.     case 0: /* 8008 old style - src is implicit D, dst is implicitly ACC */
  645.       BAsmCode[CodeLen++] = Code | 0x03;
  646.       break;
  647.     case 1: /* 8008 (new) style - 8 bit register src only, dst is implicitly ACC */
  648.       if (MomCPU == CPU8008) (void)ChkArgCnt(0, 0);
  649.       else
  650.       {
  651.         Byte Reg;
  652.  
  653.         if (!DecodeReg(ArgStr[1].str.p_str, eSyntax808x, &Reg)) WrStrErrorPos(ErrNum_InvRegName, &ArgStr[1]);
  654.           else
  655.         BAsmCode[CodeLen++] = Code | Reg;
  656.       }
  657.       break;
  658.     case 2: /* Z80 style - dst must be A and is first arg */
  659.     {
  660.       tAdrVals SrcAdrVals;
  661.  
  662.       if (!CheckAcc_Z80(&ArgStr[1]))
  663.         return;
  664.       switch (DecodeAdr_Z80(&ArgStr[2], MModReg8 | MModIHL | MModImm, &SrcAdrVals))
  665.       {
  666.         case eModReg8:
  667.           BAsmCode[CodeLen++] = Code | SrcAdrVals.Val;
  668.           break;
  669.         case eModIHL:
  670.           BAsmCode[CodeLen++] = Code | 0x07;
  671.           break;
  672.         case eModImm:
  673.           BAsmCode[CodeLen++] = 0x04;
  674.           BAsmCode[CodeLen++] = SrcAdrVals.Val;
  675.           break;
  676.         default:
  677.           break;
  678.       }
  679.     }
  680.   }
  681. }
  682.  
  683. /*!------------------------------------------------------------------------
  684.  * \fn     DecodeADC(Word Code)
  685.  * \brief  handle ADC instruction
  686.  * \param  Code machine code
  687.  * ------------------------------------------------------------------------ */
  688.  
  689. static void DecodeADC(Word Code)
  690. {
  691.   int MinArgCnt = (CurrZ80Syntax & eSyntax808x) ? ((MomCPU == CPU8008New) ? 1 : 0) : 2,
  692.       MaxArgCnt = (CurrZ80Syntax & eSyntaxZ80) ? 2 : ((MomCPU == CPU8008New) ? 1 : 0);
  693.  
  694.   if (!ChkArgCnt(MinArgCnt, MaxArgCnt))
  695.     return;
  696.  
  697.   switch (ArgCnt)
  698.   {
  699.     case 0: /* 8008 add(!) old style - src is implicit C, dst is implicitly ACC */
  700.       BAsmCode[CodeLen++] = 0x82;
  701.       break;
  702.     case 1: /* 8008 (new) style - 8 bit register src only, dst is implicitly ACC */
  703.     {
  704.       Byte Reg;
  705.  
  706.       if (!DecodeReg(ArgStr[1].str.p_str, eSyntax808x, &Reg)) WrStrErrorPos(ErrNum_InvRegName, &ArgStr[1]);
  707.         else
  708.       BAsmCode[CodeLen++] = Code | Reg;
  709.       break;
  710.     }
  711.     case 2: /* Z80 style - dst must be A and is first arg */
  712.     {
  713.       tAdrVals SrcAdrVals;
  714.  
  715.       if (!CheckAcc_Z80(&ArgStr[1]))
  716.         return;
  717.       switch (DecodeAdr_Z80(&ArgStr[2], MModReg8 | MModIHL | MModImm, &SrcAdrVals))
  718.       {
  719.         case eModReg8:
  720.           BAsmCode[CodeLen++] = Code | SrcAdrVals.Val;
  721.           break;
  722.         case eModIHL:
  723.           BAsmCode[CodeLen++] = Code | 0x07;
  724.           break;
  725.         case eModImm:
  726.           BAsmCode[CodeLen++] = 0x0c;
  727.           BAsmCode[CodeLen++] = SrcAdrVals.Val;
  728.           break;
  729.         default:
  730.           break;
  731.       }
  732.       break;
  733.     }
  734.   }
  735. }
  736.  
  737. /*!------------------------------------------------------------------------
  738.  * \fn     DecodeSUB(Word Code)
  739.  * \brief  handle SUB instruction
  740.  * \param  Code machine code
  741.  * ------------------------------------------------------------------------ */
  742.  
  743. static void DecodeSUB(Word Code)
  744. {
  745.   Byte Reg;
  746.   int MinArgCnt, MaxArgCnt;
  747.   tAdrVals SrcAdrVals;
  748.  
  749.   if (CurrZ80Syntax & eSyntaxZ80)
  750.     MaxArgCnt = 2;
  751.   else
  752.     MaxArgCnt = (MomCPU == CPU8008New) ? 1 : 0;
  753.  
  754.   /* dest operand is always A and also optional for Z80 mode, so min arg cnt is
  755.      also 1 for pure Z80 mode: */
  756.  
  757.   if ((CurrZ80Syntax & eSyntax808x) && (MomCPU == CPU8008))
  758.     MinArgCnt = 0;
  759.   else
  760.     MinArgCnt = 1;
  761.   if (!ChkArgCnt(MinArgCnt, MaxArgCnt))
  762.     return;
  763.  
  764.   /* For Z80, optionally allow A as dest */
  765.  
  766.   if ((ArgCnt == 2) && !CheckAcc_Z80(&ArgStr[1]))
  767.     return;
  768.  
  769.   /* no arg (SUB -> B register) */
  770.  
  771.   if (!ArgCnt)
  772.   {
  773.     BAsmCode[CodeLen++] = Code | 0x01;
  774.     return;
  775.   }
  776.  
  777.   /* 8 bit register as source
  778.      808x style incl. M, Z80 style excl. (HL) */
  779.  
  780.   if (DecodeReg(ArgStr[ArgCnt].str.p_str, CurrZ80Syntax, &Reg)) /* 808x style incl. M, Z80 style excl. (HL) */
  781.   {
  782.     BAsmCode[CodeLen++] = Code | Reg;
  783.     return;
  784.   }
  785.  
  786.   /* rest is Z80 style ( (HL) or immediate) */
  787.  
  788.   if (!(CurrZ80Syntax & eSyntaxZ80))
  789.   {
  790.     WrError(ErrNum_InvAddrMode);
  791.     return;
  792.   }
  793.  
  794.   switch (DecodeAdr_Z80(&ArgStr[ArgCnt], MModImm | MModIHL, &SrcAdrVals))
  795.   {
  796.     case eModIHL:
  797.       BAsmCode[CodeLen++] = Code | 0x07;
  798.       break;
  799.     case eModImm:
  800.       BAsmCode[CodeLen++] = 0x14;
  801.       BAsmCode[CodeLen++] = SrcAdrVals.Val;
  802.       break;
  803.     default:
  804.       break;
  805.   }
  806. }
  807.  
  808. /*!------------------------------------------------------------------------
  809.  * \fn     DecodeSBC(Word Code)
  810.  * \brief  handle SBC instruction
  811.  * \param  Code machine code
  812.  * ------------------------------------------------------------------------ */
  813.  
  814. static void DecodeSBC(Word Code)
  815. {
  816.   tAdrVals SrcAdrVals;
  817.  
  818.   /* special case of 8008 SBC: */
  819.  
  820.   if ((CurrZ80Syntax & eSyntax808x) && (ArgCnt == 0) && (MomCPU == CPU8008))
  821.   {
  822.     BAsmCode[CodeLen++] = Code | 0x02;
  823.     return;
  824.   }
  825.  
  826.   /* everything else is Z80-specific: */
  827.  
  828.   if (!ChkArgCnt(1, 2) || !ChkZ80Syntax(eSyntaxZ80))
  829.     return;
  830.  
  831.   /* dest operand is always A and also optional, since 8008 can only SUB from A: */
  832.  
  833.   if ((ArgCnt == 2) && !CheckAcc_Z80(&ArgStr[1]))
  834.     return;
  835.  
  836.   switch (DecodeAdr_Z80(&ArgStr[ArgCnt], MModImm | MModReg8 | MModIHL, &SrcAdrVals))
  837.   {
  838.     case eModReg8:
  839.       BAsmCode[CodeLen++] = Code | SrcAdrVals.Val;
  840.       break;
  841.     case eModIHL:
  842.       BAsmCode[CodeLen++] = Code | 0x07;
  843.       break;
  844.     case eModImm:
  845.       BAsmCode[CodeLen++] = 0x1c;
  846.       BAsmCode[CodeLen++] = SrcAdrVals.Val;
  847.       break;
  848.     default:
  849.       break;
  850.   }
  851. }
  852.  
  853. /*!------------------------------------------------------------------------
  854.  * \fn     DecodeALU8_Z80(Word Code)
  855.  * \brief  arithmetic instructions only available in Z80 style
  856.  * \param  Code machine code
  857.  * ------------------------------------------------------------------------ */
  858.  
  859. static void DecodeALU8_Z80(Word Code)
  860. {
  861.   tAdrVals SrcAdrVals;
  862.  
  863.   if (!ChkZ80Syntax(eSyntaxZ80)
  864.    || !ChkArgCnt(1, 2))
  865.     return;
  866.  
  867.   if ((ArgCnt == 2) /* A as dest */
  868.    && !CheckAcc_Z80(&ArgStr[1]))
  869.     return;
  870.  
  871.   switch (DecodeAdr_Z80(&ArgStr[ArgCnt], MModImm | MModIHL | MModReg8, &SrcAdrVals))
  872.   {
  873.     case eModReg8:
  874.       BAsmCode[CodeLen++] = Lo(Code) | SrcAdrVals.Val;
  875.       break;
  876.     case eModIHL:
  877.       BAsmCode[CodeLen++] = Lo(Code) | 0x07;
  878.       break;
  879.     case eModImm:
  880.       BAsmCode[CodeLen++] = Hi(Code);
  881.       BAsmCode[CodeLen++] = SrcAdrVals.Val;
  882.       break;
  883.     default:
  884.       break;
  885.   }
  886. }
  887.  
  888. /*!------------------------------------------------------------------------
  889.  * \fn     DecodeCP(Word Code)
  890.  * \brief  handle CP instruction
  891.  * ------------------------------------------------------------------------ */
  892.  
  893. static void DecodeCP(Word Code)
  894. {
  895.   tAdrVals SrcAdrVals;
  896.   Boolean IsCall;
  897.  
  898.   UNUSED(Code);
  899.  
  900.   if (!ChkArgCnt(1, (CurrZ80Syntax & eSyntaxZ80) ? 2 : 1))
  901.     return;
  902.  
  903.   /* 2 arguments -> check for A as dest, and compare is meant
  904.      (syntax is either Z80 or Z80+808x implicitly due to previous check) */
  905.  
  906.   if (ArgCnt == 2) /* A as dest */
  907.   {
  908.     if (!CheckAcc_Z80(&ArgStr[1]))
  909.       return;
  910.     IsCall = False;
  911.   }
  912.  
  913.   /* 1 argument -> must be compare anyway in pure Z80 syntax mode, otherwise assume 808x call-on-positive */
  914.  
  915.   else
  916.     IsCall = CurrZ80Syntax != eSyntaxZ80;
  917.  
  918.   if (IsCall)
  919.   {
  920.     DecodeJmpCore((MomCPU == CPU8008New) ? 0x52 : 0x7a);
  921.     return;
  922.   }
  923.  
  924.   switch (DecodeAdr_Z80(&ArgStr[ArgCnt], MModImm | MModIHL | MModReg8, &SrcAdrVals))
  925.   {
  926.     case eModReg8:
  927.       BAsmCode[CodeLen++] = 0xb8 | SrcAdrVals.Val;
  928.       break;
  929.     case eModIHL:
  930.       BAsmCode[CodeLen++] = 0xbf;
  931.       break;
  932.     case eModImm:
  933.       BAsmCode[CodeLen++] = 0x3c;
  934.       BAsmCode[CodeLen++] = SrcAdrVals.Val;
  935.       break;
  936.     default:
  937.       break;
  938.   }
  939. }
  940.  
  941. /*!------------------------------------------------------------------------
  942.  * \fn     DecodeINCDEC(Word Code)
  943.  * \brief  handle (Z80 style) INC/DEC
  944.  * \param  Code machine code
  945.  * ------------------------------------------------------------------------ */
  946.  
  947. static void DecodeINCDEC(Word Code)
  948. {
  949.   /* INC aka INC C on old 8008: */
  950.  
  951.   if ((MomCPU == CPU8008) && (CurrZ80Syntax & eSyntax808x) && (!ArgCnt) && !Code)
  952.   {
  953.     BAsmCode[CodeLen++] = Code | (0x02 << 3);
  954.     return;
  955.   }
  956.  
  957.   if (ChkZ80Syntax(eSyntaxZ80)
  958.    && ChkArgCnt(1, 1))
  959.   {
  960.     tAdrVals AdrVals;
  961.  
  962.     switch (DecodeAdr_Z80(&ArgStr[1], MModReg8, &AdrVals))
  963.     {
  964.       case eModReg8:
  965.         if (AdrVals.Val == AccReg) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  966.         else
  967.           BAsmCode[CodeLen++] = Code | (AdrVals.Val << 3);
  968.         break;
  969.       default:
  970.         break;
  971.     }
  972.   }
  973. }
  974.  
  975. /*!------------------------------------------------------------------------
  976.  * \fn     DecodeSingleReg(Word Index)
  977.  * \brief  handle instructions taking a single register as argument
  978.  * \param  Index machine code
  979.  * ------------------------------------------------------------------------ */
  980.  
  981. static void DecodeSingleReg(Word Index)
  982. {
  983.   Byte Reg, Opcode = Lo(Index), Shift = Hi(Index) & 7;
  984.   Boolean NoAM = (Index & 0x8000) || False;
  985.  
  986.   if (!ChkArgCnt(1, 1));
  987.   else if (!ChkZ80Syntax(eSyntax808x));
  988.   else if (!DecodeReg(ArgStr[1].str.p_str, eSyntax808x, &Reg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  989.   else if (NoAM && ((Reg == 0) || (Reg == 7))) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  990.   else
  991.   {
  992.     BAsmCode[0] = Opcode | (Reg << Shift);
  993.     CodeLen = 1;
  994.   }
  995. }
  996.  
  997. /*!------------------------------------------------------------------------
  998.  * \fn     DecodePORT(Word Index)
  999.  * \brief  handle PORT instruction
  1000.  * ------------------------------------------------------------------------ */
  1001.  
  1002. static void DecodePORT(Word Index)
  1003. {
  1004.   UNUSED(Index);
  1005.  
  1006.   CodeEquate(SegIO, 0, 0x7);
  1007. }
  1008.  
  1009. /*---------------------------------------------------------------------------*/
  1010. /* Codetabellenverwaltung */
  1011.  
  1012. static const char FlagNames[] = "CZSP";
  1013.  
  1014. static void AddFixed(const char *NName, Byte NCode, Word SyntaxMask)
  1015. {
  1016.   AddInstTable(InstTable, NName, (SyntaxMask << 8) | NCode, DecodeFixed);
  1017. }
  1018.  
  1019. static void AddFixeds(const char *NName, Byte NCode, int Shift, Byte RegMask)
  1020. {
  1021.   char Memo[10], *p;
  1022.   int Reg;
  1023.  
  1024.   strcpy(Memo, NName); p = strchr(Memo, '*');
  1025.   for (Reg = 0; Reg < 8; Reg++)
  1026.     if ((1 << Reg) & RegMask)
  1027.     {
  1028.       *p = RegNames[Reg];
  1029.       AddFixed(Memo, NCode + (Reg << Shift), eSyntax808x);
  1030.     }
  1031. }
  1032.  
  1033. static void AddImm(const char *NName, Byte NCode, Word SyntaxMask)
  1034. {
  1035.   AddInstTable(InstTable, NName, (SyntaxMask << 8) | NCode, DecodeImm);
  1036. }
  1037.  
  1038. static void AddImms(const char *NName, Byte NCode, int Pos)
  1039. {
  1040.   char Memo[10], *p;
  1041.   int z;
  1042.  
  1043.   strcpy(Memo, NName); p = strchr(Memo, '*');
  1044.   for (z = 0; z < 8; z++)
  1045.   {
  1046.     *p = RegNames[z];
  1047.     AddImm(Memo, NCode + (z << Pos), eSyntax808x);
  1048.   }
  1049. }
  1050.  
  1051. static void AddJmp(const char *NName, Byte NCode)
  1052. {
  1053.   AddInstTable(InstTable, NName, NCode, DecodeJmp);
  1054. }
  1055.  
  1056. static void AddJmps(const char *NName, Byte NCode, int Pos)
  1057. {
  1058.   char Memo[10], *p;
  1059.   int z;
  1060.  
  1061.   strcpy(Memo, NName); p = strchr(Memo, '*');
  1062.   for (z = 0; z < 4; z++)
  1063.   {
  1064.     *p = FlagNames[z];
  1065.     AddJmp(Memo, NCode + (z << Pos));
  1066.   }
  1067. }
  1068.  
  1069. static void InitFields(void)
  1070. {
  1071.   Boolean New = (MomCPU == CPU8008New);
  1072.  
  1073.   SetDynamicInstTable(InstTable = CreateInstTable(503));
  1074.  
  1075.   add_null_pseudo(InstTable);
  1076.  
  1077.   AddFixed("HLT" , 0x00, eSyntax808x);
  1078.   AddFixed("HALT", 0x00, eSyntaxZ80);
  1079.   AddFixed("NOP" , 0xc0, eSyntaxBoth); /* = MOV A,A */
  1080.  
  1081.   if (!New)
  1082.     AddInstTable(InstTable, "INP", True, DecodeINP_OUT);
  1083.   AddInstTable(InstTable, "IN" , True , DecodeINP_OUT);
  1084.   AddInstTable(InstTable, "OUT", False, DecodeINP_OUT);
  1085.  
  1086.   AddInstTable(InstTable, "JP", 0, DecodeJP);
  1087.   AddInstTable(InstTable, "J", 0, DecodeJ);
  1088.   AddJmp ("JMP", 0x44);
  1089.   if (New)
  1090.   {
  1091.     AddJmp("JNC", 0x40);
  1092.     AddJmp("JNZ", 0x48);
  1093.     AddJmp("JPO", 0x58);
  1094.     AddJmp("JM" , 0x70);
  1095.     AddJmp("JPE", 0x78);
  1096.   }
  1097.   else
  1098.   {
  1099.     AddJmp("JS" , 0x70);
  1100.     AddJmps("JF*", 0x40, 3);
  1101.     AddJmps("JT*", 0x60, 3);
  1102.   }
  1103.   AddJmp("JC" , 0x60);
  1104.   AddJmp("JZ" , 0x68);
  1105.  
  1106.   AddInstTable(InstTable, "CALL", 0, DecodeCALL);
  1107.   AddInstTable(InstTable, "CP", 0, DecodeCP);
  1108.   if (New)
  1109.   {
  1110.     AddJmp("CNC", 0x42);
  1111.     AddJmp("CNZ", 0x4a);
  1112.     AddJmp("CPO", 0x5a);
  1113.     AddJmp("CM" , 0x72);
  1114.     AddJmp("CPE", 0x7a);
  1115.   }
  1116.   else
  1117.   {
  1118.     AddJmp("CAL", 0x46);
  1119.     AddJmp("CS" , 0x72);
  1120.     AddJmps("CF*", 0x42, 3);
  1121.     AddJmps("CT*", 0x62, 3);
  1122.   }
  1123.   AddJmp ("CC" , 0x62);
  1124.   AddJmp ("CZ" , 0x6a);
  1125.  
  1126.   AddInstTable(InstTable, "RET", 0x07, DecodeRET);
  1127.   if (New)
  1128.   {
  1129.     AddFixed("RNC", 0x03, eSyntax808x);
  1130.     AddFixed("RNZ", 0x0b, eSyntax808x);
  1131.     AddFixed("RP" , 0x13, eSyntax808x);
  1132.     AddFixed("RPO", 0x1b, eSyntax808x);
  1133.     AddFixed("RM" , 0x33, eSyntax808x);
  1134.     AddFixed("RPE", 0x3b, eSyntax808x);
  1135.   }
  1136.   else
  1137.   {
  1138.     AddFixed("RFC", 0x03, eSyntax808x);
  1139.     AddFixed("RFZ", 0x0b, eSyntax808x);
  1140.     AddFixed("RFS", 0x13, eSyntax808x);
  1141.     AddFixed("RFP", 0x1b, eSyntax808x);
  1142.     AddFixed("RS" , 0x33, eSyntax808x);
  1143.     AddFixed("RP" , 0x3b, eSyntax808x);
  1144.     AddFixed("RTC", 0x23, eSyntax808x);
  1145.     AddFixed("RTZ", 0x2b, eSyntax808x);
  1146.     AddFixed("RTS", 0x33, eSyntax808x);
  1147.     AddFixed("RTP", 0x3b, eSyntax808x);
  1148.   }
  1149.   AddFixed("RC" , 0x23, eSyntax808x);
  1150.   AddFixed("RZ" , 0x2b, eSyntax808x);
  1151.  
  1152.   AddInstTable(InstTable, "RST", 0, DecodeRST); /* TODO: Z80 */
  1153.  
  1154.   if (New)
  1155.     AddInstTable(InstTable, "MOV", 0, DecodeMOV);
  1156.   else
  1157.   {
  1158.     AddFixeds("L*A", 0xc0, 3, 0xff);
  1159.     AddFixeds("L*B", 0xc1, 3, 0xff);
  1160.     AddFixeds("L*C", 0xc2, 3, 0xff);
  1161.     AddFixeds("L*D", 0xc3, 3, 0xff);
  1162.     AddFixeds("L*E", 0xc4, 3, 0xff);
  1163.     AddFixeds("L*H", 0xc5, 3, 0xff);
  1164.     AddFixeds("L*L", 0xc6, 3, 0xff);
  1165.     AddFixeds("L*M", 0xc7, 3, 0x7f); /* forbid LMM - would be opcode for HLT */
  1166.   }
  1167.  
  1168.   if (New)
  1169.   {
  1170.     AddInstTable(InstTable, "MVI", 0, DecodeMVI);
  1171.     AddInstTable(InstTable, "LXI", 0, DecodeLXI);
  1172.   }
  1173.   else
  1174.     AddImms("L*I", 0x06, 3);
  1175.  
  1176.   AddInstTable(InstTable, "LD", 0, DecodeLD);
  1177.  
  1178.   AddInstTable(InstTable, "ADD", 0x0080, DecodeADD);
  1179.   AddInstTable(InstTable, "ADC", 0x0088, DecodeADC);
  1180.   AddInstTable(InstTable, "SUB", 0x0090, DecodeSUB);
  1181.   AddInstTable(InstTable, "SBC", 0x0098, DecodeSBC);
  1182.   AddInstTable(InstTable, "AND", 0x24a0, DecodeALU8_Z80);
  1183.   AddInstTable(InstTable, "XOR", 0x2ca8, DecodeALU8_Z80);
  1184.   AddInstTable(InstTable, "OR" , 0x34b0, DecodeALU8_Z80);
  1185.   AddInstTable(InstTable, "INC", 0x00, DecodeINCDEC);
  1186.   AddInstTable(InstTable, "DEC", 0x01, DecodeINCDEC);
  1187.   if (New)
  1188.   {
  1189.     AddInstTable(InstTable, "SBB", 0x0098, DecodeSingleReg);
  1190.     AddInstTable(InstTable, "ANA", 0x00a0, DecodeSingleReg);
  1191.     AddInstTable(InstTable, "XRA", 0x00a8, DecodeSingleReg);
  1192.     AddInstTable(InstTable, "ORA", 0x00b0, DecodeSingleReg);
  1193.     AddInstTable(InstTable, "CMP", 0x00b8, DecodeSingleReg);
  1194.     AddInstTable(InstTable, "INR", 0x8300, DecodeSingleReg);
  1195.     AddInstTable(InstTable, "DCR", 0x8301, DecodeSingleReg);
  1196.   }
  1197.   else
  1198.   {
  1199.     AddFixeds("AD*", 0x80, 0, 0xf3); /* ADC/ADD handled separately */
  1200.     AddFixeds("AC*", 0x88, 0, 0xff);
  1201.     AddFixeds("SU*", 0x90, 0, 0xfd); /* SUB handled separately */
  1202.     AddFixeds("SB*", 0x98, 0, 0xfb); /* SBC handled separately */
  1203.     AddFixeds("NR*", 0xa0, 0, 0xff);
  1204.     AddFixeds("ND*", 0xa0, 0, 0xff);
  1205.     AddFixeds("XR*", 0xa8, 0, 0xff);
  1206.     AddFixeds("OR*", 0xb0, 0, 0xff);
  1207.     AddFixeds("CP*", 0xb8, 0, 0xff);
  1208.     AddFixeds("IN*", 0x00, 3, 0x7a); /* no INA/INM, INC handled separately */
  1209.     AddFixeds("DC*", 0x01, 3, 0x7e); /* no DCA/DCM */
  1210.   }
  1211.  
  1212.   AddImm ("ADI", 0x04, eSyntax808x);
  1213.   AddImm ("ACI", 0x0c, eSyntax808x);
  1214.   AddImm ("SUI", 0x14, eSyntax808x);
  1215.   AddImm ("SBI", 0x1c, eSyntax808x);
  1216.   AddImm (New ? "ANI" : "NDI", 0x24, eSyntax808x);
  1217.   AddImm ("XRI", 0x2c, eSyntax808x);
  1218.   AddImm ("ORI", 0x34, eSyntax808x);
  1219.   AddImm ("CPI", 0x3c, eSyntax808x);
  1220.  
  1221.   AddFixed ("RLC" , 0x02, eSyntax808x);
  1222.   AddFixed ("RLCA", 0x02, eSyntaxZ80);
  1223.   AddFixed ("RRC" , 0x0a, eSyntax808x);
  1224.   AddFixed ("RRCA", 0x0a, eSyntaxZ80);
  1225.   AddFixed ("RAL" , 0x12, eSyntax808x);
  1226.   AddFixed ("RLA" , 0x12, eSyntaxZ80);
  1227.   AddFixed ("RAR" , 0x1a, eSyntax808x);
  1228.   AddFixed ("RRA" , 0x1a, eSyntaxZ80);
  1229.  
  1230.   AddInstTable(InstTable, "PORT", 0, DecodePORT);
  1231.   AddZ80Syntax(InstTable);
  1232.   AddInstTable(InstTable, "DFB", eIntPseudoFlag_LittleEndian | eIntPseudoFlag_AllowInt, DecodeIntelDB);
  1233.   AddIntelPseudo(InstTable, eIntPseudoFlag_LittleEndian);
  1234. }
  1235.  
  1236. static void DeinitFields(void)
  1237. {
  1238.   DestroyInstTable(InstTable);
  1239. }
  1240.  
  1241. /*---------------------------------------------------------------------------*/
  1242. /* Callbacks */
  1243.  
  1244. static void MakeCode_8008(void)
  1245. {
  1246.   /* der Rest */
  1247.  
  1248.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  1249.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  1250. }
  1251.  
  1252. static Boolean IsDef_8008(void)
  1253. {
  1254.   return Memo("PORT");
  1255. }
  1256.  
  1257. static void SwitchFrom_8008(void)
  1258. {
  1259.   DeinitFields();
  1260. }
  1261.  
  1262. static void SwitchTo_8008(void)
  1263. {
  1264.   const TFamilyDescr *FoundDescr;
  1265.  
  1266.   FoundDescr = FindFamilyByName("8008");
  1267.  
  1268.   TurnWords = False;
  1269.   SetIntConstMode(eIntConstModeIntel);
  1270.  
  1271.   PCSymbol = "$"; HeaderID = FoundDescr->Id; NOPCode = 0xc0;
  1272.   DivideChars = ","; HasAttrs = False;
  1273.  
  1274.   ValidSegs = (1 << SegCode) | (1 << SegIO);
  1275.   Grans[SegCode ] = 1; ListGrans[SegCode ] = 1; SegInits[SegCode ] = 0;
  1276.   SegLimits[SegCode] = 0x3fff;
  1277.   Grans[SegIO   ] = 1; ListGrans[SegIO   ] = 1; SegInits[SegIO   ] = 0;
  1278.   SegLimits[SegIO] = 7;
  1279.  
  1280.   MakeCode = MakeCode_8008;
  1281.   IsDef = IsDef_8008;
  1282.   SwitchFrom = SwitchFrom_8008;
  1283.  
  1284.   InitFields();
  1285. }
  1286.  
  1287. /*---------------------------------------------------------------------------*/
  1288. /* Initialisierung */
  1289.  
  1290. void code8008_init(void)
  1291. {
  1292.   CPU8008    = AddCPU("8008"   , SwitchTo_8008);
  1293.   CPU8008New = AddCPU("8008NEW", SwitchTo_8008);
  1294. }
  1295.