Refactor ASTNodes who have both a Symbol and name into common base class ASTnamed_symbol.

Author: marsupial

src/liboslcomp/ast.cpp

@@ -251,6 +251,109 @@ ASTNode::type_c_str (const TypeSpec &type) const
 
 
 
+ASTnamed_symbol::ASTnamed_symbol (NodeType node_type, OSLCompilerImpl *comp,
+                                  ustring name)
+    : ASTNode (node_type, comp, Nothing), m_name(name), m_sym(nullptr)
+{
+}
+
+
+
+ASTnamed_symbol::ASTnamed_symbol (NodeType node_type, OSLCompilerImpl *comp,
+                                  ustring name, ASTNode *a)
+    : ASTNode (node_type, comp, Nothing, a), m_name(name), m_sym(nullptr)
+{
+}
+
+
+
+ASTnamed_symbol::ASTnamed_symbol (NodeType node_type, OSLCompilerImpl *comp,
+                                  ustring name, ASTNode *a, ASTNode *b)
+    : ASTNode (node_type, comp, Nothing, a, b), m_name(name), m_sym(nullptr)
+{
+}
+
+
+
+ASTnamed_symbol::ASTnamed_symbol (NodeType node_type, OSLCompilerImpl *comp,
+                                  ustring name, ASTNode *a, ASTNode *b,
+                                  ASTNode *c)
+    : ASTNode (node_type, comp, Nothing, a, b, c), m_name(name), m_sym(nullptr)
+{
+}
+
+
+
+void
+ASTnamed_symbol::check_reserved (ustring name, OSLCompilerImpl *comp)
+{
+    if (Strutil::starts_with(name, "___")) {
+        comp->error (comp->filename(), comp->lineno(),
+                     "'%s' : sorry, can't start with three underscores",
+                     name);
+    }
+}
+
+
+
+std::string
+ASTnamed_symbol::previous_decl (ASTNode* node)
+{
+    if (! node)
+        return "";
+
+    return Strutil::format ("\n\t\tprevious declaration was at %s:%d",
+                             OIIO::Filesystem::filename(node->sourcefile().string()),
+                             node->sourceline());
+}
+
+
+
+Symbol*
+ASTnamed_symbol::validate (ustring name, OSLCompilerImpl *comp,
+                           Validation vflags, int allowed)
+{
+    check_reserved (name, comp);
+
+    Symbol *f;
+	bool shadow = vflags & warn_shadow;
+    if (! (vflags & check_clashes)) {
+        f = comp->symtab().find (name);
+        if (! f) {
+            comp->error (comp->filename(), comp->lineno(),
+                         "'%s' was not declared in this scope", name);
+            // FIXME -- would be fun to troll through the symtab and try to
+            // find the things that almost matched and offer suggestions.
+        }
+        else if (shadow && f->symtype() == SymTypeFunction) {
+            comp->error (comp->filename(), comp->lineno(),
+                         "function '%s' can't be used as a variable", name);
+        }
+    } else {
+        f = comp->symtab().clash (name);
+        // If no symbol, or symbol matches allowed type: no clash.
+        if (! f || f->symtype() == allowed)
+            return f;
+
+        std::string e = Strutil::format ("'%s' already declared in this scope",
+                                         name);
+        e += previous_decl (f->node());
+
+        if (shadow) {
+            // special case: only a warning for param to mask global function
+            shadow = f->scope() == 0 && f->symtype() == SymTypeFunction;
+        }
+
+        if (shadow)
+            comp->warning(comp->filename(), comp->lineno(), "%s", e);
+        else
+            comp->error(comp->filename(), comp->lineno(), "%s", e);
+    }
+    return f;
+}
+
+
+
 ASTshader_declaration::ASTshader_declaration (OSLCompilerImpl *comp,
                                 int stype, ustring name, ASTNode *form,
                                 ASTNode *stmts, ASTNode *meta)
@@ -305,22 +408,11 @@ ASTshader_declaration::shadertypename () const
 ASTfunction_declaration::ASTfunction_declaration (OSLCompilerImpl *comp,
                              TypeSpec type, ustring name,
                              ASTNode *form, ASTNode *stmts, ASTNode *meta)
-    : ASTNode (function_declaration_node, comp, 0, meta, form, stmts),
-      m_name(name), m_sym(NULL), m_is_builtin(false)
+    : ASTnamed_symbol (function_declaration_node, comp, name, meta, form, stmts),
+      m_is_builtin(false)
 {
     m_typespec = type;
-    Symbol *f = comp->symtab().clash (name);
-    if (f && f->symtype() != SymTypeFunction) {
-        error ("\"%s\" already declared in this scope as a ", name.c_str(),
-               f->typespec().string().c_str());
-        // FIXME -- print the file and line of the other definition
-        f = NULL;
-    }
-
-    if (name[0] == '_' && name[1] == '_' && name[2] == '_') {
-        error ("\"%s\" : sorry, can't start with three underscores",
-               name.c_str());
-    }
+    Symbol* sym = validate (check_clashes, SymTypeFunction);
 
     std::string argcodes = oslcompiler->code_from_type (m_typespec);
     for (ASTNode *arg = form;  arg;  arg = arg->nextptr()) {
@@ -337,8 +429,8 @@ ASTfunction_declaration::ASTfunction_declaration (OSLCompilerImpl *comp,
                       v->name().c_str());
     }
 
-    if (stmts && f && f->symtype() == SymTypeFunction) {
-        for (FunctionSymbol* poly = static_cast<FunctionSymbol*>(f); poly;
+    if (stmts && sym && sym->symtype() == SymTypeFunction) {
+        for (FunctionSymbol* poly = static_cast<FunctionSymbol*>(sym); poly;
              poly = poly->nextpoly ()) {
             // If the argcodes match, only one should have statements.
             // If there is no ASTNode for the poly, must be a builtin, and has
@@ -351,11 +443,7 @@ ASTfunction_declaration::ASTfunction_declaration (OSLCompilerImpl *comp,
                        type_c_str(type), m_name,
                        argcodes.size() <= 1 ? "" :
                          m_compiler->typelist_from_code(argcodes.c_str()+1),
-                       other ? Strutil::format (
-                             "\n\t\tprevious declaration was at %s:%d",
-                             OIIO::Filesystem::filename(other->sourcefile().string()),
-                             other->sourceline())
-                             : std::string());
+                       previous_decl (other));
                 // Set m_sym to the function that is being overwritten.
                 m_sym = poly;
                 return;
@@ -364,7 +452,8 @@ ASTfunction_declaration::ASTfunction_declaration (OSLCompilerImpl *comp,
     }
 
     m_sym = new FunctionSymbol (name, type, this);
-    func()->nextpoly ((FunctionSymbol *)f);
+    if (sym && sym->symtype() == SymTypeFunction)
+        func()->nextpoly ((FunctionSymbol *)sym);
 
     func()->argcodes (ustring (argcodes));
     oslcompiler->symtab().insert (m_sym);
@@ -438,31 +527,16 @@ ASTvariable_declaration::ASTvariable_declaration (OSLCompilerImpl *comp,
                                                   ustring name, ASTNode *init,
                                                   bool isparam, bool ismeta,
                                                   bool isoutput, bool initlist)
-    : ASTNode (variable_declaration_node, comp, 0, init, NULL /* meta */),
-      m_name(name), m_sym(NULL),
+    : ASTnamed_symbol (variable_declaration_node, comp, name, init, NULL /* meta */),
       m_isparam(isparam), m_isoutput(isoutput), m_ismetadata(ismeta),
       m_initlist(initlist)
 {
     m_typespec = type;
-    Symbol *f = comp->symtab().clash (name);
-    if (f  &&  ! m_ismetadata) {
-        std::string e = Strutil::format ("\"%s\" already declared in this scope", name.c_str());
-        if (f->node()) {
-            std::string filename = OIIO::Filesystem::filename(f->node()->sourcefile().string());
-            e += Strutil::format ("\n\t\tprevious declaration was at %s:%d",
-                                  filename, f->node()->sourceline());
-        }
-        if (f->scope() == 0 && f->symtype() == SymTypeFunction && isparam) {
-            // special case: only a warning for param to mask global function
-            warning ("%s", e.c_str());
-        } else {
-            error ("%s", e.c_str());
-        }
-    }
-    if (name[0] == '_' && name[1] == '_' && name[2] == '_') {
-        error ("\"%s\" : sorry, can't start with three underscores",
-               name.c_str());
-    }
+    if (! m_ismetadata)
+        validate (warn_function_clash);
+    else
+        check_reserved ();
+
     SymType symtype = isparam ? (isoutput ? SymTypeOutputParam : SymTypeParam)
                               : SymTypeLocal;
     // Sneaky debugging aid: a local that starts with "__debug_tmp__"
@@ -523,20 +597,11 @@ ASTvariable_declaration::print (std::ostream &out, int indentlevel) const
 
 
 ASTvariable_ref::ASTvariable_ref (OSLCompilerImpl *comp, ustring name)
-    : ASTNode (variable_ref_node, comp), m_name(name), m_sym(NULL)
+    : ASTnamed_symbol (variable_ref_node, comp, name)
 {
-    m_sym = comp->symtab().find (name);
-    if (! m_sym) {
-        error ("'%s' was not declared in this scope", name.c_str());
-        // FIXME -- would be fun to troll through the symtab and try to
-        // find the things that almost matched and offer suggestions.
-        return;
-    }
-    if (m_sym->symtype() == SymTypeFunction) {
-        error ("function '%s' can't be used as a variable", name.c_str());
-        return;
-    }
-    m_typespec = m_sym->typespec();
+    m_sym = validate (warn_function_exists);
+    if (m_sym)
+        m_typespec = m_sym->typespec();
 }
 
 
@@ -1049,25 +1114,18 @@ ASTtype_constructor::childname (size_t i) const
 
 ASTfunction_call::ASTfunction_call (OSLCompilerImpl *comp, ustring name,
                                     ASTNode *args, FunctionSymbol *funcsym)
-    : ASTNode (function_call_node, comp, 0, args), m_name(name),
-      m_sym(funcsym ? funcsym : comp->symtab().find (name)), // Look it up.
+    : ASTnamed_symbol (function_call_node, comp, name, args),
       m_poly(funcsym),    // Default - resolved symbol or null
       m_argread(~1),      // Default - all args are read except the first
       m_argwrite(1),      // Default - first arg only is written by the op
       m_argtakesderivs(0) // Default - doesn't take derivs
 {
-    if (! m_sym) {
-        error ("function '%s' was not declared in this scope", name);
-        // FIXME -- would be fun to troll through the symtab and try to
-        // find the things that almost matched and offer suggestions.
+    m_sym = funcsym ? funcsym : validate (err_must_exist); // Look it up.
+    if (! m_sym || is_struct_ctr())
         return;
-    }
-    if (is_struct_ctr()) {
-        return;  // It's a struct constructor
-    }
     if (m_sym->symtype() != SymTypeFunction) {
         error ("'%s' is not a function", name.c_str());
-        m_sym = NULL;
+        m_sym = nullptr;
         return;
     }
 }