home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / VSLNode.h < prev    next >
C/C++ Source or Header  |  1998-11-23  |  5KB  |  178 lines
  1. // $Id: VSLNode.h,v 1.13 1998/11/23 17:43:46 zeller Exp $
  2. // VSL Nodes
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // DDD is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. #ifndef _DDD_VSLNode_h
  30. #define _DDD_VSLNode_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36.  
  37. // A VSLNode is a node of an evaluation tree that represents the
  38. // expressions of a VSLL library.
  39.  
  40.  
  41. #include "assert.h"
  42. #include <iostream.h>
  43. #include <string.h>
  44. #include "TypeInfo.h"
  45.  
  46. #include "VSLBuiltin.h"
  47.  
  48. class Box;
  49. class ListBox;
  50. class VSLDefList;
  51. class VSLDef;
  52. class VSLNode;
  53.  
  54. // VSLNode
  55.  
  56. class VSLNode {
  57. public:
  58.     DECLARE_TYPE_INFO
  59.  
  60. private:
  61.     char *_type;    // Type
  62.  
  63. protected:
  64.     unsigned _base; // Number of arguments in context
  65.  
  66.     // Flag: are side effects allowed?
  67.     static bool sideEffectsProhibited;
  68.  
  69.     // Flag: have side effects been observed?
  70.     static bool sideEffectsOccured;
  71.  
  72.     // Copy
  73.     VSLNode(const VSLNode& node):
  74.     _type(node._type),
  75.     _base(node._base)
  76.     {}
  77.  
  78.     // Dump
  79.     virtual void dump(ostream& s) const = 0;      // as VSL epxr
  80.     virtual void _dumpTree(ostream&) const {}     // as tree
  81.  
  82.     virtual bool matches(const VSLNode& node) const
  83.     {
  84.     return strcmp(_type, node._type) == 0;
  85.     }
  86. private:
  87.     VSLNode& operator = (const VSLNode &) { assert(0); return *this; }
  88.  
  89. public:
  90.     // Constructor
  91.     VSLNode(char *type = "VSLNode")
  92.     : _type(type), _base(0)
  93.     {}
  94.  
  95.     // Default destructor
  96.     virtual ~VSLNode()
  97.     {
  98.     _type = 0;  // Protect against further references
  99.     }
  100.  
  101.     // Copy
  102.     virtual VSLNode *dup() const = 0;
  103.  
  104.     // Evaluate
  105.     virtual const Box *eval(ListBox *arglist) const;
  106.     virtual const Box *_eval(ListBox *arglist) const = 0;
  107.  
  108.     // Optimize (default: nop)
  109.     virtual int resolveDefs(VSLDef *, bool = true)      { return 0; }
  110.     virtual int resolveSynonyms(VSLDef *, VSLNode **)   { return 0; }
  111.     virtual int foldOps(VSLDef *, VSLNode **)           { return 0; }
  112.     virtual int foldConsts(VSLDef *, VSLNode **)        { return 0; }
  113.     virtual int countSelfReferences(VSLDef *, 
  114.     VSLDefList *)                                   { return 0; }
  115.     virtual int inlineFuncs(VSLDef *, VSLNode **)       { return 0; }
  116.     virtual int instantiateArgs(VSLDef *, VSLNode **,
  117.     VSLNode **, unsigned , unsigned)                { return 0; }
  118.     virtual void countArgNodes(VSLDef *, int[],
  119.     unsigned , unsigned )                           { return; }
  120.     virtual int _reBase(VSLDef *, unsigned )            { return 0; }
  121.     int reBase(VSLDef *cdef, unsigned newBase) 
  122.     { 
  123.     int changes = _reBase(cdef, newBase);
  124.     _base = newBase;
  125.     return changes;
  126.     }
  127.  
  128.     // Other tree ops (default: nop)
  129.     virtual void compilePatterns(VSLDef *) const            { return; }
  130.     virtual void uncompilePatterns(VSLDef *) const          { return; }
  131.     virtual int resolveName(VSLDef *, VSLNode **, 
  132.     string& , unsigned)                                 { return 0; }
  133.     virtual int _resolveNames(VSLDef *, unsigned)           { return 0; }
  134.     int resolveNames(VSLDef *cdef, unsigned base)
  135.     {
  136.     _base = base;
  137.     return _resolveNames(cdef, base);
  138.     }
  139.  
  140.     virtual string firstName() const          { return ""; }
  141.  
  142.     // Check type
  143.     virtual bool isConst() const = 0;
  144.  
  145.     virtual bool isArgNode() const         { return false; }
  146.     virtual bool isBuiltinCallNode() const { return false; }
  147.     virtual bool isCallNode() const        { return false; }
  148.     virtual bool isConstNode() const       { return false; }
  149.     virtual bool isDefCallNode() const     { return false; }
  150.     virtual bool isDummyNode() const       { return false; }
  151.     virtual bool isLetNode() const         { return false; }
  152.     virtual bool isListNode() const        { return false; }
  153.     virtual bool isNameNode() const        { return false; }
  154.     virtual bool isTestNode() const        { return false; }
  155.  
  156.     virtual bool isStraight() const        { return false; }
  157.  
  158.     // # of NameNodes
  159.     virtual unsigned nargs() const            { return 0; }
  160.  
  161.     // Match functions
  162.     static bool bothSidesCanMatch;
  163.     bool operator == (const VSLNode& node) const;
  164.     bool operator != (const VSLNode& node) const
  165.     { 
  166.     return !(operator == (node)); 
  167.     }
  168.  
  169.     // Representation invariant
  170.     virtual bool OK() const;
  171.  
  172.     // Dump
  173.     friend ostream& operator << (ostream& s, const VSLNode& node); // als VSL
  174.     void dumpTree(ostream& s) const;                               // als Baum
  175. };
  176.  
  177. #endif
  178.