Merge from vendor branch LESS:
[dragonfly.git] / contrib / bc / dc / stack.c
1 /* 
2  * implement stack functions for dc
3  *
4  * Copyright (C) 1994, 1997, 1998 Free Software Foundation, Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2, or (at your option)
9  * any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, you can either send email to this
18  * program's author (see below) or write to:
19  *
20  *    The Free Software Foundation, Inc.
21  *    59 Temple Place, Suite 330
22  *    Boston, MA 02111 USA
23  */
24
25 /* This module is the only one that knows what stacks (both the
26  * regular evaluation stack and the named register stacks)
27  * look like.
28  */
29
30 #include "config.h"
31
32 #include <stdio.h>
33 #ifdef HAVE_STDLIB_H
34 # include <stdlib.h>
35 #endif
36 #include "dc.h"
37 #include "dc-proto.h"
38 #include "dc-regdef.h"
39
40 /* an oft-used error message: */
41 #define Empty_Stack     fprintf(stderr, "%s: stack empty\n", progname)
42
43
44 /* simple linked-list implementaion suffices: */
45 struct dc_list {
46         dc_data value;
47         struct dc_array *array; /* opaque */
48         struct dc_list *link;
49 };
50 typedef struct dc_list dc_list;
51
52 /* the anonymous evaluation stack */
53 static dc_list *dc_stack=NULL;
54
55 /* the named register stacks */
56 static dc_list *dc_register[DC_REGCOUNT];
57
58 \f
59 /* allocate a new dc_list item */
60 static dc_list *
61 dc_alloc DC_DECLVOID()
62 {
63         dc_list *result;
64
65         result = dc_malloc(sizeof *result);
66         result->value.dc_type = DC_UNINITIALIZED;
67         result->array = NULL;
68         result->link = NULL;
69         return result;
70 }
71
72 \f
73 /* check that there are two numbers on top of the stack,
74  * then call op with the popped numbers.  Construct a dc_data
75  * value from the dc_num returned by op and push it
76  * on the stack.
77  * If the op call doesn't return DC_SUCCESS, then leave the stack
78  * unmodified.
79  */
80 void
81 dc_binop DC_DECLARG((op, kscale))
82         int (*op)DC_PROTO((dc_num, dc_num, int, dc_num *)) DC_DECLSEP
83         int kscale DC_DECLEND
84 {
85         dc_data a;
86         dc_data b;
87         dc_data r;
88
89         if (!dc_stack || !dc_stack->link){
90                 Empty_Stack;
91                 return;
92         }
93         if (dc_stack->value.dc_type!=DC_NUMBER
94                         || dc_stack->link->value.dc_type!=DC_NUMBER){
95                 fprintf(stderr, "%s: non-numeric value\n", progname);
96                 return;
97         }
98         (void)dc_pop(&b);
99         (void)dc_pop(&a);
100         if ((*op)(a.v.number, b.v.number, kscale, &r.v.number) == DC_SUCCESS){
101                 r.dc_type = DC_NUMBER;
102                 dc_push(r);
103                 dc_free_num(&a.v.number);
104                 dc_free_num(&b.v.number);
105         }else{
106                 /* op failed; restore the stack */
107                 dc_push(a);
108                 dc_push(b);
109         }
110 }
111
112 /* check that there are two numbers on top of the stack,
113  * then call op with the popped numbers.  Construct two dc_data
114  * values from the dc_num's returned by op and push them
115  * on the stack.
116  * If the op call doesn't return DC_SUCCESS, then leave the stack
117  * unmodified.
118  */
119 void
120 dc_binop2 DC_DECLARG((op, kscale))
121         int (*op)DC_PROTO((dc_num, dc_num, int, dc_num *, dc_num *)) DC_DECLSEP
122         int kscale DC_DECLEND
123 {
124         dc_data a;
125         dc_data b;
126         dc_data r1;
127         dc_data r2;
128
129         if (!dc_stack || !dc_stack->link){
130                 Empty_Stack;
131                 return;
132         }
133         if (dc_stack->value.dc_type!=DC_NUMBER
134                         || dc_stack->link->value.dc_type!=DC_NUMBER){
135                 fprintf(stderr, "%s: non-numeric value\n", progname);
136                 return;
137         }
138         (void)dc_pop(&b);
139         (void)dc_pop(&a);
140         if ((*op)(a.v.number, b.v.number, kscale,
141                                                                 &r1.v.number, &r2.v.number) == DC_SUCCESS){
142                 r1.dc_type = DC_NUMBER;
143                 dc_push(r1);
144                 r2.dc_type = DC_NUMBER;
145                 dc_push(r2);
146                 dc_free_num(&a.v.number);
147                 dc_free_num(&b.v.number);
148         }else{
149                 /* op failed; restore the stack */
150                 dc_push(a);
151                 dc_push(b);
152         }
153 }
154
155 /* check that there are two numbers on top of the stack,
156  * then call dc_compare with the popped numbers.
157  * Return negative, zero, or positive based on the ordering
158  * of the two numbers.
159  */
160 int
161 dc_cmpop DC_DECLVOID()
162 {
163         int result;
164         dc_data a;
165         dc_data b;
166
167         if (!dc_stack || !dc_stack->link){
168                 Empty_Stack;
169                 return 0;
170         }
171         if (dc_stack->value.dc_type!=DC_NUMBER
172                         || dc_stack->link->value.dc_type!=DC_NUMBER){
173                 fprintf(stderr, "%s: non-numeric value\n", progname);
174                 return 0;
175         }
176         (void)dc_pop(&b);
177         (void)dc_pop(&a);
178         result = dc_compare(b.v.number, a.v.number);
179         dc_free_num(&a.v.number);
180         dc_free_num(&b.v.number);
181         return result;
182 }
183
184 /* check that there are three numbers on top of the stack,
185  * then call op with the popped numbers.  Construct a dc_data
186  * value from the dc_num returned by op and push it
187  * on the stack.
188  * If the op call doesn't return DC_SUCCESS, then leave the stack
189  * unmodified.
190  */
191 void
192 dc_triop DC_DECLARG((op, kscale))
193         int (*op)DC_PROTO((dc_num, dc_num, dc_num, int, dc_num *)) DC_DECLSEP
194         int kscale DC_DECLEND
195 {
196         dc_data a;
197         dc_data b;
198         dc_data c;
199         dc_data r;
200
201         if (!dc_stack || !dc_stack->link || !dc_stack->link->link){
202                 Empty_Stack;
203                 return;
204         }
205         if (dc_stack->value.dc_type!=DC_NUMBER
206                         || dc_stack->link->value.dc_type!=DC_NUMBER
207                         || dc_stack->link->link->value.dc_type!=DC_NUMBER){
208                 fprintf(stderr, "%s: non-numeric value\n", progname);
209                 return;
210         }
211         (void)dc_pop(&c);
212         (void)dc_pop(&b);
213         (void)dc_pop(&a);
214         if ((*op)(a.v.number, b.v.number, c.v.number,
215                                 kscale, &r.v.number) == DC_SUCCESS){
216                 r.dc_type = DC_NUMBER;
217                 dc_push(r);
218                 dc_free_num(&a.v.number);
219                 dc_free_num(&b.v.number);
220                 dc_free_num(&c.v.number);
221         }else{
222                 /* op failed; restore the stack */
223                 dc_push(a);
224                 dc_push(b);
225                 dc_push(c);
226         }
227 }
228
229 \f
230 /* initialize the register stacks to their initial values */
231 void
232 dc_register_init DC_DECLVOID()
233 {
234         int i;
235
236         for (i=0; i<DC_REGCOUNT; ++i)
237                 dc_register[i] = NULL;
238 }
239
240 /* clear the evaluation stack */
241 void
242 dc_clear_stack DC_DECLVOID()
243 {
244         dc_list *n;
245         dc_list *t;
246
247         for (n=dc_stack; n; n=t){
248                 t = n->link;
249                 if (n->value.dc_type == DC_NUMBER)
250                         dc_free_num(&n->value.v.number);
251                 else if (n->value.dc_type == DC_STRING)
252                         dc_free_str(&n->value.v.string);
253                 else
254                         dc_garbage("in stack", -1);
255                 dc_array_free(n->array);
256                 free(n);
257         }
258         dc_stack = NULL;
259 }
260
261 /* push a value onto the evaluation stack */
262 void
263 dc_push DC_DECLARG((value))
264         dc_data value DC_DECLEND
265 {
266         dc_list *n = dc_alloc();
267
268         if (value.dc_type!=DC_NUMBER && value.dc_type!=DC_STRING)
269                 dc_garbage("in data being pushed", -1);
270         n->value = value;
271         n->link = dc_stack;
272         dc_stack = n;
273 }
274
275 /* push a value onto the named register stack */
276 void
277 dc_register_push DC_DECLARG((stackid, value))
278         int stackid DC_DECLSEP
279         dc_data value DC_DECLEND
280 {
281         dc_list *n = dc_alloc();
282
283         stackid = regmap(stackid);
284         n->value = value;
285         n->link = dc_register[stackid];
286         dc_register[stackid] = n;
287 }
288
289 /* set *result to the value on the top of the evaluation stack */
290 /* The caller is responsible for duplicating the value if it
291  * is to be maintained as anything more than a transient identity.
292  *
293  * DC_FAIL is returned if the stack is empty (and *result unchanged),
294  * DC_SUCCESS is returned otherwise
295  */
296 int
297 dc_top_of_stack DC_DECLARG((result))
298         dc_data *result DC_DECLEND
299 {
300         if (!dc_stack){
301                 Empty_Stack;
302                 return DC_FAIL;
303         }
304         if (dc_stack->value.dc_type!=DC_NUMBER
305                         && dc_stack->value.dc_type!=DC_STRING)
306                 dc_garbage("at top of stack", -1);
307         *result = dc_stack->value;
308         return DC_SUCCESS;
309 }
310
311 /* set *result to a dup of the value on the top of the named register stack */
312 /*
313  * DC_FAIL is returned if the named stack is empty (and *result unchanged),
314  * DC_SUCCESS is returned otherwise
315  */
316 int
317 dc_register_get DC_DECLARG((regid, result))
318         int regid DC_DECLSEP
319         dc_data *result DC_DECLEND
320 {
321         dc_list *r;
322
323         regid = regmap(regid);
324         r = dc_register[regid];
325         if ( ! r ){
326                 fprintf(stderr, "%s: register ", progname);
327                 dc_show_id(stderr, regid, " is empty\n");
328                 return DC_FAIL;
329         }
330         *result = dc_dup(r->value);
331         return DC_SUCCESS;
332 }
333
334 /* set the top of the named register stack to the indicated value */
335 /* If the named stack is empty, craft a stack entry to enter the
336  * value into.
337  */
338 void
339 dc_register_set DC_DECLARG((regid, value))
340         int regid DC_DECLSEP
341         dc_data value DC_DECLEND
342 {
343         dc_list *r;
344
345         regid = regmap(regid);
346         r = dc_register[regid];
347         if ( ! r )
348                 dc_register[regid] = dc_alloc();
349         else if (r->value.dc_type == DC_NUMBER)
350                 dc_free_num(&r->value.v.number);
351         else if (r->value.dc_type == DC_STRING)
352                 dc_free_str(&r->value.v.string);
353         else if (r->value.dc_type == DC_UNINITIALIZED)
354                 ;
355         else
356                 dc_garbage("", regid);
357         dc_register[regid]->value = value;
358 }
359
360 /* pop from the evaluation stack
361  *
362  * DC_FAIL is returned if the stack is empty (and *result unchanged),
363  * DC_SUCCESS is returned otherwise
364  */
365 int
366 dc_pop DC_DECLARG((result))
367         dc_data *result DC_DECLEND
368 {
369         dc_list *r;
370
371         r = dc_stack;
372         if (!r){
373                 Empty_Stack;
374                 return DC_FAIL;
375         }
376         if (r->value.dc_type!=DC_NUMBER && r->value.dc_type!=DC_STRING)
377                 dc_garbage("at top of stack", -1);
378         *result = r->value;
379         dc_stack = r->link;
380         dc_array_free(r->array);
381         free(r);
382         return DC_SUCCESS;
383 }
384
385 /* pop from the named register stack
386  *
387  * DC_FAIL is returned if the named stack is empty (and *result unchanged),
388  * DC_SUCCESS is returned otherwise
389  */
390 int
391 dc_register_pop DC_DECLARG((stackid, result))
392         int stackid DC_DECLSEP
393         dc_data *result DC_DECLEND
394 {
395         dc_list *r;
396
397         stackid = regmap(stackid);
398         r = dc_register[stackid];
399         if (!r){
400                 fprintf(stderr, "%s: stack register ", progname);
401                 dc_show_id(stderr, stackid, " is empty\n");
402                 return DC_FAIL;
403         }
404         if (r->value.dc_type!=DC_NUMBER && r->value.dc_type!=DC_STRING)
405                 dc_garbage(" stack", stackid);
406         *result = r->value;
407         dc_register[stackid] = r->link;
408         dc_array_free(r->array);
409         free(r);
410         return DC_SUCCESS;
411 }
412
413 \f
414 /* tell how many entries are currently on the evaluation stack */
415 int
416 dc_tell_stackdepth DC_DECLVOID()
417 {
418         dc_list *n;
419         int depth=0;
420
421         for (n=dc_stack; n; n=n->link)
422                 ++depth;
423         return depth;
424 }
425
426
427 /* return the length of the indicated data value;
428  * if discard_p is DC_TOSS, the deallocate the value when done
429  *
430  * The definition of a datum's length is deligated to the
431  * appropriate module.
432  */
433 int
434 dc_tell_length DC_DECLARG((value, discard_p))
435         dc_data value DC_DECLSEP
436         dc_discard discard_p DC_DECLEND
437 {
438         int length;
439
440         if (value.dc_type == DC_NUMBER){
441                 length = dc_numlen(value.v.number);
442                 if (discard_p == DC_TOSS)
443                         dc_free_num(&value.v.number);
444         } else if (value.dc_type == DC_STRING) {
445                 length = dc_strlen(value.v.string);
446                 if (discard_p == DC_TOSS)
447                         dc_free_str(&value.v.string);
448         } else {
449                 dc_garbage("in tell_length", -1);
450                 /*NOTREACHED*/
451                 length = 0;     /*just to suppress spurious compiler warnings*/
452         }
453         return length;
454 }
455
456 \f
457
458 /* print out all of the values on the evaluation stack */
459 void
460 dc_printall DC_DECLARG((obase))
461         int obase DC_DECLEND
462 {
463         dc_list *n;
464
465         for (n=dc_stack; n; n=n->link)
466                 dc_print(n->value, obase, DC_WITHNL, DC_KEEP);
467 }
468
469 \f
470
471
472 /* get the current array head for the named array */
473 struct dc_array *
474 dc_get_stacked_array DC_DECLARG((array_id))
475         int array_id DC_DECLEND
476 {
477         dc_list *r = dc_register[regmap(array_id)];
478         return r ? r->array : NULL;
479 }
480
481 /* set the current array head for the named array */
482 void
483 dc_set_stacked_array DC_DECLARG((array_id, new_head))
484         int array_id DC_DECLSEP
485         struct dc_array *new_head DC_DECLEND
486 {
487         dc_list *r;
488
489         array_id = regmap(array_id);
490         r = dc_register[array_id];
491         if ( ! r )
492                 r = dc_register[array_id] = dc_alloc();
493         r->array = new_head;
494 }