private ScannerState TokenizeString(ScannerState previousState) { var newState = new ScannerState { Buffer = previousState.Buffer, Characters = previousState.Characters, Column = previousState.Column, CurrentCharacter = previousState.CurrentCharacter, Line = previousState.Line, Tokens = previousState.Tokens }; StringBuilder buffer = new StringBuilder("\""); newState.Column++; newState.CurrentCharacter = (char)newState.Characters.Read(); while (!IsQuote(newState.CurrentCharacter) && newState.Characters.Peek() > -1) { buffer.Append(newState.CurrentCharacter); newState.Column++; newState.CurrentCharacter = (char)newState.Characters.Read(); } buffer.Append("\""); newState.Tokens.Add(Token.Create(buffer.ToString(), previousState.Column, newState.Line)); return(newState); }
private ScannerState TokenizeStickyOperator(ScannerState previousState) { var newState = new ScannerState { Buffer = previousState.Buffer, Characters = previousState.Characters, Column = previousState.Column, CurrentCharacter = previousState.CurrentCharacter, Line = previousState.Line, Tokens = previousState.Tokens }; if (IsValidStickyOperator(newState.CurrentCharacter, PeekCharacter(newState))) { newState.Tokens.Add(Token.Create ( String.Join(String.Empty, newState.CurrentCharacter, PeekCharacter(newState)), newState.Column, newState.Line) ); newState.Column++; // Skip peeked character newState.Characters.Read(); } else { newState.Tokens.Add(Token.Create(newState.CurrentCharacter.ToString(), newState.Column, newState.Line)); } return(newState); }
private ScannerState DetermineNextStatePositions(ScannerState previousState) { var newState = new ScannerState { Buffer = previousState.Buffer, Characters = previousState.Characters, Column = previousState.Column, CurrentCharacter = previousState.CurrentCharacter, Line = previousState.Line, Tokens = previousState.Tokens }; if (IsNewlineOrReturnCharacter(newState.CurrentCharacter)) { // Handle CRLF if (IsNewlineOrReturnCharacter(PeekCharacter(newState))) { // Skip peeked LF character newState.Characters.Read(); } newState.Column = 2; newState.Line++; } else { newState.Column++; } return(newState); }
public Scanner(TokenChain tokenchain) //上级编译器必须将token链传入 { //TokenChain tokenchain = new TokenChain(); this.tokenchain = tokenchain; file = new ScannerFile(); state = ScannerState.Failed_To_Open_File; //此时并没有打开文件 }
internal AudioScan(DirectoryInfo directory, SearchOption searchoption, bool parseAdd, bool parseUpdate, bool removeDeadFiles, string[] extensions, IEnumerable <RawTrack> existingFiles, IEnumerable <string> ignoredFiles, ScanFileEventHandler parsed, ScanCompletedEventHandler done) { var thread = new Thread(Run); _directory = directory; _searchoption = searchoption; _parseAdd = parseAdd; _parseUpdate = parseUpdate; _removeDeadFiles = removeDeadFiles; _parser = new MediaParser(); _extensions = extensions; _existingFiles = existingFiles.ToDictionary(rt => rt.File); _ignoredFiles = (from s in ignoredFiles select new FileInfo(s)).ToArray(); Parsed = parsed; Done = done; _state = ScannerState.NotRunning; _added = _updated = _skipped = _error = _removed = _total = 0; thread.Start(); }
private void Run() { _state = ScannerState.Scanning; Dictionary <FileInfo, Action> actions = BuildActionDictionary(ScanForFiles(), _existingFiles.Keys); _totalFiles = actions.Count; foreach (FileInfo file in _ignoredFiles) { actions[file] = Action.Skip; } _total = actions.Count; _state = ScannerState.Parsing; for (int i = 0; i < actions.Count; i++) { var file = actions.ElementAt(i); _currentFile = i + 1; ParseFile(file.Key, file.Value); } _state = ScannerState.Completed; if (Done != null) { Done(this, new ScanCompletedEventArgs()); } }
private int GetRestartStateIndex(ScannerState state, int stateIndex) { ScannerRestartState restartState = new ScannerRestartState(); this.scanner.InitializeRestartState(restartState); restartState.State = state; for (int i = stateIndex - 1; i >= 0; i--) { ScannerRestartState rstate = (ScannerRestartState)this.stateList[i]; if (rstate == restartState) { return(i); } } int n = this.stateList.Count; for (int i = stateIndex + 1; i < n; i++) { ScannerRestartState rstate = (ScannerRestartState)this.stateList[i]; if (rstate == restartState) { return(i); } } this.stateList.Add(restartState); return(n); }
internal AudioScan(DirectoryInfo directory, SearchOption searchoption, bool parseAdd, bool parseUpdate, bool removeDeadFiles, string[] extensions, IEnumerable<RawTrack> existingFiles, IEnumerable<string> ignoredFiles, ScanFileEventHandler parsed, ScanCompletedEventHandler done) { var thread = new Thread(Run); _directory = directory; _searchoption = searchoption; _parseAdd = parseAdd; _parseUpdate = parseUpdate; _removeDeadFiles = removeDeadFiles; _parser = new MediaParser(); _extensions = extensions; _existingFiles = existingFiles.ToDictionary(rt => rt.File); _ignoredFiles = (from s in ignoredFiles select new FileInfo(s)).ToArray(); Parsed = parsed; Done = done; _state = ScannerState.NotRunning; _added = _updated = _skipped = _error = _removed = _total = 0; thread.Start(); }
public async Task <bool> ScanAsync(IEnumerable <BigInteger> collection) { if (this.State != ScannerState.Prepared) { throw new InvalidOperationException(); } try { var result = await Task.Run(() => Parallel.ForEach(collection, (element, state) => { var stripedZ = BigInteger.ModPow(BigInteger.ModPow(element, this.inverseBlendFactor, this.parent.Map.Prime), this.parent.InverseExponent, this.parent.Map.Prime); if (stripedZ == this.parent.originalZ) { state.Stop(); } })); return(!result.IsCompleted); // When completed then we did not find any value } finally { this.State = ScannerState.None; } }
/// <summary> /// Returns the next token in the file. Returns null on EOF. /// </summary> /// <returns></returns> public Token GetNextToken(ScannerState state) { switch (state) { case ScannerState.ParseKey: eatWhitespace(); return(GetNextID()); case ScannerState.ParseID: return(GetNextID()); case ScannerState.ParseParms: return(GetNextParms()); case ScannerState.ParseSimple: eatWhitespace(); return(GetNextSimple()); case ScannerState.ParseValue: Token rval = GetNextValue(); //ConsumeToEOL(); return(rval); } return(null); }
private ScannerState TokenizeBuffer(ScannerState previousState) { var newState = new ScannerState { Buffer = previousState.Buffer, Characters = previousState.Characters, Column = previousState.Column, CurrentCharacter = previousState.CurrentCharacter, Line = previousState.Line, Tokens = previousState.Tokens }; if (newState.Buffer.Length > 0) { newState.Tokens.Add(Token.Create ( String.Join(String.Empty, newState.Buffer), newState.Column - newState.Buffer.Length, newState.Line )); newState.Buffer.Clear(); } return(newState); }
/// <summary> /// The executing. /// </summary> /// <param name="cells"> /// The cells. /// </param> /// <returns> /// </returns> internal NotifyScannerStateChangedEventArgs Executing(IList <Cell> cells) { this.CellsScanned += cells.Count; this.BytesScanned += cells.Sum(cell => cell.Value != null ? cell.Value.Length : 0); this.ScannerState = ScannerState.Executing; return(this); }
public void Start(List <MemoryEntry> entries) { _fft_buffer = new byte[_controlInterface.FFTResolution]; _entries = entries; _scannerState = ScannerState.Scan; SetupFirstScan(); _timerLevelInspect.Enabled = true; }
public void Constructor() { ScannerState scannerState = new ScannerState(); Assert.IsNotNull(scannerState); Assert.AreEqual(0, scannerState.StartPosition); Assert.AreEqual(0, scannerState.CurrentPosition); Assert.IsNull(scannerState.ReadToken); }
public void Resume() { if (_scannerState == ScannerState.StayTuned) { _scannerState = ScannerState.Scan; } ResumeScan(); _timerLevelInspect.Enabled = true; }
private void ResumeScan() { _scanStateChangedCallback(_scannerState, ScannerState.Scan); _scannerState = ScannerState.Scan; _scannerTimerTickCnt = 0; _scannerTimerTickCntLastFreqChange = 0; _scannerStayTunedCnt = 0; DoReTuning(_entries[_scanIndex]); }
private void ParseLine(string line, KatResult kr) { line = line.Trim(); if (line.Length <= 1) { return; } if (line.StartsWith("Message")) { state = ScannerState.Message; return; } if (line.StartsWith("Result")) { state = ScannerState.Result; return; } if (line.StartsWith("MAC")) { state = ScannerState.MacKeyHeader; } else if (line.StartsWith("------")) { state = ScannerState.Done; return; } switch (state) { case ScannerState.Start: if (line.StartsWith(":Skein-")) { ParseHeaderLine(line, kr); } else { throw new FormatException(String.Format("Invalid entry format (line {0})", CurrentLine)); } break; case ScannerState.Message: ParseMessageLine(line, kr); break; case ScannerState.Result: ParseResultLine(line, kr); break; case ScannerState.MacKey: ParseMacKeyLine(line, kr); break; case ScannerState.MacKeyHeader: ParseMacKeyHeaderLine(line, kr); break; } }
protected ScannerBase(string input) { if (string.IsNullOrEmpty(input)) { throw new ScannerException("Input can´t be null or empty"); } _input = input; _currentState = new ScannerState(); }
private void OnStateChanged(ScannerState scannerState) { if (StateChanged != null) { StateChanged(this, new StateChangedEventArgs { State = scannerState }); } }
internal void ResetCurrentToken(ScannerState state) { if (state != _currentToken.State) { AbandonAllTokens(); Debug.Assert(_currentToken.Position == _lineBufferOffset); Debug.Assert(_currentToken.EndOfTerminatorTrivia == _endOfTerminatorTrivia); _currentToken = _currentToken.With(state, null); } }
internal override void MoveToNextSyntaxNode(ScannerState withState) { if (_currentNode == null) { return; } Debug.Assert(CanReuseNode(_currentNode), "this node could not have been used."); _lineBufferOffset = _currentToken.Position + _curNodeLength; base.MoveToNextSyntaxNode(withState); TryPopNode(); }
public Scanner() { defaults = new ScannerState { Buffer = new StringBuilder(), Column = 2, CurrentCharacter = char.MinValue, Line = 1, Tokens = new List <Token>() }; }
/// <summary> /// 调用自动机对源程序进行词法分析。 /// </summary> public void LexicalAnalysis() { if (state == ScannerState.Initialized) { Automata(); } else { state = ScannerState.Misuse; AddError("错误使用Scanner"); } }
/// <summary> /// Fill in data from KAT file, one complete element at a time. /// </summary> /// <param name="kr">The resulting KAT data.</param> /// <returns></returns> public bool FillResult(KatResult kr) { var dataFound = false; while (state != ScannerState.Done && !reader.EndOfStream) { CurrentLine++; ParseLine(reader.ReadLine(), kr); dataFound = true; } state = ScannerState.Start; return(dataFound); }
private void ParseMacKeyHeaderLine(string line, KatResult kr) { var rx = new Regex(".*=\\s*(\\d+) .*"); Match result = rx.Match(line); if (!result.Success) { throw new FormatException(String.Format("Invalid MAC key header line format (line {0})", CurrentLine)); } kr.MacKeyLen = int.Parse(result.Groups[1].Value); kr.MacKey = new byte[kr.MacKeyLen]; state = ScannerState.MacKey; }
public BigInteger Prepare(BigInteger blendFactor, BigInteger inverseBlendFactor) { if (this.State != ScannerState.None) { throw new InvalidOperationException(); } this.blendFactor = blendFactor; this.inverseBlendFactor = inverseBlendFactor; var scanvalue = BigInteger.ModPow(this.parent.Z, this.blendFactor, this.parent.Map.Prime); this.State = ScannerState.Prepared; return(scanvalue); }
void ScanStateChanged(ScannerState OldState, ScannerState NewState) { if (NewState == ScannerState.StayTuned) { if (comboBoxRecording.Text.ToLower().Equals("yes")) { WaverecorderStart(); } } else if (NewState == ScannerState.Scan) { WaverecorderStop(); } }
void ScanNextFrequencyTimeLeftCallback(double ScanTime, double WdogTime, ScannerState State) { ScanTime = ScanTime / 1000; WdogTime = WdogTime / 1000; try { if (_scanner.IsRxLevelValid) { textBoxRxLevel.Text = String.Format("{0:F0}", _scanner.PeakPower); textBoxAvgBwPower.Text = String.Format("{0:F0}", _scanner.PowerBanwidthAvg); textBoxPeakPowerBw.Text = String.Format("{0:F0}", _scanner.PeakPowerBw); } else { textBoxRxLevel.Text = ""; } if (_scanner.State == ScannerState.StayTuned) { frequencyDataGridView.DefaultCellStyle.SelectionBackColor = Color.Green; if (_scanner.IsStayTunedStable) { textBoxTimeout.Text = DisableStringTextBox; } else { textBoxTimeout.Text = String.Format("{0:0.0}", ScanTime); } if (_scanner.WdogTimerEnable) { textBoxWdog.Text = String.Format("{0:0.0}", WdogTime); } else { textBoxWdog.Text = DisableStringTextBox; } } else { frequencyDataGridView.DefaultCellStyle.SelectionBackColor = Color.Blue; textBoxTimeout.Text = String.Format("{0:0.0}", ScanTime); textBoxWdog.Text = DisableStringTextBox; } } catch (Exception) { } }
internal void GetNextTokenInState(ScannerState state) { _prevToken = _currentToken; if (_tokens.Count == 0) { _currentToken = new ScannerToken(_lineBufferOffset, _endOfTerminatorTrivia, null, state); } else { _currentToken = _tokens[0]; _tokens.RemoveAt(0); ResetCurrentToken(state); } }
/// <summary> /// 通过url初始化scanner。 /// </summary> public bool Init(string url) { if (file.Init(url)) { tokenchain.Clear(); state = ScannerState.Initialized; return(true); } else { state = ScannerState.Failed_To_Open_File; AddError("源程序文件路径错误"); return(false); } }
private void ResumeScan() { if (!_isRunning) { return; } _scanStateChangedCallback(_scannerState, ScannerState.Scan); _scannerState = ScannerState.Scan; _scannerTimerTickCnt = 0; _scannerTimerTickCntLastFreqChange = 0; _scannerStayTunedCnt = 0; _wdogTimeTickCnt = 0; DoReTuning(_entries[_scanIndex]); }
public void ConstructorFromState() { ScannerState scannerState = new ScannerState(); scannerState.StartPosition = 1; scannerState.CurrentPosition = 2; scannerState.ReadToken = new Token(TokenType.TRUE); ScannerState scannerStateFromState = new ScannerState(scannerState); Assert.IsNotNull(scannerStateFromState); Assert.AreEqual(scannerState.StartPosition, scannerStateFromState.StartPosition); Assert.AreEqual(scannerState.CurrentPosition, scannerStateFromState.CurrentPosition); Assert.AreEqual(scannerState.ReadToken, scannerStateFromState.ReadToken); }
void SetForState(ScannerState state) { switch (state) { case ScannerState.INITIAL: _startState = 3; break; case ScannerState.Other: _startState = 0; break; default: throw new InvalidOperationException("invalid state"); } }
public ScannerToken(int lineBufferOffset, int endOfTerminatorTrivia, SyntaxToken token, ScannerState state) { this.Position = lineBufferOffset; this.EndOfTerminatorTrivia = endOfTerminatorTrivia; this.InnerTokenObject = token; this.State = state; }
private void cmdSaveProcessLog_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e) { string currentDirectory = Environment.CurrentDirectory; try { SaveFileDialog dialog = new SaveFileDialog(); dialog.CheckPathExists = true; dialog.OverwritePrompt = true; dialog.Title = "Сохранить журнал операций..."; dialog.Filter = "XML файлы|*.xml|Все файлы|*.*"; if(dialog.ShowDialog(this) == DialogResult.OK) { ScannerState state = new ScannerState(); state.Legend = new List<XmlLegendItem>(processLegend.Count); foreach (ProcessLegendItem legendItem in processLegend) { state.Legend.Add(new XmlLegendItem(legendItem)); } state.Log = processLog.ConvertAll(x => new XmlFb2DocumentEntry(x)); XmlSerializer serializer = new XmlSerializer(typeof(ScannerState)); try { using (TextWriter writer = new StreamWriter(dialog.FileName)) { serializer.Serialize(writer, state); } } catch (IOException) { } } } finally { Environment.CurrentDirectory = currentDirectory; } }
public Token(string _tokenText, ScannerState _state) : this(_tokenText, _state, false) { }
public Token(string _tokenText, ScannerState _state, bool quoteFlag) { state = _state; if (_tokenText == null)//|| _tokenText.Length == 0 ) { //tokenVal = TokenValue.Error; //errorMessage = "Bad Token String - 0 length"; _tokenText = ""; } //else //{ switch (state) { case ScannerState.ParseID: tokenText = _tokenText.ToLower(); if (reservedWords.Contains(tokenText)) { tokenVal = (TokenValue)reservedWords[tokenText]; } else if (tokenText.StartsWith("x-")) { tokenVal = TokenValue.Xtension; tokenText = "x:" + tokenText.Substring(2); } else if (isID(tokenText)) // this check may be unnecessary by virute of the scanner.... { tokenVal = TokenValue.ID; } else { tokenVal = TokenValue.Error; errorMessage = "Illegal value for ID"; } if (isBeginEndValue()) { tokenText = CapsCamelCase(tokenText); } else { tokenText = CamelCase(tokenText); } break; case ScannerState.ParseParms: tokenText = HttpUtility.HtmlEncode(_tokenText); if (quoteFlag) { tokenVal = TokenValue.QuotedString; } else { tokenVal = TokenValue.Parm; } break; case ScannerState.ParseValue: tokenText = HttpUtility.HtmlEncode(_tokenText); tokenVal = TokenValue.Value; break; case ScannerState.ParseSimple: tokenVal = TokenValue.Error; errorMessage = "Bad constructor call - ParseSimple and text..."; break; } //} }
private void StoreImportState(string filename) { ScannerState state = new ScannerState(); state.SearchPath = txtImportPath.Text; state.IncludeSubDirs = chkIncludeSubDirs.Checked; state.SelectFoundFiles = chkSelectFoundFiles.Checked; state.Filter = filterCriteria; state.Entries = fileEntries.ConvertAll(x => new XmlImportFileEntry(x)); state.Legend = new List<XmlLegendItem>(processLegend.Count); foreach (ProcessLegendItem legendItem in processLegend) { state.Legend.Add(new XmlLegendItem(legendItem)); } state.Log = processLog.ConvertAll(x => new XmlFb2DocumentEntry(x)); XmlSerializer serializer = new XmlSerializer(typeof(ScannerState)); try { using (TextWriter writer = new StreamWriter(filename)) { serializer.Serialize(writer, state); } } catch (Exception) { // TODO: Add error message box } }
//TODO: get rid of stateAfterBrace private Expression ParseBlockExpression(ScannerState stateAfterBrace, object sctx, TokenSet followers){ bool savedSawReturnOrYield = this.sawReturnOrYield; this.sawReturnOrYield = false; Block block = new Block(); block.Checked = this.insideCheckedBlock; block.IsUnsafe = this.inUnsafeCode; block.SuppressCheck = this.insideUncheckedBlock; SourceContext ctx = (SourceContext)sctx; ctx.EndPos = this.scanner.CurrentSourceContext.EndPos; Debug.Assert(this.currentToken == Token.LeftBrace); // this.GetNextToken(); block.SourceContext = ctx; block.Statements = new StatementList(new ExpressionStatement(ParseComprehension(followers))); // block.Statements = this.ParseStatementsWithOptionalExpression(followers|Token.RightBrace); if (this.arrayInitializerOpeningContext != null && block.Statements == null && this.currentToken == Token.RightBrace){ this.GetNextToken(); this.sawReturnOrYield = savedSawReturnOrYield; return null; } block.SourceContext.EndPos = this.scanner.CurrentSourceContext.EndPos; this.scanner.state = stateAfterBrace; // this.ParseBracket(ctx, Token.RightBrace, followers, Error.ExpectedRightBrace); Expression result = null; if (sawReturnOrYield) result = new AnonymousNestedFunction(new ParameterList(0), block); else result = new BlockExpression(block); result.SourceContext = ctx; this.sawReturnOrYield = savedSawReturnOrYield; return result; }
private SyntaxToken ScanXmlElement(ScannerState state) { Debug.Assert(state == ScannerState.Element || state == ScannerState.EndElement || state == ScannerState.DocType); SyntaxList<SyntaxNode> leadingTrivia = null; while (CanGetChar()) { char c = PeekChar(); switch (c) { // // Whitespace // // S ::= (#x20 | #x9 | #xD | #xA)+ case UCH_CR: case UCH_LF: leadingTrivia = ScanXmlTrivia(c); break; case ' ': case UCH_TAB: leadingTrivia = ScanXmlTrivia(c); break; case '/': if (CanGetCharAtOffset(1) && PeekAheadChar(1) == '>') { return XmlMakeEndEmptyElementToken(leadingTrivia); } return XmlMakeDivToken(leadingTrivia); case '>': return XmlMakeGreaterToken(leadingTrivia); case '=': return XmlMakeEqualsToken(leadingTrivia); case '\'': case DWCH_LSMART_Q: case DWCH_RSMART_Q: return XmlMakeSingleQuoteToken(leadingTrivia, c, isOpening: true); case '"': case DWCH_LSMART_DQ: case DWCH_RSMART_DQ: return XmlMakeDoubleQuoteToken(leadingTrivia, c, isOpening: true); case '<': if (CanGetCharAtOffset(1)) { char ch = PeekAheadChar(1); switch (ch) { case '!': if (CanGetCharAtOffset(2)) { switch ((PeekAheadChar(2))) { case '-': if (CanGetCharAtOffset(3) && PeekAheadChar(3) == '-') { return XmlMakeBeginCommentToken(leadingTrivia, _scanNoTriviaFunc); } break; case '[': if (CanGetCharAtOffset(8) && PeekAheadChar(3) == 'C' && PeekAheadChar(4) == 'D' && PeekAheadChar(5) == 'A' && PeekAheadChar(6) == 'T' && PeekAheadChar(7) == 'A' && PeekAheadChar(8) == '[') { return XmlMakeBeginCDataToken(leadingTrivia, _scanNoTriviaFunc); } break; case 'D': if (CanGetCharAtOffset(8) && PeekAheadChar(3) == 'O' && PeekAheadChar(4) == 'C' && PeekAheadChar(5) == 'T' && PeekAheadChar(6) == 'Y' && PeekAheadChar(7) == 'P' && PeekAheadChar(8) == 'E') { return XmlMakeBeginDTDToken(leadingTrivia); } break; } } return XmlLessThanExclamationToken(state, leadingTrivia); case '?': return XmlMakeBeginProcessingInstructionToken(leadingTrivia, _scanNoTriviaFunc); case '/': return XmlMakeBeginEndElementToken(leadingTrivia, _scanNoTriviaFunc); } } return XmlMakeLessToken(leadingTrivia); case '?': if (CanGetCharAtOffset(1) && PeekAheadChar(1) == '>') { return XmlMakeEndProcessingInstructionToken(leadingTrivia); } return XmlMakeBadToken(leadingTrivia, 1, ERRID.ERR_IllegalXmlNameChar); case '(': return XmlMakeLeftParenToken(leadingTrivia); case ')': return XmlMakeRightParenToken(leadingTrivia); case '!': case ';': case '#': case ',': case '}': return XmlMakeBadToken(leadingTrivia, 1, ERRID.ERR_IllegalXmlNameChar); case ':': return XmlMakeColonToken(leadingTrivia); case '[': return XmlMakeOpenBracketToken(state, leadingTrivia); case ']': return XmlMakeCloseBracketToken(state, leadingTrivia); default: return ScanXmlNcName(leadingTrivia); } } return MakeEofToken(leadingTrivia); }
private SyntaxToken XmlLessThanExclamationToken( ScannerState state, SyntaxList<SyntaxNode> leadingTrivia) { Debug.Assert(PeekChar() == '<'); Debug.Assert(PeekAheadChar(1) == '!'); return XmlMakeBadToken( SyntaxSubKind.LessThanExclamationToken, leadingTrivia, 2, state == ScannerState.DocType ? ERRID.ERR_DTDNotSupported : ERRID.ERR_Syntax); }
private SyntaxToken GetScannerToken(ScannerState state) { SyntaxToken token = null; switch (state) { case ScannerState.Misc: token = ScanXmlMisc(); break; case ScannerState.Element: case ScannerState.EndElement: case ScannerState.DocType: token = ScanXmlElement(state); break; case ScannerState.Content: token = ScanXmlContent(); break; case ScannerState.CData: token = ScanXmlCData(); break; case ScannerState.StartProcessingInstruction: case ScannerState.ProcessingInstruction: token = ScanXmlPIData(state); break; case ScannerState.Comment: token = ScanXmlComment(); break; case ScannerState.SingleQuotedString: token = ScanXmlStringSingle(); break; case ScannerState.SmartSingleQuotedString: token = ScanXmlStringSmartSingle(); break; case ScannerState.QuotedString: token = ScanXmlStringDouble(); break; case ScannerState.SmartQuotedString: token = ScanXmlStringSmartDouble(); break; case ScannerState.UnQuotedString: token = ScanXmlStringUnQuoted(); break; default: throw new InvalidOperationException(); } return token; }
private void Run() { _state = ScannerState.Scanning; Dictionary<FileInfo, Action> actions = BuildActionDictionary(ScanForFiles(), _existingFiles.Keys); _totalFiles = actions.Count; foreach (FileInfo file in _ignoredFiles) actions[file] = Action.Skip; _total = actions.Count; _state = ScannerState.Parsing; for (int i = 0; i < actions.Count; i++) { var file = actions.ElementAt(i); _currentFile = i + 1; ParseFile(file.Key, file.Value); } _state = ScannerState.Completed; if (Done != null) Done(this, new ScanCompletedEventArgs()); }
/// <summary> /// Initialize a new instance with the specifie state and name. /// </summary> /// <param name="state">The execution state of the scanner.</param> /// <param name="name">The name of the current scanner.</param> public ScanningProgress(ScannerState state, string name) { this.State = state; this.Name = name; }
/// <summary> /// Restores the state of the scanner. /// </summary> protected void RestoreScannerState() { _currentState = _prevoiusState; }
/// <summary> /// Saves the state of the scanner. /// </summary> protected void SaveScannerState() { _prevoiusState = new ScannerState(_currentState); }
private SyntaxToken GetTokenAndAddToQueue(ScannerState state) { var lineBufferOffset = _lineBufferOffset; var endOfTerminatorTrivia = _endOfTerminatorTrivia; var tk = GetScannerToken(state); _tokens.Add(new ScannerToken(lineBufferOffset, endOfTerminatorTrivia, tk, state)); return tk; }
internal SyntaxToken ScanXmlPIData(ScannerState state) { // // Scan the PI data after the white space // // [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' // // [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l')) Debug.Assert(state == ScannerState.StartProcessingInstruction || state == ScannerState.ProcessingInstruction); var precedingTrivia = triviaListPool.Allocate<SyntaxNode>(); SyntaxToken result; if (state == ScannerState.StartProcessingInstruction && CanGetChar()) { var c = PeekChar(); switch (c) { case UCH_CR: case UCH_LF: case ' ': case UCH_TAB: var wsTrivia = ScanXmlTrivia(c); precedingTrivia.AddRange(wsTrivia); break; } } var Here = 0; while (CanGetCharAtOffset(Here)) { char c = PeekAheadChar(Here); switch (c) { case UCH_CR: case UCH_LF: result = XmlMakeProcessingInstructionToken(precedingTrivia.ToList(), Here + LengthOfLineBreak(c, Here)); goto CleanUp; case '?': if (CanGetCharAtOffset(Here + 1) && PeekAheadChar(Here + 1) == '>') { //// If valid characters found then return them. if (Here != 0) { result = XmlMakeProcessingInstructionToken(precedingTrivia.ToList(), Here); goto CleanUp; } // // Create token for the '?>' termination sequence result = XmlMakeEndProcessingInstructionToken(precedingTrivia.ToList()); goto CleanUp; } goto default; default: var xmlCh = ScanXmlChar(Here); if (xmlCh.Length > 0) { Here += xmlCh.Length; continue; } // bad char if (Here != 0) { result = XmlMakeProcessingInstructionToken(precedingTrivia.ToList(), Here); goto CleanUp; } else { result = XmlMakeBadToken(precedingTrivia.ToList(), 1, ERRID.ERR_IllegalChar); goto CleanUp; } } } // no more chars if (Here > 0) { result = XmlMakeProcessingInstructionToken(precedingTrivia.ToList(), Here); } else { result = MakeEofToken(precedingTrivia.ToList()); } CleanUp: triviaListPool.Free(precedingTrivia); return result; }
public SyntaxToken PeekNextToken(ScannerState state) { if (_tokens.Count > 0) { var tk = _tokens[0]; if (tk.State == state) { return tk.InnerTokenObject; } else { AbandonPeekedTokens(); } } // ensure that current token has been read GetCurrentToken(); return GetTokenAndAddToQueue(state); }
internal void ScanXmlText() { char c; int start = this.endPos; int maxPos = this.maxPos; this.unescapedString = null; this.isWhitespace = true; StringBuilder/*?*/ unescapedSB = null; for (; ; ) { c = this.GetChar(this.endPos++); if (c == '&') { isWhitespace = false; // Got an escape of some sort. Have to use the StringBuilder if (unescapedSB == null) unescapedSB = new StringBuilder(128); // start points to the first position that has not been written to the StringBuilder. // The first time we get in here that position is the beginning of the string, after that // it is the character immediately following the escape sequence int len = this.endPos - start - 1; if (len > 0) // append all the non escaped chars to the string builder unescapedSB.Append(this.sourceChars, start, len); unescapedSB.Append(this.ScanXmlEscapedChar()); start = this.endPos; } else { if (c == (char)0 && this.endPos >= maxPos) break; if (this.IsLineTerminator(c, 0)) { if (this.docCommentStart != Token.None) { if (unescapedSB == null) unescapedSB = new StringBuilder(128); int len = this.endPos - start; if (len > 0) // append all the non escaped chars to the string builder unescapedSB.Append(this.sourceChars, start, len); start = this.endPos; c = this.SkipBlanks(); if (c == '/' && this.GetChar(this.endPos) == '/' && this.GetChar(this.endPos + 1) == '/') { if (this.docCommentStart == Token.MultiLineDocCommentStart) { bool lastCharWasSlash = false; for (int j = unescapedSB.Length - 1; j > 0; j--) { char ch = unescapedSB[j]; if (ch == '/') lastCharWasSlash = true; else if (ch == '*' && lastCharWasSlash) { unescapedSB.Length = j; break; } } this.docCommentStart = Token.SingleLineDocCommentStart; this.RestartStateHasChanged = true; } this.endPos += 2; } else if (this.docCommentStart == Token.SingleLineDocCommentStart) { if (c == '/' && this.GetChar(this.endPos) == '*' && this.GetChar(this.endPos + 1) == '*') { this.docCommentStart = Token.MultiLineDocCommentStart; this.RestartStateHasChanged = true; this.endPos += 2; } else { start = --this.endPos; this.state = ScannerState.Code; this.RestartStateHasChanged = true; break; } } else { len = this.endPos - start - 1; if (len > 0) // append all the non escaped chars to the string builder unescapedSB.Append(this.sourceChars, start, len); unescapedSB.Append(c); } start = this.endPos; } } if (c == '<') break; if (!this.ignoreComments && c == '*' && this.docCommentStart == Token.MultiLineDocCommentStart && this.GetChar(this.endPos) == '/') { start = --this.endPos; this.state = ScannerState.Code; this.RestartStateHasChanged = true; break; } if (isWhitespace && !XmlScanner.IsXmlWhitespace(c)) { isWhitespace = false; } } } // update this.unescapedString using the StringBuilder if (unescapedSB != null) { int len = this.endPos - start - 1; if (len > 0) { // append all the non escaped chars to the string builder unescapedSB.Append(this.sourceChars, start, len); } this.unescapedString = unescapedSB.ToString(); } else { int len = this.endPos - start - 1; if (len <= 0) this.unescapedString = ""; else this.unescapedString = this.Substring(this.startPos, len); } if (c == '<' || c == (char)0) this.endPos--; }
private BadTokenSyntax XmlMakeOpenBracketToken(ScannerState state, SyntaxList<SyntaxNode> precedingTrivia) { Debug.Assert(PeekChar() == '['); return XmlMakeBadToken( SyntaxSubKind.OpenBracketToken, precedingTrivia, 1, state == ScannerState.DocType ? ERRID.ERR_DTDNotSupported : ERRID.ERR_IllegalXmlNameChar); }
/// <summary> /// The completed. /// </summary> /// <returns> /// </returns> internal NotifyScannerStateChangedEventArgs Completed() { this.ScannerState = ScannerState.Completed; return this; }
public ScannerToken With(ScannerState state, SyntaxToken token) { return new ScannerToken(this.Position, this.EndOfTerminatorTrivia, token, state); }
/// <summary> /// Makes token from token string and scanner state /// </summary> /// <param name="token">The input token string</param> /// <param name="state">The scanner state</param> /// <returns>The token made based on the scanner state</returns> protected static IToken MakeTokenFromState(string token, ScannerState state) { switch (state) { case ScannerState.Identifier: return MakeIdentifierToken(token); case ScannerState.Number: return MakeNumberToken(token); case ScannerState.Operator: return MakeOperatorToken(token); default: throw new ExpressionEvaluatorException( String.Format("unknown token '{0}'", token)); } }
private Token GetNextXmlToken() { int maxPos = this.maxPos; if (this.state == ScannerState.XML) { this.startPos = this.endPos; this.ScanXmlText(); char ch = this.GetChar(this.endPos); if (this.startPos < this.endPos) { if (this.state == ScannerState.Code && (this.docCommentStart == Token.SingleLineDocCommentStart || (this.docCommentStart == Token.MultiLineDocCommentStart && ch == '*'))) return Token.LiteralContentString; if (ch == '<') this.state = ScannerState.Tag; else this.state = ScannerState.Text; Debug.Assert(this.state == ScannerState.Text && this.endPos >= maxPos || this.state == ScannerState.Tag || this.state == ScannerState.Code); return Token.LiteralContentString; } } nextToken: char c = this.SkipBlanks(); this.startPos = this.endPos - 1; switch (c) { case (char)0: this.startPos = this.endPos; this.TokenIsFirstAfterLineBreak = true; return Token.EndOfFile; case '\r': if (this.GetChar(this.endPos) == '\n') this.endPos++; goto nextToken; case '\n': case (char)0x2028: case (char)0x2029: goto nextToken; case '>': this.RestartStateHasChanged = true; return Token.EndOfTag; case '=': return Token.Assign; case ':': return Token.Colon; case '"': case '\'': state = (c == '"') ? ScannerState.XmlAttr1 : ScannerState.XmlAttr2; this.ScanXmlString(c); if (this.stillInsideToken) this.stillInsideToken = false; else state = ScannerState.Tag; return Token.StringLiteral; case '/': c = this.GetChar(this.endPos); if (c == '>') { this.endPos++; this.RestartStateHasChanged = true; this.state = ScannerState.Text; return Token.EndOfSimpleTag; } return Token.Divide; case '<': c = this.GetChar(this.endPos); if (c == '/') { this.RestartStateHasChanged = true; this.endPos++; return Token.StartOfClosingTag; } else if (c == '?') { this.endPos++; this.ScanXmlProcessingInstructionsTag(); return Token.ProcessingInstructions; } else if (c == '!') { c = this.GetChar(++this.endPos); if (c == '-') { if (this.GetChar(++this.endPos) == '-') { this.endPos++; this.ScanXmlComment(); return Token.LiteralComment; } this.endPos--; } else if (c == '[') { if (this.GetChar(++this.endPos) == 'C' && this.GetChar(++this.endPos) == 'D' && this.GetChar(++this.endPos) == 'A' && this.GetChar(++this.endPos) == 'T' && this.GetChar(++this.endPos) == 'A' && this.GetChar(++this.endPos) == '[') { this.endPos++; this.ScanXmlCharacterData(); return Token.CharacterData; } } this.endPos--; } this.RestartStateHasChanged = true; return Token.StartOfTag; default: if (this.IsIdentifierStartChar(c)) { this.ScanIdentifier(); return Token.Identifier; } else if (Scanner.IsDigit(c)) return this.ScanNumber(c); return Token.IllegalCharacter; } }
/// <summary> /// Returns the next token in the file. Returns null on EOF. /// </summary> /// <returns></returns> public Token GetNextToken(ScannerState state) { switch (state) { case ScannerState.ParseKey: eatWhitespace(); return GetNextID(); case ScannerState.ParseID: return GetNextID(); case ScannerState.ParseParms: return GetNextParms(); case ScannerState.ParseSimple: eatWhitespace(); return GetNextSimple(); case ScannerState.ParseValue: Token rval = GetNextValue(); //ConsumeToEOL(); return rval; } return null; }
/// <summary> /// The executing. /// </summary> /// <param name="cells"> /// The cells. /// </param> /// <returns> /// </returns> internal NotifyScannerStateChangedEventArgs Executing(IList<Cell> cells) { this.CellsScanned += cells.Count; this.BytesScanned += cells.Sum(cell => cell.Value != null ? cell.Value.Length : 0); this.ScannerState = ScannerState.Executing; return this; }
private void _timerLevelInspect_Elapsed(object sender, System.Timers.ElapsedEventArgs e) { if (!_controlInterface.IsPlaying) { Stop(); } _scannerTimerTickCnt++; PowerDetection(); //########################################## if (_scannerState == ScannerState.Scan) //########################################## { if (_scannerTimerTickCnt * _SCAN_TIMER_INTERVALL % 200 == 0) { UpdateTimeLeft(_scanTime - (_scannerTimerTickCnt - _scannerTimerTickCntLastFreqChange) * _SCAN_TIMER_INTERVALL); } if (_scannerCompareRxLevel >= _entries[_scanIndex].StayTunedLevel) { _scanStateChangedCallback(_scannerState, ScannerState.StayTuned); _scannerState = ScannerState.StayTuned; } else if (_scannerTimerTickCnt * _SCAN_TIMER_INTERVALL % _scanTime == 0 && !_scanDisable) { _scannerTimerTickCntLastFreqChange = _scannerTimerTickCnt; _scanNextFrequencyCallBack(_scanIndex); DoReTuning(_entries[_scanIndex]); _scanIndex++; if (_scanIndex > _entries.Count - 1) { _scanIndex = 0; } } } //########################################## if (_scannerState == ScannerState.StayTuned) //########################################## { if (_scannerCompareRxLevel < _entries[_scanIndex].StayTunedLevel) { _scannerStayTunedCnt++; } else { _scannerStayTunedCnt = 0; } if (_scannerStayTunedCnt * _SCAN_TIMER_INTERVALL % 200 == 0) { UpdateTimeLeft(_tresholdReleaseTime - (_scannerStayTunedCnt * _SCAN_TIMER_INTERVALL)); } if (_scannerStayTunedCnt * _SCAN_TIMER_INTERVALL >= _tresholdReleaseTime && !_scanDisable) { ResumeScan(); } } }