public override void CheckSemantic(Scope scope, ErrorLog log)
{
Left.CheckSemantic(scope, log);
if (Left.Type is StructDeclaration)
{
Member = ((StructDeclaration)Left.Type).GetMember(MemberName);
if (Member == null)
{
log.Error(string.Format("Member {0} is not defined", MemberName), Line, Column);
}
}
else if (Left.Type is PrimitiveTypeDeclaration)
{
Member = ((PrimitiveTypeDeclaration)Left.Type).GetMember(MemberName, scope, log);
if (Member == null)
{
log.Error(string.Format("Member {0} is not defined", MemberName), Line, Column);
}
}
if (Member != null)
{
Type = Member.Type;
}
else
{
Type = ShaderRuntime.Unknow;
log.Error("Type not defined", Line, Column);
}
}
private MemberDefinition GetPublicMember(MemberDeclaration member)
{
return(new MemberDefinition
{
Name = member.Name,
Type = this.nameLookup.Lookup(member.Type, false)
});
}
private bool CanMarshalFrom(MemberDeclaration param)
{
var typeData = this.typeData[param.Type.VkName];
return(typeData.Pattern != TypePattern.Delegate &&
param.Dimensions?.FirstOrDefault()?.Type != LenType.Expression &&
param.Type.FixedLength.Type == FixedLengthType.None);
}
private ParamActionDefinition GetConstructorParam(MemberDeclaration member)
{
return(new ParamActionDefinition
{
MemberName = member.Name,
Param = new ParamDefinition
{
Name = member.ParamName,
Type = this.nameLookup.Lookup(member.Type, true)
}
});
}
/// <summary>
/// Check if scope is valid
/// </summary>
private void CheckScopeValid()
{
MemberDeclaration d = declaration;
if (d.scope.Equals(Scope.PROPERTY) && d.type == null) //type null is considered as void, and only available for method
{
throw new ArgumentException("Properties must have a type");
}
if (d.scope.Equals(Scope.PROPERTY) && d.paramList.HasElement()) //parameters only available for method
{
throw new ArgumentException("Properties cannot have parameter list");
}
}
private static void AddMatrixTypes(Scope scope)
{
TypeDeclaration[] memberTypes = { Float, Int, Boolean };
string[] scalarTypes = { Float.Name, Int.Name, Boolean.Name };
Graphics.ShaderType[] types = { Graphics.ShaderType.Float, Graphics.ShaderType.Int, Graphics.ShaderType.Bool };
for (int i = 0; i < scalarTypes.Length; i++)
{
for (int row = 0; row < 3; row++)
{
for (int column = 0; column < 3; column++)
{
var name = memberTypes[i].Name + (column + 2).ToString() + "x" + (row + 2).ToString();
var matrixType = new PrimitiveTypeDeclaration(name)
{
Colums = column + 2,
Size = 4 * ((column + 2) * (row + 2)),
ReflectionType = new Graphics.ShaderReflectionType()
{
Name = name,
Class = Graphics.TypeClass.Matrix,
Columns = column + 2,
Rows = row + 2,
Elements = 1,
Register = Graphics.RegisterSet.Float4,
Type = types[i]
}
};
var members = new MemberDeclaration[matrixType.Colums * matrixType.Rows];
matrixType.Members = members;
for (int r = 0; r < matrixType.Rows; r++)
{
for (int c = 0; c < matrixType.Colums; c++)
{
members[r * 4 + c] = new MemberDeclaration
{
Name = "_" + (r + 1).ToString() + (c + 1).ToString(),
DeclaringType = matrixType,
Offset = 4 * (r * 4 + c),
Register = Graphics.RegisterSet.Float4,
Type = memberTypes[i]
};
}
}
scope.AddType(matrixType);
}
}
}
}
private void SetDefaultValues(ref MemberDeclaration d)
{
if (string.IsNullOrEmpty(d.accessModifier))
{
d.accessModifier = AccessModifier.PUBLIC;
}
if (string.IsNullOrEmpty(d.inheritance))
{
d.inheritance = Inheritance.DEFAULT;
}
if (string.IsNullOrEmpty(d.scope))
{
d.scope = Scope.METHOD;
}
d.typeAlias = TypeAlias.GetName(d.type);
}
/// <summary>
/// Check for unrecognized token
/// </summary>
private void CheckTokenValid()
{
MemberDeclaration d = declaration;
if (!AccessModifier.IsValid(d.accessModifier))
{
throw new ArgumentException(string.Format("Invalid token '{0}'", d.accessModifier));
}
if (d.inheritance.Equals(Inheritance.SEALED))
{
throw new ArgumentException(string.Format("Invalid token '{0}'", d.inheritance));
}
if (!d.scope.Equals(Scope.METHOD) && !d.scope.Equals(Scope.PROPERTY))
{
throw new ArgumentException(string.Format("Invalid token '{0}'", d.scope));
}
}
/// <summary>
/// Check if type name is valid
/// </summary>
private void CheckNameValid()
{
MemberDeclaration d = declaration;
string n = d.memberName;
if (string.IsNullOrEmpty(n)) //not empty
{
throw new ArgumentException(string.Format("Invalid type name {0}", n));
}
if (!Char.IsLetter(n[0]) && !n[0].Equals('_')) //only starts with letter or underscores
{
throw new ArgumentException(string.Format("Invalid type name {0}", n));
}
for (int i = 1; i < n.Length; ++i)
{
if (!Char.IsLetterOrDigit(n[i]) && !n[i].Equals('_')) //not contains special character
{
throw new ArgumentException(string.Format("Invalid type name {0}", n));
}
}
}
public Vector4Type(Scope scope, string scalar)
: base(scalar + "4")
{
Colums = 4;
_scalarType = scope.GetType(scalar);
scope.AddFunction(new StdFunctionDeclaration(Name, this,
new ParameterDeclaration(_scalarType, "x"),
new ParameterDeclaration(_scalarType, "y"),
new ParameterDeclaration(_scalarType, "z"),
new ParameterDeclaration(_scalarType, "w")));
scope.AddFunction(new StdFunctionDeclaration(Name, this,
new ParameterDeclaration(scope.GetType(scalar + "2"), "v"),
new ParameterDeclaration(_scalarType, "z"),
new ParameterDeclaration(_scalarType, "w")));
scope.AddFunction(new StdFunctionDeclaration(Name, this,
new ParameterDeclaration(scope.GetType(scalar + "3"), "v"),
new ParameterDeclaration(_scalarType, "w")));
Members = new MemberDeclaration[]
{
ShaderRuntime.DeclareMember(this, "x", 0, _scalarType),
ShaderRuntime.DeclareMember(this, "y", 1, _scalarType),
ShaderRuntime.DeclareMember(this, "z", 2, _scalarType),
ShaderRuntime.DeclareMember(this, "w", 3, _scalarType)
};
ReflectionType = new Graphics.ShaderReflectionType
{
Class = Graphics.TypeClass.Vector,
Columns = 4,
Name = Name,
Register = Graphics.RegisterSet.Float4,
Elements = 1,
Type = ShaderRuntime.GetShaderType(scalar)
};
}
private MemberDefinition GetInteropMember(MemberDeclaration member)
{
string name = member.Name;
string type = this.nameLookup.Lookup(member.Type, true);
if (member.Type.FixedLength.Type != FixedLengthType.None && this.typeData[member.Type.VkName].Pattern == TypePattern.Primitive)
{
string length = "1";
if (member.Type.FixedLength.Type == FixedLengthType.IntegerLiteral)
{
length = member.Type.FixedLength.Value;
}
name += $"[{length}]";
type = "fixed " + type;
}
return(new MemberDefinition
{
Name = name,
Type = type
});
}
private static bool IsNumeric(MemberDeclaration member)
{
return(!member.RequiresMarshalling
& NumericsTypes.Contains(member.Type.VkName));
}
// public abstract IType GetDefinition (AstType resolvedType);
public abstract void ReplaceReferences(IMember member, MemberDeclaration replaceWidth);
public MemberReferenceExpression(Expression targetObject, MemberDeclaration memberDeclaration)
{
TargetObject = targetObject;
_memberDeclaration = memberDeclaration;
}
public MemberReferenceExpression(MemberDeclaration memberDeclaration)
{
TargetObject = new ThisExpression();
_memberDeclaration = memberDeclaration;
}
public override void ReplaceReferences(IMember member, MemberDeclaration replaceWidth)
{
throw new NotImplementedException ();
}
/* public override IEnumerable<ICSharpCode.NRefactory.TypeSystem.IMember> ResolveMember (Expression expression)
* {
* var pf = ParsedFile;
* var csResolver = new CSharpResolver (TypeResolveContext, System.Threading.CancellationToken.None);
* var navigator = new NodeListResolveVisitorNavigator (new[] { expression });
*
* var visitor = new ICSharpCode.NRefactory.CSharp.Resolver.ResolveVisitor (csResolver, pf, navigator);
*
* visitor.VisitCompilationUnit (Unit, null);
* var resolveResult = visitor.Resolve (expression);
* if (resolveResult == null)
* yield break;
* if (resolveResult is MemberResolveResult) {
* yield return ((MemberResolveResult)resolveResult).Member;
* } else if (resolveResult is MethodGroupResolveResult) {
* var mgg = (MethodGroupResolveResult)resolveResult;
* foreach (var m in mgg.Methods)
* yield return m;
* }
* }*/
public override void ReplaceReferences(ICSharpCode.NRefactory.TypeSystem.IMember member, MemberDeclaration replaceWidth)
{
// TODO
}
protected bool MatchMember(MemberDeclaration o, PatternMatching.Match match)
{
return MatchAttributesAndModifiers(o, match) && this.ReturnType.DoMatch(o.ReturnType, match)
&& this.PrivateImplementationType.DoMatch(o.PrivateImplementationType, match) && MatchString(this.Name, o.Name);
}
public MemberEventArgs(MemberDeclaration member)
{
Member = member;
}
static void Main(string[] args)
{
if (args.Length > 0)
{
var filePath = args[0];
var code = File.ReadAllText(filePath);
SyntaxTree tree = CSharpSyntaxTree.ParseText(code);
var root = (CompilationUnitSyntax)tree.GetRoot();
var members = root.Members;
var helloWorldDeclaration = (NamespaceDeclarationSyntax)members[0];
var classDeclaration = (ClassDeclarationSyntax)helloWorldDeclaration.Members[0];
SyntaxList <MemberDeclarationSyntax> classMembers = classDeclaration.Members;
var propertyList = new List <MemberDeclaration>();
var meaningfulMembers = classMembers
.OfType <PropertyDeclarationSyntax>()
.Where(member => !HasMemberJsonIgnoreAttribute(member))
.ToList();
foreach (var propertySyntax in meaningfulMembers)
{
var member = new MemberDeclaration();
member.Name = propertySyntax.Identifier.Text.ToCamelCase();
if (propertySyntax.Type is GenericNameSyntax)
{
member.Type = BuildPropertyTypeFromGenericNameSyntax(propertySyntax.Type as GenericNameSyntax);
}
else if (propertySyntax.Type is NullableTypeSyntax)
{
member.Type = BuildPropertyTypeFromNullableTypeSyntax(propertySyntax.Type as NullableTypeSyntax);
}
else
{
member.Type = BuildPropertyTypeFromStandardSyntax(propertySyntax.Type);
}
propertyList.Add(member);
}
//foreach (var memeber in propertyList)
//{
// Console.WriteLine($"{memeber.Name}, Type: {memeber?.Type?.Name}, {memeber?.Type?.IsArray}");
//}
var modelDeclaration = new ModelDeclaration(Path.GetFileNameWithoutExtension(filePath), propertyList);
Console.Write(JsonConvert.SerializeObject(modelDeclaration,
new JsonSerializerSettings
{
DefaultValueHandling = DefaultValueHandling.Ignore,
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Formatting = Formatting.Indented
}));
}
}
protected bool MatchMember(MemberDeclaration o, PatternMatching.Match match)
{
return(MatchAttributesAndModifiers(o, match) && this.ReturnType.DoMatch(o.ReturnType, match) &&
this.PrivateImplementationType.DoMatch(o.PrivateImplementationType, match) && MatchString(this.Name, o.Name));
}
public override void ReplaceReferences(IMember member, MemberDeclaration replaceWidth)
{
throw new NotImplementedException();
}
