Ogre源代码浅析——脚本及其解析（五）

     经过以上三个阶段的处理，借由AbstractTreeBuilder类对象，Ogre终于“理解”了指定的脚本文件究竟包含了哪些脚本对象，以及这些脚本对象间的相互关系。需要强调的是，此时各脚本对象所包含的内部数据并未被加载。在Ogre中，脚本对象与脚本对象内部数据，这两个概念是严格区分的。脚本对象与这个脚本对象中的数据，对应着脚本文件中的“同一段”内容。但脚本对象是解析过程中必不可少的一个数据抽象，只有借助它，才能有一个完整的“语义分析”过程，或者说“语义分析”才有一个落脚点。而脚本对象中的数据，以材质（material）为例，是要参与到后期的渲流程中去的；material实际上是实体类（Entity）的一个属性，material数据一旦被解析出来，就完全脱离了“脚本”和脚本对象而独立存在了。因此，对于脚本所描述的材质对象，在Ogre中有两个对象类型与之对应，它们分别是ObjectAbstractNode和Material。

     从以上的讨论可以看出Ogre实际上是——根据概念来组织代码，而非根据代码来组织概念。在很多情况下，我们往往会跳过AbstractNode这一层的抽象，而直接根据之前的解析结果，在代码中创建出相应的Material对象。如果不考虑对脚本中Import、set及派生关系的解析，则这种想法是可行的。可是，与多抽象出一个AbstractNode相比，这种做法会失掉很多的灵活性，同时也会使更多的代码纠缠在一起。如果待解析的脚本对象结构发生了变化，那么按照Ogre的做法，整个解析流程大的框架无需作任何修改，只要对AbstractNode的生成和脚本对象内部数据分析的过程作相应调整即可；而取消AbstractNode类，这种调整就会变得复杂的多。Ogre这种概念抽取，相互独立的方式体现了面向对象设计的精髓，根据概念来组织代码会使代码的组织结构更清晰，代码也更容易扩展和修改。不过事物总是有两面性，大量抽象出概念并依此构建代码也容易造成功能实现时，调用堆栈过深的情况。Ogre有时调用堆栈较深，与它的这种设计思想是有关系的。

     在根据AbstractNode来创建相应的数据对象之前，还有一些工作要做：一是，有继承关系的脚本对象要将其基类对象的相关数据包含进来；二是，通过Import引入的脚本对象，在构建出相应的ImportAbstractNode对象后，还要做进一步的相应处理；三是，对于通过'$'定义的变量，要用实际的数据对象进行替换。

     派生类对象获取其基类对象中的数据，由以下函数来完成：

    void ScriptCompiler::processObjects(Ogre::AbstractNodeList *nodes, const Ogre::AbstractNodeListPtr &top)
    {
        for(AbstractNodeList::iterator i = nodes->begin(); i != nodes->end(); ++i)
        {
            if((*i)->type == ANT_OBJECT)
            {
                ObjectAbstractNode *obj = (ObjectAbstractNode*)(*i).get();

                // Overlay base classes in order.
                for (std::vector<String>::const_iterator baseIt = obj->bases.begin(), end_it = obj->bases.end(); baseIt != end_it; ++baseIt)
                {
                    const String& base = *baseIt;
                    // Check the top level first, then check the import table
                    AbstractNodeListPtr newNodes = locateTarget(top.get(), base);
                    if(newNodes->empty())
                        newNodes = locateTarget(&mImportTable, base);

                    if (!newNodes->empty()) {
                        for(AbstractNodeList::iterator j = newNodes->begin(); j != newNodes->end(); ++j) {
                            overlayObject(*j, obj);
                        }
                    } else {
                        addError(CE_OBJECTBASENOTFOUND, obj->file, obj->line,
                            "base object named \"" + base + "\" not found in script definition");
                    }
                }

                // Recurse into children
                processObjects(&obj->children, top);

                // Overrides now exist in obj's overrides list. These are non-object nodes which must now
                // Be placed in the children section of the object node such that overriding from parents
                // into children works properly.
                obj->children.insert(obj->children.begin(), obj->overrides.begin(), obj->overrides.end());
            }
        }
    }

     函数首先会逐一访问传入的AbstractNodeList链表中的各AbstractNode对象（3行），如果它存在基类对象的话，就将它们逐一取出（14-16行），然后将基类对象数据扩展到相应的派生类中（20行）。对每个AbstractNode对象的子结点链表中的每个子结点，也做同样的操作（29行）。最后将经过基类扩展后所得的ObjectAbstractNode对象的overrides（也是一个AbstractNodeList，注意不要与下面讨论的overlayObject()函数第16行定义的override混淆，ObjectAbstractNode::overrides中保存的AbstractNode派生类对象是非ObjectAbstractNode类型的），插入到原对象的子结点链表中（34行），而此时的子结点链表中的各结点都已经扩展完毕。（说明：processObjects()函数，是在processImports()函数之后被调用，此时import的相关数据已经被处理完毕，通过import导入的AbstractNode会被保存在ScriptCompiler的mImportTable中。）

     再来看一下具体的扩展过程，由于AbstractNodeList表示的是相应脚本文件中各脚本对象的树形结构，所以将基类对象数据扩展到派生类对象中的过程，实际上就是把基类对象的子结点链表插入到派生类对象子结点链表中的过程。问题在于，对于基类与派生类中的同名且同类型的子结点（如果存在的话）应该怎么处理？仍以material为例，假设material B从material A派生，而两者都有一个名为 nt的technique子结点，在这种情况下进行扩展就不能简单地将基类的子结点链表插入到派生类的子结点链表中去了。进行扩展操作的overlayObject()函数展开如下：

    void ScriptCompiler::overlayObject(const AbstractNodePtr &source, ObjectAbstractNode *dest)
    {
        if(source->type == ANT_OBJECT)
        {
            ObjectAbstractNode *src = reinterpret_cast<ObjectAbstractNode*>(source.get());

            // Overlay the environment of one on top the other first
            for(map<String,String>::type::const_iterator i = src->getVariables().begin(); i != src->getVariables().end(); ++i)
            {
                std::pair<bool,String> var = dest->getVariable(i->first);
                if(!var.first)
                    dest->setVariable(i->first, i->second);
            }
            
            // Create a vector storing each pairing of override between source and destination
            vector<std::pair<AbstractNodePtr,AbstractNodeList::iterator> >::type overrides; 
            // A list of indices for each destination node tracks the minimum
            // source node they can index-match against
            map<ObjectAbstractNode*,size_t>::type indices;
            // A map storing which nodes have overridden from the destination node
            map<ObjectAbstractNode*,bool>::type overridden;

            // Fill the vector with objects from the source node (base)
            // And insert non-objects into the overrides list of the destination
            AbstractNodeList::iterator insertPos = dest->children.begin();
            for(AbstractNodeList::const_iterator i = src->children.begin(); i != src->children.end(); ++i)
            {
                if((*i)->type == ANT_OBJECT)
                {
                    overrides.push_back(std::make_pair(*i, dest->children.end()));
                }
                else
                {
                    AbstractNodePtr newNode((*i)->clone());
                    newNode->parent = dest;
                    dest->overrides.push_back(newNode);
                }
            }

            // Track the running maximum override index in the name-matching phase
            size_t maxOverrideIndex = 0;

            // Loop through destination children searching for name-matching overrides
            for(AbstractNodeList::iterator i = dest->children.begin(); i != dest->children.end(); )
            {
                if((*i)->type == ANT_OBJECT)
                {
                    // Start tracking the override index position for this object
                    size_t overrideIndex = 0;

                    ObjectAbstractNode *node = reinterpret_cast<ObjectAbstractNode*>((*i).get());
                    indices[node] = maxOverrideIndex;
                    overridden[node] = false;

                    // special treatment for materials with * in their name
                    bool nodeHasWildcard=node->name.find('*') != String::npos;

                    // Find the matching name node
                    for(size_t j = 0; j < overrides.size(); ++j)
                    {
                        ObjectAbstractNode *temp = reinterpret_cast<ObjectAbstractNode*>(overrides[j].first.get());
                        // Consider a match a node that has a wildcard and matches an input name
                        bool wildcardMatch = nodeHasWildcard && 
                            (StringUtil::match(temp->name,node->name,true) || 
                                (node->name.size() == 1 && temp->name.empty()));
                        if(temp->cls == node->cls && !node->name.empty() && (temp->name == node->name || wildcardMatch))
                        {
                            // Pair these two together unless it's already paired
                            if(overrides[j].second == dest->children.end())
                            {
                                AbstractNodeList::iterator currentIterator = i;
                                ObjectAbstractNode *currentNode = node;
                                if (wildcardMatch)
                                {
                                    //If wildcard is matched, make a copy of current material and put it before the iterator, matching its name to the parent. Use same reinterpret cast as above when node is set
                                    AbstractNodePtr newNode((*i)->clone());
                                    currentIterator = dest->children.insert(currentIterator, newNode);
                                    currentNode = reinterpret_cast<ObjectAbstractNode*>((*currentIterator).get());
                                    currentNode->name = temp->name;//make the regex match its matcher
                                }
                                overrides[j] = std::make_pair(overrides[j].first, currentIterator);
                                // Store the max override index for this matched pair
                                overrideIndex = j;
                                overrideIndex = maxOverrideIndex = std::max(overrideIndex, maxOverrideIndex);
                                indices[currentNode] = overrideIndex;
                                overridden[currentNode] = true;
                            }
                            else
                            {
                                addError(CE_DUPLICATEOVERRIDE, node->file, node->line);
                            }

                            if(!wildcardMatch)
                                break;
                        }
                    }

                    if (nodeHasWildcard)
                    {
                        //if the node has a wildcard it will be deleted since it was duplicated for every match
                        AbstractNodeList::iterator deletable=i++;
                        dest->children.erase(deletable);
                    }
                    else
                    {
                        ++i; //Behavior in absence of regex, just increment iterator
                    }
                }
                else 
                {
                    ++i; //Behavior in absence of replaceable object, just increment iterator to find another
                }
            }

            // Now make matches based on index
            // Loop through destination children searching for name-matching overrides
            for(AbstractNodeList::iterator i = dest->children.begin(); i != dest->children.end(); ++i)
            {
                if((*i)->type == ANT_OBJECT)
                {
                    ObjectAbstractNode *node = reinterpret_cast<ObjectAbstractNode*>((*i).get());
                    if(!overridden[node])
                    {
                        // Retrieve the minimum override index from the map
                        size_t overrideIndex = indices[node];

                        if(overrideIndex < overrides.size())
                        {
                            // Search for minimum matching override
                            for(size_t j = overrideIndex; j < overrides.size(); ++j)
                            {
                                ObjectAbstractNode *temp = reinterpret_cast<ObjectAbstractNode*>(overrides[j].first.get());
                                if(temp->name.empty() && temp->cls == node->cls && overrides[j].second == dest->children.end())
                                {
                                    overrides[j] = std::make_pair(overrides[j].first, i);
                                    break;
                                }
                            }
                        }
                    }
                }
            }

            // Loop through overrides, either inserting source nodes or overriding
            insertPos = dest->children.begin();
            for(size_t i = 0; i < overrides.size(); ++i)
            {
                if(overrides[i].second != dest->children.end())
                {
                    // Override the destination with the source (base) object
                    overlayObject(overrides[i].first, 
                        reinterpret_cast<ObjectAbstractNode*>((*overrides[i].second).get()));
                    insertPos = overrides[i].second;
                    insertPos++;
                }
                else
                {
                    // No override was possible, so insert this node at the insert position
                    // into the destination (child) object
                    AbstractNodePtr newNode(overrides[i].first->clone());
                    newNode->parent = dest;
                    if(insertPos != dest->children.end())
                    {
                        dest->children.insert(insertPos, newNode);
                    }
                    else
                    {
                        dest->children.push_back(newNode);
                    }
                }
            }
        }
    }

      此函数第一个参数sourc指向的是基类对象结点，第二个参数dest指向的是相应派生类对象结点。函数中定义的overrides容器变量很重要，它里面放了一个std::pair对象。函数先对overrides变量进行初始化（26-38行），它将基类对象的子结点链表中的每个子结点对象与派生类对象的子结点链表的结尾（end）标志对应起来；同时，clone基类中非ObjectAbstractNode类型的结点，并将其放入派生类的overrides链表中（33-37行）。初始化完成后，函数首先要对基类和派生类结点的子结点链表进行搜索，如果发现有重名且同类型的子结点就加以标记（66-87行），标记的方法就是通过overrides中的pair对象，pair的first指向基类子结点链表中的一个子结点，pair的second指向派生类子结点链表中与first指向的结点重名且同类型的结点的位置，如果基类中的某个子结点在派生类中没有重名的子结点，那么相应pair的second仍指向派生类子结点链表的end标志。

     到了overlayObject()函数的后期，如果overrides中相应pair的second值仍指向end，说明在派生类子结点中没有与基类的此子结点同名且同类型者，故只需将此结点直接插入派生类子结点链表中即可（157-170）；如果相应的pair的second值不再指向end，则说明派生类子结点中有与基类的某子结点同名且同类型的结点， 此时就需要对这两个同名子结点再进行overlayObject()操作了（148-155行）。