public SymbolTableReader(ISymbolTable symbolTable)
{
_symbolTable = symbolTable ?? throw new ArgumentNullException(nameof(symbolTable));
lock (_symbolTable)
{
_maxId = _symbolTable.MaxId;
_localSymbolsEnumerator = _symbolTable.GetDeclaredSymbolNames().GetEnumerator();
}
if (!_symbolTable.IsLocal)
{
SetFlag(HAS_NAME, true);
SetFlag(HAS_VERSION, true);
}
//what is this???
if (_maxId > 0)
{
// FIXME: is this ever true?
SetFlag(HAS_MAX_ID, true);
}
_importedTables = _symbolTable.GetImportedTables().ToArray();
if (_importedTables != null && _importedTables.Length > 0)
{
SetFlag(HAS_IMPORT_LIST, true);
}
if (_symbolTable.GetImportedMaxId() < _maxId)
{
SetFlag(HAS_SYMBOL_LIST, true);
}
}
private static void AssertTable(ISymbolTable table, string name, int version, IReadOnlyList <string> symbols)
{
Assert.IsTrue(table.IsShared);
Assert.IsFalse(table.IsSystem);
Assert.IsNull(table.GetSystemTable());
Assert.IsTrue(table.IsReadOnly);
Assert.AreEqual(name, table.Name);
Assert.AreEqual(version, table.Version);
Assert.AreEqual(0, table.GetImportedMaxId());
Assert.AreEqual(symbols.Count, table.MaxId);
var foundSymbols = new HashSet <string>();
using (var iter = table.GetDeclaredSymbolNames().GetEnumerator())
{
for (var i = 0; i < symbols.Count; i++)
{
var sid = i + 1;
var text = symbols[i];
Assert.IsTrue(iter.MoveNext());
Assert.AreEqual(text, iter.Current);
var duplicate = text != null && !foundSymbols.Add(text);
SymTabUtils.AssertSymbolInTable(text, sid, duplicate, table);
}
Assert.IsFalse(iter.MoveNext());
}
}
/// <inheritdoc />
/// <summary>
/// this computes the actual move to the next state and
/// update the current read value accordingly
/// </summary>
public IonType MoveNext()
{
if (!HasNext())
{
return(IonType.None);
}
var newState = _currentState;
switch (_currentState)
{
default:
ThrowUnrecognizedState(_currentState);
newState = -1;
break;
case S_BOF:
newState = S_STRUCT;
break;
case S_STRUCT:
//jump to the end if next() is called at S_STRUCT
//call stepin() to get into the struct
newState = S_EOF;
break;
case S_IN_STRUCT:
newState = StateFirstInStruct();
LoadStateData(newState);
break;
case S_NAME:
Debug.Assert(HasVersion());
newState = S_VERSION;
LoadStateData(newState);
break;
case S_VERSION:
if (HasMaxId())
{
newState = S_MAX_ID;
LoadStateData(newState);
break;
}
newState = StateFollowingMaxId();
break;
case S_MAX_ID:
newState = StateFollowingMaxId();
break;
case S_IMPORT_LIST:
newState = StateFollowingImportList(Op.Next);
break;
case S_IN_IMPORTS:
case S_IMPORT_STRUCT:
// we only need to get the import list once, which we
// do as we step into the import list, so it should
// be waiting for us here.
newState = NextImport();
break;
case S_IN_IMPORT_STRUCT:
// shared tables have to have a name
newState = S_IMPORT_NAME;
LoadStateData(newState);
break;
case S_IMPORT_NAME:
// shared tables have to have a version
newState = S_IMPORT_VERSION;
LoadStateData(newState);
break;
case S_IMPORT_VERSION:
// and they also always have a max id - so we set up
// for it
newState = S_IMPORT_MAX_ID;
LoadStateData(newState);
break;
case S_IMPORT_MAX_ID:
newState = S_IMPORT_STRUCT_CLOSE;
break;
case S_IMPORT_STRUCT_CLOSE:
case S_IMPORT_LIST_CLOSE:
// no change here - we just bump up against this local eof
break;
case S_AFTER_IMPORT_LIST:
Debug.Assert(_symbolTable.GetImportedMaxId() < _maxId);
newState = S_SYMBOL_LIST;
break;
case S_SYMBOL_LIST:
Debug.Assert(_symbolTable.GetImportedMaxId() < _maxId);
newState = StateFollowingLocalSymbols();
break;
case S_IN_SYMBOLS:
// we have some symbols - so we'll set up to read them, which we *have* to do once and *need* to do only once.
// since we only get into the symbol list if there are some symbols - our next state
// is at the first symbol so we just fall through to and let the S_SYMBOL
// state do it's thing (which it will do every time we move to the next symbol)
case S_SYMBOL:
Debug.Assert(_localSymbolsEnumerator != null);
if (_localSymbolsEnumerator.MoveNext())
{
_stringValue = _localSymbolsEnumerator.Current;
// null means this symbol isn't defined
newState = S_SYMBOL;
break;
}
newState = S_SYMBOL_LIST_CLOSE;
break;
case S_SYMBOL_LIST_CLOSE:
// no change here - we just bump up against this local eof
newState = S_SYMBOL_LIST_CLOSE;
break;
case S_STRUCT_CLOSE:
case S_EOF:
// no change here - we just bump up against this local eof
break;
}
_currentState = newState;
return(StateType(_currentState));
}