kturtle/src/treenode.h

   1 /*
   2     Copyright (C) 2003 by Walter Schreppers
   3     Copyright (C) 2004 by Cies Breijs
   4
   5     This program is free software; you can redistribute it and/or
   6     modify it under the terms of version 2 of the GNU General Public
   7     License as published by the Free Software Foundation.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 // This file is originally written by Walter Scheppers, but allmost
  20 // every aspect of it is slightly changed by Cies Breijs.
  21
  22
  23 #ifndef _TREENODE_H_
  24 #define _TREENODE_H_
  25
  26 #include <list>
  27
  28 #include <qstring.h>
  29
  30 #include "lexer.h"
  31 #include "token.h"
  32 #include "value.h"
  33
  34
  35 using namespace std;  // needed because treenode inherites from std::list
  36
  37 //BUGS: prevSibling and nextSibling sometimes segfault and are not optimal, in short, don't use em! :)
  38
  39 enum NodeType
  40 {
  41         Unknown = -1,
  42         programNode,
  43         functionNode,
  44         functionCallNode,
  45         funcReturnNode,
  46         returnNode,
  47         breakNode,
  48         idListNode,
  49         blockNode,
  50         forNode,
  51         forEachNode,
  52         whileNode,
  53         ifNode,
  54         assignNode,
  55         expressionNode,
  56         idNode,
  57         constantNode,
  58
  59         addNode,
  60         mulNode,
  61         divNode,
  62         subNode,
  63         minusNode,
  64
  65         nodeGE,
  66         nodeGT,
  67         nodeLE,
  68         nodeLT,
  69         nodeNE,
  70         nodeEQ,
  71
  72         andNode,
  73         orNode,
  74         notNode,
  75
  76         runNode,
  77
  78         ClearNode,
  79         GoNode,
  80         GoXNode,
  81         GoYNode,
  82         ForwardNode,
  83         BackwardNode,
  84         DirectionNode,
  85         TurnLeftNode,
  86         TurnRightNode,
  87         CenterNode,
  88         SetPenWidthNode,
  89         PenUpNode,
  90         PenDownNode,
  91         SetFgColorNode,
  92         SetBgColorNode,
  93         ResizeCanvasNode,
  94         SpriteShowNode,
  95         SpriteHideNode,
  96         SpritePressNode,
  97         SpriteChangeNode,
  98
  99         MessageNode,
 100         InputWindowNode,
 101         printNode,
 102         FontTypeNode,
 103         FontSizeNode,
 104         RepeatNode,
 105         RandomNode,
 106         WaitNode,
 107         WrapOnNode,
 108         WrapOffNode,
 109         ResetNode,
 110
 111         LineBreakNode,
 112         EndOfFileNode
 113
 114
 115 //              HOPEFULLY THIS LIST CAN ONCE LOOK LIKE THIS:
 116 //      nodeProgram, // this frirst block has no corresponding token
 117 //      nodeFunction,
 118 //      nodeFunctionCall,
 119 //      nodeReturnFunction,
 120 //      nodeParameterList,
 121 //      nodeBlock,
 122 //      nodeExpression,
 123 //      nodeId, // for assignments
 124 //
 125 //      nodeNotSet = -1, // inittial type of all tokens
 126 //      nodeUnknown = 0, // when no token was found, a tokUnknown is often a variable, function or error
 127 //
 128 //      nodeIf,
 129 //      nodeElse,
 130 //      nodeWhile,
 131 //      nodeFor,
 132 //      nodeTo,
 133 //      nodeStep,
 134 //      nodeForEach,
 135 //      nodeIn,
 136 //      nodeBreak,
 137 //      nodeReturn,
 138 //
 139 //      nodeBegin,
 140 //      nodeEnd,
 141 //
 142 // //   nodeNumber,  --> constantNode
 143 // //   nodeString,
 144 //
 145 //      nodeAssign,
 146 //
 147 //      nodeAnd,
 148 //      nodeOr,
 149 //      nodeNot,
 150 //
 151 //      nodeEq,
 152 //      nodeNe,
 153 //      nodeGe,
 154 //      nodeGt,
 155 //      nodeLe,
 156 //      nodeLt,
 157 //
 158 //      // nodeBraceOpen,
 159 //      // nodeBraceClose,
 160 //      // nodePlus,
 161 //      nodeAdd, // different from TokenType
 162 //      nodeSub, // different from TokenType
 163 //      nodeMul,
 164 //      nodeDev,
 165 //      nodeMinus, // different meaning from TokenType
 166 //
 167 //      // nodeComma,
 168 //      // nodeEOL,
 169 //      // nodeEOF,
 170 //      // nodeError,
 171 //
 172 //      nodeLearn,
 173 //
 174 //      nodeClear,
 175 //      nodeGo,
 176 //      nodeGoX,
 177 //      nodeGoY,
 178 //      nodeForward,
 179 //      nodeBackward,
 180 //      nodeDirection,
 181 //      nodeTurnLeft,
 182 //      nodeTurnRight,
 183 //      nodeCenter,
 184 //      nodeSetPenWidth,
 185 //      nodePenUp,
 186 //      nodePenDown,
 187 //      nodeSetFgColor,
 188 //      nodeSetBgColor,
 189 //      nodeResizeCanvas,
 190 //      nodeSpriteShow,
 191 //      nodeSpriteHide,
 192 //      nodeSpritePress,
 193 //      nodeSpriteChange,
 194 //      nodeMessage,
 195 //      nodeInputWindow,
 196 //      nodePrint,
 197 //      nodeFontType,
 198 //      nodeFontSize,
 199 //      nodeRepeat,
 200 //      nodeRandom,
 201 //      nodeWait,
 202 //      nodeWrapOn,
 203 //      nodeWrapOff,
 204 //      nodeReset,
 205 //      nodeRun,
 206 //
 207 //      // nodeDo
 208 };
 209
 210
 211
 212 class TreeNode : public list<TreeNode*> /*, public Value  <-- maybe oneday */
 213 {
 214         public:
 215                 TreeNode(); // used for creation of the first node called 'tree', in the contructor of the parser
 216                 TreeNode( TreeNode* ); // give parent
 217                 TreeNode( Token, NodeType = Unknown, QString = QString() );
 218                 virtual ~TreeNode();
 219
 220                 void init();
 221
 222                 void appendChild(TreeNode*);
 223                 void appendSibling(TreeNode*); // works only if it has parent set!
 224
 225                 TreeNode* firstChild();
 226                 TreeNode* secondChild();
 227                 TreeNode* thirdChild();
 228                 TreeNode* fourthChild();
 229                 TreeNode* fifthChild();
 230
 231                 TreeNode* lastChild();
 232                 TreeNode* nextSibling();
 233                 TreeNode* prevSibling();
 234
 235                 void      setParent(TreeNode* p)     { parent = p; }
 236                 TreeNode* getParent() const          { return parent; }
 237
 238                 void      setToken(Token t)          { fTok = t; }
 239                 Token&    getToken()                 { return fTok; }
 240
 241                 void      setType(NodeType t)        { fType = t; }
 242                 NodeType  getType() const            { return fType; }
 243
 244                 void      setLook(const QString& s)  { fTok.look = s; }
 245                 QString   getLook() const            { return fTok.look; }
 246
 247                 void      setValue(const Value& n)   { fTok.value = n; }
 248                 void      setValue(double d)         { fTok.value = d; }
 249                 void      setValue(const QString& s) { fTok.value = s; }
 250                 void      setValue(bool b)           { fTok.value.setBool(b); }
 251                 Value     getValue() const           { return fTok.value; }
 252
 253                 uint      getRow() const             { return fTok.start.row; }
 254                 uint      getCol() const             { return fTok.start.col; }
 255
 256                 bool hasChildren() const             { return size() != 0; }
 257                 TreeNode::iterator lookup(); // gives location in parent list as iterator (used by prevSibling and nextSibling)
 258
 259                 TreeNode& operator=(const TreeNode&);
 260
 261                 virtual void show(int indent = 0);
 262                 void showTree(TreeNode* node, int indent = 0) const;
 263
 264
 265         private:
 266                 void destroy(TreeNode*);
 267
 268                 NodeType     fType;
 269                 Token        fTok;
 270
 271
 272         protected:
 273                 TreeNode    *parent;
 274 };
 275
 276 #endif // _TREENODE_H_