Subversion Repositories thor

// ============================================================================
//        __
//   \\__/ o\    (C) 2012-2018  Robert Finch, Waterloo
//    \  __ /    All rights reserved.
//     \/_//     robfinch<remove>@finitron.ca
//       ||
//
// CC64 - 'C' derived language compiler
//  - 64 bit CPU
//
// This source file is free software: you can redistribute it and/or modify 
// it under the terms of the GNU Lesser General Public License as published 
// by the Free Software Foundation, either version 3 of the License, or     
// (at your option) any later version.                                      
//                                                                          
// This source file 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 this program.  If not, see <http://www.gnu.org/licenses/>.    
//                                                                          
// ============================================================================
//
#include "stdafx.h"
 
extern std::string *TypenoToChars(int typeno);
 
TypeArray::TypeArray()
{
  length = 0;
  ZeroMemory(this,sizeof(this));
}
 
// The most significant bit of the register number indicates if register is
// an auto var or not. auto vars consume stack space.
 
void TypeArray::Add(int tp, __int16 regno)
{
  if (this==nullptr)
    return;
  if (length < sizeof(types) / sizeof(types[0])) {
    types[length] = tp;
	preg[length] = regno;
    length++;
  }
}
 
void TypeArray::Add(TYP *tp, __int16 regno)
{
  if (tp) {
    Add(tp->typeno, regno);
  }
  else {
    Add(0,0);
  }
}
 
bool TypeArray::IsEmpty()
{
  int nn;
 
  if (this==nullptr)
    return true;
  for (nn = 0; nn < length; nn++) {
    if (types[nn]==bt_ellipsis)
      return true;
    if (types[nn])
      return false;
  }
  return true;
}
 
bool TypeArray::IsByte(int typ)
{
	return (typ==bt_byte || typ==bt_ubyte);
}
 
bool TypeArray::IsChar(int typ)
{
	return (typ==bt_char || typ==bt_uchar);
}
bool TypeArray::IsShort(int typ)
{
	return (typ==bt_short || typ==bt_ushort);
}
bool TypeArray::IsLong(int typ)
{
	return (typ==bt_long || typ==bt_ulong);
}
bool TypeArray::IsInt(int typ)
{
	return (IsChar(typ)||IsShort(typ)||IsLong(typ)||IsByte(typ));
}
 
bool TypeArray::IsEqual(TypeArray *ta)
{
  int m;
  int nn;
  int t,tat;
 
  dfs.printf("IsEqual:");
  if (this==ta) {
    dfs.printf("T1");
    return (true);
  }
  if (ta==nullptr && IsEmpty()) {
    dfs.printf("T2");
    return (true);
  }
  if (this==nullptr || ta==nullptr) {
    dfs.printf("F1");
    return (false);
 }
  m = (length > ta->length) ? length : ta->length;
  for (nn = 0; nn < m; nn++) {
    if (types[nn]==bt_ellipsis) {
      dfs.printf("T3");
      return (true);
    }
	t = types[nn];
	tat = ta->types[nn];
    if (t != tat) {
      if (t==bt_long && tat==bt_ulong)
        continue;
      if (t==bt_ulong && tat==bt_long)
        continue;
      if (t==bt_short && tat==bt_ushort)
        continue;
      if (t==bt_ushort && tat==bt_short)
        continue;
      if (t==bt_char && tat==bt_uchar)
        continue;
      if (t==bt_uchar && tat==bt_char)
        continue;
	  // Loose type matching
	  if (IsInt(t) && IsInt(tat))
		  continue;
      dfs.printf("F2");
      return false;
    }
  }
  dfs.printf("T3");
  return true;
}
 
TypeArray *TypeArray::Alloc()
{
  TypeArray *tp = (TypeArray *)allocx(sizeof(TypeArray)); 
  return tp;
}
 
void TypeArray::Clear()
{
  if (this) {
    memset(types,0,sizeof(types));
    length = 0;
  } 
}
 
void TypeArray::Print(txtoStream *fs)
{
  int nn;
 
  fs->printf("Type array:\n   ");
  if (this) {
    for (nn = 0; nn < length; nn++)
        fs->printf((char *)"%03d ",types[nn]);
  }
  fs->printf("\n");
}
 
void TypeArray::Print()
{
  Print(&dfs);
}
 
// Build a signature string.
 
std::string *TypeArray::BuildSignature()
{
	static std::string *str;
	int n;
 
	str = new std::string("");
	for (n = 0; n < length; n++) {
		str->append(*TypenoToChars(types[n]));
	}
	return str;
}