Subversion Repositories pentevo

/* code65.c */

/*****************************************************************************/

/* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */

/*                                                                           */

/* AS                                                                        */

/*                                                                           */

/* Code Generator 65xx/MELPS740                                              */

/*                                                                           */

/*****************************************************************************/

#include "stdinc.h"

#include <string.h>

#include <ctype.h>

#include "bpemu.h"

#include "strutil.h"

#include "asmdef.h"

#include "asmpars.h"

#include "asmsub.h"

#include "asmitree.h"

#include "codepseudo.h"

#include "motpseudo.h"

#include "intpseudo.h"

#include "codevars.h"

#include "errmsg.h"

#include "code65.h"

/*---------------------------------------------------------------------------*/

enum

{

  ModZA    = 0,   /* aa */

  ModA     = 1,   /* aabb */

  ModZIX   = 2,   /* aa,X */

  ModIX    = 3,   /* aabb,X */

  ModZIY   = 4,   /* aa,Y */

  ModIY    = 5,   /* aabb,Y */

  ModIndIX = 6,   /* (aa,X) */

  ModIndOX = 7,   /* (aa),X */

  ModIndOY = 8,   /* (aa),Y */

  ModIndOZ = 9,   /* (aa),Z (65CE02-specific) */

  ModInd16 =10,   /* (aabb) */

  ModImm   =11,   /* #aa */

  ModAcc   =12,   /* A */

  ModNone  =13,   /* */

  ModInd8  =14,   /* (aa) */

  ModIndSPY=15,   /* (aa,SP),Y (65CE02-specific) */

  ModSpec = 16    /* \aabb */

};

typedef struct

{

  Word CPUFlag;

  Byte Code;

} FixedOrder;

typedef struct

{

  LongInt Codes[ModSpec + 1];

} NormOrder;

typedef struct

{

  Word CPUFlag;

  Byte CodeShort, CodeLong;

} CondOrder;

typedef struct

{

  ShortInt ErgMode;

  int AdrCnt;

  Byte AdrVals[2];

} tAdrResult;

/* NOTE: keep in the same order as in registration in code65_init()! */

#define M_6502      (1 << 0)

#define M_65SC02    (1 << 1)

#define M_65C02     (1 << 2)

#define M_65CE02    (1 << 3)

#define M_W65C02S   (1 << 4)

#define M_65C19     (1 << 5)

#define M_MELPS740  (1 << 6)

#define M_HUC6280   (1 << 7)

#define M_6502U     (1 << 8)

static Boolean This_CLI_SEI_Flag, This_ADC_SBC_Flag,

               Last_CLI_SEI_Flag, Last_ADC_SBC_Flag;

static FixedOrder *FixedOrders;

static NormOrder *NormOrders;

static CondOrder *CondOrders;

static CPUVar CPU6502, CPU65SC02, CPU65C02, CPU65CE02, CPUW65C02S, CPU65C19, CPUM740, CPUHUC6280, CPU6502U;

static LongInt SpecPage, RegB, MPR[8];

/*---------------------------------------------------------------------------*/

static unsigned ChkZero(const tStrComp *pArg, Byte *erg)

{

 if ((strlen(pArg->str.p_str) > 1) && ((*pArg->str.p_str == '<') || (*pArg->str.p_str == '>')))

 {

   *erg = Ord(*pArg->str.p_str == '<') + 1;

   return 1;

 }

 else

 {

   *erg = 0;

   return 0;

 }

}

static Boolean CPUAllowed(Word Flag)

{

  return (((Flag >> (MomCPU - CPU6502)) & 1) || False);

}

static void InsNOP(void)

{

  memmove(BAsmCode, BAsmCode + 1, CodeLen);

  CodeLen++;

  BAsmCode[0] = NOPCode;

}

static Boolean IsAllowed(LongInt Val)

{

  return (CPUAllowed(Val >> 8) && (Val != -1));

}

static void ChkZeroMode(tAdrResult *pResult, const NormOrder *pOrder, ShortInt ZeroMode)

{

  if (pOrder && (IsAllowed(pOrder->Codes[ZeroMode])))

  {

    pResult->ErgMode = ZeroMode;

    pResult->AdrCnt--;

  }

}

/*---------------------------------------------------------------------------*/

static Word EvalAddress(const tStrComp *pArg, IntType Type, Boolean *pOK)

{

  /* for the HUC6280, check if the address is within one of the selected pages */

  if (MomCPU == CPUHUC6280)

  {

    Word Page;

    LongWord AbsAddress;

    tSymbolFlags Flags;

    /* get the absolute address */

    AbsAddress = EvalStrIntExpressionWithFlags(pArg, UInt21, pOK, &Flags);

    if (!*pOK)

      return 0;

    /* within one of the 8K pages? */

    for (Page = 0; Page < 8; Page++)

      if ((LargeInt)((AbsAddress >> 13) & 255) == MPR[Page])

        break;

    if (Page >= 8)

    {

      WrError(ErrNum_InAccPage);

      AbsAddress &= 0x1fff;

    }

    else

      AbsAddress = (AbsAddress & 0x1fff) | (Page << 13);

    /* short address requested? */

    if ((Type != UInt16) && (Type != Int16) && Hi(AbsAddress))

    {

      if (mFirstPassUnknown(Flags))

        AbsAddress &= 0xff;

      else

      {

        *pOK = False;

        WrError(ErrNum_OverRange);

      }

    }

    return AbsAddress;

  }

  /* for the 65CE02, regard basepage register */

  else if (MomCPU == CPU65CE02)

  {

    Word Address;

    tSymbolFlags Flags;

    /* alwys get a full 16 bit address */

    Address = EvalStrIntExpressionWithFlags(pArg, UInt16, pOK, &Flags);

    if (!*pOK)

      return 0;

    /* short address requested? */

    if ((Type != UInt16) && (Type != Int16))

    {

      if ((Hi(Address) != RegB) && !mFirstPassUnknown(Flags))

      {

        *pOK = False;

        WrError(ErrNum_OverRange);

      }

      if (*pOK)

        Address &= 0xff;

    }

    return Address;

  }

  else

    return EvalStrIntExpression(pArg, Type, pOK);

}

static Boolean IsBasePage(Byte Page)

{

  return (MomCPU == CPU65CE02) ? (Page == RegB) : !Page;

}

static void DecodeAdr(tAdrResult *pResult, const NormOrder *pOrder)

{

  Word AdrWord;

  Boolean ValOK;

  Byte ZeroMode;

  /* normale Anweisungen: Adressausdruck parsen */

  pResult->ErgMode = -1;

  if (ArgCnt == 0)

  {

    pResult->AdrCnt = 0;

    pResult->ErgMode = ModNone;

  }

  else if (ArgCnt == 1)

  {

    /* 1. Akkuadressierung */

    if (!as_strcasecmp(ArgStr[1].str.p_str, "A"))

    {

      pResult->AdrCnt = 0;

      pResult->ErgMode = ModAcc;

    }

    /* 2. immediate ? */

    else if (*ArgStr[1].str.p_str == '#')

    {

      IntType Type = Memo("PHW") ? Int16 : Int8;

      Word Value;

      Value = EvalStrIntExpressionOffs(&ArgStr[1], 1, Type, &ValOK);

      if (ValOK)

      {

        pResult->ErgMode = ModImm;

        pResult->AdrVals[0] = Lo(Value);

        pResult->AdrCnt = 1;

        if (Int16 == Type)

          pResult->AdrVals[pResult->AdrCnt++] = Hi(Value);

      }

    }

    /* 3. Special Page ? */

    else if (*ArgStr[1].str.p_str == '\\')

    {

      tSymbolFlags Flags;

      AdrWord = EvalStrIntExpressionOffsWithFlags(&ArgStr[1], 1, UInt16, &ValOK, &Flags);

      if (ValOK)

      {

        if (mFirstPassUnknown(Flags))

          AdrWord = (SpecPage << 8) | Lo(AdrWord);

        if (Hi(AdrWord) != SpecPage) WrError(ErrNum_UnderRange);

        else

        {

          pResult->ErgMode = ModSpec;

          pResult->AdrVals[0] = Lo(AdrWord);

          pResult->AdrCnt = 1;

        }

      }

    }

    /* 4. X-inner-indirekt ? */

    else if ((strlen(ArgStr[1].str.p_str) >= 5) && (!as_strcasecmp(ArgStr[1].str.p_str + strlen(ArgStr[1].str.p_str) - 3, ",X)")))

    {

      if (*ArgStr[1].str.p_str != '(') WrError(ErrNum_InvAddrMode);

      else

      {

        tStrComp AddrArg;

        StrCompRefRight(&AddrArg, &ArgStr[1], 1);

        StrCompShorten(&AddrArg, 3);

        StrCompIncRefLeft(&AddrArg, ChkZero(&AddrArg, &ZeroMode));

        if (Memo("JMP") || Memo("JSR"))

        {

          AdrWord = EvalAddress(&AddrArg, UInt16, &ValOK);

          if (ValOK)

          {

            pResult->AdrVals[0] = Lo(AdrWord);

            pResult->AdrVals[1] = Hi(AdrWord);

            pResult->ErgMode = ModIndIX;

            pResult->AdrCnt = 2;

          }

        }

        else

        {

          pResult->AdrVals[0] = EvalAddress(&AddrArg, UInt8, &ValOK);

          if (ValOK)

          {

            pResult->ErgMode = ModIndIX;

            pResult->AdrCnt = 1;

          }

        }

      }

    }

    else

    {

      /* 5. indirekt absolut ? */

      if (IsIndirect(ArgStr[1].str.p_str))

      {

        tStrComp AddrArg;

        StrCompRefRight(&AddrArg, &ArgStr[1], 1);

        StrCompShorten(&AddrArg, 1);

        StrCompIncRefLeft(&AddrArg, ChkZero(&AddrArg, &ZeroMode));

        if (ZeroMode == 2)

        {

          pResult->AdrVals[0] = EvalAddress(&AddrArg, UInt8, &ValOK);

          if (ValOK)

          {

            pResult->ErgMode = ModInd8;

            pResult->AdrCnt = 1;

          }

        }

        else

        {

          AdrWord = EvalAddress(&AddrArg, UInt16, &ValOK);

          if (ValOK)

          {

            pResult->ErgMode = ModInd16;

            pResult->AdrCnt = 2;

            pResult->AdrVals[0] = Lo(AdrWord);

            pResult->AdrVals[1] = Hi(AdrWord);

            if ((ZeroMode == 0) && IsBasePage(pResult->AdrVals[1]))

              ChkZeroMode(pResult, pOrder, ModInd8);

          }

        }

      }

      /* 6. absolut */

      else

      {

        tStrComp AddrArg;

        StrCompRefRight(&AddrArg, &ArgStr[1], ChkZero(&ArgStr[1], &ZeroMode));

        if (ZeroMode == 2)

        {

          pResult->AdrVals[0] = EvalAddress(&AddrArg, UInt8, &ValOK);

          if (ValOK)

          {

            pResult->ErgMode = ModZA;

            pResult->AdrCnt = 1;

          }

        }

        else

        {

          AdrWord = EvalAddress(&AddrArg, UInt16, &ValOK);

          if (ValOK)

          {

            pResult->ErgMode = ModA;

            pResult->AdrCnt = 2;

            pResult->AdrVals[0] = Lo(AdrWord);

            pResult->AdrVals[1] = Hi(AdrWord);

            if ((ZeroMode == 0) && IsBasePage(pResult->AdrVals[1]))

              ChkZeroMode(pResult, pOrder, ModZA);

          }

        }

      }

    }

  }

  else if (ArgCnt == 2)

  {

    Boolean Indir1 = IsIndirect(ArgStr[1].str.p_str);

    /* 7. stack-relative (65CE02-specific) ? */

    if (Indir1 && !as_strcasecmp(ArgStr[2].str.p_str, "Y") && (!as_strcasecmp(ArgStr[1].str.p_str + strlen(ArgStr[1].str.p_str) - 4, ",SP)")))

    {

      if (*ArgStr[1].str.p_str != '(') WrError(ErrNum_InvAddrMode);

      else

      {

        tStrComp DistArg;

        StrCompRefRight(&DistArg, &ArgStr[1], 1);

        StrCompShorten(&DistArg, 4);

        pResult->AdrVals[0] = EvalStrIntExpression(&DistArg, UInt8, &ValOK);

        if (ValOK)

        {

          pResult->ErgMode = ModIndSPY;

          pResult->AdrCnt = 1;

        }

      }

    }

    /* 8. X,Y,Z-outer-indirekt ? */

    else if (Indir1

          && (!as_strcasecmp(ArgStr[2].str.p_str, "X")

           || !as_strcasecmp(ArgStr[2].str.p_str, "Y")

           || !as_strcasecmp(ArgStr[2].str.p_str, "Z")))

    {

      int Mode = toupper(ArgStr[2].str.p_str[0]) - 'X';

      tStrComp AddrArg;

      StrCompRefRight(&AddrArg, &ArgStr[1], 1);

      StrCompShorten(&AddrArg, 1);

      StrCompIncRefLeft(&AddrArg, ChkZero(&AddrArg, &ZeroMode));

      pResult->AdrVals[0] = EvalAddress(&AddrArg, UInt8, &ValOK);

      if (ValOK)

      {

        pResult->ErgMode = ModIndOX + Mode;

        pResult->AdrCnt = 1;

      }

    }

    /* 9. X,Y-indiziert ? */

    else

    {

      tStrComp AddrArg;

      StrCompRefRight(&AddrArg, &ArgStr[1], ChkZero(&ArgStr[1], &ZeroMode));

      if (ZeroMode == 2)

      {

        pResult->AdrVals[0] = EvalAddress(&AddrArg, UInt8, &ValOK);

        if (ValOK)

        {

          pResult->AdrCnt = 1;

          if (!as_strcasecmp(ArgStr[2].str.p_str, "X"))

            pResult->ErgMode = ModZIX;

          else if (!as_strcasecmp(ArgStr[2].str.p_str, "Y"))

            pResult->ErgMode = ModZIY;

          else

            WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);

        }

      }

      else

      {

        AdrWord = EvalAddress(&AddrArg, Int16, &ValOK);

        if (ValOK)

        {

          pResult->AdrCnt = 2;

          pResult->AdrVals[0] = Lo(AdrWord);

          pResult->AdrVals[1] = Hi(AdrWord);

          if (!as_strcasecmp(ArgStr[2].str.p_str, "X"))

            pResult->ErgMode = ModIX;

          else if (!as_strcasecmp(ArgStr[2].str.p_str, "Y"))

            pResult->ErgMode = ModIY;

          else

            WrStrErrorPos(ErrNum_InvReg, &ArgStr[2]);

          if (pResult->ErgMode != -1)

          {

            if (IsBasePage(pResult->AdrVals[1]) && (ZeroMode == 0))

              ChkZeroMode(pResult, pOrder, (!as_strcasecmp(ArgStr[2].str.p_str, "X")) ? ModZIX : ModZIY);

          }

        }

      }

    }

  }

  else

    (void)ChkArgCnt(0, 2);

}

static int ImmStart(const char *pArg)

{

  return !!(*pArg == '#');

}

/*---------------------------------------------------------------------------*/

/* Anweisungen ohne Argument */

static void DecodeFixed(Word Index)

{

  const FixedOrder *pOrder = FixedOrders + Index;

  if (ChkArgCnt(0, 0)

   && (ChkExactCPUMask(pOrder->CPUFlag, CPU6502) >= 0))

  {

    CodeLen = 1;

    BAsmCode[0] = pOrder->Code;

    if (MomCPU == CPUM740)

    {

      if (Memo("PLP"))

        BAsmCode[CodeLen++] = NOPCode;

      if ((Last_ADC_SBC_Flag) && (Memo("SEC") || Memo("CLC") || Memo("CLD")))

        InsNOP();

    }

  }

}

/* All right, guys, this really makes tool developers' lives difficult: you can't

   seem to agree on whether BRK is a single or two byte instruction.  Always adding

   a NOP is obviously not what suits the majority of people, so I'll change it to

   an optional argument.  I hope this ends the discussion about BRK.  No, wait, it

   *will* end discussion because I will not answer any further requests about this

   instruction... */

static void DecodeBRK(Word Index)

{

  UNUSED(Index);

  if (ChkArgCnt(0, 1))

  {

    BAsmCode[0] = 0x00;

    if (ArgCnt > 0)

    {

      Boolean OK;

      BAsmCode[1] = EvalStrIntExpressionOffs(&ArgStr[1], !!(*ArgStr[1].str.p_str == '#'), Int8, &OK);

      if (OK)

        CodeLen = 2;

    }

    else

      CodeLen = 1;

  }

}

static void DecodeSEB_CLB(Word Code)

{

  if (ChkArgCnt(2, 2)

   && ChkExactCPU(CPUM740))

  {

    Boolean ValOK;

    Byte BitNo = EvalStrIntExpression(&ArgStr[1], UInt3, &ValOK);

    if (ValOK)

    {

      BAsmCode[0] = Code + (BitNo << 5);

      if (!as_strcasecmp(ArgStr[2].str.p_str, "A"))

        CodeLen = 1;

      else

      {

        BAsmCode[1] = EvalStrIntExpression(&ArgStr[2], UInt8, &ValOK);

        if (ValOK)

        {

          CodeLen = 2;

          BAsmCode[0] += 4;

        }

      }

    }

  }

}

static void DecodeBBC_BBS(Word Code)

{

  Boolean ValOK;

  tSymbolFlags Flags;

  int b;

  if (ChkArgCnt(3, 3)

   && ChkExactCPU(CPUM740))

  {

    BAsmCode[0] = EvalStrIntExpression(&ArgStr[1], UInt3, &ValOK);

    if (ValOK)

    {

      BAsmCode[0] = (BAsmCode[0] << 5) + Code;

      b = (as_strcasecmp(ArgStr[2].str.p_str, "A") != 0);

      if (!b)

        ValOK = True;

      else

      {

        BAsmCode[0] += 4;

        BAsmCode[1] = EvalStrIntExpression(&ArgStr[2], UInt8, &ValOK);

      }

      if (ValOK)

      {

        Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[3], Int16, &ValOK, &Flags) - (EProgCounter() + 2 + Ord(b) + Ord(Last_CLI_SEI_Flag));

        if (ValOK)

        {

          if (((AdrInt > 127) || (AdrInt < -128)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);

          else

          {

            CodeLen = 2 + Ord(b);

            BAsmCode[CodeLen - 1] = AdrInt & 0xff;

            if (Last_CLI_SEI_Flag)

              InsNOP();

          }

        }

      }

    }

  }

}

static void DecodeBBR_BBS(Word Code)

{

  Boolean ValOK;

  if (ChkArgCnt(2, 2)

   && (ChkExactCPUMask(M_65C02 | M_65CE02 | M_W65C02S | M_65C19 | M_HUC6280, CPU6502) >= 0))

  {

    Byte ForceSize;

    unsigned Offset = ChkZero(&ArgStr[1], &ForceSize);

    if (ForceSize == 1) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);

    else

    {

      BAsmCode[1] = EvalStrIntExpressionOffs(&ArgStr[1], Offset, UInt8, &ValOK);

      if (ValOK)

      {

        Integer AdrInt;

        tSymbolFlags Flags;

        BAsmCode[0] = Code;

        AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[2], UInt16, &ValOK, &Flags) - (EProgCounter() + 3);

        if (ValOK)

        {

          if (((AdrInt > 127) || (AdrInt < -128)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);

          else

          {

            CodeLen = 3;

            BAsmCode[2] = AdrInt & 0xff;

          }

        }

      }

    }

  }

}

static void DecodeRMB_SMB(Word Code)

{

  if (ChkArgCnt(1, 1)

   && (ChkExactCPUMask(M_65C02 | M_65CE02 | M_W65C02S | M_65C19 | M_HUC6280, CPU6502) >= 0))

  {

    Byte ForceSize;

    unsigned Offset = ChkZero(&ArgStr[1], &ForceSize);

    if (ForceSize == 1) WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[1]);

    else

    {

      Boolean ValOK;

      BAsmCode[1] = EvalStrIntExpressionOffs(&ArgStr[1], Offset, UInt8, &ValOK);

      if (ValOK)

      {

        BAsmCode[0] = Code;

        CodeLen = 2;

      }

    }

  }

}

static void DecodeRBA_SBA(Word Code)

{

  if (ChkArgCnt(2, 2)

   && ChkExactCPU(CPU65C19))

  {

    Boolean OK;

    Word Addr;

    Addr = EvalStrIntExpression(&ArgStr[1], UInt16, &OK);

    if (OK)

    {

      BAsmCode[3] = EvalStrIntExpressionOffs(&ArgStr[2], ImmStart(ArgStr[2].str.p_str), UInt8, &OK);

      if (OK)

      {

        BAsmCode[0] = Code;

        BAsmCode[1] = Lo(Addr);

        BAsmCode[2] = Hi(Addr);

        CodeLen = 4;

      }

    }

  }

}

static void DecodeBAR_BAS(Word Code)

{

  if (ChkArgCnt(3, 3)

   && ChkExactCPU(CPU65C19))

  {

    Boolean OK;

    Word Addr;

    Addr = EvalStrIntExpression(&ArgStr[1], UInt16, &OK);

    if (OK)

    {

      BAsmCode[3] = EvalStrIntExpressionOffs(&ArgStr[2], ImmStart(ArgStr[2].str.p_str), UInt8, &OK);

      if (OK)

      {

        tSymbolFlags Flags;

        Integer Dist = EvalStrIntExpressionWithFlags(&ArgStr[3], UInt16, &OK, &Flags) - (EProgCounter() + 5);

        if (OK)

        {

          if (((Dist > 127) || (Dist < -128)) && !mSymbolQuestionable(Flags)) WrError(ErrNum_JmpDistTooBig);

          else

          {

            BAsmCode[0] = Code;

            BAsmCode[1] = Lo(Addr);

            BAsmCode[2] = Hi(Addr);

            BAsmCode[4] = Dist & 0xff;

            CodeLen = 5;

          }

        }

      }

    }

  }

}

static void DecodeSTI(Word Code)

{

  UNUSED(Code);

  if (ChkArgCnt(2, 2)

   && ChkExactCPU(CPU65C19))

  {

    Boolean OK;

    BAsmCode[1] = EvalStrIntExpression(&ArgStr[1], UInt8, &OK);

    if (OK)

    {

      BAsmCode[2] = EvalStrIntExpressionOffs(&ArgStr[2], ImmStart(ArgStr[2].str.p_str), UInt8, &OK);

      if (OK)

      {

        BAsmCode[0] = 0xb2;

        CodeLen = 3;

      }

    }

  }

}

static void DecodeLDM(Word Code)

{

  Boolean ValOK;

  UNUSED(Code);

  if (ChkArgCnt(2, 2)

   && ChkExactCPU(CPUM740))

  {

    BAsmCode[0] = 0x3c;