Subversion Repositories pentevo

Rev

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

  1. /* codevector.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Codegenerator Atari Asteroids Vector Processor                            */
  8. /*                                                                           */
  9. /*****************************************************************************/
  10.  
  11. #include "stdinc.h"
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include <ctype.h>
  15.  
  16. #include "nls.h"
  17. #include "strutil.h"
  18. #include "bpemu.h"
  19. #include "asmdef.h"
  20. #include "asmsub.h"
  21. #include "asmpars.h"
  22. #include "asmitree.h"
  23. #include "codepseudo.h"
  24. #include "intpseudo.h"
  25. #include "codevars.h"
  26. #include "headids.h"
  27. #include "errmsg.h"
  28. #include "codepseudo.h"
  29.  
  30. #include "codevector.h"
  31.  
  32. static CPUVar CPUVector;
  33.  
  34. /*--------------------------------------------------------------------------
  35.  * Operand Parsers
  36.  *--------------------------------------------------------------------------*/
  37.  
  38. static Boolean Is4(const char *pAsc, Word *pResult)
  39. {
  40.   *pResult = 0;
  41.  
  42.   for (; *pAsc; pAsc++)
  43.   {
  44.     if (!isdigit(*pAsc))
  45.       return False;
  46.     *pResult = (*pResult * 10) + (*pAsc - '0');
  47.   }
  48.   return (*pResult <= 15);
  49. }
  50.  
  51. static Boolean DecodeScale(tStrComp *pArg, Word *pResult)
  52. {
  53.   Boolean OK;
  54.  
  55.   KillPrefBlanksStrComp(pArg);
  56.   KillPostBlanksStrComp(pArg);
  57.  
  58.   if ((toupper(*pArg->str.p_str) == 'S') && (Is4(pArg->str.p_str + 1, pResult)))
  59.     return True;
  60.  
  61.   *pResult = EvalStrIntExpression(pArg, UInt4, &OK);
  62.   return OK;
  63. }
  64.  
  65. static Boolean DecodeBright(tStrComp *pArg, Word *pResult)
  66. {
  67.   Boolean OK;
  68.  
  69.   KillPrefBlanksStrComp(pArg);
  70.   KillPostBlanksStrComp(pArg);
  71.  
  72.   if ((toupper(*pArg->str.p_str) == 'Z') && (Is4(pArg->str.p_str + 1, pResult)))
  73.     return True;
  74.  
  75.   *pResult = EvalStrIntExpression(pArg, UInt4, &OK);
  76.   return OK;
  77. }
  78.  
  79. static Boolean DecodeSign(tStrComp *pArg, Word *pResult, Boolean Signed)
  80. {
  81.   LongInt Val;
  82.   Boolean OK;
  83.   tSymbolFlags Flags;
  84.  
  85.   Val = EvalStrIntExpressionWithFlags(pArg, SInt16, &OK, &Flags);
  86.   if (!OK)
  87.     return False;
  88.  
  89.   if (mFirstPassUnknown(Flags))
  90.     Val = 0;
  91.  
  92.   if (!ChkRange(Val, Signed ? -1023 : 0, 1023))
  93.     return False;
  94.  
  95.   if ((Signed) && (Val < 0))
  96.     *pResult = (-Val) | (1 << 10);
  97.   else
  98.     *pResult = Val;
  99.   return True;
  100. }
  101.  
  102. static Boolean DecodeXY(tStrComp *pArg, Word *pX, Word *pY, Boolean Signed)
  103. {
  104.   tStrComp Tot, Left, Right;
  105.   char *pEnd, *pPos;
  106.  
  107.   KillPrefBlanksStrComp(pArg);
  108.   KillPostBlanksStrComp(pArg);
  109.  
  110.   if (*pArg->str.p_str != '(')
  111.   {
  112.     WrError(ErrNum_BrackErr);
  113.     return False;
  114.   }
  115.   StrCompRefRight(&Tot, pArg, 1);
  116.  
  117.   pEnd = Tot.str.p_str + strlen(Tot.str.p_str) - 1;
  118.   if (*pEnd != ')')
  119.   {
  120.     WrError(ErrNum_BrackErr);
  121.     return False;
  122.   }
  123.   *pEnd = '\0';
  124.   Tot.Pos.Len--;
  125.  
  126.   pPos = strchr(Tot.str.p_str, ',');
  127.   if (!pPos)
  128.   {
  129.     WrError(ErrNum_UseLessAttr);
  130.     return False;
  131.   }
  132.   StrCompSplitRef(&Left, &Right, &Tot, pPos);
  133.  
  134.   if (!DecodeSign(&Left, pX, Signed))
  135.     return False;
  136.   if (!DecodeSign(&Right, pY, Signed))
  137.     return False;
  138.  
  139.   return True;
  140. }
  141.  
  142. /*--------------------------------------------------------------------------
  143.  * Code Handlers
  144.  *--------------------------------------------------------------------------*/
  145.  
  146. static void DecodeFixed(Word Index)
  147. {
  148.   if (ChkArgCnt(0, 0))
  149.   {
  150.     WAsmCode[0] = Index;
  151.     CodeLen = 1;
  152.   }
  153. }
  154.  
  155. static void DecodeJmp(Word Index)
  156. {
  157.   Boolean OK;
  158.  
  159.   if (ChkArgCnt(1, 1))
  160.   {
  161.     WAsmCode[0] = Index | EvalStrIntExpression(&ArgStr[1], UInt12, &OK);
  162.     if (OK)
  163.       CodeLen = 1;
  164.   }
  165. }
  166.  
  167. static void DecodeLAbs(Word Index)
  168. {
  169.   Word X, Y, Scale;
  170.  
  171.   UNUSED(Index);
  172.  
  173.   if (!ChkArgCnt(2, 2));
  174.   else if (!DecodeXY(&ArgStr[1], &X, &Y, False));
  175.   else if (!DecodeScale(&ArgStr[2], &Scale));
  176.   else
  177.   {
  178.     WAsmCode[0] = 0xa000 | Y;
  179.     WAsmCode[1] = (Scale << 12) | X;
  180.     CodeLen = 2;
  181.   }
  182. }
  183.  
  184. static void DecodeVctr(Word Index)
  185. {
  186.   Word X, Y, Scale, Bright;
  187.  
  188.   UNUSED(Index);
  189.  
  190.   if (!ChkArgCnt(3, 3));
  191.   else if (!DecodeXY(&ArgStr[1], &X, &Y, True));
  192.   else if (!DecodeScale(&ArgStr[2], &Scale));
  193.   else if (!DecodeBright(&ArgStr[3], &Bright));
  194.   else
  195.   {
  196.     WAsmCode[0] = (Scale << 12) | Y;
  197.     WAsmCode[1] = (Bright << 12) | X;
  198.     CodeLen = 2;
  199.   }
  200. }
  201.  
  202. static void DecodeSVec(Word Index)
  203. {
  204.   Word X, Y, Scale, Bright;
  205.  
  206.   UNUSED(Index);
  207.  
  208.   if (!ChkArgCnt(3, 3));
  209.   else if (!DecodeXY(&ArgStr[1], &X, &Y, True));
  210.   else if ((X & 0xff) || (Y & 0xff)) WrError(ErrNum_NotAligned);
  211.   else if (!DecodeScale(&ArgStr[2], &Scale));
  212.   else if (Scale > 3) WrError(ErrNum_OverRange);
  213.   else if (!DecodeBright(&ArgStr[3], &Bright));
  214.   else
  215.   {
  216.     WAsmCode[0] = 0xf000
  217.                 | (Bright << 4)
  218.                 | ((X >> 8) & 3)
  219.                 | (Y & 0x300)
  220.                 | ((Scale & 1) << 11)
  221.                 | ((Scale & 2) << 2);
  222.     CodeLen = 1;
  223.   }
  224. }
  225.  
  226. /*--------------------------------------------------------------------------
  227.  * Instruction Table Handling
  228.  *--------------------------------------------------------------------------*/
  229.  
  230. static void InitFields(void)
  231. {
  232.   InstTable = CreateInstTable(17);
  233.  
  234.   add_null_pseudo(InstTable);
  235.  
  236.   AddInstTable(InstTable, "RTSL", 0xd000, DecodeFixed);
  237.   AddInstTable(InstTable, "HALT", 0xb0b0, DecodeFixed);
  238.  
  239.   AddInstTable(InstTable, "JMPL", 0xe000, DecodeJmp);
  240.   AddInstTable(InstTable, "JSRL", 0xc000, DecodeJmp);
  241.  
  242.   AddInstTable(InstTable, "LABS", 0x0000, DecodeLAbs);
  243.   AddInstTable(InstTable, "VCTR", 0x0000, DecodeVctr);
  244.   AddInstTable(InstTable, "SVEC", 0x0000, DecodeSVec);
  245. }
  246.  
  247. static void DeinitFields(void)
  248. {
  249.   DestroyInstTable(InstTable);
  250. }
  251.  
  252. /*--------------------------------------------------------------------------
  253.  * Semipublic Functions
  254.  *--------------------------------------------------------------------------*/
  255.  
  256. static Boolean IsDef_Vector(void)
  257. {
  258.   return FALSE;
  259. }
  260.  
  261. static void SwitchFrom_Vector(void)
  262. {
  263.   DeinitFields();
  264. }
  265.  
  266. static void MakeCode_Vector(void)
  267. {
  268.   if (!LookupInstTable(InstTable, OpPart.str.p_str))
  269.     WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
  270. }
  271.  
  272. static void SwitchTo_Vector(void)
  273. {
  274.   const TFamilyDescr *FoundDescr;
  275.  
  276.   FoundDescr = FindFamilyByName("ATARI_VECTOR");
  277.  
  278.   TurnWords = False;
  279.   SetIntConstMode(eIntConstModeMoto);
  280.  
  281.   PCSymbol = "$"; HeaderID = FoundDescr->Id;
  282.  
  283.   /* NOP = ??? */
  284.  
  285.   NOPCode = 0x00000;
  286.   DivideChars = ","; HasAttrs = False;
  287.  
  288.   ValidSegs = (1 << SegCode);
  289.   Grans[SegCode] = 2; ListGrans[SegCode] = 2; SegInits[SegCode] = 0;
  290.   SegLimits[SegCode] = 0xfff;
  291.  
  292.   MakeCode = MakeCode_Vector; IsDef = IsDef_Vector;
  293.   SwitchFrom = SwitchFrom_Vector; InitFields();
  294. }
  295.  
  296. /*--------------------------------------------------------------------------
  297.  * Initialization
  298.  *--------------------------------------------------------------------------*/
  299.  
  300. void codevector_init(void)
  301. {
  302.   CPUVector = AddCPU("ATARI_VECTOR", SwitchTo_Vector);
  303. }
  304.