C# Module.SetName方法代码示例

 public static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         BlockCommentPrototype.pattern
             = new AbstractPattern(null, "BlockCommentPrototype");    
         
         BlockCommentPrototype.pattern.SetType(typeof(BlockCommentPrototype));
         grammar.PatternDefined(BlockCommentPrototype.pattern);
         
         string expression = "s('/*' *(s(!('*/') a(0 any))) '*/')";
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression,
             new Pattern[]{BlockCommentPrototype.pattern});
     
         pattern = new ConcretePattern(null, "BlockComment",
             parseGraph);
         
         pattern.SetType(typeof(BlockComment));
         
         BlockCommentPrototype.pattern.AddAltPattern(pattern);
     }
     
     module.SetName("BlockComment", typeof(BlockComment));
     grammar.PatternDefined(pattern);
 }

 public static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         pattern = new AbstractPattern(null, "PatternExpression");
         pattern.SetType(typeof(PatternExpression));
     }
     
     module.SetName("PatternExpression", typeof(PatternExpression));
     grammar.PatternDefined(pattern);
 }

 public static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         pattern = new AbstractPattern(null, "Member");
         pattern.SetType(typeof(Member));
     }
     
     module.SetName("Member", typeof(Member));
     grammar.PatternDefined(pattern);
 }

 public new static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         pattern = new AbstractPattern(null, "UnaryExpression");
         pattern.SetType(typeof(UnaryExpression));
         
         Expression.pattern.AddAltPattern(pattern);
     }
     
     module.SetName("UnaryExpression", typeof(UnaryExpression));
     grammar.PatternDefined(pattern);
 }

 public static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "l(text o((whitespace null) t( s( '\\\"' *( a( s( !(a('\\\\' '\\\"')) any ) s('\\\\' a('\\\\' 'r' 'n' 't' '\\\"' '\\\'' '0') ) ) ) '\\\"' ) ) ) )";
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, null);
 
         pattern = new ConcretePattern(null, "String", parseGraph);
         pattern.SetType(typeof(String));
     }
     
     module.SetName("String", typeof(String));
     grammar.PatternDefined(pattern);
 }

 public static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "l(number o((whitespace null) t(s(+(r('0' '9')) ?(s('.' +(r('0' '9'))))))))";
     
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, null);
 
         pattern = new ConcretePattern(null, "Number", parseGraph);
         pattern.SetType(typeof(Number));
     }
     
     module.SetName("Number", typeof(Number));
     grammar.PatternDefined(pattern);
 }

 public new static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         ParseGraphNode parseGraph = BootstrapParser.Parse("'.'", null);
 
         pattern = new ConcretePattern(null, "AnyPatternExpression", parseGraph);
         pattern.SetType(typeof(AnyPatternExpression));
     
         PatternExpression.pattern.AddAltPattern(pattern);
     }
     
     module.SetName("AnyPatternExpression", typeof(AnyPatternExpression));
     grammar.PatternDefined(pattern);
 }

 public static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "+(a(' ' '\\t' s('\\r' ?('\\n')) '\\n'))";
     
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, null);
     
         pattern = new ConcretePattern(null, "DefaultWhitespace", parseGraph);
         pattern.SetType(typeof(DefaultWhitespace));
     }
     
     module.SetName("DefaultWhitespace", typeof(DefaultWhitespace));
     grammar.PatternDefined(pattern);
 }

 public static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "s('//' *(s(!(a( s('\r' ?('\n')) '\n' )) any)))";
     
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, null);
     
         pattern = new ConcretePattern(null, "LineComment", parseGraph);
         pattern.SetType(typeof(LineComment));
     }
     
     module.SetName("LineComment", typeof(LineComment));
     grammar.PatternDefined(pattern);
 }

 public new static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "l(statement 0)";
         Pattern[] parameters = {Statement.pattern};
     
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, parameters);
     
         pattern = new ConcretePattern(null, "TopLevelStatement", parseGraph);
         pattern.SetType(typeof(TopLevelStatement));
     }
     
     module.SetName("TopLevelStatement", typeof(TopLevelStatement));
     grammar.PatternDefined(pattern);
 }

 public static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "o((whitespace 0) l(statements *(1)))";
         Pattern[] patterns = {Whitespace.pattern, TopLevelStatement.pattern};
     
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, patterns);
     
         pattern = new ConcretePattern(null, "Program", parseGraph);
         pattern.SetType(typeof(Program));
     }
     
     module.SetName("Program", typeof(Program));
     grammar.PatternDefined(pattern);
 }

 public static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "+(a(0 1 2))";
         Pattern[] patterns = {LineComment.pattern, BlockComment.pattern, DefaultWhitespace.pattern};
         
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, patterns);
     
         pattern = new ConcretePattern(null, "Whitespace", parseGraph);
         pattern.SetType(typeof(Whitespace));
     }
     
     module.SetName("Whitespace", typeof(Whitespace));
     grammar.PatternDefined(pattern);
 }

 public new static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "s('option' l(optionKey 0) ?(s('=' o((dropPrecedence true) l(optionValue 1)))) ';')";
         Pattern[] patterns = {Name.pattern, Expression.pattern};
     
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, patterns);
 
         pattern = new ConcretePattern(null, "Option", parseGraph);
         pattern.SetType(typeof(Option));
     }
     
     module.SetName("Option", typeof(Option));
     grammar.PatternDefined(pattern);
 }

 public new static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "s('token' l(body 0))";
         Pattern[] patterns = {BlockPatternExpression.pattern};
     
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, patterns);
 
         pattern = new ConcretePattern(null, "TokenPatternExpression", parseGraph);
         pattern.SetType(typeof(TokenPatternExpression));
     
         PatternExpression.pattern.AddAltPattern(pattern);
     }
     
     module.SetName("TokenPatternExpression", typeof(TokenPatternExpression));
     grammar.PatternDefined(pattern);
 }

 public new static void SetUp(Module module, Grammar grammar)
 {
     if (pattern == null)
     {
         string expression = "s('throw' l(exception 0) ';')";
         Pattern[] parameters = {Expression.pattern};
     
         ParseGraphNode parseGraph = BootstrapParser.Parse(expression, parameters);
     
         pattern = new ConcretePattern(null, "ThrowStatement", parseGraph);
         pattern.SetType(typeof(ThrowStatement));
     
         Statement.pattern.AddAltPattern(pattern);
     }
     
     module.SetName("ThrowStatement", typeof(ThrowStatement));
     grammar.PatternDefined(pattern);
 }