macross/lookups.c
2016-01-21 22:02:21 +01:00

543 lines
13 KiB
C

/*
* Copyright (c) 1987 Fujitsu
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/*
lookups.c -- Routines to lookup things in tables.
Chip Morningstar -- Lucasfilm Ltd.
5-November-1984
*/
#include "macrossTypes.h"
#include "macrossGlobals.h"
/*
These routines all do basically the same thing. Various kinds of keywords
and so forth are stored in hash tables. The hash buckets contain linked
lists that are sorted alphabetically.
*/
conditionType
lookupConditionCode(s, hashValue)
char *s;
int hashValue;
{
conditionTableEntryType *result;
genericTableEntryType *prehashedStringLookup();
result = (conditionTableEntryType *) prehashedStringLookup(s,
conditionTable, hashValue);
if (result != NULL)
return(result->code);
else
return(NOT_FOUND_COND);
}
int
lookupKeyword(s, hashValue)
char *s;
int hashValue;
{
keywordTableEntryType *result;
genericTableEntryType *prehashedStringLookup();
result = (keywordTableEntryType *) prehashedStringLookup(s,
keywordTable, hashValue);
if (result != NULL)
return(result->token);
else
return(0);
}
macroTableEntryType *
lookupMacroName(s, hashValue)
char *s;
int hashValue;
{
genericTableEntryType *prehashedStringLookup();
return((macroTableEntryType *) prehashedStringLookup(s, macroTable,
hashValue));
}
opcodeTableEntryType *
lookupOpcode(s, hashValue)
char *s;
int hashValue;
{
genericTableEntryType *prehashedStringLookup();
return((opcodeTableEntryType *) prehashedStringLookup(s,
opcodeTable, hashValue));
}
/* lookupOrEnterSymbol -- if there is an entry in the symbol table for the
given symbol, return that entry, otherwise create a new entry for it of
the given kind and return *that* */
symbolTableEntryType *
lookupOrEnterSymbol(s, kind)
stringType *s;
symbolUsageKindType kind;
{
symbolTableEntryType *result;
genericTableEntryType *hashStringLookup();
genericTableEntryType *hashStringEnter();
symbolTableEntryType *buildSymbolTableEntry();
if (result = (symbolTableEntryType *)hashStringLookup(s,symbolTable)){
/* result->referenceCount++;*/
return(result);
} else
return((symbolTableEntryType *)
hashStringEnter(buildSymbolTableEntry(s, kind),
symbolTable));
}
void
pushSymbol(symbol)
symbolTableEntryType *symbol;
{
symbolInContextType *newContext;
newContext = typeAlloc(symbolInContextType);
newContext->pushedContexts = symbol->context;
symbol->context = newContext;
}
void
popSymbol(symbol)
symbolTableEntryType *symbol;
{
symbolInContextType *deadContext;
deadContext = symbol->context;
if (deadContext == NULL)
botch("symbol pop underflow\n");
else {
symbol->context = deadContext->pushedContexts;
if (freeFlag) {
if (deadContext->value != NULL)
freeValue(deadContext->value);
free(deadContext);
}
}
}
macroTableEntryType *
createMacro(macroName)
stringType *macroName;
{
macroTableEntryType *result;
symbolTableEntryType *testSymbol;
genericTableEntryType *hashStringLookup();
genericTableEntryType *hashStringEnter();
macroTableEntryType *buildMacroTableEntry();
symbolTableEntryType *lookupOrEnterSymbol();
testSymbol = lookupOrEnterSymbol(macroName, MACRO_SYMBOL);
if (testSymbol->context->usage != MACRO_SYMBOL) {
error(SYMBOL_ALREADY_THERE_ERROR, symbName(testSymbol));
return(NULL);
} else if (hashStringLookup(macroName, macroTable) != NULL) {
error(SYMBOL_ALREADY_THERE_ERROR, symbName(testSymbol));
return(NULL);
} else {
result = (macroTableEntryType *)
hashStringEnter(buildMacroTableEntry(macroName),
macroTable);
result->body = NULL;
return(result);
}
}
/*
Generic table lookup utility routines
*/
genericTableEntryType *
prehashedStringLookup(s, table, hashValue)
char *s;
genericTableEntryType *table[];
int hashValue;
{
genericTableEntryType *result;
int test;
result = table[hashValue];
while (result != NULL) {
if ((test = strcmplc(s, result->string)) == 0)
break;
else if (test > 0) {
result = NULL;
break;
} else {
result = result->next;
}
}
return(result);
}
genericTableEntryType *
hashStringLookup(s, table)
char *s;
genericTableEntryType *table[];
{
return(prehashedStringLookup(s, table, hashString(s)));
}
genericTableEntryType *
hashStringEnter(entry, table)
genericTableEntryType *entry;
genericTableEntryType *table[];
{
genericTableEntryType *result;
genericTableEntryType *oldResult;
int test;
int hashValue;
hashValue = hashString(entry->string);
result = table[hashValue];
if (result == NULL) {
table[hashValue] = entry;
entry->next = NULL;
return(entry);
}
oldResult = NULL;
while (result != NULL) {
if ((test = strcmplc(entry->string, result->string)) == 0) {
botch("symbol table entry %s already there\n",
entry->string);
} else if (test > 0) {
entry->next = result;
if (oldResult == NULL)
table[hashValue] = entry;
else
oldResult->next = entry;
return(entry);
} else {
oldResult = result;
result = result->next;
}
}
if (oldResult == NULL)
table[hashValue] = entry;
else
oldResult->next = entry;
entry->next = NULL;
return(entry);
}
int
hashString(s)
char *s;
{
unsigned result;
result = 0;
while (*s != '\0')
result = (result << 1) + toLowerCase(*s++);
return(result & HASH_TABLE_MASK);
}
bool
strcmplc(s1, s2) /* string compare in lower case */
char *s1; /* heavily optimized version */
char *s2;
{
char c1;
int result;
do {
c1 = toLowerCase(*s1++);
/* if result != 0, they differ */
if (result = c1 - toLowerCase(*s2++)) {
return(result); /* c1<c2==neg, c1>c2==pos */
} else if (!c1) { /* if they're null, we're done */
return(0);
}
} while (TRUE);
}
bool
strcmplct(s1, s2) /* For tables: s2 is already lower case */
char *s1; /* heavily optimized version. */
char *s2;
{
char c1;
int result;
while (TRUE) {
c1 = toLowerCase(*s1++);
if (result = c1 - (*s2++)) { /* if result != 0, they differ */
return(result); /* c1<c2==neg, c1>c2==pos */
} else if (!c1) { /* if they're null, we're done */
return(0);
}
}
}
void
purgeSymbol(symbol)
symbolTableEntryType *symbol;
{
symbolInContextType *context;
symbolInContextType *getWorkingContext();
if ((context = getWorkingContext(symbol)) != NULL)
context->usage = DEAD_SYMBOL;
}
void
reincarnateSymbol(context, newUsage)
symbolInContextType *context;
symbolUsageKindType newUsage;
{
context->attributes = 0;
dupValue(context->value, UndefinedValue);
context->usage = newUsage;
}
/*
Routines to handle assembly-time binding of symbols to contexts.
*/
void
pushBinding(symbol, newBinding, newUsage)
symbolTableEntryType *symbol;
valueType *newBinding;
symbolUsageKindType newUsage;
{
valueType *newValue();
pushSymbol(symbol);
if (newBinding == NULL)
newBinding = newValue(FAIL, 0, EXPRESSION_OPND);
symbol->context->value = newBinding;
symbol->context->usage = newUsage;
symbol->context->environmentNumber = currentEnvironment->
environmentNumber;
symbol->context->attributes = DEFINED_VARIABLE_ATT;
}
void
popBinding(symbol)
symbolTableEntryType *symbol;
{
popSymbol(symbol);
}
int /* returns number of bindings completed, negative this if failure */
bindMacroArguments(argumentList, parameterList, macroName)
argumentDefinitionListType *argumentList;
operandListType *parameterList;
stringType *macroName;
{
int numberBound;
bool arrayTag;
int arrayLength;
valueType **arrayContents;
int i;
valueType *newValue();
if (argumentList == NULL)
arrayTag = FALSE;
else
arrayTag = ((argumentListHeadType *)argumentList)->arrayTag;
numberBound = 1;
while (argumentList!=NULL && (!arrayTag || argumentList->
nextArgument!=NULL) && parameterList!=NULL) {
pushBinding(argumentList->theArgument, newValue(OPERAND_VALUE,
parameterList, EXPRESSION_OPND), ARGUMENT_SYMBOL);
argumentList = argumentList->nextArgument;
parameterList = parameterList->nextOperand;
numberBound++;
}
if (!arrayTag) {
if (parameterList != NULL) {
error(TOO_MANY_ARGUMENTS_TO_MACRO_ERROR, macroName,
numberBound-1);
return(-numberBound);
}
while (argumentList != NULL) {
pushBinding(argumentList->theArgument, newValue(FAIL,
0, EXPRESSION_OPND), ARGUMENT_SYMBOL);
argumentList = argumentList->nextArgument;
numberBound++;
}
} else {
if (parameterList == NULL) {
while (argumentList->nextArgument != NULL) {
pushBinding(argumentList->theArgument,
newValue(FAIL, 0, EXPRESSION_OPND),
ARGUMENT_SYMBOL);
argumentList = argumentList->nextArgument;
numberBound++;
}
}
arrayLength = countParameters(parameterList);
pushBinding(argumentList->theArgument, newValue(ARRAY_VALUE,
allocArray(arrayLength, &arrayContents),
EXPRESSION_OPND), ARGUMENT_SYMBOL);
for (i=0; i<arrayLength; ++i) {
arrayContents[i] = newValue(OPERAND_VALUE,
parameterList, EXPRESSION_OPND);
parameterList = parameterList->nextOperand;
}
numberBound++;
}
return(numberBound);
}
int /* returns number of bindings completed, negative this if failure */
bindFunctionArguments(argumentList, parameterList, functionName)
argumentDefinitionListType *argumentList;
operandListType *parameterList;
stringType *functionName;
{
valueType *argument;
bool arrayTag;
int arrayLength;
valueType **arrayContents;
int i;
int numberBound;
valueType *firstArgument;
environmentType *saveEnvironment;
valueType *evaluateOperand();
valueType *newValue();
if (argumentList == NULL)
arrayTag = FALSE;
else
arrayTag = ((argumentListHeadType *)argumentList)->arrayTag;
numberBound = 1;
firstArgument = NULL;
while (argumentList!=NULL && (!arrayTag || argumentList->
nextArgument!=NULL) && parameterList!=NULL) {
saveEnvironment = currentEnvironment;
currentEnvironment = currentEnvironment->previousEnvironment;
argument = evaluateOperand(parameterList, NO_FIXUP);
currentEnvironment = saveEnvironment;
if (firstArgument == NULL)
firstArgument = argument;
if (isUsable(argument)) {
pushBinding(argumentList->theArgument, argument,
ARGUMENT_SYMBOL);
argumentList = argumentList->nextArgument;
parameterList = parameterList->nextOperand;
expand((argumentList!=NULL && parameterList!=NULL) ?
moreExpression(", ") : 0);
numberBound++;
} else {
if (isUndefined(argument))
resultOfLastFunctionCall =
newValue(UNDEFINED_VALUE, 0,
firstArgument->addressMode);
return(-numberBound);
}
}
if (!arrayTag) {
if (parameterList != NULL) {
error(TOO_MANY_ARGUMENTS_TO_FUNCTION_ERROR,
functionName, numberBound - 1);
return(-numberBound);
}
while (argumentList != NULL) {
pushBinding(argumentList->theArgument, newValue(FAIL,
0, EXPRESSION_OPND), ARGUMENT_SYMBOL);
argumentList = argumentList->nextArgument;
numberBound++;
}
} else {
if (parameterList == NULL) {
while (argumentList->nextArgument != NULL) {
pushBinding(argumentList->theArgument,
newValue(FAIL, 0, EXPRESSION_OPND),
ARGUMENT_SYMBOL);
argumentList = argumentList->nextArgument;
numberBound++;
}
}
arrayLength = countParameters(parameterList);
pushBinding(argumentList->theArgument, newValue(ARRAY_VALUE,
allocArray(arrayLength, &arrayContents),
EXPRESSION_OPND), ARGUMENT_SYMBOL);
numberBound++;
for (i=0; i<arrayLength; ++i) {
saveEnvironment = currentEnvironment;
currentEnvironment = currentEnvironment->
previousEnvironment;
argument = evaluateOperand(parameterList, NO_FIXUP);
currentEnvironment = saveEnvironment;
if (firstArgument == NULL)
firstArgument = argument;
if (isUsable(argument)) {
arrayContents[i] = argument;
parameterList = parameterList->nextOperand;
} else {
if (isUndefined(argument))
resultOfLastFunctionCall =
newValue(UNDEFINED_VALUE, 0,
firstArgument->addressMode);
return(-numberBound);
}
}
}
return(numberBound);
}
void
unbindArguments(argumentList, numberToUnbind)
argumentDefinitionListType *argumentList;
int numberToUnbind;
{
while (argumentList != NULL && numberToUnbind-- > 0) {
popBinding(argumentList->theArgument);
argumentList = argumentList->nextArgument;
}
if (numberToUnbind > 0)
botch("binding count larger than number of bindings\n");
}
void
unbindLocalVariables(identifierList)
identifierListType *identifierList;
{
identifierListType *deadEntry;
while (identifierList != NULL) {
popBinding(identifierList->theSymbol);
deadEntry = identifierList;
identifierList = identifierList->nextIdentifier;
qfree(deadEntry);
}
}