/usr/include/Attribute/paramlist.h is in ivtools-dev 1.2.11a1-11.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 | /*
* Copyright (c) 1994-1996,1999 Vectaport Inc.
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the names of the copyright holders not be used in
* advertising or publicity pertaining to distribution of the software
* without specific, written prior permission. The copyright holders make
* no representations about the suitability of this software for any purpose.
* It is provided "as is" without express or implied warranty.
*
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
* IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL,
* INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
* FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
/*
* ParamList - a list of parameter definition structures.
*/
#if !defined(param_list_h)
#define param_list_h
#include <IV-2_6/InterViews/defs.h>
#include <Unidraw/enter-scope.h>
#include <IV-2_6/_enter.h>
class ALIterator;
class LexScan;
class AList;
#include <iosfwd>
//: signature of static methods for reading parameter data from an istream.
typedef int (*param_callback)(istream&, void*, void*, void*, void*);
class ParamList;
//: parameter definition structure for ParamList.
// structure for defining an argument to be read out of a serialized view
// of an object written out for persistent storage or interprocess communication.
class ParamStruct {
public:
enum ParamFormat { required, optional, keyword, other };
// type of parameter formats supported. Similar to Common Lisp.
ParamStruct(const char* name, ParamFormat format, param_callback ifunc,
int offset1, int offset2, int offset3, int offset4,
int indirection = -1);
// construct with 'name' and 'format', a pointer to a static method
// with 'param_callback' signature, and up to 4 offsets relative to a
// base pointer that will be used in constructing the contents of another
// object during a de-serialization process (an istream constructor).
// Also possible to specify an 'indirection' amount used when adding
// offsets to the base.
ParamStruct(ParamStruct&);
// copy constructor.
~ParamStruct();
const char* name() {return _name;}
// the name of the parameter -- keyword parameters do not need the ":".
ParamFormat format() {return _format;}
// parameter format type: required, optional, keyword, or other.
param_callback ifunc() {return _ifunc;}
// pointer to static method (or function) to invoke when parameter found
// during de-serialization process.
int offset1() {return _offset1;}
// first offset from base. This one is always supplied, and might
// be the only true offset if pointing to an array.
int offset2() {return _offset2;}
// second offset from base. Might really be an array length in a
// certain usage. The 'ifunc' is free to interpret these as it wants.
int offset3() {return _offset3;}
// third offset from base.
int offset4() {return _offset4;}
// fourth offset from base. If this is not enough either an array can
// can be passed by using the first two, or these can be ignored
// all together and you can use fixed locations within the object being
// deserialized.
int indirection() {return _indirection;}
// offset from base address used to retrieve another address (by indirection).
// disabled if less than zero.
void* addr1(void* base);
// compute address by adding offset1() to 'base' or an indirect base
// determined by the contents of 'base' + indirection().
void* addr2(void* base);
// compute address by adding offset2() to 'base' or an indirect base
// determined by the contents of 'base' + indirection().
void* addr3(void* base);
// compute address by adding offset3() to 'base' or an indirect base
// determined by the contents of 'base' + indirection().
void* addr4(void* base);
// compute address by adding offset4() to 'base' or an indirect base
// determined by the contents of 'base' + indirection().
protected:
char* _name;
ParamFormat _format;
param_callback _ifunc;
int _offset1;
int _offset2;
int _offset3;
int _offset4;
int _indirection;
};
//: list of ParamStruct objects for de-serialization of a previously serialized object.
// list of ParamStruct objects that defines the possible signature
// of a serialized object, for use in de-serialization (istream constructors).
// <p>
// See OverlayScript and OverlayComp for an example of how this is used.
// OverlayScript is a serializing view of an OverlayComp, and generates a variable
// length, ASCII record (with arguments enclosed in parenthesis following the object
// name) that describes the internal state of an OverlayComp. Then later, the
// istream constructor of an OverlayComp uses the static ParamList object of its
// class to reverse the process (called de-serialization), to set the internal state
// of a newly constructed OverlayComp to mirror the internal state of the original
// object. This mechanism can be used for any struct or C++ class that needs to be
// saved out to disk for persistent storage, or transmitted over a socket.
// <p>
// Keep in mind that only relative addresses are used to construct the ParamStruct
// objects that make up the ParamList, and the actual base address used to
// resolve where to place data is different when the final object is constructed
// (except for the very first time an object of a given class gets constructed --
// at that time the addresses used to build up the ParamList are the same ones
// used to populate the object).
class ParamList {
public:
ParamList(ParamList* = nil);
// construct with optional ParamList to copy.
virtual ~ParamList();
static LexScan* lexscan();
// construct default LexScan for use.
void add_param(
const char* name, ParamStruct::ParamFormat format, param_callback ifunc,
void* base, void* addr1,
void* addr2 = nil, void* addr3 = nil, void* addr4 = nil);
// compose and insert ParamStruct, computing offsets 1 thru 4 by differing
// against 'base'.
void add_param_indirect(
const char* name, ParamStruct::ParamFormat format, param_callback ifunc,
void* base, void* offset, void* addr1,
void* addr2 = nil, void* addr3 = nil, void* addr4 = nil);
// compose and insert ParamStruct, computing offsets 1 thru 4 by differing
// against the content of 'offset', and subtracting 'base' from 'offset'
// to arrive at indirection offset to set in the ParamStruct (the offset from
// the base address of the object being constructed where you will find
// an address to add the other offsets to, to arrive a final address).
void add_param_first(
const char* name, ParamStruct::ParamFormat format, param_callback ifunc,
void* base = (void*)0x1, void* addr1 = (void*)0x1,
void* addr2 = nil, void* addr3 = nil, void* addr4 = nil);
// compose and insert ParamStruct as far forward in the ParamList as possible
// given its desired format type. In this manner a parameter handler can be
// easily overriden.
boolean read_args(istream& in, void* base);
// work-horse method that assumes istream is positioned right before
// the open-paren of the serialized object (the object name precedes
// the open-paren). Handles the logic to parse first required, then
// optional, then keyword arguments (or 'other' arugments, which means
// pass the rest of the arguments on as is). Invokes all the function
// pointers of type param_callback.
/* static callback functions */
static int read_int(istream&, void* p0, void* p1=NULL, void* p2=NULL, void* p3=NULL);
// param_callback to read up to four comma-separated integers from istream.
static int read_float(istream&, void* p0, void* p1=NULL, void* p2=NULL, void* p3=NULL);
// param_callback to read up to four comma-separated floats from istream.
static int read_double(istream&, void* p0, void* p1=NULL, void* p2=NULL, void* p3=NULL);
// param_callback to read up to four comma-separated doubles from istream.
static int read_string(istream&, void* p0, void* p1=NULL, void* p2=NULL, void* p3=NULL);
// param_callback to read up to four comma-separated character strings from istream.
static int read_symbol(istream&, void* p0, void* p1=NULL, void* p2=NULL, void* p3=NULL);
// param_callback to read up to four comma-separated character strings (as symbols) from istream.
static int read_ints(istream&, void* p0, void* p1=NULL, void* p2=NULL, void* p3=NULL);
// param_callback to read any number of comma-separated integers from istream.
static int read_floats(istream&, void* p0, void* p1=NULL, void* p2=NULL, void* p3=NULL);
// param_callback to read any number of comma-separated floats from istream.
static int read_doubles(istream&, void* p0, void* p1=NULL, void* p2=NULL, void* p3=NULL);
// param_callback to read any number of comma-separated doubles from istream.
static int read_strings(istream&, void* p0, void* p1=NULL, void* p2=NULL, void* p3=NULL);
// param_callback to read any number of comma-separated strings from istream.
/* static functions for use in callbacks */
static int skip_space(istream& in);
// skip whitespace in istream, for use of a param_callback.
static int parse_token(istream& in, char* buffer, int buflen, const char delim = '(');
// parse token from istream, for use of a param_callback.
static int parse_token(istream& in, char* buffer, int buflen, const char* delim);
// parse token from istream ended by one of a string of delimters,
// for use of a param_callback.
static int parse_string(istream& in, char* buffer, int buflen, boolean keep_backslashes=0);
// parse string from istream, correctly handling embedded quotes prefixed
// by back-slashes, for use of a param_callback.
static int parse_points(istream&, Coord*&, Coord*&, int&);
// parse parenthesized point list of integers from istream, for use of a param_callback.
static int parse_fltpts(istream&, float*&, float*&, int&);
// parse parenthesized point list of floats from istream, for use of a param_callback.
static int parse_dblpts(istream&, double*&, double*&, int&);
// parse parenthesized point list of doubles from istream, for use of a param_callback.
static int parse_text(istream& in, char* buffer, int buflen);
// parse text string, converting embedded octal constants, and handling
// embedded quotes preceded by back-slashes, for use of a param_callback.
static char* parse_textbuf(istream& in);
// parse multi-line comma-separated set of character strings into a single buffer,
// for use of a param_callback.
static int output_text(ostream& out, const char* text, int indent=0);
// output text in a format readable by parse_text().
static int parse_pathname(istream& in, char* buffer, int buflen, const char* dir);
// parse pathname, expanding relative pathnames from 'dir', for use of a
// param_callback.
static boolean url_use_ok();
// test if url use ok for pathnames. Same as OpenFileChooser method.
static boolean urltest(const char*);
// test if pathname looks like a URL. Same as OpenFileChooser method.
static int bintest(const char* name);
// return 0 if executable can be found, otherwise -1.
static boolean bincheck(const char* name);
// return true if executable can be found.
static const char* filter(const char* string, int len);
// filter text buffer for octal constants.
static char* octal(unsigned char c, register char* p);
// convert a character to an octal string.
static char octal(const char* p);
// convert string of three octal digits to a character.
static ParamStruct* CurrParamStruct() { return _currstruct; }
// last ParamStruct from ::GetStruct
protected:
void insert(ParamStruct*);
void insert_first(ParamStruct*);
void First(ALIterator&);
void Last(ALIterator&);
void Next(ALIterator&);
void Prev(ALIterator&);
boolean Done(ALIterator);
boolean IsEmpty();
int Number();
void Append(ParamStruct*);
void Prepend(ParamStruct*);
void InsertAfter(ALIterator, ParamStruct*);
void InsertBefore(ALIterator, ParamStruct*);
void Remove(ParamStruct*);
void Remove(ALIterator&);
ParamStruct* GetStruct(ALIterator);
void SetStruct(ParamStruct*, ALIterator&);
boolean Includes(ParamStruct*);
ParamStruct* Struct(AList*);
AList* Elem(ALIterator);
protected:
AList* _alist;
int _count;
int _required_count;
int _optional_count;
int _keyword_count;
int _other_count;
static LexScan* _lexscan;
static ParamStruct* _currstruct;
};
#include <IV-2_6/_leave.h>
#endif /* !defined(_param_list_h) */
|