public SlotModels(string baseNamespace, GrammarInfo grammarInfo) { Namespace = baseNamespace; // Wenn eine Regel aus mehr als einer Alternative besteht, dann wird diese zur Basisklasse // für die konkreten Syntaxen var baseRules = new Dictionary <string, string>(); foreach (var parserRule in grammarInfo.Rules.Where(rule => rule.Alternatives.Count > 1)) { AbstractSlots.Add(new AbstractSlotModel(rule: parserRule, baseNamespace: baseNamespace)); foreach (var alternative in parserRule.Alternatives) { baseRules[alternative.Elements[0].Name] = parserRule.Name; } } // Aus Regeln mir genau einer "Alternative" werden zu konkreten Syntaxen foreach (var parserRule in grammarInfo.Rules.Where(rule => rule.Alternatives.Count == 1)) { baseRules.TryGetValue(parserRule.Name, out var baseRule); Slots.Add(new SlotModel(rule: parserRule, baseRule: baseRule, baseNamespace: baseNamespace, grammarInfo)); } }
public void LoadGrammarTest() { var g = new GrammarInfo(typeof(TestGrammar)); Assert.AreEqual(2, g.Rules.Count); Assert.AreEqual(2, g.RuleDependencies.Count); Assert.AreEqual("List", g.RuleDependencies["CommentOrWhitespace"].First()); }
public SlotModel(ParserRule rule, string baseRule, string baseNamespace, GrammarInfo grammarInfo) : base(rule: rule, baseNamespace: baseNamespace) { if (rule.Alternatives.Count != 1) { throw new ArgumentException(); } BaseRuleName = baseRule?.ToPascalcase(); SyntaxKind = $"{rule.Name.ToPascalcase()}Syntax"; int index = 0; if (IsSection) { // Überprüfen, ob es sich um eine benannte Sektion handelt var expectedSectionName = RuleName.Replace("Section", "Identifier"); // Die Begin-/End Sektionen muss es geben, andernfalls ist die Grammatik falsch formuliert var sb = grammarInfo.Rules.Single(r => r.Name?.ToPascalcase() == SectionBeginName); var sbName = sb.Alternatives.Single().Elements.FirstOrDefault(e => e.Name.ToPascalcase() == expectedSectionName); var se = grammarInfo.Rules.Single(r => r.Name?.ToPascalcase() == SectionEndName); var seName = se.Alternatives.Single().Elements.FirstOrDefault(e => e.Name.ToPascalcase() == expectedSectionName); if (sbName != null && seName != null) { IsNamedSection = true; NamedSectionIdentifierName = expectedSectionName; } } foreach (var element in rule.Alternatives.Single().Elements) { var name = element.Name.ToPascalcase(); if (name == "EOF") { name = "Eof"; } var syntaxKind = element.SyntaxKind; if (syntaxKind == "EOF") { syntaxKind = "Eof"; } Slots.Add(new SlotMemberModel { Name = name, IsToken = element is TokenElement, IsLabeled = element.IsLabeled, SyntaxKind = syntaxKind, Cardinality = element.Cardinality, SlotIndex = index++ }); } }
private static void GetSetGrammarInformation(Attributes resourceString, StringDataForResourceVersionID item, TextInfomationDto textInfomationDto) { var grammarInformation = resourceString.GrammarInfo.Where(x => x.StringId == item.StringId).ToList(); if (grammarInformation.Count > 0) { foreach (var gInfo in grammarInformation) { GrammarInfo grammar = new GrammarInfo { WordClassId = gInfo.WordClassId, PhraseTemplateId = gInfo.PhraseTemplateId, PhraseElementId = gInfo.PhraseElementId, ModifierPositionId = gInfo.ModifierPositionId }; textInfomationDto.GrammarInfo.Add(grammar); } } }
public SyntaxKindEnumModel(string @namespace, TokenInfo tokenInfo, GrammarInfo grammarInfo) { Namespace = @namespace; EnumMembers.Add( new EnumMemberModel { Name = "None", Value = 0 }); foreach (var token in tokenInfo.Tokens) { EnumMembers.Add( new EnumMemberModel { Name = token.Name, Value = token.Index }); } var syntaxEnumStart = 1000; foreach (var rule in grammarInfo.Rules) { EnumMembers.Add( new EnumMemberModel { Name = $"{rule.Name.ToPascalcase()}Syntax", Value = syntaxEnumStart++ }); } EnumMembers.Add( new EnumMemberModel { Name = "SyntaxList", Value = 2000 }); }
public ClassType[] GenerateParserClasses(BNF bnf, string parserName, string dataNamespace, string parserNamespace) { List <ClassType> classes = new List <ClassType>(); GrammarInfo grammarInfo = _bnfAnalyzer.Analyze(bnf); ClassType parserClass = new ClassType(parserNamespace, "public", parserName, null) { Usings = new List <string>() { $"using {dataNamespace};", "using System;", "using System.Collections.Generic;" } }; parserClass.Methods = new List <MethodType>(); MethodType parseTerminalMethod = new MethodType("public", $"{dataNamespace}.Token", "ParseTerminal") { Parameters = new List <ParameterType>() { new ParameterType($"IEnumerator<{dataNamespace}.Token>", "tokens"), new ParameterType("string", "expected") }, Body = new List <string>() { "if(expected == \"EPSILON\")", "{", $" return new {dataNamespace}.Token() {{ Name = \"EPSILON\" }};", "}", $"{dataNamespace}.Token token = tokens.Current;", "if(token.Name == expected)", "{", " tokens.MoveNext();", " return token;", "}", "else", "{", " throw new UnexpectedTokenException(token);", "}" } }; parserClass.Methods.Add(parseTerminalMethod); foreach (var production in bnf) { MethodType parseMethod = new MethodType("public", $"{dataNamespace}.{production.Key}", $"Parse{production.Key}") { Parameters = new List <ParameterType>() { new ParameterType($"IEnumerator<{dataNamespace}.Token>", "tokens") } }; List <string> methodStatements = new List <string>(); methodStatements.Add($"{dataNamespace}.{production.Key} node = new {dataNamespace}.{production.Key}(){{ Name = \"{production.Key}\" }};"); methodStatements.Add("switch(tokens.Current.Name)"); methodStatements.Add("{"); for (int expansionIndex = 0; expansionIndex < production.Value.Count; expansionIndex++) { foreach (var predictSymbol in grammarInfo.PredictsSets[(production.Key, expansionIndex)])
public IsSuccessResult Edit(int userId, GrammarInfo data) { var log = GetLogger(); var isAdmin = NiHonGoContext.Users .Where(r => r.Type == (int)UserType.Admin) .Any(r => r.Id == userId); if (isAdmin == false) { return(new IsSuccessResult(ErrorCode.NoAuthentication.ToString())); } if (string.IsNullOrWhiteSpace(data.Title)) { return(new IsSuccessResult(ErrorCode.TitleIsNull.ToString())); } if (string.IsNullOrWhiteSpace(data.Description)) { return(new IsSuccessResult(ErrorCode.DescriptionIsNull.ToString())); } try { if (data.Id == 0) { var isAny = NiHonGoContext.Grammars .Any(r => r.Title == data.Title); if (isAny) { return(new IsSuccessResult(ErrorCode.AlreadyHadThisGrammar.ToString())); } var levels = new List <Level>(); foreach (var item in data.Levels) { var level = NiHonGoContext.Levels.SingleOrDefault(r => r.Id == item.Id); if (level != null) { levels.Add(level); } } var grammar = new Grammar { Title = data.Title, Description = data.Description, Levels = levels }; NiHonGoContext.Grammars.Add(grammar); NiHonGoContext.SaveChanges(); } else { var isAny = NiHonGoContext.Grammars .Any(r => r.Title == data.Title && r.Id != data.Id); if (isAny) { return(new IsSuccessResult(ErrorCode.AlreadyHadThisGrammar.ToString())); } var grammar = NiHonGoContext.Grammars .SingleOrDefault(r => r.Id == data.Id); if (grammar == null) { return(new IsSuccessResult(ErrorCode.GrammarNotFound.ToString())); } grammar.Title = data.Title; grammar.Description = data.Description; var levels = new List <Level>(); foreach (var item in data.Levels) { var level = NiHonGoContext.Levels.SingleOrDefault(r => r.Id == item.Id); if (level != null) { levels.Add(level); } } grammar.Levels = levels; NiHonGoContext.SaveChanges(); } return(new IsSuccessResult()); } catch (Exception ex) { log.Error(ex); return(new IsSuccessResult(ErrorCode.InternalError.ToString())); } }
public Attributes GetStringDataForResourceVersionIDs(int resourceVersionId) { var attributes = new Attributes(); using SqlConnection con = new SqlConnection(m_connectionString); DataTable table = new DataTable(); table.Columns.Add("ResourceVersionId", typeof(int)); table.Rows.Add(resourceVersionId); using SqlCommand cmd = new SqlCommand("[dbo].[bsp_GetStringDataForResourceVersionIDs]", con) { CommandType = CommandType.StoredProcedure }; cmd.Parameters.AddWithValue("@resourceVersionIDs", table); con.Open(); using (SqlDataReader reader = cmd.ExecuteReader()) { while (reader.Read()) { StringDataForResourceVersionID stringDataForResourceVersionID = new StringDataForResourceVersionID { StringId = (int)reader["StringId"], FriendlyStringId = (int)reader["FriendlyStringId"], StringTypeId = (int)reader["StringTypeId"], Text = (string)reader["Text"], WordCount = (int)reader["WordCount"], IsTranslationEligible = (bool)reader["IsTranslationEligible"], LocalizedVersionId = (int)reader["LocalizedVersionId"], MaxCharacterLength = (int)reader["MaxCharacterLength"], TimingRestriction = (TimeConstraint)reader["TimingRestriction"], VOComment = (string)reader["VOComment"], EditorComment = (string)reader["EditorComment"], //StringTypeName = (string) reader["StringTypeName"] ListenerCharacterResourceID = Convert.IsDBNull(reader["ListenerCharacterResourceID"]) ? null : (int?)reader["ListenerCharacterResourceID"], //RecordingTypeName = (string)reader["RecordingTypeName"] }; attributes.stringDataForResourceVersionID.Add(stringDataForResourceVersionID); } reader.NextResult(); while (reader.Read()) { StringSpeakerCharacter stringSpeakerCharacter = new StringSpeakerCharacter() { CharacterResourceId = (int)reader["CharacterResourceId"], IsVOEligible = (bool)reader["IsVOEligible"], IsVOReRecord = (bool)reader["IsVOReRecord"], VORequestOnUTC = (DateTime)reader["VORequestOnUTC"], VORequestResourceVersionId = (int)reader["VORequestResourceVersionId"] }; attributes.stringSpeakerCharacter.Add(stringSpeakerCharacter); } reader.NextResult(); while (reader.Read()) { GrammarInfo grammarInfo = new GrammarInfo() { StringId = (int)reader["StringID"], ModifierPositionId = (int)reader["ModifierPositionId"], PhraseTemplateId = (int)reader["PhraseTemplateId"], PhraseElementId = (int)reader["PhraseElementId"], WordClassId = (int)reader["WordClassId"] }; attributes.GrammarInfo.Add(grammarInfo); } } return(attributes); }