/* %%%%%%%%%%%%%%%%%%%% (c) William Landi 1991 %%%%%%%%%%%%%%%%%%%%%%%%%%%% */
/* Permission to use this code is granted as long as the copyright */
/* notice remains in place. */
/* ============================= convert.c ================================= */
/* Contains routines that convert one thing to another. Most of the routines */
/* deal with converting a number to a string of that number in some base, or */
/* converting a string (assuming some base) into an integer. Basically       */
/* just a file of miscellaneous 'useful' routines.                           */
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include "sym_tab.h"
#include "constants.h"
#include "scan_line.h"
#include "assem.h"
#include "buffer.h"


/* MISSING_LABEL_NAME            Sections need names because the symbol      */
/*                               requires module names. MISSING_LABEL_NAME   */
/*                               is a global that is the name to the next    */
/*                               section that needs a name.                  */
char MISSING_LABEL_NAME[3] = "_!";

/* ------------------------ RESET_MISSING_LABEL_NAME ----------------------- */
/* Between pass1 and pass2, MISSING_LABEL_NAME must be reset to its          */
/* orginal value. This procedure does this.                                  */
void RESET_MISSING_LABEL_NAME()
{
  (void) strcpy(MISSING_LABEL_NAME,"_!");
}

/* ------------------------ GET_NEXT_MISSING_LABEL ------------------------- */
/* Puts MISSING_LABEL_NAME into string LABEL, and puts it into the symbol    */
/* table. It then changes MISSING_LABEL_NAME to some other unique name.      */
/* NOTE: this will only return about 90 unique names, after that it returns  */
/*       the same name repeadily. This would result only some additional     */
/*       previously defined label error messages. Never called when executed */
/*       on a source with no errors.                                         */
void GET_NEXT_MISSING_LABEL(char *LABEL,SYMBOL_TABLE *SYM_TAB)
{
  char *CH;

  (void) strcpy(LABEL,MISSING_LABEL_NAME);
  CH = &(MISSING_LABEL_NAME[strlen(MISSING_LABEL_NAME)-1]);
  if ((*CH) < '\127') (*CH) = (*CH) + '\1';
  (void) INSERT_IN_SYM_TAB(MODULE_NAME,LABEL,0,RELATIVE,SYM_TAB);
}


/* ---------------------------- BLANK_STR ---------------------------------- */
/* Set characters 0-7 of STRING to blank and make the 8th character NULL     */
/* ie. a 8 character string of blanks.                                       */
void BLANK_STR(char *STRING)
{
  int I;
  for (I=0;I < LABEL_SIZE_1; I ++)
    STRING[I] = ' ';
  STRING[LABEL_SIZE_1] = '\0';
}

/* ------------------------ CHAR_TO_DIGIT ---------------------------------- */
/* Convert a character (CH) into its integer value give base NUM_BASE. Return*/
/* -1 if it is not a valid digit in that base.                               */
int CHAR_TO_DIGIT(char CH,int NUM_BASE)
{
  int DIGIT = -1;
  if ( (CH >= '0') && (CH <= '9') ) DIGIT = (int) (CH - '0');
  if ( (CH >= 'A') && (CH <= 'Z') ) DIGIT = ((int) (CH - 'A'))+10;
  if (DIGIT >= NUM_BASE) DIGIT = -1;
  return DIGIT;
}


/* ------------------------- NUM_TO_STR ------------------------------------ */
/* Put into STR the string with LEN digits that represents the number NUM    */
/* in base BASE (eg. NUM_TO_STR(10,16,3,STR) puts "00A" in STR).             */
void  NUM_TO_STR(int NUM,int BASE,int LEN,char *STR)
{
  int I;                        /* loop counter                              */
  int DIGIT;                    /* one digit in base specified of NUM        */

  STR[LEN] = '\0';
  for (I=(LEN-1); I>=0; I--) {
    DIGIT = NUM - (NUM/BASE) * BASE;
    NUM /= BASE;
    if ((DIGIT >= 0) && (DIGIT <= 9))
      STR[I] = (char) DIGIT + '0';
    else STR[I] = (char) (DIGIT-10) + 'A';
  }
  if (NUM != 0)
    (void) printf("NUM_TO_STR called illegally.\n");
}

/* -------------------------- PRT_NUM ------------------------------------- */
/* Output (to stream OUTPUT) the string with LEN digits that represents the */
/* number NUM in base BASE (eg. NUM_TO_STR(20,16,2,STR) puts "14" in STR).  */
void PRT_NUM(int NUM,int NUM_BASE,int LEN,FILE *OUTPUT)
{
  int COUNT;                  /* loop counter                               */
  int MAX_NUM;                /* Biggest number can represent with LEN      */
                              /*    digits in base BASE                     */
  int DIGIT;                  /* One digit in base specified of NUM         */

  MAX_NUM = ((int) pow((NUM_BASE*1.0),(LEN-1)*1.0));

  if (NUM < 0) NUM = MAX_NUM*NUM_BASE + NUM;
  
  if (NUM >= MAX_NUM * NUM_BASE) 
    (void) printf("ASSEMBLER ERROR: PRT_NUM called illegally.\n");

  for (COUNT= MAX_NUM; COUNT >= 1; COUNT /= NUM_BASE) {
    DIGIT = NUM / COUNT;
    NUM = NUM - DIGIT*COUNT;
    if ((DIGIT >= 0) && (DIGIT <= 9))
      (void) fprintf(OUTPUT,"%c",(char) (DIGIT + '0'));
    else (void) fprintf(OUTPUT,"%c",(char) (DIGIT - 10 + 'A'));
  }

}


/* ------------------------------ GET_NUM ---------------------------------- */
/* CURRENT_CHAR points to a string. Starting with the character              */
/* **CURRENT_CHAR and get the biggest possible integer in BASE NUM_BASE. If  */
/* that number is too large/small to fit in BITS bits (2's complement),      */
/* Put an error message into ERROR_REC_BUF. Returns 0 if this or any error is*/
/* detected, otherwise it returns the integer representation of the number.  */
/* NOTE: If number is to large/small this routine stops as soon as it        */
/*   realizes this w/o (with out) looking at the rest of the input.          */
int GET_NUM(char **CURRENT_CHAR,int BITS,int NUM_BASE)
{
  int CONVERT = 0;                /* CONVERT is the converted integer of the */
                                  /*    string */
  int MAX_UNSIGNED_INT;           /* MAX_UNSIGNED_INT = 2^(BITS-1)           */
                                  /*    - Biggest negative number            */
				  /*      (w/o sign) that fits               */
                                  /*    - Biggest biggest number + 1         */
				  /*      (w/o sign) that fits               */
  int SIGN = 1;                   /* Sign of the number- assume positive.    */
  char *INPUT_START;              /* Keeps track of where string started     */
  int DIGIT;                      /* One digit of the number.                */

  MAX_UNSIGNED_INT = (int) pow(2.0,(BITS-1)*1.0);
  INPUT_START = *CURRENT_CHAR;

  if ((**CURRENT_CHAR) == '-')
    SIGN = -1;
  else SIGN = 1;

  if ( ((**CURRENT_CHAR) == '-') || ((**CURRENT_CHAR) == '+')) {
/*  ---------------------------- MUST be a valid digit after the sign       */
    (*CURRENT_CHAR) ++;
    if (CHAR_TO_DIGIT(**CURRENT_CHAR,NUM_BASE) == -1) {
      char *ERROR_MSG;
      ERROR_MSG = (char *) malloc((unsigned int) 80);
      if (**CURRENT_CHAR > 0)
	(void) sprintf(ERROR_MSG,
		       "eERROR[15]: Illegal Expression. Found '%c' after %c.",
		       **CURRENT_CHAR,*( (*CURRENT_CHAR) - 1));
      else
	(void) sprintf(ERROR_MSG,
		       "eERROR[15]: Illegal Expression. Found '' after %c.",
		       *( (*CURRENT_CHAR) - 1));
      ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF,ERROR_MSG);
      free(ERROR_MSG);
    }
  }

/* ----------------------------- Get the biggest [legal] number you can      */
  while ( ( (DIGIT = CHAR_TO_DIGIT(**CURRENT_CHAR,NUM_BASE)) != -1) &&
	 !eoln(**CURRENT_CHAR) ) {
    if (CONVERT <= MAX_UNSIGNED_INT)
      CONVERT = CONVERT*NUM_BASE + DIGIT;
    (*CURRENT_CHAR) ++;
  }

/* ----------------------------- Make sure number is not to big or small     */
  if ( ((CONVERT > MAX_UNSIGNED_INT) && (SIGN == -1)) ||
      ((CONVERT > (MAX_UNSIGNED_INT - 1)) && (SIGN == 1)) ) {
    char SAV_CHAR;
    char *ERROR_MSG;

    SAV_CHAR = **CURRENT_CHAR;
    **CURRENT_CHAR = '\0';
    ERROR_MSG = (char *) malloc((unsigned int)
	   (80+ ((int) log10((double) NUM_BASE)) +
	    ((int) log10((double) MAX_UNSIGNED_INT)) +strlen(INPUT_START)));
      
    if (SIGN == 1)
      (void) sprintf(ERROR_MSG, 
       "eERROR[10]: %s[%d] is too large for it's intended use (MAX %d[10]).",
		     INPUT_START,NUM_BASE,MAX_UNSIGNED_INT - 1);
    else
      (void) sprintf(ERROR_MSG, 
       "eERROR[11]: %s[%d] is too small for it's intended use (MIN %d[10]).",
		     INPUT_START,NUM_BASE,-1*MAX_UNSIGNED_INT);
    ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF,ERROR_MSG);
    free(ERROR_MSG);
    **CURRENT_CHAR = SAV_CHAR;
    CONVERT = 0;
  }
  
  return CONVERT*SIGN;
}


/* ---------------------------- GET_EXPRESSION ----------------------------- */
/* Is used to find an expression (well, for now actually it can have no      */
/* operations, just single terms). Caller can specify what kind of expression*/
/* is needed (ABSOLUTE or RELATIVE) or can specify that either kind is okay. */
/* Sets WHAT_KIND to they type (kind) of expression found.                   */
int GET_EXPRESSION(char **CURRENT_CHAR,int BITS,int LOCATION,
                   SYMBOL_TABLE *SYM_TAB,int *WHAT_KIND)
{
  char *START;                        /* remember where the expression       */
                                      /*    started in string.               */
  START = (*CURRENT_CHAR);

/* ------------------ Check if a decimal constant, if so get it              */
  if ((*WHAT_KIND != RELATIVE_VALUE_1) && 
      ( ( ((**CURRENT_CHAR) >= '0') && ((**CURRENT_CHAR) <= '9') ) ||
       ((**CURRENT_CHAR) == '-') || ((**CURRENT_CHAR) == '+') ))
 {
    (*WHAT_KIND) = ABSOLUTE_VALUE_1;
    return GET_NUM(CURRENT_CHAR,BITS,10);
  }

/* ------------------ Check if hexidecimal constant, if so, get it           */
  if ((*WHAT_KIND != RELATIVE_VALUE_1) && 
      ( ((**CURRENT_CHAR) == 'X') && (*((*CURRENT_CHAR)+1) == '\'')) ) {
    int RESULT;

    (*WHAT_KIND) = ABSOLUTE_VALUE_1;
    (*CURRENT_CHAR) += 2;
    RESULT = GET_NUM(CURRENT_CHAR,BITS,16);
/* --------------------------- Check for error messages                      */
    if ( (**CURRENT_CHAR) != '\'') {
      while ( (**CURRENT_CHAR != '\'') && (!eoln(**CURRENT_CHAR)) )
	(*CURRENT_CHAR) ++;
      if (eoln(**CURRENT_CHAR)) {
	char ERROR_MSG[80];
	(void) sprintf(ERROR_MSG,
	       "eERROR[16]: Illegal Hexidecimal. Expected close quote.");
	ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF,ERROR_MSG);
      } else {
	char TEMP;
	char *ERROR_MSG;

	(*CURRENT_CHAR) ++;

	TEMP = **CURRENT_CHAR;
	**CURRENT_CHAR = '\0';

        ERROR_MSG = (char *) malloc((unsigned int)
		(80+ strlen(START)));
	 
	(void) sprintf(ERROR_MSG,
		       "eERROR[17]: Illegal Hexidecimal. %s",START);
	ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF,ERROR_MSG);
	free(ERROR_MSG);
	**CURRENT_CHAR = TEMP;
      }
    }
    else (*CURRENT_CHAR) ++;
    return RESULT;
  }

/* ----------------------------- Must be a label, get it                     */
  {
    char LABEL_NAME[LABEL_SIZE_1 + 1];
    struct SYMBOL_TABLE_ENTRY *LABEL_INFO;

    GET_LABEL(LABEL_NAME,*CURRENT_CHAR,CURRENT_CHAR,pass1);

    if (!strcmp(LABEL_NAME,"")) {
/* ----------------------------- There was no label. ERROR                   */
   char *ERROR_MSG;
      
      ERROR_MSG = (char *) malloc((unsigned int)
				  (80+ strlen(*CURRENT_CHAR)));
      (void) sprintf(ERROR_MSG,
		     "eERROR[14]: Expected an expression, found '%s'.",
		     *CURRENT_CHAR);
      ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF,ERROR_MSG);
      free(ERROR_MSG);
      }
    else {
/* ----------------------------- Get the value of the LABEL                  */
     LABEL_INFO = LOOK_UP_SYMBOL(MODULE_NAME,LABEL_NAME,SYM_TAB);
     if (LABEL_INFO == NULL) {
/* ----------------------------- has no value                                */
       char *ERROR_MSG;
      
       ERROR_MSG = (char *) malloc((unsigned int)
				  (80+ strlen(LABEL_NAME)));
       if ((*WHAT_KIND) != ABSOLUTE_OR_RELATIVE_1)
	 (void) sprintf(ERROR_MSG,
         "eERROR[24]: %s is not a defined symbol or is forwardly declared.",
			LABEL_NAME);
       else
	 (void) sprintf(ERROR_MSG,"eERROR[49]: %s is not a defined symbol.",
			LABEL_NAME);

       ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF,ERROR_MSG);
       free(ERROR_MSG);
     } else
       if ( (*WHAT_KIND != RELATIVE_VALUE_1) &&
	   ((*LABEL_INFO).TYPE == ABSOLUTE)) {
	 (*WHAT_KIND) = ABSOLUTE_VALUE_1;
	 return (*LABEL_INFO).LOCATION;
       } else
	   if ( (*WHAT_KIND != ABSOLUTE_VALUE_1) &&
	       ((*LABEL_INFO).TYPE != ABSOLUTE)) {
	     if ((*LABEL_INFO).TYPE == EXTERN_REF) {
/* ----------------------- Value needs a modification record                 */
	       char OUTPUT_LINE[9+LABEL_SIZE_1];
	       char FIX_LEN_NAME[LABEL_SIZE_1+1];
	       char LEN_STR[3];
	       
	       NUM_TO_STR(LOCATION,16,6,OUTPUT_LINE);
	       NUM_TO_STR((BITS/4),16,2,LEN_STR);
	       (void) strcat(OUTPUT_LINE,LEN_STR);
	       (void) strcat(OUTPUT_LINE,"+");
	       BLANK_STR(FIX_LEN_NAME);
	       (void) strncpy(FIX_LEN_NAME,LABEL_NAME,strlen(LABEL_NAME));
	       (void) strcat(OUTPUT_LINE,FIX_LEN_NAME);
	       ADD_TO_END_OF_BUFFER(&MOD_REC_BUF,OUTPUT_LINE);
	       (*WHAT_KIND) = EXTERN_VALUE_1;
	     } else (*WHAT_KIND) = RELATIVE_VALUE_1;
	     return (*LABEL_INFO).LOCATION;
	   } else {
	     char *ERROR_MSG;
      
	     ERROR_MSG = (char *) malloc((unsigned int)
				     (80+ strlen(LABEL_NAME)));
	     if (*WHAT_KIND == ABSOLUTE_VALUE_1)
	       (void) sprintf(ERROR_MSG,
			"eERROR[25]: %s is a LABEL, expected a CONSTANT.",
			    LABEL_NAME);
	     else
	       (void) sprintf(ERROR_MSG,
			"eERROR[50]: %s is a CONSTANT, expected a LABEL.",
			    LABEL_NAME);
	     ADD_TO_END_OF_BUFFER(&ERROR_REC_BUF,ERROR_MSG);
	     free(ERROR_MSG);
	   } 
   }
    return 0;
  }
}