1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
|
/**
* <b>SOFTWARE RIGHTS</b>
* <p>
* ANTLR 2.6.0 MageLang Insitute, 1998
* <p>
* We reserve no legal rights to the ANTLR--it is fully in the
* public domain. An individual or company may do whatever
* they wish with source code distributed with ANTLR or the
* code generated by ANTLR, including the incorporation of
* ANTLR, or its output, into commerical software.
* <p>
* We encourage users to develop software with ANTLR. However,
* we do ask that credit is given to us for developing
* ANTLR. By "credit", we mean that if you use ANTLR or
* incorporate any source code into one of your programs
* (commercial product, research project, or otherwise) that
* you acknowledge this fact somewhere in the documentation,
* research report, etc... If you like ANTLR and have
* developed a nice tool with the output, please mention that
* you developed it using ANTLR. In addition, we ask that the
* headers remain intact in our source code. As long as these
* guidelines are kept, we expect to continue enhancing this
* system and expect to make other tools available as they are
* completed.
* <p>
* The ANTLR gang:
* @version ANTLR 2.6.0 MageLang Insitute, 1998
* @author Terence Parr, <a href=http://www.MageLang.com>MageLang Institute</a>
* @author <br>John Lilley, <a href=http://www.Empathy.com>Empathy Software</a>
* @author <br><a href="mailto:pete@yamuna.demon.co.uk">Pete Wells</a>
*/
#include "Antlr/ASTFactory.hpp"
#include "Antlr/CommonASTNode.hpp"
/** AST Support code shared by TreeParser and Parser.
* We use delegation to share code (and have only one
* bit of code to maintain) rather than subclassing
* or superclassing (forces AST support code to be
* loaded even when you don't want to do AST stuff).
*
* Typically, setASTNodeType is used to specify the
* type of node to create, but you can override
* create to make heterogeneous nodes etc...
*/
ASTFactory::ASTFactory()
{
nodeFactory = &CommonASTNode::factory;
}
/** Add a child to the current AST */
void ASTFactory::addASTChild(ASTPair& currentAST, RefAST child)
{
if (child) {
if (!currentAST.root) {
// Make new child the current root
currentAST.root = child;
}
else {
if (!currentAST.child) {
// Add new child to current root
currentAST.root->setFirstChild(child);
}
else {
currentAST.child->setNextSibling(child);
}
}
// Make new child the current child
currentAST.child = child;
currentAST.advanceChildToEnd();
}
}
/** Create a new empty AST node; if the user did not specify
* an AST node type, then create a default one: CommonAST.
*/
RefAST ASTFactory::create()
{
ASTNode* node = nodeFactory(); //new CommonASTNode();
node->setType(Token::INVALID_TYPE);
return RefAST(new AST(node));
}
RefAST ASTFactory::create(int type)
{
RefAST t = create();
t->initialize(type,"");
return t;
}
RefAST ASTFactory::create(int type, const std::string& txt)
{
RefAST t = create();
t->initialize(type,txt);
return t;
}
/** Create a new empty AST node; if the user did not specify
* an AST node type, then create a default one: CommonAST.
*/
RefAST ASTFactory::create(const AST* tr)
{
if (!tr) return nullAST; // create(null) == null
RefAST t = create();
t->initialize(tr);
return t;
}
RefAST ASTFactory::create(RefToken tok)
{
RefAST t = create();
t->initialize(tok);
return t;
}
/** Copy a single node. clone() is not used because
* we want to return an AST not a plain object...a type
* safety issue. Further, we want to have all AST node
* creation go through the factory so creation can be
* tracked. Returns null if t is null.
*/
RefAST ASTFactory::dup(const AST* t)
{
return create(t); // if t==null, create returns null
}
/** Duplicate tree including siblings of root. */
RefAST ASTFactory::dupList(const AST* t)
{
RefAST result = dupTree(t); // if t == null, then result==null
RefAST nt = result;
while (t) { // for each sibling of the root
t = t->getNextSibling();
nt->setNextSibling(dupTree(t)); // dup each subtree, building new tree
nt = nt->getNextSibling();
}
return result;
}
/**Duplicate a tree, assuming this is a root node of a tree--
* duplicate that node and what's below; ignore siblings of root node.
*/
RefAST ASTFactory::dupTree(const AST* t)
{
RefAST result = dup(t); // make copy of root
// copy all children of root.
if (t) {
result->setFirstChild( dupList(t->getFirstChild()) );
}
return result;
}
/** Make a tree from a list of nodes. The first element in the
* array is the root. If the root is null, then the tree is
* a simple list not a tree. Handles null children nodes correctly.
* For example, build(a, b, null, c) yields tree (a b c). build(null,a,b)
* yields tree (nil a b).
*/
RefAST ASTFactory::make(std::vector<RefAST> nodes)
{
if ( nodes.size()==0 )
return RefAST(0);
RefAST root = nodes[0];
RefAST tail = RefAST(0);
if (root) {
root->setFirstChild(RefAST(0)); // don't leave any old pointers set
}
// link in children;
for (unsigned int i=1; i<nodes.size(); i++) {
if ( !nodes[i] ) continue; // ignore null nodes
if ( !root ) {
// Set the root and set it up for a flat list
root = tail = nodes[i];
}
else if ( !tail ) {
root->setFirstChild(nodes[i]);
tail = root->getFirstChild();
}
else {
tail->setNextSibling(nodes[i]);
tail = tail->getNextSibling();
}
// Chase tail to last sibling
while (tail->getNextSibling()) {
tail = tail->getNextSibling();
}
}
return root;
}
/** Make a tree from a list of nodes, where the nodes are contained
* in an ASTArray object
*/
RefAST ASTFactory::make(ASTArray* nodes)
{
RefAST ret = make(nodes->array);
delete nodes;
return ret;
}
/** Make an AST the root of current AST */
void ASTFactory::makeASTRoot(ASTPair& currentAST, RefAST root)
{
if (root) {
// Add the current root as a child of new root
root->addChild(currentAST.root);
// The new current child is the last sibling of the old root
currentAST.child = currentAST.root;
currentAST.advanceChildToEnd();
// Set the new root
currentAST.root = root;
}
}
void ASTFactory::setASTNodeFactory(factory_type factory)
{
nodeFactory = factory;
}
|