Substantial rewrite (again) of decl handling.

The decl.* code now no longer interacts with Symbols, but just returns names, types, initializer expressions, etc., as needed. This makes the code a bit more understandable. Fixes issues #171 and #130.
2012-04-12 17:28:30 -07:00
parent d88dbf3612
commit 5ece6fec04
15 changed files with 396 additions and 423 deletions
--- a/decl.cpp
+++ b/decl.cpp
@@ -33,7 +33,7 @@

 /** @file decl.cpp
    @brief Implementations of classes related to turning declarations into 
-           symbols and types.
+           symbol names and types.
 */

 #include "decl.h"
@@ -218,50 +218,44 @@ Declarator::Declarator(DeclaratorKind dk, SourcePos p)
    : pos(p), kind(dk) { 
    child = NULL;
    typeQualifiers = 0;
+    storageClass = SC_NONE;
    arraySize = -1;
-    sym = NULL;
+    type = NULL;
    initExpr = NULL;
 }


 void
 Declarator::InitFromDeclSpecs(DeclSpecs *ds) {
-    const Type *t = GetType(ds);
-    if (t == NULL) {
+    const Type *baseType = ds->GetBaseType(pos);
+    InitFromType(baseType, ds);
+
+    if (type == NULL) {
        Assert(m->errorCount > 0);
        return;
    }

-    Symbol *sym = GetSymbol();
-    if (sym != NULL) {
-        sym->type = t;
-        sym->storageClass = ds->storageClass;
+    storageClass = ds->storageClass;
+
+    if (ds->declSpecList.size() > 0 && 
+        dynamic_cast<const FunctionType *>(type) == NULL) {
+        Error(pos, "__declspec specifiers for non-function type \"%s\" are "
+              "not used.", type->GetString().c_str());
    }
 }


-Symbol *
-Declarator::GetSymbol() const {
-    // The symbol lives at the last child in the chain, so walk down there
-    // and return the one there.
-    const Declarator *d = this;
-    while (d->child != NULL)
-        d = d->child;
-    return d->sym;
-}
-
-
 void
 Declarator::Print(int indent) const {
    printf("%*cdeclarator: [", indent, ' ');
    pos.Print();

    lPrintTypeQualifiers(typeQualifiers);
-    Symbol *sym = GetSymbol();
-    if (sym != NULL)
-        printf("%s", sym->name.c_str());
+    printf("%s ", lGetStorageClassName(storageClass));
+    if (name.size() > 0)
+        printf("%s", name.c_str());
    else
-        printf("(null symbol)");
+        printf("(unnamed)");

    printf(", array size = %d", arraySize);

@@ -295,55 +289,8 @@ Declarator::Print(int indent) const {
 }


-Symbol *
-Declarator::GetFunctionInfo(DeclSpecs *ds, std::vector<Symbol *> *funArgs) {
-    const FunctionType *type = 
-        dynamic_cast<const FunctionType *>(GetType(ds));
-    if (type == NULL)
-        return NULL;
-
-    Symbol *declSym = GetSymbol();
-    Assert(declSym != NULL);
-
-    // Get the symbol for the function from the symbol table.  (It should
-    // already have been added to the symbol table by AddGlobal() by the
-    // time we get here.)
-    Symbol *funSym = m->symbolTable->LookupFunction(declSym->name.c_str(), type);
-    if (funSym == NULL)
-        // May be NULL due to error earlier in compilation
-        Assert(m->errorCount > 0);
-    else
-        funSym->pos = pos;
-
-    // Walk down to the declarator for the function.  (We have to get past
-    // the stuff that specifies the function's return type before we get to
-    // the function's declarator.)
-    Declarator *d = this;
-    while (d != NULL && d->kind != DK_FUNCTION)
-        d = d->child;
-    Assert(d != NULL);
-
-    for (unsigned int i = 0; i < d->functionParams.size(); ++i) {
-        Symbol *sym = d->GetSymbolForFunctionParameter(i);
-        if (sym->type == NULL) {
-            Assert(m->errorCount > 0);
-            continue;
-        }
-        else
-            sym->type = sym->type->ResolveUnboundVariability(Variability::Varying);
-
-        funArgs->push_back(sym);
-    }
-
-    if (funSym != NULL)
-        funSym->type = funSym->type->ResolveUnboundVariability(Variability::Varying);
-
-    return funSym;
-}
-
-
-const Type *
-Declarator::GetType(const Type *base, DeclSpecs *ds) const {
+void
+Declarator::InitFromType(const Type *baseType, DeclSpecs *ds) {
    bool hasUniformQual = ((typeQualifiers & TYPEQUAL_UNIFORM) != 0);
    bool hasVaryingQual = ((typeQualifiers & TYPEQUAL_VARYING) != 0);
    bool isTask =         ((typeQualifiers & TYPEQUAL_TASK) != 0);
@@ -352,12 +299,16 @@ Declarator::GetType(const Type *base, DeclSpecs *ds) const {

    if (hasUniformQual && hasVaryingQual) {
        Error(pos, "Can't provide both \"uniform\" and \"varying\" qualifiers.");
-        return NULL;
+        return;
    }
-    if (kind != DK_FUNCTION && isTask)
+    if (kind != DK_FUNCTION && isTask) {
        Error(pos, "\"task\" qualifier illegal in variable declaration.");
-    if (kind != DK_FUNCTION && isExported)
+        return;
+    }
+    if (kind != DK_FUNCTION && isExported) {
        Error(pos, "\"export\" qualifier illegal in variable declaration.");
+        return;
+    }

    Variability variability(Variability::Unbound);
    if (hasUniformQual)
@@ -365,66 +316,76 @@ Declarator::GetType(const Type *base, DeclSpecs *ds) const {
    else if (hasVaryingQual)
        variability = Variability::Varying;

-    const Type *type = base;
-    switch (kind) {
-    case DK_BASE:
+    if (kind == DK_BASE) {
        // All of the type qualifiers should be in the DeclSpecs for the
        // base declarator
        Assert(typeQualifiers == 0);
        Assert(child == NULL);
-        return type;
-
-    case DK_POINTER:
+        type = baseType;
+    }
+    else if (kind == DK_POINTER) {
        /* For now, any pointer to an SOA type gets the slice property; if
           we add the capability to declare pointers as slices or not,
           we'll want to set this based on a type qualifier here. */
-        type = new PointerType(type, variability, isConst, type->IsSOAType());
-        if (child != NULL)
-            return child->GetType(type, ds);
+        const Type *ptrType = new PointerType(baseType, variability, isConst,
+                                              baseType->IsSOAType());
+        if (child != NULL) {
+            child->InitFromType(ptrType, ds);
+            type = child->type;
+            name = child->name;
+        }
        else
-            return type;
-        break;
-
-    case DK_REFERENCE:
-        if (hasUniformQual)
+            type = ptrType;
+    }
+    else if (kind == DK_REFERENCE) {
+        if (hasUniformQual) {
            Error(pos, "\"uniform\" qualifier is illegal to apply to references.");
-        if (hasVaryingQual)
+            return;
+        }
+        if (hasVaryingQual) {
            Error(pos, "\"varying\" qualifier is illegal to apply to references.");
-        if (isConst)
+            return;
+        }
+        if (isConst) {
            Error(pos, "\"const\" qualifier is to illegal apply to references.");
-
+            return;
+        }
        // The parser should disallow this already, but double check.
-        if (dynamic_cast<const ReferenceType *>(type) != NULL) {
+        if (dynamic_cast<const ReferenceType *>(baseType) != NULL) {
            Error(pos, "References to references are illegal.");
-            return NULL;
+            return;
        }

-        type = new ReferenceType(type);
-        if (child != NULL)
-            return child->GetType(type, ds);
+        const Type *refType = new ReferenceType(baseType);
+        if (child != NULL) {
+            child->InitFromType(refType, ds);
+            type = child->type;
+            name = child->name;
+        }
        else
-            return type;
-        break;
-
-    case DK_ARRAY:
-        if (Type::Equal(type, AtomicType::Void)) {
+            type = refType;
+    }
+    else if (kind == DK_ARRAY) {
+        if (Type::Equal(baseType, AtomicType::Void)) {
            Error(pos, "Arrays of \"void\" type are illegal.");
-            return NULL;
+            return;
        }
-        if (dynamic_cast<const ReferenceType *>(type)) {
+        if (dynamic_cast<const ReferenceType *>(baseType)) {
            Error(pos, "Arrays of references (type \"%s\") are illegal.",
-                  type->GetString().c_str());
-            return NULL;
+                  baseType->GetString().c_str());
+            return;
        }

-        type = new ArrayType(type, arraySize);
-        if (child)
-            return child->GetType(type, ds);
+        const Type *arrayType = new ArrayType(baseType, arraySize);
+        if (child != NULL) {
+            child->InitFromType(arrayType, ds);
+            type = child->type;
+            name = child->name;
+        }
        else
-            return type;
-        break;
-
-    case DK_FUNCTION: {
+            type = arrayType;
+    }
+    else if (kind == DK_FUNCTION) {
        std::vector<const Type *> args;
        std::vector<std::string> argNames;
        std::vector<Expr *> argDefaults;
@@ -436,20 +397,40 @@ Declarator::GetType(const Type *base, DeclSpecs *ds) const {
        for (unsigned int i = 0; i < functionParams.size(); ++i) {
            Declaration *d = functionParams[i];

-            Symbol *sym = GetSymbolForFunctionParameter(i);
-
-            if (d->declSpecs->storageClass != SC_NONE)
-                Error(sym->pos, "Storage class \"%s\" is illegal in "
-                      "function parameter declaration for parameter \"%s\".", 
-                      lGetStorageClassName(d->declSpecs->storageClass),
-                      sym->name.c_str());
-            if (Type::Equal(sym->type, AtomicType::Void)) {
-                Error(sym->pos, "Parameter with type \"void\" illegal in function "
-                      "parameter list.");
-                sym->type = NULL;
+            if (d == NULL) {
+                Assert(m->errorCount > 0);
+                continue;
+            }
+            if (d->declarators.size() == 0) {
+                // function declaration like foo(float), w/o a name for the
+                // parameter; wire up a placeholder Declarator for it
+                d->declarators.push_back(new Declarator(DK_BASE, pos));
+                d->declarators[0]->InitFromDeclSpecs(d->declSpecs);
            }

-            const ArrayType *at = dynamic_cast<const ArrayType *>(sym->type);
+            Assert(d->declarators.size() == 1);
+            Declarator *decl = d->declarators[0];
+
+            if (decl->name == "") {
+                // Give a name to any anonymous parameter declarations
+                char buf[32];
+                sprintf(buf, "__anon_parameter_%d", i);
+                decl->name = buf;
+            }
+            decl->type = decl->type->ResolveUnboundVariability(Variability::Varying);
+
+            if (d->declSpecs->storageClass != SC_NONE)
+                Error(decl->pos, "Storage class \"%s\" is illegal in "
+                      "function parameter declaration for parameter \"%s\".", 
+                      lGetStorageClassName(d->declSpecs->storageClass),
+                      decl->name.c_str());
+            if (Type::Equal(decl->type, AtomicType::Void)) {
+                Error(decl->pos, "Parameter with type \"void\" illegal in function "
+                      "parameter list.");
+                decl->type = NULL;
+            }
+
+            const ArrayType *at = dynamic_cast<const ArrayType *>(decl->type);
            if (at != NULL) {
                // As in C, arrays are passed to functions as pointers to
                // their element type.  We'll just immediately make this
@@ -459,69 +440,66 @@ Declarator::GetType(const Type *base, DeclSpecs *ds) const {
                // report this differently than it was originally declared
                // in the function, but it's not clear that this is a
                // significant problem.)
-                if (at->GetElementType() == NULL) {
+                const Type *targetType = at->GetElementType();
+                if (targetType == NULL) {
                    Assert(m->errorCount > 0);
-                    return NULL;
+                    return;
                }

-                const Type *targetType = at->GetElementType();
-                targetType = 
-                    targetType->ResolveUnboundVariability(Variability::Varying);
-                sym->type = PointerType::GetUniform(targetType);
+                decl->type = PointerType::GetUniform(targetType);

                // Make sure there are no unsized arrays (other than the
                // first dimension) in function parameter lists.
-                at = dynamic_cast<const ArrayType *>(at->GetElementType());
+                at = dynamic_cast<const ArrayType *>(targetType);
                while (at != NULL) {
                    if (at->GetElementCount() == 0)
-                        Error(sym->pos, "Arrays with unsized dimensions in "
+                        Error(decl->pos, "Arrays with unsized dimensions in "
                              "dimensions after the first one are illegal in "
                              "function parameter lists.");
                    at = dynamic_cast<const ArrayType *>(at->GetElementType());
                }
            }

-            args.push_back(sym->type);
-            argNames.push_back(sym->name);
-            argPos.push_back(sym->pos);
+            args.push_back(decl->type);
+            argNames.push_back(decl->name);
+            argPos.push_back(decl->pos);

            Expr *init = NULL;
-            if (d->declarators.size()) {
-                // Try to find an initializer expression.
-                Declarator *decl = d->declarators[0];
-                while (decl != NULL) {
+            // Try to find an initializer expression.
+            while (decl != NULL) {
+                if (decl->initExpr != NULL) {
+                    decl->initExpr = TypeCheck(decl->initExpr);
+                    decl->initExpr = Optimize(decl->initExpr);
                    if (decl->initExpr != NULL) {
-                        decl->initExpr = TypeCheck(decl->initExpr);
-                        decl->initExpr = Optimize(decl->initExpr);
-                        if (decl->initExpr != NULL) {
-                            init = dynamic_cast<ConstExpr *>(decl->initExpr);
-                            if (init == NULL)
-                                init = dynamic_cast<NullPointerExpr *>(decl->initExpr);
-                            if (init == NULL)
-                                Error(decl->initExpr->pos, "Default value for parameter "
-                                      "\"%s\" must be a compile-time constant.", 
-                                      sym->name.c_str());
-                        }
-                        break;
+                        init = dynamic_cast<ConstExpr *>(decl->initExpr);
+                        if (init == NULL)
+                            init = dynamic_cast<NullPointerExpr *>(decl->initExpr);
+                        if (init == NULL)
+                            Error(decl->initExpr->pos, "Default value for parameter "
+                                  "\"%s\" must be a compile-time constant.", 
+                                  decl->name.c_str());
                    }
-                    else
-                        decl = decl->child;
+                    break;
                }
+                else
+                    decl = decl->child;
            }
            argDefaults.push_back(init);
        }

-        const Type *returnType = type;
+        const Type *returnType = baseType;
        if (returnType == NULL) {
            Error(pos, "No return type provided in function declaration.");
-            return NULL;
+            return;
        }

        if (dynamic_cast<const FunctionType *>(returnType) != NULL) {
            Error(pos, "Illegal to return function type from function.");
-            return NULL;
+            return;
        }
        
+        returnType = returnType->ResolveUnboundVariability(Variability::Varying);
+
        bool isExternC =  ds && (ds->storageClass == SC_EXTERN_C);
        bool isExported = ds && ((ds->typeQualifiers & TYPEQUAL_EXPORT) != 0);
        bool isTask =     ds && ((ds->typeQualifiers & TYPEQUAL_TASK) != 0);
@@ -529,28 +507,27 @@ Declarator::GetType(const Type *base, DeclSpecs *ds) const {
        if (isExported && isTask) {
            Error(pos, "Function can't have both \"task\" and \"export\" "
                  "qualifiers");
-            return NULL;
+            return;
        }
        if (isExternC && isTask) {
            Error(pos, "Function can't have both \"extern \"C\"\" and \"task\" "
                  "qualifiers");
-            return NULL;
+            return;
        }
        if (isExternC && isExported) {
            Error(pos, "Function can't have both \"extern \"C\"\" and \"export\" "
                  "qualifiers");
-            return NULL;
+            return;
        }

        if (child == NULL) {
            Assert(m->errorCount > 0);
-            return NULL;
+            return;
        }

        const FunctionType *functionType = 
            new FunctionType(returnType, args, argNames, argDefaults,
                             argPos, isTask, isExported, isExternC);
-        functionType = functionType->ResolveUnboundVariability(Variability::Varying);

        // handle any explicit __declspecs on the function
        if (ds != NULL) {
@@ -572,60 +549,12 @@ Declarator::GetType(const Type *base, DeclSpecs *ds) const {
            }
        }

-        return child->GetType(functionType, ds);
-    }
-    default:
-        FATAL("Unexpected decl kind");
-        return NULL;
+        child->InitFromType(functionType, ds);
+        type = child->type;
+        name = child->name;
    }
 }

-
-const Type *
-Declarator::GetType(DeclSpecs *ds) const {
-    const Type *baseType = ds->GetBaseType(pos);
-    const Type *type = GetType(baseType, ds);
-
-    if (ds->declSpecList.size() > 0 && 
-        type != NULL &&
-        dynamic_cast<const FunctionType *>(type) == NULL) {
-        Error(pos, "__declspec specifiers for non-function type \"%s\" are "
-              "not used.", type->GetString().c_str());
-    }
-
-    return type;
-}
-
-
-Symbol *
-Declarator::GetSymbolForFunctionParameter(int paramNum) const {
-    Assert(paramNum < (int)functionParams.size());
-    Declaration *d = functionParams[paramNum];
-
-    char buf[32];
-    Symbol *sym;
-    if (d->declarators.size() == 0) {
-        // function declaration like foo(float), w/o a name for
-        // the parameter
-        sprintf(buf, "__anon_parameter_%d", paramNum);
-        sym = new Symbol(buf, pos);
-        sym->type = d->declSpecs->GetBaseType(pos);
-    }
-    else {
-        Assert(d->declarators.size() == 1);
-        sym = d->declarators[0]->GetSymbol();
-        if (sym == NULL) {
-            // Handle more complex anonymous declarations like
-            // float (float **).
-            sprintf(buf, "__anon_parameter_%d", paramNum);
-            sym = new Symbol(buf, d->declarators[0]->pos);
-            sym->type = d->declarators[0]->GetType(d->declSpecs);
-        }
-    }
-    return sym;
-}
-
-
 ///////////////////////////////////////////////////////////////////////////
 // Declaration

@@ -655,27 +584,23 @@ Declaration::GetVariableDeclarations() const {

    for (unsigned int i = 0; i < declarators.size(); ++i) {
        Declarator *decl = declarators[i];
-        if (decl == NULL) {
+        if (decl == NULL || decl->type == NULL) {
            // Ignore earlier errors
            Assert(m->errorCount > 0);
            continue;
        }

-        Symbol *sym = decl->GetSymbol();
-        if (sym == NULL || sym->type == NULL) {
-            // Ignore errors
-            Assert(m->errorCount > 0);
-            continue;
-        }
-        sym->type = sym->type->ResolveUnboundVariability(Variability::Varying);
-
-        if (Type::Equal(sym->type, AtomicType::Void))
-            Error(sym->pos, "\"void\" type variable illegal in declaration.");
-        else if (dynamic_cast<const FunctionType *>(sym->type) == NULL) {
+        if (Type::Equal(decl->type, AtomicType::Void))
+            Error(decl->pos, "\"void\" type variable illegal in declaration.");
+        else if (dynamic_cast<const FunctionType *>(decl->type) == NULL) {
+            decl->type = decl->type->ResolveUnboundVariability(Variability::Varying);
+            Symbol *sym = new Symbol(decl->name, decl->pos, decl->type,
+                                     decl->storageClass);
            m->symbolTable->AddVariable(sym);
            vars.push_back(VariableDeclaration(sym, decl->initExpr));
        }
    }
+
    return vars;
 }

@@ -686,25 +611,20 @@ Declaration::DeclareFunctions() {

    for (unsigned int i = 0; i < declarators.size(); ++i) {
        Declarator *decl = declarators[i];
-        if (decl == NULL) {
+        if (decl == NULL || decl->type == NULL) {
            // Ignore earlier errors
            Assert(m->errorCount > 0);
            continue;
        }

-        Symbol *sym = decl->GetSymbol();
-        if (sym == NULL || sym->type == NULL) {
-            // Ignore errors
-            Assert(m->errorCount > 0);
-            continue;
-        }
-        sym->type = sym->type->ResolveUnboundVariability(Variability::Varying);
-
-        if (dynamic_cast<const FunctionType *>(sym->type) == NULL)
+        const FunctionType *ftype = 
+            dynamic_cast<const FunctionType *>(decl->type);
+        if (ftype == NULL)
            continue;

        bool isInline = (declSpecs->typeQualifiers & TYPEQUAL_INLINE);
-        m->AddFunctionDeclaration(sym, isInline);
+        m->AddFunctionDeclaration(decl->name, ftype, decl->storageClass,
+                                  isInline, decl->pos);
    }
 }

@@ -718,6 +638,7 @@ Declaration::Print(int indent) const {
        declarators[i]->Print(indent+4);
 }

+
 ///////////////////////////////////////////////////////////////////////////

 void
@@ -748,21 +669,19 @@ GetStructTypesNamesPositions(const std::vector<StructDeclaration *> &sd,
            Declarator *d = (*sd[i]->declarators)[j];
            d->InitFromDeclSpecs(&ds);

-            Symbol *sym = d->GetSymbol();
-
-            if (Type::Equal(sym->type, AtomicType::Void))
+            if (Type::Equal(d->type, AtomicType::Void))
                Error(d->pos, "\"void\" type illegal for struct member.");

-            elementTypes->push_back(sym->type);
+            elementTypes->push_back(d->type);

-            if (seenNames.find(sym->name) != seenNames.end())
+            if (seenNames.find(d->name) != seenNames.end())
                Error(d->pos, "Struct member \"%s\" has same name as a "
-                      "previously-declared member.", sym->name.c_str());
+                      "previously-declared member.", d->name.c_str());
            else
-                seenNames.insert(sym->name);
+                seenNames.insert(d->name);

-            elementNames->push_back(sym->name);
-            elementPositions->push_back(sym->pos);
+            elementNames->push_back(d->name);
+            elementPositions->push_back(d->pos);
        }
    }