private void ParseSchemaDefTaggedOption(ParseTreeNode node, RecordTypeBuilder recordBuilder)
{
_currentNode = node;
foreach (var child in node.ChildNodes)
{
switch (child.Term.Name)
{
case SchematraGrammer.term_schema_def_tag:
var guidText = child.Token.ValueString;
recordBuilder.SetTag(Guid.Parse(guidText));
break;
}
}
}
private void ParseSchemaDefOption(ParseTreeNode node, Context context, RecordTypeBuilder recordBuilder)
{
_currentNode = node;
foreach (var child in node.ChildNodes)
{
switch (child.Term.Name)
{
case SchematraGrammer.term_schema_def_tagged_option:
ParseSchemaDefTaggedOption(child, recordBuilder);
break;
case SchematraGrammer.term_schema_def_extends_option:
ParseSchemaDefExtendsOption(child, context, recordBuilder);
break;
}
}
}
private void ParseSchemaDefOptions(ParseTreeNode node, Context context, RecordTypeBuilder recordBuilder)
{
_currentNode = node;
if (node.ChildNodes.Count <= 0)
return;
foreach (var child in node.ChildNodes)
{
switch (child.Term.Name)
{
case SchematraGrammer.term_schema_def_option:
ParseSchemaDefOption(child, context, recordBuilder);
break;
}
}
}
private void ParseSchemaDefExtendsOption(ParseTreeNode node, Context context, RecordTypeBuilder recordBuilder)
{
_currentNode = node;
foreach (var child in node.ChildNodes)
{
switch (child.Term.Name)
{
case SchematraGrammer.term_schema_def_extends:
recordBuilder.SetBaseType(new TypeResolver(child.Token.ValueString, context.Usings));
break;
}
}
}
private void ParseSchemaDefBody(ParseTreeNode node, Context context, RecordTypeBuilder recordBuilder)
{
_currentNode = node;
foreach (var child in node.ChildNodes)
{
switch (child.Term.Name)
{
case SchematraGrammer.term_field:
ParseField(child, context, recordBuilder);
break;
}
}
}
private void ParseSchemaDef(ParseTreeNode node, Context context, string space)
{
_currentNode = node;
var recordBuilder = new RecordTypeBuilder(context.TypeContext);
foreach (var child in node.ChildNodes)
{
switch (child.Term.Name)
{
case SchematraGrammer.term_schema_def_name:
recordBuilder.SetName(child.Token.Text, space);
break;
case SchematraGrammer.term_schema_def_options:
ParseSchemaDefOptions(child, context, recordBuilder);
break;
case SchematraGrammer.term_schema_def_body:
ParseSchemaDefBody(child, context, recordBuilder);
break;
}
}
context.TypeContext.AddType(recordBuilder.Create());
}
/// <summary>
/// Parsing of field nonterm
/// </summary>
private void ParseField(ParseTreeNode node, Context context, RecordTypeBuilder recordBuilder)
{
_currentNode = node;
Int32 index = 0;
FieldQualifier qualifier = FieldQualifier.Optional;
String typeName = "";
String name = "";
Object defaultValue = null;
foreach (var child in node.ChildNodes)
{
if (child.Term == null || child.Term.Name == null)
continue;
switch (child.Term.Name)
{
case SchematraGrammer.term_field_index:
index = Int32.Parse(child.Token.Value.ToString());
break;
case SchematraGrammer.term_field_qualifier:
qualifier = GetQualifierByString(child.ChildNodes[0].Term.Name);
break;
case SchematraGrammer.term_field_nullable:
// fieldDefinition.Nullable = child.ChildNodes.Count > 0;
break;
case SchematraGrammer.term_field_schema:
typeName = child.Token.Value.ToString();
break;
case SchematraGrammer.term_field_name:
name = child.Token.Value.ToString();
break;
case SchematraGrammer.term_field_init_value:
// yes, too cryptic
if (child.ChildNodes.Count > 0 && child.ChildNodes[0].ChildNodes.Count > 0)
defaultValue = child.ChildNodes[0].ChildNodes[0].Token.Value;
break;
}
}
recordBuilder.AddField(index, name, new TypeResolver(typeName, context.Usings), qualifier, defaultValue);
}
/// <summary>
/// Define Record type
/// </summary>
public TypeContext DefineRecord(Action<RecordTypeBuilder> builder)
{
var recordTypeBuilder = new RecordTypeBuilder(this);
builder(recordTypeBuilder);
AddType(recordTypeBuilder.Create());
return this;
}
