C++ ASTNode::nodetype方法代码示例

void
ASTfunction_declaration::add_meta (ASTNode *meta)
{
    for (  ;  meta;  meta = meta->nextptr()) {
        ASSERT (meta->nodetype() == ASTNode::variable_declaration_node);
        const ASTvariable_declaration *metavar = static_cast<const ASTvariable_declaration *>(meta);
        Symbol *metasym = metavar->sym();
        if (metasym->name() == "builtin") {
            m_is_builtin = true;
            if (func()->typespec().is_closure())  { // It is a builtin closure
                // Force keyword arguments at the end
                func()->argcodes(ustring(std::string(func()->argcodes().c_str()) + "."));
            }
            // For built-in functions, if any of the params are output,
            // also automatically mark it as readwrite_special_case.
            for (ASTNode *f = formals().get(); f; f = f->nextptr()) {
                ASSERT (f->nodetype() == variable_declaration_node);
                ASTvariable_declaration *v = (ASTvariable_declaration *)f;
                if (v->is_output())
                    func()->readwrite_special_case (true);
            }
        }
        else if (metasym->name() == "derivs")
            func()->takes_derivs (true);
        else if (metasym->name() == "printf_args")
            func()->printf_args (true);
        else if (metasym->name() == "texture_args")
            func()->texture_args (true);
        else if (metasym->name() == "rw")
            func()->readwrite_special_case (true);
    }
}

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)
{
    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;
    }

    // FIXME -- allow multiple function declarations, but only if they
    // aren't the same polymorphic type.

    if (name[0] == '_' && name[1] == '_' && name[2] == '_') {
        error ("\"%s\" : sorry, can't start with three underscores",
               name.c_str());
    }

    m_sym = new FunctionSymbol (name, type, this);
    func()->nextpoly ((FunctionSymbol *)f);
    std::string argcodes = oslcompiler->code_from_type (m_typespec);
    for (ASTNode *arg = form;  arg;  arg = arg->nextptr()) {
        const TypeSpec &t (arg->typespec());
        if (t == TypeSpec() /* UNKNOWN */) {
            m_typespec = TypeDesc::UNKNOWN;
            return;
        }
        argcodes += oslcompiler->code_from_type (t);
        ASSERT (arg->nodetype() == variable_declaration_node);
        ASTvariable_declaration *v = (ASTvariable_declaration *)arg;
        if (v->init())
            v->error ("function parameter '%s' may not have a default initializer.",
                      v->name().c_str());
    }
    func()->argcodes (ustring (argcodes));
    oslcompiler->symtab().insert (m_sym);

    // Typecheck it right now, upon declaration
    typecheck (typespec ());
}

void
ASTfunction_call::typecheck_builtin_specialcase ()
{
    if (m_name == "transform") {
        // Special case for transform: under the covers, it selects
        // vector or normal special versions depending on its use.
        if (typespec().simpletype() == TypeDesc::TypeVector)
            m_name = ustring ("transformv");
        else if (typespec().simpletype() == TypeDesc::TypeNormal)
            m_name = ustring ("transformn");
    }

    // Void functions DO read their first arg, DON'T write it
    if (typespec().is_void()) {
        argread (0, true);
        argwrite (0, false);
    }

    if (func()->readwrite_special_case()) {
        if (m_name == "fresnel") {
            // This function has some output args
            argwriteonly (3);
            argwriteonly (4);
            argwriteonly (5);
            argwriteonly (6);
        } else if (m_name == "sincos") {
            argwriteonly (1);
            argwriteonly (2);
        } else if (m_name == "getattribute" || m_name == "getmessage" ||
                   m_name == "gettextureinfo" || m_name == "dict_value") {
            // these all write to their last argument
            argwriteonly ((int)listlength(args()));
        } else if (func()->texture_args()) {
            // texture-like function, look out for "alpha"

            std::vector<ASTNode::ref> argvec;
            list_to_vec (args(), argvec);

            // Find the beginning of the optional arguments -- it will be
            // the first string argument AFTER the filename.
            int nargs = (int) listlength(args());
            int firstopt = 2;
            while (firstopt < nargs &&
                   ! argvec[firstopt]->typespec().is_string())
                ++firstopt;

            // Loop through the optional args, look for "alpha"
            for (int a = firstopt;  a < (int)argvec.size()-1;  a += 2) {
                ASTNode *s = argvec[a].get();
                if (s->typespec().is_string() &&
                    s->nodetype() == ASTNode::literal_node &&
                    ! strcmp (((ASTliteral *)s)->strval(), "alpha")) {
                    // 'alpha' writes to the next arg!
                    if (a+2 < 32)
                        argwriteonly (a+2);   // mark writeable
                    else {
                        // We can only designate the first 32 args
                        // writeable.  So swap it with earlier optional args.
                        std::swap (argvec[firstopt],   argvec[a]);
                        std::swap (argvec[firstopt+1], argvec[a+1]);
                        argwriteonly (firstopt+1);
                        firstopt += 2;  // advance in case another is needed
                    }
                }
            }

            m_children[0] = vec_to_list (argvec);
        }
    }

    if (func()->takes_derivs()) {
        // Special handling for the few functions that take derivatives
        // of their arguments.  Mark those with argtakesderivs.
        // N.B. This counts arguments in the same way that opcodes do --
        // assuming "arg 0" is the return value.
        size_t nargs = listlength(args());
        if (m_name == "area") {
            argtakesderivs (1, true);
        } else if (m_name == "aastep") {
            // all but the 5-arg version take derivs of edge param
            argtakesderivs (1, nargs<5);
            // aastep(f,f) and aastep(f,f,str) take derivs of s param
            if (nargs == 2 || list_nth(args(),2)->typespec().is_string())
                argtakesderivs (2, true);
        } else if (m_name == "bump" || m_name == "displace") {
            // FIXME -- come back to this
        } else if (m_name == "calculatenormal") {
            argtakesderivs (1, true);
        } else if (m_name == "Dx" || m_name == "Dy") {
            argtakesderivs (1, true);
        } else if (m_name == "texture") {
            if (nargs == 3 || list_nth(args(),3)->typespec().is_string()) {
                argtakesderivs (2, true);
                argtakesderivs (3, true);
            }
        } else if (m_name == "texture3d") {
            if (nargs == 2 || list_nth(args(),2)->typespec().is_string()) {
                argtakesderivs (2, true);
            }
        } else if (m_name == "environment") {
//.........这里部分代码省略.........