/// <summary>
/// Inserts the specified token at the given depth.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="depth">The depth.</param>
public void Insert(Token token, int depth)
{
var index = (int)Hash(token.Lexeme) % PRIME_TABLE_SIZE;
var newEntry = new LinkedListNode<Entry>
{
Value = new Entry
{
Token = token,
Depth = depth
}
};
// Collision
if (this._Table[index] != null)
{
var possibleDuplicateEntry = this.Lookup(token.Lexeme);
// possibleDuplicateEntry is the latest [Lexeme] inserted into the table
if (possibleDuplicateEntry != null && possibleDuplicateEntry.Depth == depth)
{
throw new DuplicateEntryException(token.Lexeme);
}
newEntry.Next = this._Table[index];
this._Table[index].Previous = newEntry;
}
this._Table[index] = newEntry;
}
/// <summary>
/// Determines whether the specified item is boolean.
/// </summary>
/// <param name="item">The item.</param>
/// <returns></returns>
private static bool IsBoolean(Token item)
{
return item.Type == TokenType.True || item.Type == TokenType.False;
}
/// <summary>
/// Determines whether [is number or variable] [the specified token].
/// </summary>
/// <param name="token">The token.</param>
/// <returns></returns>
private static bool IsNumberOrVariable(Token token)
{
return
token.Type == TokenType.LiteralInteger ||
token.Type == TokenType.LiteralReal ||
token.Type == TokenType.Identifier;
}
/// <summary>
/// Pushes the specified token.
/// </summary>
/// <param name="token">The token.</param>
public void Push(Token token)
{
_Tokens.Add(token);
}
private void InsertClass(Token identifier)
{
CurrentClass = new ClassEntry
{
MethodNames = null,
Fields = null,
SizeOfLocal = 0
};
SymbolTable.Insert(identifier, Depth);
var entry = SymbolTable.Lookup(identifier.Lexeme);
entry.Type = EntryType.Class;
entry.Content = CurrentClass;
}
private void InsertMethod(TokenType returnType, Token identifier)
{
// Get type
var _returnType = GetDataType(returnType);
CurrentMethod = new MethodEntry
{
NumberOfParameters = 0,
Parameters = null,
ReturnType = _returnType,
SizeOfLocal = 0
};
// Insert formal parameter
SymbolTable.Insert(identifier, Depth);
var entry = SymbolTable.Lookup(identifier.Lexeme);
entry.Type = EntryType.Function;
entry.Content = CurrentMethod;
// Add method name to class
var methodName = new Models.Table.LinkedListNode<string> { Value = identifier.Lexeme };
methodName.Next = CurrentClass.MethodNames;
CurrentClass.MethodNames = methodName;
}
private void InsertVariable(TokenType dataType, Token identifier, bool isConstant = false, string value = "")
{
// Get type
var _dataType = GetDataType(dataType);
var _size = GetDataTypeSize(_dataType);
var _offset = 0;
var _scope = CurrentVariableScope;
if (_scope == VariableScope.MethodParameter)
{
var paramType = new Models.Table.LinkedListNode<KeyValuePair<string, VariableType>>
{
Value = new KeyValuePair<string, VariableType>(identifier.Lexeme, _dataType)
};
paramType.Next = CurrentMethod.Parameters;
CurrentMethod.Parameters = paramType;
CurrentMethod.NumberOfParameters++;
CurrentMethod.ParameterSize += _size;
}
else if (_scope == VariableScope.ClassBody)
{
var field = new Models.Table.LinkedListNode<string> { Value = identifier.Lexeme };
field.Next = CurrentClass.Fields;
CurrentClass.Fields = field;
CurrentClass.SizeOfLocal += _size;
_offset = Offset;
Offset += _size;
}
else if (_scope == VariableScope.MethodBody)
{
CurrentMethod.SizeOfLocal += _size;
_offset = Offset;
Offset += _size;
}
// Insert formal parameter
SymbolTable.Insert(identifier, Depth);
var entry = SymbolTable.Lookup(identifier.Lexeme);
if (isConstant)
{
entry.Type = EntryType.Constant;
entry.Content = new ConstantEntry
{
DataType = _dataType,
Offset = _offset,
Value = value
};
}
else
{
entry.Type = EntryType.Variable;
entry.Content = new VariableEntry
{
DataType = _dataType,
Offset = _offset,
Size = _size
};
}
}
