public override ParserMatch TryMatch(IScanner scan)
{
int offset = scan.Offset;
var left = LeftParser.Parse(scan);
if (left.Success)
{
var right = RightParser.Parse(scan);
if (right.Success)
{
return ParserMatch.Concat(this, left, right);
}
}
else
{
scan.Seek(offset);
left = RightParser.Parse(scan);
if (left.Success)
{
var right = LeftParser.Parse(scan);
if (right.Success)
{
return ParserMatch.Concat(this, left, right);
}
}
}
scan.Seek(offset);
return scan.NoMatch;
}
public ParserMatch TryMatch(IScanner scan)
{
int offset = scan.Offset;
int len = 0;
if (!scan.EndOfInput && scan.Peek() == '\r') // CR
{
scan.Read();
len++;
}
if (!scan.EndOfInput && scan.Peek() == '\n') // LF
{
scan.Read();
len++;
}
if (len > 0)
{
return scan.CreateMatch(this, offset, len);
}
scan.Seek(offset);
return scan.NoMatch;
}
public BorrowController(IDisplay display, ICardReader reader, IScanner scanner, IPrinter printer,
IBookDAO bookDAO, ILoanDAO loanDAO, IMemberDAO memberDAO)
{
if(display == null) throw new ArgumentException("Display object was not provided to begin the application");
if (reader == null) throw new ArgumentException("Reader object was not provided to begin the application");
if (scanner == null) throw new ArgumentException("Scanner object was not provided to begin the application");
if (printer == null) throw new ArgumentException("Printer object was not provided to begin the application");
if (bookDAO == null) throw new ArgumentException("BookDAO object was not provided to begin the application");
if (loanDAO == null) throw new ArgumentException("LoanDAO object was not provided to begin the application");
if (memberDAO == null) throw new ArgumentException("MemberDAO object was not provided to begin the application");
_display = display;
_reader = reader;
_scanner = scanner;
_printer = printer;
_bookDAO = bookDAO;
_loanDAO = loanDAO;
_memberDAO = memberDAO;
_ui = new BorrowControl(this);
_reader.Listener = this;
_scanner.Listener = this;
_bookList = new List<IBook>();
_loanList = new List<ILoan>();
_state = EBorrowState.CREATED;
}
private static string Solve(IScanner scanner)
{
int numberOfPhoneNumbers = scanner.NextInt();
Program.PhoneNode phoneBook = new Program.PhoneNode(String.Empty, false);
string answer = null;
for (int j = 0; j < numberOfPhoneNumbers; j++)
{
var no = scanner.Next();
Debug.WriteLine("Processing: " + no);
if (answer != null)
continue;
var current = phoneBook;
for (int index = 0; index < no.Length; index++)
{
var digit = no[index] - '0';
if (current.Nodes[digit] == null)
current.Nodes[digit] = new PhoneNode(current.Id + digit, index == no.Length - 1);
else if (index == no.Length - 1 || current.Nodes[digit].IsStop)
{
// if this is my last digit and number already used - 'NO'
// if some other number finished here - 'NO'
// number already exists
answer = "NO";
break;
}
current = current.Nodes[digit];
}
}
return answer ?? "YES";
}
public CategoriesListViewModel(IProductService service, INavigationService navi, IScanner scanner)
{
_service = service;
_navi = navi;
_scanner = scanner;
Items = new NotifyTaskCompletion<List<Product>>(_service.GetProducts());
Categories = new NotifyTaskCompletion<List<string>>(_service.GetCategories());
NavigateToCategory = new RelayCommand<string>(async cat =>
{
var items = (await _service.GetProductsForCategory(cat))
.OrderByDescending(i => i.Rating)
.ToList();
if (items != null && items.Any())
{
var page = App.GetProductsListPage(items, cat);
await _navi.PushAsync(page);
}
else
{
await _navi.DisplayAlert("Error", "There are no items in the category " + cat);
}
});
_searchCommand = new RelayCommand(Search, () => !string.IsNullOrWhiteSpace(SearchTerm));
ScanCommand = new RelayCommand(async () =>
{
var result = await _scanner.Scan();
SearchTerm = result.Text;
Search();
});
}
public ParserMatch TryMatch(IScanner scan)
{
if (source == null) throw new Exception("Empty holding parser");
if (! (source is IMatchingParser)) throw new Exception("Holding parser was non terminating");
return (source as IMatchingParser).TryMatch(scan);
}
public GlobalDataWorkItem(IScanner scanner, Program program, Address addr, DataType dt) : base(addr)
{
this.scanner = scanner;
this.program = program;
this.dt = dt;
this.rdr = program.CreateImageReader(addr);
}
public override ParserMatch TryMatch(IScanner scan)
{
int offset = scan.Offset;
var m = LeftParser.Parse(scan);
int goodOffset = scan.Offset;
if (!m.Success)
{
scan.Seek(offset);
return scan.NoMatch;
}
// doing difference
scan.Seek(offset);
var m2 = RightParser.Parse(scan);
if (m2.Success)
{
// fail: must match left but NOT right
scan.Seek(offset);
return scan.NoMatch;
}
// Good match
scan.Seek(goodOffset);
return m;
}
public override IScanner GetScanner(IVsTextLines buffer)
{
if (scanner == null)
this.scanner = new LineScanner();
return this.scanner;
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
if (scanner == null)
throw new ArgumentNullException("scanner");
return ParserMatch.CreateFailureMatch(scanner);
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
// save scanner state
long offset = scanner.Offset;
// apply the first parser
ParserMatch m = FirstParser.Parse(scanner);
// if m1 successful, do m2
if (m.Success)
{
return m;
}
// not found try the next
scanner.Seek(offset);
// apply the second parser
m = SecondParser.Parse(scanner);
if (m.Success)
{
return m;
}
scanner.Seek(offset);
return ParserMatch.CreateFailureMatch(scanner);
}
public ProcedureWorkItem(IScanner scanner, Program program, Address addr, string name) : base(addr)
{
this.scanner = scanner;
this.program = program;
this.addr = addr;
this.name = name;
}
/// <summary>
/// Lookahead to determine if parser can be used to parse (does not consume input)
/// </summary>
/// <param name="scanner"></param>
/// <returns></returns>
internal ParserMatch TryAccept(IScanner scanner)
{
long offset = scanner.Offset;
ParserMatch m = ParseMain(scanner);
scanner.Offset = offset;
return m;
}
public Register(IBasket basket, IDisplay display, IScanner scanner)
{
logger = LoggerFactory.GetLogger();
this.basket = basket;
this.display = display;
this.scanner = scanner;
basket.OnAdd += display.AddProduct;
basket.AddSuccess += scanner.FlashLed;
basket.AddFail += scanner.FlashLed;
basket.OnUpdate += display.UpdateProduct;
basket.OnRemove += display.RemoveProduct;
basket.OnUpdateTotalCost += display.UpdateTotalCost;
basket.OnUpdateProductCount += display.UpdateProductCount;
display.OnStartScan += scanner.Start;
display.OnStopScan += scanner.Stop;
display.OnClear += basket.Clear;
scanner.OnRead += new OnReadHandler(scanner_OnRead);
logger.Write("Register", LogLevel.INFO, "Register initialized");
display.Display();
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
// save scanner state
long offset = scanner.Offset;
// apply the first parser
ParserMatch m = FirstParser.Parse(scanner);
// if m1 successful, do m2
if (m.Success)
{
ParserMatch m2 = SecondParser.Parse(scanner);
if (m2.Success)
{
m.Concat(m2);
}
else
{
m = ParserMatch.CreateFailureMatch(scanner, offset);
}
}
// restoring parser failed, rewind scanner
if (!m.Success)
{
scanner.Seek(offset);
}
return m;
}
public override ParserMatch TryMatch(IScanner scan)
{
int offset = scan.Offset;
var m = new ParserMatch(this, scan, offset, -1);
while (!scan.EndOfInput)
{
offset = scan.Offset;
var a = LeftParser.Parse(scan);
if (!a.Success)
{
scan.Seek(offset);
return m;
}
var b = RightParser.Parse(scan);
if (!b.Success)
{
scan.Seek(offset);
return m;
}
m.AddSubmatch(a);
m.AddSubmatch(b);
}
return m;
}
public override ParserMatch TryMatch(IScanner scan)
{
// save scanner state
int offset = scan.Offset;
// apply the first parser
var m = LeftParser.Parse(scan);
// rewind
scan.Seek(offset);
// apply the second parser
var m2 = RightParser.Parse(scan);
// pick the longest result
if (m.Success || m2.Success)
{
if (m2.Length >= m.Length)
{
scan.Seek(m2.Offset + m2.Length);
return m2;
}
scan.Seek(m.Offset + m.Length);
return m;
}
// rewind to point of failure
scan.Seek(offset);
return scan.NoMatch;
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
long offset = scanner.Offset;
int len = 0;
if (scanner.Peek() == '\r') // CR
{
scanner.Read();
++len;
}
if (scanner.Peek() == '\n') // LF
{
scanner.Read();
++len;
}
if (len>0)
{
ParserMatch m = ParserMatch.CreateSuccessfulMatch(scanner, offset, len);
return m;
}
scanner.Seek(offset);
return ParserMatch.CreateFailureMatch(scanner);
}
protected Intra16X16LumaAbstractPredictor(int x, int y, Macroblock macroblock, IAlgorithmFactory algorithms)
{
this.x = x;
this.y = y;
access = macroblock.MacroblockAccess;
info = new MacroblockInfo(macroblock);
transform = algorithms.CreateTransform();
quantizer = algorithms.CreateQuantizer();
distortion = algorithms.CreateDistortionMetric();
scanner = algorithms.CreateScanner();
mOrig = new int[mbHeight][];
for (var i = 0; i < mOrig.Length; i++)
mOrig[i] = new int[mbWidth];
mResd = new int[mbHeight][];
for (var i = 0; i < mResd.Length; i++)
mResd[i] = new int[mbWidth];
mPred = new int[mbHeight][];
for (var i = 0; i < mPred.Length; i++)
mPred[i] = new int[mbWidth];
mDc = new int[dcHeight][];
for (var i = 0; i < mDc.Length; i++)
mDc[i] = new int[dcWidth];
}
/// <summary>
/// Public scanner method. Test scanner input for this parser's patterns.
/// </summary>
/// <remarks>Most parsers won't need to override this method</remarks>
/// <param name="scan">Scanner to parse from</param>
/// <returns>Match (success of failure) of the parser against the scanne</returns>
public virtual ParserMatch Parse(IScanner scan)
{
scan.Normalise();
var st = new System.Diagnostics.StackTrace();
scan.StackStats(st.FrameCount);
if (scan.RecursionCheck(this, scan.Offset))
if (!(this is Recursion))
return scan.NoMatch;
ParserMatch m;
if (this is IMatchingParser) m = ((IMatchingParser) this).TryMatch(scan);
else m = Parse(scan);
if (m.Success)
{
scan.ClearFailures();
}
else
{
scan.AddFailure(this, scan.Offset);
}
return m;
}
/// <summary>
/// Builds a new successful match ending at the current position of the scanner
/// </summary>
/// <param name="scanner">The scanner used while matching</param>
/// <param name="startOffset">The position at which the match started</param>
public static ParserMatch CreateSuccessfulMatch(IScanner scanner, long startOffset)
{
if (scanner == null)
throw new ArgumentNullException("scanner");
return CreateSuccessfulMatch(scanner, startOffset, scanner.Offset);
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
long offset = scanner.Offset;
ParserMatch m = FirstParser.Parse(scanner);
if (!m.Success)
{
scanner.Seek(offset);
return m;
}
while (!scanner.AtEnd)
{
offset = scanner.Offset;
ParserMatch b = SecondParser.Parse(scanner);
if (!b.Success)
{
scanner.Seek(offset);
return m;
}
ParserMatch a = FirstParser.Parse(scanner);
if (!a.Success)
{
scanner.Seek(offset);
return m;
}
m.Concat(b);
m.Concat(a);
}
return m;
}
public void Setup()
{
mr = new MockRepository();
program = new Program();
proc = new Procedure("testProc", new Frame(PrimitiveType.Word32));
block = proc.AddBlock("l00100000");
trace = new RtlTrace(0x00100000);
r0 = new Identifier("r0", PrimitiveType.Word32, new RegisterStorage("r0", 0, 0, PrimitiveType.Word32));
r1 = new Identifier("r1", PrimitiveType.Word32, new RegisterStorage("r1", 1, 0, PrimitiveType.Word32));
r2 = new Identifier("r2", PrimitiveType.Word32, new RegisterStorage("r2", 2, 0, PrimitiveType.Word32));
sp = new Identifier("sp", PrimitiveType.Word32, new RegisterStorage("sp", 15, 0, PrimitiveType.Word32));
grf = proc.Frame.EnsureFlagGroup(Registers.eflags, 3, "SCZ", PrimitiveType.Byte);
var sc = new ServiceContainer();
var listener = mr.Stub<DecompilerEventListener>();
scanner = mr.StrictMock<IScanner>();
arch = mr.Stub<IProcessorArchitecture>();
program.Architecture = arch;
program.SegmentMap = new SegmentMap(
Address.Ptr32(0x00100000),
new ImageSegment(
".text",
new MemoryArea(Address.Ptr32(0x00100000), new byte[0x20000]),
AccessMode.ReadExecute));
arch.Replay();
program.Platform = new DefaultPlatform(null, arch);
arch.BackToRecord();
arch.Stub(s => s.StackRegister).Return((RegisterStorage)sp.Storage);
arch.Stub(s => s.PointerType).Return(PrimitiveType.Pointer32);
scanner.Stub(s => s.Services).Return(sc);
sc.AddService<DecompilerEventListener>(listener);
}
// private IScanner scanner;
// private IVsTextLines buffer;
// private List<TokenInfo>[] tokenList;
// private string savedSqlText;
public MySqlColorizer(LanguageService service, IVsTextLines buffer, IScanner scanner)
: base(service, buffer, scanner)
{
(scanner as MySqlScanner).Colorizer = this;
// this.scanner = scanner;
// this.buffer = buffer;
}
public Zap(ISettings settings, ILogger logger, IScanner scanner, IReporting reporting, ISpider spider)
{
this.settings = settings;
this.logger = logger;
this.scanner = scanner;
this.reporting = reporting;
this.spider = spider;
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
if (scanner.AtEnd)
{
return ParserMatch.CreateSuccessfulEmptyMatch(scanner);
}
return ParserMatch.CreateFailureMatch(scanner);
}
public CompilationUnitNode parseCompilationUnit(IScanner scanner) {
this.scanner = scanner;
if (nextLexicalUnit(false) == LexicalUnit.EndOfStream) {
return null;
} else {
return parseCompilationUnit();
}
}
private void ReadSymbols(IScanner src)
{
while (src.HasNext())
{
var node = this.ParseLine(src.NextLine());
this.Symbols.Add(node);
}
}
public virtual void Connect(IScannerConnectorEventHandler connectorEventsHandler)
{
CodeContract.Requires(connectorEventsHandler != null);
_connectorEventsHandler = connectorEventsHandler;
_scanner = ConnectToScanner();
_connectorEventsHandler.WantToConnect(_scanner.SerialNumber, _scanner.IPAddress, _scanner.Status);
StartBroadcasting();
}
public ExpressionNode parseExpression(IScanner scanner) {
this.scanner = scanner;
if (nextLexicalUnit(false) == LexicalUnit.EndOfStream) {
return null;
} else {
return parseExpression();
}
}
private void BuildTest(IntelArchitecture arch, Address addr, IPlatform platform, Action <X86Assembler> m)
{
proc = new Procedure(arch, "test", arch.CreateFrame());
block = proc.AddBlock("testblock");
var asm = new X86Assembler(sc, new DefaultPlatform(sc, arch), addr, new List <ImageSymbol>());
scanner = mr.StrictMock <IScanner>();
scanner.Stub(s => s.Services).Return(sc);
m(asm);
lr = asm.GetImage();
this.state = arch.CreateProcessorState();
host = new RewriterHost(
asm.ImportReferences,
new Dictionary <string, FunctionType>
{
{
"GetDC",
new FunctionType(
new Identifier("", new Pointer(VoidType.Instance, 32), new RegisterStorage("eax", 0, 0, PrimitiveType.Word32)),
new [] {
new Identifier("arg",
new TypeReference(
"HWND",
new Pointer(VoidType.Instance, 32)),
new StackArgumentStorage(4, new TypeReference(
"HWND",
new Pointer(VoidType.Instance, 32))))
})
{
StackDelta = 4,
}
}
},
new Dictionary <string, DataType>());
var rw = arch.CreateRewriter(
lr.SegmentMap.Segments.Values.First().MemoryArea.CreateLeReader(addr),
this.state,
proc.Frame,
host);
this.program = new Program
{
Architecture = arch,
SegmentMap = lr.SegmentMap,
ImageMap = lr.ImageMap,
Platform = platform,
};
using (mr.Record())
{
scanner.Stub(x => x.FindContainingBlock(Arg <Address> .Is.Anything)).Return(block);
scanner.Stub(x => x.GetTrace(null, null, null)).IgnoreArguments().Return(rw);
scanner.Stub(x => x.Services).Return(sc);
}
wi = new BlockWorkitem(scanner, program, state, addr);
}
public static Int32 Peek(this IScanner scanner)
{
if (scanner.MoveNext())
{
var character = scanner.Current;
scanner.MoveBack();
return(character);
}
return(CharacterTable.End);
}
public void Dispose()
{
StopBroadcasting();
if (_scanner != null)
{
_scanner.SetIndicator("Выключение...");
_scanner.Dispose();
_scanner = null;
}
GC.SuppressFinalize(this);
}
private static IToken ScanLine(IScanner scanner, TextPosition start)
{
var sb = StringBuilderPool.Pull();
while (scanner.MoveNext() && scanner.Current != CharacterTable.LineFeed)
{
sb.Append(Char.ConvertFromUtf32(scanner.Current));
}
return(new CommentToken(TokenType.Comment, sb.Stringify(), start, scanner.Position));
}
public void Match()
{
IScanner scanner = Provider.NewScanner;
ParserMatch m = ParserMatch.CreateSuccessfulMatch(scanner, scanner.Offset, 2);
Assert.IsTrue(m.Success);
Assert.IsFalse(m.Empty);
Assert.AreEqual(2, m.Length);
Assert.AreEqual(Provider.Text.Substring((int)scanner.Offset, 2), m.Value);
}
public static ILValue ReadLValue(this IScanner <Token> scanner)
{
ILValue result;
if (scanner.TryReadLValue(out result))
{
return(result);
}
throw new ParserException(ErrorMessages.MissingLValue);
}
public IToken Next(IScanner scanner)
{
var state = new StringState(scanner);
if (scanner.MoveNext())
{
return(state.Normal());
}
return(state.Error());
}
//========================================================================================
// Methods
//========================================================================================
/// <summary>
/// This is the worker method for the Librarian background thread. It implements
/// a continual loop waiting for scanning tasks to perform.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = (BackgroundWorker)sender;
while (!worker.CancellationPending)
{
scanner = queue.Dequeue();
if (worker.CancellationPending)
{
break;
}
if (watcher != null)
{
// Disable the watcher while scanning is active. This way we won't have
// file lock contentions or complex threading issues.
watcher.EnableRaisingEvents = false;
}
ProgressChangedEventHandler progressHandler =
new ProgressChangedEventHandler(DoScannerProgressChanged);
scanner.ProgressChanged += progressHandler;
worker.ReportProgress(10,
new ScanningProgress(ScannerState.Beginning, scanner.Name));
try
{
scanner.Execute();
}
catch (Exception exc)
{
App.LogException(new SmartException(exc));
}
RemoveScanner(scanner);
if (watcher != null)
{
watcher.EnableRaisingEvents = true;
}
worker.ReportProgress(100,
new ScanningProgress(ScannerState.Completed, scanner.Name));
lock (sync)
{
scanner.ProgressChanged -= progressHandler;
scanner = null;
}
}
}
public FancyXerox(
IPrinter printer,
IScanner scanner,
IFaxer faxer,
ICoffeeMaker coffeeMaker)
{
Printer = printer;
Scanner = scanner;
Faxer = faxer;
CoffeeMaker = coffeeMaker;
}
/// <summary>
/// Forces the highlighter to be reset.
/// </summary>
public void ForceReset()
{
this.scanners.Clear();
IScanner entryPointScanner = this.BuildEntryPointScanner(new CharTokenizer(), new OccurrenceCollection());
if (entryPointScanner != null)
{
this.scanners.Add(entryPointScanner);
}
}
private static void LoadScanner()
{
var processes = Process.GetProcessesByName("MUXControlsTestApp");
Verify.IsTrue(processes.Length > 0);
string directory = Environment.GetEnvironmentVariable("TEMP") + @"\"; // For instance C:\Users\TDPUser\AppData\Local\Temp\
var config = Config.Builder.ForProcessId(processes[0].Id).WithOutputFileFormat(OutputFileFormat.A11yTest).WithOutputDirectory(directory).Build();
scanner = ScannerFactory.CreateScanner(config);
}
public GameListViewModel(
IRepository repository,
IScanner scanner,
IEventAggregator eventAggregator,
IGameViewModelFactory gameViewModelFactory)
{
this.repository = repository;
this.scanner = scanner;
this.eventAggregator = eventAggregator;
this.gameViewModelFactory = gameViewModelFactory;
}
public static IStatement ReadStatementExcludingNext(this IScanner <Token> scanner)
{
IStatement result;
if (scanner.TryReadStatementExcludingNext(out result))
{
return(result);
}
throw new ParserException(ErrorMessages.MissingStatement);
}
public static Range ReadRange(this IScanner <Token> scanner)
{
Range result;
if (scanner.TryReadRange(out result))
{
return(result);
}
throw new ParserException(ErrorMessages.RemoveMissingRange);
}
/// <summary>
/// Initialize the singleton object with an instance of an IScanner implementation
/// </summary>
/// <param name="scanner">Instance of an IScanner implementation</param>
public static void Initialize(IScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException("scanner");
}
else
{
Scanner.Instance = scanner;
}
}
public static List <TextSpan> ConsumeList(this IScanner scanner, params SqlToken[] tokenTypeList)
{
scanner.IgnoreComments();
var textSpanList = new List <TextSpan>();
foreach (var tokenType in tokenTypeList)
{
textSpanList.Add(scanner.Consume <SqlToken>(tokenType));
}
return(textSpanList);
}
public static bool TryConsumeString <TTokenType>(this IScanner scanner, TTokenType tokenType, out string spanText)
where TTokenType : struct
{
if (scanner.TryConsume(tokenType, out var span))
{
spanText = scanner.GetSpanString(span);
return(true);
}
spanText = string.Empty;
return(false);
}
/// <summary>
/// Create a failure match
/// </summary>
/// <param name="scanner">The scanner used while matching</param>
/// <param name="startOffset">The position at which the match started</param>
/// <param name="endOffset">The position of the end of the stream successfully matched before failure</param>
public static ParserMatch CreateFailureMatch(IScanner scanner, long startOffset, long endOffset)
{
int length = (int)(endOffset - startOffset);
if (length < 0)
{
throw new ArgumentOutOfRangeException("startOffset", "start Offset must be before the end offset");
}
return(new ParserMatch(false, scanner, startOffset, length));
}
public static ArrayVariable ReadArray(this IScanner <Token> scanner)
{
string identifier;
scanner.ReadToken(Token.Identifier, out identifier);
scanner.ReadToken(Token.LBracket);
var indexes = scanner.ReadExpressions();
scanner.ReadToken(Token.RBracket);
return(new ArrayVariable(identifier, indexes));
}
public static IScanner <TypeDefinition> GetDefinedTypes(this IScanner <AssemblyDefinition> source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
return(source.Transform(asm =>
asm.Modules.SelectMany(mod =>
mod.GetTypes())));
}
public ScanPage(IClinicDB db, IScanner scanner, StaffLogin technician)
{
InitializeComponent();
this.db = db;
this.scanner = scanner;
this.technician = technician;
uc4_scan = new UC4_Scan(this.db, scanner);
modelImporter = new ModelImporter();
}
public IEnumerator StopCamera(Action callback)
{
// Stop Scanning
BarcodeScanner.Destroy();
BarcodeScanner = null;
// Wait a bit
yield return(new WaitForSeconds(0.02f));
callback.Invoke();
}
public StationControl(IChargeControl charger, IDoor door, IScanner scanner, IDisplay display, ILog log)
{
_charger = charger;
_door = door;
door.StateChanged += DoorChanged;
_display = display;
_Log = log;
_scanner = scanner;
scanner.ScanEvent += RfidDetected;
_state = LadeskabState.Available;
}
/// <summary>
/// Reads specified token from the scanner.
/// A return value indicating whether the read succeeded.
/// </summary>
/// <typeparam name="TToken">The type of the token.</typeparam>
/// <param name="scanner">The input stream of tokens.</param>
/// <param name="token">The next requierd token.</param>
/// <returns><c>true</c> if the next token is equals to <paramref name="token"/>; otherwise, <c>false</c>.</returns>
public static bool TryReadToken <TToken>(this IScanner <TToken> scanner, TToken token)
where TToken : struct
{
if (EqualityComparer <TToken> .Default.Equals(scanner.CurrentToken, token))
{
scanner.MoveNext();
return(true);
}
return(false);
}
private static Line ReadStatementWithLineNumber(IScanner <Token> scanner, string lineNumber)
{
IStatement statement;
if (!scanner.TryReadToken(Token.Next, () => new Next(), out statement))
{
statement = scanner.ReadStatementExcludingNext();
}
return(new Line(lineNumber, statement));
}
/// <summary>
/// Inner parse method
/// </summary>
/// <param name="scanner">scanner</param>
/// <returns>the match</returns>
protected override ParserMatch ParseMain(IScanner scanner)
{
// save scanner state
long startOffset = scanner.Offset;
ParserMatch m = ParserMatch.CreateSuccessfulEmptyMatch(scanner);
ParserMatch m_temp;
// execution bound
int count = 0;
// lower bound, minimum number of executions
while (count < LowerBound && !scanner.AtEnd)
{
m_temp = Parser.Parse(scanner);
// stop if not successful
if (!m_temp.Success)
{
break;
}
// increment count and update full match
++count;
m.Concat(m_temp);
}
if (count == LowerBound)
{
while (count < UpperBound && !scanner.AtEnd)
{
m_temp = Parser.Parse(scanner);
// stop if not successful
if (!m_temp.Success)
{
break;
}
// increment count
++count;
m.Concat(m_temp);
}
}
else
{
m = ParserMatch.CreateFailureMatch(scanner, startOffset);
}
// restoring parser failed, rewind scanner
if (!m.Success)
{
scanner.Seek(startOffset);
}
return(m);
}
public override ParserMatch ParseMain(IScanner scanner)
{
if (scanner == null)
{
throw new ArgumentNullException(nameof(scanner));
}
long offset = scanner.Offset;
return(null);
}
public void AppendStringShorthand()
{
IScanner scanner = Provider.NewScanner;
ArrayList list = NewList;
Parser parser = new StringParser(Provider.Text)[ActionHandlers.Append(list)];
parser.Parse(scanner);
Assert.AreEqual(list.Count, 1);
Assert.AreEqual(list[0], Provider.Text);
}
public void Success()
{
IScanner scanner = Provider.Scanner;
SequenceParser parser = new SequenceParser(First, Second);
ParserMatch m = parser.Parse(scanner);
Assert.IsTrue(m.Success);
Assert.AreEqual(m.Offset, 0);
Assert.AreEqual(scanner.Offset, m.Offset + m.Length);
Assert.AreEqual(m.Value, First.MatchedString + Second.MatchedString);
}
public void AppendString()
{
IScanner scanner = Provider.NewScanner;
StringParser parser = new StringParser(Provider.Text);
IList list = NewList;
parser.Act += ActionHandlers.Append(list);
parser.Parse(scanner);
Assert.AreEqual(list.Count, 1);
Assert.AreEqual(list[0], Provider.Text);
}
