public MessageListViewModel(IMessageListView view, IApplicationController appc)
: base(view, appc)
{
Parser = new ParserEngine();
_browseLimit = App.UserSettings.BrowseLimit;
Messages = new SelectableItemCollection <MessageInfo>();
BindingOperations.EnableCollectionSynchronization(Messages, _syncLock);
Progress = new RangeProgress();
Filter = new BrowseFilter();
BuildCommands();
AvailableConverters = new List <LabelValuePair <IByteCharConverter> >
{
new LabelValuePair <IByteCharConverter> {
Label = "CP-1252", Value = new DefaultByteCharConverter()
},
new LabelValuePair <IByteCharConverter> {
Label = "EBCDIC", Value = new EbcdicByteCharConverter()
}
};
_currentConverter = AvailableConverters[0].Value;
StatusInfoViewModel = new MessageListStatusInfo(this);
}
public void TestParseWithFields()
{
var conf = new ParserConfiguration();
conf.Message
.Field("Field01", 5)
.Constant("space", 1, " ")
.Field("Field02", 6);
var g1 = conf.Message.Group("group01")
.Field("subfield01", 1)
.Field("subfield02", 1);
var parser = new ParserEngine();
parser.Configuration = conf;
var ok = parser.ParseMessage("Hello World!$*");
Assert.IsTrue(ok);
Assert.IsTrue(parser.Result.Nodes[0].Value == "Hello");
Assert.IsTrue(parser.Result.Nodes[2].Value == "World!");
Assert.IsTrue(parser.Result.Nodes[3].Children[0].Value == "$");
Assert.IsTrue(parser.Result.Nodes[3].Children[1].Value == "*");
}
public void CreateMonitorThread(ParserEngine aEngine, string aName, DThread aThread, ParserElementBase.ElementCompleteHandler aLastFieldHandler)
{
// Create DObject paragraph
ParserParagraph para0 = base.CreateMonitorObjectParagraph(aName, aThread);
aEngine.Add(para0);
// Create MState paragraphs
ParserParagraph para1 = new ParserParagraph(aName + "_MSTATE");
para1.Tag = aThread;
aEngine.Add(para1);
CreateThreadMState(para1, DThread.TThreadState.ECreated, "CREATED", false);
CreateThreadMState(para1, DThread.TThreadState.EDead, "DEAD", false);
CreateThreadMState(para1, DThread.TThreadState.EReady, "READY", false);
CreateThreadMState(para1, DThread.TThreadState.EWaitSemaphore, "WAITSEM", true);
CreateThreadMState(para1, DThread.TThreadState.EWaitSemaphoreSuspended, "WAITSEMS", true);
CreateThreadMState(para1, DThread.TThreadState.EWaitMutex, "WAITMUTEX", true);
CreateThreadMState(para1, DThread.TThreadState.EWaitMutexSuspended, "WAITMUTXS", true);
CreateThreadMState(para1, DThread.TThreadState.EHoldMutexPending, "HOLDMUTXP", true);
CreateThreadMState(para1, DThread.TThreadState.EWaitCondVar, "WAITCONDVAR", true);
CreateThreadMState(para1, DThread.TThreadState.EWaitCondVarSuspended, "WAITCONDVRS", true);
CreateThreadMState(para1, DThread.TThreadState.EUnknown, "??", true);
// Create common thread paragraph
ParserParagraph para2 = CreateThreadCommon(aName, aThread);
aEngine.Add(para2);
// Create NThread paragraphs
iHelper.CreateMonitorNThread(aEngine, aName + "_NTHREAD", aThread.NThread, aLastFieldHandler);
// TODO: add support for older memory models?
}
private void CreateRegisterParagraphs(ParserEngine aEngine, NThread aThread, ParserElementBase.ElementCompleteHandler aLastFieldHandler)
{
{
ParserParagraph para = new ParserParagraph("NTHREAD_REGS1");
para.SetTargetMethod(aThread.Registers, "Add");
ParserLine l1 = ParserLine.NewSymFormat("FPEXC %08x\r\n");
ParserLine l2 = ParserLine.NewSymFormat("CAR %08x\r\n");
ParserLine l3 = ParserLine.NewSymFormat("DACR %08x\r\n");
para.Add(l1, l2, l3);
aEngine.Add(para);
}
{
ParserParagraph para = new ParserParagraph("NTHREAD_REGS2");
para.SetTargetMethod(aThread.Registers, "Add");
ParserLine l1 = ParserLine.NewSymFormat("R13_USR %08x R14_USR %08x SPSR_SVC %08x\r\n");
ParserLine l2 = ParserLine.NewSymFormat(" R4 %08x R5 %08x R6 %08x R7 %08x\r\n");
ParserLine l3 = ParserLine.NewSymFormat(" R8 %08x R9 %08x R10 %08x R11 %08x\r\n");
ParserLine l4 = ParserLine.NewSymFormat(" PC %08x\r\n");
//
if (aLastFieldHandler != null)
{
l4[0].ElementComplete += new ParserElementBase.ElementCompleteHandler(aLastFieldHandler);
}
//
para.Add(l1, l2, l3, l4);
aEngine.Add(para);
}
}
private void PrepareEntryParser()
{
// Junk the old paragraphs
ParserEngine.Reset();
// Get a handle to our destination container
DObjectCon container = CrashDebugger.ContainerByType(DObject.TObjectType.EProcess);
// Save last thread if it looks valid
if (iCurrentObject != null && iCurrentObject.KernelAddress != 0)
{
bool alreadyExists = container.Contains(iCurrentObject);
if (!alreadyExists)
{
container.Add(iCurrentObject);
}
//
iCurrentObject = null;
}
// Create a new object which will contain the next set of parser data
iCurrentObject = new DProcess(CrashDebugger);
// Use the helper to prepare next paragraphs
iHelper.CreateMonitorProcess(ParserEngine, "ENTRY [" + container.TypeDescription + "]", iCurrentObject, new SymbianParserLib.BaseStructures.ParserElementBase.ElementCompleteHandler(ProcessChunksComplete_ElementHandler));
}
protected virtual void CreateEntryParagraphs(DObject aObject)
{
string name = "ENTRY [" + Container.TypeDescription + "]";
ParserParagraph para = iHelperDObject.CreateMonitorObjectParagraph(name, aObject);
ParserEngine.Add(para);
}
protected virtual void CreateEntryParser()
{
// Remove all the old entries
ParserEngine.Reset();
// Save last thread if it looks valid
if (iCurrentObject != null)
{
bool ready = IsObjectReadyForSaving(iCurrentObject);
if (ready)
{
Container.Add(iCurrentObject);
iCurrentObject = null;
}
}
// Create a new object which will contain the next set of parser data
iCurrentObject = CreateNewObject();
// Use the helper to prepare next paragraphs
CreateEntryParagraphs(iCurrentObject);
// Catch the next new entry
CreateEntryDetector();
}
protected virtual void CreateEntryDetector()
{
string containerType = Container.TypeDescription;
ParserParagraph para = iHelperDObject.CreateEntryDetector(containerType, new SymbianParserLib.BaseStructures.ParserElementBase.ElementCompleteHandler(NewElementDetected));
ParserEngine.Add(para);
}
public static void RegisterCommands(ParserEngine aEngine)
{
CreateDictionary();
//
foreach (KeyValuePair <TState, TStateMapplet> keyVP in iDictionary)
{
string[] commandIds = keyVP.Value.CommandIdentifiers;
foreach (string commandId in commandIds)
{
// Create paragraph and associate the state type with the tag so that
// we know what type of object to create later on when the line fires.
ParserParagraph command = new ParserParagraph(commandId);
command.Tag = keyVP.Key;
// Create line to match
ParserLine line = ParserLine.New(commandId);
// Make sure that the paragraph and line don't disable themselves whenever
// they see a matching line. Some of these objects are needed more than once!
command.DisableWhenComplete = false;
line.DisableWhenComplete = false;
//
command.Add(line);
aEngine.Add(command);
}
}
}
public void TestParseWithSwitch()
{
var conf = new ParserConfiguration();
conf.Message
.Field("X", 1, "X")
.Field("Y", 1, "Y")
.Field("SW", 1, "SW");
var sw = conf.Message.Switch("test", "{SW}");
sw.Case("case1", "{X}")
.Field("case1_f1", 1);
sw.Case("case2", "{Y}")
.Field("case2_f1", 1);
sw.Else("else")
.Field("else_f1", 1);
var parser = new ParserEngine();
parser.Configuration = conf;
var ok = parser.ParseMessage("abad");
Assert.IsTrue(ok);
Assert.IsTrue(parser.Result.Nodes[3].Children[0].Label == "case1");
ok = parser.ParseMessage("abbd");
Assert.IsTrue(ok);
Assert.IsTrue(parser.Result.Nodes[3].Children[0].Label == "case2");
ok = parser.ParseMessage("abzd");
Assert.IsTrue(ok);
Assert.IsTrue(parser.Result.Nodes[3].Children[0].Label == "else");
}
private void Parse_Exception(ParserEngine p, string sample, string testMessage = null)
{
var passed = false;
Exception ex = null;
try
{
p.Parse(sample);
passed = true;
}
catch (Exception err)
{
ex = err;
}
if (passed)
{
Assert.Fail("Expected syntax failure for: " + sample);
}
Assert.IsNotNull(ex, "Syntax error was not raised");
Assert.IsInstanceOfType(ex, typeof(SyntaxException),
"Parse generated wrong exception " + ex.GetType());
if (testMessage != null)
{
Assert.AreEqual(testMessage, ex.Message);
}
}
public void Test_Parse1()
{
var p = new ParserEngine();
Parse_ChunkCount(p, "2", 2);
Parse_ChunkCount(p, "2+", 3);
}
public void TestParse_SyntaxError()
{
var p = new ParserEngine();
Parse_Exception(p, "2a+3", "Unsupported character or syntax error a");
Parse_Exception(p, "2++2");
Parse_Exception(p, "2.2. + 3");
}
public void CreateStackParagraphs(ParserEngine aEngine, DThread aThread)
{
ParserParagraph p1 = PrepareUserStack(aThread.StackInfoUser);
ParserParagraph p2 = PrepareSupervisorStack(aThread.StackInfoSupervisor);
//
aEngine.Add(p1, p2);
}
public void CreateMonitorMessageQueue(ParserEngine aEngine, string aName, DMsgQueue aQueue)
{
ParserParagraph para0 = base.CreateMonitorObjectParagraph(aName, aQueue);
aEngine.Add(para0);
ParserParagraph para1 = CreateMessageQueueCommon(aName, aQueue);
aEngine.Add(para1);
}
public void Test_Parse2()
{
var p = new ParserEngine();
Parse_ChunkCount(p, "2+3", 4);
Parse_ChunkCount(p, "2.0+3.0", 4);
Parse_ChunkCount(p, "2.0 +3.0", 4);
Parse_ChunkCount(p, "2.0*11.30 - 42", 6);
}
public void Resolve(IList <string> files)
{
StringBuilder builder = new StringBuilder();
builder.AppendLine("ClientIP,HitCount");
Hashtable hashTable = new Hashtable();
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
foreach (var item in files)
{
if (File.Exists(item))
{
Console.WriteLine($"Reading file {item}");
List <IISLogEvent> logs = new List <IISLogEvent>();
using (ParserEngine parser = new ParserEngine(item))
{
while (parser.MissingRecords)
{
logs = parser.ParseLog().ToList();
// to find out files that match a certain pattern, get the csuri
// bifurcate via csuristem
foreach (IISLogEvent logEvent in logs)
{
var cip = logEvent.cIp;
if (!string.IsNullOrEmpty(cip))
{
if (hashTable.ContainsKey(cip))
{
hashTable[cip] = (int)hashTable[cip] + 1;
}
else
{
hashTable.Add(cip, 1);
}
}
}
}
}
}
}
var dict = hashTable.Cast <DictionaryEntry>().ToDictionary(d => d.Key, d => d.Value);
var sortedDictionary = dict.OrderByDescending(x => x.Value);
foreach (var keyVal in sortedDictionary)
{
builder.AppendLine($"{keyVal.Key},{keyVal.Value}");
Console.WriteLine($"--- {keyVal.Key} has count {keyVal.Value}");
}
sw.Stop();
Console.WriteLine($"Total time taken for processing is {sw.ElapsedMilliseconds / 1000} seconds");
File.WriteAllText($"./{DateTime.Now.ToShortDateString().Replace(' ', '-')}_output.csv", builder.ToString());
}
public void TestMinimalXml_Parse_WithAttributes()
{
// Arrange
var subject = new ParserEngine();
// Act
var result = subject.ParseTestString("<sample attr=\"attributecontent\"></sample>");
// Assert
result.Attributes.Should().ContainSingle(x => x.Name == "attr" && x.Content == "attributecontent");
}
public void CreateMonitorChunk(ParserEngine aEngine, string aName, DChunk aChunk)
{
ParserParagraph para0 = base.CreateMonitorObjectParagraph(aName, aChunk);
aEngine.Add(para0);
ParserParagraph para1 = CreateChunkMultiple(aName, aChunk);
aEngine.Add(para1);
// TODO: add support for older memory models?
}
public void TestMinimalXml_Parse_WithChildren()
{
// Arrange
var subject = new ParserEngine();
// Act
var result = subject.ParseTestString("<sample><childnode></childnode></sample>");
// Assert
result.Children.Should().ContainSingle(x => x.Name == "childnode");
}
public static MofSpecificationAst Parse(List <Token> lexerTokens, ParserQuirks quirks = ParserQuirks.None)
{
// remove all comments and whitespace
var tokens = lexerTokens.Where(lt => !(lt is CommentToken) &&
!(lt is WhitespaceToken)).ToList();
var stream = new ParserStream(tokens);
var program = ParserEngine.ParseMofSpecificationAst(stream, quirks);
return(program);
}
// Constructor
internal ConfiguratorSession(ConfigurationInstance configurationInstance, List <CustomRule> customRules, SolverContext context)
{
this.configurationInstance = configurationInstance;
this.configurationInstance.SMTStaticText = context.GetSMTStaticText;
this.customRules = customRules;
this.solverContext = context;
this.parserEngine = new ParserEngine(configurationInstance);
}
public void TestMinimalXml_Parse_WithChildren()
{
// Arrange
var subject = new ParserEngine();
// Act
var result = subject.ParseTestString("<sample><childnode></childnode></sample>");
// Assert
result.Children.Should().ContainSingle(x => x.Name == "childnode");
}
public void TestMinimalXml_Parse_WithAttributes()
{
// Arrange
var subject = new ParserEngine();
// Act
var result = subject.ParseTestString("<sample attr=\"attributecontent\"></sample>");
// Assert
result.Attributes.Should().ContainSingle(x => x.Name == "attr" && x.Content == "attributecontent");
}
protected override void HandleFilteredLine(string aLine)
{
string line = aLine;
bool consumed = iCommandParser.OfferLine(ref line);
if (!consumed && iStateObject != null)
{
ParserEngine stateParser = iStateObject.ParserEngine;
stateParser.OfferLine(ref line);
}
}
public ParsingEditorViewModel(IParsingEditorView view, IApplicationController appc) : base(view, appc)
{
BuildCommand();
Title = "Parsing Editor";
UniqueId = ParsingEditorViewModel.ID;
ParserDefinitionDocument = new TextDocument();
ParserDefinitionDocument.Text = "<parser>\n\t<parts/>\n\t<message>\n\t\t<field label=\"sample\" length=\"15\" />\n\t</message>\n</parser>";
Engine = new ParserEngine();
}
public override void Prepare()
{
// First, we need to know which thread we're dealing with
// so that means we must look for the thread info
ParserParagraph para = new ParserParagraph("STACK_THREAD_INFO");
//
ParserLine l1 = ParserLine.NewSymFormat("STACK DATA for thread at %8x");
l1.SetTargetMethod(this, "SetThreadAddress");
para.Add(l1);
ParserEngine.Add(para);
}
public void TestMinimalXml_Parse()
{
// Arrange
var subject = new ParserEngine();
// Act
var result = subject.ParseTestString("<sample></sample>");
// Assert
result.Should().NotBeNull();
result.Name.Should().Be("sample");
}
public void TestMinimalXml_Parse()
{
// Arrange
var subject = new ParserEngine();
// Act
var result = subject.ParseTestString("<sample></sample>");
// Assert
result.Should().NotBeNull();
result.Name.Should().Be("sample");
}
public object Post([FromBody] string[] urls)
{
var events = new ParserEngine().Parse(urls, new List <IParser>()
{
new MicroDataParser()
});
return(new
{
urls = urls,
events = events
});
}
public IEnumerable <IISLogEvent> ParseIISLogs(System.IO.FileInfo logFileInfo)
{
List <IISLogEvent> logs = new List <IISLogEvent>();
using (ParserEngine parser = new ParserEngine(logFileInfo.FullName))
{
while (parser.MissingRecords)
{
logs = parser.ParseLog().ToList();
}
}
return(logs);
}
public IEnumerable <IISLogEvent> ParseIISLogs(string logFilePath)
{
List <IISLogEvent> logs = new List <IISLogEvent>();
using (ParserEngine parser = new ParserEngine(logFilePath))
{
while (parser.MissingRecords)
{
logs = parser.ParseLog().ToList();
}
}
return(logs);
}
/// <summary>
/// Parses the given string from XML
/// </summary>
/// <param name="subject">The Parser which is applied</param>
/// <param name="content">The content of the XML file</param>
/// <returns>The <see cref="XmlElement"/> that subject.Parse(...) returned</returns>
public static XmlElement ParseTestString(this ParserEngine subject, string content)
{
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write(content);
writer.Flush();
stream.Position = 0;
var result = subject.Parse(stream);
return(result);
}
