ooRexx  4.2.0-source
About: ooRexx (Open Object Rexx) is a free implementation of Object Rexx. Object Rexx is an enhancement of the classic Rexx interpreter; a full-featured programming language with a human-oriented syntax.
  Fossies Dox: ooRexx-4.2.0-source.tar.gz  ("inofficial" and yet experimental doxygen-generated source code documentation)  

RexxCompoundElement.hpp
Go to the documentation of this file.
1 /*----------------------------------------------------------------------------*/
2 /* */
3 /* Copyright (c) 1995, 2004 IBM Corporation. All rights reserved. */
4 /* Copyright (c) 2005-2009 Rexx Language Association. All rights reserved. */
5 /* */
6 /* This program and the accompanying materials are made available under */
7 /* the terms of the Common Public License v1.0 which accompanies this */
8 /* distribution. A copy is also available at the following address: */
9 /* http://www.oorexx.org/license.html */
10 /* */
11 /* Redistribution and use in source and binary forms, with or */
12 /* without modification, are permitted provided that the following */
13 /* conditions are met: */
14 /* */
15 /* Redistributions of source code must retain the above copyright */
16 /* notice, this list of conditions and the following disclaimer. */
17 /* Redistributions in binary form must reproduce the above copyright */
18 /* notice, this list of conditions and the following disclaimer in */
19 /* the documentation and/or other materials provided with the distribution. */
20 /* */
21 /* Neither the name of Rexx Language Association nor the names */
22 /* of its contributors may be used to endorse or promote products */
23 /* derived from this software without specific prior written permission. */
24 /* */
25 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */
26 /* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */
27 /* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */
28 /* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT */
29 /* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, */
30 /* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */
31 /* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, */
32 /* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY */
33 /* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING */
34 /* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS */
35 /* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
36 /* */
37 /*----------------------------------------------------------------------------*/
38 /******************************************************************************/
39 /* REXX Kernel RexxCompoundElement.hpp */
40 /* */
41 /* Primitive CompoundVariable Class Definition */
42 /* */
43 /******************************************************************************/
44 #ifndef Included_RexxCompoundElement
45 #define Included_RexxCompoundElement
46 
47 #include "RexxVariable.hpp"
48 #include "StringClass.hpp"
49 
51  friend class RexxCompoundTable; // allow the compound table to access innards.
52 
53  public:
54  inline void *operator new(size_t size, void *ptr) { return ptr; };
55  inline void operator delete(void *) { ; }
56  inline void operator delete(void *, void *) { ; }
57 
58  inline RexxCompoundElement(RESTORETYPE restoreType) { ; };
59  void live(size_t);
60  void liveGeneral(int reason);
61  void flatten(RexxEnvelope *);
62 
64  inline void setParent(RexxCompoundElement *parentElement) { OrefSet(this, this->parent, parentElement); }
65  inline void setLeft(RexxCompoundElement *leftChild) { OrefSet(this, this->left, leftChild); }
66  inline void setRight(RexxCompoundElement *rightChild) { OrefSet(this, this->right, rightChild); }
67  inline void expose(RexxCompoundElement *real) { OrefSet(this, this->real_element, real); }
68  inline RexxString *createCompoundName(RexxString *stemName) { return stemName->concat(getName()); }
69  inline void setValue(RexxObject *value) { set(value); }
70 
72 
73 protected:
74 
75  RexxCompoundElement *left; /* the left child */
76  RexxCompoundElement *right; /* the right child */
77  RexxCompoundElement *parent; /* the parent entry to this node */
78  unsigned short leftdepth; /* depth on the left side */
79  unsigned short rightdepth; /* depth on the right side */
80  RexxCompoundElement *real_element; /* a potential expose indirection */
81 };
82 
83 
85 
86 #endif
RexxCompoundElement::createCompoundName
RexxString * createCompoundName(RexxString *stemName)
Definition: RexxCompoundElement.hpp:68
RexxCompoundElement::right
RexxCompoundElement * right
Definition: RexxCompoundElement.hpp:76
RexxCompoundElement
Definition: RexxCompoundElement.hpp:50
RexxVariable.hpp
RexxCompoundElement::left
RexxCompoundElement * left
Definition: RexxCompoundElement.hpp:75
OrefSet
#define OrefSet(o, r, v)
Definition: RexxCore.h:94
RexxCompoundElement::RexxCompoundElement
RexxCompoundElement(RESTORETYPE restoreType)
Definition: RexxCompoundElement.hpp:58
new_compoundElement
RexxCompoundElement * new_compoundElement(RexxString *s)
Definition: RexxCompoundElement.hpp:84
RexxCompoundElement::setParent
void setParent(RexxCompoundElement *parentElement)
Definition: RexxCompoundElement.hpp:64
RexxVariable::getName
RexxString * getName()
Definition: RexxVariable.hpp:74
RexxCompoundElement::real_element
RexxCompoundElement * real_element
Definition: RexxCompoundElement.hpp:80
RexxCompoundElement::realVariable
RexxCompoundElement * realVariable()
Definition: RexxCompoundElement.hpp:63
RexxCompoundElement::flatten
void flatten(RexxEnvelope *)
Definition: RexxCompoundElement.cpp:76
RexxCompoundElement::parent
RexxCompoundElement * parent
Definition: RexxCompoundElement.hpp:77
RexxEnvelope
Definition: RexxEnvelope.hpp:53
OREF_NULL
#define OREF_NULL
Definition: RexxCore.h:60
RexxCompoundElement::setRight
void setRight(RexxCompoundElement *rightChild)
Definition: RexxCompoundElement.hpp:66
RexxCompoundElement::newInstance
static RexxCompoundElement * newInstance(RexxString *name)
Definition: RexxCompoundElement.cpp:95
StringClass.hpp
RexxVariable::set
void set(RexxObject *value)
Definition: RexxVariable.hpp:67
RexxCompoundElement::rightdepth
unsigned short rightdepth
Definition: RexxCompoundElement.hpp:79
RexxCompoundElement::live
void live(size_t)
Definition: RexxCompoundElement.cpp:48
RexxCompoundTable
Definition: RexxCompoundTable.hpp:66
RexxCompoundElement::liveGeneral
void liveGeneral(int reason)
Definition: RexxCompoundElement.cpp:62
RexxCompoundElement::setLeft
void setLeft(RexxCompoundElement *leftChild)
Definition: RexxCompoundElement.hpp:65
RESTORETYPE
RESTORETYPE
Definition: ObjectClass.hpp:80
RexxCompoundElement::expose
void expose(RexxCompoundElement *real)
Definition: RexxCompoundElement.hpp:67
RexxCompoundElement::leftdepth
unsigned short leftdepth
Definition: RexxCompoundElement.hpp:78
RexxString::concat
RexxString * concat(RexxString *)
Definition: StringClass.cpp:1172
RexxCompoundElement::setValue
void setValue(RexxObject *value)
Definition: RexxCompoundElement.hpp:69
RexxObject
Definition: ObjectClass.hpp:311
RexxString
Definition: StringClass.hpp:119
RexxVariable
Definition: RexxVariable.hpp:49