home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / smalltalk-1.1.1 / mstsym.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-12  |  21.0 KB  |  879 lines
  1. /***********************************************************************
  2.  *
  3.  *    Symbol Table module.
  4.  *
  5.  ***********************************************************************/
  6.  
  7. /***********************************************************************
  8.  *
  9.  * Copyright (C) 1990, 1991 Free Software Foundation, Inc.
  10.  * Written by Steve Byrne.
  11.  *
  12.  * This file is part of GNU Smalltalk.
  13.  *
  14.  * GNU Smalltalk is free software; you can redistribute it and/or modify it
  15.  * under the terms of the GNU General Public License as published by the Free
  16.  * Software Foundation; either version 1, or (at your option) any later 
  17.  * version.
  18.  * 
  19.  * GNU Smalltalk is distributed in the hope that it will be useful, but WITHOUT
  20.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
  21.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  22.  * more details.
  23.  * 
  24.  * You should have received a copy of the GNU General Public License along with
  25.  * GNU Smalltalk; see the file COPYING.  If not, write to the Free Software
  26.  * Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  
  27.  *
  28.  ***********************************************************************/
  29.  
  30.  
  31. /*
  32.  *    Change Log
  33.  * ============================================================================
  34.  * Author      Date       Change 
  35.  * sbyrne    16 May 90      Changed usages of "entry" to "ent" to prevent
  36.  *              collisions with C compilers which have this
  37.  *              identifier as a reserved word.
  38.  *
  39.  * sbyrne    21 Apr 90      Addded byteArraySymbol.
  40.  *
  41.  * sbyrne    13 Jan 90      Added thisContextSymbol.
  42.  *
  43.  * sbyrne    19 Dec 89      Rebuilt symbol table.  Used to use the main OOP table
  44.  *              as a symbol table, due to issues involving initial
  45.  *              bootstrapping of the system.  Now using open hash
  46.  *              table built of arrays and linked lists, so that no
  47.  *              special precautions need be taken by the GC system or
  48.  *              the image save/restore facility.
  49.  *
  50.  * sbyrne    25 Jul 89      Changed undeclareName to take a parameter that
  51.  *              controls whether the frame index is decremented or
  52.  *              not.  It appears that each block gets its own,
  53.  *              non-shared temporaries/arguments, so that if the
  54.  *              block is used in a process, other blocks won't have
  55.  *              strange things happening to their arguments.
  56.  *
  57.  * sbyrne     5 Jan 89      Created.
  58.  *
  59.  */
  60.  
  61. #include "mst.h"
  62. #include "mstsym.h"
  63. #include "mstoop.h"
  64. #include "mstcomp.h"
  65. #include "mstdict.h"
  66. #include "msttree.h"
  67. #include <stdio.h>
  68. #include <ctype.h>
  69. #ifdef HAS_ALLOCA_H
  70. #include <alloca.h>
  71. #endif
  72.  
  73. /* if defined, use the hash algorithm given in the dragon book (see usage for
  74.    better reference. */
  75. #define dragon_book
  76.  
  77. #define    max(x, y) \
  78.   ( ((x) > (y)) ? (x) : (y) )
  79.  
  80. #define isSymbol(oop) \
  81.    ( !isNil(oop) && (oopClass(oop) ==  symbolClass) )
  82.  
  83. typedef struct {
  84.   OBJ_HEADER;
  85.   OOP        nextLink;
  86.   OOP        symbol;
  87. } *SymLink;
  88.  
  89. OOP            andColonSymbol, atColonPutColonSymbol, atColonSymbol,
  90.             atEndSymbol, bitAndColonSymbol, bitOrColonSymbol,
  91.             bitShiftColonSymbol, blockCopyColonSymbol, classSymbol,
  92.             divideSymbol, doColonSymbol, equalSymbol,
  93.             greaterEqualSymbol, greaterThanSymbol,
  94.             ifFalseColonIfTrueColonSymbol, ifFalseColonSymbol,
  95.             ifTrueColonIfFalseColonSymbol, ifTrueColonSymbol,
  96.             integerDivideSymbol, lessEqualSymbol, lessThanSymbol,
  97.             minusSymbol, newColonSymbol, newSymbol,
  98.             nextPutColonSymbol, nextSymbol, notEqualSymbol,
  99.             notSameObjectSymbol, orColonSymbol, plusSymbol,
  100.             remainderSymbol, sameObjectSymbol, sizeSymbol,
  101.             thisContextSymbol,
  102.             timesSymbol, valueColonSymbol,
  103.             valueColonValueColonSymbol,
  104.             valueColonValueColonValueColonSymbol,
  105.              valueWithArgumentsColonSymbol,
  106.             valueSymbol,
  107.             whileFalseColonSymbol, whileTrueColonSymbol, orSymbol,
  108.             andSymbol, superSymbol, nilSymbol, trueSymbol,
  109.             falseSymbol, selfSymbol,
  110.             doesNotUnderstandColonSymbol, unknownSymbol,
  111.             charSymbol, stringSymbol, stringOutSymbol, 
  112.             symbolSymbol, intSymbol, longSymbol, doubleSymbol,
  113.             voidSymbol, variadicSymbol, cObjectSymbol, 
  114.             smalltalkSymbol, symbolTable, byteArraySymbol;
  115.  
  116. #ifdef symbol_table_profiling
  117. int            adds = 0, reused = 0, reprobes = 0,
  118.             hitsOn[OOP_TABLE_SIZE];
  119. #endif /* symbol_table_profiling */
  120.  
  121. void             printString();
  122.  
  123. static SymbolEntry    allocSymbolEntry();
  124. static Symbol        makeNewSymbol();
  125. static Boolean        isSameString(), isWhiteSpace();
  126. unsigned long        hashString();
  127. static void        declareName(), undeclareName(), parseVariableName();
  128. static OOP        scanName(), internCountedString();
  129. static int        instanceVariableIndex(), localVarIndex();
  130.  
  131. typedef struct SymbolListStruct *SymbolList;
  132.  
  133. struct SymbolListStruct {
  134.   OOP        symbol;
  135.   int        index;
  136.   SymbolList    prevSymbol;
  137. };
  138.   
  139. static SymbolList    symbolList;
  140. static int        methodArguments, frameIndex, maxFrameIndex;
  141.  
  142.  
  143. int getArgCount()
  144. {
  145.   return (methodArguments);
  146. }
  147.  
  148. int getTempCount()
  149. {
  150.   return (maxFrameIndex - methodArguments);
  151. }
  152.  
  153. void initArgCount()
  154. {
  155.   methodArguments = 0;
  156. }
  157.  
  158. void initTempCount()
  159. {
  160. }
  161.  
  162. void declareArguments(args)
  163. TreeNode args;
  164. {
  165.   symbolList = nil;
  166.   frameIndex = 0;
  167.   maxFrameIndex = 0;
  168.  
  169.   if (args->nodeType == unaryExprType) {
  170.     return;
  171.   } else if (args->nodeType == binaryExprType) {
  172.     declareName(args->vExpr.expression->vList.name);
  173.     methodArguments++;
  174.   } else {
  175.     for(args = args->vExpr.expression; args != nil; args = args->vList.next) {
  176.       declareName(args->vList.value->vList.name);
  177.       methodArguments++;
  178.     }
  179.   }
  180. }
  181.   
  182. void declareTemporaries(temps)
  183. TreeNode temps;
  184. {
  185.   for( ; temps != nil; temps = temps->vList.next) {
  186.     declareName(temps->vList.name);
  187.   }
  188. }
  189.  
  190. void declareBlockArguments(args)
  191. TreeNode args;
  192. {
  193.   for( ; args != nil; args = args->vList.next) {
  194.     declareName(args->vList.name);
  195.   }
  196. }
  197.  
  198. static void declareName(name)
  199. char    *name;
  200. {
  201.   SymbolList    newList;
  202.  
  203.   newList = (SymbolList)malloc(sizeof(struct SymbolListStruct));
  204.   newList->symbol = internString(name);
  205.   newList->index = frameIndex++;
  206.   maxFrameIndex = max(maxFrameIndex, frameIndex);
  207.   newList->prevSymbol = symbolList;
  208.   symbolList = newList;
  209. }
  210.  
  211. void undeclareArguments(args)
  212. TreeNode args;
  213. {
  214.   if (args == nil) {
  215.     return;
  216.   }
  217.  
  218.   if (args->nodeType == unaryExprType) {
  219.     return;
  220.   } else if (args->nodeType == binaryExprType) {
  221.     undeclareName(true);
  222.   } else {
  223.     for(args = args->vExpr.expression; args != nil; args = args->vList.next) {
  224.       undeclareName(true);
  225.     }
  226.   }
  227. }
  228.  
  229. void undeclareTemporaries(temps)
  230. TreeNode temps;
  231. {
  232.   for( ; temps != nil; temps = temps->vList.next) {
  233.     undeclareName(true);
  234.   }
  235. }
  236.  
  237. void undeclareBlockArguments(args)
  238. TreeNode args;
  239. {
  240.   if (args == nil) {
  241.     return;
  242.   }
  243.  
  244.   for( ; args != nil; args = args->vList.next) {
  245.     undeclareName(false);
  246.   }
  247. }
  248.  
  249. static void undeclareName(decrFrameIndex)
  250. Boolean decrFrameIndex;
  251. {
  252.   SymbolList    oldList;
  253.  
  254.   oldList = symbolList;
  255.   symbolList = symbolList->prevSymbol;
  256.   free(oldList);
  257.   if (decrFrameIndex) {
  258.     frameIndex--;
  259.   }
  260. }
  261.  
  262. OOP findClassVariable(varName)
  263. OOP    varName;
  264. {
  265.   OOP        classOOP, assocOOP, classVariableOOP;
  266.  
  267.   if (oopClass(thisClass) == behaviorClass
  268.       || oopClass(thisClass) == classDescriptionClass) {
  269.     /* classDescriptions and above don't have class or pool variables */
  270.     /* ### this isn't quite the right test; we probably should be testing
  271.        for if we have a classClass or some derivative of that */
  272.     return (nilOOP);
  273.   }
  274.  
  275.   for (classOOP = thisClass; !isNil(classOOP);
  276.        classOOP = superClass(classOOP)) {
  277.     if (oopClass(classOOP) == metaclassClass) {
  278.       /* pretend that metaclasses have the class variables and shared
  279.      pools that their instance classes do */
  280.       classVariableOOP = metaclassInstance(classOOP);
  281.     } else {
  282.       classVariableOOP = classOOP;
  283.     }
  284.     assocOOP =
  285.       dictionaryAssociationAt(classVariableDictionary(classVariableOOP),
  286.                   varName);
  287.     if (!isNil(assocOOP)) {
  288.       return (assocOOP);
  289.     }
  290.  
  291.     assocOOP = findSharedPoolVariable(classVariableOOP, varName);
  292.     if (!isNil(assocOOP)) {
  293.       return (assocOOP);
  294.     }
  295.   }
  296.  
  297.   return (nilOOP);
  298. }
  299.  
  300.  
  301. SymbolEntry findVariable(varName)
  302. char    *varName;
  303. {
  304.   OOP        varAssoc, symbol;
  305.   int        index;
  306.  
  307.   symbol = internString(varName);
  308.   index = localVarIndex(symbol);
  309.   if (index >= 0) {
  310.     return (allocSymbolEntry(temporaryScope, symbol, index));
  311.   }
  312.  
  313.   index = instanceVariableIndex(symbol);
  314.   if (index >= 0) {
  315.     return (allocSymbolEntry(receiverScope, symbol, index));
  316.   }
  317.  
  318.   varAssoc = findClassVariable(symbol);
  319.   if (isNil(varAssoc)) {
  320.     return (nil);
  321.   }
  322.  
  323.   index = addForcedObject(varAssoc);
  324.  
  325.   return (allocSymbolEntry(globalScope, varAssoc, index));
  326. }
  327.  
  328. static int instanceVariableIndex(symbol)
  329. OOP    symbol;
  330. {
  331.   OOP        arrayOOP;
  332.   int        index, numVars;
  333.  
  334.  
  335.   if (oopClass(thisClass) == behaviorClass) {
  336.     /* behaviors have no instance variables */
  337.     return (-1);
  338.   }
  339.  
  340.   arrayOOP = instanceVariableArray(thisClass);
  341.   numVars = numOOPs(oopToObj(arrayOOP));
  342.  
  343.   for (index = 1; index <= numVars; index++) {
  344.     if (arrayAt(arrayOOP, index) == symbol) {
  345.       return (index-1);
  346.     }
  347.   }
  348.  
  349.   return (-1);
  350. }
  351.  
  352. static int localVarIndex(symbol)
  353. OOP    symbol;
  354. {
  355.   SymbolList    s;
  356.  
  357.   for (s = symbolList; s != nil && symbol != s->symbol; s = s->prevSymbol);
  358.  
  359.   if (s != nil) {        /* found one */
  360.     return (s->index);
  361.   } else {
  362.     return (-1);
  363.   }
  364. }
  365.  
  366. static SymbolEntry allocSymbolEntry(scope, symbol, index)
  367. ScopeType    scope;
  368. OOP        symbol;
  369. int        index;
  370. {
  371.   SymbolEntry    ent;
  372.  
  373.   ent = (SymbolEntry)malloc(sizeof(struct SymbolEntryStruct));
  374.   ent->scope = scope;
  375.   ent->symbol = symbol;
  376.   ent->varIndex = index;
  377.   return (ent);
  378. }
  379.  
  380.  
  381. void freeSymbolEntry(ent)
  382. SymbolEntry ent;
  383. {
  384.   free(ent);
  385. }
  386.  
  387.  
  388. OOP makeInstanceVariableArray(superclassOOP, variableString)
  389. OOP    superclassOOP;
  390. Byte    *variableString;
  391. {
  392.   OOP        arrayOOP, superArrayOOP, name;
  393.   int        index, numInstanceVars, superInstanceVars;
  394.   Byte        *p;
  395.  
  396.   if (variableString == nil) {
  397.     variableString = (Byte *)"";
  398.   }
  399.  
  400.  
  401.   if (isNil(superclassOOP)) {
  402.     superArrayOOP = nilOOP;
  403.     superInstanceVars = numInstanceVars = 0;
  404.   } else {
  405.     superArrayOOP = instanceVariableArray(superclassOOP);
  406.     superInstanceVars = numInstanceVars = numOOPs(oopToObj(superArrayOOP));
  407.   }
  408.  
  409.   for (p = variableString; *p; ) {
  410.     /* skip intervening whitespace */
  411.     name = scanName(&p);
  412.     if (!isNil(name)) {
  413.       numInstanceVars++;
  414.     }
  415.   }
  416.  
  417.   if (numInstanceVars == 0) {
  418.     return (nilOOP);        /* no instances here */
  419.   }
  420.  
  421.   arrayOOP = arrayNew(numInstanceVars);
  422.  
  423.   /* inherit variables from parent */
  424.   for (index = 1; index <= superInstanceVars; index++) {
  425.     arrayAtPut(arrayOOP, index, arrayAt(superArrayOOP, index));
  426.   }
  427.  
  428.   /* now add our own variables */
  429.   for (p = variableString; *p; index++) {
  430.     /* skip intervening whitespace */
  431.     name = scanName(&p);
  432.     if (!isNil(name)) {
  433.       arrayAtPut(arrayOOP, index, name);
  434.     }
  435.   }
  436.  
  437.   return (arrayOOP);
  438. }
  439.  
  440. OOP makeClassVariableDictionary(classOOP, variableNames)
  441. OOP    classOOP;
  442. Byte    *variableNames;
  443. {
  444.   OOP        dictionaryOOP, name;
  445.   int        len;
  446.   Byte        *p;
  447.  
  448.   if (variableNames == nil) {
  449.     variableNames = (Byte *)"";
  450.   }
  451.  
  452.   dictionaryOOP = dictionaryNew();
  453.  
  454.   for (p = variableNames; *p; ) {
  455.     name = scanName(&p);
  456.     if (!isNil(name)) {
  457.       /* ### error if already exists */
  458.       dictionaryAtPut(dictionaryOOP, name, nilOOP);
  459.     }
  460.   }
  461.  
  462.   if (dictionarySize(dictionaryOOP) == 0) {
  463.     dictionaryOOP = nilOOP;
  464.   }
  465.  
  466.   return (dictionaryOOP);
  467. }
  468.  
  469. OOP makePoolArray(classOOP, poolNames)
  470. OOP    classOOP;
  471. Byte     *poolNames;
  472. {
  473.   OOP        pools, name;
  474.   int        len, numPools, i;
  475.   Byte        *p, *e;
  476.  
  477.   if (poolNames == nil) {
  478.     poolNames = (Byte *)"";
  479.   }
  480.   
  481.   /* count the number of new pool names */
  482.   for (p = poolNames, numPools = 0; *p; ) {
  483.     parseVariableName(&p, &e);
  484.     if (p != e) {
  485.       numPools++;
  486.       p = e;
  487.     }
  488.   }
  489.  
  490.   pools = arrayNew(numPools);
  491.  
  492.   for (p = poolNames, i = 1; *p; i++) {
  493.     name = scanName(&p);
  494.     if (!isNil(name)) {
  495.       /* ### error if already exists in parent?,
  496.      or if value isn't a dictionary */
  497.       /* ### should I keep these as names?  or associations?  Should
  498.      I look up the names somewhere other than in the smalltalk
  499.      dictionary?  Need to check for undefineds? */
  500.       arrayAtPut(pools, i, dictionaryAt(smalltalkDictionary, name));
  501.     }
  502.   }
  503.  
  504.   if (numPools == 0) {        /* ### maybe change this to leave empty array */
  505.     pools = nilOOP;
  506.   }
  507.  
  508.   return (pools);
  509. }
  510.  
  511. /*
  512.  *    static OOP scanName(pp)
  513.  *
  514.  * Description
  515.  *
  516.  *    Scan a variable name (letters and digits, initial letter), and return a
  517.  *    symbol for it.
  518.  *
  519.  * Inputs
  520.  *
  521.  *    pp    : pointer to a pointer to the start of the string to be scanned.
  522.  *        May be pointing at either whitespace or start of variable.  At
  523.  *        end, points to first character after the parsed variable name,
  524.  *        which may be NUL. 
  525.  *
  526.  * Outputs
  527.  *
  528.  *    Symbol for variable name, or nilOOP if none found.  pp points to first
  529.  *    char after symbol name (if any).
  530.  */
  531. static OOP scanName(pp)
  532. Byte    **pp;
  533. {
  534.   Byte        *end, *str;
  535.   long        len;
  536.  
  537.   parseVariableName(pp, &end);
  538.   len = end - *pp;
  539.   if (len == 0) {
  540.     return (nilOOP);
  541.   }
  542.  
  543.  
  544.   str = (Byte *)alloca(len + 1);
  545.   strncpy(str, *pp, len);
  546.   str[len] = '\0';
  547.  
  548.   *pp = end;
  549.  
  550.   return (internString(str));
  551. }
  552.  
  553. static void parseVariableName(pp, endp)
  554. Byte    **pp, **endp;
  555. {
  556.   register Byte    *p, *e;
  557.  
  558.   p = *pp;
  559.   e = *endp;
  560.  
  561.   while (isWhiteSpace(*p)) {
  562.     p++;
  563.   }
  564.  
  565.   /* ### check for non-null here and not alnum; we've jammed on a bogus char
  566.      and it's an error */
  567.  
  568.   /* variable name extends from p to e-1 */
  569.   for (e = p; *e; e++) {
  570.     if (!isalnum(*e)) {
  571.       break;
  572.     }
  573.   }
  574.  
  575.   *pp = p;
  576.   *endp = e;
  577. }
  578.  
  579. static Boolean isWhiteSpace(c)
  580. Byte    c;
  581. {
  582.    return (c == ' ' || c == '\t' || c == '\n' || c == '\f');
  583. }
  584.  
  585. OOP internStringOOP(stringOOP)
  586. OOP    stringOOP;
  587. {
  588.   int        len;
  589.  
  590.   len = stringOOPLen(stringOOP);
  591.   return (internCountedString(stringOOPChars(stringOOP), len));
  592. }
  593.  
  594. OOP internString(str)
  595. char    *str;
  596. {
  597.   int        len;
  598.  
  599.   len = strlen(str);
  600.   return (internCountedString(str, len));
  601. }
  602.  
  603. static OOP internCountedString(str, len)
  604. Byte    *str;
  605. int    len;
  606. {
  607.   unsigned long    index;
  608.   int        i;
  609.   SymLink    link;
  610.   Symbol    symbol;
  611.   OOP        symbolOOP, linkOOP;
  612.  
  613.   index = (hashString(str, len) % numOOPs(oopToObj(symbolTable))) + 1;
  614.   for (linkOOP = arrayAt(symbolTable, index); !isNil(linkOOP);
  615.        linkOOP = link->nextLink) {
  616.     link = (SymLink)oopToObj(linkOOP);
  617.     if (isSameString(str, link->symbol, len)) {
  618.       return (link->symbol);
  619.     }
  620.   }
  621.  
  622.   /* no match, have to add it to head of list */
  623.   
  624.   symbol = (Symbol)newInstanceWith(symbolClass, (long)len);
  625.   strncpy(symbol->symString, str, len);
  626.   symbolOOP = allocOOP(symbol);
  627.   symbolOOP->emptyBytes = (4 - len) & 3;
  628.  
  629.   link = (SymLink)newInstance(symLinkClass);
  630.   link->nextLink = arrayAt(symbolTable, index);
  631.   maybeMoveOOP(link->nextLink);    /* make sure it's here with us */
  632.   link->symbol = symbolOOP;
  633.   arrayAtPut(symbolTable, index, allocOOP(link));
  634.   return (symbolOOP);
  635. }
  636.  
  637.  
  638. static Symbol makeNewSymbol(str, len)
  639. Byte    *str;
  640. int    len;
  641. {
  642.   Symbol    symbol;
  643.  
  644.   symbol = (Symbol)newInstanceWith(symbolClass, (long)len);
  645.   strncpy(symbol->symString, str, len);
  646.  
  647.   return (symbol);
  648. }
  649.  
  650. #ifdef preserved_code /* Sun Oct  8 10:30:55 1989 */
  651. /**/static Boolean isSymbol(oop)
  652. /**/OOP    oop;
  653. /**/{
  654. /**/  if (isNil(oop)) {
  655. /**/    return (false);
  656. /**/  }
  657. /**/
  658. /**/  /* ??? are there subclasses of symbol ... do we need to worry about it? */
  659. /**/  return (oop->object->objClass == symbolClass);
  660. /**/}
  661. #endif /* preserved_code Sun Oct  8 10:30:55 1989 */
  662.  
  663. static Boolean isSameString(str, oop, len)
  664. char    *str;
  665. OOP    oop;
  666. int    len;
  667. {
  668.   if (stringOOPLen(oop) == len) {
  669.     return (strncmp(str, ((Symbol)oopToObj(oop))->symString, len) == 0);
  670.   }
  671.  
  672.   return (false);
  673. }
  674.  
  675. int stringOOPLen(oop)
  676. OOP    oop;
  677. {
  678.   return (oopSizeBytes(oop) - oop->emptyBytes);
  679. }
  680.  
  681.  
  682. unsigned long hashString(str, len)
  683. char    *str;
  684. int    len;
  685. {
  686. #ifdef dragon_book
  687. /* from Dragon Book, p436 */
  688.   unsigned long hashVal = 0, carry;
  689.  
  690.   for ( ; len > 0; str++, len--) {
  691.     hashVal = (hashVal << 4) + (*str);
  692.     if (carry = (hashVal & 0xf0000000)) {
  693.       hashVal ^= (carry >> 24);
  694.       hashVal ^= carry;
  695.     }
  696.   }
  697.  
  698.   return (hashVal);
  699. #else
  700.   long    result = 0L;
  701.  
  702.   for (; len > 0; str++, len--) {
  703.     result = (result << 1) /* | (result < 0) */;
  704.     result ^= *str;
  705.   }
  706.  
  707.   return ((unsigned long)result);
  708. #endif /* ! dragon_book */
  709. }
  710.  
  711. void printSymbol(symbol)
  712. OOP    symbol;
  713. {
  714.   if (isNil(symbol)) {
  715.     printf(nilName);
  716.   } else {
  717.     printString(symbol);
  718.   }
  719. }
  720.  
  721. void printString(string)
  722. OOP    string;
  723. {
  724.   int        len;
  725.  
  726.   len = stringOOPLen(string);
  727.   fwrite(oopToObj(string)->data, sizeof(Byte), len, stdout);
  728.   fflush(stdout);
  729. }
  730.  
  731. /*
  732.  *    char *symbolAsString(symbolOOP)
  733.  *
  734.  * Description
  735.  *
  736.  *    Given a symbol, this routine returns a C string that corresponds to the
  737.  *    name of the symbol.  The returned value is a pointer to a static area,
  738.  *    so if it's to be used for anything other than immediate output, the
  739.  *    caller needs to make a copy of the retured string.
  740.  *
  741.  * Inputs
  742.  *
  743.  *    symbolOOP: 
  744.  *        An OOP for a symbol
  745.  *
  746.  * Outputs
  747.  *
  748.  *    Pointer to a C string that contains the symbol name.
  749.  */
  750. char *symbolAsString(symbolOOP)
  751. OOP    symbolOOP;
  752. {
  753.   static char    stringBuf[256];    /* probably large enough for most symbols */
  754.   int        len;
  755.   Symbol    symbol;
  756.  
  757.   symbol = (Symbol)oopToObj(symbolOOP);
  758.  
  759.   len = stringOOPLen(symbolOOP);
  760.   if (len >= sizeof(stringBuf)) {
  761.     errorf("symbol name too long: %d, max is %d", len, sizeof(stringBuf));
  762.   }
  763.   strncpy(stringBuf, symbol->symString, len);
  764.   stringBuf[len] = '\0';
  765.   return (stringBuf);
  766. }
  767.  
  768. /*
  769.  *    void printSymbols()
  770.  *
  771.  * Description
  772.  *
  773.  *    This routine is used for symbol table debugging only.
  774.  *
  775.  */
  776. void printSymbolChain();    /* ### hack */
  777. void printSymbols()
  778. {
  779.   unsigned long    i;
  780.   
  781.   for (i = 1; i <= numOOPs(oopToObj(symbolTable)); i++) {
  782.     printf("Table[%d]:\n", i);
  783.     printSymbolChain(i);
  784.     printf("\n");
  785.   }
  786. }
  787.  
  788. void printSymbolChain(i)
  789. unsigned long i;
  790. {
  791.   SymLink    link;
  792.   OOP        linkOOP;
  793.   for (linkOOP = arrayAt(symbolTable, i); !isNil(linkOOP);
  794.        linkOOP = link->nextLink) {
  795.     link = (SymLink)oopToObj(linkOOP);
  796.     printf("%d:", linkOOP - oopTable); /* ### */
  797.     printSymbol(link->symbol);
  798.     printf("->");
  799.   }
  800. }
  801.  
  802.  
  803. void printSymLink(symLinkOOP)
  804. OOP    symLinkOOP;
  805. {
  806.   SymLink    link;
  807.  
  808.   link = (SymLink)oopToObj(symLinkOOP);
  809.  
  810.   printObject(link->symbol);
  811. }
  812.  
  813. void initSymbols()
  814. {
  815.   andColonSymbol             = internString("and:");
  816.   andSymbol            = internString("&");
  817.   atColonPutColonSymbol         = internString("at:put:");
  818.   atColonSymbol             = internString("at:");
  819.   atEndSymbol                 = internString("atEnd");
  820.   bitAndColonSymbol             = internString("bitAnd:");
  821.   bitOrColonSymbol             = internString("bitOr:");
  822.   bitShiftColonSymbol             = internString("bitShift:");
  823.   blockCopyColonSymbol             = internString("blockCopy:");
  824.   byteArraySymbol        = internString("byteArray");
  825.   charSymbol                    = internString("char");
  826.   classSymbol                 = internString("class");
  827.   cObjectSymbol                 = internString("cObject");
  828.   divideSymbol                 = internString("/");
  829.   doColonSymbol             = internString("do:");
  830.   doesNotUnderstandColonSymbol  = internString("doesNotUnderstand:");
  831.   doubleSymbol                  = internString("double");
  832.   equalSymbol                 = internString("=");
  833.   falseSymbol            = internString("false");
  834.   greaterEqualSymbol             = internString(">=");
  835.   greaterThanSymbol             = internString(">");
  836.   ifFalseColonIfTrueColonSymbol = internString("ifFalse:ifTrue:");
  837.   ifFalseColonSymbol             = internString("ifFalse:");
  838.   ifTrueColonIfFalseColonSymbol = internString("ifTrue:ifFalse:");
  839.   ifTrueColonSymbol             = internString("ifTrue:");
  840.   integerDivideSymbol             = internString("//");
  841.   intSymbol                     = internString("int");
  842.   lessEqualSymbol             = internString("<=");
  843.   lessThanSymbol             = internString("<");
  844.   longSymbol                    = internString("long");
  845.   minusSymbol                 = internString("-");
  846.   newColonSymbol             = internString("new:");
  847.   newSymbol                 = internString("new");
  848.   nextPutColonSymbol             = internString("nextPut:");
  849.   nextSymbol                 = internString("next");
  850.   nilSymbol            = internString("nil");
  851.   notEqualSymbol             = internString("~=");
  852.   notSameObjectSymbol        = internString("~~");
  853.   orColonSymbol             = internString("or:");
  854.   orSymbol            = internString("|");
  855.   plusSymbol                 = internString("+");
  856.   remainderSymbol             = internString("\\");
  857.   sameObjectSymbol             = internString("==");
  858.   selfSymbol            = internString("self");
  859.   sizeSymbol                 = internString("size");
  860.   smalltalkSymbol        = internString("smalltalk");
  861.   stringOutSymbol               = internString("stringOut");
  862.   stringSymbol                  = internString("string");
  863.   superSymbol            = internString("super");
  864.   symbolSymbol                  = internString("symbol");
  865.   thisContextSymbol        = internString("thisContext");
  866.   timesSymbol                 = internString("*");
  867.   trueSymbol            = internString("true");
  868.   unknownSymbol                 = internString("unknown");
  869.   valueColonSymbol             = internString("value:");
  870.   valueColonValueColonSymbol    = internString("value:value:");
  871.   valueColonValueColonValueColonSymbol = internString("value:value:value:");
  872.   valueSymbol                 = internString("value");
  873.   valueWithArgumentsColonSymbol = internString("valueWithArguments:");
  874.   variadicSymbol                = internString("variadic");
  875.   voidSymbol                    = internString("void");
  876.   whileFalseColonSymbol            = internString("whileFalse:");
  877.   whileTrueColonSymbol             = internString("whileTrue:");
  878. }
  879.