/***********************************************************************
 *
 *	Symbol Table module.
 *
 *	$Revision: 1.6 $
 *	$Date: 1995/09/12 04:34:44 $
 *	$Author: sbb $
 *
 ***********************************************************************/

/***********************************************************************
 *
 * Copyright (C) 1990, 1991, 1992, 1994, 1995 Free Software Foundation, Inc.
 * Written by Steve Byrne.
 *
 * This file is part of GNU Smalltalk.
 *
 * GNU Smalltalk 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 1, or (at your option) any later 
 * version.
 * 
 * GNU Smalltalk 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
 * GNU Smalltalk; see the file COPYING.  If not, write to the Free Software
 * Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  
 *
 ***********************************************************************/


/*
 *    Change Log
 * ============================================================================
 * Author      Date       Change 
 * sbb	     10 Sep 95	  Added incubator usage.
 *
 * sbb	     13 Jul 95	  Removed HAVE_ALLOCA_H.
 *
 * sbb	     11 Jul 95	  Added John Stanhope (jehu@vt.edu)'s changes for
 *			  Objective-C calling (Thanks John!!!)
 *
 * sbb	     29 Jun 95	  Fixed pool dictionary allocation to not allocate a
 *			  large number of immediately thrown away arrays.
 *
 * sbb	      6 Jun 95	  Switched to new file naming scheme.
 *
 * sbb	     30 May 95	  Boolean => mst_Boolean.
 *
 * sbb       31 Mar 95    Adjusted a reference to the empty bytes to use the 
 *                        new, architecture independent macro definitions.
 *
 * sbb	      8 Oct 94	  Fixed the internCountedString bug by deferring OOP
 *			  allocation until all instances have ben allocated.
 *
 * sbb	      2 Oct 94	  Fixed a bug in internCountedString that occurs other
 *			  places where there is the possibility of doing a
 *			  garbage collection just after a newly allocated
 *			  object which has not been added to a
 *			  root-set-reachable object.  The GC sees that there
 *			  are no references to the new object, and marks its
 *			  oop free and does not copy the just allocated object
 *			  into the new current semispace.  This problem can
 *			  occur anywhere these conditions occur.  Given that
 *			  allocOOP moves the object to the current space if
 *			  it's not already there, for this case to really
 *			  occur, you have to have done the allocOOP before you
 *			  call the second instantiate or other allocation
 *			  primitive. 
 *
 * sbb	     11 Jun 94	  Added cObjectPtrSymbol for new call by value
 *			  parameter passing mode.
 *
 * sbyrne    16 May 90	  Changed usages of "entry" to "ent" to prevent
 *			  collisions with C compilers which have this
 *			  identifier as a reserved word.
 *
 * sbyrne    21 Apr 90	  Addded byteArraySymbol.
 *
 * sbyrne    13 Jan 90	  Added thisContextSymbol.
 *
 * sbyrne    19 Dec 89	  Rebuilt symbol table.  Used to use the main OOP table
 *			  as a symbol table, due to issues involving initial
 *			  bootstrapping of the system.  Now using open hash
 *			  table built of arrays and linked lists, so that no
 *			  special precautions need be taken by the GC system or
 *			  the image save/restore facility.
 *
 * sbyrne    25 Jul 89	  Changed undeclareName to take a parameter that
 *			  controls whether the frame index is decremented or
 *			  not.  It appears that each block gets its own,
 *			  non-shared temporaries/arguments, so that if the
 *			  block is used in a process, other blocks won't have
 *			  strange things happening to their arguments.
 *
 * sbyrne     5 Jan 89	  Created.
 *
 */

#include "gst.h"
#include "sym.h"
#include "oop.h"
#include "comp.h"
#include "dict.h"
#include "tree.h"
#include "lex.h"
#include <stdio.h>
#include <ctype.h>
#if STDC_HEADERS
#include <stdlib.h>
#include <string.h>
#endif /* STDC_HEADERS */

/* if defined, use the hash algorithm given in the dragon book (see usage for
 *  better reference.
 */
#define dragon_book

#if !defined(max)
#define	max(x, y) \
  ( ((x) > (y)) ? (x) : (y) )
#endif

#define isSymbol(oop) \
   ( !isNil(oop) && (oopClass(oop) ==  symbolClass) )

typedef struct {
  OBJ_HEADER;
  OOP		nextLink;
  OOP		symbol;
} *SymLink;

OOP			andColonSymbol, atColonPutColonSymbol, atColonSymbol,
			atEndSymbol, bitAndColonSymbol, bitOrColonSymbol,
			bitShiftColonSymbol, blockCopyColonSymbol, classSymbol,
			divideSymbol, doColonSymbol, equalSymbol,
			greaterEqualSymbol, greaterThanSymbol,
			ifFalseColonIfTrueColonSymbol, ifFalseColonSymbol,
			ifTrueColonIfFalseColonSymbol, ifTrueColonSymbol,
			integerDivideSymbol, lessEqualSymbol, lessThanSymbol,
			minusSymbol, newColonSymbol, newSymbol,
			nextPutColonSymbol, nextSymbol, notEqualSymbol,
			notSameObjectSymbol, orColonSymbol, plusSymbol,
			remainderSymbol, sameObjectSymbol, sizeSymbol,
			thisContextSymbol,
			timesSymbol, valueColonSymbol,
			valueColonValueColonSymbol,
			valueColonValueColonValueColonSymbol,
 			valueWithArgumentsColonSymbol,
			valueSymbol,
			whileFalseColonSymbol, whileTrueColonSymbol, orSymbol,
			andSymbol, superSymbol, nilSymbol, trueSymbol,
			falseSymbol, selfSymbol,
			doesNotUnderstandColonSymbol, unknownSymbol,
			charSymbol, stringSymbol, stringOutSymbol, 
			symbolSymbol, intSymbol, longSymbol, floatSymbol, 
			doubleSymbol,
			voidSymbol, variadicSymbol, cObjectSymbol,
			cObjectPtrSymbol,  smalltalkSymbol, symbolTable,
			byteArraySymbol, byteArrayOutSymbol;

#ifdef symbol_table_profiling
int			adds = 0, reused = 0, reprobes = 0,
			hitsOn[OOP_TABLE_SIZE];
#endif /* symbol_table_profiling */

void 			printString();

static SymbolEntry	allocSymbolEntry();
#ifdef appears_to_be_unused /* Sun Jul  9 00:21:06 1995 */
/**/static Symbol		makeNewSymbol();
#endif /* appears_to_be_unused Sun Jul  9 00:21:06 1995 */
static mst_Boolean		isSameString(), isWhiteSpace();
unsigned long		hashString();
static void		declareName(), undeclareName(), parseVariableName();
static OOP		scanName(), internCountedString();
static int		instanceVariableIndex(), localVarIndex();

typedef struct SymbolListStruct *SymbolList;

struct SymbolListStruct {
  OOP		symbol;
  int		index;
  SymbolList	prevSymbol;
};
  
static SymbolList	symbolList;
static int		methodArguments, frameIndex, maxFrameIndex;


int getArgCount()
{
  return (methodArguments);
}

int getTempCount()
{
  return (maxFrameIndex - methodArguments);
}

void initArgCount()
{
  methodArguments = 0;
}

void initTempCount()
{
}

void declareArguments(args)
TreeNode args;
{
  symbolList = nil;
  frameIndex = 0;
  maxFrameIndex = 0;

  if (args->nodeType == unaryExprType) {
    return;
  } else if (args->nodeType == binaryExprType) {
    declareName(args->vExpr.expression->vList.name);
    methodArguments++;
  } else {
    for(args = args->vExpr.expression; args != nil; args = args->vList.next) {
      declareName(args->vList.value->vList.name);
      methodArguments++;
    }
  }
}
  
void declareTemporaries(temps)
TreeNode temps;
{
  for( ; temps != nil; temps = temps->vList.next) {
    declareName(temps->vList.name);
  }
}

void declareBlockArguments(args)
TreeNode args;
{
  for( ; args != nil; args = args->vList.next) {
    declareName(args->vList.name);
  }
}

static void declareName(name)
char	*name;
{
  SymbolList	newList;

  newList = (SymbolList)malloc(sizeof(struct SymbolListStruct));
  newList->symbol = internString(name);
  newList->index = frameIndex++;
  maxFrameIndex = max(maxFrameIndex, frameIndex);
  newList->prevSymbol = symbolList;
  symbolList = newList;
}

void undeclareArguments(args)
TreeNode args;
{
  if (args == nil) {
    return;
  }

  if (args->nodeType == unaryExprType) {
    return;
  } else if (args->nodeType == binaryExprType) {
    undeclareName(true);
  } else {
    for(args = args->vExpr.expression; args != nil; args = args->vList.next) {
      undeclareName(true);
    }
  }
}

void undeclareTemporaries(temps)
TreeNode temps;
{
  for( ; temps != nil; temps = temps->vList.next) {
    undeclareName(true);
  }
}

void undeclareBlockArguments(args)
TreeNode args;
{
  if (args == nil) {
    return;
  }

  for( ; args != nil; args = args->vList.next) {
    undeclareName(false);
  }
}

static void undeclareName(decrFrameIndex)
mst_Boolean decrFrameIndex;
{
  SymbolList	oldList;

  oldList = symbolList;
  symbolList = symbolList->prevSymbol;
  free(oldList);
  if (decrFrameIndex) {
    frameIndex--;
  }
}

OOP findClassVariable(varName)
OOP	varName;
{
  OOP		classOOP, assocOOP, classVariableOOP;

  if (oopClass(thisClass) == behaviorClass
      || oopClass(thisClass) == classDescriptionClass) {
    /* classDescriptions and above don't have class or pool variables */
    /* ### this isn't quite the right test; we probably should be testing
       for if we have a classClass or some derivative of that */
    return (nilOOP);
  }

  for (classOOP = thisClass; !isNil(classOOP);
       classOOP = superClass(classOOP)) {
    if (oopClass(classOOP) == metaclassClass) {
      /* pretend that metaclasses have the class variables and shared
	 pools that their instance classes do */
      classVariableOOP = metaclassInstance(classOOP);
    } else {
      classVariableOOP = classOOP;
    }
    assocOOP =
      dictionaryAssociationAt(classVariableDictionary(classVariableOOP),
			      varName);
    if (!isNil(assocOOP)) {
      return (assocOOP);
    }

    assocOOP = findSharedPoolVariable(classVariableOOP, varName);
    if (!isNil(assocOOP)) {
      return (assocOOP);
    }
  }

  return (nilOOP);
}


SymbolEntry findVariable(varName)
char	*varName;
{
  OOP		varAssoc, symbol;
  int		index;

  symbol = internString(varName);
  index = localVarIndex(symbol);
  if (index >= 0) {
    return (allocSymbolEntry(temporaryScope, symbol, index));
  }

  index = instanceVariableIndex(symbol);
  if (index >= 0) {
    return (allocSymbolEntry(receiverScope, symbol, index));
  }

  varAssoc = findClassVariable(symbol);
  if (isNil(varAssoc)) {
    return (nil);
  }

  index = addForcedObject(varAssoc);

  return (allocSymbolEntry(globalScope, varAssoc, index));
}

static int instanceVariableIndex(symbol)
OOP	symbol;
{
  OOP		arrayOOP;
  int		index, numVars;


  if (oopClass(thisClass) == behaviorClass) {
    /* behaviors have no instance variables */
    return (-1);
  }

  arrayOOP = instanceVariableArray(thisClass);
  numVars = numOOPs(oopToObj(arrayOOP));

  for (index = 1; index <= numVars; index++) {
    if (arrayAt(arrayOOP, index) == symbol) {
      return (index-1);
    }
  }

  return (-1);
}

static int localVarIndex(symbol)
OOP	symbol;
{
  SymbolList	s;

  for (s = symbolList; s != nil && symbol != s->symbol; s = s->prevSymbol);

  if (s != nil) {		/* found one */
    return (s->index);
  } else {
    return (-1);
  }
}

static SymbolEntry allocSymbolEntry(scope, symbol, index)
ScopeType	scope;
OOP		symbol;
int		index;
{
  SymbolEntry	ent;

  ent = (SymbolEntry)malloc(sizeof(struct SymbolEntryStruct));
  ent->scope = scope;
  ent->symbol = symbol;
  ent->varIndex = index;
  return (ent);
}


void freeSymbolEntry(ent)
SymbolEntry ent;
{
  free(ent);
}


OOP makeInstanceVariableArray(superclassOOP, variableString)
OOP	superclassOOP;
Byte	*variableString;
{
  OOP		arrayOOP, superArrayOOP, name;
  int		index, numInstanceVars, superInstanceVars;
  Byte		*p;
  IncPtr	incPtr;			

  if (variableString == nil) {
    variableString = (Byte *)"";
  }


  if (isNil(superclassOOP)) {
    superArrayOOP = nilOOP;
    superInstanceVars = numInstanceVars = 0;
  } else {
    superArrayOOP = instanceVariableArray(superclassOOP);
    superInstanceVars = numInstanceVars = numOOPs(oopToObj(superArrayOOP));
  }

  for (p = variableString; *p; ) {
    /* skip intervening whitespace */
    name = scanName(&p);
    if (!isNil(name)) {
      numInstanceVars++;
    }
  }

  if (numInstanceVars == 0) {
    return (nilOOP);		/* no instances here */
  }

  incPtr = incSavePointer();

  arrayOOP = arrayNew(numInstanceVars);
  incAddOOP(arrayOOP);

  /* inherit variables from parent */
  for (index = 1; index <= superInstanceVars; index++) {
    arrayAtPut(arrayOOP, index, arrayAt(superArrayOOP, index));
  }

  /* now add our own variables */
  for (p = variableString; *p; index++) {
    /* skip intervening whitespace */
    name = scanName(&p);
    /* don't need to add name to incubator
     * -- it's a symbol so it's already held onto
     */
    if (!isNil(name)) {
      arrayAtPut(arrayOOP, index, name);
    }
  }

  incRestorePointer(incPtr);
  return (arrayOOP);
}

OOP makeClassVariableDictionary(classOOP, variableNames)
OOP	classOOP;
Byte	*variableNames;
{
  OOP		dictionaryOOP, name;
  Byte		*p;
  IncPtr	incPtr;

  if (variableNames == nil) {
    variableNames = (Byte *)"";
  }

  incPtr = incSavePointer();

  dictionaryOOP = dictionaryNew();
  incAddOOP(dictionaryOOP);

  for (p = variableNames; *p; ) {
    name = scanName(&p);
    if (!isNil(name)) {
      /* ### error if already exists */
      /* don't need to add name to incubator
       * -- it's a symbol so it's already held onto
       */
      dictionaryAtPut(dictionaryOOP, name, nilOOP);
    }
  }

  if (dictionarySize(dictionaryOOP) == 0) {
    dictionaryOOP = nilOOP;
  }

  incRestorePointer(incPtr);
  return (dictionaryOOP);
}

OOP makePoolArray(classOOP, poolNames)
OOP	classOOP;
Byte 	*poolNames;
{
  OOP		pools, name;
  int		numPools, i;
  Byte		*p, *e;
  IncPtr	incPtr;

  if (poolNames == nil) {
    poolNames = (Byte *)"";
  }
  
  /* count the number of new pool names */
  for (p = poolNames, numPools = 0; *p; ) {
    parseVariableName(&p, &e);
    if (p != e) {
      numPools++;
      p = e;
    }
  }

  incPtr = incSavePointer();

  pools = nilOOP;	/* ### maybe change this to leave empty array */

  for (p = poolNames, i = 1; *p; i++) {
    name = scanName(&p);
    if (!isNil(name)) {
      /* don't need to add name to incubator -- it's a symbol so it's
       * already held onto.
       */

      /* ### error if already exists in parent?,
	 or if value isn't a dictionary */
      /* ### should I keep these as names?  or associations?  Should
	 I look up the names somewhere other than in the smalltalk
	 dictionary?  Need to check for undefineds? */
      if (pools == nilOOP) {
	pools = arrayNew(numPools);
	incAddOOP(pools);
      }
      arrayAtPut(pools, i, dictionaryAt(smalltalkDictionary, name));
    }
  }


  incRestorePointer(incPtr);
  return (pools);
}

/*
 *	static OOP scanName(pp)
 *
 * Description
 *
 *	Scan a variable name (letters and digits, initial letter), and return a
 *	symbol for it.
 *
 * Inputs
 *
 *	pp    : pointer to a pointer to the start of the string to be scanned.
 *		May be pointing at either whitespace or start of variable.  At
 *		end, points to first character after the parsed variable name,
 *		which may be NUL. 
 *
 * Outputs
 *
 *	Symbol for variable name, or nilOOP if none found.  pp points to first
 *	char after symbol name (if any).
 */
static OOP scanName(pp)
Byte	**pp;
{
  Byte		*end, *str;
  long		len;

  parseVariableName(pp, &end);
  len = end - *pp;
  if (len == 0) {
    return (nilOOP);
  }


  str = (Byte *)alloca(len + 1);
  strncpy(str, *pp, len);
  str[len] = '\0';

  *pp = end;

  return (internString(str));
}

static void parseVariableName(pp, endp)
Byte	**pp, **endp;
{
  register Byte	*p, *e;

  p = *pp;
  e = *endp;

  while (isWhiteSpace(*p)) {
    p++;
  }

  /* ### check for non-null here and not alnum; we've jammed on a bogus char
     and it's an error */

  /* variable name extends from p to e-1 */
  for (e = p; *e; e++) {
    if (!isalnum(*e)) {
      break;
    }
  }

  *pp = p;
  *endp = e;
}

static mst_Boolean isWhiteSpace(c)
Byte	c;
{
   return (c == ' ' || c == '\t' || c == '\n' || c == '\f');
}

OOP internStringOOP(stringOOP)
OOP	stringOOP;
{
  int		len;
  char		copyBuf[100], *copyPtr;
  OOP		symbolOOP;

  len = stringOOPLen(stringOOP);
  /* do this slightly more complicated bit of code because:
   * 1) we don't want to call malloc/free if we can help it
   * 2) if we just used stringOOPChars (as we used to), we pass the
   *    *dereferenced* value of the stringOOP.  internCountedString
   *    can do allocations.  If it allocates, and the gc runs, stringOOP
   *    can move, meaning the dereferenced set of chars becomes invalid.
   *    So instead we make a non-moving copy and use that.
   */
  if (len < sizeof(copyBuf)) {
    copyPtr = copyBuf;
  } else {
    copyPtr = (char *)malloc(len);
  }

  memcpy(copyPtr, stringOOPChars(stringOOP), len);

  symbolOOP = internCountedString(copyPtr, len);

  if (len >= sizeof(copyBuf)) {
    free(copyPtr);
  }

  return symbolOOP;
}

OOP internString(str)
char	*str;
{
  int		len;

  len = strlen(str);
  return (internCountedString(str, len));
}

static OOP internCountedString(str, len)
Byte	*str;
int	len;
{
  unsigned long	index;
  SymLink	link;
  Symbol	symbol;
  OOP		symbolOOP, linkOOP;
  IncPtr	incPtr;

  index = (hashString(str, len) % numOOPs(oopToObj(symbolTable))) + 1;
  for (linkOOP = arrayAt(symbolTable, index); !isNil(linkOOP);
       linkOOP = link->nextLink) {
    link = (SymLink)oopToObj(linkOOP);
    if (isSameString(str, link->symbol, len)) {
      return (link->symbol);
    }
  }

  /* no match, have to add it to head of list */

  incPtr = incSavePointer();
  symbol = (Symbol)newInstanceWith(symbolClass, (long)len);
  strncpy(symbol->symString, str, len);
  symbolOOP = allocOOP(symbol);
  initEmptyBytes(symbolOOP, len);
  incAddOOP(symbolOOP);


  link = (SymLink)newInstance(symLinkClass);
  link->nextLink = arrayAt(symbolTable, index);
  link->symbol = nilOOP;	/* keep the GC happy */
  /* maybeMoveOOP(link->nextLink);	/* make sure it's here with us */

  link->symbol = symbolOOP;
  arrayAtPut(symbolTable, index, allocOOP(link));

  incRestorePointer(incPtr);
  return (symbolOOP);
}


#ifdef appears_to_be_unused /* Sun Jul  9 00:20:46 1995 */
/**/static Symbol makeNewSymbol(str, len)
/**/Byte	*str;
/**/int	len;
/**/{
/**/  Symbol	symbol;
/**/
/**/  symbol = (Symbol)newInstanceWith(symbolClass, (long)len);
/**/  strncpy(symbol->symString, str, len);
/**/
/**/  return (symbol);
/**/}
#endif /* appears_to_be_unused Sun Jul  9 00:20:46 1995 */


static mst_Boolean isSameString(str, oop, len)
char	*str;
OOP	oop;
int	len;
{
  if (stringOOPLen(oop) == len) {
    return (strncmp(str, ((Symbol)oopToObj(oop))->symString, len) == 0);
  }

  return (false);
}

int stringOOPLen(oop)
OOP	oop;
{
  return (oopSizeBytes(oop) - (oop->flags & EMPTY_BYTES));
}


unsigned long hashString(str, len)
char	*str;
int	len;
{
#ifdef dragon_book
/* from Dragon Book, p436 */
  unsigned long hashVal = 0, carry;

  for ( ; len > 0; str++, len--) {
    hashVal = (hashVal << 4) + (*str);
    if (carry = (hashVal & 0xf0000000)) {
      hashVal ^= (carry >> 24);
      hashVal ^= carry;
    }
  }

  return (hashVal);
#else
  long	result = 0L;

  for (; len > 0; str++, len--) {
    result = (result << 1) /* | (result < 0) */;
    result ^= *str;
  }

  return ((unsigned long)result);
#endif /* ! dragon_book */
}

void printSymbol(symbol)
OOP	symbol;
{
  if (isNil(symbol)) {
    printf(nilName);
  } else {
    printString(symbol);
  }
}

void printString(string)
OOP	string;
{
  int		len;

  len = stringOOPLen(string);
  fwrite(oopToObj(string)->data, sizeof(Byte), len, stdout);
  fflush(stdout);
}

/*
 *	char *symbolAsString(symbolOOP)
 *
 * Description
 *
 *	Given a symbol, this routine returns a C string that corresponds to the
 *	name of the symbol.  The returned value is a pointer to a static area,
 *	so if it's to be used for anything other than immediate output, the
 *	caller needs to make a copy of the retured string.
 *
 * Inputs
 *
 *	symbolOOP: 
 *		An OOP for a symbol
 *
 * Outputs
 *
 *	Pointer to a C string that contains the symbol name.
 */
char *symbolAsString(symbolOOP)
OOP	symbolOOP;
{
  static char	stringBuf[256];	/* probably large enough for most symbols */
  int		len;
  Symbol	symbol;

  symbol = (Symbol)oopToObj(symbolOOP);

  len = stringOOPLen(symbolOOP);
  if (len >= sizeof(stringBuf)) {
    errorf("symbol name too long: %d, max is %d", len, sizeof(stringBuf));
  }
  strncpy(stringBuf, symbol->symString, len);
  stringBuf[len] = '\0';
  return (stringBuf);
}

mst_Boolean okToCheck = false;
void
checkSymbolChain()
{
  unsigned long	i;
  
  if (!okToCheck) return;

  for (i = 1; i <= numOOPs(oopToObj(symbolTable)); i++) {
    SymLink	link;
    OOP		linkOOP;
    for (linkOOP = arrayAt(symbolTable, i); !isNil(linkOOP);
	 linkOOP = link->nextLink) {
      link = (SymLink)oopToObj(linkOOP);
      if (oopClass(linkOOP) != symLinkClass ||
	  oopClass(link->symbol) != symbolClass) {
	printf("Bad symbol %x\n", linkOOP);
	debug();
      }
    }
  }
}


/*
 *	void printSymbols()
 *
 * Description
 *
 *	This routine is used for symbol table debugging only.
 *
 */
void printSymbolChain();	/* ### hack */
void printSymbols()
{
  unsigned long	i;
  
  for (i = 1; i <= numOOPs(oopToObj(symbolTable)); i++) {
    printf("Table[%d]:\n", i);
    printSymbolChain(i);
    printf("\n");
  }
}

void printSymbolChain(i)
unsigned long i;
{
  SymLink	link;
  OOP		linkOOP;
  for (linkOOP = arrayAt(symbolTable, i); !isNil(linkOOP);
       linkOOP = link->nextLink) {
    link = (SymLink)oopToObj(linkOOP);
    printf("%d:", linkOOP - oopTable); /* ### */
    printSymbol(link->symbol);
    printf("->");
  }
}


void printSymLink(symLinkOOP)
OOP	symLinkOOP;
{
  SymLink	link;

  link = (SymLink)oopToObj(symLinkOOP);

  printObject(link->symbol);
}

void initSymbols()
{
  andColonSymbol 	        = internString("and:");
  andSymbol			= internString("&");
  atColonPutColonSymbol         = internString("at:put:");
  atColonSymbol 	        = internString("at:");
  atEndSymbol 		        = internString("atEnd");
  bitAndColonSymbol 	        = internString("bitAnd:");
  bitOrColonSymbol 	        = internString("bitOr:");
  bitShiftColonSymbol 	        = internString("bitShift:");
  blockCopyColonSymbol 	        = internString("blockCopy:");
  byteArraySymbol		= internString("byteArray");
  byteArrayOutSymbol		= internString("byteArrayOut");
  charSymbol                    = internString("char");
  classSymbol 		        = internString("class");
  cObjectSymbol                 = internString("cObject");
  cObjectPtrSymbol              = internString("cObjectPtr");
  divideSymbol 		        = internString("/");
  doColonSymbol 	        = internString("do:");
  doesNotUnderstandColonSymbol  = internString("doesNotUnderstand:");
  floatSymbol			= internString("float");
  doubleSymbol                  = internString("double");
  equalSymbol 		        = internString("=");
  falseSymbol			= internString("false");
  greaterEqualSymbol 	        = internString(">=");
  greaterThanSymbol 	        = internString(">");
  ifFalseColonIfTrueColonSymbol = internString("ifFalse:ifTrue:");
  ifFalseColonSymbol 	        = internString("ifFalse:");
  ifTrueColonIfFalseColonSymbol = internString("ifTrue:ifFalse:");
  ifTrueColonSymbol 	        = internString("ifTrue:");
  integerDivideSymbol 	        = internString("//");
  intSymbol                     = internString("int");
  lessEqualSymbol 	        = internString("<=");
  lessThanSymbol 	        = internString("<");
  longSymbol                    = internString("long");
  minusSymbol 		        = internString("-");
  newColonSymbol 	        = internString("new:");
  newSymbol 		        = internString("new");
  nextPutColonSymbol 	        = internString("nextPut:");
  nextSymbol 		        = internString("next");
  nilSymbol			= internString("nil");
  notEqualSymbol 	        = internString("~=");
  notSameObjectSymbol		= internString("~~");
  orColonSymbol 	        = internString("or:");
  orSymbol			= internString("|");
  plusSymbol 		        = internString("+");
  remainderSymbol 	        = internString("\\");
  sameObjectSymbol 	        = internString("==");
  selfSymbol			= internString("self");
  sizeSymbol 		        = internString("size");
  smalltalkSymbol		= internString("smalltalk");
  stringOutSymbol               = internString("stringOut");
  stringSymbol                  = internString("string");
  superSymbol			= internString("super");
  symbolSymbol                  = internString("symbol");
  thisContextSymbol		= internString("thisContext");
  timesSymbol 		        = internString("*");
  trueSymbol			= internString("true");
  unknownSymbol                 = internString("unknown");
  valueColonSymbol 	        = internString("value:");
  valueColonValueColonSymbol	= internString("value:value:");
  valueColonValueColonValueColonSymbol = internString("value:value:value:");
  valueSymbol 		        = internString("value");
  valueWithArgumentsColonSymbol = internString("valueWithArguments:");
  variadicSymbol                = internString("variadic");
  voidSymbol                    = internString("void");
  whileFalseColonSymbol	        = internString("whileFalse:");
  whileTrueColonSymbol 	        = internString("whileTrue:");
}
