Subversion Repositories pentevo

Rev

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

  1. /* code2650.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator Signetics 2650                                              */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <string.h>
  13. #include <ctype.h>
  14.  
  15. #include "nls.h"
  16. #include "chunks.h"
  17. #include "bpemu.h"
  18. #include "strutil.h"
  19.  
  20. #include "asmdef.h"
  21. #include "asmsub.h"
  22. #include "asmpars.h"
  23. #include "asmitree.h"
  24. #include "codevars.h"
  25. #include "headids.h"
  26. #include "intpseudo.h"
  27. #include "errmsg.h"
  28. #include "onoff_common.h"
  29.  
  30. #include "code2650.h"
  31.  
  32. #define ADDR_INT UInt15
  33.  
  34. /*--------------------------------------------------------------------------*/
  35. /* Local Variables */
  36.  
  37. static CPUVar CPU2650;
  38. static Boolean splitted_arg;
  39.  
  40. /*--------------------------------------------------------------------------*/
  41. /* Expression Parsers */
  42.  
  43. static Boolean DecodeReg(const char *pAsc, Byte *pRes)
  44. {
  45.   Boolean Result;
  46.  
  47.   Result = ((strlen(pAsc) == 2) && (as_toupper(pAsc[0]) == 'R') && (pAsc[1] >= '0') && (pAsc[1] <= '3'));
  48.   if (Result)
  49.     *pRes = pAsc[1] - '0';
  50.   return Result;
  51. }
  52.  
  53. /*!------------------------------------------------------------------------
  54.  * \fn     DecodeCondition(const tStrComp *p_arg, Byte *p_ret)
  55.  * \brief  decode condition code
  56.  * \param  p_arg source argument
  57.  * \param  p_ret binary encoded argument
  58.  * \return true if success
  59.  * ------------------------------------------------------------------------ */
  60.  
  61. static Boolean DecodeCondition(const tStrComp *p_arg, Byte *p_ret)
  62. {
  63.   const char *p_asc = p_arg->str.p_str;
  64.  
  65.   if (!as_strcasecmp(p_asc, "EQ") || !as_strcasecmp(p_asc, "Z"))
  66.   {
  67.     *p_ret = 0;
  68.     return True;
  69.   }
  70.   else if (!as_strcasecmp(p_asc, "GT") || !as_strcasecmp(p_asc, "P"))
  71.   {
  72.     *p_ret = 1;
  73.     return True;
  74.   }
  75.   else if (!as_strcasecmp(p_asc, "LT") || !as_strcasecmp(p_asc, "N"))
  76.   {
  77.     *p_ret = 2;
  78.     return True;
  79.   }
  80.   else if ((!as_strcasecmp(p_asc, "ALWAYS")) || (!as_strcasecmp(p_asc, "UN")))
  81.   {
  82.     *p_ret = 3;
  83.     return True;
  84.   }
  85.   else
  86.   {
  87.     Boolean ok;
  88.  
  89.     *p_ret = EvalStrIntExpression(p_arg, UInt2, &ok);
  90.     return ok;
  91.   }
  92. }
  93.  
  94. /*!------------------------------------------------------------------------
  95.  * \fn     page_rel_ok(Word dest, Word src, tSymbolFlags flags, Word *p_dist, Boolean is_branch)
  96.  * \brief  check whether relative addressing in same 8K page is possible
  97.  * \param  dest target address
  98.  * \param  src current (source) address
  99.  * \param  flags expression evaluation flags
  100.  * \param  p_dist resulting distance
  101.  * \param  is_branch code or data access?
  102.  * \return True if distance is in range
  103.  * ------------------------------------------------------------------------ */
  104.  
  105. #define PAGE_MASK 0x1fff
  106.  
  107. static Boolean page_rel_ok(Word dest, Word src, tSymbolFlags flags, Word *p_dist, Boolean is_branch)
  108. {
  109.   if (((src & ~PAGE_MASK) != (dest & ~PAGE_MASK)) && !mSymbolQuestionable(flags))
  110.   {
  111.     WrError(is_branch ? ErrNum_JmpTargOnDiffPage : ErrNum_TargOnDiffPage);
  112.     return False;
  113.   }
  114.  
  115.   *p_dist = (dest - src) & PAGE_MASK;
  116.   if (((*p_dist < 0x1fc0) && (*p_dist > 0x3f)) && !mSymbolQuestionable(flags))
  117.   {
  118.     WrError(is_branch ? ErrNum_JmpDistTooBig : ErrNum_DistTooBig);
  119.     return False;
  120.   }
  121.  
  122.   return True;
  123. }
  124.  
  125. /*!------------------------------------------------------------------------
  126.  * \fn     Boolean page_abs_ok(Word dest, Word src, tSymbolFlags flags, Word *p_dest, Boolean is_branch)
  127.  * \brief  check whether absolute address is in same 8K page
  128.  * \param  dest target address
  129.  * \param  src current (source) address
  130.  * \param  flags expression evaluation flags
  131.  * \param  p_dest resulting address in machine instruction
  132.  * \param  is_branch code or data access?
  133.  * \return True if distance is in range
  134.  * ------------------------------------------------------------------------ */
  135.  
  136. static Boolean page_abs_ok(Word dest, Word src, tSymbolFlags flags, Word *p_dest, Boolean is_branch)
  137. {
  138.   if (((src & ~PAGE_MASK) != (dest & ~PAGE_MASK)) && !mSymbolQuestionable(flags))
  139.   {
  140.     WrError(is_branch ? ErrNum_JmpTargOnDiffPage : ErrNum_TargOnDiffPage);
  141.     return False;
  142.   }
  143.  
  144.   *p_dest = dest & PAGE_MASK;
  145.   return True;
  146. }
  147.  
  148. /*--------------------------------------------------------------------------*/
  149. /* Instruction Decoders */
  150.  
  151. static void DecodeFixed(Word Index)
  152. {
  153.   if (ChkArgCnt(0, 0))
  154.   {
  155.     BAsmCode[0] = Index; CodeLen = 1;
  156.   }
  157. }
  158.  
  159. /*!------------------------------------------------------------------------
  160.  * \fn     DecodeOneReg(Word Index)
  161.  * \brief  decode instructions taking a single register as argument
  162.  * \param  Index machine code of instruction when register 0 is used
  163.  * ------------------------------------------------------------------------ */
  164.  
  165. static void DecodeOneReg(Word Index)
  166. {
  167.   Byte Reg;
  168.  
  169.   if (!ChkArgCnt(1, 1));
  170.   else if (!DecodeReg(ArgStr[1].str.p_str, &Reg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  171.   else
  172.   {
  173.     BAsmCode[0] = Index | Reg;
  174.     CodeLen = 1;
  175.   }
  176. }
  177.  
  178. /*!------------------------------------------------------------------------
  179.  * \fn     DecodeOneReg_NoZero(Word Index)
  180.  * \brief  decode instructions taking a single register except R0 as argument
  181.  * \param  Index machine code of instruction register # is added to
  182.  * ------------------------------------------------------------------------ */
  183.  
  184.  
  185. static void DecodeOneReg_NoZero(Word Index)
  186. {
  187.   Byte Reg;
  188.  
  189.   if (!ChkArgCnt(1, 1));
  190.   else if (!DecodeReg(ArgStr[1].str.p_str, &Reg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  191.   else if (!Reg) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  192.   else
  193.   {
  194.     BAsmCode[0] = Index | Reg;
  195.     CodeLen = 1;
  196.   }
  197. }
  198.  
  199. /*!------------------------------------------------------------------------
  200.  * \fn     DecodeLODZ(Word Index)
  201.  * \brief  decode LODZ instruction
  202.  * \param  Index machine code of instruction when register 0 is used
  203.  * ------------------------------------------------------------------------ */
  204.  
  205. static void DecodeLODZ(Word Index)
  206. {
  207.   Byte Reg;
  208.  
  209.   if (!ChkArgCnt(1, 1));
  210.   else if (!DecodeReg(ArgStr[1].str.p_str, &Reg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  211.   else
  212.   {
  213.     /* LODZ R0 shall be encoded as IORZ R0 */
  214.     BAsmCode[0] = Reg ? (Index | Reg) : 0x60;
  215.     CodeLen = 1;
  216.   }
  217. }
  218.  
  219. static void DecodeImm(Word Index)
  220. {
  221.   Boolean OK;
  222.  
  223.   if (ChkArgCnt(1, 1))
  224.   {
  225.     BAsmCode[1] = EvalStrIntExpression(&ArgStr[1], Int8, &OK);
  226.     if (OK)
  227.     {
  228.       BAsmCode[0] = Index; CodeLen = 2;
  229.     }
  230.   }
  231. }
  232.  
  233. static void DecodeRegImm(Word Index)
  234. {
  235.   Byte Reg;
  236.   Boolean OK;
  237.  
  238.   if (!ChkArgCnt(2, 2));
  239.   else if (!DecodeReg(ArgStr[1].str.p_str, &Reg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  240.   else
  241.   {
  242.     BAsmCode[1] = EvalStrIntExpression(&ArgStr[2], Int8, &OK);
  243.     if (OK)
  244.     {
  245.       BAsmCode[0] = Index | Reg; CodeLen = 2;
  246.     }
  247.   }
  248. }
  249.  
  250. /*!------------------------------------------------------------------------
  251.  * \fn     void DecodeRegAbs(Word code)
  252.  * \brief  handle instruction with register & absolute address
  253.  * \param  code instruction machine code
  254.  * ------------------------------------------------------------------------ */
  255.  
  256. static void DecodeRegAbs(Word code)
  257. {
  258.   Byte dest_reg;
  259.  
  260.   if (!ChkArgCnt(2, 4));
  261.   else if (!DecodeReg(ArgStr[1].str.p_str, &dest_reg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  262.   else
  263.   {
  264.     Boolean ok, ind_flag = *ArgStr[2].str.p_str == '*';
  265.     Word abs_val;
  266.     tSymbolFlags flags;
  267.     Byte index_reg;
  268.  
  269.     abs_val = EvalStrIntExpressionOffsWithFlags(&ArgStr[2], ind_flag, ADDR_INT, &ok, &flags);
  270.     if (ok && page_abs_ok(abs_val, EProgCounter() + 3, flags, &abs_val, False))
  271.     {
  272.       BAsmCode[0] = code;
  273.       BAsmCode[1] = Hi(abs_val);
  274.       BAsmCode[2] = Lo(abs_val);
  275.       if (ind_flag)
  276.         BAsmCode[1] |= 0x80;
  277.       if (ArgCnt == 2)
  278.       {
  279.         BAsmCode[0] |= dest_reg;
  280.         CodeLen = 3;
  281.       }
  282.       else
  283.       {
  284.         if (!DecodeReg(ArgStr[3].str.p_str, &index_reg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[3]);
  285.         else if (dest_reg != 0) WrError(ErrNum_InvAddrMode);
  286.         else
  287.         {
  288.           BAsmCode[0] |= index_reg;
  289.           if (ArgCnt == 3)
  290.           {
  291.             BAsmCode[1] |= 0x60;
  292.             CodeLen = 3;
  293.           }
  294.           else if (!strcmp(ArgStr[4].str.p_str, "-"))
  295.           {
  296.             BAsmCode[1] |= 0x40;
  297.             CodeLen = 3;
  298.           }
  299.           else if (!strcmp(ArgStr[4].str.p_str, "+"))
  300.           {
  301.             BAsmCode[1] |= 0x20;
  302.             CodeLen = 3;
  303.           }
  304.           else
  305.             WrError(ErrNum_InvAddrMode);
  306.         }
  307.       }
  308.     }
  309.   }
  310. }
  311.  
  312. /*!------------------------------------------------------------------------
  313.  * \fn     DecodeRegRel(Word code)
  314.  * \brief  handle instructions with register & relative argument
  315.  * \param  code instruction machine code
  316.  * ------------------------------------------------------------------------ */
  317.  
  318. static void DecodeRegRel(Word code)
  319. {
  320.   Byte reg;
  321.  
  322.   if (!ChkArgCnt(2, 2));
  323.   else if (!DecodeReg(ArgStr[1].str.p_str, &reg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  324.   else
  325.   {
  326.     Word dest, dist;
  327.     tSymbolFlags flags;
  328.     Boolean ind_flag, ok;
  329.  
  330.     BAsmCode[0] = code | reg;
  331.     ind_flag = *ArgStr[2].str.p_str == '*';
  332.     dest = EvalStrIntExpressionOffsWithFlags(&ArgStr[2], ind_flag, ADDR_INT, &ok, &flags);
  333.     if (ok && page_rel_ok(dest, EProgCounter() + 2, flags, &dist, False))
  334.     {
  335.       BAsmCode[1] = dist & 0x7f;
  336.       if (ind_flag)
  337.         BAsmCode[1] |= 0x80;
  338.       CodeLen = 2;
  339.     }
  340.   }
  341. }
  342.  
  343. static void DecodeCondAbs(Word Index)
  344. {
  345.   Byte Cond;
  346.   Word Address;
  347.   Boolean OK, IndFlag;
  348.  
  349.   if (ChkArgCnt(2, 2)
  350.    && DecodeCondition(&ArgStr[1], &Cond))
  351.   {
  352.     IndFlag = *ArgStr[2].str.p_str == '*';
  353.     Address = EvalStrIntExpressionOffs(&ArgStr[2], IndFlag, ADDR_INT, &OK);
  354.     if (OK)
  355.     {
  356.       BAsmCode[0] = Index | Cond;
  357.       BAsmCode[1] = Hi(Address);
  358.       if (IndFlag)
  359.         BAsmCode[1] |= 0x80;
  360.       BAsmCode[2] = Lo(Address);
  361.       CodeLen = 3;
  362.     }
  363.   }
  364. }
  365.  
  366. /*!------------------------------------------------------------------------
  367.  * \fn     DecodeCondRel(Word code)
  368.  * \brief  decode relative branches
  369.  * \param  code machine code
  370.  * ------------------------------------------------------------------------ */
  371.  
  372. static void DecodeCondRel(Word code)
  373. {
  374.   Byte cond;
  375.  
  376.   if (ChkArgCnt(2, 2)
  377.    && DecodeCondition(&ArgStr[1], &cond))
  378.   {
  379.     Boolean ind_flag, ok;
  380.     tSymbolFlags flags;
  381.     Word dist, dest;
  382.  
  383.     BAsmCode[0] = code | cond;
  384.     ind_flag = *ArgStr[2].str.p_str == '*';
  385.     dest = EvalStrIntExpressionOffsWithFlags(&ArgStr[2], ind_flag, ADDR_INT, &ok, &flags);
  386.     if (ok && page_rel_ok(dest, EProgCounter() + 2, flags, &dist, True))
  387.     {
  388.       BAsmCode[1] = dist & 0x7f;
  389.       if (ind_flag)
  390.         BAsmCode[1] |= 0x80;
  391.       CodeLen = 2;
  392.     }
  393.   }
  394. }
  395.  
  396. static void DecodeRegAbs2(Word Index)
  397. {
  398.   Byte Reg;
  399.   Word AbsVal;
  400.   Boolean IndFlag, OK;
  401.  
  402.   if (!ChkArgCnt(2, 2));
  403.   else if (!DecodeReg(ArgStr[1].str.p_str, &Reg)) WrStrErrorPos(ErrNum_InvReg, &ArgStr[1]);
  404.   else
  405.   {
  406.     BAsmCode[0] = Index | Reg;
  407.     IndFlag = *ArgStr[2].str.p_str == '*';
  408.     AbsVal = EvalStrIntExpressionOffs(&ArgStr[2], IndFlag, ADDR_INT, &OK);
  409.     if (OK)
  410.     {
  411.       BAsmCode[1] = Hi(AbsVal);
  412.       if (IndFlag)
  413.         BAsmCode[1] |= 0x80;
  414.       BAsmCode[2] = Lo(AbsVal);
  415.       CodeLen = 3;
  416.     }
  417.   }
  418. }
  419.  
  420. static void DecodeBrAbs(Word Index)
  421. {
  422.   Byte Reg = 3;
  423.   Word AbsVal;
  424.   Boolean IndFlag, OK;
  425.  
  426.   if (!ChkArgCnt(1, 2));
  427.   else if ((ArgCnt == 2) && (!DecodeReg(ArgStr[2].str.p_str, &Reg))) WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);
  428.   else if (Reg != 3) WrError(ErrNum_InvAddrMode);
  429.   else
  430.   {
  431.     BAsmCode[0] = Index | Reg;
  432.     IndFlag = *ArgStr[1].str.p_str == '*';
  433.     AbsVal = EvalStrIntExpressionOffs(&ArgStr[1], IndFlag, ADDR_INT, &OK);
  434.     if (OK)
  435.     {
  436.       BAsmCode[1] = Hi(AbsVal);
  437.       if (IndFlag)
  438.         BAsmCode[1] |= 0x80;
  439.       BAsmCode[2] = Lo(AbsVal);
  440.       CodeLen = 3;
  441.     }
  442.   }
  443. }
  444.  
  445. static void DecodeCond(Word Index)
  446. {
  447.   Byte Cond;
  448.  
  449.   if (ChkArgCnt(1, 1)
  450.    && DecodeCondition(&ArgStr[1], &Cond))
  451.   {
  452.     BAsmCode[0] = Index | Cond;
  453.     CodeLen = 1;
  454.   }
  455. }
  456.  
  457. /*!------------------------------------------------------------------------
  458.  * \fn     DecodeZero(Word code)
  459.  * \brief  decode zero page branch instructions
  460.  * \param  code machine code
  461.  * ------------------------------------------------------------------------ */
  462.  
  463. static void DecodeZero(Word code)
  464. {
  465.   if (ChkArgCnt(1, 1))
  466.   {
  467.     Boolean ind_flag, ok;
  468.     tSymbolFlags flags;
  469.     Word dest, dist;
  470.  
  471.     BAsmCode[0] = code;
  472.     ind_flag = *ArgStr[1].str.p_str == '*';
  473.     dest = EvalStrIntExpressionOffsWithFlags(&ArgStr[1], ind_flag, ADDR_INT, &ok, &flags);
  474.     if (ok && page_rel_ok(dest, 0x0000, flags, &dist, True))
  475.     {
  476.       BAsmCode[1] = dist & 0x7f;
  477.       if (ind_flag)
  478.         BAsmCode[1] |= 0x80;
  479.       CodeLen = 2;
  480.     }
  481.   }
  482. }
  483.  
  484. /*!------------------------------------------------------------------------
  485.  * \fn     check_no_splitted_arg(Word code)
  486.  * \brief  complain if pseudo op got derived by splitting off argument
  487.  * ------------------------------------------------------------------------ */
  488.  
  489. static void check_no_splitted_arg(Word code)
  490. {
  491.   UNUSED(code);
  492.   if (splitted_arg)
  493.     WrStrErrorPos(ErrNum_InvArg, &ArgStr[1]);
  494. }
  495.  
  496. /*--------------------------------------------------------------------------*/
  497. /* Code Table Handling */
  498.  
  499. static void AddFixed(const char *pName, Word Code)
  500. {
  501.   AddInstTable(InstTable, pName, Code, DecodeFixed);
  502. }
  503.  
  504. static void AddOneReg(const char *pName, Word Code)
  505. {
  506.   AddInstTable(InstTable, pName, Code, DecodeOneReg);
  507. }
  508.  
  509. static void AddImm(const char *pName, Word Code)
  510. {
  511.   AddInstTable(InstTable, pName, Code, DecodeImm);
  512. }
  513.  
  514. static void AddRegImm(const char *pName, Word Code)
  515. {
  516.   AddInstTable(InstTable, pName, Code, DecodeRegImm);
  517. }
  518.  
  519. static void AddRegAbs(const char *pName, Word Code)
  520. {
  521.   AddInstTable(InstTable, pName, Code, DecodeRegAbs);
  522. }
  523.  
  524. static void AddRegRel(const char *pName, Word Code)
  525. {
  526.   AddInstTable(InstTable, pName, Code, DecodeRegRel);
  527. }
  528.  
  529. static void AddCondAbs(const char *pName, Word Code)
  530. {
  531.   AddInstTable(InstTable, pName, Code, DecodeCondAbs);
  532. }
  533.  
  534. static void AddCondRel(const char *pName, Word Code)
  535. {
  536.   AddInstTable(InstTable, pName, Code, DecodeCondRel);
  537. }
  538.  
  539. static void AddRegAbs2(const char *pName, Word Code)
  540. {
  541.   AddInstTable(InstTable, pName, Code, DecodeRegAbs2);
  542. }
  543.  
  544. static void AddBrAbs(const char *pName, Word Code)
  545. {
  546.   AddInstTable(InstTable, pName, Code, DecodeBrAbs);
  547. }
  548.  
  549. static void AddCond(const char *pName, Word Code)
  550. {
  551.   AddInstTable(InstTable, pName, Code, DecodeCond);
  552. }
  553.  
  554. static void AddZero(const char *pName, Word Code)
  555. {
  556.   AddInstTable(InstTable, pName, Code, DecodeZero);
  557. }
  558.  
  559. static void InitFields(void)
  560. {
  561.   InstTable = CreateInstTable(203);
  562.  
  563.   AddFixed("NOP", 0xc0);
  564.   AddFixed("HALT", 0x40);
  565.   AddFixed("LPSL", 0x93);
  566.   AddFixed("LPSU", 0x92);
  567.   AddFixed("SPSL", 0x13);
  568.   AddFixed("SPSU", 0x12);
  569.  
  570.   AddOneReg("ADDZ", 0x80);
  571.   /* ANDZ R0 is not allowed and decodes as HALT */
  572.   AddInstTable(InstTable, "ANDZ", 0x40, DecodeOneReg_NoZero);
  573.   AddOneReg("COMZ", 0xe0);
  574.   AddOneReg("DAR", 0x94);
  575.   AddOneReg("EORZ", 0x20);
  576.   AddOneReg("IORZ", 0x60);
  577.   AddInstTable(InstTable, "LODZ", 0x00, DecodeLODZ);
  578.   AddOneReg("REDC", 0x30);
  579.   AddOneReg("REDD", 0x70);
  580.   AddOneReg("RRL", 0xd0);
  581.   AddOneReg("RRR", 0x50);
  582.   /* STRZ R0 is not allowed and decodes as NOP */
  583.   AddInstTable(InstTable, "STRZ", 0xc0, DecodeOneReg_NoZero);
  584.   AddOneReg("SUBZ", 0xa0);
  585.   AddOneReg("WRTC", 0xb0);
  586.   AddOneReg("WRTD", 0xf0);
  587.  
  588.   AddImm("CPSL", 0x75);
  589.   AddImm("CPSU", 0x74);
  590.   AddImm("PPSL", 0x77);
  591.   AddImm("PPSU", 0x76);
  592.   AddImm("TPSL", 0xb5);
  593.   AddImm("TPSU", 0xb4);
  594.  
  595.   AddRegImm("ADDI", 0x84);
  596.   AddRegImm("ANDI", 0x44);
  597.   AddRegImm("COMI", 0xe4);
  598.   AddRegImm("EORI", 0x24);
  599.   AddRegImm("IORI", 0x64);
  600.   AddRegImm("LODI", 0x04);
  601.   AddRegImm("REDE", 0x54);
  602.   AddRegImm("SUBI", 0xa4);
  603.   AddRegImm("TMI", 0xf4);
  604.   AddRegImm("WRTE", 0xd4);
  605.  
  606.   AddRegAbs("ADDA", 0x8c);
  607.   AddRegAbs("ANDA", 0x4c);
  608.   AddRegAbs("COMA", 0xec);
  609.   AddRegAbs("EORA", 0x2c);
  610.   AddRegAbs("IORA", 0x6c);
  611.   AddRegAbs("LODA", 0x0c);
  612.   AddRegAbs("STRA", 0xcc);
  613.   AddRegAbs("SUBA", 0xac);
  614.  
  615.   AddRegRel("ADDR", 0x88);
  616.   AddRegRel("ANDR", 0x48);
  617.   AddRegRel("BDRR", 0xf8);
  618.   AddRegRel("BIRR", 0xd8);
  619.   AddRegRel("BRNR", 0x58);
  620.   AddRegRel("BSNR", 0x78);
  621.   AddRegRel("COMR", 0xe8);
  622.   AddRegRel("EORR", 0x28);
  623.   AddRegRel("IORR", 0x68);
  624.   AddRegRel("LODR", 0x08);
  625.   AddRegRel("STRR", 0xc8);
  626.   AddRegRel("SUBR", 0xa8);
  627.  
  628.   AddCondAbs("BCFA", 0x9c);
  629.   AddCondAbs("BCTA", 0x1c);
  630.   AddCondAbs("BSFA", 0xbc);
  631.   AddCondAbs("BSTA", 0x3c);
  632.  
  633.   AddCondRel("BCFR", 0x98);
  634.   AddCondRel("BCTR", 0x18);
  635.   AddCondRel("BSFR", 0xb8);
  636.   AddCondRel("BSTR", 0x38);
  637.  
  638.   AddRegAbs2("BDRA", 0xfc);
  639.   AddRegAbs2("BIRA", 0xdc);
  640.   AddRegAbs2("BRNA", 0x5c);
  641.   AddRegAbs2("BSNA", 0x7c);
  642.  
  643.   AddBrAbs("BSXA", 0xbf);
  644.   AddBrAbs("BXA", 0x9f);
  645.  
  646.   AddCond("RETC", 0x14);
  647.   AddCond("RETE", 0x34);
  648.  
  649.   AddZero("ZBRR", 0x9b);
  650.   AddZero("ZBSR", 0xbb);
  651.  
  652.   inst_table_set_prefix_proc(InstTable, check_no_splitted_arg, 0);
  653.   AddInstTable(InstTable, "RES", 1, DecodeIntelDS);
  654.   AddInstTable(InstTable, "ACON", eIntPseudoFlag_BigEndian | eIntPseudoFlag_AllowInt | eIntPseudoFlag_AllowString, DecodeIntelDW);
  655.   AddIntelPseudo(InstTable, eIntPseudoFlag_DynEndian);
  656. }
  657.  
  658. static void DeinitFields(void)
  659. {
  660.   DestroyInstTable(InstTable);
  661. }
  662.  
  663. /*--------------------------------------------------------------------------*/
  664. /* Callbacks */
  665.  
  666. static void MakeCode_2650(void)
  667. {
  668.   char *pPos;
  669.  
  670.   /* Nullanweisung */
  671.  
  672.   if ((*OpPart.str.p_str == '\0') && (ArgCnt == 0))
  673.     return;
  674.  
  675.   /* try to split off first (register) operand from instruction */
  676.  
  677.   pPos = strchr(OpPart.str.p_str, ',');
  678.   splitted_arg = !!pPos;
  679.   if (splitted_arg)
  680.   {
  681.     InsertArg(1, strlen(OpPart.str.p_str));
  682.     StrCompSplitRight(&OpPart, &ArgStr[1], pPos);
  683.   }
  684.  
  685.   /* alles aus der Tabelle */
  686.  
  687.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  688.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  689. }
  690.  
  691. static Boolean IsDef_2650(void)
  692. {
  693.   return FALSE;
  694. }
  695.  
  696. static void SwitchFrom_2650(void)
  697. {
  698.   DeinitFields();
  699. }
  700.  
  701. static void SwitchTo_2650(void)
  702. {
  703.   const TFamilyDescr *pDescr;
  704.  
  705.   TurnWords = False;
  706.   SetIntConstMode(eIntConstModeMoto);
  707.  
  708.   pDescr = FindFamilyByName("2650");
  709.   PCSymbol = "$"; HeaderID = pDescr->Id; NOPCode = 0xc0;
  710.   DivideChars = ","; HasAttrs = False;
  711.  
  712.   ValidSegs = (1 << SegCode);
  713.   Grans[SegCode] = 1; ListGrans[SegCode] = 1; SegInits[SegCode] = 0;
  714.   SegLimits[SegCode] = IntTypeDefs[ADDR_INT].Max;
  715.  
  716.   MakeCode = MakeCode_2650; IsDef = IsDef_2650;
  717.   SwitchFrom = SwitchFrom_2650; InitFields();
  718.  
  719.   onoff_bigendian_add();
  720. }
  721.  
  722. /*--------------------------------------------------------------------------*/
  723. /* Initialisierung */
  724.  
  725. void code2650_init(void)
  726. {
  727.   CPU2650 = AddCPU("2650", SwitchTo_2650);
  728. }
  729.