/*
 * Copyright 2003-2004,2016 Ronald S. Burkey <info@sandroid.org>
 *
 * This file is part of yaAGC.
 *
 * yaAGC is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * yaAGC is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with yaAGC; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Filename:     ParseEQUALS.c
 * Purpose:      Assembles the EQUALS or = pseudo-op.
 * Mod History:  04/16/03 RSB   Began.
 *               07/26/04 RSB   Offset moved out of symbol and into
 *                              global variable.
 *               07/27/05 JMS   Added support for symbol debugging.
 *               11/02/16 RSB   Modified treatment of "EQUALS number", where
 *                              "number" is a large number.  Small numbers
 *                              continue to be treated as constant, while
 *                              larger ones are treated as flat addresses.
 *                              This was needed for Sunburst, and specifically
 *                              for the SAVERASE label.  Mods to the operands,
 *                              such as +1 or -25, are now treated differently,
 *                              and hopefully more-correctly, because the old
 *                              method was failing for the very large mods
 *                              found some places in SUNBURST.  However, I
 *               01/29/17 MAS   Added an address calculation tweak for
 *                              the --raytheon option.
 */

#include "yaYUL.h"
#include <stdlib.h>
#include <string.h>

//------------------------------------------------------------------------
// JMS: To properly add entries to the symbol table for debugging, we
// need the current file name and line number of the symbol, so i take the
// global variables in Pass.c. I am being lazy here, I probably should
// include this information in InputRecord_t.
extern Line_t CurrentFilename;
extern int CurrentLineInFile;

//------------------------------------------------------------------------
// Fetch a symbol value, possibly with offset.  Return 0 on success.
// The symbol value will have an Invalid field if not resolved yet.
// ... Later:  For a very long time, I simply added the offset into the
// symbol value.  However, I eventually realized that in doing this it 
// circumvents all kinds of crazy things the assembler wants to do with
// offsets --- such as converting one operand type to another.  Therefore,
// I now simply put the offset into a global variable, where it is 
// eventually added to the already-processed opcode+operand.  
int
FetchSymbolPlusOffset(Address_t *pc, char *Operand, char *Mod1,
    Address_t *Value)
{
  Symbol_t *Symbol;
  Address_t dummyAddress;
  int i, Offset;

  i = GetOctOrDec(Operand, &Offset);
  if (!i)
    {
      IncPc(pc, Offset, Value);
      return (0);
    }
  Value->Invalid = 1;
  Symbol = GetSymbol(Operand);
  if (Symbol == NULL)
    return (1);
  *Value = Symbol->Value;
  i = GetOctOrDec(Mod1, &Offset);
  if (!i)
    {
      if (Block1)
        {
          //IncPc (&Symbol->Value, Offset, Value);
          OpcodeOffset = Offset;
          // I'm not sure how to treat very big offsets.  Empirically, this works.
          if (OpcodeOffset >= 0)
            OpcodeOffset &= 07777;
          else
            OpcodeOffset = -(07777 & -OpcodeOffset);
        }
      else
        {
          PseudoToStruct(Symbol->Value.Value + Offset, &dummyAddress);
          *Value = dummyAddress;
        }
    }
  return (0);
}

//------------------------------------------------------------------------
// Return 0 on success.
int
ParseEquate(ParseInput_t *InRecord, ParseOutput_t *OutRecord)
{
  return (ParseEQUALS(InRecord, OutRecord));
}

int
ParseEQUALS(ParseInput_t *InRecord, ParseOutput_t *OutRecord)
{
  Address_t LabelValue =
    { 1 };
  int Value, i;

  OutRecord->ProgramCounter = InRecord->ProgramCounter;
  OutRecord->EBank = InRecord->EBank;
  OutRecord->SBank = InRecord->SBank;
  OutRecord->LabelValue.Invalid = 1;
  OutRecord->NumWords = 0;
  OutRecord->Equals = 1;

  // As a special case, it sometimes happens that the label is empty.
  // I *believe* that this is done only for documentation purposes, and
  // has no other effect.
  if (*InRecord->Label == 0)
    {
      OutRecord->LabelValueValid = 0;
      return (0);
    }

  // As another special case, there is sometimes no operand.  *That* means
  // that the current program counter is the value.  
  if (*InRecord->Operand == 0 && *InRecord->Mod1 == 0)
    {
      EditSymbolNew(InRecord->Label, &InRecord->ProgramCounter, SYMBOL_CONSTANT,
          CurrentFilename, CurrentLineInFile);
      OutRecord->LabelValue = InRecord->ProgramCounter;
      return (0);
    }

  i = GetOctOrDec(InRecord->Operand, &Value);
  if (i)
    {
      // The operand is NOT a number.  Presumably, it's a symbol.
      if (!strcmp(InRecord->Mod1, "+") || !strcmp(InRecord->Mod1, "-"))
        {
          // Handle the case of whitespace between +/- and the actual offset. 
          if (*InRecord->Mod2 != 0)
            {
              char mod[1 + MAX_LINE_LENGTH];

              strcpy(mod, InRecord->Mod1);
              strcat(mod, InRecord->Mod2);
              i = FetchSymbolPlusOffset(&InRecord->ProgramCounter,
                  InRecord->Operand, mod, &LabelValue);
            }
          else
            {
              sprintf(OutRecord->ErrorMessage,
                  "Syntax error, invalid offset specified");
              OutRecord->Fatal = 1;
              return (0);
            }
        }
      else
        {
          //if (!strcmp(InRecord->Operand, "VPRED"))
          //  {
          //    fprintf(stderr, "Hello\n");
          //  }
          i = FetchSymbolPlusOffset(&InRecord->ProgramCounter,
              InRecord->Operand, InRecord->Mod1, &LabelValue);
        }

      if (i)
        {
          sprintf(OutRecord->ErrorMessage,
              "Symbol \"%s\" undefined or offset bad", InRecord->Operand);
          OutRecord->Fatal = 1;
          return (0);
        }

      if (OpcodeOffset)
        {
          if (LabelValue.Constant)
            {
              LabelValue.Value += OpcodeOffset;
            }
          else
            IncPc(&LabelValue, OpcodeOffset, &LabelValue);
        }

      EditSymbolNew(InRecord->Label, &LabelValue, SYMBOL_CONSTANT,
          CurrentFilename, CurrentLineInFile);
      OutRecord->LabelValueValid = 1;
    }
  else
    {
      // Next, it may be that the operand is simply a number.  If so, then
      // we're talking about a simple constant.  

      ParseOutput_t TempOutput;

      if (*InRecord->Operand == '+' || *InRecord->Operand == '-')
        {
          IncPc(&InRecord->ProgramCounter, Value, &LabelValue);
        }
      else
        {
          if (Value < -16383 || Value > 32767)
            {
              strcpy(OutRecord->ErrorMessage,
                  "Value out of range---truncating");
              OutRecord->Warning = 1;
              if (Value < -16383)
                Value = -16383;
              else if (Value > 32767)
                Value = 32767;
            }

          if (Raytheon && Value >= 02000 && Value < 04000)
            {
              // For Raytheon builds, shift common-fixed literals into the expected range
              Value += 010000 + InRecord->ProgramCounter.FB * 02000;
            }

          LabelValue.Invalid = 0;
          LabelValue.Constant = 1;
          LabelValue.Value = Value;

          PseudoToSegmented(Value, &TempOutput);

          if (!TempOutput.ProgramCounter.Invalid)
            {
              LabelValue = TempOutput.ProgramCounter;
              if (!strcmp(InRecord->Operator, "ERASE")
                  || (Value >= 02000 && !strcmp(InRecord->Operator, "EQUALS")))
                {
                  // Special case. This is to handle "ERASE start - end" constructs, 
                  // which should not be tagged as constants.
                  LabelValue.Constant = 0;
                }
              else
                {
                  // Otherwise mark it as a constant as well.
                  LabelValue.Constant = 1;
                }
            }
        }

      EditSymbolNew(InRecord->Label, &LabelValue, SYMBOL_CONSTANT,
          CurrentFilename, CurrentLineInFile);
    }

  OutRecord->LabelValue = LabelValue;

  return (0);
}