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 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);
}
