source: git/MP/MP/h/MPT.h @ 554c78c

spielwiese
Last change on this file since 554c78c was 554c78c, checked in by Hans Schönemann <hannes@…>, 18 years ago
*hannes/krueger: syntax, format git-svn-id: file:///usr/local/Singular/svn/trunk@9424 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 11.7 KB
Line 
1/******************************************************************
2 *
3 * File:    MPT.h
4 * Purpose: Main Header file for MP Tree routines
5 * Author:  Olaf Bachmann (obachman@mathematik.uni-kl.de)
6 * Created: 11/96
7 *
8 * Change History (most recent first):
9 *
10 ******************************************************************/
11#ifndef _MPT_H_
12#define _MPT_H_
13
14#include"MP.h"
15
16/***************************************************************
17 *
18 * Declare all names of types that we use
19 *
20 ***************************************************************/
21typedef struct MPT_Tree_t MPT_Tree_t;
22typedef MPT_Tree_t * MPT_Tree_pt;
23
24typedef struct MPT_Node_t MPT_Node_t;
25typedef MPT_Node_t * MPT_Node_pt;
26
27typedef struct MPT_Annot_t MPT_Annot_t;
28typedef MPT_Annot_t * MPT_Annot_pt;
29
30typedef void * MPT_Arg_t;
31typedef MPT_Arg_t * MPT_Arg_pt;
32
33typedef struct MPT_Union_t MPT_Union_t;
34typedef MPT_Union_t * MPT_Union_pt;
35
36typedef struct MPT_DynArgs_t MPT_DynArgs_t;
37typedef MPT_DynArgs_t * MPT_DynArgs_pt;
38
39typedef void * MPT_ExternalData_t;
40
41/***************************************************************
42 *
43 * Tree declarations
44 *
45 ***************************************************************/
46
47/* A Tree consists of */
48struct MPT_Tree_t
49{
50  MPT_Node_pt     node;  /* a node  */
51  MPT_Arg_pt      args;  /* and possibly of arguments */
52};
53
54/***************************************************************
55 *
56 * Node declaration
57 *
58 ***************************************************************/
59/* A node has a */
60struct MPT_Node_t
61{
62  MP_NodeType_t     type;
63  MP_DictTag_t      dict; /* may have a defined semantics in a dictionary */
64  MPT_Arg_t         nvalue; /* always has a (node) value */
65  MP_NumChild_t     numchild; /* may specify that numchild args follow */
66  MP_NumAnnot_t     numannot; /* always may have 0 or more annots */
67  MPT_Annot_pt      *annots; /* which are stored here */
68};
69
70/***************************************************************
71 *
72 * Annotation declaration
73 *
74 ***************************************************************/
75/* An annot has */
76struct MPT_Annot_t
77{
78  MP_AnnotFlags_t   flags; /* as defined in the MP spec */
79  MP_AnnotType_t    type;  /* as defined in some dict*/
80  MP_DictTag_t      dict;  /* always need to be defined in a dict */
81  MPT_Tree_pt       value; /* and may have a tree as value */
82};
83
84/***************************************************************
85 *
86 * Argument declaration
87 *
88 * The problem is that we need to compactly represent (arrays and
89 * 8, 16, 32, and 64 bit (numeric) quantities. Hence, we can not
90 * just do
91 *
92 * union MPT_Arg_t { ... all types ... };
93 * typedef MPT_Arg_t * MPT_Args_pt;
94 *
95 * since in this case sizeof(MPT_Arg_t) == sizeof(type_with_max_size);
96 *
97 * Hence, we need to let MPT_Arg_t be (void *) and cast it to whatever
98 * it is supposed to be (which is determined from the context)
99 *
100 * We provide Macros for doing that
101 ***************************************************************/
102/* First of all, an argument may have one of the basic types */
103/* For the following, we assume that sizeof(void *) >= sizeof(type) */
104#define MP_BOOLEAN_T(arg)      ((MP_Boolean_t) (MP_UINT32_T(arg)))
105#define MP_COMMON_T(arg)       ((MP_Common_t)  (MP_UINT32_T(arg)))
106#define MP_SINT8_T(arg)        ((MP_Sint8_t)  (MP_SINT32_T(arg)))
107#define MP_UINT8_T(arg)        ((MP_Uint8_t) (MP_UINT32_T(arg)))
108#define MP_SINT32_T(arg)       ((MP_Sint32_t) (arg))
109#define MP_UINT32_T(arg)       ((MP_Uint32_t) (arg))
110#define MP_REAL32_T(arg)       ((MP_Real32_t)  (arg))
111#ifndef __64_BIT__
112/* sizeof(void *) < sizeof(MP_Real64_t) */
113#define MP_REAL64_T(arg)       (*((MP_Real64_t *) (arg)))
114#else
115/* sizeof(void *) >= sizeof(MP_Real64_t) */
116#define MP_REAL64_T(arg)       ((MP_Real64_t)  (arg))
117#endif
118#define MP_APINT_T(arg)        ((MP_ApInt_t) (arg))
119#define MP_APREAL_T(arg)       ((MP_ApReal_t) (arg))
120#define MP_STRING_T(arg)       ((char *)   (arg))
121
122/* Now we come to "structured" or composite types */
123/* For ProtoD:Union */
124#define MPT_UNION_PT(arg)      ((MPT_Union_pt) (arg))
125/* for MetaOps with numchild == 0 */
126#define MPT_DYNARGS_PT(arg)     ((MPT_DynArgs_pt) (arg))
127/* For ProtoD:Struct, and ProtoD:Ptr, and MetaOps with numchild > 0 */
128#define MPT_ARG_PT(arg)        ((MPT_Arg_pt) arg)
129/* For user defined Meta types or unspecified types */
130#define MPT_TREE_PT(arg)       ((MPT_Tree_pt) arg)
131
132
133/* And here are Macros tofor dealing with MPT_Arg_pt's */
134
135#define MP_BOOLEAN_PT(arg_pt)      ((MP_Boolean_t *) (arg_pt))
136#define MP_COMMON_PT(arg_pt)       ((MP_Common_t *)  (arg_pt))
137#define MP_SINT8_PT(arg_pt)        ((MP_Sint8_t *) (arg_pt))
138#define MP_UINT8_PT(arg_pt)        ((MP_Uint8_t *) (arg_pt))
139#define MP_SINT32_PT(arg_pt)       ((MP_Sint32_t *) (arg_pt))
140#define MP_UINT32_PT(arg_pt)       ((MP_Uint32_t *) (arg_pt))
141#define MP_REAL32_PT(arg_pt)       ((MP_Real32_t *)  (arg_pt))
142#define MP_REAL64_PT(arg_pt)       ((MP_Real64_t *)  (arg_pt))
143
144
145/* Argument of Dynamic length -- used for MetaOperators with numchil == 0 */
146struct MPT_DynArgs_t
147{
148  MP_Uint32_t   length; /* Length of array pointed to by */
149  MPT_Arg_pt    args;
150};
151
152/* Union -- for ProtoD:Union data*/
153struct MPT_Union_t
154{
155  MP_Uint32_t   tag; /* Identifying type of the arg */
156  MPT_Arg_t     arg; /* different typespecs */
157};
158
159
160/* Furthermore, we need a numeric value which identifies external data in
161   node->type */
162#define MPT_ExternalDataType    255
163
164/***************************************************************
165 *
166 * From MPT_Error.c
167 *
168 ***************************************************************/
169
170/* Enumeration of MPT specific errors */
171typedef enum MPT_Errors
172{
173  MPT_Failure,
174  MPT_Success,
175  MPT_MP_Failure,
176  MPT_UnknownType,
177  MPT_OutOfMemory,
178  MPT_WrongNodeType,
179  MPT_WrongTreeSyntax,
180  MPT_NoPointerTypespec,
181  MPT_WrongUnionDiscriminator,
182  MPT_ViolatedAssumption,
183  MPT_NotExternalData,
184  MPT_MaxError
185} MPT_Errors;
186
187typedef MPT_Errors MPT_Status_t;
188
189/* global MPT error variable */
190extern MPT_Status_t MPT_errno;
191
192/* defined in MPT_Error.c */
193extern char *MPT_errlist[];
194
195extern MPT_Status_t MPT_CheckStatus();
196
197#define MPT_DEBUG 1
198#ifdef MPT_DEBUG
199/* For Debugging, it is more convenient to have the following defined
200   as functions. This way, we can easily set a breakpoints there. */
201extern MPT_Status_t MPT_SetError(MPT_Status_t error);
202extern void MPT_ClearError();
203extern void MPT_Assume(MP_Boolean_t value);
204#else
205#define MPT_SetError(error) MPT_errno = (error)
206#define MPT_ClearError()    MPT_errno = MPT_Success
207#define MPT_Assume(x) ((void)0)
208#endif
209
210/***************************************************************
211 *
212 * From MPT_Tree.c Copying/Deleting a tree
213 *
214 ***************************************************************/
215extern void MPT_DeleteTree(MPT_Tree_pt tree);
216extern void MPT_DeleteNode(MPT_Node_pt node);
217extern void MPT_DeleteArgs(MPT_Arg_pt args, MP_NumChild_t nc,
218                           MPT_Tree_pt typespec);
219extern void MPT_DeleteTypespecedArg(MPT_Arg_t arg, MPT_Tree_pt typespec);
220
221extern void MPT_CpyTree(MPT_Tree_pt *dest, MPT_Tree_pt src);
222extern void MPT_CpyNode(MPT_Node_pt *odest, MPT_Node_pt src);
223extern void MPT_CpyArgs(MPT_Arg_pt *oargs, MPT_Arg_pt args,
224                        MP_NumChild_t nc, MPT_Tree_pt typespec);
225extern void MPT_CpyTypespecedArg(MPT_Arg_t *oarg, MPT_Arg_t arg,
226                                 MPT_Tree_pt typespec);
227
228/***************************************************************
229 *
230 * From MPT_Get.c
231 *
232 ***************************************************************/
233
234extern MPT_Status_t MPT_GetTree(MP_Link_pt link, MPT_Tree_pt *otree);
235extern MPT_Status_t MPT_GetNode(MP_Link_pt link, MPT_Node_pt *onode);
236extern MPT_Status_t MPT_GetAnnot(MP_Link_pt link, MPT_Annot_pt *oanot);
237extern MPT_Status_t MPT_GetArgs(MP_Link_pt link, MPT_Arg_pt *oargs,
238                                MP_NumChild_t nc, MPT_Tree_pt typespec);
239extern MPT_Status_t MPT_GetTypespecedArg(MP_Link_pt link, MPT_Arg_t  *oarg,
240                                         MPT_Tree_pt typespec);
241extern MPT_Status_t MPT_SkipTree(MP_Link_pt link);
242extern MPT_Status_t MPT_SkipArgs(MP_Link_pt link, MPT_Node_pt node);
243extern MPT_Status_t MPT_SkipAnnot(MP_Link_pt link, MP_Boolean_t *req);
244extern MPT_Status_t MPT_SkipAnnots(MP_Link_pt link, MP_NumAnnot_t na,
245                                   MP_Boolean_t *req);
246
247/***************************************************************
248 *
249 * From MPT_Put.c
250 *
251 ***************************************************************/
252extern MPT_Status_t MPT_PutTree(MP_Link_pt link, MPT_Tree_pt tree);
253extern MPT_Status_t MPT_PutNode(MP_Link_pt link, MPT_Node_pt node);
254extern MPT_Status_t MPT_PutArgs(MP_Link_pt link, MPT_Arg_pt args,
255                                MP_NumChild_t nc,
256                                MPT_Tree_pt typespec);
257extern MPT_Status_t MPT_PutTypespecedArg(MP_Link_pt link, MPT_Arg_t arg,
258                                         MPT_Tree_pt typespec);
259
260/***************************************************************
261 *
262 * From MPT_ApNumber.c
263 *
264 ***************************************************************/
265
266extern void MPT_InitCpyApInt(MPT_Arg_t *dest, MPT_Arg_t src);
267extern void MPT_InitCpyApReal(MPT_Arg_t *dest, MPT_Arg_t src);
268extern void MPT_DeleteApInt(MPT_Arg_t arg);
269extern void MPT_DeleteApReal(MPT_Arg_t arg);
270extern MPT_Status_t MPT_GetApInt(MP_Link_pt link, MPT_Arg_t *arg);
271extern MPT_Status_t MPT_GetApReal(MP_Link_pt link, MPT_Arg_t *arg);
272extern MPT_Status_t MPT_PutApInt(MP_Link_pt link, MPT_Arg_t arg);
273extern MPT_Status_t MPT_PutApReal(MP_Link_pt link, MPT_Arg_t arg);
274
275/***************************************************************
276 *
277 * From MPT_Misc.c
278 *
279 ***************************************************************/
280
281extern MPT_Annot_pt MPT_FindAnnot(MPT_Node_pt node, MP_DictTag_t dict,
282                                  MP_AnnotType_t atype);
283extern MPT_Tree_pt MPT_GetProtoTypespec(MPT_Node_pt node);
284extern void MPT_PushRecStruct(MPT_Tree_pt tree);
285extern void MPT_PopRecStruct();
286extern void MPT_PushRecUnion(MPT_Tree_pt tree);
287extern void MPT_PopRecUnion();
288extern MPT_Tree_pt MPT_RecStructTree;
289extern MPT_Tree_pt MPT_RecUnionTree;
290
291/***************************************************************
292 *
293 * From MPT_ExternalData.c
294 *
295 ***************************************************************/
296
297extern void (*MPT_DeleteExternalData)(MPT_Arg_t edata);
298extern void (*MPT_CpyExternalData)(MPT_Arg_t *src,
299                                   MPT_Arg_t dest);
300extern MPT_Status_t (*MPT_GetExternalData)(MP_Link_pt link,
301                                           MPT_Arg_t *data,
302                                           MPT_Node_pt node);
303extern MPT_Status_t (*MPT_PutExternalData)(MP_Link_pt link,
304                                           MPT_Arg_t data);
305
306
307
308/***************************************************************
309 *
310 * Useful Macros
311 *
312 ***************************************************************/
313#define mpt_failr(cond)                              \
314do {                                                 \
315  MPT_Status_t _mpt_status = cond;                   \
316  if (_mpt_status != MPT_Success) return _mpt_status;\
317} while (0)
318
319#define mp_failr(cond)                                              \
320do                                                                  \
321{                                                                   \
322  if ((cond) != MP_Success) return MPT_SetError(MPT_MP_Failure);    \
323} while (0)
324
325
326#define mp_return(stmnt)                                            \
327do                                                                  \
328{                                                                   \
329  if ((stmnt) != MP_Success)  return MPT_SetError(MPT_MP_Failure);  \
330  else return MPT_Success;                                          \
331}                                                                   \
332while (0)
333
334#endif /* _MPT_H_ */
335
Note: See TracBrowser for help on using the repository browser.