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)  

RoutineClass.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 RoutineClass.hpp */
40 /* */
41 /* Primitive Kernel Method Class Definitions */
42 /* */
43 /******************************************************************************/
44 #ifndef Included_RoutineClass
45 #define Included_RoutineClass
46 
47 #include "MethodClass.hpp"
48 
50 {
51 public:
52  void *operator new(size_t);
53  inline void *operator new(size_t size, void *ptr) { return ptr; };
54  RoutineClass(RexxString *n, BaseCode *_code);
55  RoutineClass(RexxString *name);
57  RoutineClass(RexxString *name, const char *data, size_t length);
59  inline RoutineClass(RESTORETYPE restoreType) { ; };
60 
61  void execute(RexxObject *, RexxObject *);
62  void live(size_t);
63  void liveGeneral(int reason);
64  void flatten(RexxEnvelope*);
65 
66  void call(RexxActivity *, RexxString *, RexxObject **, size_t, RexxString *, RexxString *, int, ProtectedObject &);
67  void call(RexxActivity *, RexxString *, RexxObject **, size_t, ProtectedObject &);
68  void runProgram(RexxActivity *activity, RexxString * calltype, RexxString * environment, RexxObject **arguments, size_t argCount, ProtectedObject &result);
69  void runProgram(RexxActivity *activity, RexxObject **arguments, size_t argCount, ProtectedObject &result);
70 
71  RexxObject *callRexx(RexxObject **, size_t);
73 
74  RexxBuffer *save();
75  void save(PRXSTRING outBuffer);
76  void save(const char *filename);
78 
79  RoutineClass *newRexx(RexxObject **, size_t);
82 
83  static RoutineClass *restore(RexxBuffer *, char *, size_t length);
84  static RoutineClass *restore(const char *data, size_t length);
85  static RoutineClass *restore(RexxString *fileName, RexxBuffer *buffer);
87  static RoutineClass *restore(RexxBuffer *buffer);
88  static RoutineClass *restore(RXSTRING *inData, RexxString *name);
89  static RoutineClass *fromFile(RexxString *filename);
90 
93 
94  static RoutineClass *processInstore(PRXSTRING instore, RexxString * name );
95 
96  static void createInstance();
98 };
99 #endif
100 
RexxArray
Definition: ArrayClass.hpp:100
BaseExecutable::source
RexxArray * source()
Definition: MethodClass.cpp:146
RoutineClass::runProgram
void runProgram(RexxActivity *activity, RexxString *calltype, RexxString *environment, RexxObject **arguments, size_t argCount, ProtectedObject &result)
Definition: RoutineClass.cpp:293
MethodClass.hpp
RoutineClass::setSecurityManager
RexxObject * setSecurityManager(RexxObject *)
Definition: RoutineClass.cpp:323
RoutineClass
Definition: RoutineClass.hpp:49
RoutineClass::save
RexxBuffer * save()
Definition: RoutineClass.cpp:333
RoutineClass::classInstance
static RexxClass * classInstance
Definition: RoutineClass.hpp:97
RexxEnvelope
Definition: RexxEnvelope.hpp:53
RexxBuffer
Definition: BufferClass.hpp:91
RoutineClass::restore
static RoutineClass * restore(RexxBuffer *, char *, size_t length)
Definition: RoutineClass.cpp:722
RoutineClass::execute
void execute(RexxObject *, RexxObject *)
RexxSource
Definition: SourceFile.hpp:131
RoutineClass::call
void call(RexxActivity *, RexxString *, RexxObject **, size_t, RexxString *, RexxString *, int, ProtectedObject &)
Definition: RoutineClass.cpp:237
RexxActivity
Definition: RexxActivity.hpp:127
_RXSTRING
Definition: rexx.h:156
RoutineClass::RoutineClass
RoutineClass(RexxString *n, BaseCode *_code)
Definition: RoutineClass.cpp:91
RexxClass
Definition: ClassClass.hpp:49
ProtectedObject
Definition: ProtectedObject.hpp:46
RoutineClass::restoreFromMacroSpace
static RoutineClass * restoreFromMacroSpace(RexxString *name)
Definition: RoutineClass.cpp:638
BaseCode
Definition: MethodClass.hpp:62
RoutineClass::callRexx
RexxObject * callRexx(RexxObject **, size_t)
Definition: RoutineClass.cpp:264
RoutineClass::processInstore
static RoutineClass * processInstore(PRXSTRING instore, RexxString *name)
Definition: RoutineClass.cpp:653
BaseExecutable
Definition: MethodClass.hpp:82
RoutineClass::loadExternalRoutine
RoutineClass * loadExternalRoutine(RexxString *name, RexxString *descriptor)
Definition: RoutineClass.cpp:875
RoutineClass::newRoutineObject
static RoutineClass * newRoutineObject(RexxString *, RexxObject *, RexxObject *, RexxSource *s)
Definition: RoutineClass.cpp:418
RoutineClass::flatten
void flatten(RexxEnvelope *)
Definition: RoutineClass.cpp:206
RoutineClass::createInstance
static void createInstance()
Definition: RoutineClass.cpp:78
RoutineClass::liveGeneral
void liveGeneral(int reason)
Definition: RoutineClass.cpp:196
RoutineClass::fromFile
static RoutineClass * fromFile(RexxString *filename)
Definition: RoutineClass.cpp:845
RoutineClass::newRexx
RoutineClass * newRexx(RexxObject **, size_t)
Definition: RoutineClass.cpp:550
RESTORETYPE
RESTORETYPE
Definition: ObjectClass.hpp:80
RoutineClass::RoutineClass
RoutineClass(RESTORETYPE restoreType)
Definition: RoutineClass.hpp:59
RexxObject
Definition: ObjectClass.hpp:311
RoutineClass::newFileRexx
RoutineClass * newFileRexx(RexxString *)
Definition: RoutineClass.cpp:607
RoutineClass::callWithRexx
RexxObject * callWithRexx(RexxArray *)
Definition: RoutineClass.cpp:280
RexxString
Definition: StringClass.hpp:119
RoutineClass::live
void live(size_t)
Definition: RoutineClass.cpp:186