internal virtual void RunParseTest(string document, Func <ParserBase, Action> parserActionSelector, Block expectedRoot, IList <RazorError> expectedErrors, bool designTimeParser)
{
// Create the source
using (StringTextBuffer reader = new StringTextBuffer(document)) {
ParserResults results = null;
try {
ParserBase codeParser = CreateCodeParser();
MarkupParser markupParser = CreateMarkupParser();
SyntaxTreeBuilderVisitor listener = new SyntaxTreeBuilderVisitor();
ParserContext context = CreateParserRun(new TextBufferReader(reader), codeParser, markupParser, listener);
context.DesignTimeMode = designTimeParser;
codeParser.Context = context;
markupParser.Context = context;
// Run the parser
parserActionSelector(context.ActiveParser)();
context.OnComplete();
// Collect the results
results = listener.Results;
EvaluateResults(TestContext, results, expectedRoot, expectedErrors);
}
finally {
if (TestContext != null && results != null && results.Document != null)
{
TestContext.WriteLine(String.Empty);
TestContext.WriteLine("Actual Parse Tree:");
WriteNode(0, TestContext, results.Document);
}
}
}
}
private string TryToRecoverTheVersion(string messageString)
{
String version = null;
String wholeField12;
try
{
String[] fields = PipeParser.Split(messageString.Substring(0, (Math.Max(messageString.IndexOf("\r"), messageString.Length)) - (0)),
Convert.ToString(enchars.FieldSeparator));
wholeField12 = fields[11];
//message structure is component 3 but we'll accept a composite of 1 and 2 if there is no component 3 ...
// if component 1 is ACK, then the structure is ACK regardless of component 2
String[] comps = PipeParser.Split(wholeField12, Convert.ToString(enchars.ComponentSeparator));
if (comps.Length > 0)
{
//messageStructure = comps[2];
version = comps[0];
}
else
{
StringBuilder buf = new StringBuilder("Can't determine message version from MSH-12: ");
throw new HL7Exception(buf.ToString(), HL7Exception.UNSUPPORTED_VERSION_ID);
}
}
catch (IndexOutOfRangeException e)
{
throw new HL7Exception("Can't find message structure (MSH-9-3): " + e.Message, HL7Exception.UNSUPPORTED_MESSAGE_TYPE);
}
return(ParserBase.ValidVersion(version) ? version : null);
}
// parse expression inside "(...)" or base class for Filter
private PlanNode parseAtom()
{
if (nextTokenIs("("))
{
tokens.Pop();
PlanNode node = parseOr();
if (!nextTokenIs(")"))
{
throw new Exception("Unmatched parenthesis");
}
tokens.Pop();
return(node);
}
if (tokens.Count == 0)
{
throw new Exception("Unexpected end of input stream");
}
if (!tokens.Peek().StartsWith("-"))
{
throw new Exception("Unexpected token " + tokens.Peek());
}
// 这个name就是参数名，例如-type的"type"，-size的"size"
String name = tokens.Pop().Substring(1);
// 在registry中找到与参数名对应的parser
ParserBase parser = optionParserRegistry.GetValueOrDefault(name);
if (parser == null)
{
throw new Exception("Unrecognized option " + name);
}
// Parser各自的parse()方法用于parse参数的arguments
// 例如 -size +1M，那么"size"所对应的parser应当知道如何parse"+1M"
return(parser.parse(tokens));
}
private void ImportSourceFolder(ParserBase importParser, string fileOrFolderName)
{
ErrorLog.Inst.WriteStatus("Importing Source Files...");
var progressBar = ProgressDialog.Run(this, "Importing Source Files and Registry Entries ...",
"Importing Source Files and Registry Entries From \"{0}\"", fileOrFolderName);
try
{
importParser.Parse(string.Format(@"\\?\{0}", fileOrFolderName));
this.SuspendLayout();
importParser.PopulateSourceTreeView(sourceFilesTree, sourceRegTree);
this.ResumeLayout();
}
catch (Exception ex)
{
ErrorLog.Inst.ShowError("Source Files Import Error : {0}", ex.Message);
}
finally
{
progressBar.ShutDown();
}
ErrorLog.Inst.WriteStatus("Source Files and Registry Entries Import Completed");
}
protected override ParserBase SelectActiveParser(
ParserBase codeParser,
ParserBase markupParser
)
{
return(codeParser);
}
protected virtual ParserResults RunParse(string document, Func <ParserBase, Action> parserActionSelector, bool designTimeParser, Func <ParserContext, ParserBase> parserSelector = null)
{
parserSelector = parserSelector ?? (c => c.ActiveParser);
// Create the source
ParserResults results = null;
using (SeekableTextReader reader = new SeekableTextReader(document))
{
try
{
ParserBase codeParser = CreateCodeParser();
ParserBase markupParser = CreateMarkupParser();
ParserContext context = CreateParserContext(reader, codeParser, markupParser);
context.DesignTimeMode = designTimeParser;
codeParser.Context = context;
markupParser.Context = context;
// Run the parser
parserActionSelector(parserSelector(context))();
results = context.CompleteParse();
}
finally
{
if (results != null && results.Document != null)
{
WriteTraceLine(String.Empty);
WriteTraceLine("Actual Parse Tree:");
WriteNode(0, results.Document);
}
}
}
return(results);
}
/// <summary>
/// Initializes a new instance of the <see cref="ParserContext"/> class.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="parser">The parser.</param>
/// <param name="errorSink">The error sink.</param>
public ParserContext(ITextDocument source, ParserBase parser, ParserErrorSink errorSink, TagProvidersCollection providers)
{
Source = new TextDocumentReader(source);
Parser = parser;
_errorSink = errorSink;
TagProviders = providers;
}
/// <summary> Returns a subclass of GenericMessage corresponding to a certain version.
/// This is needed so that version-specific segments can be added as the message
/// is parsed.
/// </summary>
public static Type getGenericMessageClass(String version)
{
if (!ParserBase.ValidVersion(version))
{
throw new ArgumentException("The version " + version + " is not recognized");
}
Type c = null;
if (version.Equals("2.1"))
{
c = typeof(V21);
}
else if (version.Equals("2.2"))
{
c = typeof(V22);
}
else if (version.Equals("2.3"))
{
c = typeof(V23);
}
else if (version.Equals("2.3.1"))
{
c = typeof(V231);
}
else if (version.Equals("2.4"))
{
c = typeof(V24);
}
else if (version.Equals("2.5"))
{
c = typeof(V25);
}
return(c);
}
static void Main(string[] args)
{
ParserBase parser = new ParserBase();
Console.WriteLine(parser.DynamicRenderControl <HyperLink>(parser.Parse("")));
Console.ReadLine();
}
/// <summary>
/// Returns a subclass of GenericMessage corresponding to a certain version.
/// This is needed so that version-specific segments can be added as the message
/// is parsed.
/// </summary>
public static Type GetGenericMessageClass(string version)
{
if (!ParserBase.ValidVersion(version))
{
throw new ArgumentException($"The version {version} is not recognized");
}
Type c;
if (GenericMessages.ContainsKey(version))
{
c = GenericMessages[version];
}
else
{
var versionClassName = $"V{version.Replace(".", string.Empty)}";
var fullName = $"{typeof(GenericMessage).FullName}+{versionClassName}";
c = Type.GetType(fullName, false);
if (c != null)
{
GenericMessages.TryAdd(version, c);
}
}
return(c);
}
public override ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
{
if (incomingCodeParser is CSharpCodeParser)
{
return(new SimpleCSharpCodeParser());
}
return(base.DecorateCodeParser(incomingCodeParser));
}
/// <summary>
/// Gets an instance of the markup parser and is provided an opportunity to decorate or replace it
/// </summary>
/// <param name="incomingMarkupParser">The markup parser</param>
/// <returns>Either the same markup parser, after modifications, or a different markup parser</returns>
public virtual ParserBase DecorateMarkupParser(ParserBase incomingMarkupParser)
{
if (incomingMarkupParser == null)
{
throw new ArgumentNullException("incomingMarkupParser");
}
return(incomingMarkupParser);
}
[Test] public void TestHtmlExtract()
{
const string t = "<a href=\"/Archives/edgar/data/0000878146/000125529405000179/0001255294-05-000179-index.htm\">5</a>";
var p = new ParserBase();
var o = p.GetLinkText(t);
Assert.AreEqual(o, "5");
}
public override ParserContext CreateParserContext(
ITextDocument input,
ParserBase codeParser,
ParserBase markupParser,
ErrorSink errorSink)
{
return(base.CreateParserContext(input, codeParser, markupParser, errorSink));
}
public WhiteSpaceBusterHtmlMarkupParser(ParserBase inner, RazorOptimizer optimizer)
{
Require.NotNull(inner, nameof(inner));
Require.NotNull(optimizer, nameof(optimizer));
_inner = inner;
_optimizer = optimizer;
}
/// <summary>
/// Constructoe
/// </summary>
/// <param name="codeParser">The Script source code parser instance</param>
/// <param name="markupParser">The Markup parser</param>
/// <param name="parserVisitor">The Parser visitor on recognized Razor tree elements</param>
public RazorTranspiler(ParserBase codeParser, ParserBase markupParser, BaseParserVisitor parserVisitor)
{
if (codeParser == null || markupParser == null)
{
throw new NullReferenceException(codeParser == null ? "codeParser" : "markupParser");
}
Parser = new RazorParser(codeParser, markupParser);
Visitor = parserVisitor == null ? new BaseParserVisitor() : parserVisitor;
}
/// <summary>
/// Gets an instance of the code parser and is provided an opportunity to decorate or replace it
/// </summary>
/// <param name="incomingCodeParser">The code parser</param>
/// <returns>Either the same code parser, after modifications, or a different code parser</returns>
public virtual ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
{
if (incomingCodeParser == null)
{
throw new ArgumentNullException(nameof(incomingCodeParser));
}
return(incomingCodeParser);
}
/// <inheritdoc />
public override ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
{
if (incomingCodeParser == null)
{
throw new ArgumentNullException(nameof(incomingCodeParser));
}
return(new MvcRazorCodeParser());
}
public void MakeControlMSH_UnknownVersion_ThrowsHL7Exception()
{
// Arrange
var version = "1";
var factory = new DefaultModelClassFactory();
// Act / Assert
Assert.Throws <HL7Exception>(() => ParserBase.MakeControlMSH(version, factory));
}
public override ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
{
if (incomingCodeParser is System.Web.Razor.Parser.CSharpCodeParser)
{
return(new ServiceStackCSharpCodeParser());
}
return(base.DecorateCodeParser(incomingCodeParser));
}
/// <summary>
/// Decorates the code parser.
/// </summary>
/// <param name="incomingCodeParser">The incoming code parser.</param>
/// <returns></returns>
public override ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
{
if (incomingCodeParser is CSharpCodeParser)
{
return(new NancyCSharpRazorCodeParser(this.razorAssemblyProvider));
}
return(base.DecorateCodeParser(incomingCodeParser));
}
static void Main(string[] args) {
//ISearch syahoo = new SearchYahoo();
//var result = syahoo.GetSearchResults("anxiety", 2);
ISearch sr = new SearchGoogle();
beginTime = DateTime.Now;
#if USE_ASYNC
//sr.GetSearchResultsAsync("anxiety", NUM_PAGES, ProcessResult);
IProcessor<ProcessorResultKWPosition> processor = new ProcessorKWPosition("helpguide.org", ResulsProcessing);
//IProcessor processor = new ProcessorKWPosition("phobia-anxiety.org");
//var processor = new ProcessorKWPosition("phobia-anxiety.org", ResulsProcessing);
sr.GetSearchResultsAsync("anxiety", NUM_PAGES, processor.ProcessResultAsync);
#else
var result = sr.GetSearchResults("anxiety", NUM_PAGES);
#if USE_PARSE
var endTime = DateTime.Now;
var totTime = (endTime - beginTime).TotalMilliseconds;
Console.WriteLine("total execution time ms: {0}", totTime);
ParserBase pparser = ParserFactoryStatic.GetParser(result.SearchEngine.ToString());
var parseResults = pparser.Parse(result.SearchResponseRaw);
if (parseResults != null) {
for (int i = 0; i < parseResults.Count; i++) {
//Console.WriteLine("links[i]: " + links[i]);
Debug.WriteLine(string.Format("parseResults[{0}]: {1}", i, parseResults[i]));
}
}
#else
var links = pparser.ParseGetLinks(result.SearchResponseRaw);
if (links != null)
{
for (int i = 0; i < links.Count; i++)
{
//Console.WriteLine("links[i]: " + links[i]);
Debug.WriteLine(string.Format("links[{0}]: {1}", i, links[i]));
}
}
#endif
#endif
Console.ReadLine();
}
public void MakeControlMSH_ValidVersion_ReturnsExpectedMsh(string version, Type expectedType)
{
// Arrange
var factory = new DefaultModelClassFactory();
// Act
var msh = ParserBase.MakeControlMSH(version, factory);
// Assert
Assert.IsInstanceOf(expectedType, msh);
}
public void DecorateMarkupParserReturnsIncomingParser()
{
// Arrange
ParserBase expected = new HtmlMarkupParser();
// Act
ParserBase actual = CreateHost().DecorateMarkupParser(expected);
// Assert
Assert.Same(expected, actual);
}
public void DecorateCodeParserDoesNotModifyIncomingParser()
{
// Arrange
ParserBase expected = new CSharpCodeParser();
// Act
ParserBase actual = CreateHost().DecorateCodeParser(expected);
// Assert
Assert.Same(expected, actual);
}
public override ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
{
if (incomingCodeParser is CSharpCodeParser)
return new CSharp.CSharpCodeParser();
#if !RAZOR4
if (incomingCodeParser is VBCodeParser)
return new VisualBasic.VBCodeParser();
#endif
return base.DecorateCodeParser(incomingCodeParser);
}
public override ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
{
if (incomingCodeParser is CSharpCodeParser)
{
return(new MvcCSharpRazorCodeParser());
}
else
{
return(base.DecorateCodeParser(incomingCodeParser));
}
}
protected internal virtual RazorParser CreateParser()
{
ParserBase codeParser = Host.CodeLanguage.CreateCodeParser();
ParserBase markupParser = Host.CreateMarkupParser();
return(new RazorParser(Host.DecorateCodeParser(codeParser),
Host.DecorateMarkupParser(markupParser))
{
DesignTimeMode = Host.DesignTimeMode
});
}
private void OnSkeletonModelParseComplate(ParserBase parser)
{
this._model = (parser as SkinnedMeshParser).go;
this.smParser.parseCompleteListener = null;
this._loaded = true;
this.source = null;
if (this.asset.loadedListener != null)
{
this.asset.loadedListener(this.asset);
}
}
public virtual ParserContext CreateParserContext(ITextDocument input,
ParserBase codeParser,
ParserBase markupParser,
ErrorSink errorSink)
{
return(new ParserContext(input,
codeParser,
markupParser,
SelectActiveParser(codeParser, markupParser),
errorSink));
}
public void CreateCodeParserReturnsNewCSharpCodeParser()
{
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Act
ParserBase parser = service.CreateCodeParser();
// Assert
Assert.NotNull(parser);
Assert.IsType <CSharpCodeParser>(parser);
}
public void CreateCodeParserReturnsNewCSharpCodeParser()
{
// Arrange
RazorCodeLanguage service = new CSharpRazorCodeLanguage();
// Act
ParserBase parser = service.CreateCodeParser();
// Assert
Assert.IsNotNull(parser);
Assert.IsInstanceOfType(parser, typeof(CSharpCodeParser));
}
void AddOptionParserPair(string standardOption, ParserBase parser)
{
optionsLookupTable.Add(standardOption.ToLowerInvariant(), standardOption);
parsersTable.Add(standardOption, parser);
}
public static ParserBase[] GetParsers(VisualStudioVersion vsVersion)
{
ParserBase[] lParsers = new ParserBase[3];
switch (vsVersion)
{
case VisualStudioVersion.VS2002:
case VisualStudioVersion.VS2003:
lParsers[0] = new CSharp30Parser();
lParsers[1] = new VB10Parser();
lParsers[2] = new ParserCpp();
break;
case VisualStudioVersion.VS2005:
lParsers[0] = new CSharp30Parser();
lParsers[1] = new VB10Parser();
lParsers[2] = new ParserCpp();
break;
}
return lParsers;
}
