public void BooleanDecimalTests()
{
var strings = new List <string>();
var decimals = new List <decimal>();
for (int i = 0; i < 1000; i++)
{
decimals.Add(0);
strings.Add("0");
}
var rnd = new Random();
for (int i = 0; i < 1_000; i++)
{
var n = ((decimal)rnd.Next(7999999)) / 3;
strings.Add(n.ToString(NumberFormatInfo.InvariantInfo));
decimals.Add(n);
}
var tq = new TypeQualifier();
foreach (var s in strings)
{
tq.Qualify(s);
}
Assert.Equal("decimal", tq.DataType);
Assert.Equal(decimals.Max(), tq.MaxValue);
Assert.Equal(decimals.Min(), tq.MinValue);
}
public virtual void VisitTypeQualifier(TypeQualifier node, TContext context)
{
foreach (var n in node.Layout)
{
this.Visit(n, context);
}
}
public void IntegerTests()
{
var strings = new List <string>();
var ints = new List <int>();
strings.Add(null);
var rnd = new Random();
for (int i = 0; i < 1_000_000; i++)
{
var n = rnd.Next(799999);
strings.Add(n.ToString());
ints.Add(n);
}
var tq = new TypeQualifier();
foreach (var s in strings)
{
tq.Qualify(s);
}
Assert.Equal("integer", tq.DataType);
Assert.Equal(ints.Max(), tq.MaxValue);
Assert.Equal(ints.Min(), tq.MinValue);
}
public override AstNode VisitType_qualifier(GLSL_ES300Parser.Type_qualifierContext context)
{
TypeQualifier result = new TypeQualifier();
if (context.invariant_qualifier() != null)
{
result.Invariant = true;
}
if (context.interpolation_qualifier() != null)
{
var interp = context.interpolation_qualifier();
result.Interpolation = (InterpolationQualifier)Enum.Parse(typeof(InterpolationQualifier), interp.GetText(), true);
}
if (context.storage_qualifier() != null)
{
var stor = context.storage_qualifier();
result.Storage = (StorageQualifier)Enum.Parse(typeof(StorageQualifier), stor.GetText(), true);
}
if (context.layout_qualifier() != null)
{
var layoutIdList = context.layout_qualifier().layout_qualifier_idlist();
while (layoutIdList != null)
{
if (layoutIdList.layout_qualifier_id() != null)
{
var idQualifier = new LayoutIdQualifier();
var layoutId = layoutIdList.layout_qualifier_id();
idQualifier.Identifier = new Identifier()
{
Name = layoutId.Identifier().Symbol.Text
};
if (layoutId.IntegerLiteral() != null)
{
idQualifier.Order = new IntegerLiteral()
{
LiteralValue = layoutId.IntegerLiteral().GetText()
};
}
result.Layout.Add(idQualifier);
}
layoutIdList = layoutIdList.layout_qualifier_idlist();
}
}
return(result);
}
public override void VisitTypeQualifier(TypeQualifier node, CloningAstVisitorContext context)
{
var result = new TypeQualifier()
{
Invariant = node.Invariant,
Interpolation = node.Interpolation,
Precision = node.Precision,
Storage = node.Storage
};
this.CloneNodeCollection(node.Layout, result.Layout, context);
context.Result = result;
}
public void StringTests()
{
var strings = new List <string>(new[] { "true", "1", "2", "3.5" });
var tq = new TypeQualifier();
foreach (var s in strings)
{
tq.Qualify(s);
}
Assert.Equal("string", tq.DataType);
Assert.Null(tq.MaxValue);
Assert.Null(tq.MinValue);
}
public override AstNode VisitFully_specified_type([NotNull] GLSL_ES300Parser.Fully_specified_typeContext context)
{
TypeQualifier resultQualifier = null;
var qualifier = context.type_qualifier();
if (qualifier != null)
{
resultQualifier = (TypeQualifier)VisitType_qualifier(qualifier);
}
var typeSpecifier = (TypeSpecifier)VisitType_specifier_nonarray(context.type_specifier_nonarray());
typeSpecifier.Qualifier = resultQualifier;
return(typeSpecifier);
}
public static int WriteTypeQualifiers(this int typeQualifiers, TextWriter writer, int count)
{
string tqString = TypeQualifier.GetTypeQualifierString(typeQualifiers);
if (!string.IsNullOrEmpty(tqString))
{
if (count > 0)
{
writer.Write(' ');
count++;
}
writer.Write(tqString);
count += tqString.Length;
}
return(count);
}
public static bool TypeQualifiersAreEquivalent(TypeQualifier typeQualifier1, TypeQualifier typeQualifier2)
{
if (typeQualifier1 == null && typeQualifier2 == null)
{
return(true);
}
if (typeQualifier1 == null || typeQualifier2 == null)
{
return(false);
}
return
(typeQualifier1.Invariant == typeQualifier2.Invariant &&
typeQualifier1.Interpolation == typeQualifier2.Interpolation &&
typeQualifier1.Precision == typeQualifier2.Precision &&
typeQualifier1.Storage == typeQualifier2.Storage &&
LayoutTypeQualifiersAreEquivalent(typeQualifier1.Layout, typeQualifier2.Layout));
}
public void BooleanTests()
{
string[] booleans = new[] { "true", "false", "1", "0", "y", "n", "yes", "no" };
var strings = new List <string>();
var rnd = new Random();
for (int i = 0; i < 1_000_000; i++)
{
strings.Add(booleans[rnd.Next(7)].ToString());
}
var tq = new TypeQualifier();
foreach (var s in strings)
{
tq.Qualify(s);
}
Assert.Equal("boolean", tq.DataType);
Assert.Null(tq.MaxValue);
Assert.Null(tq.MinValue);
}
public void BooleanIntDecimalStringTests()
{
var strings = new List <string>();
for (int i = 0; i < 1_000; i++)
{
strings.Add("1");
}
var rnd = new Random();
for (int i = 0; i < 1_000; i++)
{
var n = ((decimal)rnd.Next(799999)) / 3;
strings.Add(n.ToString(NumberFormatInfo.InvariantInfo));
}
for (int i = 0; i < 1_000; i++)
{
var n = rnd.Next(799999);
strings.Add(n.ToString());
}
strings.Add("zzzz");
var tq = new TypeQualifier();
foreach (var s in strings)
{
tq.Qualify(s);
}
Assert.Equal("string", tq.DataType);
Assert.Null(tq.MaxValue);
Assert.Null(tq.MinValue);
}
public async Task Consume(ConsumeContext <GenerateMetadata> context)
{
var filter = new BsonDocument("FileId", context.Message.FileId).Add("Status", new BsonDocument("$ne", "Failed"));
var fields = await _files.Aggregate().Match(new BsonDocument("_id", context.Message.FileId))
.Project("{\"Properties.Fields\":1}")
.FirstOrDefaultAsync();
IEnumerable <string> fieldNames = new string[] { };
if (fields.GetValue("Properties", null)?.AsBsonDocument.Contains("Fields") ?? false)
{
fieldNames = fields["Properties"]["Fields"].AsBsonArray.Select(b => b?.AsBsonValue.AsString);
}
var infoboxMetadata = new
{
Id = Guid.NewGuid(),
context.Message.FileId,
Title = "Fields",
FileType = "MOL", // | application/osdr-chemical-file+mol",
InfoBoxType = "fields",
Screens = new[] { new { Title = "", ScreenType = "composite", ScreenParts = new List <object>() } }
};
var entityMetadatas = new
{
Id = context.Message.FileId,
Fields = new List <object>()
};
foreach (var fieldName in fieldNames)
{
var typeQualifer = new TypeQualifier();
using (var cursor = await _records.Aggregate(new AggregateOptions {
BatchSize = 1000
}).Match(filter)
.ReplaceRoot <BsonDocument>("$Properties")
.Unwind("Fields")
.Match(new BsonDocument("Fields.Name", fieldName))
.Project("{\"Fields.Value\":1}").ToCursorAsync())
{
while (await cursor.MoveNextAsync())
{
foreach (var document in cursor.Current)
{
typeQualifer.Qualify(document["Fields"]["Value"].AsString);
}
}
}
var screenParts = new
{
Title = fieldName,
ResponseType = "text-response",
typeQualifer.DataType,
ResponseTarget = $"Properties.Fields[@Name='{fieldName}'].Value"
};
infoboxMetadata.Screens[0].ScreenParts.Add(screenParts);
if (typeQualifer.MaxValue != null)
{
entityMetadatas.Fields.Add(new
{
Name = fieldName,
typeQualifer.DataType,
typeQualifer.MinValue,
typeQualifer.MaxValue
});
}
else
{
entityMetadatas.Fields.Add(new
{
Name = fieldName,
typeQualifer.DataType,
});
}
}
await _metadataCollection.FindOneAndReplaceAsync(new BsonDocument("FileId", context.Message.FileId).Add("InfoBoxType", "fields"), infoboxMetadata.ToBsonDocument(), new FindOneAndReplaceOptions <BsonDocument> {
IsUpsert = true
});
await _metadataCollection.FindOneAndReplaceAsync(new BsonDocument("_id", context.Message.FileId), entityMetadatas.ToBsonDocument(), new FindOneAndReplaceOptions <BsonDocument> {
IsUpsert = true
});
await context.Publish <MetadataGenerated>(new { Id = context.Message.FileId });
}
private static string CSharpName(this Type type, TypeQualifier qualifier, bool includeGenericParameters = true)
{
if (primitives.ContainsKey(type))
{
return(primitives[type]);
}
else if (type.IsGenericParameter)
{
return(includeGenericParameters ? type.Name : "");
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
var nonNullable = Nullable.GetUnderlyingType(type);
var underlyingName = nonNullable.CSharpName(qualifier, includeGenericParameters);
return(underlyingName + "?");
}
else
{
var name = type.Name;
if (type.IsGenericType && name.Contains('`'))
{
name = name.Substring(0, name.IndexOf('`'));
}
var genericArguments = (IEnumerable <Type>)type.GetGenericArguments();
if (type.IsNested)
{
name = type.DeclaringType.CSharpName(qualifier, includeGenericParameters) + "." + name;
if (type.DeclaringType.IsGenericType)
{
genericArguments.Skip(type.DeclaringType.GetGenericArguments().Length);
}
}
if (!type.IsNested)
{
if ((qualifier == TypeQualifier.Namespace || qualifier == TypeQualifier.GlobalNamespace) && type.Namespace != null)
{
name = type.Namespace + "." + name;
}
if (qualifier == TypeQualifier.GlobalNamespace)
{
name = "global::" + name;
}
}
if (genericArguments.Any())
{
name += "<";
name += string.Join(includeGenericParameters ? ", " : ",", genericArguments.Select(t => t.CSharpName(qualifier, includeGenericParameters)).ToArray());
name += ">";
}
return(name);
}
}
public override void VisitTypeQualifier(TypeQualifier node, AstPrinterContext context)
{
bool printed = false;
if (node.Invariant)
{
context.Write("invariant");
printed = true;
}
if (node.Interpolation != null)
{
if (printed)
{
context.Write(" ");
}
context.Write(node.Interpolation.ToString().ToLower());
printed = true;
}
if (node.Layout != null && node.Layout.Count > 0)
{
if (printed)
{
context.Write(" ");
}
context.Write("layout(");
foreach (var n in node.Layout)
{
this.Visit(n, context);
}
context.Write(")");
printed = true;
}
if (node.Storage != null)
{
if (printed)
{
context.Write(" ");
}
if (storageQualifierExplicitStringValues.ContainsKey(node.Storage.Value))
{
context.Write(storageQualifierExplicitStringValues[node.Storage.Value]);
}
else
{
context.Write(node.Storage.ToString().ToLower());
}
printed = true;
}
if (node.Precision != null)
{
if (printed)
{
context.Write(" ");
}
context.Write(node.Precision.ToString().ToLower());
}
}
public static void SetDeclarationRules()
{
// declaration
// : declaration-specifiers [Init-declarator-list]? ';'
Declaration.Is(
(DeclarationSpecifiers)
.Then(InitDeclaratorList.Optional(ImmutableList <InitDeclr> .Empty))
.Then(Semicolon)
.Then(Decln.Create)
.TransformResult(
_ => {
var result = _.Result;
var env = _.Environment;
env = result.InitDeclrs.Aggregate(env, (currentEnv, initDeclr) =>
currentEnv.AddSymbol(
initDeclr.Declr.Name,
result.DeclnSpecs.StorageClsSpecs.DefaultIfEmpty(StorageClsSpec.AUTO).First()
)
);
return(ParserSucceeded.Create(result, env, _.Source));
}
)
);
// declaration-specifiers
// : [ storage-class-specifier | Type-specifier | Type-qualifier ]+
DeclarationSpecifiers.Is(
Parser.Seed(DeclnSpecs.Empty)
.Then(
Either(
Given <DeclnSpecs>()
.Then(StorageClassSpecifier)
.Then(DeclnSpecs.Add)
).Or(
Given <DeclnSpecs>()
.Then(TypeSpecifier)
.Then(DeclnSpecs.Add)
).Or(
Given <DeclnSpecs>()
.Then(TypeQualifier)
.Then(DeclnSpecs.Add)
).OneOrMore()
)
);
// Init-declarator-list
// : Init-declarator [ ',' Init-declarator ]*
InitDeclaratorList.Is(
InitDeclarator.OneOrMore(Comma)
);
// Init-declarator
// : declarator [ '=' initializer ]?
InitDeclarator.Is(
(Declarator)
.Then(
(Assign).Then(Initializer).Optional()
).Then(InitDeclr.Create)
);
// storage-class-specifier
// : auto | register | static | extern | typedef
StorageClassSpecifier.Is(
Either(Auto)
.Or(Register)
.Or(Static)
.Or(Extern)
.Or(Typedef)
);
// Type-specifier
// : void
// | char
// | short
// | int
// | long
// | float
// | double
// | signed
// | unsigned
// | struct-or-union-specifier
// | enum-specifier
// | typedef-name
TypeSpecifier.Is(
Either(
Either(Void)
.Or(Char)
.Or(Short)
.Or(Int)
.Or(Long)
.Or(Float)
.Or(Double)
.Or(Signed)
.Or(Unsigned)
.Then(kind => new BasicTypeSpec(kind) as TypeSpec)
)
.Or(StructOrUnionSpecifier)
.Or(EnumSpecifier)
.Or(TypeDefName.Then(TypedefName.Create))
);
// type_qualifier
// : const
// | volatile
TypeQualifier.Is(
Either(Const).Or(Volatile)
);
// declarator
// : [pointer]? direct-declarator
Declarator.Is(
(Pointer.Optional())
.Then(DirectDeclarator)
.Then(Declr.Create)
);
// pointer
// : [ '*' [Type-qualifier-list]? ]+
Pointer.Is(
(
Mult.
Then(TypeQualifierList.Optional(ImmutableList <TypeQual> .Empty))
.Then(PointerModifier.Create)
).OneOrMore()
.Then(pointerModifiers => pointerModifiers.Reverse())
);
// parameter-Type-list
// : parameter-list [ ',' '...' ]?
ParameterTypeList.Is(
ParameterList
.Then(
(Comma)
.Then(Period).Then(Period).Then(Period)
.Optional()
).Then(ParamTypeList.Create)
);
// parameter-list
// : parameter-declaration [ ',' parameter-declaration ]*
ParameterList.Is(
ParameterDeclaration.OneOrMore(Comma)
);
// Type-qualifier-list
// : [Type-qualifier]+
TypeQualifierList.Is(
TypeQualifier.OneOrMore()
);
// direct-declarator
// : [
// identifier | '(' declarator ')'
// ] [
// '[' [constant-expression]? ']'
// | '(' [parameter-Type-list]? ')'
// ]*
DirectDeclarator.Is(
(
Either(
(Identifier).Then(Declr.Create)
).Or(
(LeftParen).Then(Declarator).Then(RightParen)
)
).Then(
Either(
Given <Declr>()
.Then(LeftBracket)
.Then(
ConstantExpression.Optional().Then(ArrayModifier.Create)
).Then(RightBracket)
.Then(Declr.Add)
).Or(
Given <Declr>()
.Then(LeftParen)
.Then(
ParameterTypeList
.Optional()
.Then(FunctionModifier.Create)
).Then(RightParen)
.Then(Declr.Add)
)
.ZeroOrMore()
)
);
// enum-specifier
// : enum [identifier]? '{' enumerator-list '}'
// | enum identifier
EnumSpecifier.Is(
(Enum)
.Then(
Either(
Identifier.Optional()
.Then(LeftCurlyBrace)
.Then(EnumeratorList)
.Then(RightCurlyBrace)
.Then(EnumSpec.Create)
).Or(
(Identifier)
.Then(EnumSpec.Create)
)
)
);
// enumerator-list
// : enumerator [ ',' enumerator ]*
EnumeratorList.Is(
Enumerator.OneOrMore(Comma)
);
// enumerator
// : enumeration-constant [ '=' constant-expression ]?
Enumerator.Is(
EnumerationConstant
.Then(
(Assign)
.Then(ConstantExpression)
.Optional()
).Then(Enumr.Create)
);
// enumeration-constant
// : identifier
EnumerationConstant.Is(
Identifier
);
// struct-or-union-specifier
// : struct-or-union [identifier]? { struct-declaration-list }
// | struct-or-union identifier
StructOrUnionSpecifier.Is(
(StructOrUnion)
.Then(
Either(
Given <StructOrUnion>()
.Then(Identifier.Optional())
.Then(LeftCurlyBrace)
.Then(StructDeclarationList)
.Then(RightCurlyBrace)
.Then(StructOrUnionSpec.Create)
).Or(
Given <StructOrUnion>()
.Then(Identifier)
.Then(StructOrUnionSpec.Create)
)
)
);
// struct-or-union
// : struct | union
StructOrUnion.Is(
Either(Struct).Or(Union)
);
// struct-declaration-list
// : [struct-declaration]+
StructDeclarationList.Is(
StructDeclaration.OneOrMore()
);
// struct-declaration
// : specifier-qualifier-list struct-declarator-list ';'
StructDeclaration.Is(
(SpecifierQualifierList)
.Then(StructDeclaratorList)
.Then(Semicolon)
.Then(StructDecln.Create)
);
// specifier-qualifier-list
// : [ Type-specifier | Type-qualifier ]+
SpecifierQualifierList.Is(
Parser.Seed(SpecQualList.Empty)
.Then(
Either(
Given <SpecQualList>()
.Then(TypeSpecifier)
.Then(SpecQualList.Add)
).Or(
Given <SpecQualList>()
.Then(TypeQualifier)
.Then(SpecQualList.Add)
)
.OneOrMore()
)
);
// struct-declarator-list
// : struct-declarator [ ',' struct-declarator ]*
StructDeclaratorList.Is(
StructDeclarator.OneOrMore(Comma)
);
// struct-declarator
// : [declarator]? ':' constant-expression
// | declarator
StructDeclarator.Is(
Either(
(Declarator.Optional())
.Then(Colon)
.Then(ConstantExpression)
.Then(StructDeclr.Create)
).Or(
(Declarator)
.Then(StructDeclr.Create)
)
);
// parameter-declaration
// : declaration-specifiers [ declarator | abstract-declarator ]?
ParameterDeclaration.Is(
(DeclarationSpecifiers)
.Then(
Either(
(Declarator).Then(ParamDeclr.Create)
).Or(
(AbstractDeclarator).Then(ParamDeclr.Create)
).Optional()
).Then(ParamDecln.Create)
);
// abstract-declarator
// : [pointer]? direct-abstract-declarator
// | pointer
AbstractDeclarator.Is(
Either(
(Pointer.Optional(ImmutableList <PointerModifier> .Empty))
.Then(DirectAbstractDeclarator)
.Then(AbstractDeclr.Add)
).Or(
(Pointer)
.Then(AbstractDeclr.Create)
)
);
// direct-abstract-declarator
// : [
// '(' abstract-declarator ')'
// | '[' [constant-expression]? ']' // array modifier
// | '(' [parameter-type_list]? ')' // function modifier
// ] [
// '[' [constant-expression]? ']' // array modifier
// | '(' [parameter-Type-list]? ')' // function modifier
// ]*
DirectAbstractDeclarator.Is(
(
Either(
(LeftParen)
.Then(AbstractDeclarator)
.Then(RightParen)
).Or(
(LeftBracket)
.Then(ConstantExpression.Optional())
.Then(RightBracket)
.Then(ArrayModifier.Create)
.Then <ArrayModifier, ImmutableList <ArrayModifier> >(ImmutableList.Create)
.Then(AbstractDeclr.Create)
).Or(
(LeftParen)
.Then(ParameterTypeList.Optional())
.Then(RightParen)
.Then(FunctionModifier.Create)
.Then <FunctionModifier, ImmutableList <FunctionModifier> >(ImmutableList.Create)
.Then(AbstractDeclr.Create)
)
).Then(
Either(
Given <AbstractDeclr>()
.Then(
LeftBracket
.Then(ConstantExpression.Optional())
.Then(RightBracket)
.Then(ArrayModifier.Create)
).Then(
AbstractDeclr.Add
)
).Or(
Given <AbstractDeclr>()
.Then(
(LeftParen)
.Then(ParameterTypeList.Optional())
.Then(RightParen)
.Then(FunctionModifier.Create)
).Then(
AbstractDeclr.Add
)
)
.ZeroOrMore()
)
);
// initializer
// : assignment-expression
// | '{' initializer-list '}'
// | '{' initializer-list ',' '}'
Initializer.Is(
Either <Initr>(
(AssignmentExpression)
.Then(InitExpr.Create)
).Or(
(LeftCurlyBrace)
.Then(InitializerList)
.Then(RightCurlyBrace)
).Or(
(LeftCurlyBrace)
.Then(InitializerList)
.Then(Comma)
.Then(RightCurlyBrace)
)
);
// initializer-list
// : initializer [ ',' initializer ]*
InitializerList.Is(
Initializer.OneOrMore(Comma)
.Then(InitList.Create)
);
// Type-name
// : specifier-qualifier-list [abstract-declarator]?
TypeName.Is(
(SpecifierQualifierList)
.Then(AbstractDeclarator.Optional())
.Then(AST.TypeName.Create)
);
// typedef-name
// : identifier
TypeDefName.Is(
(Identifier)
.Check(
result => result.Environment.IsTypedefName(result.Result)
)
);
}
