private static void DumpLexicalAnalyzer_GetKeywordList(
RegulationList grammar, string grammarId, CodeTypeDeclaration lexiType)
{
{
// private static readonly List<Keyword> keywords = new List<Keyword>();
var field = new CodeMemberField(typeof(List <Keyword>), "keywords");
field.Attributes = MemberAttributes.Private | MemberAttributes.Static;
field.InitExpression = new CodeObjectCreateExpression(typeof(List <Keyword>));
lexiType.Members.Add(field);
}
{
// protected override IEnumerable<Keyword> GetKeywords()
var method = new CodeMemberMethod();
method.Name = "GetKeywords";
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.ReturnType = new CodeTypeReference(typeof(IEnumerable <Keyword>));
var returnKeywords = new CodeMethodReturnStatement(
new CodeVariableReferenceExpression("keywords"));
method.Statements.Add(returnKeywords);
lexiType.Members.Add(method);
}
{
// static DemoLexicalAnalyzer()
var method = new CodeTypeConstructor();
method.Name = GetLexicalAnalyzerName(grammarId);
method.Attributes = MemberAttributes.Static;
//{
// // List<Keyword> keyword = new List<Keyword>();
// var keyword = new CodeVariableDeclarationStatement("List<Keyword>", "keyword");
// keyword.InitExpression = new CodeObjectCreateExpression("List<Keyword>");
// method.Statements.Add(keyword);
//}
var convertor = new TreeNodeType2TokenType();
foreach (var node in grammar.GetAllTreeNodeLeaveTypes())
{
// keywords.Add(new Keyword("__x", "x"));
if (node.IsIdentifier())
{
TokenType tokenType = convertor.GetTokenType(node);
var ctor = new CodeObjectCreateExpression(typeof(Keyword),
new CodePrimitiveExpression(tokenType.Type),
new CodePrimitiveExpression(tokenType.Content));
var add = new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("keywords"),
"Add",
ctor);
method.Statements.Add(add);
}
}
//{
// // DemoLexicalAnalyzer.keywords = keywords;
// var assign = new CodeAssignStatement(
// new CodeFieldReferenceExpression(
// new CodeSnippetExpression(GetLexicalAnalyzerName(grammarId)), "keywords"),
// new CodeVariableReferenceExpression("keywords"));
// method.Statements.Add(assign);
//}
lexiType.Members.Add(method);
}
}
private static void DumpTokenTypeConstFields(RegulationList grammar, CodeTypeDeclaration tokenTypeConstType)
{
// public const string __colon_colon_equal = "__colon_colon_equal";
var convertor = new TreeNodeType2TokenType();
foreach (var node in grammar.GetAllTreeNodeLeaveTypes())
{
var field = new CodeMemberField(typeof(string), GetNodeNameInParser(node));
field.Attributes = MemberAttributes.Public | MemberAttributes.Const;
TokenType tokenType = convertor.GetTokenType(node);
field.InitExpression = new CodePrimitiveExpression(tokenType.Type);
tokenTypeConstType.Members.Add(field);
}
}
public virtual CodeStatement[] DumpReadToken(string grammarId, SyntaxParserMapAlgorithm algorithm)
{
List <CodeStatement> list = new List <CodeStatement>();
{
/// if ("XXX" == str)
var ifStatement = new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(this.Value.Content),
CodeBinaryOperatorType.IdentityEquality,
new CodeVariableReferenceExpression("str")));
{
var convertor = new TreeNodeType2TokenType();
// result.TokenType = new TokenType("..", "..", "..");
var newTokenType = new CodeAssignStatement(
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("result"),
"TokenType"),
new CodeObjectCreateExpression(typeof(TokenType),
new CodeFieldReferenceExpression(
new CodeTypeReferenceExpression(Program.GetTokenConstTypeName(grammarId, algorithm)),
Program.GetNodeNameInParser(this.Value)),
new CodePrimitiveExpression(this.Value.Content),
new CodePrimitiveExpression(this.Value.Nickname)));
ifStatement.TrueStatements.Add(newTokenType);
// context.NextLetterIndex = context.NextLetterIndex + {0}
var pointer = new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("context"), "NextLetterIndex");
var incresePointer = new CodeAssignStatement(
pointer, new CodeBinaryOperatorExpression(
pointer, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(this.Value.Content.Length)));
ifStatement.TrueStatements.Add(incresePointer);
// return true;
var returnTrue = new CodeMethodReturnStatement(new CodePrimitiveExpression(true));
ifStatement.TrueStatements.Add(returnTrue);
}
list.Add(ifStatement);
}
return(list.ToArray());
}
