private void Engine_ScannerNewData(string arg1, string arg2)
{
try {
ScannerInfo.Add(arg1, arg2);
}
catch { }
}
private void OnInitialize()
{
m_lexicon = new Lexicon();
OnDefineLexer(m_lexicon, m_triviaTokens);
m_scannerInfo = OnCreateScannerInfo();
var production = OnDefineGrammar();
if (production == null)
{
throw new InvalidOperationException("Root producton is not defined");
}
var rootProduction = production.SuffixedBy(Grammar.Eos());
m_productionInfoManager = new ProductionInfoManager(rootProduction);
m_transitionTable = OnCreateTransitionTable(OnCreateAutomaton(m_productionInfoManager), m_scannerInfo);
OnDefineParserErrors(m_errorDefinition, m_errorManager);
m_isInitialized = true;
}
public void OpenIncomingInteractionChannel(string localSerialNumber, string localIpAddress)
{
CodeContract.Requires(!string.IsNullOrEmpty(localSerialNumber));
CodeContract.Requires(!string.IsNullOrEmpty(localIpAddress));
if (_hostChannel != null)
{
return;
}
_localScannerInfo = new ScannerInfo(localSerialNumber, localIpAddress);
try
{
IDictionary props = new Hashtable();
props["name"] = "BpcTcpChannel";
props["port"] = REMOTE_INTERACTION_PORT;
_hostChannel = new TcpChannel(
props,
new BinaryClientFormatterSinkProvider(),
new BinaryServerFormatterSinkProvider());
ChannelServices.RegisterChannel(_hostChannel, false);
Logger.LogInfo(Message.SyncChannelOpened, localIpAddress);
}
catch (Exception ex)
{
Logger.LogError(Message.SyncOpenInteractionChannelError, ex);
}
}
public ForkableScannerBuilder(ScannerInfo info)
{
CodeContract.RequiresArgumentNotNull(info, "info");
m_info = info;
m_triviaTokens = new int[0];
}
private void OnInitialize()
{
m_lexicon = new Lexicon();
OnDefineLexer(m_lexicon, m_triviaTokens);
m_scannerInfo = OnCreateScannerInfo();
var parser = OnDefineParser();
if (parser == null)
{
throw new InvalidOperationException("Parser not defined");
}
m_parser = parser.SuffixedBy(Parsers.Eos());
m_context = new ParserContext(m_errorManager, m_unexpectedTokenErrorId, m_missingTokenErrorId);
OnDefineParserErrors(m_errorManager);
m_parserRunner = new ParserRunner <T>(m_parser, m_context);
m_scannerBuilder = new ForkableScannerBuilder(m_scannerInfo);
m_scannerBuilder.SetTriviaTokens(m_triviaTokens.Select(t => t.Index).ToArray());
m_scannerBuilder.ErrorManager = m_errorManager;
m_scannerBuilder.RecoverErrors = true;
m_scannerBuilder.LexicalErrorId = m_lexicalErrorId;
m_isInitialized = true;
}
public ForkableScannerBuilder(ScannerInfo info)
{
CodeContract.RequiresArgumentNotNull(info, "info");
m_info = info;
m_triviaTokens = new int[0];
}
private void MainForm_Load(object sender, EventArgs e)
{
this.ClientSize = Properties.Settings.Default.formSize;
Visibility.Update();
progressMain.ProgressText = "Updating Name Lookups from abgx.net";
_scanner = new GameScanner();
_scanner.OnGameProcessed += _loader_OnGameScanned;
_scanner.OnStatusUpdate += _loader_OnStatusUpdate;
_scanner.OnFinish += _loader_OnScanFinish;
_scrapper = new WebScrapper();
_scrapper.OnGameProcessed += _OnGameProcessed;
_scrapper.OnStatusUpdate += _loader_OnStatusUpdate;
_scrapper.OnFinish += _loader_OnFinish;
_abgx = new AbgxChecker();
_abgx.OnFinish += _loader_OnFinish;
_abgx.OnGameProcessed += _OnGameProcessed;
_abgx.OnStatusUpdate += _loader_OnStatusUpdate;
_move = new MoveProcessor();
_move.OnFinish += _loader_OnFinish;
_move.OnGameProcessed += _OnGameProcessed;
_move.OnStatusUpdate += _loader_OnStatusUpdate;
_info = new ScannerInfo();
progressMain.ProgressText = "";
progressSub.ProgressText = "";
if (Program.Wizard)
{
menuSettings_Click(null, null);
}
}
private void OnInitialize()
{
m_lexicon = new Lexicon();
OnDefineLexer(m_lexicon, m_triviaTokens);
m_scannerInfo = OnCreateScannerInfo();
var production = OnDefineGrammar();
if (production == null)
{
throw new InvalidOperationException("Root producton is not defined");
}
var rootProduction = production.SuffixedBy(Grammar.Eos());
m_productionInfoManager = new Generator.ProductionInfoManager(rootProduction);
m_transitionTable = OnCreateTransitionTable();
OnDefineParserErrors(m_errorDefinition, m_errorManager);
m_scanner = new Scanner(m_scannerInfo);
m_scanner.SetTriviaTokens(m_triviaTokens.Select(t => t.Index).ToArray());
m_scanner.ErrorManager = m_errorManager;
m_scanner.RecoverErrors = true;
m_scanner.LexicalErrorId = m_errorDefinition.LexicalErrorId;
m_isInitialized = true;
}
internal Lexeme(ScannerInfo scannerInfo, int state, SourceSpan span, string content)
{
m_scannerInfo = scannerInfo;
m_stateIndex = state;
Value = new LexemeValue(content, span);
m_trivia = s_emptyTrivia;
}
void barcodeManager_Connection(object sender, BarcodeManager.ScannerConnectionEventArgs e)
{
string status;
string scannerName = "";
ScannerInfo scannerInfo = e.P0;
BarcodeManager.ConnectionState connectionState = e.P1;
string statusBT = connectionState.ToString();
string scannerNameBT = scannerInfo.FriendlyName;
if (scannerList.Count != 0)
{
scannerName = scannerList[scannerIndex].FriendlyName;
}
if (scannerName.ToLower().Equals(scannerNameBT.ToLower()))
{
status = "Status: " + scannerNameBT + ":" + statusBT;
RunOnUiThread(() => textViewStatus.Text = status);
if (connectionState == BarcodeManager.ConnectionState.Connected)
{
// Bluetooth scanner connected
// Restore continuous mode flag
isContinuousMode = isContinuousModeSaved;
// Initialize scanner
InitScanner();
SetTrigger();
SetDecoders();
}
if (connectionState == BarcodeManager.ConnectionState.Disconnected)
{
// Bluetooth scanner disconnected
// Save the current state of continuous mode flag
isContinuousModeSaved = isContinuousMode;
// Reset continuous flag
isContinuousMode = false;
// De-initialize scanner
DeInitScanner();
// Enable UI Controls
RunOnUiThread(() => EnableUIControls(true));
}
}
else
{
status = "Status: " + statusString + " " + scannerNameBT + ":" + statusBT;
RunOnUiThread(() => textViewStatus.Text = status);
}
}
private void BarcodeManager_Connection(object sender, BarcodeManager.ScannerConnectionEventArgs e)
{
ScannerInfo scannerInfo = e.P0;
BarcodeManager.ConnectionState connectionState = e.P1;
string statusBT = connectionState.ToString();
string scannerNameBT = scannerInfo.FriendlyName;
}
public void ThrowExceptionAtEosTest()
{
Lexicon lexicon = new Lexicon();
Lexer global = lexicon.Lexer;
var ID = global.DefineToken(RE.Range('a', 'z').Concat(
(RE.Range('a', 'z') | RE.Range('0', '9')).Many()));
var NUM = global.DefineToken(RE.Range('0', '9').Many1());
var WHITESPACE = global.DefineToken(RE.Symbol(' ').Many());
var ERROR = global.DefineToken(RE.Range(Char.MinValue, (char)255));
ScannerInfo info = lexicon.CreateScannerInfo();
Compiler.Scanner.Scan.Scanner scanner = new Compiler.Scanner.Scan.Scanner(info);
string source = "aaa bbb ccc";
StringReader sr = new StringReader(source);
scanner.SetSource(new SourceReader(sr));
scanner.SetTriviaTokens(WHITESPACE.Index, ERROR.Index);
scanner.ThrowAtReadingAfterEndOfStream = true;
Lexeme l1 = scanner.Read();
Assert.AreEqual(ID.Index, l1.TokenIndex);
Assert.AreEqual("aaa", l1.ToContentString());
Assert.AreEqual(0, l1.PrefixTrivia.Count);
Lexeme l2 = scanner.Read();
Assert.AreEqual(ID.Index, l2.TokenIndex);
Assert.AreEqual("bbb", l2.ToContentString());
Assert.AreEqual(1, l2.PrefixTrivia.Count);
Lexeme l3 = scanner.Read();
Assert.AreEqual(ID.Index, l3.TokenIndex);
Assert.AreEqual("ccc", l3.ToContentString());
Assert.AreEqual(1, l3.PrefixTrivia.Count);
Lexeme leof = scanner.Read();
Assert.AreEqual(info.EndOfStreamTokenIndex, leof.TokenIndex);
Assert.AreEqual(leof.Span.StartLocation.CharIndex, leof.Span.EndLocation.CharIndex);
Assert.AreEqual(source.Length, leof.Span.StartLocation.CharIndex);
try
{
Lexeme leof2 = scanner.Read();
Assert.Fail("The Read above should throw an exception");
}
catch (ScannerException)
{
Assert.True(true);
}
}
public void ForkableScannerTest()
{
Lexicon lexicon = new Lexicon();
var A = lexicon.DefaultLexer.DefineToken(RE.Range('a', 'z'));
ScannerInfo si = lexicon.CreateScannerInfo();
string source = "abcdefghijklmnopqrstuvwxyz";
ForkableScannerBuilder fsBuilder = new ForkableScannerBuilder(si);
ForkableScanner fscanner = fsBuilder.Create(new SourceReader(new StringReader(source)));
var l1 = fscanner.Read();
Assert.AreEqual("a", l1.Value);
var l2 = fscanner.Read();
Assert.AreEqual("b", l2.Value);
//fork
ForkableScanner fscanner2 = fscanner.Fork();
for (int i = 2; i <= 4; i++)
{
var l = fscanner.Read();
Assert.AreEqual(source[i].ToString(), l.Value);
}
for (int i = 2; i <= 5; i++)
{
var l = fscanner2.Read();
Assert.AreEqual(source[i].ToString(), l.Value);
}
ForkableScanner fscanner3 = fscanner.Fork();
var l5a = fscanner.Read();
var l5b = fscanner3.Read();
Assert.AreEqual(source[5].ToString(), l5a.Value);
Assert.AreEqual(source[5].ToString(), l5b.Value);
var l6b = fscanner2.Read();
var l6a = fscanner3.Read();
Assert.AreEqual(source[6].ToString(), l6a.Value);
Assert.AreEqual(source[6].ToString(), l6b.Value);
var l7a = fscanner2.Read();
for (int i = 7; i < 9; i++)
{
var l = fscanner3.Read();
Assert.AreEqual(source[i].ToString(), l.Value);
}
}
public bool ReadScanner(string name, out string data)
{
if (ScannerInfo.ContainsKey(name))
{
data = ScannerInfo[name];
ScannerInfo.Remove(name);
return(true);
}
data = "";
return(false);
}
public bool GetScanners(out short numberOfScanners, out List <ScannerInfo> scannerInfoList,
out string outXml,
out string status)
{
int scannerCount = 0, zStatus;
int[] connectedScannerIdArray;
ScannerInfo[] scannerInfoArray;
LogWrapper.log(MethodBase.GetCurrentMethod());
numberOfScanners = 0;
outXml = string.Empty;
scannerInfoList = new List <ScannerInfo>();
connectedScannerIdArray = new int[MAX_NUM_DEVICES];
try {
if (_IsOpen == false)
{
status = "Scanner is closed";
return(false);
}
_CoreScanner.GetScanners(out numberOfScanners, connectedScannerIdArray, out outXml, out zStatus);
if (STATUS_SUCCESS == zStatus)
{
if (numberOfScanners < 1)
{
status = "No Scanners Were Found";
return(false);
}
scannerInfoArray = new ScannerInfo[MAX_NUM_DEVICES];
for (int i = 0; i < MAX_NUM_DEVICES; i++)
{
scannerInfoArray[i] = new ScannerInfo();
}
scannerInfoList = parseScannerXml <ScannerData>(outXml);
//_Xml.ReadXmlstring_GetScanners(outXml, scannerInfoArray, numberOfScanners, out scannerCount, out status);
for (int i = 0; i < scannerCount; i++)
{
scannerInfoList.Add(scannerInfoArray[i]);
}
status = "OK";
return(true);
}
else
{
status = decodeStatusMessage(zStatus);
return(false);
}
} catch (Exception ex) {
status = ex.Message;
return(false);
}
}
public void SetInteractionChannel(
IScannerInteractionChannel interactionChannel, ScannerInfo remoteScannerInfo)
{
CodeContract.Requires(interactionChannel != null);
CodeContract.Requires(remoteScannerInfo != null);
lock (s_aliveSync)
{
_interactionChannel = interactionChannel;
_remoteScannerInfo = remoteScannerInfo;
_alive = true;
}
}
private void ScannerManager_RemoteScannerConnected(object sender, ScannerEventArgs e)
{
lock (s_remoteScannerSync)
{
if (IsRemoteScannerConnected)
{
Logger.LogVerbose(Message.SyncIgnoreRemoteScannerConnectedEvent);
return;
}
_remoteScannerInfo = new ScannerInfo(e.SerialNumber, e.IpAddress);
}
if (_localScannerInfo == null)
{
return;
}
try
{
Logger.LogVerbose(Message.SyncTryOpenConnection);
var uri = GetUriForRemoteInteraction(e.IpAddress);
var connector = GetRemoteScannerConnector(uri);
var allowed = connector.IsRemoteConnectionAllow(
_localScannerInfo.SerialNumber, _localScannerInfo.IpAddress);
if (!allowed)
{
Logger.LogVerbose(Message.SyncRemoteConnectionNotAllow);
return;
}
_remoteScannerInterface.SetInteractionChannel(connector, _remoteScannerInfo);
Logger.LogInfo(Message.SyncRemoteConnectionSuccess, e.SerialNumber, e.IpAddress);
_remoteScannerDisconnected.Reset();
_remoteScannerConnected.Set();
RemoteScannerConnected.RaiseEvent(this);
}
catch (ThreadAbortException)
{
throw;
}
catch (Exception ex)
{
if (ex is RemotingException || ex is SocketException)
{
Logger.LogInfo(Message.SyncCannotConnectToRemoteScanner, ex.Message);
}
else
{
Logger.LogError(Message.SyncConnectRemoteScannerError, ex);
}
}
}
private void SetUpScanner()
{
var lexcion = new Lexicon();
var lexer = lexcion.Lexer;
PLUS = lexer.DefineToken(RE.Symbol('+'));
ASTERISK = lexer.DefineToken(RE.Symbol('*'));
LEFT_PARENTHESIS = lexer.DefineToken(RE.Symbol('('));
RIGHT_PARENTHESIS = lexer.DefineToken(RE.Symbol(')'));
NUMBER = lexer.DefineToken(RE.Range('0', '9').Many1(), "number");
SPACE = lexer.DefineToken(RE.Symbol(' ').Many1());
m_scannerInfo = lexcion.CreateScannerInfo();
}
public void ErrorRecoveryTest()
{
Lexicon lexicon = new Lexicon();
Lexer global = lexicon.Lexer;
var ID = global.DefineToken(RE.Range('a', 'z').Concat(
(RE.Range('a', 'z') | RE.Range('0', '9')).Many()));
var NUM = global.DefineToken(RE.Range('0', '9').Many1());
var WHITESPACE = global.DefineToken(RE.Symbol(' ').Many());
ScannerInfo info = lexicon.CreateScannerInfo();
Compiler.Scanner.Scan.Scanner scanner = new Compiler.Scanner.Scan.Scanner(info);
string source = "asdf04a 1107 !@#$!@ Z if vvv xmlns 772737";
StringReader sr = new StringReader(source);
scanner.SetSource(new SourceReader(sr));
scanner.SetTriviaTokens(WHITESPACE.Index);
scanner.RecoverErrors = true;
CompilationErrorManager em = new CompilationErrorManager();
em.DefineError(101, 0, CompilationStage.Scanning, "Invalid token: {0}");
var el = em.CreateErrorList();
scanner.ErrorList = el;
scanner.LexicalErrorId = 101;
Lexeme l1 = scanner.Read();
Assert.AreEqual(ID.Index, l1.TokenIndex);
Lexeme l2 = scanner.Read();
Assert.AreEqual(NUM.Index, l2.TokenIndex);
Assert.AreEqual(0, el.Count);
Lexeme l3 = scanner.Read();
Assert.AreEqual(ID.Index, l3.TokenIndex);
Assert.IsTrue(el.Count > 0);
Assert.AreEqual(101, el[0].Info.Id);
}
private void PrepareScannerComboBox()
{
var scannerName = SettingsTable.Get <string>(Strings.VScan_ScannerName, Strings.VScan_DefaultScannerName);
//this.cbScanners.SelectedIndexChanged -= new System.EventHandler(this.Scanners_SelectedIndexChanged);
this.cbScanners.Clear();
foreach (var scanner in ScannerInfo.SelectInstalled())
{
int index = cbScanners.Items.Add(scanner);
}
this.cbScanners.SelectedItem = scannerName;
//this.cbScanners.SelectedIndexChanged += new System.EventHandler(this.Scanners_SelectedIndexChanged);
}
private void barcodeManager_Connection(object sender, BarcodeManager.ScannerConnectionEventArgs e)
{
string status;
string scannerName = "";
ScannerInfo scannerInfo = e.P0;
BarcodeManager.ConnectionState connectionState = e.P1;
string statusBT = connectionState.ToString();
string scannerNameBT = scannerInfo.FriendlyName;
if (deviceList.Count != 0)
{
scannerName = deviceList[scannerIndex].FriendlyName;
}
if (scannerName.ToLower().Equals(scannerNameBT.ToLower()))
{
status = "Status: " + scannerNameBT + ":" + statusBT;
RunOnUiThread(() => textViewStatus.Text = status);
if (connectionState == BarcodeManager.ConnectionState.Connected)
{
DeInitScanner();
InitScanner();
SetTrigger();
SetConfig();
}
if (connectionState == BarcodeManager.ConnectionState.Disconnected)
{
// De-initialize scanner
DeInitScanner();
}
status = "Status: " + scannerNameBT + ":" + statusBT;
RunOnUiThread(() => textViewStatus.Text = status);
}
else
{
status = "Status: " + statusString + " " + scannerNameBT + ":" + statusBT;
RunOnUiThread(() => textViewStatus.Text = status);
}
}
/// <summary>
/// Get the topology of devices that are connected to the calling system.
/// </summary>
/// <param name="scannerService"></param>
/// <returns></returns>
public static IEnumerable <ScannerInfo> GetDeviceTopology(
this ICoreScannerService scannerService)
{
Contract.Requires(scannerService != null);
XDocument inXml = new XDocument(
new XElement("inArgs", String.Empty));
return(scannerService
.ExecuteCommand(OperationCode.GetDeviceTopology, inXml.ToString())
.ParseXmlDocument()
.Elements("outArgs")
.Elements("arg-xml")
.Elements("scanners")
.Elements("scanner")
.Select(scanner => ScannerInfo.Parse(scanner.ToString())));
}
private void Engine_ScannerNewData(string arg1, string arg2)
{
try
{
if (ScannerInfo.Count == 0)
{
ScannerInfo.Add(arg1, arg2);
}
else
{
ScannerInfo[arg1] = arg2;
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public IEnumerable <ScannerInfo> GetScanners()
{
Contract.Ensures(Contract.Result <IEnumerable <ScannerInfo> >() != null);
Int16 numDevices;
String outXml;
Int32 status;
this.coreScanner
.GetScanners(out numDevices, this.deviceIdsBuffer, out outXml, out status);
((Status)status).ThrowIfError();
return(outXml
.ParseXmlDocument()
.Elements("scanners")
.Elements("scanner")
.Select(scanner => ScannerInfo.Parse(scanner.ToString())));
}
void barcodeManager_Connection(object sender, BarcodeManager.ScannerConnectionEventArgs e)
{
String status;
String scannerName = "";
ScannerInfo scannerInfo = e.P0;
BarcodeManager.ConnectionState connectionState = e.P1;
String statusBT = connectionState.ToString();
String scannerNameBT = scannerInfo.FriendlyName;
if (scannerList.Count != 0)
{
scannerName = scannerList[scannerIndex].FriendlyName;
}
if (scannerName.ToLower().Equals(scannerNameBT.ToLower()))
{
status = "Status: " + scannerNameBT + ":" + statusBT;
RunOnUiThread(() => textViewStatus.Text = status);
if (connectionState == BarcodeManager.ConnectionState.Connected)
{
// Bluetooth scanner connected
initScanner();
setTrigger();
setDecoders();
}
if (connectionState == BarcodeManager.ConnectionState.Disconnected)
{
// Bluetooth scanner disconnected
deInitScanner();
RunOnUiThread(() => EnableUIControls(true));
}
}
else
{
status = "Status: " + statusString + " " + scannerNameBT + ":" + statusBT;
RunOnUiThread(() => textViewStatus.Text = status);
}
}
public List <ScannerInfo> GetScannerInfos()
{
lock (s_votesSync)
{
var resultList = new List <ScannerInfo>();
foreach (VoteKey key in _votes.Keys)
{
if (key.ScannerSerialNumber == null)
{
continue;
}
var scannerInfo = new ScannerInfo(key.ScannerSerialNumber.ToString(), null);
if (!resultList.Contains(scannerInfo))
{
resultList.Add(scannerInfo);
}
}
return(resultList);
}
}
public void LexerStateToDFATest()
{
Lexicon lexicon = new Lexicon();
LexerState global = lexicon.DefaultLexer;
LexerState keywords = global.CreateSubState();
LexerState xml = keywords.CreateSubState();
var ID = global.DefineToken(RE.Range('a', 'z').Concat(
(RE.Range('a', 'z') | RE.Range('0', '9')).Many()));
var NUM = global.DefineToken(RE.Range('0', '9').Many1());
var ERROR = global.DefineToken(RE.Range(Char.MinValue, (char)255));
var IF = keywords.DefineToken(RE.Literal("if"));
var ELSE = keywords.DefineToken(RE.Literal("else"));
var XMLNS = xml.DefineToken(RE.Literal("xmlns"));
DFAModel dfa = DFAModel.Create(lexicon);
CompressedTransitionTable tc = CompressedTransitionTable.Compress(dfa);
ScannerInfo si = lexicon.CreateScannerInfo();
FiniteAutomationEngine engine = new FiniteAutomationEngine(si.TransitionTable, si.CharClassTable);
engine.InputString("if");
Assert.AreEqual(ID.Index, si.GetTokenIndex(engine.CurrentState));
engine.Reset();
engine.InputString("12345");
Assert.AreEqual(NUM.Index, si.GetTokenIndex(engine.CurrentState));
engine.Reset();
engine.InputString("asdf12dd");
Assert.AreEqual(ID.Index, si.GetTokenIndex(engine.CurrentState));
engine.Reset();
engine.InputString("A");
Assert.AreEqual(ERROR.Index, si.GetTokenIndex(engine.CurrentState));
engine.Reset();
engine.InputString("AAA");
Assert.IsTrue(engine.IsAtStoppedState);
engine.Reset();
engine.InputString("if ");
Assert.IsTrue(engine.IsAtStoppedState);
engine.Reset();
si.LexerStateIndex = keywords.Index;
engine.InputString("if");
Assert.AreEqual(IF.Index, si.GetTokenIndex(engine.CurrentState));
engine.Reset();
engine.InputString("else");
Assert.AreEqual(ELSE.Index, si.GetTokenIndex(engine.CurrentState));
engine.Reset();
engine.InputString("xmlns");
Assert.AreEqual(ID.Index, si.GetTokenIndex(engine.CurrentState));
engine.Reset();
si.LexerStateIndex = xml.Index;
engine.InputString("if");
Assert.AreEqual(IF.Index, si.GetTokenIndex(engine.CurrentState));
engine.Reset();
engine.InputString("xml");
Assert.IsFalse(engine.IsAtStoppedState);
engine.Reset();
engine.InputString("xmlns");
Assert.AreEqual(XMLNS.Index, si.GetTokenIndex(engine.CurrentState));
;
}
public override void EventScannerAppeared(ScannerInfo availableScanner)
{
Console.WriteLine("Found mofo scanner");
}
public void SkipTokenTest()
{
Lexicon lexicon = new Lexicon();
LexerState global = lexicon.DefaultLexer;
LexerState keywords = global.CreateSubState();
LexerState xml = keywords.CreateSubState();
var ID = global.DefineToken(RE.Range('a', 'z').Concat(
(RE.Range('a', 'z') | RE.Range('0', '9')).Many()));
var NUM = global.DefineToken(RE.Range('0', '9').Many1());
var WHITESPACE = global.DefineToken(RE.Symbol(' ').Many());
var ERROR = global.DefineToken(RE.Range(Char.MinValue, (char)255));
var IF = keywords.DefineToken(RE.Literal("if"));
var ELSE = keywords.DefineToken(RE.Literal("else"));
var XMLNS = xml.DefineToken(RE.Literal("xmlns"));
ScannerInfo info = lexicon.CreateScannerInfo();
PeekableScanner scanner = new PeekableScanner(info);
string source = "asdf04a 1107 else Z if vvv xmlns 772737";
StringReader sr = new StringReader(source);
scanner.SetSource(new SourceReader(sr));
scanner.SetTriviaTokens(WHITESPACE.Index, ERROR.Index);
info.LexerStateIndex = xml.Index;
Lexeme l1 = scanner.Read();
Assert.AreEqual(ID.Index, l1.TokenIndex);
Assert.AreEqual("asdf04a", l1.Value);
Assert.AreEqual(0, l1.PrefixTrivia.Count);
Lexeme l2 = scanner.Read();
Assert.AreEqual(NUM.Index, l2.TokenIndex);
Assert.AreEqual("1107", l2.Value);
Assert.AreEqual(1, l2.PrefixTrivia.Count);
Lexeme l3 = scanner.Read();
Assert.AreEqual(ELSE.Index, l3.TokenIndex);
Assert.AreEqual("else", l3.Value);
Assert.AreEqual(1, l2.PrefixTrivia.Count);
Lexeme l4 = scanner.Read();
Assert.AreEqual(IF.Index, l4.TokenIndex);
Assert.AreEqual("if", l4.Value);
Assert.AreEqual(3, l4.PrefixTrivia.Count);
int p1 = scanner.Peek();
Assert.AreEqual(ID.Index, p1);
int p2 = scanner.Peek2();
int p3 = scanner.Peek(3);
int peof = scanner.Peek(4);
Assert.AreEqual(info.EndOfStreamTokenIndex, peof);
Lexeme l6 = scanner.Read();
Lexeme l7 = scanner.Read();
Assert.AreEqual(XMLNS.Index, l7.TokenIndex);
Lexeme l8 = scanner.Read();
Assert.AreEqual(NUM.Index, l8.TokenIndex);
Lexeme leof = scanner.Read();
Assert.AreEqual(info.EndOfStreamTokenIndex, leof.TokenIndex);
Assert.AreEqual(leof.Span.StartLocation.CharIndex, leof.Span.EndLocation.CharIndex);
Assert.AreEqual(source.Length, leof.Span.StartLocation.CharIndex);
}
public void ScannerTest()
{
Lexicon lexicon = new Lexicon();
LexerState global = lexicon.DefaultLexer;
LexerState keywords = global.CreateSubState();
LexerState xml = keywords.CreateSubState();
var ID = global.DefineToken(RE.Range('a', 'z').Concat(
(RE.Range('a', 'z') | RE.Range('0', '9')).Many()));
var NUM = global.DefineToken(RE.Range('0', '9').Many1());
var WHITESPACE = global.DefineToken(RE.Symbol(' ').Many());
var ERROR = global.DefineToken(RE.Range(Char.MinValue, (char)255));
var IF = keywords.DefineToken(RE.Literal("if"));
var ELSE = keywords.DefineToken(RE.Literal("else"));
var XMLNS = xml.DefineToken(RE.Literal("xmlns"));
ScannerInfo info = lexicon.CreateScannerInfo();
PeekableScanner scanner = new PeekableScanner(info);
string source = "asdf04a 1107 else Z if vvv xmlns 772737";
StringReader sr = new StringReader(source);
scanner.SetSource(new SourceReader(sr));
Lexeme l1 = scanner.Read();
Assert.AreEqual(ID.Index, l1.TokenIndex);
Assert.AreEqual("asdf04a", l1.Value);
Assert.AreEqual(0, l1.Span.StartLocation.Column);
Assert.AreEqual(6, l1.Span.EndLocation.Column);
Lexeme l2 = scanner.Read();
Assert.AreEqual(WHITESPACE.Index, l2.TokenIndex);
Assert.AreEqual(" ", l2.Value);
Lexeme l3 = scanner.Read();
Assert.AreEqual(NUM.Index, l3.TokenIndex);
Assert.AreEqual("1107", l3.Value);
Lexeme l4 = scanner.Read();
Assert.AreEqual(WHITESPACE.Index, l4.TokenIndex);
Lexeme l5 = scanner.Read();
Assert.AreEqual(ID.Index, l5.TokenIndex);
int p1 = scanner.Peek();
Assert.AreEqual(WHITESPACE.Index, p1);
int p2 = scanner.Peek2();
Assert.AreEqual(ERROR.Index, p2);
int p3 = scanner.Peek(3);
Assert.AreEqual(WHITESPACE.Index, p3);
int p4 = scanner.Peek(4);
Assert.AreEqual(ID.Index, p4);
int p5 = scanner.Peek(5);
Assert.AreEqual(WHITESPACE.Index, p5);
Lexeme l6 = scanner.Read();
Lexeme l7 = scanner.Read();
Assert.AreEqual(ERROR.Index, l7.TokenIndex);
int p3_2 = scanner.Peek();
Assert.AreEqual(p3, p3_2);
Lexeme l8 = scanner.Read(); // whitespace
Lexeme l9 = scanner.Read(); // ID:if
Lexeme l10 = scanner.Read(); // whitespace
Lexeme l11 = scanner.Read(); // ID:vvv
Lexeme l12 = scanner.Read(); // whitespace
Lexeme l13 = scanner.Read(); // ID:xmlns
Lexeme l14 = scanner.Read(); // whitespace
Lexeme l15 = scanner.Read(); // NUM:772737
Lexeme leof = scanner.Read(); // eof
Assert.AreEqual(info.EndOfStreamTokenIndex, leof.TokenIndex);
Assert.AreEqual(leof.Span.StartLocation.CharIndex, leof.Span.EndLocation.CharIndex);
Assert.AreEqual(source.Length, leof.Span.StartLocation.CharIndex);
Lexeme leof2 = scanner.Read(); //after eof, should return eof again
Assert.AreEqual(info.EndOfStreamTokenIndex, leof2.TokenIndex);
Assert.AreEqual(leof.Span.StartLocation.CharIndex, leof2.Span.StartLocation.CharIndex);
}
private void PushScanner(XmlScanner newScanner, object entity, String baseURI, XmlAttributeTokenInfo[] fields,
int readCount, int usedCount, int lastToken, int nextFunction, bool depthIncrement,
String entityName, int depth, Encoding encoding, bool standalone, bool oldExternal,
bool newExternal) {
ScannerInfo ei = (ScannerInfo)_ScannerStack.Push();
if (ei == null) {
ei = new ScannerInfo();
_ScannerStack[_ScannerStack.Length-1] = ei;
}
ei._Scanner = _Scanner;
ei._Entity = entity;
ei._BaseURI = baseURI;
ei._LastToken = lastToken;
ei._NextFunction = nextFunction;
ei._DepthIncrement = depthIncrement;
ei._Fields = fields;
ei._ReadCount = readCount;
ei._Used = usedCount;
ei._EntityName = entityName;
ei._EntityDepth = depth;
ei._Encoding = encoding;
ei._StandAlone = standalone;
ei._IsExternal = oldExternal;
_MaxCount = 0;
//
// reset xmldecl flag
//
_CantHaveXmlDecl = false;
if (depthIncrement) {
if (readCount != -1 && fields != null && fields[readCount] != null)
fields[readCount].Depth++;
else
_ElementDepth++;
}
_Scanner = newScanner;
if (newExternal)
_Encoding = _Scanner.Encoding;
}
protected virtual TransitionTable OnCreateTransitionTable(LR0Model automaton, ScannerInfo scannerInfo)
{
return(TransitionTable.Create(automaton, scannerInfo));
}
