From 7d079fd7802763efd8c2d8856117b5df0b3a14e4 Mon Sep 17 00:00:00 2001 From: Michal Krol Date: Mon, 17 Jan 2005 16:01:49 +0000 Subject: 2005-oct-19 3dlabs slang compiler, tweaked a little bit --- src/mesa/shader/slang/Include/Types.h | 223 ++++++++++++++++++++++++++++++++++ 1 file changed, 223 insertions(+) create mode 100755 src/mesa/shader/slang/Include/Types.h (limited to 'src/mesa/shader/slang/Include/Types.h') diff --git a/src/mesa/shader/slang/Include/Types.h b/src/mesa/shader/slang/Include/Types.h new file mode 100755 index 0000000000..368b140342 --- /dev/null +++ b/src/mesa/shader/slang/Include/Types.h @@ -0,0 +1,223 @@ +// +//Copyright (C) 2002-2004 3Dlabs Inc. Ltd. +//All rights reserved. +// +//Redistribution and use in source and binary forms, with or without +//modification, are permitted provided that the following conditions +//are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following +// disclaimer in the documentation and/or other materials provided +// with the distribution. +// +// Neither the name of 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +//POSSIBILITY OF SUCH DAMAGE. +// + +#ifndef _TYPES_INCLUDED +#define _TYPES_INCLUDED + +#include "../Include/Common.h" +#include "../Include/BaseTypes.h" + +// +// Need to have association of line numbers to types in a list for building structs. +// +class TType; +struct TTypeLine { + TType* type; + int line; +}; +typedef TVector TTypeList; + +inline TTypeList* NewPoolTTypeList() +{ + void* memory = GlobalPoolAllocator.allocate(sizeof(TTypeList)); + return new(memory) TTypeList; +} + +// +// This is a workaround for a problem with the yacc stack, It can't have +// types that the compiler thinks non-trivial constructors. It should +// just be used while recognizing the grammar, not anything else. Pointers +// could be used, but also trying to avoid lots of memory management overhead. +// +// Not as bad as it looks, there is no actual assumption that the fields +// match up or are name the same or anything like that. +// +class TPublicType { +public: + TBasicType type; + TQualifier qualifier; + int size; // size of vector or matrix, not size of array + bool matrix; + bool array; + TType* userDef; + int line; +}; + +// +// Base class for things that have a type. +// +class TType { +public: + POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator) + explicit TType(TBasicType t, TQualifier q = EvqTemporary, int s = 1, bool m = false, bool a = false) : + type(t), qualifier(q), size(s), matrix(m), array(a), arraySize(0), + structure(0), structureSize(0), maxArraySize(0), arrayInformationType(0) + { } + explicit TType(TPublicType p) : + type(p.type), qualifier(p.qualifier), size(p.size), matrix(p.matrix), array(p.array), arraySize(0), + structure(0), structureSize(0), maxArraySize(0), arrayInformationType(0) + { + if (p.userDef) { + structure = p.userDef->getStruct(); + structureSize = setStructSize(p.userDef->getStruct()); + typeName = p.userDef->getTypeName(); + } + } + explicit TType(TTypeList* userDef, TString n) : + type(EbtStruct), qualifier(EvqTemporary), size(1), matrix(false), array(false), arraySize(0), + structure(userDef), typeName(n), maxArraySize(0), arrayInformationType(0) { + structureSize = setStructSize(userDef); + } + + virtual ~TType() {} + TType (const TType& type) { *this = type; } + + int setStructSize(TTypeList* userDef) + { + int stSize = 0; + for (TTypeList::iterator tl = userDef->begin(); tl != userDef->end(); tl++) { + if (((*tl).type)->isArray()) { + stSize += ((*tl).type)->getInstanceSize() * ((*tl).type)->getArraySize(); + } else if (((*tl).type)->isMatrix() || ((*tl).type)->isVector()){ + stSize += ((*tl).type)->getInstanceSize(); + } else if (((*tl).type)->getStruct()) { + //?? We should actually be calling getStructSize() function and not setStructSize. This problem occurs in case + // of nested/embedded structs. + stSize += setStructSize(((*tl).type)->getStruct()); + } else + stSize += 1; + } + structureSize = stSize; + return stSize; + } + + virtual void setType(TBasicType t, int s, bool m, bool a, int aS = 0) + { type = t; size = s; matrix = m; array = a; arraySize = aS; } + virtual void setType(TBasicType t, int s, bool m, TType* userDef = 0) + { type = t; + size = s; + matrix = m; + if (userDef) + structure = userDef->getStruct(); + // leave array information intact. + } + virtual void setTypeName(const TString& n) { typeName = n; } + virtual void setFieldName(const TString& n) { fieldName = n; } + virtual const TString& getTypeName() const { return typeName; } + virtual const TString& getFieldName() const { return fieldName; } + virtual TBasicType getBasicType() const { return type; } + virtual TQualifier getQualifier() const { return qualifier; } + virtual void changeQualifier(TQualifier q) { qualifier = q; } + + // One-dimensional size of single instance type + virtual int getNominalSize() const { return size; } + + // Full-dimensional size of single instance of type + virtual int getInstanceSize() const + { + if (matrix) + return size * size; + else + return size; + } + + virtual bool isMatrix() const { return matrix; } + virtual bool isArray() const { return array; } + int getArraySize() const { return arraySize; } + void setArraySize(int s) { array = true; arraySize = s; } + void setMaxArraySize (int s) { maxArraySize = s; } + int getMaxArraySize () const { return maxArraySize; } + void setArrayInformationType(TType* t) { arrayInformationType = t; } + TType* getArrayInformationType() { return arrayInformationType; } + virtual bool isVector() const { return size > 1 && !matrix; } + static char* getBasicString(TBasicType t) { + switch (t) { + case EbtVoid: return "void"; break; + case EbtFloat: return "float"; break; + case EbtInt: return "int"; break; + case EbtBool: return "bool"; break; + case EbtSampler1D: return "sampler1D"; break; + case EbtSampler2D: return "sampler2D"; break; + case EbtSampler3D: return "sampler3D"; break; + case EbtSamplerCube: return "samplerCube"; break; + case EbtSampler1DShadow: return "sampler1DShadow"; break; + case EbtSampler2DShadow: return "sampler2DShadow"; break; + case EbtStruct: return "structure"; break; + default: return "unknown type"; + } + } + const char* getBasicString() const { return TType::getBasicString(type); } + const char* getQualifierString() const { return ::getQualifierString(qualifier); } + TTypeList* getStruct() { return structure; } + int getStructSize() { return structureSize; } + TTypeList* getStruct() const { return structure; } + TString& getMangledName() { + if (mangled.size() == 0) { + buildMangledName(mangled); + mangled+=';'; + } + return mangled; + } + bool operator==(const TType& right) const { + return type == right.type && + size == right.size && + matrix == right.matrix && + array == right.array && + structure == right.structure; + // don't check the qualifier, it's not ever what's being sought after + } + bool operator!=(const TType& right) const { + return !operator==(right); + } + TString getCompleteString() const; + +protected: + TBasicType type; + TQualifier qualifier; + int size; // size of vector or matrix, not size of array + bool matrix; + bool array; + int arraySize; + TTypeList* structure; // 0 unless this is a struct + TString fieldName; // for structure field names + TString typeName; // for structure field type name + TString mangled; + int structureSize; + int maxArraySize; + TType* arrayInformationType; + + void buildMangledName(TString&); +}; + +#endif // _TYPES_INCLUDED_ -- cgit v1.2.3