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 char *prefix;
SYM *search2(char *na,TABLE *tbl,TypeArray *typearray);
uint8_t hashadd(char *nm);
 
#ifndef min
int min (int a, int b) { return a < b ? a : b; }
#endif
 
SYM *TABLE::match[100];
int TABLE::matchno;
 
TABLE::TABLE()
{
  base = 0;
  head = 0;
  tail = 0;
  owner = 0;
}
 
// Used when deriving classes from base clasases.
 
void TABLE::CopySymbolTable(TABLE *dst, TABLE *src)
{
	SYM *sp, *newsym;
	dfs.puts("<CopySymbolTable>\n");
	if (src) {
	  dfs.printf("A");
		sp = sp->GetPtr(src->GetHead());
		while (sp) {
  	  dfs.printf("B");
			newsym = SYM::Copy(sp);
  	  dfs.printf("C");
			dst->insert(newsym);
  	  dfs.printf("D");
			sp = sp->GetNextPtr();
		}
	}
	dfs.puts("</CopySymbolTable>\n");
}
 
//Generic table insert routine, used for all inserts.
 
void TABLE::insert(SYM *sp)
{
	int nn;
	TypeArray *ta = sp->fi->GetProtoTypes();
	TABLE *tab = this;
	int s1,s2,s3;
	std::string nm;
//  std::string sig;
 
	if (sp == nullptr || this == nullptr ) {
	  dfs.printf("Null pointer at insert\n");
		throw new C64PException(ERR_NULLPOINTER,1);
  }
 
  if (this==&tagtable) {
    dfs.printf("Insert into tagtable:%s|\n",(char *)sp->name->c_str());
  }
  else
    dfs.printf("Insert %s into %p", (char *)sp->name->c_str(), (char *)this);
    dfs.printf("(%s)\n",owner ? (char *)SYM::GetPtr(owner)->name->c_str(): (char *)"");
//  sig = sp->BuildSignature();
	if (tab==&gsyms[0]) {
	  dfs.printf("Insert into global table\n");
		s1 = hashadd((char *)sp->name->c_str());
		s2 = hashadd((char *)sp->name2->c_str());
		s3 = hashadd((char *)sp->name3->c_str());
//		tab = &gsyms[(s1&s2)|(s1&s3)|(s2&s3)];
		tab = &gsyms[s1];
	}
 
  nm = *sp->name;
  // The symbol may not have a type if it's just a label. Find doens't
  // look at the return type parameter anyway, so we just set it to bt_long
  // if tp isn't set.
  nn = tab->Find(nm,sp->tp ? sp->tp->typeno : bt_long,ta,true); 
	if(nn == 0) {
    if( tab->head == 0) {
      tab->SetHead(sp->GetIndex());
			tab->SetTail(sp->GetIndex());
		}
    else {
      sp->GetPtr(tab->tail)->next = sp->GetIndex();
      tab->SetTail(sp->GetIndex());
    }
    sp->SetNext(0);
    dfs.printf("At insert:\n");
    sp->fi->GetProtoTypes()->Print();
  }
  else
    error(ERR_DUPSYM);
	if (ta)
		delete ta;
//  p = tab->GetHead();
//  while(p) {
//    printf("Xele:%p|%s|\r\n", p, p->name.c_str());
//    p = p->GetNext();
//  }
}
 
// Parameters:
//  na:			the name to search for
//	rettype:	this parameter is ignored
 
int TABLE::Find(std::string na,__int16 rettype, TypeArray *typearray, bool exact)
{
	SYM *thead, *first;
	TypeArray *ta;
	int s1,s2,s3;
	std::string name;
 
  dfs.puts("<Find>");
  dfs.puts((char *)na.c_str());
  if (this==nullptr) {
    matchno = 0;
    return 0;
  }
	if (na.length()==0) {
	  dfs.printf("name is empty string\n");
		throw new C64PException(ERR_NULLPOINTER,1);
  }
 
	matchno = 0;
	if (this==&gsyms[0])
		thead = SYM::GetPtr(gsyms[hashadd((char *)na.c_str())].GetHead());
	else
		thead = SYM::GetPtr(head);
	first = thead;
//	while(thead != NULL) {
//	  lfs.printf("Ele:%s|\n", (char *)thead->name->c_str());
//	  thead = thead->GetNext();
// }
 thead = first;
	while( thead != NULL) {
//		dfs.printf((char *)"|%s|,|%s|\n",(char *)thead->name->c_str(),(char *)na.c_str());
		if (thead->name) {	// ???
    name = *thead->name;
		s1 = thead->name->compare(na);
		s2 = thead->name2->compare(na);
		s3 = thead->name3->compare(na);
//		dfs.printf("s1:%d ",s1);
//		dfs.printf("s2:%d ",s2);
//		dfs.printf("s3:%d\n",s3);
		if(((s1&s2)|(s1&s3)|(s2&s3))==0) {
		  dfs.printf("Match\n");
			match[matchno] = thead;
			matchno++;
			if (matchno > 98)
				break;
 
			if (exact) {
				ta = thead->fi->GetProtoTypes();
				if (ta->IsEqual(typearray)) {
				  dfs.printf("Exact match");
				  ta->Print();
				  typearray->Print();
				  delete ta;
				  return 1;
				}
				ta->Print();
				delete ta;
			}
		}
		}
    thead = thead->GetNextPtr();
    if (thead==first) {
      dfs.printf("Circular list.\n");
      throw new C64PException(ERR_CIRCULAR_LIST,1);
    }
  }
  dfs.puts("</Find>\n");
  return exact ? 0 : matchno;
}
 
int TABLE::Find(std::string na)
{
	return Find(na,(__int16)bt_long,nullptr,false);
}
 
 
// Findrising searchs the table hierarchy at higher and higher
// levels until the symbol is found. It returns a table full of matches
// which is ordered according to the level at which the symbol was found.
// Subclasses appear in the table before base classes, so that a 
// subclass definiton of the symbol shadows a base class definition.
//
int TABLE::FindRising(std::string na)
{
	int sp;
  SYM *sym;
  int bse;
  static SYM *mt[110];
  int nn, ii;
  int ndx;
  TypeArray *ta;
 
  ndx = 0;
  dfs.printf("<FindRising>%s \n",(char *)na.c_str());
  if (this==nullptr)
    return 0;
	sp = Find(na);
	nn = min(100,ndx+TABLE::matchno);
	memcpy(&mt[0],TABLE::match,nn*sizeof(SYM *));
	ndx += nn;
	bse = base;
	while (bse) {
	  sym = SYM::GetPtr(bse);
	  dfs.printf("Searching class:%s \n",(char *)sym->name->c_str());
		sp = sym->tp->lst.Find(na);
  	nn = min(100,ndx+TABLE::matchno);
  	memcpy(&mt[ndx],TABLE::match,nn*sizeof(SYM *));
  	ndx += nn;
		bse = sym->tp->lst.base;
	}
	dfs.puts("</FindRising>");
 
  memcpy(TABLE::match,mt,ndx*sizeof(SYM *));
  TABLE::matchno = ndx;
  for (nn = 0; nn < ndx; nn++) {
    sym = TABLE::match[nn];
	if (sym) {
		if (sym->tp->type == bt_func || sym->tp->type == bt_ifunc) {
			if (sym->name)
				dfs.printf("Sym:%s Types: (", (char *)sym->name->c_str());
			else
				dfs.printf("Sym:%s Types: (", (char *)"<no name>");
			ta = sym->fi->GetProtoTypes();
			if (ta) {
				for (ii = 0; ii < 20; ii++) {
					dfs.printf("%03d, ", ta->types[ii]);
				}
			}
			dfs.puts(")\n");
		}
    }
  }
  return (ndx);
}
 
SYM *TABLE::Find(std::string na, bool opt)
{
	Find(na,(__int16)bt_long,nullptr,false);
	if (matchno==0)
		return nullptr;
	return match[matchno-1];
}