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();
}
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
}
}
private void ResumeScan()
{
_scanStateChangedCallback(_scannerState, ScannerState.Scan);
_scannerState = ScannerState.Scan;
_scannerTimerTickCnt = 0;
_scannerTimerTickCntLastFreqChange = 0;
_scannerStayTunedCnt = 0;
DoReTuning(_entries[_scanIndex]);
}
//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();
}
}
}
