1/** Interface for an ANTLR3 common tree which is what gets 2 * passed around by the AST producing parser. 3 */ 4 5#ifndef _ANTLR3_COMMON_TREE_H 6#define _ANTLR3_COMMON_TREE_H 7 8// [The "BSD licence"] 9// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC 10// http://www.temporal-wave.com 11// http://www.linkedin.com/in/jimidle 12// 13// All rights reserved. 14// 15// Redistribution and use in source and binary forms, with or without 16// modification, are permitted provided that the following conditions 17// are met: 18// 1. Redistributions of source code must retain the above copyright 19// notice, this list of conditions and the following disclaimer. 20// 2. Redistributions in binary form must reproduce the above copyright 21// notice, this list of conditions and the following disclaimer in the 22// documentation and/or other materials provided with the distribution. 23// 3. The name of the author may not be used to endorse or promote products 24// derived from this software without specific prior written permission. 25// 26// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 27// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 28// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 29// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 30// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 31// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 32// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 33// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 35// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 36 37#include <antlr3defs.h> 38#include <antlr3basetree.h> 39#include <antlr3commontoken.h> 40 41#ifdef __cplusplus 42extern "C" { 43#endif 44 45typedef struct ANTLR3_COMMON_TREE_struct 46{ 47 48 /// Not used by ANTLR, but if a super structure is created above 49 /// this structure, it can be used to point to the start of the super 50 /// structure, where additional data and function pointers can be stored. 51 /// 52 void * super; 53 54 /// Start token index that encases this tree 55 /// 56 ANTLR3_MARKER startIndex; 57 58 /// End token that encases this tree 59 /// 60 ANTLR3_MARKER stopIndex; 61 62 /// A single token, this is the payload for the tree 63 /// 64 pANTLR3_COMMON_TOKEN token; 65 66 /// Points to the node that has this node as a child. 67 /// If this is NULL, then this is the root node. 68 /// 69 pANTLR3_COMMON_TREE parent; 70 71 /// What index is this particular node in the child list it 72 /// belongs to? 73 /// 74 ANTLR3_INT32 childIndex; 75 76 /// Pointer to the tree factory that manufactured this 77 /// token. This can be used by duplication methods and so on 78 /// to manufacture another auto-tracked common tree structure 79 /// 80 pANTLR3_ARBORETUM factory; 81 82 /// An encapsulated BASE TREE structure (NOT a pointer) 83 /// that performs a lot of the dirty work of node management 84 /// To this we add just a few functions that are specific to the 85 /// payload. You can further abstract common tree so long 86 /// as you always have a baseTree pointer in the top structure 87 /// and copy it from the next one down. 88 /// So, lets say we have a structure JIMS_TREE. 89 /// It needs an ANTLR3_BASE_TREE that will support all the 90 /// general tree duplication stuff. 91 /// It needs a ANTLR3_COMMON_TREE structure embedded or completely 92 /// provides the equivalent interface. 93 /// It provides it's own methods and data. 94 /// To create a new one of these, the function provided to 95 /// the tree adaptor (see comments there) should allocate the 96 /// memory for a new JIMS_TREE structure, then call 97 /// antlr3InitCommonTree(<addressofembeddedCOMMON_TREE>) 98 /// antlr3BaseTreeNew(<addressofBASETREE>) 99 /// The interfaces for BASE_TREE and COMMON_TREE will then 100 /// be initialized. You then call and you can override them or just init 101 /// JIMS_TREE (note that the base tree in common tree will be ignored) 102 /// just the top level base tree is used). Codegen will take care of the rest. 103 /// 104 ANTLR3_BASE_TREE baseTree; 105 106} 107 ANTLR3_COMMON_TREE; 108 109/// \brief ANTLR3 Tree factory interface to create lots of trees efficiently 110/// rather than creating and freeing lots of little bits of memory. 111/// 112typedef struct ANTLR3_ARBORETUM_struct 113{ 114 /// Pointers to the array of tokens that this factory has produced so far 115 /// 116 pANTLR3_COMMON_TREE *pools; 117 118 /// Current pool tokens we are allocating from 119 /// 120 ANTLR3_INT32 thisPool; 121 122 /// The next token to throw out from the pool, will cause a new pool allocation 123 /// if this exceeds the available tokenCount 124 /// 125 ANTLR3_UINT32 nextTree; 126 127 /// Trick to initialize tokens and their API quickly, we set up this token when the 128 /// factory is created, then just copy the memory it uses into the new token. 129 /// 130 ANTLR3_COMMON_TREE unTruc; 131 132 /// Pointer to a vector factory that is used to create child list vectors 133 /// for any child nodes that need them. This means that we auto track the 134 /// vectors and auto free them when we close the factory. It also means 135 /// that all rewriting trees can use the same tree factory and the same 136 /// vector factory and we do not dup any nodes unless we must do so 137 /// explicitly because of context such as an empty rewrite stream and 138 /// ->IMAGINARY[ID] so on. This makes memory tracking much simpler and 139 /// tempts no errors. 140 /// 141 pANTLR3_VECTOR_FACTORY vFactory; 142 143 /// A resuse stack for reclaiming Nil nodes that were used in rewrites 144 /// and are now dead. The nilNode() method will eat one of these before 145 /// creating a new node. 146 /// 147 pANTLR3_STACK nilStack; 148 149 /// Pointer to a function that returns a new tree 150 /// 151 pANTLR3_BASE_TREE (*newTree) (struct ANTLR3_ARBORETUM_struct * factory); 152 pANTLR3_BASE_TREE (*newFromTree) (struct ANTLR3_ARBORETUM_struct * factory, pANTLR3_COMMON_TREE tree); 153 pANTLR3_BASE_TREE (*newFromToken) (struct ANTLR3_ARBORETUM_struct * factory, pANTLR3_COMMON_TOKEN token); 154 155 /// Pointer to a function the destroys the factory 156 /// 157 void (*close) (struct ANTLR3_ARBORETUM_struct * factory); 158} 159 ANTLR3_ARBORETUM; 160 161#ifdef __cplusplus 162} 163#endif 164 165#endif 166 167 168