2005-oct-19 3dlabs slang compiler, tweaked a little bit

1 files changed, 223 insertions, 0 deletions

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<TTypeLine> 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_