Subversion Repositories pentevo

Rev

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

  1. /*
  2.  * AS-Portierung
  3.  *
  4.  * AS-Codegeneratormodul fuer die Texas Instruments TMS320C2x-Familie
  5.  *
  6.  * (C) 1996 Thomas Sailer <sailer@ife.ee.ethz.ch>
  7.  *
  8.  */
  9.  
  10. #include "stdinc.h"
  11. #include <string.h>
  12. #include <ctype.h>
  13.  
  14. #include "strutil.h"
  15. #include "chunks.h"
  16. #include "asmdef.h"
  17. #include "asmsub.h"
  18. #include "errmsg.h"
  19. #include "asmpars.h"
  20. #include "asmitree.h"
  21. #include "codevars.h"
  22. #include "codepseudo.h"
  23. #include "tipseudo.h"
  24. #include "be_le.h"
  25. #include "errmsg.h"
  26.  
  27. #include "code3202x.h"
  28.  
  29. /* ---------------------------------------------------------------------- */
  30.  
  31. typedef struct
  32. {
  33.   Word Code;
  34.   Boolean Must1;
  35. } AdrOrder;
  36.  
  37. typedef struct
  38. {
  39.   Word Code;
  40.   Word AllowShifts;
  41. } AdrShiftOrder;
  42.  
  43. typedef struct
  44. {
  45.   Word Code;
  46.   Integer Min;
  47.   Integer Max;
  48.   Word Mask;
  49. } ImmOrder;
  50.  
  51. typedef struct
  52. {
  53.   const char *Name;
  54.   Word Mode;
  55. } tAdrMode;
  56.  
  57. static AdrOrder *AdrOrders;
  58. static AdrOrder *Adr2ndAdrOrders;
  59. static AdrShiftOrder *AdrShiftOrders;
  60. static ImmOrder *ImmOrders;
  61. static tAdrMode *AdrModes;
  62.  
  63. /* ---------------------------------------------------------------------- */
  64.  
  65. static Word AdrMode;
  66.  
  67. static CPUVar CPU32025, CPU32026, CPU32028;
  68.  
  69. /* ---------------------------------------------------------------------- */
  70.  
  71. static Word EvalARExpression(const tStrComp *pArg, Boolean *OK)
  72. {
  73.   *OK = True;
  74.   if ((as_toupper(pArg->str.p_str[0]) == 'A')
  75.    && (as_toupper(pArg->str.p_str[1]) == 'R')
  76.    && (pArg->str.p_str[2] >= '0') && (pArg->str.p_str[2] <= '7')
  77.    && (pArg->str.p_str[3] == '\0'))
  78.     return pArg->str.p_str[2] - '0';
  79.   return EvalStrIntExpression(pArg, UInt3, OK);
  80. }
  81.  
  82. /* ---------------------------------------------------------------------- */
  83.  
  84. static Boolean DecodeAdr(const tStrComp *pArg, int MinArgCnt, int aux, Boolean Must1)
  85. {
  86.   const tAdrMode *pAdrMode = AdrModes;
  87.   Byte h;
  88.   Boolean AdrOK = False;
  89.   tEvalResult EvalResult;
  90.  
  91.   while (pAdrMode->Name && as_strcasecmp(pAdrMode->Name, pArg->str.p_str))
  92.     pAdrMode++;
  93.   if (!pAdrMode->Name)
  94.   {
  95.     if (aux <= ArgCnt)
  96.     {
  97.       (void)ChkArgCnt(MinArgCnt, aux - 1);
  98.       return False;
  99.     }
  100.     h = EvalStrIntExpressionWithResult(pArg, Int16, &EvalResult);
  101.     if (!EvalResult.OK)
  102.       return False;
  103.     if (Must1 && (h >= 0x80) && !mFirstPassUnknown(EvalResult.Flags))
  104.     {
  105.       WrError(ErrNum_UnderRange);
  106.       return False;
  107.     }
  108.     AdrMode = h & 0x7f;
  109.     ChkSpace(SegData, EvalResult.AddrSpaceMask);
  110.     return True;
  111.   }
  112.   AdrMode = pAdrMode->Mode;
  113.   if (aux <= ArgCnt)
  114.   {
  115.     h = EvalARExpression(&ArgStr[aux], &AdrOK);
  116.     if (AdrOK)
  117.       AdrMode |= 0x8 | h;
  118.     return AdrOK;
  119.   }
  120.   else
  121.     return True;
  122. }
  123.  
  124. /* ---------------------------------------------------------------------- */
  125.  
  126. /* prozessorspezifische Befehle */
  127.  
  128. static void DecodeCNFD(Word Code)
  129. {
  130.   UNUSED(Code);
  131.  
  132.   if (ChkArgCnt(0, 0)
  133.    && ChkExcludeCPU(CPU32026))
  134.   {
  135.     CodeLen = 1;
  136.     WAsmCode[0] = 0xce04;
  137.   }
  138. }
  139.  
  140. static void DecodeCNFP(Word Code)
  141. {
  142.   UNUSED(Code);
  143.  
  144.   if (ChkArgCnt(0, 0)
  145.    && ChkExcludeCPU(CPU32026))
  146.   {
  147.     CodeLen = 1;
  148.     WAsmCode[0] = 0xce05;
  149.   }
  150. }
  151.  
  152. static void DecodeCONF(Word Code)
  153. {
  154.   Boolean OK;
  155.  
  156.   UNUSED(Code);
  157.  
  158.   if (ChkArgCnt(1, 1)
  159.    && ChkExactCPU(CPU32026))
  160.   {
  161.     WAsmCode[0] = 0xce3c | EvalStrIntExpression(&ArgStr[1], UInt2, &OK);
  162.     if (OK)
  163.       CodeLen = 1;
  164.   }
  165. }
  166.  
  167. /* kein Argument */
  168.  
  169. static void DecodeFixed(Word Code)
  170. {
  171.   if (ChkArgCnt(0, 0))
  172.   {
  173.     CodeLen = 1;
  174.     WAsmCode[0] = Code;
  175.   }
  176. }
  177.  
  178. /* Spruenge */
  179.  
  180. static void DecodeJmp(Word Code)
  181. {
  182.   Boolean OK;
  183.  
  184.   if (ChkArgCnt(1, 3))
  185.   {
  186.     if (ArgCnt > 1)
  187.     {
  188.       OK = DecodeAdr(&ArgStr[2], 1, 3, False);
  189.       if (OK  && (AdrMode < 0x80))
  190.       {
  191.         OK = False;
  192.         WrError(ErrNum_InvAddrMode);
  193.       }
  194.     }
  195.     else
  196.     {
  197.       OK = True;
  198.       AdrMode = 0;
  199.     }
  200.     if (OK)
  201.     {
  202.       WAsmCode[1] = EvalStrIntExpression(&ArgStr[1], Int16, &OK);
  203.       if (OK)
  204.       {
  205.         CodeLen = 2;
  206.         WAsmCode[0] = Code | (AdrMode & 0x7f);
  207.       }
  208.     }
  209.   }
  210. }
  211.  
  212. /* nur Adresse */
  213.  
  214. static void DecodeAdrInst(Word Index)
  215. {
  216.   const AdrOrder *pOrder = AdrOrders + Index;
  217.  
  218.   if (ChkArgCnt(1, 2))
  219.   {
  220.     if (DecodeAdr(&ArgStr[1], 1, 2, pOrder->Must1))
  221.     {
  222.       CodeLen = 1;
  223.       WAsmCode[0] = pOrder->Code | AdrMode;
  224.     }
  225.   }
  226. }
  227.  
  228. /* 2 Addressen */
  229.  
  230. static void Decode2ndAdr(Word Index)
  231. {
  232.   const AdrOrder *pOrder = Adr2ndAdrOrders + Index;
  233.   Boolean OK;
  234.  
  235.   if (ChkArgCnt(2, 3))
  236.   {
  237.     WAsmCode[1] = EvalStrIntExpression(&ArgStr[1], Int16, &OK);
  238.     if (OK && DecodeAdr(&ArgStr[2], 2, 3, pOrder->Must1))
  239.     {
  240.       CodeLen = 2;
  241.       WAsmCode[0] = pOrder->Code | AdrMode;
  242.     }
  243.   }
  244. }
  245.  
  246. /* Adresse & schieben */
  247.  
  248. static void DecodeShiftAdr(Word Index)
  249. {
  250.   const AdrShiftOrder *pOrder = AdrShiftOrders + Index;
  251.  
  252.   if (ChkArgCnt(1, 3))
  253.   {
  254.     Boolean OK;
  255.     Word AdrWord;
  256.     tSymbolFlags Flags;
  257.  
  258.     if (DecodeAdr(&ArgStr[1], 1, 3, False))
  259.     {
  260.       if (ArgCnt < 2)
  261.       {
  262.         OK = True;
  263.         AdrWord = 0;
  264.         Flags = eSymbolFlag_None;
  265.       }
  266.       else
  267.       {
  268.         AdrWord = EvalStrIntExpressionWithFlags(&ArgStr[2], Int4, &OK, &Flags);
  269.         if (OK && mFirstPassUnknown(Flags))
  270.           AdrWord = 0;
  271.       }
  272.       if (OK)
  273.       {
  274.         if (pOrder->AllowShifts < AdrWord) WrError(ErrNum_InvShiftArg);
  275.         else
  276.         {
  277.           CodeLen = 1;
  278.           WAsmCode[0] = pOrder->Code | AdrMode | (AdrWord << 8);
  279.         }
  280.       }
  281.     }
  282.   }
  283. }
  284.  
  285. /* Ein/Ausgabe */
  286.  
  287. static void DecodeIN_OUT(Word Code)
  288. {
  289.   if (ChkArgCnt(2, 3))
  290.   {
  291.     if (DecodeAdr(&ArgStr[1], 2, 3, False))
  292.     {
  293.       tEvalResult EvalResult;
  294.       Word AdrWord = EvalStrIntExpressionWithResult(&ArgStr[2], Int4, &EvalResult);
  295.  
  296.       if (EvalResult.OK)
  297.       {
  298.         ChkSpace(SegIO, EvalResult.AddrSpaceMask);
  299.         CodeLen = 1;
  300.         WAsmCode[0] = Code | AdrMode | (AdrWord << 8);
  301.       }
  302.     }
  303.   }
  304. }
  305.  
  306. /* konstantes Argument */
  307.  
  308. static void DecodeImm(Word Index)
  309. {
  310.   const ImmOrder *pOrder = ImmOrders + Index;
  311.  
  312.   if (ChkArgCnt(1, (pOrder->Mask != 0xffff) ? 1 : 2))
  313.   {
  314.     tEvalResult EvalResult;
  315.     LongInt AdrLong = EvalStrIntExpressionWithResult(&ArgStr[1], Int32, &EvalResult);
  316.  
  317.     if (EvalResult.OK)
  318.     {
  319.       if (mFirstPassUnknown(EvalResult.Flags))
  320.         AdrLong &= pOrder->Mask;
  321.       if (pOrder->Mask == 0xffff)
  322.       {
  323.         if (ChkRange(AdrLong, -32768, 65535))
  324.         {
  325.           Word AdrWord = 0;
  326.  
  327.           EvalResult.OK = True;
  328.           if (ArgCnt == 2)
  329.           {
  330.             AdrWord = EvalStrIntExpressionWithResult(&ArgStr[2], Int4, &EvalResult);
  331.             if (EvalResult.OK && mFirstPassUnknown(EvalResult.Flags))
  332.              AdrWord = 0;
  333.           }
  334.           if (EvalResult.OK)
  335.           {
  336.             CodeLen = 2;
  337.             WAsmCode[0] = pOrder->Code | (AdrWord << 8);
  338.             WAsmCode[1] = AdrLong;
  339.           }
  340.         }
  341.       }
  342.       else if (ChkRange(AdrLong, pOrder->Min, pOrder->Max))
  343.       {
  344.         CodeLen = 1;
  345.         WAsmCode[0] = pOrder->Code | (AdrLong & pOrder->Mask);
  346.       }
  347.     }
  348.   }
  349. }
  350.  
  351. /* mit Hilfsregistern */
  352.  
  353. static void DecodeLARP(Word Code)
  354. {
  355.   UNUSED(Code);
  356.  
  357.   if (ChkArgCnt(1, 1))
  358.   {
  359.     Boolean OK;
  360.     Word AdrWord = EvalARExpression(&ArgStr[1], &OK);
  361.  
  362.     if (OK)
  363.     {
  364.       CodeLen = 1;
  365.       WAsmCode[0] = 0x5588 | AdrWord;
  366.     }
  367.   }
  368. }
  369.  
  370. static void DecodeLAR_SAR(Word Code)
  371. {
  372.   if (ChkArgCnt(2, 3))
  373.   {
  374.     Boolean OK;
  375.     Word AdrWord = EvalARExpression(&ArgStr[1], &OK);
  376.  
  377.     if (OK)
  378.     {
  379.       if (DecodeAdr(&ArgStr[2], 2, 3, False))
  380.       {
  381.         CodeLen = 1;
  382.         WAsmCode[0] = Code | AdrMode | (AdrWord << 8);
  383.       }
  384.     }
  385.   }
  386. }
  387.  
  388. static void DecodeLARK(Word Code)
  389. {
  390.   UNUSED(Code);
  391.  
  392.   if (ChkArgCnt(2, 2))
  393.   {
  394.     Boolean OK;
  395.     Word AdrWord = EvalARExpression(&ArgStr[1], &OK);
  396.  
  397.     if (OK)
  398.     {
  399.       WAsmCode[0] = EvalStrIntExpression(&ArgStr[2], Int8, &OK) & 0xff;
  400.       if (OK)
  401.       {
  402.         CodeLen = 1;
  403.         WAsmCode[0] |= 0xc000 | (AdrWord << 8);
  404.       }
  405.     }
  406.   }
  407. }
  408.  
  409. static void DecodeLRLK(Word Code)
  410. {
  411.   UNUSED(Code);
  412.  
  413.   if (ChkArgCnt(2, 2))
  414.   {
  415.     Boolean OK;
  416.     Word AdrWord = EvalARExpression(&ArgStr[1], &OK);
  417.  
  418.     if (OK)
  419.     {
  420.       WAsmCode[1] = EvalStrIntExpression(&ArgStr[2], Int16, &OK);
  421.       if (OK)
  422.       {
  423.         CodeLen = 2;
  424.         WAsmCode[0] = 0xd000 | (AdrWord << 8);
  425.       }
  426.     }
  427.   }
  428. }
  429.  
  430. static void DecodeLDPK(Word Code)
  431. {
  432.   UNUSED(Code);
  433.  
  434.   if (ChkArgCnt(1, 1))
  435.   {
  436.     tEvalResult EvalResult;
  437.  
  438.     WAsmCode[0] = EvalStrIntExpressionWithResult(&ArgStr[1], UInt16, &EvalResult);
  439.     if (EvalResult.OK)
  440.     {
  441.       if (WAsmCode[0] < 0x1ff)
  442.         WAsmCode[0] |= 0xc800;
  443.       else
  444.       {
  445.         ChkSpace(SegData, EvalResult.AddrSpaceMask);
  446.         WAsmCode[0] = ((WAsmCode[0] >> 7) & 0x1ff) | 0xc800;
  447.       }
  448.       CodeLen = 1;
  449.     }
  450.   }
  451. }
  452.  
  453. static void DecodeNORM(Word Code)
  454. {
  455.   UNUSED(Code);
  456.  
  457.   if (ChkArgCnt(1, 1))
  458.   {
  459.     if (DecodeAdr(&ArgStr[1], 1, 2, False))
  460.     {
  461.       if (AdrMode < 0x80) WrError(ErrNum_InvAddrMode);
  462.       else
  463.       {
  464.         CodeLen = 1;
  465.         WAsmCode[0] = 0xce82 | (AdrMode & 0x70);
  466.       }
  467.     }
  468.   }
  469. }
  470.  
  471. static void DecodePORT(Word Code)
  472. {
  473.   UNUSED(Code);
  474.  
  475.   CodeEquate(SegIO, 0, 15);
  476. }
  477.  
  478. /* ---------------------------------------------------------------------- */
  479.  
  480. static void AddFixed(const char *NName, Word NCode)
  481. {
  482.   AddInstTable(InstTable, NName, NCode, DecodeFixed);
  483. }
  484.  
  485. static void AddJmp(const char *NName, Word NCode)
  486. {
  487.   AddInstTable(InstTable, NName, NCode, DecodeJmp);
  488. }
  489.  
  490. static void AddAdr(const char *NName, Word NCode, Boolean NMust1)
  491. {
  492.   order_array_rsv_end(AdrOrders, AdrOrder);
  493.   AdrOrders[InstrZ].Code = NCode;
  494.   AdrOrders[InstrZ].Must1 = NMust1;
  495.   AddInstTable(InstTable, NName, InstrZ++, DecodeAdrInst);
  496. }
  497.  
  498. static void Add2ndAdr(const char *NName, Word NCode, Boolean NMust1)
  499. {
  500.   order_array_rsv_end(Adr2ndAdrOrders, AdrOrder);
  501.   Adr2ndAdrOrders[InstrZ].Code = NCode;
  502.   Adr2ndAdrOrders[InstrZ].Must1 = NMust1;
  503.   AddInstTable(InstTable, NName, InstrZ++, Decode2ndAdr);
  504. }
  505.  
  506. static void AddShiftAdr(const char *NName, Word NCode, Word nallow)
  507. {
  508.   order_array_rsv_end(AdrShiftOrders, AdrShiftOrder);
  509.   AdrShiftOrders[InstrZ].Code = NCode;
  510.   AdrShiftOrders[InstrZ].AllowShifts = nallow;
  511.   AddInstTable(InstTable, NName, InstrZ++, DecodeShiftAdr);
  512. }
  513.  
  514. static void AddImm(const char *NName, Word NCode, Integer NMin, Integer NMax, Word NMask)
  515. {
  516.   order_array_rsv_end(ImmOrders, ImmOrder);
  517.   ImmOrders[InstrZ].Code = NCode;
  518.   ImmOrders[InstrZ].Min = NMin;
  519.   ImmOrders[InstrZ].Max = NMax;
  520.   ImmOrders[InstrZ].Mask = NMask;
  521.   AddInstTable(InstTable, NName, InstrZ++, DecodeImm);
  522. }
  523.  
  524. static void AddAdrMode(const char *NName, Word NMode)
  525. {
  526.   order_array_rsv_end(AdrModes, tAdrMode);
  527.   AdrModes[InstrZ].Name = NName;
  528.   AdrModes[InstrZ++].Mode = NMode;
  529. }
  530.  
  531. static void InitFields(void)
  532. {
  533.   InstTable = CreateInstTable(307);
  534.   AddInstTable(InstTable, "CNFD", 0, DecodeCNFD);
  535.   AddInstTable(InstTable, "CNFP", 0, DecodeCNFP);
  536.   AddInstTable(InstTable, "CONF", 0, DecodeCONF);
  537.   AddInstTable(InstTable, "OUT", 0xe000, DecodeIN_OUT);
  538.   AddInstTable(InstTable, "IN", 0x8000, DecodeIN_OUT);
  539.   AddInstTable(InstTable, "LARP", 0, DecodeLARP);
  540.   AddInstTable(InstTable, "LAR", 0x3000, DecodeLAR_SAR);
  541.   AddInstTable(InstTable, "SAR", 0x7000, DecodeLAR_SAR);
  542.   AddInstTable(InstTable, "LARK", 0, DecodeLARK);
  543.   AddInstTable(InstTable, "LRLK", 0, DecodeLRLK);
  544.   AddInstTable(InstTable, "LDPK", 0, DecodeLDPK);
  545.   AddInstTable(InstTable, "NORM", 0, DecodeNORM);
  546.   AddInstTable(InstTable, "PORT", 0, DecodePORT);
  547.  
  548.   AddFixed("ABS",    0xce1b); AddFixed("CMPL",   0xce27);
  549.   AddFixed("NEG",    0xce23); AddFixed("ROL",    0xce34);
  550.   AddFixed("ROR",    0xce35); AddFixed("SFL",    0xce18);
  551.   AddFixed("SFR",    0xce19); AddFixed("ZAC",    0xca00);
  552.   AddFixed("APAC",   0xce15); AddFixed("PAC",    0xce14);
  553.   AddFixed("SPAC",   0xce16); AddFixed("BACC",   0xce25);
  554.   AddFixed("CALA",   0xce24); AddFixed("RET",    0xce26);
  555.   AddFixed("RFSM",   0xce36); AddFixed("RTXM",   0xce20);
  556.   AddFixed("RXF",    0xce0c); AddFixed("SFSM",   0xce37);
  557.   AddFixed("STXM",   0xce21); AddFixed("SXF",    0xce0d);
  558.   AddFixed("DINT",   0xce01); AddFixed("EINT",   0xce00);
  559.   AddFixed("IDLE",   0xce1f); AddFixed("NOP",    0x5500);
  560.   AddFixed("POP",    0xce1d); AddFixed("PUSH",   0xce1c);
  561.   AddFixed("RC",     0xce30); AddFixed("RHM",    0xce38);
  562.   AddFixed("ROVM",   0xce02); AddFixed("RSXM",   0xce06);
  563.   AddFixed("RTC",    0xce32); AddFixed("SC",     0xce31);
  564.   AddFixed("SHM",    0xce39); AddFixed("SOVM",   0xce03);
  565.   AddFixed("SSXM",   0xce07); AddFixed("STC",    0xce33);
  566.   AddFixed("TRAP",   0xce1e);
  567.  
  568.   AddJmp("B",      0xff80); AddJmp("BANZ",   0xfb80);
  569.   AddJmp("BBNZ",   0xf980); AddJmp("BBZ",    0xf880);
  570.   AddJmp("BC",     0x5e80); AddJmp("BGEZ",   0xf480);
  571.   AddJmp("BGZ",    0xf180); AddJmp("BIOZ",   0xfa80);
  572.   AddJmp("BLEZ",   0xf280); AddJmp("BLZ",    0xf380);
  573.   AddJmp("BNC",    0x5f80); AddJmp("BNV",    0xf780);
  574.   AddJmp("BNZ",    0xf580); AddJmp("BV",     0xf080);
  575.   AddJmp("BZ",     0xf680); AddJmp("CALL",   0xfe80);
  576.  
  577.   InstrZ = 0;
  578.   AddAdr("ADDC",   0x4300, False); AddAdr("ADDH",   0x4800, False);
  579.   AddAdr("ADDS",   0x4900, False); AddAdr("ADDT",   0x4a00, False);
  580.   AddAdr("AND",    0x4e00, False); AddAdr("LACT",   0x4200, False);
  581.   AddAdr("OR",     0x4d00, False); AddAdr("SUBB",   0x4f00, False);
  582.   AddAdr("SUBC",   0x4700, False); AddAdr("SUBH",   0x4400, False);
  583.   AddAdr("SUBS",   0x4500, False); AddAdr("SUBT",   0x4600, False);
  584.   AddAdr("XOR",    0x4c00, False); AddAdr("ZALH",   0x4000, False);
  585.   AddAdr("ZALR",   0x7b00, False); AddAdr("ZALS",   0x4100, False);
  586.   AddAdr("LDP",    0x5200, False); AddAdr("MAR",    0x5500, False);
  587.   AddAdr("LPH",    0x5300, False); AddAdr("LT",     0x3c00, False);
  588.   AddAdr("LTA",    0x3d00, False); AddAdr("LTD",    0x3f00, False);
  589.   AddAdr("LTP",    0x3e00, False); AddAdr("LTS",    0x5b00, False);
  590.   AddAdr("MPY",    0x3800, False); AddAdr("MPYA",   0x3a00, False);
  591.   AddAdr("MPYS",   0x3b00, False); AddAdr("MPYU",   0xcf00, False);
  592.   AddAdr("SPH",    0x7d00, False); AddAdr("SPL",    0x7c00, False);
  593.   AddAdr("SQRA",   0x3900, False); AddAdr("SQRS",   0x5a00, False);
  594.   AddAdr("DMOV",   0x5600, False); AddAdr("TBLR",   0x5800, False);
  595.   AddAdr("TBLW",   0x5900, False); AddAdr("BITT",   0x5700, False);
  596.   AddAdr("LST",    0x5000, False); AddAdr("LST1",   0x5100, False);
  597.   AddAdr("POPD",   0x7a00, False); AddAdr("PSHD",   0x5400, False);
  598.   AddAdr("RPT",    0x4b00, False); AddAdr("SST",    0x7800, True);
  599.   AddAdr("SST1",   0x7900, True);
  600.  
  601.   InstrZ = 0;
  602.   Add2ndAdr("BLKD",   0xfd00, False); Add2ndAdr("BLKP",   0xfc00, False);
  603.   Add2ndAdr("MAC",    0x5d00, False); Add2ndAdr("MACD",   0x5c00, False);
  604.  
  605.   InstrZ = 0;
  606.   AddShiftAdr("ADD",    0x0000, 0xf); AddShiftAdr("LAC",    0x2000, 0xf);
  607.   AddShiftAdr("SACH",   0x6800, 0x7); AddShiftAdr("SACL",   0x6000, 0x7);
  608.   AddShiftAdr("SUB",    0x1000, 0xf); AddShiftAdr("BIT",    0x9000, 0xf);
  609.  
  610.   InstrZ = 0;
  611.   AddImm("ADDK",   0xcc00,     0,    255,   0xff);
  612.   AddImm("LACK",   0xca00,     0,    255,   0xff);
  613.   AddImm("SUBK",   0xcd00,     0,    255,   0xff);
  614.   AddImm("ADRK",   0x7e00,     0,    255,   0xff);
  615.   AddImm("SBRK",   0x7f00,     0,    255,   0xff);
  616.   AddImm("RPTK",   0xcb00,     0,    255,   0xff);
  617.   AddImm("MPYK",   0xa000, -4096,   4095, 0x1fff);
  618.   AddImm("SPM",    0xce08,     0,      3,    0x3);
  619.   AddImm("CMPR",   0xce50,     0,      3,    0x3);
  620.   AddImm("FORT",   0xce0e,     0,      1,    0x1);
  621.   AddImm("ADLK",   0xd002,     0, 0x7fff, 0xffff);
  622.   AddImm("ANDK",   0xd004,     0, 0x7fff, 0xffff);
  623.   AddImm("LALK",   0xd001,     0, 0x7fff, 0xffff);
  624.   AddImm("ORK",    0xd005,     0, 0x7fff, 0xffff);
  625.   AddImm("SBLK",   0xd003,     0, 0x7fff, 0xffff);
  626.   AddImm("XORK",   0xd006,     0, 0x7fff, 0xffff);
  627.  
  628.   InstrZ = 0;
  629.   AddAdrMode( "*-",     0x90 ); AddAdrMode( "*+",     0xa0 );
  630.   AddAdrMode( "*BR0-",  0xc0 ); AddAdrMode( "*0-",    0xd0 );
  631.   AddAdrMode( "*AR0-",  0xd0 ); AddAdrMode( "*0+",    0xe0 );
  632.   AddAdrMode( "*AR0+",  0xe0 ); AddAdrMode( "*BR0+",  0xf0 );
  633.   AddAdrMode( "*",      0x80 ); AddAdrMode( NULL,     0);
  634. }
  635.  
  636. static void DeinitFields(void)
  637. {
  638.   DestroyInstTable(InstTable);
  639.  
  640.   order_array_free(AdrOrders);
  641.   order_array_free(Adr2ndAdrOrders);
  642.   order_array_free(AdrShiftOrders);
  643.   order_array_free(ImmOrders);
  644.   order_array_free(AdrModes);
  645. }
  646.  
  647. /* ---------------------------------------------------------------------- */
  648.  
  649. static void MakeCode_3202x(void)
  650. {
  651.   CodeLen = 0;
  652.   DontPrint = False;
  653.  
  654.   /* zu ignorierendes */
  655.  
  656.   if (Memo(""))
  657.     return;
  658.  
  659.   /* Pseudoanweisungen */
  660.  
  661.   if (DecodeTIPseudo())
  662.     return;
  663.  
  664.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  665.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  666. }
  667.  
  668. /* ---------------------------------------------------------------------- */
  669.  
  670. static Boolean IsDef_3202x(void)
  671. {
  672.   return Memo("PORT") || IsTIDef();
  673. }
  674.  
  675. /* ---------------------------------------------------------------------- */
  676.  
  677. static void SwitchFrom_3202x(void)
  678. {
  679.   DeinitFields();
  680. }
  681.  
  682. /* ---------------------------------------------------------------------- */
  683.  
  684. static void SwitchTo_3202x(void)
  685. {
  686.   TurnWords = False;
  687.   SetIntConstMode(eIntConstModeIntel);
  688.  
  689.   PCSymbol = "$";
  690.   HeaderID = 0x75;
  691.   NOPCode = 0x5500;
  692.   DivideChars = ",";
  693.   HasAttrs = False;
  694.  
  695.   ValidSegs = (1 << SegCode) | (1 << SegData) | (1 << SegIO);
  696.   Grans[SegCode] = 2; ListGrans[SegCode] = 2; SegInits[SegCode] = 0;
  697.         SegLimits[SegCode] = 0xffff;
  698.   Grans[SegData] = 2; ListGrans[SegData] = 2; SegInits[SegData] = 0;
  699.         SegLimits[SegData] = 0xffff;
  700.   Grans[SegIO  ] = 2; ListGrans[SegIO  ] = 2; SegInits[SegIO  ] = 0;
  701.         SegLimits[SegIO  ] = 0xf;
  702.  
  703.   MakeCode = MakeCode_3202x;
  704.   IsDef = IsDef_3202x; SwitchFrom = SwitchFrom_3202x;
  705.   InitFields();
  706. }
  707.  
  708. /* ---------------------------------------------------------------------- */
  709.  
  710. void code3202x_init(void)
  711. {
  712.   CPU32025 = AddCPU("320C25", SwitchTo_3202x);
  713.   CPU32026 = AddCPU("320C26", SwitchTo_3202x);
  714.   CPU32028 = AddCPU("320C28", SwitchTo_3202x);
  715.  
  716.   AddCopyright("TMS320C2x-Generator (C) 1994/96 Thomas Sailer");
  717. }
  718.