From 517513645afb8eaf4841e7b7035f1ba3a9c7cd57 Mon Sep 17 00:00:00 2001 From: Tim Foley Date: Thu, 15 Jun 2017 13:12:51 -0700 Subject: Rename `Slang::Compiler` -> `Slang` This gets rid of one unecessary namespace. --- source/slang/syntax.cpp | 2411 +++++++++++++++++++++++------------------------ 1 file changed, 1204 insertions(+), 1207 deletions(-) (limited to 'source/slang/syntax.cpp') diff --git a/source/slang/syntax.cpp b/source/slang/syntax.cpp index e47c610c0..38323e2b3 100644 --- a/source/slang/syntax.cpp +++ b/source/slang/syntax.cpp @@ -5,1481 +5,1478 @@ namespace Slang { - namespace Compiler - { - // BasicExpressionType - - bool BasicExpressionType::EqualsImpl(ExpressionType * type) - { - auto basicType = dynamic_cast(type); - if (basicType == nullptr) - return false; - return basicType->BaseType == BaseType; - } + // BasicExpressionType - ExpressionType* BasicExpressionType::CreateCanonicalType() - { - // A basic type is already canonical, in our setup - return this; - } + bool BasicExpressionType::EqualsImpl(ExpressionType * type) + { + auto basicType = dynamic_cast(type); + if (basicType == nullptr) + return false; + return basicType->BaseType == BaseType; + } - CoreLib::Basic::String BasicExpressionType::ToString() - { - CoreLib::Basic::StringBuilder res; + ExpressionType* BasicExpressionType::CreateCanonicalType() + { + // A basic type is already canonical, in our setup + return this; + } - switch (BaseType) - { - case Compiler::BaseType::Int: - res.Append("int"); - break; - case Compiler::BaseType::UInt: - res.Append("uint"); - break; - case Compiler::BaseType::UInt64: - res.Append("uint64_t"); - break; - case Compiler::BaseType::Bool: - res.Append("bool"); - break; - case Compiler::BaseType::Float: - res.Append("float"); - break; - case Compiler::BaseType::Void: - res.Append("void"); - break; - default: - break; - } - return res.ProduceString(); - } + CoreLib::Basic::String BasicExpressionType::ToString() + { + CoreLib::Basic::StringBuilder res; + + switch (BaseType) + { + case Slang::BaseType::Int: + res.Append("int"); + break; + case Slang::BaseType::UInt: + res.Append("uint"); + break; + case Slang::BaseType::UInt64: + res.Append("uint64_t"); + break; + case Slang::BaseType::Bool: + res.Append("bool"); + break; + case Slang::BaseType::Float: + res.Append("float"); + break; + case Slang::BaseType::Void: + res.Append("void"); + break; + default: + break; + } + return res.ProduceString(); + } - RefPtr ProgramSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitProgram(this); - } + RefPtr ProgramSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitProgram(this); + } - RefPtr FunctionSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitFunction(this); - } + RefPtr FunctionSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitFunction(this); + } - // + // - RefPtr ScopeDecl::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitScopeDecl(this); - } + RefPtr ScopeDecl::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitScopeDecl(this); + } - // + // - RefPtr BlockStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitBlockStatement(this); - } + RefPtr BlockStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitBlockStatement(this); + } - RefPtr BreakStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitBreakStatement(this); - } + RefPtr BreakStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitBreakStatement(this); + } - RefPtr ContinueStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitContinueStatement(this); - } + RefPtr ContinueStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitContinueStatement(this); + } - RefPtr DoWhileStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitDoWhileStatement(this); - } + RefPtr DoWhileStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitDoWhileStatement(this); + } - RefPtr EmptyStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitEmptyStatement(this); - } + RefPtr EmptyStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitEmptyStatement(this); + } - RefPtr ForStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitForStatement(this); - } + RefPtr ForStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitForStatement(this); + } - RefPtr IfStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitIfStatement(this); - } + RefPtr IfStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitIfStatement(this); + } - RefPtr ReturnStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitReturnStatement(this); - } + RefPtr ReturnStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitReturnStatement(this); + } - RefPtr VarDeclrStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitVarDeclrStatement(this); - } + RefPtr VarDeclrStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitVarDeclrStatement(this); + } - RefPtr Variable::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitDeclrVariable(this); - } + RefPtr Variable::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitDeclrVariable(this); + } - RefPtr WhileStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitWhileStatement(this); - } + RefPtr WhileStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitWhileStatement(this); + } - RefPtr ExpressionStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitExpressionStatement(this); - } + RefPtr ExpressionStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitExpressionStatement(this); + } - RefPtr ConstantExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitConstantExpression(this); - } + RefPtr ConstantExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitConstantExpression(this); + } - RefPtr IndexExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitIndexExpression(this); - } - RefPtr MemberExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitMemberExpression(this); - } + RefPtr IndexExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitIndexExpression(this); + } + RefPtr MemberExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitMemberExpression(this); + } - // SwizzleExpr + // SwizzleExpr - RefPtr SwizzleExpr::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitSwizzleExpression(this); - } + RefPtr SwizzleExpr::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitSwizzleExpression(this); + } - // DerefExpr + // DerefExpr - RefPtr DerefExpr::Accept(SyntaxVisitor * /*visitor*/) - { - // throw "unimplemented"; - return this; - } + RefPtr DerefExpr::Accept(SyntaxVisitor * /*visitor*/) + { + // throw "unimplemented"; + return this; + } - // + // - RefPtr InvokeExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitInvokeExpression(this); - } + RefPtr InvokeExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitInvokeExpression(this); + } - RefPtr TypeCastExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitTypeCastExpression(this); - } + RefPtr TypeCastExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitTypeCastExpression(this); + } - RefPtr VarExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitVarExpression(this); - } + RefPtr VarExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitVarExpression(this); + } - // OverloadedExpr + // OverloadedExpr - RefPtr OverloadedExpr::Accept(SyntaxVisitor * /*visitor*/) - { + RefPtr OverloadedExpr::Accept(SyntaxVisitor * /*visitor*/) + { // throw "unimplemented"; - return this; - } + return this; + } - // + // - RefPtr ParameterSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitParameter(this); - } + RefPtr ParameterSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitParameter(this); + } - // ImportDecl + // ImportDecl - RefPtr ImportDecl::Accept(SyntaxVisitor * visitor) - { - visitor->visitImportDecl(this); - return this; - } + RefPtr ImportDecl::Accept(SyntaxVisitor * visitor) + { + visitor->visitImportDecl(this); + return this; + } - // + // - RefPtr StructField::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitStructField(this); - } - RefPtr StructSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitStruct(this); - } - RefPtr ClassSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitClass(this); - } - RefPtr TypeDefDecl::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitTypeDefDecl(this); - } + RefPtr StructField::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitStructField(this); + } + RefPtr StructSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitStruct(this); + } + RefPtr ClassSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitClass(this); + } + RefPtr TypeDefDecl::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitTypeDefDecl(this); + } - RefPtr DiscardStatementSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitDiscardStatement(this); - } + RefPtr DiscardStatementSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitDiscardStatement(this); + } - // BasicExpressionType + // BasicExpressionType - BasicExpressionType* BasicExpressionType::GetScalarType() - { - return this; - } + BasicExpressionType* BasicExpressionType::GetScalarType() + { + return this; + } - // + // - bool ExpressionType::Equals(ExpressionType * type) - { - return GetCanonicalType()->EqualsImpl(type->GetCanonicalType()); - } + bool ExpressionType::Equals(ExpressionType * type) + { + return GetCanonicalType()->EqualsImpl(type->GetCanonicalType()); + } - bool ExpressionType::Equals(RefPtr type) - { - return Equals(type.Ptr()); - } + bool ExpressionType::Equals(RefPtr type) + { + return Equals(type.Ptr()); + } - bool ExpressionType::EqualsVal(Val* val) - { - if (auto type = dynamic_cast(val)) - return const_cast(this)->Equals(type); - return false; - } + bool ExpressionType::EqualsVal(Val* val) + { + if (auto type = dynamic_cast(val)) + return const_cast(this)->Equals(type); + return false; + } - NamedExpressionType* ExpressionType::AsNamedType() - { - return dynamic_cast(this); - } + NamedExpressionType* ExpressionType::AsNamedType() + { + return dynamic_cast(this); + } - RefPtr ExpressionType::SubstituteImpl(Substitutions* subst, int* ioDiff) - { - int diff = 0; - auto canSubst = GetCanonicalType()->SubstituteImpl(subst, &diff); + RefPtr ExpressionType::SubstituteImpl(Substitutions* subst, int* ioDiff) + { + int diff = 0; + auto canSubst = GetCanonicalType()->SubstituteImpl(subst, &diff); - // If nothing changed, then don't drop any sugar that is applied - if (!diff) - return this; + // If nothing changed, then don't drop any sugar that is applied + if (!diff) + return this; - // If the canonical type changed, then we return a canonical type, - // rather than try to re-construct any amount of sugar - (*ioDiff)++; - return canSubst; - } + // If the canonical type changed, then we return a canonical type, + // rather than try to re-construct any amount of sugar + (*ioDiff)++; + return canSubst; + } - ExpressionType* ExpressionType::GetCanonicalType() + ExpressionType* ExpressionType::GetCanonicalType() + { + if (!this) return nullptr; + ExpressionType* et = const_cast(this); + if (!et->canonicalType) { - if (!this) return nullptr; - ExpressionType* et = const_cast(this); - if (!et->canonicalType) - { - // TODO(tfoley): worry about thread safety here? - et->canonicalType = et->CreateCanonicalType(); - assert(et->canonicalType); - } - return et->canonicalType; + // TODO(tfoley): worry about thread safety here? + et->canonicalType = et->CreateCanonicalType(); + assert(et->canonicalType); } + return et->canonicalType; + } - bool ExpressionType::IsTextureOrSampler() - { - return IsTexture() || IsSampler(); - } - bool ExpressionType::IsStruct() - { - auto declRefType = AsDeclRefType(); - if (!declRefType) return false; - auto structDeclRef = declRefType->declRef.As(); - if (!structDeclRef) return false; - return true; - } + bool ExpressionType::IsTextureOrSampler() + { + return IsTexture() || IsSampler(); + } + bool ExpressionType::IsStruct() + { + auto declRefType = AsDeclRefType(); + if (!declRefType) return false; + auto structDeclRef = declRefType->declRef.As(); + if (!structDeclRef) return false; + return true; + } - bool ExpressionType::IsClass() - { - auto declRefType = AsDeclRefType(); - if (!declRefType) return false; - auto classDeclRef = declRefType->declRef.As(); - if (!classDeclRef) return false; - return true; - } + bool ExpressionType::IsClass() + { + auto declRefType = AsDeclRefType(); + if (!declRefType) return false; + auto classDeclRef = declRefType->declRef.As(); + if (!classDeclRef) return false; + return true; + } #if 0 - RefPtr ExpressionType::Bool; - RefPtr ExpressionType::UInt; - RefPtr ExpressionType::Int; - RefPtr ExpressionType::Float; - RefPtr ExpressionType::Float2; - RefPtr ExpressionType::Void; + RefPtr ExpressionType::Bool; + RefPtr ExpressionType::UInt; + RefPtr ExpressionType::Int; + RefPtr ExpressionType::Float; + RefPtr ExpressionType::Float2; + RefPtr ExpressionType::Void; #endif - RefPtr ExpressionType::Error; - RefPtr ExpressionType::initializerListType; - RefPtr ExpressionType::Overloaded; + RefPtr ExpressionType::Error; + RefPtr ExpressionType::initializerListType; + RefPtr ExpressionType::Overloaded; - Dictionary> ExpressionType::sBuiltinTypes; - Dictionary ExpressionType::sMagicDecls; - List> ExpressionType::sCanonicalTypes; + Dictionary> ExpressionType::sBuiltinTypes; + Dictionary ExpressionType::sMagicDecls; + List> ExpressionType::sCanonicalTypes; - void ExpressionType::Init() - { - Error = new ErrorType(); - initializerListType = new InitializerListType(); - Overloaded = new OverloadGroupType(); - } - void ExpressionType::Finalize() - { - Error = nullptr; - initializerListType = nullptr; - Overloaded = nullptr; - // Note(tfoley): This seems to be just about the only way to clear out a List - sCanonicalTypes = List>(); - sBuiltinTypes = Dictionary>(); - sMagicDecls = Dictionary(); - } - bool ArrayExpressionType::EqualsImpl(ExpressionType * type) - { - auto arrType = type->AsArrayType(); - if (!arrType) - return false; - return (ArrayLength == arrType->ArrayLength && BaseType->Equals(arrType->BaseType.Ptr())); - } - ExpressionType* ArrayExpressionType::CreateCanonicalType() - { - auto canonicalBaseType = BaseType->GetCanonicalType(); - auto canonicalArrayType = new ArrayExpressionType(); - sCanonicalTypes.Add(canonicalArrayType); - canonicalArrayType->BaseType = canonicalBaseType; - canonicalArrayType->ArrayLength = ArrayLength; - return canonicalArrayType; - } - int ArrayExpressionType::GetHashCode() - { - if (ArrayLength) - return (BaseType->GetHashCode() * 16777619) ^ ArrayLength->GetHashCode(); - else - return BaseType->GetHashCode(); - } - CoreLib::Basic::String ArrayExpressionType::ToString() - { - if (ArrayLength) - return BaseType->ToString() + "[" + ArrayLength->ToString() + "]"; - else - return BaseType->ToString() + "[]"; - } - RefPtr GenericAppExpr::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitGenericApp(this); - } - - // DeclRefType - - String DeclRefType::ToString() - { - return declRef.GetName(); - } - - int DeclRefType::GetHashCode() - { - return (declRef.GetHashCode() * 16777619) ^ (int)(typeid(this).hash_code()); - } - - bool DeclRefType::EqualsImpl(ExpressionType * type) - { - if (auto declRefType = type->AsDeclRefType()) - { - return declRef.Equals(declRefType->declRef); - } + void ExpressionType::Init() + { + Error = new ErrorType(); + initializerListType = new InitializerListType(); + Overloaded = new OverloadGroupType(); + } + void ExpressionType::Finalize() + { + Error = nullptr; + initializerListType = nullptr; + Overloaded = nullptr; + // Note(tfoley): This seems to be just about the only way to clear out a List + sCanonicalTypes = List>(); + sBuiltinTypes = Dictionary>(); + sMagicDecls = Dictionary(); + } + bool ArrayExpressionType::EqualsImpl(ExpressionType * type) + { + auto arrType = type->AsArrayType(); + if (!arrType) return false; - } - - ExpressionType* DeclRefType::CreateCanonicalType() - { - // A declaration reference is already canonical - return this; - } - - RefPtr DeclRefType::SubstituteImpl(Substitutions* subst, int* ioDiff) - { - if (!subst) return this; - - // the case we especially care about is when this type references a declaration - // of a generic parameter, since that is what we might be substituting... - if (auto genericTypeParamDecl = dynamic_cast(declRef.GetDecl())) - { - // search for a substitution that might apply to us - for (auto s = subst; s; s = s->outer.Ptr()) - { - // the generic decl associated with the substitution list must be - // the generic decl that declared this parameter - auto genericDecl = s->genericDecl; - if (genericDecl != genericTypeParamDecl->ParentDecl) - continue; - - int index = 0; - for (auto m : genericDecl->Members) - { - if (m.Ptr() == genericTypeParamDecl) - { - // We've found it, so return the corresponding specialization argument - (*ioDiff)++; - return s->args[index]; - } - else if(auto typeParam = m.As()) - { - index++; - } - else if(auto valParam = m.As()) - { - index++; - } - else - { - } - } - - } - } - - - int diff = 0; - DeclRef substDeclRef = declRef.SubstituteImpl(subst, &diff); + return (ArrayLength == arrType->ArrayLength && BaseType->Equals(arrType->BaseType.Ptr())); + } + ExpressionType* ArrayExpressionType::CreateCanonicalType() + { + auto canonicalBaseType = BaseType->GetCanonicalType(); + auto canonicalArrayType = new ArrayExpressionType(); + sCanonicalTypes.Add(canonicalArrayType); + canonicalArrayType->BaseType = canonicalBaseType; + canonicalArrayType->ArrayLength = ArrayLength; + return canonicalArrayType; + } + int ArrayExpressionType::GetHashCode() + { + if (ArrayLength) + return (BaseType->GetHashCode() * 16777619) ^ ArrayLength->GetHashCode(); + else + return BaseType->GetHashCode(); + } + CoreLib::Basic::String ArrayExpressionType::ToString() + { + if (ArrayLength) + return BaseType->ToString() + "[" + ArrayLength->ToString() + "]"; + else + return BaseType->ToString() + "[]"; + } + RefPtr GenericAppExpr::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitGenericApp(this); + } - if (!diff) - return this; + // DeclRefType - // Make sure to record the difference! - *ioDiff += diff; + String DeclRefType::ToString() + { + return declRef.GetName(); + } - // Re-construct the type in case we are using a specialized sub-class - return DeclRefType::Create(substDeclRef); - } + int DeclRefType::GetHashCode() + { + return (declRef.GetHashCode() * 16777619) ^ (int)(typeid(this).hash_code()); + } - static RefPtr ExtractGenericArgType(RefPtr val) + bool DeclRefType::EqualsImpl(ExpressionType * type) + { + if (auto declRefType = type->AsDeclRefType()) { - auto type = val.As(); - assert(type.Ptr()); - return type; + return declRef.Equals(declRefType->declRef); } + return false; + } - static RefPtr ExtractGenericArgInteger(RefPtr val) - { - auto intVal = val.As(); - assert(intVal.Ptr()); - return intVal; - } + ExpressionType* DeclRefType::CreateCanonicalType() + { + // A declaration reference is already canonical + return this; + } + + RefPtr DeclRefType::SubstituteImpl(Substitutions* subst, int* ioDiff) + { + if (!subst) return this; - // TODO: need to figure out how to unify this with the logic - // in the generic case... - DeclRefType* DeclRefType::Create(DeclRef declRef) + // the case we especially care about is when this type references a declaration + // of a generic parameter, since that is what we might be substituting... + if (auto genericTypeParamDecl = dynamic_cast(declRef.GetDecl())) { - if (auto builtinMod = declRef.GetDecl()->FindModifier()) - { - auto type = new BasicExpressionType(builtinMod->tag); - type->declRef = declRef; - return type; - } - else if (auto magicMod = declRef.GetDecl()->FindModifier()) + // search for a substitution that might apply to us + for (auto s = subst; s; s = s->outer.Ptr()) { - Substitutions* subst = declRef.substitutions.Ptr(); + // the generic decl associated with the substitution list must be + // the generic decl that declared this parameter + auto genericDecl = s->genericDecl; + if (genericDecl != genericTypeParamDecl->ParentDecl) + continue; - if (magicMod->name == "SamplerState") - { - auto type = new SamplerStateType(); - type->declRef = declRef; - type->flavor = SamplerStateType::Flavor(magicMod->tag); - return type; - } - else if (magicMod->name == "Vector") - { - assert(subst && subst->args.Count() == 2); - auto vecType = new VectorExpressionType(); - vecType->declRef = declRef; - vecType->elementType = ExtractGenericArgType(subst->args[0]); - vecType->elementCount = ExtractGenericArgInteger(subst->args[1]); - return vecType; - } - else if (magicMod->name == "Matrix") - { - assert(subst && subst->args.Count() == 3); - auto matType = new MatrixExpressionType(); - matType->declRef = declRef; - return matType; - } - else if (magicMod->name == "Texture") - { - assert(subst && subst->args.Count() >= 1); - auto textureType = new TextureType( - TextureType::Flavor(magicMod->tag), - ExtractGenericArgType(subst->args[0])); - textureType->declRef = declRef; - return textureType; - } - else if (magicMod->name == "TextureSampler") - { - assert(subst && subst->args.Count() >= 1); - auto textureType = new TextureSamplerType( - TextureType::Flavor(magicMod->tag), - ExtractGenericArgType(subst->args[0])); - textureType->declRef = declRef; - return textureType; - } - else if (magicMod->name == "GLSLImageType") + int index = 0; + for (auto m : genericDecl->Members) { - assert(subst && subst->args.Count() >= 1); - auto textureType = new GLSLImageType( - TextureType::Flavor(magicMod->tag), - ExtractGenericArgType(subst->args[0])); - textureType->declRef = declRef; - return textureType; - } - - #define CASE(n,T) \ - else if(magicMod->name == #n) { \ - assert(subst && subst->args.Count() == 1); \ - auto type = new T(); \ - type->elementType = ExtractGenericArgType(subst->args[0]); \ - type->declRef = declRef; \ - return type; \ + if (m.Ptr() == genericTypeParamDecl) + { + // We've found it, so return the corresponding specialization argument + (*ioDiff)++; + return s->args[index]; } - - CASE(ConstantBuffer, ConstantBufferType) - CASE(TextureBuffer, TextureBufferType) - CASE(GLSLInputParameterBlockType, GLSLInputParameterBlockType) - CASE(GLSLOutputParameterBlockType, GLSLOutputParameterBlockType) - CASE(GLSLShaderStorageBufferType, GLSLShaderStorageBufferType) - - CASE(PackedBuffer, PackedBufferType) - CASE(Uniform, UniformBufferType) - CASE(Patch, PatchType) - - CASE(HLSLBufferType, HLSLBufferType) - CASE(HLSLStructuredBufferType, HLSLStructuredBufferType) - CASE(HLSLRWBufferType, HLSLRWBufferType) - CASE(HLSLRWStructuredBufferType, HLSLRWStructuredBufferType) - CASE(HLSLAppendStructuredBufferType, HLSLAppendStructuredBufferType) - CASE(HLSLConsumeStructuredBufferType, HLSLConsumeStructuredBufferType) - CASE(HLSLInputPatchType, HLSLInputPatchType) - CASE(HLSLOutputPatchType, HLSLOutputPatchType) - - CASE(HLSLPointStreamType, HLSLPointStreamType) - CASE(HLSLLineStreamType, HLSLPointStreamType) - CASE(HLSLTriangleStreamType, HLSLPointStreamType) - - #undef CASE - - // "magic" builtin types which have no generic parameters - #define CASE(n,T) \ - else if(magicMod->name == #n) { \ - auto type = new T(); \ - type->declRef = declRef; \ - return type; \ + else if(auto typeParam = m.As()) + { + index++; + } + else if(auto valParam = m.As()) + { + index++; + } + else + { } - - CASE(HLSLByteAddressBufferType, HLSLByteAddressBufferType) - CASE(HLSLRWByteAddressBufferType, HLSLRWByteAddressBufferType) - CASE(UntypedBufferResourceType, UntypedBufferResourceType) - - CASE(GLSLInputAttachmentType, GLSLInputAttachmentType) - - #undef CASE - - else - { - throw "unimplemented"; } - } - else - { - return new DeclRefType(declRef); + } } - // OverloadGroupType - - String OverloadGroupType::ToString() - { - return "overload group"; - } - bool OverloadGroupType::EqualsImpl(ExpressionType * /*type*/) - { - return false; - } + int diff = 0; + DeclRef substDeclRef = declRef.SubstituteImpl(subst, &diff); - ExpressionType* OverloadGroupType::CreateCanonicalType() - { + if (!diff) return this; - } - int OverloadGroupType::GetHashCode() - { - return (int)(int64_t)(void*)this; - } + // Make sure to record the difference! + *ioDiff += diff; - // InitializerListType + // Re-construct the type in case we are using a specialized sub-class + return DeclRefType::Create(substDeclRef); + } - String InitializerListType::ToString() - { - return "initializer list"; - } + static RefPtr ExtractGenericArgType(RefPtr val) + { + auto type = val.As(); + assert(type.Ptr()); + return type; + } - bool InitializerListType::EqualsImpl(ExpressionType * /*type*/) - { - return false; - } + static RefPtr ExtractGenericArgInteger(RefPtr val) + { + auto intVal = val.As(); + assert(intVal.Ptr()); + return intVal; + } - ExpressionType* InitializerListType::CreateCanonicalType() + // TODO: need to figure out how to unify this with the logic + // in the generic case... + DeclRefType* DeclRefType::Create(DeclRef declRef) + { + if (auto builtinMod = declRef.GetDecl()->FindModifier()) { - return this; + auto type = new BasicExpressionType(builtinMod->tag); + type->declRef = declRef; + return type; } - - int InitializerListType::GetHashCode() + else if (auto magicMod = declRef.GetDecl()->FindModifier()) { - return (int)(int64_t)(void*)this; - } + Substitutions* subst = declRef.substitutions.Ptr(); - // ErrorType + if (magicMod->name == "SamplerState") + { + auto type = new SamplerStateType(); + type->declRef = declRef; + type->flavor = SamplerStateType::Flavor(magicMod->tag); + return type; + } + else if (magicMod->name == "Vector") + { + assert(subst && subst->args.Count() == 2); + auto vecType = new VectorExpressionType(); + vecType->declRef = declRef; + vecType->elementType = ExtractGenericArgType(subst->args[0]); + vecType->elementCount = ExtractGenericArgInteger(subst->args[1]); + return vecType; + } + else if (magicMod->name == "Matrix") + { + assert(subst && subst->args.Count() == 3); + auto matType = new MatrixExpressionType(); + matType->declRef = declRef; + return matType; + } + else if (magicMod->name == "Texture") + { + assert(subst && subst->args.Count() >= 1); + auto textureType = new TextureType( + TextureType::Flavor(magicMod->tag), + ExtractGenericArgType(subst->args[0])); + textureType->declRef = declRef; + return textureType; + } + else if (magicMod->name == "TextureSampler") + { + assert(subst && subst->args.Count() >= 1); + auto textureType = new TextureSamplerType( + TextureType::Flavor(magicMod->tag), + ExtractGenericArgType(subst->args[0])); + textureType->declRef = declRef; + return textureType; + } + else if (magicMod->name == "GLSLImageType") + { + assert(subst && subst->args.Count() >= 1); + auto textureType = new GLSLImageType( + TextureType::Flavor(magicMod->tag), + ExtractGenericArgType(subst->args[0])); + textureType->declRef = declRef; + return textureType; + } - String ErrorType::ToString() - { - return "error"; - } + #define CASE(n,T) \ + else if(magicMod->name == #n) { \ + assert(subst && subst->args.Count() == 1); \ + auto type = new T(); \ + type->elementType = ExtractGenericArgType(subst->args[0]); \ + type->declRef = declRef; \ + return type; \ + } - bool ErrorType::EqualsImpl(ExpressionType* type) - { - if (auto errorType = type->As()) - return true; - return false; - } + CASE(ConstantBuffer, ConstantBufferType) + CASE(TextureBuffer, TextureBufferType) + CASE(GLSLInputParameterBlockType, GLSLInputParameterBlockType) + CASE(GLSLOutputParameterBlockType, GLSLOutputParameterBlockType) + CASE(GLSLShaderStorageBufferType, GLSLShaderStorageBufferType) + + CASE(PackedBuffer, PackedBufferType) + CASE(Uniform, UniformBufferType) + CASE(Patch, PatchType) + + CASE(HLSLBufferType, HLSLBufferType) + CASE(HLSLStructuredBufferType, HLSLStructuredBufferType) + CASE(HLSLRWBufferType, HLSLRWBufferType) + CASE(HLSLRWStructuredBufferType, HLSLRWStructuredBufferType) + CASE(HLSLAppendStructuredBufferType, HLSLAppendStructuredBufferType) + CASE(HLSLConsumeStructuredBufferType, HLSLConsumeStructuredBufferType) + CASE(HLSLInputPatchType, HLSLInputPatchType) + CASE(HLSLOutputPatchType, HLSLOutputPatchType) + + CASE(HLSLPointStreamType, HLSLPointStreamType) + CASE(HLSLLineStreamType, HLSLPointStreamType) + CASE(HLSLTriangleStreamType, HLSLPointStreamType) + + #undef CASE + + // "magic" builtin types which have no generic parameters + #define CASE(n,T) \ + else if(magicMod->name == #n) { \ + auto type = new T(); \ + type->declRef = declRef; \ + return type; \ + } - ExpressionType* ErrorType::CreateCanonicalType() - { - return this; - } + CASE(HLSLByteAddressBufferType, HLSLByteAddressBufferType) + CASE(HLSLRWByteAddressBufferType, HLSLRWByteAddressBufferType) + CASE(UntypedBufferResourceType, UntypedBufferResourceType) + + CASE(GLSLInputAttachmentType, GLSLInputAttachmentType) - int ErrorType::GetHashCode() + #undef CASE + + else + { + throw "unimplemented"; + } + } + else { - return (int)(int64_t)(void*)this; + return new DeclRefType(declRef); } + } + // OverloadGroupType - // NamedExpressionType + String OverloadGroupType::ToString() + { + return "overload group"; + } - String NamedExpressionType::ToString() - { - return declRef.GetName(); - } + bool OverloadGroupType::EqualsImpl(ExpressionType * /*type*/) + { + return false; + } - bool NamedExpressionType::EqualsImpl(ExpressionType * /*type*/) - { - assert(!"unreachable"); - return false; - } + ExpressionType* OverloadGroupType::CreateCanonicalType() + { + return this; + } - ExpressionType* NamedExpressionType::CreateCanonicalType() - { - return declRef.GetType()->GetCanonicalType(); - } + int OverloadGroupType::GetHashCode() + { + return (int)(int64_t)(void*)this; + } - int NamedExpressionType::GetHashCode() - { - assert(!"unreachable"); - return 0; - } + // InitializerListType - // FuncType + String InitializerListType::ToString() + { + return "initializer list"; + } - String FuncType::ToString() - { - // TODO: a better approach than this - if (declRef) - return declRef.GetName(); - else - return "/* unknown FuncType */"; - } + bool InitializerListType::EqualsImpl(ExpressionType * /*type*/) + { + return false; + } - bool FuncType::EqualsImpl(ExpressionType * type) - { - if (auto funcType = type->As()) - { - return declRef == funcType->declRef; - } - return false; - } + ExpressionType* InitializerListType::CreateCanonicalType() + { + return this; + } - ExpressionType* FuncType::CreateCanonicalType() - { - return this; - } + int InitializerListType::GetHashCode() + { + return (int)(int64_t)(void*)this; + } - int FuncType::GetHashCode() - { - return declRef.GetHashCode(); - } + // ErrorType - // TypeType + String ErrorType::ToString() + { + return "error"; + } - String TypeType::ToString() - { - StringBuilder sb; - sb << "typeof(" << type->ToString() << ")"; - return sb.ProduceString(); - } + bool ErrorType::EqualsImpl(ExpressionType* type) + { + if (auto errorType = type->As()) + return true; + return false; + } - bool TypeType::EqualsImpl(ExpressionType * t) - { - if (auto typeType = t->As()) - { - return t->Equals(typeType->type); - } - return false; - } + ExpressionType* ErrorType::CreateCanonicalType() + { + return this; + } - ExpressionType* TypeType::CreateCanonicalType() - { - auto canType = new TypeType(type->GetCanonicalType()); - sCanonicalTypes.Add(canType); - return canType; - } + int ErrorType::GetHashCode() + { + return (int)(int64_t)(void*)this; + } - int TypeType::GetHashCode() - { - assert(!"unreachable"); - return 0; - } - // GenericDeclRefType + // NamedExpressionType - String GenericDeclRefType::ToString() - { - // TODO: what is appropriate here? - return ""; - } + String NamedExpressionType::ToString() + { + return declRef.GetName(); + } - bool GenericDeclRefType::EqualsImpl(ExpressionType * type) - { - if (auto genericDeclRefType = type->As()) - { - return declRef.Equals(genericDeclRefType->declRef); - } - return false; - } + bool NamedExpressionType::EqualsImpl(ExpressionType * /*type*/) + { + assert(!"unreachable"); + return false; + } - int GenericDeclRefType::GetHashCode() - { - return declRef.GetHashCode(); - } + ExpressionType* NamedExpressionType::CreateCanonicalType() + { + return declRef.GetType()->GetCanonicalType(); + } - ExpressionType* GenericDeclRefType::CreateCanonicalType() - { - return this; - } + int NamedExpressionType::GetHashCode() + { + assert(!"unreachable"); + return 0; + } - // ArithmeticExpressionType + // FuncType - // VectorExpressionType + String FuncType::ToString() + { + // TODO: a better approach than this + if (declRef) + return declRef.GetName(); + else + return "/* unknown FuncType */"; + } - String VectorExpressionType::ToString() + bool FuncType::EqualsImpl(ExpressionType * type) + { + if (auto funcType = type->As()) { - StringBuilder sb; - sb << "vector<" << elementType->ToString() << "," << elementCount->ToString() << ">"; - return sb.ProduceString(); + return declRef == funcType->declRef; } + return false; + } - BasicExpressionType* VectorExpressionType::GetScalarType() - { - return elementType->AsBasicType(); - } + ExpressionType* FuncType::CreateCanonicalType() + { + return this; + } - // MatrixExpressionType + int FuncType::GetHashCode() + { + return declRef.GetHashCode(); + } - String MatrixExpressionType::ToString() - { - StringBuilder sb; - sb << "matrix<" << getElementType()->ToString() << "," << getRowCount()->ToString() << "," << getColumnCount()->ToString() << ">"; - return sb.ProduceString(); - } + // TypeType - BasicExpressionType* MatrixExpressionType::GetScalarType() - { - return getElementType()->AsBasicType(); - } + String TypeType::ToString() + { + StringBuilder sb; + sb << "typeof(" << type->ToString() << ")"; + return sb.ProduceString(); + } - ExpressionType* MatrixExpressionType::getElementType() + bool TypeType::EqualsImpl(ExpressionType * t) + { + if (auto typeType = t->As()) { - return this->declRef.substitutions->args[0].As().Ptr(); + return t->Equals(typeType->type); } + return false; + } - IntVal* MatrixExpressionType::getRowCount() - { - return this->declRef.substitutions->args[1].As().Ptr(); - } + ExpressionType* TypeType::CreateCanonicalType() + { + auto canType = new TypeType(type->GetCanonicalType()); + sCanonicalTypes.Add(canType); + return canType; + } - IntVal* MatrixExpressionType::getColumnCount() - { - return this->declRef.substitutions->args[2].As().Ptr(); - } + int TypeType::GetHashCode() + { + assert(!"unreachable"); + return 0; + } - // + // GenericDeclRefType -#if 0 - String GetOperatorFunctionName(Operator op) - { - switch (op) - { - case Operator::Add: - case Operator::AddAssign: - return "+"; - case Operator::Sub: - case Operator::SubAssign: - return "-"; - case Operator::Neg: - return "-"; - case Operator::Not: - return "!"; - case Operator::BitNot: - return "~"; - case Operator::PreInc: - case Operator::PostInc: - return "++"; - case Operator::PreDec: - case Operator::PostDec: - return "--"; - case Operator::Mul: - case Operator::MulAssign: - return "*"; - case Operator::Div: - case Operator::DivAssign: - return "/"; - case Operator::Mod: - case Operator::ModAssign: - return "%"; - case Operator::Lsh: - case Operator::LshAssign: - return "<<"; - case Operator::Rsh: - case Operator::RshAssign: - return ">>"; - case Operator::Eql: - return "=="; - case Operator::Neq: - return "!="; - case Operator::Greater: - return ">"; - case Operator::Less: - return "<"; - case Operator::Geq: - return ">="; - case Operator::Leq: - return "<="; - case Operator::BitAnd: - case Operator::AndAssign: - return "&"; - case Operator::BitXor: - case Operator::XorAssign: - return "^"; - case Operator::BitOr: - case Operator::OrAssign: - return "|"; - case Operator::And: - return "&&"; - case Operator::Or: - return "||"; - case Operator::Sequence: - return ","; - case Operator::Select: - return "?:"; - case Operator::Assign: - return "="; - default: - return ""; - } - } -#endif - String OperatorToString(Operator op) + String GenericDeclRefType::ToString() + { + // TODO: what is appropriate here? + return ""; + } + + bool GenericDeclRefType::EqualsImpl(ExpressionType * type) + { + if (auto genericDeclRefType = type->As()) { - switch (op) - { - case Slang::Compiler::Operator::Neg: - return "-"; - case Slang::Compiler::Operator::Not: - return "!"; - case Slang::Compiler::Operator::PreInc: - return "++"; - case Slang::Compiler::Operator::PreDec: - return "--"; - case Slang::Compiler::Operator::PostInc: - return "++"; - case Slang::Compiler::Operator::PostDec: - return "--"; - case Slang::Compiler::Operator::Mul: - case Slang::Compiler::Operator::MulAssign: - return "*"; - case Slang::Compiler::Operator::Div: - case Slang::Compiler::Operator::DivAssign: - return "/"; - case Slang::Compiler::Operator::Mod: - case Slang::Compiler::Operator::ModAssign: - return "%"; - case Slang::Compiler::Operator::Add: - case Slang::Compiler::Operator::AddAssign: - return "+"; - case Slang::Compiler::Operator::Sub: - case Slang::Compiler::Operator::SubAssign: - return "-"; - case Slang::Compiler::Operator::Lsh: - case Slang::Compiler::Operator::LshAssign: - return "<<"; - case Slang::Compiler::Operator::Rsh: - case Slang::Compiler::Operator::RshAssign: - return ">>"; - case Slang::Compiler::Operator::Eql: - return "=="; - case Slang::Compiler::Operator::Neq: - return "!="; - case Slang::Compiler::Operator::Greater: - return ">"; - case Slang::Compiler::Operator::Less: - return "<"; - case Slang::Compiler::Operator::Geq: - return ">="; - case Slang::Compiler::Operator::Leq: - return "<="; - case Slang::Compiler::Operator::BitAnd: - case Slang::Compiler::Operator::AndAssign: - return "&"; - case Slang::Compiler::Operator::BitXor: - case Slang::Compiler::Operator::XorAssign: - return "^"; - case Slang::Compiler::Operator::BitOr: - case Slang::Compiler::Operator::OrAssign: - return "|"; - case Slang::Compiler::Operator::And: - return "&&"; - case Slang::Compiler::Operator::Or: - return "||"; - case Slang::Compiler::Operator::Assign: - return "="; - default: - return "ERROR"; - } + return declRef.Equals(genericDeclRefType->declRef); } + return false; + } - // TypeExp + int GenericDeclRefType::GetHashCode() + { + return declRef.GetHashCode(); + } - TypeExp TypeExp::Accept(SyntaxVisitor* visitor) - { - return visitor->VisitTypeExp(*this); - } + ExpressionType* GenericDeclRefType::CreateCanonicalType() + { + return this; + } - // BuiltinTypeModifier + // ArithmeticExpressionType - // MagicTypeModifier + // VectorExpressionType - // GenericDecl + String VectorExpressionType::ToString() + { + StringBuilder sb; + sb << "vector<" << elementType->ToString() << "," << elementCount->ToString() << ">"; + return sb.ProduceString(); + } - RefPtr GenericDecl::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitGenericDecl(this); - } + BasicExpressionType* VectorExpressionType::GetScalarType() + { + return elementType->AsBasicType(); + } - // GenericTypeParamDecl + // MatrixExpressionType - RefPtr GenericTypeParamDecl::Accept(SyntaxVisitor * /*visitor*/) { - //throw "unimplemented"; - return this; - } + String MatrixExpressionType::ToString() + { + StringBuilder sb; + sb << "matrix<" << getElementType()->ToString() << "," << getRowCount()->ToString() << "," << getColumnCount()->ToString() << ">"; + return sb.ProduceString(); + } - // GenericTypeConstraintDecl + BasicExpressionType* MatrixExpressionType::GetScalarType() + { + return getElementType()->AsBasicType(); + } - RefPtr GenericTypeConstraintDecl::Accept(SyntaxVisitor * visitor) - { - return this; - } + ExpressionType* MatrixExpressionType::getElementType() + { + return this->declRef.substitutions->args[0].As().Ptr(); + } - // GenericValueParamDecl + IntVal* MatrixExpressionType::getRowCount() + { + return this->declRef.substitutions->args[1].As().Ptr(); + } - RefPtr GenericValueParamDecl::Accept(SyntaxVisitor * /*visitor*/) { - //throw "unimplemented"; - return this; - } + IntVal* MatrixExpressionType::getColumnCount() + { + return this->declRef.substitutions->args[2].As().Ptr(); + } - // GenericParamIntVal + // - bool GenericParamIntVal::EqualsVal(Val* val) - { - if (auto genericParamVal = dynamic_cast(val)) - { - return declRef.Equals(genericParamVal->declRef); - } - return false; +#if 0 + String GetOperatorFunctionName(Operator op) + { + switch (op) + { + case Operator::Add: + case Operator::AddAssign: + return "+"; + case Operator::Sub: + case Operator::SubAssign: + return "-"; + case Operator::Neg: + return "-"; + case Operator::Not: + return "!"; + case Operator::BitNot: + return "~"; + case Operator::PreInc: + case Operator::PostInc: + return "++"; + case Operator::PreDec: + case Operator::PostDec: + return "--"; + case Operator::Mul: + case Operator::MulAssign: + return "*"; + case Operator::Div: + case Operator::DivAssign: + return "/"; + case Operator::Mod: + case Operator::ModAssign: + return "%"; + case Operator::Lsh: + case Operator::LshAssign: + return "<<"; + case Operator::Rsh: + case Operator::RshAssign: + return ">>"; + case Operator::Eql: + return "=="; + case Operator::Neq: + return "!="; + case Operator::Greater: + return ">"; + case Operator::Less: + return "<"; + case Operator::Geq: + return ">="; + case Operator::Leq: + return "<="; + case Operator::BitAnd: + case Operator::AndAssign: + return "&"; + case Operator::BitXor: + case Operator::XorAssign: + return "^"; + case Operator::BitOr: + case Operator::OrAssign: + return "|"; + case Operator::And: + return "&&"; + case Operator::Or: + return "||"; + case Operator::Sequence: + return ","; + case Operator::Select: + return "?:"; + case Operator::Assign: + return "="; + default: + return ""; } - - String GenericParamIntVal::ToString() - { - return declRef.GetName(); + } +#endif + String OperatorToString(Operator op) + { + switch (op) + { + case Slang::Operator::Neg: + return "-"; + case Slang::Operator::Not: + return "!"; + case Slang::Operator::PreInc: + return "++"; + case Slang::Operator::PreDec: + return "--"; + case Slang::Operator::PostInc: + return "++"; + case Slang::Operator::PostDec: + return "--"; + case Slang::Operator::Mul: + case Slang::Operator::MulAssign: + return "*"; + case Slang::Operator::Div: + case Slang::Operator::DivAssign: + return "/"; + case Slang::Operator::Mod: + case Slang::Operator::ModAssign: + return "%"; + case Slang::Operator::Add: + case Slang::Operator::AddAssign: + return "+"; + case Slang::Operator::Sub: + case Slang::Operator::SubAssign: + return "-"; + case Slang::Operator::Lsh: + case Slang::Operator::LshAssign: + return "<<"; + case Slang::Operator::Rsh: + case Slang::Operator::RshAssign: + return ">>"; + case Slang::Operator::Eql: + return "=="; + case Slang::Operator::Neq: + return "!="; + case Slang::Operator::Greater: + return ">"; + case Slang::Operator::Less: + return "<"; + case Slang::Operator::Geq: + return ">="; + case Slang::Operator::Leq: + return "<="; + case Slang::Operator::BitAnd: + case Slang::Operator::AndAssign: + return "&"; + case Slang::Operator::BitXor: + case Slang::Operator::XorAssign: + return "^"; + case Slang::Operator::BitOr: + case Slang::Operator::OrAssign: + return "|"; + case Slang::Operator::And: + return "&&"; + case Slang::Operator::Or: + return "||"; + case Slang::Operator::Assign: + return "="; + default: + return "ERROR"; } + } - int GenericParamIntVal::GetHashCode() - { - return declRef.GetHashCode() ^ 0xFFFF; - } + // TypeExp - RefPtr GenericParamIntVal::SubstituteImpl(Substitutions* subst, int* ioDiff) - { - // search for a substitution that might apply to us - for (auto s = subst; s; s = s->outer.Ptr()) - { - // the generic decl associated with the substitution list must be - // the generic decl that declared this parameter - auto genericDecl = s->genericDecl; - if (genericDecl != declRef.GetDecl()->ParentDecl) - continue; + TypeExp TypeExp::Accept(SyntaxVisitor* visitor) + { + return visitor->VisitTypeExp(*this); + } - int index = 0; - for (auto m : genericDecl->Members) - { - if (m.Ptr() == declRef.GetDecl()) - { - // We've found it, so return the corresponding specialization argument - (*ioDiff)++; - return s->args[index]; - } - else if(auto typeParam = m.As()) - { - index++; - } - else if(auto valParam = m.As()) - { - index++; - } - else - { - } - } - } + // BuiltinTypeModifier - // Nothing found: don't substittue. - return this; - } + // MagicTypeModifier - // ExtensionDecl + // GenericDecl - RefPtr ExtensionDecl::Accept(SyntaxVisitor * visitor) - { - visitor->VisitExtensionDecl(this); - return this; - } + RefPtr GenericDecl::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitGenericDecl(this); + } - // ConstructorDecl + // GenericTypeParamDecl - RefPtr ConstructorDecl::Accept(SyntaxVisitor * visitor) - { - visitor->VisitConstructorDecl(this); - return this; - } + RefPtr GenericTypeParamDecl::Accept(SyntaxVisitor * /*visitor*/) { + //throw "unimplemented"; + return this; + } - // SubscriptDecl + // GenericTypeConstraintDecl - RefPtr SubscriptDecl::Accept(SyntaxVisitor * visitor) - { - visitor->visitSubscriptDecl(this); - return this; - } + RefPtr GenericTypeConstraintDecl::Accept(SyntaxVisitor * visitor) + { + return this; + } - // AccessorDecl + // GenericValueParamDecl - RefPtr AccessorDecl::Accept(SyntaxVisitor * visitor) + RefPtr GenericValueParamDecl::Accept(SyntaxVisitor * /*visitor*/) { + //throw "unimplemented"; + return this; + } + + // GenericParamIntVal + + bool GenericParamIntVal::EqualsVal(Val* val) + { + if (auto genericParamVal = dynamic_cast(val)) { - visitor->visitAccessorDecl(this); - return this; + return declRef.Equals(genericParamVal->declRef); } + return false; + } + + String GenericParamIntVal::ToString() + { + return declRef.GetName(); + } - // Substitutions + int GenericParamIntVal::GetHashCode() + { + return declRef.GetHashCode() ^ 0xFFFF; + } - RefPtr Substitutions::SubstituteImpl(Substitutions* subst, int* ioDiff) + RefPtr GenericParamIntVal::SubstituteImpl(Substitutions* subst, int* ioDiff) + { + // search for a substitution that might apply to us + for (auto s = subst; s; s = s->outer.Ptr()) { - if (!this) return nullptr; + // the generic decl associated with the substitution list must be + // the generic decl that declared this parameter + auto genericDecl = s->genericDecl; + if (genericDecl != declRef.GetDecl()->ParentDecl) + continue; - int diff = 0; - auto outerSubst = outer->SubstituteImpl(subst, &diff); - - List> substArgs; - for (auto a : args) + int index = 0; + for (auto m : genericDecl->Members) { - substArgs.Add(a->SubstituteImpl(subst, &diff)); + if (m.Ptr() == declRef.GetDecl()) + { + // We've found it, so return the corresponding specialization argument + (*ioDiff)++; + return s->args[index]; + } + else if(auto typeParam = m.As()) + { + index++; + } + else if(auto valParam = m.As()) + { + index++; + } + else + { + } } + } - if (!diff) return this; + // Nothing found: don't substittue. + return this; + } - (*ioDiff)++; - auto substSubst = new Substitutions(); - substSubst->genericDecl = genericDecl; - substSubst->args = substArgs; - return substSubst; - } + // ExtensionDecl - bool Substitutions::Equals(Substitutions* subst) - { - // both must be NULL, or non-NULL - if (!this || !subst) - return !this && !subst; + RefPtr ExtensionDecl::Accept(SyntaxVisitor * visitor) + { + visitor->VisitExtensionDecl(this); + return this; + } - if (genericDecl != subst->genericDecl) - return false; + // ConstructorDecl - int argCount = args.Count(); - assert(args.Count() == subst->args.Count()); - for (int aa = 0; aa < argCount; ++aa) - { - if (!args[aa]->EqualsVal(subst->args[aa].Ptr())) - return false; - } + RefPtr ConstructorDecl::Accept(SyntaxVisitor * visitor) + { + visitor->VisitConstructorDecl(this); + return this; + } - if (!outer->Equals(subst->outer.Ptr())) - return false; + // SubscriptDecl - return true; - } + RefPtr SubscriptDecl::Accept(SyntaxVisitor * visitor) + { + visitor->visitSubscriptDecl(this); + return this; + } + // AccessorDecl - // DeclRef + RefPtr AccessorDecl::Accept(SyntaxVisitor * visitor) + { + visitor->visitAccessorDecl(this); + return this; + } - RefPtr DeclRef::Substitute(RefPtr type) const - { - // No substitutions? Easy. - if (!substitutions) - return type; + // Substitutions - // Otherwise we need to recurse on the type structure - // and apply substitutions where it makes sense + RefPtr Substitutions::SubstituteImpl(Substitutions* subst, int* ioDiff) + { + if (!this) return nullptr; - return type->Substitute(substitutions.Ptr()).As(); - } + int diff = 0; + auto outerSubst = outer->SubstituteImpl(subst, &diff); - DeclRef DeclRef::Substitute(DeclRef declRef) const + List> substArgs; + for (auto a : args) { - if(!substitutions) - return declRef; - - int diff = 0; - return declRef.SubstituteImpl(substitutions.Ptr(), &diff); + substArgs.Add(a->SubstituteImpl(subst, &diff)); } - RefPtr DeclRef::Substitute(RefPtr expr) const - { - // No substitutions? Easy. - if (!substitutions) - return expr; + if (!diff) return this; - assert(!"unimplemented"); + (*ioDiff)++; + auto substSubst = new Substitutions(); + substSubst->genericDecl = genericDecl; + substSubst->args = substArgs; + return substSubst; + } - return expr; - } + bool Substitutions::Equals(Substitutions* subst) + { + // both must be NULL, or non-NULL + if (!this || !subst) + return !this && !subst; + if (genericDecl != subst->genericDecl) + return false; - DeclRef DeclRef::SubstituteImpl(Substitutions* subst, int* ioDiff) + int argCount = args.Count(); + assert(args.Count() == subst->args.Count()); + for (int aa = 0; aa < argCount; ++aa) { - if (!substitutions) return *this; + if (!args[aa]->EqualsVal(subst->args[aa].Ptr())) + return false; + } - int diff = 0; - RefPtr substSubst = substitutions->SubstituteImpl(subst, &diff); + if (!outer->Equals(subst->outer.Ptr())) + return false; - if (!diff) - return *this; + return true; + } - *ioDiff += diff; - DeclRef substDeclRef; - substDeclRef.decl = decl; - substDeclRef.substitutions = substSubst; - return substDeclRef; - } + // DeclRef + RefPtr DeclRef::Substitute(RefPtr type) const + { + // No substitutions? Easy. + if (!substitutions) + return type; - // Check if this is an equivalent declaration reference to another - bool DeclRef::Equals(DeclRef const& declRef) const - { - if (decl != declRef.decl) - return false; + // Otherwise we need to recurse on the type structure + // and apply substitutions where it makes sense - if (!substitutions->Equals(declRef.substitutions.Ptr())) - return false; + return type->Substitute(substitutions.Ptr()).As(); + } - return true; - } + DeclRef DeclRef::Substitute(DeclRef declRef) const + { + if(!substitutions) + return declRef; - // Convenience accessors for common properties of declarations - String const& DeclRef::GetName() const - { - return decl->Name.Content; - } + int diff = 0; + return declRef.SubstituteImpl(substitutions.Ptr(), &diff); + } - DeclRef DeclRef::GetParent() const - { - auto parentDecl = decl->ParentDecl; - if (auto parentGeneric = dynamic_cast(parentDecl)) - { - // We need to strip away one layer of specialization - assert(substitutions); - return DeclRef(parentGeneric, substitutions->outer); - } - else - { - // If the parent isn't a generic, then it must - // use the same specializations as this declaration - return DeclRef(parentDecl, substitutions); - } + RefPtr DeclRef::Substitute(RefPtr expr) const + { + // No substitutions? Easy. + if (!substitutions) + return expr; - } + assert(!"unimplemented"); - int DeclRef::GetHashCode() const - { - auto rs = PointerHash<1>::GetHashCode(decl); - if (substitutions) - { - rs *= 16777619; - rs ^= substitutions->GetHashCode(); - } - return rs; - } + return expr; + } - // Val - RefPtr Val::Substitute(Substitutions* subst) - { - if (!this) return nullptr; - if (!subst) return this; - int diff = 0; - return SubstituteImpl(subst, &diff); - } + DeclRef DeclRef::SubstituteImpl(Substitutions* subst, int* ioDiff) + { + if (!substitutions) return *this; - RefPtr Val::SubstituteImpl(Substitutions* /*subst*/, int* /*ioDiff*/) - { - // Default behavior is to not substitute at all - return this; - } + int diff = 0; + RefPtr substSubst = substitutions->SubstituteImpl(subst, &diff); - // IntVal + if (!diff) + return *this; - int GetIntVal(RefPtr val) - { - if (auto constantVal = val.As()) - { - return constantVal->value; - } - assert(!"unexpected"); - return 0; - } + *ioDiff += diff; + + DeclRef substDeclRef; + substDeclRef.decl = decl; + substDeclRef.substitutions = substSubst; + return substDeclRef; + } - // ConstantIntVal - bool ConstantIntVal::EqualsVal(Val* val) - { - if (auto intVal = dynamic_cast(val)) - return value == intVal->value; + // Check if this is an equivalent declaration reference to another + bool DeclRef::Equals(DeclRef const& declRef) const + { + if (decl != declRef.decl) return false; - } - String ConstantIntVal::ToString() - { - return String(value); - } + if (!substitutions->Equals(declRef.substitutions.Ptr())) + return false; - int ConstantIntVal::GetHashCode() - { - return value; - } + return true; + } - // SwitchStmt + // Convenience accessors for common properties of declarations + String const& DeclRef::GetName() const + { + return decl->Name.Content; + } - RefPtr SwitchStmt::Accept(SyntaxVisitor * visitor) + DeclRef DeclRef::GetParent() const + { + auto parentDecl = decl->ParentDecl; + if (auto parentGeneric = dynamic_cast(parentDecl)) { - return visitor->VisitSwitchStmt(this); + // We need to strip away one layer of specialization + assert(substitutions); + return DeclRef(parentGeneric, substitutions->outer); } - - RefPtr CaseStmt::Accept(SyntaxVisitor * visitor) + else { - return visitor->VisitCaseStmt(this); + // If the parent isn't a generic, then it must + // use the same specializations as this declaration + return DeclRef(parentDecl, substitutions); } - RefPtr DefaultStmt::Accept(SyntaxVisitor * visitor) + } + + int DeclRef::GetHashCode() const + { + auto rs = PointerHash<1>::GetHashCode(decl); + if (substitutions) { - return visitor->VisitDefaultStmt(this); + rs *= 16777619; + rs ^= substitutions->GetHashCode(); } + return rs; + } - // InterfaceDecl + // Val - RefPtr InterfaceDecl::Accept(SyntaxVisitor * visitor) - { - visitor->visitInterfaceDecl(this); - return this; - } + RefPtr Val::Substitute(Substitutions* subst) + { + if (!this) return nullptr; + if (!subst) return this; + int diff = 0; + return SubstituteImpl(subst, &diff); + } + + RefPtr Val::SubstituteImpl(Substitutions* /*subst*/, int* /*ioDiff*/) + { + // Default behavior is to not substitute at all + return this; + } - // InheritanceDecl + // IntVal - RefPtr InheritanceDecl::Accept(SyntaxVisitor * visitor) + int GetIntVal(RefPtr val) + { + if (auto constantVal = val.As()) { - visitor->visitInheritanceDecl(this); - return this; + return constantVal->value; } + assert(!"unexpected"); + return 0; + } - // SharedTypeExpr + // ConstantIntVal - RefPtr SharedTypeExpr::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitSharedTypeExpr(this); - } + bool ConstantIntVal::EqualsVal(Val* val) + { + if (auto intVal = dynamic_cast(val)) + return value == intVal->value; + return false; + } + + String ConstantIntVal::ToString() + { + return String(value); + } + + int ConstantIntVal::GetHashCode() + { + return value; + } + + // SwitchStmt + + RefPtr SwitchStmt::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitSwitchStmt(this); + } + + RefPtr CaseStmt::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitCaseStmt(this); + } + + RefPtr DefaultStmt::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitDefaultStmt(this); + } + + // InterfaceDecl - // OperatorExpressionSyntaxNode + RefPtr InterfaceDecl::Accept(SyntaxVisitor * visitor) + { + visitor->visitInterfaceDecl(this); + return this; + } + + // InheritanceDecl + + RefPtr InheritanceDecl::Accept(SyntaxVisitor * visitor) + { + visitor->visitInheritanceDecl(this); + return this; + } + + // SharedTypeExpr + + RefPtr SharedTypeExpr::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitSharedTypeExpr(this); + } + + // OperatorExpressionSyntaxNode #if 0 - void OperatorExpressionSyntaxNode::SetOperator(RefPtr scope, Slang::Compiler::Operator op) - { - this->Operator = op; - auto opExpr = new VarExpressionSyntaxNode(); - opExpr->Variable = GetOperatorFunctionName(Operator); - opExpr->scope = scope; - opExpr->Position = this->Position; - this->FunctionExpr = opExpr; - } + void OperatorExpressionSyntaxNode::SetOperator(RefPtr scope, Slang::Operator op) + { + this->Operator = op; + auto opExpr = new VarExpressionSyntaxNode(); + opExpr->Variable = GetOperatorFunctionName(Operator); + opExpr->scope = scope; + opExpr->Position = this->Position; + this->FunctionExpr = opExpr; + } #endif - RefPtr OperatorExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) - { - return visitor->VisitOperatorExpression(this); - } + RefPtr OperatorExpressionSyntaxNode::Accept(SyntaxVisitor * visitor) + { + return visitor->VisitOperatorExpression(this); + } - // DeclGroup + // DeclGroup - RefPtr DeclGroup::Accept(SyntaxVisitor * visitor) - { - visitor->VisitDeclGroup(this); - return this; - } + RefPtr DeclGroup::Accept(SyntaxVisitor * visitor) + { + visitor->VisitDeclGroup(this); + return this; + } - // + // - void RegisterBuiltinDecl( - RefPtr decl, - RefPtr modifier) - { - auto type = DeclRefType::Create(DeclRef(decl.Ptr(), nullptr)); - ExpressionType::sBuiltinTypes[(int)modifier->tag] = type; - } + void RegisterBuiltinDecl( + RefPtr decl, + RefPtr modifier) + { + auto type = DeclRefType::Create(DeclRef(decl.Ptr(), nullptr)); + ExpressionType::sBuiltinTypes[(int)modifier->tag] = type; + } - void RegisterMagicDecl( - RefPtr decl, - RefPtr modifier) - { - ExpressionType::sMagicDecls[modifier->name] = decl.Ptr(); - } + void RegisterMagicDecl( + RefPtr decl, + RefPtr modifier) + { + ExpressionType::sMagicDecls[modifier->name] = decl.Ptr(); + } - RefPtr findMagicDecl( - String const& name) - { - return ExpressionType::sMagicDecls[name].GetValue(); - } + RefPtr findMagicDecl( + String const& name) + { + return ExpressionType::sMagicDecls[name].GetValue(); + } - ExpressionType* ExpressionType::GetBool() - { - return sBuiltinTypes[(int)BaseType::Bool].GetValue().Ptr(); - } + ExpressionType* ExpressionType::GetBool() + { + return sBuiltinTypes[(int)BaseType::Bool].GetValue().Ptr(); + } - ExpressionType* ExpressionType::GetFloat() - { - return sBuiltinTypes[(int)BaseType::Float].GetValue().Ptr(); - } + ExpressionType* ExpressionType::GetFloat() + { + return sBuiltinTypes[(int)BaseType::Float].GetValue().Ptr(); + } - ExpressionType* ExpressionType::GetInt() - { - return sBuiltinTypes[(int)BaseType::Int].GetValue().Ptr(); - } + ExpressionType* ExpressionType::GetInt() + { + return sBuiltinTypes[(int)BaseType::Int].GetValue().Ptr(); + } - ExpressionType* ExpressionType::GetUInt() - { - return sBuiltinTypes[(int)BaseType::UInt].GetValue().Ptr(); - } + ExpressionType* ExpressionType::GetUInt() + { + return sBuiltinTypes[(int)BaseType::UInt].GetValue().Ptr(); + } - ExpressionType* ExpressionType::GetVoid() - { - return sBuiltinTypes[(int)BaseType::Void].GetValue().Ptr(); - } + ExpressionType* ExpressionType::GetVoid() + { + return sBuiltinTypes[(int)BaseType::Void].GetValue().Ptr(); + } - ExpressionType* ExpressionType::getInitializerListType() - { - return initializerListType.Ptr(); - } + ExpressionType* ExpressionType::getInitializerListType() + { + return initializerListType.Ptr(); + } - ExpressionType* ExpressionType::GetError() - { - return ExpressionType::Error.Ptr(); - } + ExpressionType* ExpressionType::GetError() + { + return ExpressionType::Error.Ptr(); + } - // + // - RefPtr UnparsedStmt::Accept(SyntaxVisitor * visitor) - { - return this; - } + RefPtr UnparsedStmt::Accept(SyntaxVisitor * visitor) + { + return this; + } - // + // - RefPtr InitializerListExpr::Accept(SyntaxVisitor * visitor) - { - return visitor->visitInitializerListExpr(this); - } + RefPtr InitializerListExpr::Accept(SyntaxVisitor * visitor) + { + return visitor->visitInitializerListExpr(this); + } - // + // - RefPtr ModifierDecl::Accept(SyntaxVisitor * visitor) - { - return this; - } + RefPtr ModifierDecl::Accept(SyntaxVisitor * visitor) + { + return this; + } - // + // - RefPtr EmptyDecl::Accept(SyntaxVisitor * visitor) - { - return this; - } + RefPtr EmptyDecl::Accept(SyntaxVisitor * visitor) + { + return this; + } - // + // - SyntaxNodeBase* createInstanceOfSyntaxClassByName( - String const& name) - { - if(0) {} - #define CASE(NAME) \ - else if(name == #NAME) return new NAME() + SyntaxNodeBase* createInstanceOfSyntaxClassByName( + String const& name) + { + if(0) {} + #define CASE(NAME) \ + else if(name == #NAME) return new NAME() - CASE(GLSLBufferModifier); - CASE(GLSLWriteOnlyModifier); - CASE(GLSLReadOnlyModifier); - CASE(GLSLPatchModifier); - CASE(SimpleModifier); + CASE(GLSLBufferModifier); + CASE(GLSLWriteOnlyModifier); + CASE(GLSLReadOnlyModifier); + CASE(GLSLPatchModifier); + CASE(SimpleModifier); - #undef CASE - else - { - assert(!"unexpected"); - return nullptr; - } + #undef CASE + else + { + assert(!"unexpected"); + return nullptr; } + } - IntrinsicOp findIntrinsicOp(char const* name) - { - // TODO: need to make this faster by using a dictionary... + IntrinsicOp findIntrinsicOp(char const* name) + { + // TODO: need to make this faster by using a dictionary... - if (0) {} + if (0) {} #define INTRINSIC(NAME) else if(strcmp(name, #NAME) == 0) return IntrinsicOp::NAME; #include "intrinsic-defs.h" - return IntrinsicOp::Unknown; - } - + return IntrinsicOp::Unknown; } + } \ No newline at end of file -- cgit v1.2.3