source: git/MP/MP/MP_Util.c @ a3600c

fieker-DuValspielwiese
Last change on this file since a3600c was a3600c, checked in by Hans Schönemann <hannes@…>, 25 years ago
* hannes: glibc-fixes: rename errno of an MP link to MP_errno git-svn-id: file:///usr/local/Singular/svn/trunk@2978 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 11.9 KB
Line 
1/************************************************************************
2 *                                                                 
3 *                    MP version 1.1.2:  Multi Protocol
4 *                    Kent State University, Kent, OH
5 *                 Authors:  S. Gray, N. Kajler, P. Wang
6 *          (C) 1993, 1994, 1995, 1996, 1997 All Rights Reserved
7 *
8 *                                 NOTICE
9 *
10 *  Permission to use, copy, modify, and distribute this software and
11 *  its documentation for non-commercial purposes and without fee is
12 *  hereby granted provided that the above copyright notice appear in all
13 *  copies and that both the copyright notice and this permission notice
14 *  appear in supporting documentation.
15 * 
16 *  Neither Kent State University nor the Authors make any representations
17 *  about the suitability of this software for any purpose.  The MP Library
18 *  is distributed in the hope that it will be useful, but is provided  "as
19 *  is" and without any warranty of any kind and without even the implied 
20 *  warranty of merchantability or fitness for a particular purpose.
21 *                                                                 
22 *   IMPLEMENTATION FILE:  MP_Util.c
23 *                                                               
24 *        Useful utility routines used throughout.
25 *                                                               
26 *
27 *  Change Log:
28 *      11/25/95 sgray - commented out call to MP_ClearError() from
29 *                       MP_PrintError().  I think the error value should
30 *                         remain until the next call has cleared it.
31 *       4/25/96 sgray - Added logging support routines log_fixnum(),
32 *                       log_op(), and log_fixreal().
33 *       5/7/96  sgray - Added MP_ApIntType to IMP_TypeToString().
34 *       8/30/96 sgray - Added test for NULL link and environment in
35 *                       MP_LogEvent().
36 *
37 **********************************************************************/
38
39#ifndef lint
40static char vcid[] = "@(#) $Id: MP_Util.c,v 1.5 1999-04-09 12:14:52 Singular Exp $";
41#endif /* lint */
42
43#include "MP.h"
44
45#include <string.h>
46
47#ifndef __WIN32__
48#include <unistd.h>
49#endif
50
51/* these are used in a bunch of places */
52char fix_log_msg[log_msg_len];
53char AnnotFlagsStr[32];
54
55#ifdef __STDC__
56char* IMP_StrDup(char* s)
57#else
58void IMP_StrDup(s)
59  char* s;
60#endif
61{
62  char* d = NULL;
63 
64  if (s != NULL)
65  {
66    d = (char*) IMP_RawMemAllocFnc(strlen(s) + 1);
67    strcpy(d, s);
68  }
69  return d;
70}
71
72#ifdef __STDC__
73void MP_LogEvent(MP_Link_pt link,
74                 char      *event,
75                 char      *msg)
76#else
77void MP_LogEvent(link, event, msg)
78    MP_Link_pt link;
79    char      *event;
80    char      *msg;
81#endif
82{
83#ifdef MP_DEBUG
84    fprintf(stderr, "MP_LogEvent: entering - event = %s\n", event);
85    fflush(stderr);
86#endif
87
88    if (link == NULL || link->env == NULL){
89      fprintf(stderr, "MP_LogEvent: link or environment pointer NULL!!!\n");
90      return;
91      }
92
93    /*
94     * Be kind and make sure there is a logfile first
95     */
96    if (link->env->logfilename != NULL) {
97        fprintf(link->env->logfd, "L%d: %s %s\n", link->link_id, event, msg);
98        fflush(link->env->logfd);
99    }
100
101#ifdef MP_DEBUG
102    fprintf(stderr, "MP_LogEvent: exiting \n"); fflush(stderr);
103#endif
104}
105
106
107
108#ifdef __STDC__
109MP_Status_t MP_SetError(MP_Link_pt link, MP_Status_t the_err)
110#else
111MP_Status_t MP_SetError(link, the_err)
112    MP_Link_pt  link;
113    MP_Status_t the_err;
114#endif
115{
116    link->MP_errno = the_err;
117    if (the_err != MP_Failure && the_err >= 0 && the_err < MP_MaxError)
118        MP_LogEvent(link, MP_ERROR_EVENT, MP_errlist[the_err]);
119    else {
120        sprintf(fix_log_msg, "Unknown error number %d", link->MP_errno);
121        MP_LogEvent(link, MP_ERROR_EVENT, fix_log_msg);
122    }
123
124    return MP_Failure;
125}
126
127
128/*
129#ifdef __STDC__
130MP_Status_t MP_ClearError(MP_Link_pt link)
131#else
132MP_Status_t MP_ClearError(link)
133    MP_Link_pt link;
134#endif
135{
136   return (link->MP_errno = MP_Success);
137}
138*/
139
140
141#ifdef __STDC__
142void MP_PrintError(MP_Link_pt link)
143#else
144void MP_PrintError(link)
145  MP_Link_pt link;
146#endif
147{
148    if (link->MP_errno >= 0 && link->MP_errno < MP_MaxError) {
149        fprintf(stderr, "\nMP ERROR: %s\n", MP_errlist[link->MP_errno]);
150        fflush(stderr);
151    } else
152        fprintf(stderr, "MP: Unknown error number %d\n", link->MP_errno);
153}
154
155
156#ifdef __STDC__
157char* MP_ErrorStr(MP_Link_pt link)
158#else
159char* MP_ErrorStr(link)
160  MP_Link_pt link;
161#endif
162{
163  if (link->MP_errno >= 0 && link->MP_errno < MP_MaxError)
164    return MP_errlist[link->MP_errno];
165  else
166    return "MP: Unknown error number";
167
168}
169
170#ifdef __STDC__
171char* MP_StatusErrorStr(MP_Link_pt link, MP_Status_t status)
172#else
173char* MP_ErrorStr(link, status)
174  MP_Link_pt link;
175  MP_Status_t status;
176#endif
177{
178  if (link->MP_errno != MP_Success && link->MP_errno != MP_Failure
179      && link->MP_errno < MP_MaxError && link->MP_errno >= 0)
180    return MP_ErrorStr(link);
181  if (status != MP_Success && status != MP_Failure && 
182      status < MP_MaxError && status >= 0)
183    return MP_errlist[status];
184 
185  if (status == MP_Failure || link->MP_errno == MP_Failure)
186    return MP_errlist[MP_Failure];
187
188  if (status == MP_Success && link->MP_errno == MP_Success)
189    return MP_errlist[MP_Success];
190 
191  return "MP: Unknown Error number";
192}
193
194
195
196
197/***********************************************************************
198 * FUNCTION:  IMP_GetCmdlineArg
199 * INPUT:     argc - number of arguments in argv
200 *            argv - arguments as strings
201 *            cmd  - the cmdline option for which we seek an argument
202 * OUTPUT:    Success: pointer to the option's argument
203 *            Failure: NULL
204 * OPERATION: Just iterate through argv until we run out of things to
205 *            look at or find what we want.  We assume that there are,
206 *            in fact, argc things in argv.
207 ***********************************************************************/
208#ifdef __STDC__
209char* IMP_GetCmdlineArg(int argc,
210                        char **argv,
211                        char *cmd)
212#else
213char* IMP_GetCmdlineArg(argc, argv, cmd)
214    int argc;
215    char **argv;
216    char *cmd;
217#endif
218{
219    int i;
220   
221#ifdef MP_DEBUG
222    fprintf(stderr, "IMP_GetCmdlineArg: entering\n");
223    fflush(stderr);
224#endif
225    while (*cmd == '-') cmd++;
226
227    for (i = 0; i < argc; i++)
228        if (strstr(argv[i], cmd) != NULL  && (*(argv[i]) == '-'))
229            if (i+1 == argc)
230              return NULL;
231            else
232              return argv[i+1];
233
234#ifdef MP_DEBUG
235    fprintf(stderr, "IMP_GetCmdlineArg: exiting\n");fflush(stderr);
236#endif
237
238    return NULL;
239}
240
241
242
243#ifdef __STDC__
244char * IMP_TypeToString(MP_NodeType_t t)
245#else
246char * IMP_TypeToString(t)
247    MP_NodeType_t t;
248#endif
249{
250    switch (t) {
251    case MP_Sint32Type:
252        return "MP_Sint32";
253    case MP_Uint32Type:
254        return "MP_Uint32";
255    case MP_Uint8Type:
256        return "MP_Uint8";
257    case MP_Sint8Type:
258        return "MP_Sint8";
259    case MP_ApIntType:
260        return "MP_ApInt";
261    case MP_ApRealType:
262        return "MP_ApReal";
263    case MP_BooleanType:
264        return "MP_Boolean";
265    case MP_Real32Type:
266        return "MP_Real32";
267    case MP_Real64Type:
268        return "MP_Real64";
269    case MP_IdentifierType:
270        return "MP_Identifier";
271    case MP_CommonGreekIdentifierType:
272        return "MP_CommonGreekId";
273    case MP_CommonLatinIdentifierType:
274        return "MP_CommonLatinId";
275    case MP_ConstantType:
276        return "MP_Constant";
277    case MP_CommonConstantType:
278        return "MP_CommonConstant";
279    case MP_StringType:
280        return "MP_String";
281    case MP_RawType:
282        return "MP_Raw";
283    case MP_MetaType:
284        return "MP_MetaType";
285    case MP_CommonMetaType:
286        return "MP_CommonMeta";
287    case MP_OperatorType:
288        return "MP_Operator";
289    case MP_CommonOperatorType:
290        return "MP_CommonOp";
291    case MP_MetaOperatorType:
292        return "MP_MetaOperator";
293    case MP_CommonMetaOperatorType:
294        return "MP_CommonMetaOp";
295    default:
296        return "Unknown type";
297    }
298}
299
300
301
302#ifdef __STDC__
303void log_dicttype(MP_Link_pt     link,
304                  char          *event,
305                  char          *type_str,
306                  MP_NodeType_t  type,
307                  MP_NumAnnot_t  na,
308                  MP_DictTag_t   dtag,
309                  void          *data,
310                  MP_NumChild_t  nc)
311#else
312void log_dicttype(link, event, type_str, type, na, dtag, data,nc)
313    MP_Link_pt     link;
314    char          *event;
315    char          *type_str;
316    MP_NodeType_t  type;
317    MP_NumAnnot_t  na;
318    MP_DictTag_t   dtag;
319    void          *data;
320    MP_NumChild_t  nc;
321#endif
322{
323    char *msg;
324    int   len = 3;
325
326    if (type != MP_CommonOperatorType) {
327        len = strlen((char *)data);
328        if (len < 24) len = 24;
329    }
330
331    msg = (char *)IMP_MemAllocFnc(len + 62);
332
333    switch (type) {
334    case MP_OperatorType:
335    case MP_MetaOperatorType:
336     
337        sprintf(msg, "%-12s  annots: %lu   dict: %lu   op: %s   args: %lu",
338                type_str, na, dtag, (char *)data, nc);
339        break;
340
341    case MP_CommonOperatorType:
342    case MP_CommonMetaOperatorType:
343        sprintf(msg, "%-12s  annots: %lu   dict: %lu   op-tag: %u   args: %lu",
344                type_str, na, dtag, (unsigned int)*((MP_Common_t *)data), nc);
345        break;
346
347    case MP_CommonConstantType:
348    case MP_CommonMetaType:
349        sprintf(msg, "%-12s  annots: %lu   dict: %lu   id-tag: %u",
350                type_str, na, dtag, *((MP_Common_t *)data));
351        break;
352
353    default: ;
354    }
355
356    MP_LogEvent(link, event, msg);
357    IMP_MemFreeFnc(msg, len+62);
358}
359
360
361
362#ifdef __STDC__
363void log_fixnum(MP_Link_pt     link,
364                char          *event,
365                char          *type_str,
366                int            type,
367                MP_NumAnnot_t  na,
368                void          *val)
369#else
370void log_fixnum(link, event, type_str, type, na, val)
371    MP_Link_pt     link;
372    char          *event;
373    char          *type_str;
374    int            type;
375    MP_NumAnnot_t  na;
376    void          *val;
377#endif
378{
379    MP_Uint8_t t;
380
381    switch (type) {
382        case MP_BooleanType:
383        case MP_Uint8Type:
384        t = (MP_Uint8_t)*((MP_Uint8_t *)val);
385        sprintf(fix_log_msg, "%-12s  annots: %lu   value: %u", type_str, na,t);
386        break;
387
388    case MP_Uint32Type:
389        sprintf(fix_log_msg, "%-12s  value: %lu\n", type_str,
390                (MP_Uint32_t)*((MP_Uint32_t *)val));
391        break;
392
393    case MP_Sint8Type:
394        sprintf(fix_log_msg, "%-12s  annots: %lu   value: %d", type_str, na,
395                *((MP_Sint8_t *)val));
396        break;
397
398    case MP_Sint32Type:
399        sprintf(fix_log_msg, "%-12s  value: %ld", type_str,
400                (MP_Sint32_t)*((MP_Sint32_t *)val));
401        break;
402
403    default: ;
404    }
405
406    MP_LogEvent(link, event, fix_log_msg);
407}
408
409
410
411#ifdef __STDC__
412void log_fixreal(MP_Link_pt     link,
413                 char          *event,
414                 char          *type_str,
415                 int            type,
416                 MP_NumAnnot_t  na,
417                 void          *val)
418#else
419void log_fixreal(link, event, type_str, type, na, val)
420    MP_Link_pt     link;
421    char          *event;
422    char          *type_str;
423    int            type;
424    MP_NumAnnot_t  na;
425    void          *val;
426#endif
427{
428    switch (type) {
429    case MP_Real32Type:
430        sprintf(fix_log_msg, "%-12s  value: %-20.10G", type_str,
431                *((MP_Real32_t *)val));
432        break;
433
434    case MP_Real64Type:
435        sprintf(fix_log_msg, "%-12s  value: %-20.15G", type_str,
436                *((MP_Real64_t *)val));
437        break;
438
439    }
440
441    MP_LogEvent(link, event, fix_log_msg);
442}
443
444
445
446#ifdef __STDC__
447void annot_flags_to_str(MP_AnnotFlags_t flags)
448#else
449void annot_flags_to_str(flags)
450    MP_AnnotFlags_t flags;
451#endif
452{
453    char *req, *scope, *valuated;
454
455    valuated = (flags & MP_AnnotValuated)  ? "Arg"  : "NoArg";
456    req      = (flags & MP_AnnotRequired)  ? "Req"  : "Sup";
457    scope    = (flags & MP_AnnotTreeScope) ? "Node" : "Tree";
458
459    sprintf(AnnotFlagsStr, "%s %s %s", req, valuated, scope);
460}
461
462
Note: See TracBrowser for help on using the repository browser.