/// <summary>
/// Initializes a new instance of the <see cref="DataModelTypeBuilder"/> class.
/// </summary>
/// <param name="decl">The declaration declaring this type.</param>
protected DataModelTypeBuilder(GrammarSymbol decl)
{
this.DeclSymbol = decl;
this.G4DeclaredName = decl.GetLogicalText();
this.SummaryText = decl.Annotations.GetAnnotationValue("summary");
this.RemarksText = decl.Annotations.GetAnnotationValue("remarks");
this.CSharpName
= decl.Annotations.GetAnnotationValue("className")
?? LinguisticTransformer.ToCSharpName(this.G4DeclaredName);
this.InterfaceName = decl.Annotations.GetAnnotationValue("interface");
this.Pattern = decl.Annotations.GetAnnotationValue("pattern");
this.RootObject = decl.Annotations.GetAnnotationValue("rootObject") != null;
this.G4DeclaredValues = new List <string>();
string serializedValuesText = decl.Annotations.GetAnnotationValue("serializedValues");
if (!string.IsNullOrEmpty(serializedValuesText))
{
this.SerializedValues = new List <string>(serializedValuesText.Split(','));
}
else
{
this.SerializedValues = new List <string>();
}
}
public void CompileProduction(GrammarSymbol production)
{
Debug.Assert(production.Kind == SymbolKind.Production);
GrammarSymbol decl = production[0];
Debug.Assert(decl.Kind == SymbolKind.ProductionDecl);
if (decl.FirstToken != production.FirstToken)
{
// Honestly I don't know why "fragment" productions are even
// in the grammar if they're not supposed to be produced; but this is what
// the original MSR code did and we need to parse their grammar files.
Debug.Assert(production.FirstToken.GetText() == "fragment");
return;
}
string productionName = decl.GetLogicalText();
if (s_basicBuiltinTypes.Any(type => type.G4DeclaredName == productionName))
{
// Builtins don't matter in the grammar.
return;
}
GrammarSymbol productionIs = production[1];
switch (productionIs.Kind)
{
case SymbolKind.String:
this.CompileEnumValueType(decl, productionIs.FirstToken);
break;
case SymbolKind.Identifier:
case SymbolKind.ZeroOrMoreQuantifier:
case SymbolKind.OneOrMoreQuantifier:
case SymbolKind.ZeroOrOneQuantifier:
this.CompileStandardType(decl, ImmutableArray.Create(productionIs));
break;
case SymbolKind.Group:
this.CompileStandardType(decl, productionIs.Children);
break;
case SymbolKind.Alternation:
if (productionIs.Children.All(child => child.Kind == SymbolKind.String))
{
this.CompileEnumValueType(decl, productionIs.Children);
break;
}
else if (productionIs.Children.All(child => child.Kind == SymbolKind.Identifier))
{
this.CompileBaseType(decl, productionIs.Children);
break;
}
goto default;
default:
throw new G4ParseFailureException(production.GetLocation(), Strings.UnrecognizedDataModel, productionName);
}
}
/// <summary>
/// Initializes a <see cref="DataModelMetadata"/> instance from the given grammar.
/// </summary>
/// <exception cref="ArgumentException">
/// Thrown when the supplied <see cref="GrammarSymbol"/> is not a valid grammar.
/// </exception>
/// <param name="grammar">
/// The grammar from which the <see cref="DataModelMetadata"/> shall be generated.
/// </param>
/// <returns>
/// A <see cref="DataModelMetadata"/> containing data from the grammar <paramref name="grammar"/>.
/// </returns>
public static DataModelMetadata FromGrammar(GrammarSymbol grammar)
{
if (grammar.Kind != SymbolKind.Grammar)
{
throw new ArgumentException("FromGrammar requires a grammar.");
}
GrammarSymbol decl = grammar.Children[0];
GrammarSymbol grammarId = decl.Children[0];
string grammarName = grammarId.GetLogicalText();
System.Collections.Immutable.ImmutableArray <Annotation> annotations = grammarId.Annotations;
string nameSpace = annotations.GetAnnotationValue("namespace") ?? grammarName;
return(new DataModelMetadata(grammarName, nameSpace, annotations.HasAnnotation("generateLocations"), !annotations.HasAnnotation("noGenerateEquals")));
}
private static List <string> GetStringValuesAfter(ImmutableArray <GrammarSymbol> groupMemberList, int idx)
{
var result = new List <string>();
for (; idx < groupMemberList.Length; ++idx)
{
GrammarSymbol current = groupMemberList[idx];
if (current.Kind != SymbolKind.String)
{
break;
}
result.Add(current.GetLogicalText());
}
return(result);
}
private void CompileBaseType(GrammarSymbol decl, ImmutableArray <GrammarSymbol> children)
{
_compiledBases.Add(decl.GetLogicalText(),
new DataModelBaseTypeBuilder(decl, children.Select(child => child.GetLogicalText())));
}
internal void AddMember(GrammarSymbol declSymbol, int rank, bool required, string delimeter = null)
{
string declaredName = declSymbol.GetLogicalText();
string annotationName = declSymbol.Annotations.GetAnnotationValue("name");
string pattern = declSymbol.Annotations.GetAnnotationValue("pattern");
string minimum = declSymbol.Annotations.GetAnnotationValue("minimum");
string minItems = declSymbol.Annotations.GetAnnotationValue("minItems");
string uniqueItems = declSymbol.Annotations.GetAnnotationValue("uniqueItems");
string defaultValue = declSymbol.Annotations.GetAnnotationValue("default");
string cSharpName = annotationName ?? LinguisticTransformer.ToCSharpName(declaredName);
string serializedName = declSymbol.Annotations.GetAnnotationValue("serializedName");
if (serializedName == null)
{
serializedName = LinguisticTransformer.ToJsonName(cSharpName);
}
if (serializedName == null)
{
serializedName = LinguisticTransformer.ToJsonName(declaredName);
}
string argumentName = declSymbol.Annotations.GetAnnotationValue("argumentName");
if (argumentName == null)
{
if (annotationName == null)
{
argumentName = LinguisticTransformer.ToArgumentName(declaredName);
}
else
{
argumentName = LinguisticTransformer.ToArgumentName(annotationName);
}
}
foreach (DataModelMember existingMember in this.Members)
{
if (existingMember.CSharpName == cSharpName)
{
throw new G4ParseFailureException(declSymbol.GetLocation(), Strings.DuplicateCSharpMemberName, cSharpName);
}
if (existingMember.SerializedName == serializedName)
{
throw new G4ParseFailureException(declSymbol.GetLocation(), Strings.DuplicateJsonMemberName, serializedName);
}
if (existingMember.ArgumentName == argumentName)
{
throw new G4ParseFailureException(declSymbol.GetLocation(), Strings.DuplicateArgumentName, argumentName);
}
}
DataModelMember newMember = new DataModelMember(
declaredName,
cSharpName,
serializedName,
declSymbol.Annotations.GetAnnotationValue("summary"),
argumentName,
pattern,
minimum,
minItems,
uniqueItems,
defaultValue,
rank,
required
);
this.Members.Add(newMember);
this.ToStringEntries.Add(new ToStringEntry(delimeter, newMember));
}