Debian Codegraph @

builtin.c

raw
1 /*
2 * The Regina Rexx Interpreter
3 * Copyright (C) 1992-1994 Anders Christensen <[email protected]>
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the Free
17 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20 #include "rexx.h"
21 #include <stdlib.h>
22 #include <string.h>
23 #include <math.h>
24 #include <time.h>
25 #include <stdio.h>
26 #include <assert.h>
27 #include <limits.h>
28
29 #ifdef HAVE_UNISTD_H
30 #include <unistd.h>
31 #endif
32
33 #ifdef HAVE_PROCESS_H
34 #include <process.h>
35 #endif
36
37 #ifdef SunKludges
38 double pow( double, double ) ;
39 #endif
40
41 #if defined(HAVE_PUTENV) && defined(FIX_PROTOS) && defined(ultrix)
42 void putenv( char* );
43 #endif
44
45 #define UPPERLETTER(a) ((((a)&0xdf)>='A')&&(((a)&0xdf)<='Z'))
46 #define NUMERIC(a) (((a)>='0')&&((a)<='9'))
47
48 static const char *WeekDays[] = { "Sunday", "Monday", "Tuesday", "Wednesday",
49 "Thursday", "Friday", "Saturday" } ;
50 const char *months[] = { "January", "February", "March", "April", "May",
51 "June", "July", "August", "September", "October",
52 "November", "December" } ;
53
54 struct envirlist {
55 struct envirlist *next ;
56 streng *ptr ;
57 };
58
59 typedef struct { /* bui_tsd: static variables of this module (thread-safe) */
60 struct envirlist * first_envirvar;
61 lineboxptr srcline_ptr; /* std_sourceline() */
62 lineboxptr srcline_first; /* std_sourceline() */
63 int srcline_lineno; /* std_sourceline() */
64 int seed;
65 } bui_tsd_t; /* thread-specific but only needed by this module. see
66 * init_builtin
67 */
68
69 /* init_builtin initializes the module.
70 * Currently, we set up the thread specific data.
71 * The function returns 1 on success, 0 if memory is short.
72 */
73 int init_builtin( tsd_t *TSD )
74 {
75 bui_tsd_t *bt;
76
77 if (TSD->bui_tsd != NULL)
78 return(1);
79
80 if ( ( TSD->bui_tsd = MallocTSD( sizeof(bui_tsd_t) ) ) == NULL )
81 return(0);
82 bt = (bui_tsd_t *)TSD->bui_tsd;
83 memset( bt, 0, sizeof(bui_tsd_t) ); /* correct for all values */
84
85 #if defined(HAVE_RANDOM)
86 srandom((int) (time((time_t *)0)+getpid())%(3600*24)) ;
87 #else
88 srand((unsigned) (time((time_t *)0)+getpid())%(3600*24)) ;
89 #endif
90 return(1);
91 }
92
93 static int contained_in( const char *first, const char *fend, const char *second, const char *send )
94 /*
95 * Determines if one string exists in another string. Search is done
96 * based on words.
97 */
98 {
99 /*
100 * Skip over any leading spaces in the search string
101 */
102 for (; (first<fend)&&(rx_isspace(*first)); first++)
103 {
104 ;
105 }
106 /*
107 * Trim any trailing spaces in the search string
108 */
109 for (; (first<fend)&&(rx_isspace(*(fend-1))); fend--)
110 {
111 ;
112 }
113 /*
114 * Skip over any leading spaces in the searched string
115 */
116 for (; (second<send)&&(rx_isspace(*second)); second++)
117 {
118 ;
119 }
120 /*
121 * Trim any trailing spaces in the searched string
122 */
123 for (; (second<send)&&(rx_isspace(*(send-1))); send--)
124 {
125 ;
126 }
127 /*
128 * If the length of the search string is less than the string to
129 * search we won't find a match
130 */
131 if (fend-first > send-second)
132 return 0;
133
134 for (; (first<fend); )
135 {
136 for (; (first<fend)&&(!rx_isspace(*first)); first++, second++)
137 {
138 if ((*first)!=(*second))
139 return 0 ;
140 }
141
142 if ((second<send)&&(!rx_isspace(*second)))
143 return 0 ;
144
145 if (first==fend)
146 return 1 ;
147
148 for (; (first<fend)&&(rx_isspace(*first)); first++)
149 {
150 ;
151 }
152 for (; (second<send)&&(rx_isspace(*second)); second++)
153 {
154 ;
155 }
156 }
157
158 return 1 ;
159 }
160
161
162 streng *std_wordpos( tsd_t *TSD, cparamboxptr parms )
163 {
164 streng *seek=NULL, *target=NULL ;
165 char *sptr=NULL, *tptr=NULL, *end=NULL, *send=NULL ;
166 int start=1, res=0 ;
167
168 checkparam( parms, 2, 3 , "WORDPOS" ) ;
169 seek = parms->value ;
170 target = parms->next->value ;
171 if ((parms->next->next)&&(parms->next->next->value))
172 start = atopos( TSD, parms->next->next->value, "WORDPOS", 3 ) ;
173
174 end = target->value + Str_len(target) ;
175 /* Then lets position right in the target */
176 for (tptr=target->value; (tptr<end) && rx_isspace(*tptr) ; tptr++) /* FGC: ordered */
177 {
178 ;
179 }
180 for (res=1; (res<start); res++)
181 {
182 for (; (tptr<end)&&(!rx_isspace(*tptr)); tptr++ )
183 {
184 ;
185 }
186 for (; (tptr<end) && rx_isspace(*tptr); tptr++ )
187 {
188 ;
189 }
190 }
191
192 send = seek->value + Str_len(seek) ;
193 for (sptr=seek->value; (sptr<send) && rx_isspace(*sptr); sptr++)
194 {
195 ;
196 }
197 if (sptr<send)
198 {
199 for ( ; (sptr<send)&&(tptr<end); )
200 {
201 if (contained_in( sptr, send, tptr, end ))
202 break ;
203
204 for (; (tptr<end)&&(!rx_isspace(*tptr)); tptr++)
205 {
206 ;
207 }
208 for (; (tptr<end)&&(rx_isspace(*tptr)); tptr++)
209 {
210 ;
211 }
212 res++ ;
213 }
214 }
215 if ((sptr>=send)||((sptr<send)&&(tptr>=end)))
216 res = 0 ;
217
218 return int_to_streng( TSD, res ) ;
219 }
220
221
222 streng *std_wordlength( tsd_t *TSD, cparamboxptr parms )
223 {
224 int i=0, number=0 ;
225 streng *string=NULL ;
226 char *ptr=NULL, *end=NULL ;
227
228 checkparam( parms, 2, 2 , "WORDLENGTH" ) ;
229 string = parms->value ;
230 number = atopos( TSD, parms->next->value, "WORDLENGTH", 2 ) ;
231
232 end = (ptr=string->value) + Str_len(string) ;
233 for (; (ptr<end) && rx_isspace(*ptr); ptr++)
234 {
235 ;
236 }
237 for (i=0; i<number-1; i++)
238 {
239 for (; (ptr<end)&&(!rx_isspace(*ptr)); ptr++)
240 {
241 ;
242 }
243 for (; (ptr<end)&&(rx_isspace(*ptr)); ptr++ )
244 {
245 ;
246 }
247 }
248
249 for (i=0; (((ptr+i)<end)&&(!rx_isspace(*(ptr+i)))); i++)
250 {
251 ;
252 }
253 return (int_to_streng( TSD,i)) ;
254 }
255
256
257
258 streng *std_wordindex( tsd_t *TSD, cparamboxptr parms )
259 {
260 int i=0, number=0 ;
261 streng *string=NULL ;
262 char *ptr=NULL, *end=NULL ;
263
264 checkparam( parms, 2, 2 , "WORDINDEX" ) ;
265 string = parms->value ;
266 number = atopos( TSD, parms->next->value, "WORDINDEX", 2 ) ;
267
268 end = (ptr=string->value) + Str_len(string) ;
269 for (; (ptr<end) && rx_isspace(*ptr); ptr++)
270 {
271 ;
272 }
273 for (i=0; i<number-1; i++)
274 {
275 for (; (ptr<end)&&(!rx_isspace(*ptr)); ptr++)
276 {
277 ;
278 }
279 for (; (ptr<end)&&(rx_isspace(*ptr)); ptr++)
280 {
281 ;
282 }
283 }
284
285 return ( int_to_streng( TSD, (ptr<end) ? (ptr - string->value + 1 ) : 0) ) ;
286 }
287
288
289 streng *std_delword( tsd_t *TSD, cparamboxptr parms )
290 {
291 char *rptr=NULL, *cptr=NULL, *end=NULL ;
292 streng *string=NULL ;
293 int length=(-1), start=0, i=0 ;
294
295 checkparam( parms, 2, 3 , "DELWORD" ) ;
296 string = Str_dupTSD(parms->value) ;
297 start = atopos( TSD, parms->next->value, "DELWORD", 2 ) ;
298 if ((parms->next->next)&&(parms->next->next->value))
299 length = atozpos( TSD, parms->next->next->value, "DELWORD", 3 ) ;
300
301 end = (cptr=string->value) + Str_len(string) ;
302 for (; (cptr<end) && rx_isspace(*cptr); cptr++ )
303 {
304 ;
305 }
306 for (i=0; i<(start-1); i++)
307 {
308 for (; (cptr<end)&&(!rx_isspace(*cptr)); cptr++)
309 {
310 ;
311 }
312 for (; (cptr<end) && rx_isspace(*cptr); cptr++)
313 {
314 ;
315 }
316 }
317
318 rptr = cptr ;
319 for (i=0; (i<(length))||((length==(-1))&&(cptr<end)); i++)
320 {
321 for (; (cptr<end)&&(!rx_isspace(*cptr)); cptr++ )
322 {
323 ;
324 }
325 for (; (cptr<end) && rx_isspace(*cptr); cptr++ )
326 {
327 ;
328 }
329 }
330
331 for (; (cptr<end);)
332 {
333 for (; (cptr<end)&&(!rx_isspace(*cptr)); *(rptr++) = *(cptr++))
334 {
335 ;
336 }
337 for (; (cptr<end) && rx_isspace(*cptr); *(rptr++) = *(cptr++))
338 {
339 ;
340 }
341 }
342
343 string->len = (rptr - string->value) ;
344 return string ;
345 }
346
347
348 streng *std_xrange( tsd_t *TSD, cparamboxptr parms )
349 {
350 int start=0, stop=0xff, i=0, length=0 ;
351 streng *result=NULL ;
352
353 checkparam( parms, 0, 2 , "XRANGE" ) ;
354 if ( parms->value )
355 start = (unsigned char) getonechar( TSD, parms->value, "XRANGE", 1 ) ;
356
357 if ( ( parms->next )
358 && ( parms->next->value ) )
359 stop = (unsigned char) getonechar( TSD, parms->next->value, "XRANGE", 2 ) ;
360
361 length = stop - start + 1 ;
362 if (length<1)
363 length = 256 + length ;
364
365 result = Str_makeTSD( length ) ;
366 for (i=0; (i<length); i++)
367 {
368 if (start==256)
369 start = 0 ;
370 result->value[i] = (char) start++ ;
371 }
372 /* result->value[i] = (char) stop ; */
373 result->len = i ;
374
375 return result ;
376 }
377
378
379 streng *std_lastpos( tsd_t *TSD, cparamboxptr parms )
380 {
381 int res=0, start=0, i=0, j=0, nomore=0 ;
382 streng *needle=NULL, *heystack=NULL ;
383
384 checkparam( parms, 2, 3 , "LASTPOS" ) ;
385 needle = parms->value ;
386 heystack = parms->next->value ;
387 if ((parms->next->next)&&(parms->next->next->value))
388 start = atopos( TSD, parms->next->next->value, "LASTPOS", 3 ) ;
389 else
390 start = Str_len( heystack ) ;
391
392 nomore = Str_len( needle ) ;
393 if (start>Str_len(heystack))
394 start = Str_len( heystack ) ;
395
396 if (nomore>start
397 || nomore==0)
398 res = 0 ;
399 else
400 {
401 for (i=start-nomore ; i>=0; i-- )
402 {
403 /*
404 * FGC: following loop was "<=nomore"
405 */
406 for (j=0; (j<nomore)&&(needle->value[j]==heystack->value[i+j]);j++) ;
407 if (j>=nomore)
408 {
409 res = i + 1 ;
410 break ;
411 }
412 }
413 }
414 return (int_to_streng( TSD,res)) ;
415 }
416
417
418
419 streng *std_pos( tsd_t *TSD, cparamboxptr parms )
420 {
421 int start=1, res=0 ;
422 streng *needle=NULL, *heystack=NULL ;
423 checkparam( parms, 2, 3 , "POS" ) ;
424
425 needle = parms->value ;
426 heystack = parms->next->value ;
427 if ((parms->next->next)&&(parms->next->next->value))
428 start = atopos( TSD, parms->next->next->value, "POS", 3 ) ;
429
430 if ((!needle->len)
431 || (!heystack->len)
432 || (start>heystack->len))
433 res = 0 ;
434 else
435 {
436 res = bmstrstr(heystack, start-1, needle, 0) + 1 ;
437 }
438
439 return (int_to_streng( TSD, res ) ) ;
440 }
441
442
443
444 streng *std_subword( tsd_t *TSD, cparamboxptr parms )
445 {
446 int i=0, length=0, start=0 ;
447 char *cptr=NULL, *eptr=NULL, *cend=NULL ;
448 streng *string=NULL, *result=NULL ;
449
450 checkparam( parms, 2, 3 , "SUBWORD" ) ;
451 string = parms->value ;
452 start = atopos( TSD, parms->next->value, "SUBWORD", 2 ) ;
453 if ((parms->next->next)&&(parms->next->next->value))
454 length = atozpos( TSD, parms->next->next->value, "SUBWORD", 3 ) ;
455 else
456 length = -1 ;
457
458 cptr = string->value ;
459 cend = cptr + Str_len(string) ;
460 for (i=1; i<start; i++)
461 {
462 for ( ; (cptr<cend)&&(rx_isspace(*cptr)); cptr++)
463 {
464 ;
465 }
466 for ( ; (cptr<cend)&&(!rx_isspace(*cptr)); cptr++)
467 {
468 ;
469 }
470 }
471 for ( ; (cptr<cend)&&(rx_isspace(*cptr)); cptr++)
472 {
473 ;
474 }
475
476 eptr = cptr ;
477 if (length>=0)
478 {
479 for( i=0; (i<length); i++ )
480 {
481 for (;(eptr<cend)&&(rx_isspace(*eptr)); eptr++) /* wount hit 1st time */
482 {
483 ;
484 }
485 for (;(eptr<cend)&&(!rx_isspace(*eptr)); eptr++)
486 {
487 ;
488 }
489 }
490 }
491 else
492 eptr = cend;
493
494 /* fixes bug 1113373 */
495 while ((eptr > cptr) && rx_isspace(*(eptr-1)))
496 {
497 eptr--;
498 }
499
500 result = Str_makeTSD( eptr-cptr ) ;
501 memcpy( result->value, cptr, (eptr-cptr) ) ;
502 result->len = (eptr-cptr) ;
503
504 return result ;
505 }
506
507
508
509 streng *std_symbol( tsd_t *TSD, cparamboxptr parms )
510 {
511 int type=0 ;
512
513 checkparam( parms, 1, 1 , "SYMBOL" ) ;
514
515 type = valid_var_symbol( parms->value ) ;
516 if (type==SYMBOL_BAD)
517 return Str_creTSD("BAD") ;
518
519 if ( ( type != SYMBOL_CONSTANT ) && ( type != SYMBOL_NUMBER ) )
520 {
521 assert(type==SYMBOL_STEM||type==SYMBOL_SIMPLE||type==SYMBOL_COMPOUND);
522 if (isvariable(TSD, parms->value))
523 return Str_creTSD("VAR") ;
524 }
525
526 return Str_creTSD("LIT") ;
527 }
528
529
530 #if defined(TRACEMEM)
531 static void mark_envirvars( const tsd_t *TSD )
532 {
533 struct envirlist *ptr=NULL ;
534 bui_tsd_t *bt;
535
536 bt = (bui_tsd_t *) TSD->bui_tsd;
537 for (ptr=bt->first_envirvar; ptr; ptr=ptr->next)
538 {
539 markmemory( ptr, TRC_STATIC ) ;
540 markmemory( ptr->ptr, TRC_STATIC ) ;
541 }
542 }
543
544 static void add_new_env( const tsd_t *TSD, streng *ptr )
545 {
546 struct envirlist *newElem=NULL ;
547 bui_tsd_t *bt;
548
549 bt = (bui_tsd_t *) TSD->bui_tsd;
550 newElem = (struct envirlist *) MallocTSD( sizeof( struct envirlist )) ;
551 newElem->next = bt->first_envirvar ;
552 newElem->ptr = ptr ;
553
554 if (!bt->first_envirvar)
555 regmarker( TSD, mark_envirvars ) ;
556
557 bt->first_envirvar = newElem ;
558 }
559 #endif
560
561 /*
562 * ext_pool_value processes the request of the BIF value() and putenv() for the external
563 * variable pool known as the "environment" in terms of the C library.
564 *
565 * name has to be a '\0'-terminated streng, value is either NULL or the
566 * new content of the variable called name.
567 */
568 streng *ext_pool_value( tsd_t *TSD, streng *name, streng *value,
569 streng *env )
570 {
571 streng *retval=NULL;
572 int ok=HOOK_GO_ON;
573
574 /*
575 * Get the current value from the exit if we have one, or from the
576 * environment directly if not...
577 */
578 if ( TSD->systeminfo->hooks & HOOK_MASK( HOOK_GETENV ) )
579 ok = hookup_input_output( TSD, HOOK_GETENV, name, &retval );
580
581 #ifdef VMS
582 if ( ok == HOOK_GO_ON )
583 {
584 /*
585 * Either there was no exit handler, or the exit handler didn't
586 * handle the GETENV. Get the environment variable directly from
587 * the system.
588 */
589 retval = vms_resolv_symbol( TSD, name, value, env );
590 }
591 else if ( value )
592 exiterror( ERR_SYSTEM_FAILURE, 1, "No support for setting an environment variable" );
593 /*
594 * FIXME: What happens if value is set and HOOK_GO_ON isn't set?
595 * What happens with the different Pools SYMBOL, SYSTEM, LOGICAL?
596 */
597 return retval;
598 #else
599 if ( ok == HOOK_GO_ON )
600 {
601 char *val = mygetenv( TSD, name->value, NULL, 0 );
602 if ( val )
603 {
604 retval = Str_creTSD( val );
605 FreeTSD( val );
606 }
607 }
608
609 /*
610 * retval is prepared. Check for setting a new value.
611 */
612 if ( value )
613 {
614 /*
615 * We are setting a value in the external environment
616 */
617
618 if ( TSD->restricted )
619 exiterror( ERR_RESTRICTED, 2, "VALUE", 2 );
620
621 if ( TSD->systeminfo->hooks & HOOK_MASK( HOOK_SETENV ) )
622 ok = hookup_output2( TSD, HOOK_SETENV, name, value );
623
624 if ( ok == HOOK_GO_ON )
625 {
626 # if defined(HAVE_MY_WIN32_SETENV)
627 streng *strvalue = Str_dupstrTSD( value );
628
629 TSD->OS->setenv_exec(name->value, strvalue->value );
630 Free_stringTSD( strvalue );
631 # elif defined(HAVE_SETENV)
632 streng *strvalue = Str_dupstrTSD( value );
633
634 setenv(name->value, strvalue->value, 1 );
635 Free_stringTSD( strvalue );
636 # elif defined(HAVE_PUTENV)
637 /*
638 * Note: we don't release the allocated memory, because the runtime
639 * system might use the pointer itself, not the content.
640 * (See glibc's documentation)
641 */
642 streng *newstr = Str_makeTSD( Str_len( name ) + Str_len( value ) + 2 );
643
644 Str_catTSD( newstr, name );
645 Str_catstrTSD( newstr, "=" );
646 Str_catTSD( newstr, value );
647 newstr->value[Str_len(newstr)] = '\0';
648
649 putenv( newstr->value );
650 # ifdef TRACEMEM
651 add_new_env( TSD, newstr );
652 # endif
653 # else
654 exiterror( ERR_SYSTEM_FAILURE, 1, "No support for setting an environment variable" );
655 # endif /* HAVE_PUTENV */
656 }
657 }
658
659 return retval;
660 #endif /* !VMS */
661 }
662
663 /*
664 * FGC, 07.04.2005
665 * FIXME: We are not throwing 40.36, but I'm not sure we should at all.
666 */
667 streng *std_value( tsd_t *TSD, cparamboxptr parms )
668 {
669 streng *name,*retval;
670 streng *value=NULL,*env=NULL;
671 int i,err,pool=-1,ext_pool=0;
672
673 checkparam( parms, 1, 3 , "VALUE" );
674 name = Str_dupstrTSD( parms->value );
675
676 if ( parms->next )
677 {
678 value = parms->next->value;
679 if ( parms->next->next )
680 env = parms->next->next->value;
681 }
682
683 if ( env )
684 {
685 i = Str_len( env );
686 if ( ( ( i == 6 ) && ( memcmp( env->value, "SYSTEM", 6 ) == 0 ) )
687 || ( ( i == 14 ) && ( memcmp( env->value, "OS2ENVIRONMENT", 14 ) == 0 ) )
688 || ( ( i == 11 ) && ( memcmp( env->value, "ENVIRONMENT", 11 ) == 0 ) ) )
689 {
690 ext_pool = 1;
691 }
692 else if ( ( i == 6 ) && ( memcmp( env->value, "CALLER", 6) == 0 ) )
693 {
694 pool = TSD->currlevel->pool - 1;
695 }
696 else
697 {
698 pool = streng_to_int( TSD, env, &err );
699 /*
700 * Accept a builtin pool if it is a number >= 0.
701 */
702 if ( pool < 0 )
703 err = 1;
704 if ( pool > TSD->currlevel->pool )
705 err = 1;
706 if ( err )
707 exiterror( ERR_INCORRECT_CALL, 37, "VALUE", tmpstr_of( TSD, env ) );
708 }
709
710 if ( ext_pool == 1 )
711 {
712 /*
713 * Use external environment
714 */
715 retval = ext_pool_value( TSD, name, value, env );
716 Free_stringTSD( name );
717 if ( retval == NULL )
718 retval = nullstringptr();
719
720 return retval;
721 }
722 }
723
724 /*
725 * Internal variable pool; ie Rexx variables. According to ANSI standard
726 * need to uppercase the variable name first.
727 */
728 if ( !valid_var_symbol( name ) )
729 {
730 Free_stringTSD( name );
731 exiterror( ERR_INCORRECT_CALL, 26, "VALUE", tmpstr_of( TSD, parms->value ) );
732 }
733
734 Str_upper( name );
735 retval = Str_dupTSD( get_it_anyway( TSD, name, pool ) );
736 if ( value )
737 setvalue( TSD, name, Str_dupTSD( value ), pool );
738 Free_stringTSD( name );
739
740 return retval;
741 }
742
743
744 streng *std_abs( tsd_t *TSD, cparamboxptr parms )
745 {
746 checkparam( parms, 1, 1 , "ABS" ) ;
747 return str_abs( TSD, parms->value ) ;
748 }
749
750
751 streng *std_condition( tsd_t *TSD, cparamboxptr parms )
752 {
753 char opt='I' ;
754 streng *result=NULL ;
755 sigtype *sig=NULL ;
756 trap *traps=NULL ;
757 char buf[20];
758
759 checkparam( parms, 0, 1 , "CONDITION" ) ;
760
761 if (parms&&parms->value)
762 opt = getoptionchar( TSD, parms->value, "CONDITION", 1, "CEIDS", "" ) ;
763
764 result = NULL ;
765 sig = getsigs(TSD->currlevel) ;
766 if (sig)
767 switch (opt)
768 {
769 case 'C':
770 result = Str_creTSD( signalnames[sig->type] ) ;
771 break ;
772
773 case 'I':
774 result = Str_creTSD( (sig->invoke) ? "SIGNAL" : "CALL" ) ;
775 break ;
776
777 case 'D':
778 if (sig->descr)
779 result = Str_dupTSD( sig->descr ) ;
780 break ;
781
782 case 'E':
783 if (sig->subrc)
784 sprintf(buf, "%d.%d", sig->rc, sig->subrc );
785 else
786 sprintf(buf, "%d", sig->rc );
787 result = Str_creTSD( buf ) ;
788 break ;
789
790 case 'S':
791 traps = gettraps( TSD, TSD->currlevel ) ;
792 if (traps[sig->type].delayed)
793 result = Str_creTSD( "DELAY" ) ;
794 else
795 result = Str_creTSD( (traps[sig->type].on_off) ? "ON" : "OFF" ) ;
796 break ;
797
798 default:
799 /* should not get here */
800 break;
801 }
802
803 if (!result)
804 result = nullstringptr() ;
805
806 return result ;
807 }
808
809
810 streng *std_format( tsd_t *TSD, cparamboxptr parms )
811 {
812 streng *number=NULL ;
813 int before=(-1), after=(-1) ;
814 int esize=(-1), trigger=(-1) ;
815 cparamboxptr ptr ;
816
817 checkparam( parms, 1, 5, "FORMAT" ) ;
818 number = (ptr=parms)->value ;
819
820 if ((ptr) && ((ptr=ptr->next)!=NULL) && (ptr->value))
821 before = atozpos( TSD, ptr->value, "FORMAT", 2 ) ;
822
823 if ((ptr) && ((ptr=ptr->next)!=NULL) && (ptr->value))
824 after = atozpos( TSD, ptr->value, "FORMAT", 3 ) ;
825
826 if ((ptr) && ((ptr=ptr->next)!=NULL) && (ptr->value))
827 esize = atozpos( TSD, ptr->value, "FORMAT", 4 ) ;
828
829 if ((ptr) && ((ptr=ptr->next)!=NULL) && (ptr->value))
830 trigger = atozpos( TSD, ptr->value, "FORMAT", 5 ) ;
831
832 return str_format( TSD, number, before, after, esize, trigger ) ;
833 }
834
835
836
837 streng *std_overlay( tsd_t *TSD, cparamboxptr parms )
838 {
839 streng *newstr=NULL, *oldstr=NULL, *retval=NULL ;
840 char padch=' ' ;
841 int length=0, spot=0, oldlen=0, i=0, j=0, k=0 ;
842 paramboxptr tmpptr=NULL ;
843
844 checkparam( parms, 2, 5, "OVERLAY" ) ;
845 newstr = parms->value ;
846 oldstr = parms->next->value ;
847 length = Str_len(newstr) ;
848 oldlen = Str_len(oldstr) ;
849 if (parms->next->next)
850 {
851 tmpptr = parms->next->next ;
852 if (parms->next->next->value)
853 spot = atopos( TSD, tmpptr->value, "OVERLAY", 3 ) ;
854
855 if (tmpptr->next)
856 {
857 tmpptr = tmpptr->next ;
858 if (tmpptr->value)
859 length = atozpos( TSD, tmpptr->value, "OVERLAY", 4 ) ;
860 if ((tmpptr->next)&&(tmpptr->next->value))
861 padch = getonechar( TSD, tmpptr->next->value, "OVERLAY", 5 ) ;
862 }
863 }
864
865 retval = Str_makeTSD(((spot+length-1>oldlen)?spot+length-1:oldlen)) ;
866 for (j=i=0;(i<spot-1)&&(i<oldlen);retval->value[j++]=oldstr->value[i++]) ;
867 for (;j<spot-1;retval->value[j++]=padch) ;
868 for (k=0;(k<length)&&(Str_in(newstr,k));retval->value[j++]=newstr->value[k++])
869 if (i<oldlen) i++ ;
870
871 for (;k++<length;retval->value[j++]=padch) if (oldlen>i) i++ ;
872 for (;oldlen>i;retval->value[j++]=oldstr->value[i++]) ;
873
874 retval->len = j ;
875 return retval ;
876 }
877
878 streng *std_insert( tsd_t *TSD, cparamboxptr parms )
879 {
880 streng *newstr=NULL, *oldstr=NULL, *retval=NULL ;
881 char padch=' ' ;
882 int length=0, spot=0, oldlen=0, i=0, j=0, k=0 ;
883 paramboxptr tmpptr=NULL ;
884
885 checkparam( parms, 2, 5, "INSERT" ) ;
886 newstr = parms->value ;
887 oldstr = parms->next->value ;
888 length = Str_len(newstr) ;
889 oldlen = Str_len(oldstr) ;
890 if (parms->next->next)
891 {
892 tmpptr = parms->next->next ;
893 if (parms->next->next->value)
894 spot = atozpos( TSD, tmpptr->value, "INSERT", 3 ) ;
895
896 if (tmpptr->next)
897 {
898 tmpptr = tmpptr->next ;
899 if (tmpptr->value)
900 length = atozpos( TSD, tmpptr->value, "INSERT", 4 ) ;
901 if ((tmpptr->next)&&(tmpptr->next->value))
902 padch = getonechar( TSD, tmpptr->next->value, "INSERT", 5) ;
903 }
904 }
905
906 retval = Str_makeTSD(length+((spot>oldlen)?spot:oldlen)) ;
907 for (j=i=0;(i<spot)&&(oldlen>i);retval->value[j++]=oldstr->value[i++]) ;
908 for (;j<spot;retval->value[j++]=padch) ;
909 for (k=0;(k<length)&&(Str_in(newstr,k));retval->value[j++]=newstr->value[k++]) ;
910 for (;k++<length;retval->value[j++]=padch) ;
911 for (;oldlen>i;retval->value[j++]=oldstr->value[i++]) ;
912 retval->len = j ;
913 return retval ;
914 }
915
916
917
918 streng *std_time( tsd_t *TSD, cparamboxptr parms )
919 {
920 int hour=0 ;
921 time_t unow=0, now=0, rnow=0 ;
922 long usec=0L, sec=0L, timediff=0L ;
923 char *ampm=NULL ;
924 char format='N' ;
925 #ifdef __CHECKER__
926 /* Fix a bug by checker: */
927 streng *answer=Str_makeTSD( 64 ) ;
928 #else
929 streng *answer=Str_makeTSD( 50 ) ;
930 #endif
931 streng *supptime=NULL;
932 streng *str_suppformat=NULL;
933 char suppformat = 'N' ;
934 paramboxptr tmpptr=NULL;
935 struct tm tmdata, *tmptr ;
936
937 checkparam( parms, 0, 3 , "TIME" ) ;
938 if ((parms)&&(parms->value))
939 format = getoptionchar( TSD, parms->value, "TIME", 1, "CEHLMNORS", "JT" ) ;
940
941 if (parms->next)
942 {
943 tmpptr = parms->next ;
944 if (parms->next->value)
945 supptime = tmpptr->value ;
946
947 if (tmpptr->next)
948 {
949 tmpptr = tmpptr->next ;
950 if (tmpptr->value)
951 {
952 str_suppformat = tmpptr->value;
953 suppformat = getoptionchar( TSD, tmpptr->value, "TIME", 3, "CHLMNS", "T" ) ;
954 }
955 }
956 else
957 {
958 suppformat = 'N';
959 }
960 }
961
962 if (TSD->currentnode->now)
963 {
964 now = TSD->currentnode->now->sec ;
965 unow = TSD->currentnode->now->usec ;
966 }
967 else
968 {
969 getsecs(&now, &unow) ;
970 TSD->currentnode->now = (rexx_time *)MallocTSD( sizeof( rexx_time ) ) ;
971 TSD->currentnode->now->sec = now ;
972 TSD->currentnode->now->usec = unow ;
973 }
974
975 rnow = now ;
976
977 if (unow>=(500*1000)
978 && format != 'L')
979 now ++ ;
980
981
982 if ((tmptr = localtime(&now)) != NULL)
983 tmdata = *tmptr;
984 else
985 memset(&tmdata,0,sizeof(tmdata)); /* what shall we do in this case? */
986
987 if (supptime) /* time conversion required */
988 {
989 if (convert_time(TSD,supptime,suppformat,&tmdata,&unow))
990 {
991 char *p1, *p2;
992 if (supptime && supptime->len)
993 p1 = (char *) tmpstr_of( TSD, supptime ) ;
994 else
995 p1 = "";
996 if (str_suppformat && str_suppformat->len)
997 p2 = (char *) tmpstr_of( TSD, str_suppformat ) ;
998 else
999 p2 = "N";
1000 exiterror( ERR_INCORRECT_CALL, 19, "TIME", p1, p2 ) ;
1001 }
1002 }
1003
1004 switch (format)
1005 {
1006 case 'C':
1007 hour = tmdata.tm_hour ;
1008 ampm = (char *)( ( hour > 11 ) ? "pm" : "am" ) ;
1009 if ((hour=hour%12)==0)
1010 hour = 12 ;
1011 answer->len = sprintf( answer->value, "%d:%02d%s", hour, tmdata.tm_min, ampm );
1012 break ;
1013
1014 case 'E':
1015 case 'R':
1016 sec = (long)((TSD->currlevel->rx_time.sec) ? rnow-TSD->currlevel->rx_time.sec : 0) ;
1017 usec = (long)((TSD->currlevel->rx_time.sec) ? unow-TSD->currlevel->rx_time.usec : 0) ;
1018
1019 if (usec<0)
1020 {
1021 usec += 1000000 ;
1022 sec-- ;
1023 }
1024
1025 /* assert( usec>=0 && sec>=0 ) ; */
1026 if (!TSD->currlevel->rx_time.sec || format=='R')
1027 {
1028 TSD->currlevel->rx_time.sec = rnow ;
1029 TSD->currlevel->rx_time.usec = unow ;
1030 }
1031
1032 /*
1033 * We have to cast these since time_t can be 'any' type, and
1034 * the format specifier can not be set to correspond with time_t,
1035 * then be have to convert it. Besides, we use unsigned format
1036 * in order not to generate any illegal numbers
1037 */
1038 if (sec)
1039 answer->len = sprintf( answer->value,"%ld.%06lu", (long)sec, (unsigned long)usec );
1040 else
1041 answer->len = sprintf( answer->value,"0.%06lu", (unsigned long)usec );
1042 break ;
1043
1044 case 'H':
1045 answer->len = sprintf( answer->value, "%d", tmdata.tm_hour );
1046 break ;
1047
1048 case 'J':
1049 answer->len = sprintf( answer->value, "%.06f", cpu_time() );
1050 break ;
1051
1052 case 'L':
1053 answer->len = sprintf(answer->value, "%02d:%02d:%02d.%06ld", tmdata.tm_hour, tmdata.tm_min, tmdata.tm_sec, unow );
1054 break ;
1055
1056 case 'M':
1057 answer->len = sprintf(answer->value, "%d", tmdata.tm_hour*60 + tmdata.tm_min);
1058 break ;
1059
1060 case 'N':
1061 answer->len = sprintf(answer->value, "%02d:%02d:%02d", tmdata.tm_hour, tmdata.tm_min, tmdata.tm_sec );
1062 break ;
1063
1064 case 'O':
1065 #ifdef VMS
1066 timediff = mktime(localtime(&now));
1067 #else
1068 timediff = (long)(mktime(localtime(&now))-mktime(gmtime(&now)));
1069 tmptr = localtime(&now);
1070 # if !defined(WIN32)
1071 /* Windows already includes the daylight savings hour in localtime() */
1072 /* Bug #450 - change suggested by Stefan Haubenthal */
1073 if ( tmptr->tm_isdst )
1074 timediff += 3600;
1075 # endif
1076 #endif
1077 answer->len = sprintf( answer->value, "%ld%s", timediff,(timediff)?"000000":"" );
1078 break ;
1079
1080 case 'S':
1081 answer->len = sprintf(answer->value, "%d", (((tmdata.tm_hour*60)+tmdata.tm_min) * 60) + tmdata.tm_sec);
1082 break ;
1083
1084 case 'T':
1085 rnow = mktime( &tmdata );
1086 answer->len = sprintf(answer->value, "%ld", rnow );
1087 break ;
1088
1089 default:
1090 /* should not get here */
1091 break;
1092 }
1093 return answer ;
1094 }
1095
1096 streng *std_date( tsd_t *TSD, cparamboxptr parms )
1097 {
1098 static const char *fmt = "%02d%c%02d%c%02d" ;
1099 static const char *fmt1 = "%02d%02d%02d" ;
1100 static const char *sdate = "%04d%c%02d%c%02d" ;
1101 static const char *sdate1 = "%04d%02d%02d" ;
1102 static const char *iso = "%04d%c%02d%c%02d" ;
1103 static const char *iso1 = "%04d%02d%02d" ;
1104 static const char *ndate = "%d%c%c%c%c%c%4d" ;
1105 static const char *ndate1 = "%d%c%c%c%4d" ;
1106 char format = 'N' ;
1107 char suppformat = 'N' ;
1108 int length=0,rcode=0 ;
1109 const char *chptr=NULL ;
1110 streng *answer=Str_makeTSD( 50 ) ;
1111 paramboxptr tmpptr=NULL;
1112 streng *suppdate=NULL;
1113 streng *str_suppformat=NULL;
1114 struct tm tmdata, *tmptr ;
1115 time_t now=0, unow=0, rnow=0 ;
1116 char osep = '?', isep = '?';
1117
1118 if ( get_options_flag( TSD->currlevel, EXT_STRICT_ANSI ) )
1119 checkparam( parms, 0, 3 , "DATE" ) ;
1120 else
1121 checkparam( parms, 0, 5 , "DATE" ) ;
1122 /* check first argument; output format of date */
1123 if ((parms)&&(parms->value))
1124 format = getoptionchar( TSD, parms->value, "DATE", 1, "BDEMNOSUW", "CIT" ) ;
1125
1126 tmpptr = parms->next ;
1127 if (tmpptr)
1128 {
1129 /* we will be doing a conversion */
1130 if (tmpptr->value)
1131 suppdate = tmpptr->value ;
1132 tmpptr = tmpptr->next ;
1133 if (tmpptr)
1134 {
1135 /* format of suppdate; input date */
1136 if (tmpptr->value)
1137 {
1138 str_suppformat = tmpptr->value;
1139 suppformat = getoptionchar( TSD, tmpptr->value, "DATE", 3, "BDENOSU", "IT" ) ;
1140 }
1141 tmpptr = tmpptr->next ;
1142 if (tmpptr)
1143 {
1144 /* this arg is the output separator */
1145 if (tmpptr->value)
1146 {
1147 if ( Str_len( tmpptr->value ) == 0 )
1148 osep = '\0';
1149 else
1150 osep = getonespecialchar( TSD, tmpptr->value, "DATE", 4 ) ;
1151 if ( !(format == 'E' || format == 'N' || format == 'O' || format == 'S' || format == 'U' || format == 'I') )
1152 exiterror( ERR_INCORRECT_CALL, 44, "DATE", 2, tmpstr_of( TSD, suppdate ), 4 ) ;
1153 }
1154 tmpptr = tmpptr->next ;
1155 if (tmpptr)
1156 {
1157 /* this arg is the input separator */
1158 if (tmpptr->value)
1159 {
1160 if ( Str_len( tmpptr->value ) == 0 )
1161 isep = '\0';
1162 else
1163 isep = getonespecialchar( TSD, tmpptr->value, "DATE", 5 ) ;
1164 if ( !(suppformat == 'E' || suppformat == 'N' || suppformat == 'O' || suppformat == 'S' || suppformat == 'U' || suppformat == 'I') )
1165 exiterror( ERR_INCORRECT_CALL, 44, "DATE", 2, tmpstr_of( TSD, suppdate ), 5 ) ;
1166 }
1167 }
1168 }
1169 }
1170 }
1171 if ( isep == '?' )
1172 {
1173 /* set default input separator */
1174 switch( suppformat )
1175 {
1176 case 'E':
1177 case 'O':
1178 case 'U':
1179 isep = '/';
1180 break;
1181 case 'S':
1182 isep = '\0';
1183 break;
1184 case 'I':
1185 isep = '-';
1186 break;
1187 case 'N':
1188 isep = ' ';
1189 break;
1190 }
1191 }
1192 if ( osep == '?' )
1193 {
1194 /* set default output separator */
1195 switch( format )
1196 {
1197 case 'E':
1198 case 'O':
1199 case 'U':
1200 osep = '/';
1201 break;
1202 case 'S':
1203 osep = '\0';
1204 break;
1205 case 'I':
1206 osep = '-';
1207 break;
1208 case 'N':
1209 osep = ' ';
1210 break;
1211 }
1212 }
1213 /* get the current time for the clause */
1214 if (TSD->currentnode->now)
1215 {
1216 now = TSD->currentnode->now->sec ;
1217 unow = TSD->currentnode->now->usec ;
1218 }
1219 else
1220 {
1221 getsecs(&now, &unow) ;
1222 TSD->currentnode->now = (rexx_time *)MallocTSD( sizeof( rexx_time ) ) ;
1223 TSD->currentnode->now->sec = now ;
1224 TSD->currentnode->now->usec = unow ;
1225 }
1226
1227 /*
1228 * MH - 3/3/2000
1229 * This should not be rounded up for dates. If this were
1230 * run at 11:59:59.500001 on 10 Jun, DATE would report back
1231 * 11 Jun!
1232 if (unow>=(500*1000))
1233 now ++ ;
1234 */
1235
1236 /* get current time in case we are not doing a conversion */
1237 if ( ( tmptr = localtime( &now ) ) != NULL )
1238 tmdata = *tmptr;
1239 else
1240 memset( &tmdata, 0, sizeof( tmdata ) ); /* what shall we do in this case? */
1241 tmdata.tm_year += 1900;
1242
1243 if ( suppdate )
1244 {
1245 /* date conversion of input date required */
1246 if ( ( rcode = convert_date( TSD, suppdate, suppformat, &tmdata, isep ) ) )
1247 {
1248 char *p1, *p2;
1249 if (suppdate && suppdate->len)
1250 p1 = (char *) tmpstr_of( TSD, suppdate ) ;
1251 else
1252 p1 = "";
1253 if (str_suppformat && str_suppformat->len)
1254 p2 = (char *) tmpstr_of( TSD, str_suppformat ) ;
1255 else
1256 p2 = "N";
1257 if ( rcode == 1 )
1258 exiterror( ERR_INCORRECT_CALL, 19, "DATE", p1, p2 ) ;
1259 else
1260 exiterror( ERR_INCORRECT_CALL, 44, "DATE", 2, p1, 5 ) ;
1261 }
1262 /*
1263 * Check for crazy years...
1264 */
1265 if ( tmdata.tm_year < 0 || tmdata.tm_year > 9999 )
1266 exiterror( ERR_INCORRECT_CALL, 18, "DATE" ) ;
1267 }
1268
1269 switch (format)
1270 {
1271 case 'B':
1272 answer->len = sprintf( answer->value, "%d", tmdata.tm_yday + basedays( tmdata.tm_year ) );
1273 break ;
1274
1275 case 'C':
1276 length = tmdata.tm_yday + basedays(tmdata.tm_year); /* was +1 */
1277 answer->len = sprintf( answer->value, "%d", length-basedays( (tmdata.tm_year/100)*100)+1 ); /* bja */
1278 break ;
1279 case 'D':
1280 answer->len = sprintf( answer->value, "%d", tmdata.tm_yday + 1 );
1281 break ;
1282
1283 case 'E':
1284 if ( osep == '\0' )
1285 answer->len = sprintf( answer->value, fmt1, tmdata.tm_mday, tmdata.tm_mon+1, tmdata.tm_year%100 );
1286 else
1287 answer->len = sprintf( answer->value, fmt, tmdata.tm_mday, osep, tmdata.tm_mon+1, osep, tmdata.tm_year%100 );
1288 break ;
1289
1290 case 'I':
1291 if ( osep == '\0' )
1292 answer->len = sprintf( answer->value, iso1, tmdata.tm_year, tmdata.tm_mon+1, tmdata.tm_mday );
1293 else
1294 answer->len = sprintf( answer->value, iso, tmdata.tm_year, osep, tmdata.tm_mon+1, osep, tmdata.tm_mday );
1295 break ;
1296
1297 case 'M':
1298 chptr = months[tmdata.tm_mon] ;
1299 answer->len = strlen( chptr );
1300 memcpy( answer->value, chptr, answer->len ) ;
1301 break ;
1302
1303 case 'N':
1304 chptr = months[tmdata.tm_mon] ;
1305 if ( osep == '\0' )
1306 answer->len = sprintf( answer->value, ndate1, tmdata.tm_mday, chptr[0], chptr[1], chptr[2], tmdata.tm_year );
1307 else
1308 answer->len = sprintf( answer->value, ndate, tmdata.tm_mday, osep, chptr[0], chptr[1], chptr[2], osep, tmdata.tm_year );
1309 break ;
1310
1311 case 'O':
1312 if ( osep == '\0' )
1313 answer->len = sprintf( answer->value, fmt1, tmdata.tm_year%100, tmdata.tm_mon+1, tmdata.tm_mday );
1314 else
1315 answer->len = sprintf( answer->value, fmt, tmdata.tm_year%100, osep, tmdata.tm_mon+1, osep, tmdata.tm_mday );
1316 break ;
1317
1318 case 'S':
1319 if ( osep == '\0' )
1320 answer->len = sprintf(answer->value, sdate1, tmdata.tm_year, tmdata.tm_mon+1, tmdata.tm_mday );
1321 else
1322 answer->len = sprintf(answer->value, sdate, tmdata.tm_year, osep, tmdata.tm_mon+1, osep, tmdata.tm_mday );
1323 break ;
1324
1325 case 'T':
1326 tmdata.tm_year -= 1900;
1327 rnow = mktime( &tmdata );
1328 answer->len = sprintf(answer->value, "%ld", rnow );
1329 break ;
1330
1331 case 'U':
1332 if ( osep == '\0' )
1333 answer->len = sprintf( answer->value, fmt1, tmdata.tm_mon+1, tmdata.tm_mday, tmdata.tm_year%100 );
1334 else
1335 answer->len = sprintf( answer->value, fmt, tmdata.tm_mon+1, osep, tmdata.tm_mday, osep, tmdata.tm_year%100 );
1336 break ;
1337
1338 case 'W':
1339 chptr = WeekDays[tmdata.tm_wday] ;
1340 answer->len = strlen(chptr);
1341 memcpy(answer->value, chptr, answer->len) ;
1342 break ;
1343
1344 default:
1345 /* should not get here */
1346 break;
1347 }
1348
1349 return ( answer );
1350 }
1351
1352
1353 streng *std_words( tsd_t *TSD, cparamboxptr parms )
1354 {
1355 int space=0, i=0, j=0 ;
1356 streng *string=NULL ;
1357 int send=0 ;
1358
1359 checkparam( parms, 1, 1 , "WORDS" ) ;
1360 string = parms->value ;
1361
1362 send = Str_len(string) ;
1363 space = 1 ;
1364 for (i=j=0;send>i;i++) {
1365 if ((!space)&&(rx_isspace(string->value[i]))) j++ ;
1366 space = (rx_isspace(string->value[i])) ; }
1367
1368 if ((!space)&&(i>0)) j++ ;
1369 return( int_to_streng( TSD, j ) ) ;
1370 }
1371
1372
1373 streng *std_word( tsd_t *TSD, cparamboxptr parms )
1374 {
1375 streng *string=NULL, *result=NULL ;
1376 int i=0, j=0, finished=0, start=0, stop=0, number=0, space=0, slen=0 ;
1377
1378 checkparam( parms, 2, 2 , "WORD" ) ;
1379 string = parms->value ;
1380 number = atopos( TSD, parms->next->value, "WORD", 2 ) ;
1381
1382 start = 0 ;
1383 stop = 0 ;
1384 finished = 0 ;
1385 space = 1 ;
1386 slen = Str_len(string) ;
1387 for (i=j=0;(slen>i)&&(!finished);i++)
1388 {
1389 if ((space)&&(!rx_isspace(string->value[i])))
1390 start = i ;
1391 if ((!space)&&(rx_isspace(string->value[i])))
1392 {
1393 stop = i ;
1394 finished = (++j==number) ;
1395 }
1396 space = (rx_isspace(string->value[i])) ;
1397 }
1398
1399 if ((!finished)&&(((number==j+1)&&(!space)) || ((number==j)&&(space))))
1400 {
1401 stop = i ;
1402 finished = 1 ;
1403 }
1404
1405 if (finished)
1406 {
1407 result = Str_makeTSD(stop-start) ; /* problems with length */
1408 result = Str_nocatTSD( result, string, stop-start, start) ;
1409 result->len = stop-start ;
1410 }
1411 else
1412 result = nullstringptr() ;
1413
1414 return result ;
1415 }
1416
1417
1418
1419
1420
1421 streng *std_address( tsd_t *TSD, cparamboxptr parms )
1422 {
1423 char opt = 'N';
1424
1425 checkparam( parms, 0, 1 , "ADDRESS" ) ;
1426
1427 if ( parms && parms->value )
1428 opt = getoptionchar( TSD, parms->value, "ADDRESS", 1, "EINO", "" ) ;
1429
1430 update_envirs( TSD, TSD->currlevel ) ;
1431 if ( opt == 'N' )
1432 return Str_dupTSD( TSD->currlevel->environment ) ;
1433 else
1434 {
1435 return get_envir_details( TSD, opt, TSD->currlevel->environment );
1436 }
1437 }
1438
1439
1440 streng *std_digits( tsd_t *TSD, cparamboxptr parms )
1441 {
1442 checkparam( parms, 0, 0 , "DIGITS" ) ;
1443 return int_to_streng( TSD, TSD->currlevel->currnumsize ) ;
1444 }
1445
1446
1447 streng *std_form( tsd_t *TSD, cparamboxptr parms )
1448 {
1449 checkparam( parms, 0, 0 , "FORM" ) ;
1450 return Str_creTSD( numeric_forms[TSD->currlevel->numform] ) ;
1451 }
1452
1453
1454 streng *std_fuzz( tsd_t *TSD, cparamboxptr parms )
1455 {
1456 checkparam( parms, 0, 0 , "FUZZ" ) ;
1457 return int_to_streng( TSD, TSD->currlevel->numfuzz ) ;
1458 }
1459
1460
1461 streng *std_abbrev( tsd_t *TSD, cparamboxptr parms )
1462 {
1463 int length=0, answer=0, i=0 ;
1464 streng *longstr=NULL, *shortstr=NULL ;
1465
1466 checkparam( parms, 2, 3 , "ABBREV" ) ;
1467 longstr = parms->value ;
1468 shortstr = parms->next->value ;
1469
1470 if ((parms->next->next)&&(parms->next->next->value))
1471 length = atozpos( TSD, parms->next->next->value, "ABBREV", 3 ) ;
1472 else
1473 length = Str_len(shortstr) ;
1474
1475 answer = (Str_ncmp(shortstr,longstr,length)) ? 0 : 1 ;
1476
1477 if ((length>Str_len(shortstr))||(Str_len(shortstr)>Str_len(longstr)))
1478 answer = 0 ;
1479 else
1480 {
1481 for (i=length; i<Str_len(shortstr); i++)
1482 if (shortstr->value[i] != longstr->value[i])
1483 answer = 0 ;
1484 }
1485
1486 return int_to_streng( TSD, answer ) ;
1487 }
1488
1489
1490 streng *std_qualify( tsd_t *TSD, cparamboxptr parms )
1491 {
1492 streng *ret=NULL;
1493
1494 checkparam( parms, 1, 1 , "QUALIFY" ) ;
1495 ret = ConfigStreamQualified( TSD, parms->value );
1496 /*
1497 * Returned streng is always MAX_PATH long, so it should be safe
1498 * to Nul terminate the ret->value
1499 */
1500 ret->value[ret->len] = '\0';
1501 return (ret) ;
1502 }
1503
1504 streng *std_queued( tsd_t *TSD, cparamboxptr parms )
1505 {
1506 int rc;
1507
1508 checkparam( parms, 0, 0 , "QUEUED" );
1509 rc = lines_in_stack( TSD, NULL);
1510 return int_to_streng( TSD, ( rc < 0 ) ? 0 : rc );
1511 }
1512
1513
1514
1515 streng *std_strip( tsd_t *TSD, cparamboxptr parms )
1516 {
1517 char option='B', padch=' ' ;
1518 streng *input=NULL ;
1519 int leading=0, trailing=0, start=0, stop=0 ;
1520
1521 checkparam( parms, 1, 3 , "STRIP" ) ;
1522 if ( ( parms->next )
1523 && ( parms->next->value ) )
1524 option = getoptionchar( TSD, parms->next->value, "STRIP", 2, "LTB", "" );
1525
1526 if ( ( parms->next )
1527 && ( parms->next->next )
1528 && ( parms->next->next->value ) )
1529 padch = getonechar( TSD, parms->next->next->value, "STRIP", 3 ) ;
1530
1531 input = parms->value ;
1532 leading = ((option=='B')||(option=='L')) ;
1533 trailing = ((option=='B')||(option=='T')) ;
1534
1535 for (start=0;(start<Str_len(input))&&(input->value[start]==padch)&&(leading);start++) ;
1536 for (stop=Str_len(input)-1;(stop >=start)&&(input->value[stop]==padch)&&(trailing);stop--) ;
1537 if (stop<start)
1538 stop = start - 1 ; /* FGC: If this happens, it will crash */
1539
1540 return Str_nocatTSD(Str_makeTSD(stop-start+2),input,stop-start+1, start) ;
1541 }
1542
1543
1544
1545 streng *std_space( tsd_t *TSD, cparamboxptr parms )
1546 {
1547 streng *retval=NULL, *string=NULL ;
1548 char padch=' ' ;
1549 int i=0, j=0, k=0, l=0, space=1, length=1, hole=0 ;
1550
1551 checkparam( parms, 1, 3 , "SPACE" ) ;
1552 if ( ( parms->next )
1553 && ( parms->next->value ) )
1554 length = atozpos( TSD, parms->next->value, "SPACE", 2 ) ;
1555
1556 if ( ( parms->next )
1557 && ( parms->next->next )
1558 && ( parms->next->next->value ) )
1559 padch = getonechar( TSD, parms->next->next->value, "SPACE", 3 ) ;
1560
1561 string = parms->value ;
1562 for ( i = 0; Str_in( string, i ); i++ )
1563 {
1564 if ((space)&&(string->value[i]!=' ')) hole++ ;
1565 space = (string->value[i]==' ') ;
1566 }
1567
1568 space = 1 ;
1569 retval = Str_makeTSD(i + hole*length ) ;
1570 for (j=l=i=0;Str_in(string,i);i++)
1571 {
1572 if (!((space)&&(string->value[i]==' ')))
1573 {
1574 if ((space=(string->value[i]==' '))!=0)
1575 for (l=j,k=0;k<length;k++)
1576 retval->value[j++] = padch ;
1577 else
1578 retval->value[j++] = string->value[i] ;
1579 }
1580 }
1581
1582 retval->len = j ;
1583 if ((space)&&(j))
1584 retval->len -= length ;
1585
1586 return retval ;
1587 }
1588
1589
1590 streng *std_arg( tsd_t *TSD, cparamboxptr parms )
1591 {
1592 rx_64 number=0, retval=0, tmpval=0 ;
1593 char flag='N' ;
1594 streng *value=NULL ;
1595 paramboxptr ptr=NULL ;
1596
1597 checkparam( parms, 0, 2 , "ARG" ) ;
1598 if ( ( parms )
1599 && ( parms->value ) )
1600 {
1601 number = atoposrx64( TSD, parms->value, "ARG", 1 ) ;
1602 if ( parms->next )
1603 flag = getoptionchar( TSD, parms->next->value, "ARG", 2, "ENO", "" ) ;
1604 }
1605
1606 ptr = TSD->currlevel->args ;
1607 if (number==0)
1608 {
1609 for (retval=0,tmpval=1; ptr; ptr=ptr->next, tmpval++)
1610 if (ptr->value)
1611 retval = tmpval ;
1612
1613 value = rx64_to_streng( TSD, retval ) ;
1614 }
1615
1616 else
1617 {
1618 for (retval=1;(retval<number)&&(ptr)&&((ptr=ptr->next)!=NULL);retval++) ;
1619 switch (flag)
1620 {
1621 case 'E':
1622 retval = ((ptr)&&(ptr->value)) ;
1623 value = rx64_to_streng( TSD, retval ? 1 : 0 ) ;
1624 break;
1625 case 'O':
1626 retval = ((ptr)&&(ptr->value)) ;
1627 value = rx64_to_streng( TSD, retval ? 0 : 1 ) ;
1628 break;
1629 case 'N':
1630 if ((ptr)&&(ptr->value))
1631 value = Str_dupTSD(ptr->value) ;
1632 else
1633 value = nullstringptr() ;
1634 break;
1635 }
1636 }
1637
1638 return value ;
1639 }
1640
1641
1642 #define LOGIC_AND 0
1643 #define LOGIC_OR 1
1644 #define LOGIC_XOR 2
1645
1646
1647 static char logic( char first, char second, int ltype )
1648 {
1649 switch (ltype)
1650 {
1651 case ( LOGIC_AND ) : return (char)( first & second ) ;
1652 case ( LOGIC_OR ) : return (char)( first | second ) ;
1653 case ( LOGIC_XOR ) : return (char)( first ^ second ) ;
1654 default :
1655 exiterror( ERR_INTERPRETER_FAILURE, 1, __FILE__, __LINE__, "" ) ;
1656 }
1657 /* not reached, next line only to satisfy compiler */
1658 return 'X' ;
1659 }
1660
1661
1662 static streng *misc_logic( tsd_t *TSD, int ltype, cparamboxptr parms, const char *bif, int argnum )
1663 {
1664 int length1=0, length2=0, i=0 ;
1665 char padch=' ' ;
1666 streng *kill=NULL ;
1667 streng *pad=NULL, *outstr=NULL, *str1=NULL, *str2=NULL ;
1668
1669 checkparam( parms, 1, 3 , bif ) ;
1670 str1 = parms->value ;
1671
1672 str2 = (parms->next) ? (parms->next->value) : NULL ;
1673 if (str2 == NULL)
1674 kill = str2 = nullstringptr() ;
1675 else
1676 kill = NULL ;
1677
1678 if ((parms->next)&&(parms->next->next))
1679 pad = parms->next->next->value ;
1680 else
1681 pad = NULL ;
1682
1683 if (pad)
1684 padch = getonechar( TSD, pad, bif, argnum ) ;
1685 #ifdef lint
1686 else
1687 padch = ' ' ;
1688 #endif
1689
1690 length1 = Str_len(str1) ;
1691 length2 = Str_len(str2) ;
1692 if (length2 > length1 )
1693 {
1694 streng *tmp ;
1695 tmp = str2 ;
1696 str2 = str1 ;
1697 str1 = tmp ;
1698 }
1699
1700 outstr = Str_makeTSD( Str_len(str1) ) ;
1701
1702 for (i=0; Str_in(str2,i); i++)
1703 outstr->value[i] = logic( str1->value[i], str2->value[i], ltype ) ;
1704
1705 if (pad)
1706 for (; Str_in(str1,i); i++)
1707 outstr->value[i] = logic( str1->value[i], padch, ltype ) ;
1708 else
1709 for (; Str_in(str1,i); i++)
1710 outstr->value[i] = str1->value[i] ;
1711
1712 if (kill)
1713 Free_stringTSD( kill ) ;
1714 outstr->len = i ;
1715 return outstr ;
1716 }
1717
1718
1719 streng *std_bitand( tsd_t *TSD, cparamboxptr parms )
1720 {
1721 return misc_logic( TSD, LOGIC_AND, parms, "BITAND", 3 ) ;
1722 }
1723
1724 streng *std_bitor( tsd_t *TSD, cparamboxptr parms )
1725 {
1726 return misc_logic( TSD, LOGIC_OR, parms, "BITOR", 3 ) ;
1727 }
1728
1729 streng *std_bitxor( tsd_t *TSD, cparamboxptr parms )
1730 {
1731 return misc_logic( TSD, LOGIC_XOR, parms, "BITXOR", 3 ) ;
1732 }
1733
1734
1735 streng *std_center( tsd_t *TSD, cparamboxptr parms )
1736 {
1737 int length=0, i=0, j=0, start=0, stop=0, chars=0 ;
1738 char padch=' ' ;
1739 streng *pad=NULL, *str=NULL, *ptr=NULL ;
1740
1741 checkparam( parms, 2, 3 , "CENTER" ) ;
1742 length = atozpos( TSD, parms->next->value, "CENTER", 2 ) ;
1743 str = parms->value ;
1744 if (parms->next->next!=NULL)
1745 pad = parms->next->next->value ;
1746 else
1747 pad = NULL ;
1748
1749 chars = Str_len(str) ;
1750 if (pad==NULL)
1751 padch = ' ' ;
1752 else
1753 padch = getonechar( TSD, pad, "CENTER", 3 ) ;
1754
1755 start = (chars>length) ? ((chars-length)/2) : 0 ;
1756 stop = (chars>length) ? (chars-(chars-length+1)/2) : chars ;
1757
1758 ptr = Str_makeTSD( length ) ;
1759 for (j=0;j<((length-chars)/2);ptr->value[j++]=padch) ;
1760 for (i=start;i<stop;ptr->value[j++]=str->value[i++]) ;
1761 for (;j<length;ptr->value[j++]=padch) ;
1762
1763 ptr->len = j ;
1764 assert((ptr->len<=ptr->max) && (j==length));
1765
1766 return ptr ;
1767 }
1768
1769 static unsigned num_sourcelines(const internal_parser_type *ipt)
1770 {
1771 const otree *otp;
1772
1773 if (ipt->first_source_line != NULL)
1774 return ipt->last_source_line->lineno ;
1775
1776 /* must be incore_source but that value may be NULL because of a failed
1777 * instore[0] of RexxStart!
1778 */
1779 if ((otp = ipt->srclines) == NULL)
1780 return 0; /* May happen if the user doesn't provides the true
1781 * source. If you set it to 1 you must return anything
1782 * below for that line.
1783 */
1784 while (otp->next)
1785 otp = otp->next;
1786 return otp->sum + otp->num;
1787 }
1788
1789 streng *std_sourceline( tsd_t *TSD, cparamboxptr parms )
1790 {
1791 int line, i ;
1792 bui_tsd_t *bt;
1793 const internal_parser_type *ipt = &TSD->systeminfo->tree ;
1794 const otree *otp;
1795 streng *retval;
1796
1797 bt = (bui_tsd_t *)TSD->bui_tsd;
1798 checkparam( parms, 0, 1 , "SOURCELINE" ) ;
1799 if (!parms->value)
1800 return int_to_streng( TSD, num_sourcelines( ipt ) ) ;
1801
1802 line = atopos( TSD, parms->value, "SOURCELINE", 1 ) ;
1803
1804 if (ipt->first_source_line == NULL)
1805 { /* must be incore_source but that value may be NULL because of a failed
1806 * instore[0] of RexxStart!
1807 */
1808 otp = ipt->srclines; /* NULL if incore_source==NULL */
1809 if (line > 0)
1810 {
1811 while (otp && ((int) otp->num < line))
1812 {
1813 line -= otp->num;
1814 otp = otp->next;
1815 }
1816 }
1817 if ((otp == NULL) || /* line not found or error */
1818 (line < 1))
1819 {
1820 exiterror( ERR_INCORRECT_CALL, 34, "SOURCELINE", 1, line, num_sourcelines( ipt ) ) ;
1821 }
1822
1823 line--;
1824 i = otp->elems[line].length ;
1825 retval = Str_makeTSD( i ) ;
1826 retval->len = i ;
1827 memcpy( retval->value, ipt->incore_source + otp->elems[line].offset, i ) ;
1828 return(retval);
1829 }
1830 if (bt->srcline_first != ipt->first_source_line)
1831 {
1832 bt->srcline_lineno = 1 ;
1833 bt->srcline_first =
1834 bt->srcline_ptr =
1835 ipt->first_source_line ;
1836 }
1837 for (;(bt->srcline_lineno<line);)
1838 {
1839 if ((bt->srcline_ptr=bt->srcline_ptr->next)==NULL)
1840 {
1841 exiterror( ERR_INCORRECT_CALL, 34, "SOURCELINE", 1, line, num_sourcelines( ipt ) ) ;
1842 }
1843 bt->srcline_lineno = bt->srcline_ptr->lineno ;
1844 }
1845 for (;(bt->srcline_lineno>line);)
1846 {
1847 if ((bt->srcline_ptr=bt->srcline_ptr->prev)==NULL)
1848 exiterror( ERR_INCORRECT_CALL, 0 ) ;
1849 bt->srcline_lineno = bt->srcline_ptr->lineno ;
1850 }
1851
1852 return Str_dupTSD(bt->srcline_ptr->line) ;
1853 }
1854
1855
1856 streng *std_compare( tsd_t *TSD, cparamboxptr parms )
1857 {
1858 char padch=' ' ;
1859 streng *pad=NULL, *str1=NULL, *str2=NULL ;
1860 int i=0, j=0, value=0 ;
1861
1862 checkparam( parms, 2, 3 , "COMPARE" ) ;
1863 str1 = parms->value ;
1864 str2 = parms->next->value ;
1865 if (parms->next->next)
1866 pad = parms->next->next->value ;
1867 else
1868 pad = NULL ;
1869
1870 if (!pad)
1871 padch = ' ' ;
1872 else
1873 padch = getonechar( TSD, pad, "COMPARE", 3) ;
1874
1875 value=i=j=0 ;
1876 while ((Str_in(str1,i))||(Str_in(str2,j))) {
1877 if (((Str_in(str1,i))?(str1->value[i]):(padch))!=
1878 ((Str_in(str2,j))?(str2->value[j]):(padch))) {
1879 value = (i>j) ? i : j ;
1880 break ; }
1881 if (Str_in(str1,i)) i++ ;
1882 if (Str_in(str2,j)) j++ ; }
1883
1884 if ((!Str_in(str1,i))&&(!Str_in(str2,j)))
1885 value = 0 ;
1886 else
1887 value++ ;
1888
1889 return int_to_streng( TSD, value ) ;
1890 }
1891
1892
1893 streng *std_errortext( tsd_t *TSD, cparamboxptr parms )
1894 {
1895 char opt = 'N';
1896 streng *tmp,*tmp1,*tmp2,*retstr;
1897 int numdec=0, errnum, suberrnum, pos=0, i;
1898 #if 0
1899 const char *err=NULL;
1900 #endif
1901
1902 checkparam( parms, 1, 2 , "ERRORTEXT" ) ;
1903
1904 if (parms&&parms->next&&parms->next->value)
1905 opt = getoptionchar( TSD, parms->next->value, "ERRORTEXT", 2, "NS", "" ) ;
1906 tmp = Str_dupTSD( parms->value );
1907 for (i=0; i<Str_len( tmp); i++ )
1908 {
1909 if ( *( tmp->value+i ) == '.' )
1910 {
1911 numdec++;
1912 *( tmp->value+i) = '\0';
1913 pos = i;
1914 }
1915 }
1916 if ( numdec > 1 )
1917 exiterror( ERR_INCORRECT_CALL, 11, 1, tmpstr_of( TSD, parms->value ) ) ;
1918
1919 if ( numdec == 1 )
1920 {
1921 tmp1 = Str_ncreTSD( tmp->value, pos );
1922 tmp2 = Str_ncreTSD( tmp->value+pos+1, Str_len( tmp ) - pos - 1 );
1923 errnum = atoposorzero( TSD, tmp1, "ERRORTEXT", 1 );
1924 suberrnum = atoposorzero( TSD, tmp2, "ERRORTEXT", 1 );
1925 Free_stringTSD( tmp1 ) ;
1926 Free_stringTSD( tmp2 ) ;
1927 }
1928 else
1929 {
1930 errnum = atoposorzero( TSD, tmp, "ERRORTEXT", 1 );
1931 suberrnum = 0;
1932 }
1933 /*
1934 * Only restrict the error number passed if STRICT_ANSI is in effect.
1935 */
1936 if ( get_options_flag( TSD->currlevel, EXT_STRICT_ANSI )
1937 && ( errnum > 90 || suberrnum > 900 ) )
1938 exiterror( ERR_INCORRECT_CALL, 17, "ERRORTEXT", tmpstr_of( TSD, parms->value ) ) ;
1939
1940 Free_stringTSD( tmp ) ;
1941
1942 retstr = Str_dupTSD( errortext( TSD, errnum, suberrnum, (opt=='S')?1:0, 1 ) ) ;
1943 clear_errortext_buffers( TSD ); /* fix bug 449 */
1944 return retstr;
1945 }
1946
1947
1948 streng *std_length( tsd_t *TSD, cparamboxptr parms )
1949 {
1950 checkparam( parms, 1, 1 , "LENGTH" ) ;
1951 return int_to_streng( TSD, Str_len( parms->value )) ;
1952 }
1953
1954
1955 streng *std_left( tsd_t *TSD, cparamboxptr parms )
1956 {
1957 int length=0, i=0 ;
1958 char padch=' ' ;
1959 streng *pad=NULL, *str=NULL, *ptr=NULL ;
1960
1961 checkparam( parms, 2, 3 , "LEFT" ) ;
1962 length = atozpos( TSD, parms->next->value, "LEFT", 2 ) ;
1963 str = parms->value ;
1964 if (parms->next->next!=NULL)
1965 pad = parms->next->next->value ;
1966 else
1967 pad = NULL ;
1968
1969 if (pad==NULL)
1970 padch = ' ' ;
1971 else
1972 padch = getonechar( TSD, pad, "LEFT", 3) ;
1973
1974 ptr = Str_makeTSD( length ) ;
1975 for (i=0;(i<length)&&(Str_in(str,i));i++)
1976 ptr->value[i] = str->value[i] ;
1977
1978 for (;i<length;ptr->value[i++]=padch) ;
1979 ptr->len = length ;
1980
1981 return ptr ;
1982 }
1983
1984 streng *std_right( tsd_t *TSD, cparamboxptr parms )
1985 {
1986 int length=0, i=0, j=0 ;
1987 char padch=' ' ;
1988 streng *pad=NULL, *str=NULL, *ptr=NULL ;
1989
1990 checkparam( parms, 2, 3 , "RIGHT" ) ;
1991 length = atozpos( TSD, parms->next->value, "RIGHT", 2 ) ;
1992 str = parms->value ;
1993 if (parms->next->next!=NULL)
1994 pad = parms->next->next->value ;
1995 else
1996 pad = NULL ;
1997
1998 if (pad==NULL)
1999 padch = ' ' ;
2000 else
2001 padch = getonechar( TSD, pad, "RIGHT", 3 ) ;
2002
2003 ptr = Str_makeTSD( length ) ;
2004 for (j=0;Str_in(str,j);j++) ;
2005 for (i=length-1,j--;(i>=0)&&(j>=0);ptr->value[i--]=str->value[j--]) ;
2006
2007 for (;i>=0;ptr->value[i--]=padch) ;
2008 ptr->len = length ;
2009
2010 return ptr ;
2011 }
2012
2013
2014 streng *std_verify( tsd_t *TSD, cparamboxptr parms )
2015 {
2016 char tab[256], ch=' ' ;
2017 streng *str=NULL, *ref=NULL ;
2018 int inv=0, start=0, res=0, i=0 ;
2019
2020 checkparam( parms, 2, 4 , "VERIFY" ) ;
2021
2022 str = parms->value ;
2023 ref = parms->next->value ;
2024 if ( parms->next->next )
2025 {
2026 if ( parms->next->next->value )
2027 {
2028 ch = getoptionchar( TSD, parms->next->next->value, "VERIFY", 3, "MN", "" ) ;
2029 if ( ch == 'M' )
2030 inv = 1 ;
2031 }
2032 if (parms->next->next->next)
2033 start = atopos( TSD, parms->next->next->next->value, "VERIFY", 4 ) - 1 ;
2034 }
2035
2036 for (i=0;i<256;tab[i++]=0) ;
2037 for (i=0;Str_in(ref,i);tab[(unsigned char)(ref->value[i++])]=1) ;
2038 for (i=start;(Str_in(str,i))&&(!res);i++)
2039 {
2040 if (inv==(tab[(unsigned char)(str->value[i])]))
2041 res = i+1 ;
2042 }
2043
2044 return int_to_streng( TSD, res ) ;
2045 }
2046
2047
2048
2049 streng *std_substr( tsd_t *TSD, cparamboxptr parms )
2050 {
2051 int rlength=0, length=0, start=0, i=0 ;
2052 int available, copycount;
2053 char padch=' ' ;
2054 streng *pad=NULL, *str=NULL, *ptr=NULL ;
2055 paramboxptr bptr=NULL ;
2056
2057 checkparam( parms, 2, 4 , "SUBSTR" ) ;
2058 str = parms->value ;
2059 rlength = Str_len( str ) ;
2060 start = atopos( TSD, parms->next->value, "SUBSTR", 2 ) ;
2061 if ( ( (bptr = parms->next->next) != NULL )
2062 && ( parms->next->next->value ) )
2063 length = atozpos( TSD, parms->next->next->value, "SUBSTR", 3 ) ;
2064 else
2065 length = ( rlength >= start ) ? rlength - start + 1 : 0;
2066
2067 if ( (bptr )
2068 && ( bptr->next )
2069 && ( bptr->next->value ) )
2070 pad = parms->next->next->next->value ;
2071
2072 if ( pad == NULL )
2073 padch = ' ' ;
2074 else
2075 padch = getonechar( TSD, pad, "SUBSTR", 4) ;
2076
2077 ptr = Str_makeTSD( length ) ;
2078 i = ((rlength>=start)?start-1:rlength) ;
2079 /*
2080 * New algorithm by Julian Onions speeds up substr() by 50%
2081 */
2082 available = Str_len(str) - i;
2083 copycount = length > available ? available : length;
2084 memcpy(ptr->value, &str->value[i], copycount);
2085 if (copycount < length)
2086 memset(&ptr->value[copycount], padch, length - copycount);
2087 ptr->len = length;
2088 return ptr ;
2089 }
2090
2091
2092 static streng *minmax( tsd_t *TSD, cparamboxptr parms, const char *name,
2093 int sign )
2094 {
2095 /*
2096 * fixes bug 677645
2097 */
2098 streng *retval;
2099 num_descr *m,*test;
2100 int ccns,fuzz,StrictAnsi,result,required,argno;
2101
2102 StrictAnsi = get_options_flag( TSD->currlevel, EXT_STRICT_ANSI );
2103 /*
2104 * Round the number according to NUMERIC DIGITS. This is rule 9.2.1.
2105 * Don't set DIGITS or FUZZ where it's possible to raise a condition.
2106 * We don't have a chance to set it back to the original value.
2107 */
2108 ccns = TSD->currlevel->currnumsize;
2109 fuzz = TSD->currlevel->numfuzz;
2110
2111 required = count_params(parms, PARAM_TYPE_HARD);
2112 if ( !parms->value )
2113 exiterror( ERR_INCORRECT_CALL, 3, name, required );
2114 m = get_a_descr( TSD, name, 1, parms->value );
2115 if ( StrictAnsi )
2116 {
2117 str_round_lostdigits( TSD, m, ccns );
2118 }
2119
2120 parms = parms->next;
2121 argno = 1;
2122 while ( parms )
2123 {
2124 argno++;
2125 if ( !parms->value )
2126 exiterror( ERR_INCORRECT_CALL, 3, name, required ); /* fixes bug 1109296 */
2127
2128 test = get_a_descr( TSD, name, argno, parms->value );
2129 if ( StrictAnsi )
2130 {
2131 str_round_lostdigits( TSD, test, ccns );
2132 }
2133
2134 if ( ( TSD->currlevel->currnumsize = test->size ) < m->size )
2135 TSD->currlevel->currnumsize = m->size;
2136 TSD->currlevel->numfuzz = 0;
2137 result = string_test( TSD, test, m ) * sign;
2138 TSD->currlevel->currnumsize = ccns;
2139 TSD->currlevel->numfuzz = fuzz;
2140
2141 if ( result <= 0 )
2142 {
2143 free_a_descr( TSD, test );
2144 }
2145 else
2146 {
2147 free_a_descr( TSD, m );
2148 m = test;
2149 }
2150 parms = parms->next;
2151 }
2152
2153 m->used_digits = m->size;
2154 retval = str_norm( TSD, m, NULL );
2155 free_a_descr( TSD, m );
2156 return retval;
2157
2158 }
2159 streng *std_max( tsd_t *TSD, cparamboxptr parms )
2160 {
2161 return minmax( TSD, parms, "MAX", 1 );
2162 }
2163
2164
2165
2166 streng *std_min( tsd_t *TSD, cparamboxptr parms )
2167 {
2168 return minmax( TSD, parms, "MIN", -1 );
2169 }
2170
2171
2172
2173 streng *std_reverse( tsd_t *TSD, cparamboxptr parms )
2174 {
2175 streng *ptr=NULL ;
2176 int i=0, j=0 ;
2177
2178 checkparam( parms, 1, 1 , "REVERSE" ) ;
2179
2180 ptr = Str_makeTSD(j=Str_len(parms->value)) ;
2181 ptr->len = j-- ;
2182 for (i=0;j>=0;ptr->value[i++]=parms->value->value[j--]) ;
2183
2184 return ptr ;
2185 }
2186
2187 streng *std_random( tsd_t *TSD, cparamboxptr parms )
2188 {
2189 int min=0, max=999, result=0 ;
2190 #if defined(HAVE_RANDOM)
2191 int seed;
2192 #else
2193 unsigned seed;
2194 #endif
2195
2196 checkparam( parms, 0, 3 , "RANDOM" ) ;
2197 if (parms!=NULL)
2198 {
2199 if (parms->value)
2200 {
2201 if (parms->next)
2202 min = atozpos( TSD, parms->value, "RANDOM", 1 ) ;
2203 else
2204 {
2205 max = atozpos( TSD, parms->value, "RANDOM", 1 ) ;
2206 if ( max > 100000 )
2207 exiterror( ERR_INCORRECT_CALL, 31, "RANDOM", max ) ;
2208 }
2209 }
2210 if (parms->next!=NULL)
2211 {
2212 if (parms->next->value!=NULL)
2213 max = atozpos( TSD, parms->next->value, "RANDOM", 2 ) ;
2214
2215 if (parms->next->next!=NULL&&parms->next->next->value!=NULL)
2216 {
2217 seed = atozpos( TSD, parms->next->next->value, "RANDOM", 3 ) ;
2218 #if defined(HAVE_RANDOM)
2219 srandom( seed ) ;
2220 #else
2221 srand( seed ) ;
2222 #endif
2223 }
2224 }
2225 }
2226
2227 if (min>max)
2228 exiterror( ERR_INCORRECT_CALL, 33, "RANDOM", min, max ) ;
2229 if (max-min > 100000)
2230 exiterror( ERR_INCORRECT_CALL, 32, "RANDOM", min, max ) ;
2231
2232 #if defined(HAVE_RANDOM)
2233 result = (random() % (max-min+1)) + min ;
2234 #else
2235 # if RAND_MAX < 100000
2236 /* result = (((rand() * 100) + (clock() % 100)) % (max-min+1)) + min ; */
2237 result = (((rand() * RAND_MAX) + rand() ) % (max-min+1)) + min ; /* pgb */
2238 # else
2239 result = (rand() % (max-min+1)) + min ;
2240 # endif
2241 #endif
2242 return int_to_streng( TSD, result ) ;
2243 }
2244
2245
2246 streng *std_copies( tsd_t *TSD, cparamboxptr parms )
2247 {
2248 streng *ptr=NULL ;
2249 int copies=0, i=0, length=0 ;
2250
2251 checkparam( parms, 2, 2 , "COPIES" ) ;
2252
2253 length = Str_len(parms->value) ;
2254 copies = atozpos( TSD, parms->next->value, "COPIES", 2 ) * length ;
2255 ptr = Str_makeTSD( copies ) ;
2256 for (i=0;i<copies;i+=length)
2257 memcpy(ptr->value+i,parms->value->value,length) ;
2258
2259 ptr->len = i ;
2260 return ptr ;
2261 }
2262
2263
2264 streng *std_sign( tsd_t *TSD, cparamboxptr parms )
2265 {
2266 checkparam( parms, 1, 1 , "SIGN" );
2267
2268 return str_sign( TSD, parms->value );
2269 }
2270
2271
2272 streng *std_trunc( tsd_t *TSD, cparamboxptr parms )
2273 {
2274 int decimals=0;
2275
2276 checkparam( parms, 1, 2 , "TRUNC" );
2277 if ( parms->next && parms->next->value )
2278 decimals = atozpos( TSD, parms->next->value, "TRUNC", 2 );
2279
2280 return str_trunc( TSD, parms->value, decimals );
2281 }
2282
2283
2284 streng *std_translate( tsd_t *TSD, cparamboxptr parms )
2285 {
2286 streng *iptr=NULL, *optr=NULL ;
2287 char padch=' ' ;
2288 streng *string=NULL, *result=NULL ;
2289 paramboxptr ptr=NULL ;
2290 int olength=0, i=0, ii=0 ;
2291
2292 checkparam( parms, 1, 4 , "TRANSLATE" ) ;
2293
2294 string = parms->value ;
2295 if ( ( (ptr = parms->next) != NULL )
2296 && ( parms->next->value ) )
2297 {
2298 optr = parms->next->value ;
2299 olength = Str_len( optr ) ;
2300 }
2301
2302 if ( ( ptr )
2303 && ( (ptr = ptr->next) != NULL )
2304 && ( ptr->value ) )
2305 {
2306 iptr = ptr->value ;
2307 }
2308
2309 if ( ( ptr )
2310 && ( (ptr = ptr->next) != NULL )
2311 && ( ptr->value ) )
2312 padch = getonechar( TSD, ptr->value, "TRANSLATE", 4 ) ;
2313
2314 result = Str_makeTSD( Str_len(string) ) ;
2315 for (i=0; Str_in(string,i); i++)
2316 {
2317 if ((!iptr)&&(!optr))
2318 result->value[i] = (char) rx_toupper(string->value[i]) ;
2319 else
2320 {
2321 if (iptr)
2322 {
2323 for (ii=0; Str_in(iptr,ii); ii++)
2324 if (iptr->value[ii]==string->value[i])
2325 break ;
2326
2327 if (ii==Str_len(iptr))
2328 {
2329 result->value[i] = string->value[i] ;
2330 continue ;
2331 }
2332 }
2333 else
2334 ii = ((unsigned char*)string->value)[i] ;
2335
2336 if ((optr)&&(ii<olength))
2337 result->value[i] = optr->value[ii] ;
2338 else
2339 result->value[i] = padch ;
2340 }
2341 }
2342
2343 result->len = i ;
2344 return result ;
2345 }
2346
2347
2348 streng *std_delstr( tsd_t *TSD, cparamboxptr parms )
2349 {
2350 int i=0, j=0, length=0, sleng=0, start=0 ;
2351 streng *string=NULL, *result=NULL ;
2352
2353 checkparam( parms, 2, 3 , "DELSTR" ) ;
2354
2355 sleng = Str_len((string = parms->value)) ;
2356 /*
2357 * found while fixing bug 1108868, but fast-finding Walter will create
2358 * a new bug item before releasing the fix I suppose ;-) (was atozpos)
2359 */
2360 start = atopos( TSD, parms->next->value, "DELSTR", 2 ) ;
2361
2362 if ((parms->next->next)&&(parms->next->next->value))
2363 length = atozpos( TSD, parms->next->next->value, "DELSTR", 3 ) ;
2364 else
2365 length = Str_len( string ) - start + 1 ;
2366
2367 if (length<0)
2368 length = 0 ;
2369
2370 result = Str_makeTSD( (start+length>sleng) ? start : sleng-length ) ;
2371
2372 for (i=j=0; (Str_in(string,i))&&(i<start-1); result->value[i++] = string->value[j++]) ;
2373 j += length ;
2374 for (; (j<=sleng)&&(Str_in(string,j)); result->value[i++] = string->value[j++] ) ;
2375
2376 result->len = i ;
2377 return result ;
2378 }
2379
2380
2381
2382
2383
2384 static int valid_hex_const( const streng *str )
2385 {
2386 const char *ptr=NULL, *end_ptr=NULL ;
2387 int space_stat=0 ;
2388
2389 ptr = str->value ;
2390 end_ptr = ptr + str->len ;
2391
2392 if ((end_ptr>ptr) && ((rx_isspace(*ptr)) || (rx_isspace(*(end_ptr-1)))))
2393 {
2394 return 0 ; /* leading or trailing space */
2395 }
2396
2397 space_stat = 0 ;
2398 for (; ptr<end_ptr; ptr++)
2399 {
2400 if (rx_isspace(*ptr))
2401 {
2402 if (space_stat==0)
2403 {
2404 space_stat = 2 ;
2405 }
2406 else if (space_stat==1)
2407 {
2408 /* non-even number of hex digits in non-first group */
2409 return 0 ;
2410 }
2411 }
2412 else if (rx_isxdigit(*ptr))
2413 {
2414 if (space_stat)
2415 space_stat = ((space_stat==1) ? 2 : 1) ;
2416 }
2417 else
2418 {
2419 return 0 ; /* neither space nor hex digit */
2420 }
2421 }
2422
2423 if (space_stat==1)
2424 {
2425 /* non-even number of digits in last grp, which not also first grp */
2426 return 0 ;
2427 }
2428
2429 /* note: the nullstring is a valid hexstring */
2430 return 1 ; /* a valid hex string */
2431 }
2432
2433 static int valid_binary_const( const streng *str)
2434 /* check for valid binary streng. returns 1 for TRUE, 0 for FALSE */
2435 {
2436 char c;
2437 const char *ptr;
2438 int len,digits;
2439
2440 ptr = str->value;
2441 if ((len = Str_len(str))==0)
2442 return(1); /* ANSI */
2443 len--; /* on last char */
2444
2445 if (rx_isspace(ptr[0]) || rx_isspace(ptr[len]))
2446 return(0); /* leading or trailing space */
2447 /* ptr must consist of 0 1nd 1. After a blank follows a blank or a block
2448 * of four digits. Since the first block of binary digits may contain
2449 * less than four digits, we casn parse backwards and check only filled
2450 * block till we reach the start. Thanks to ANSI testing program. */
2451 for (digits = 0; len >= 0; len--)
2452 {
2453 c = ptr[len];
2454 if (rx_isspace(c))
2455 {
2456 if ((digits % 4) != 0)
2457 return(0);
2458 }
2459 else if ((c != '0') && (c != '1'))
2460 return(0);
2461 digits++;
2462 }
2463
2464 return(1);
2465 }
2466
2467 streng *std_datatype( tsd_t *TSD, cparamboxptr parms )
2468 {
2469 streng *string=NULL, *result=NULL ;
2470 char option=' ', *cptr=NULL ;
2471 int res;
2472 parambox parms_for_symbol;
2473
2474 checkparam( parms, 1, 2 , "DATATYPE" ) ;
2475
2476 string = parms->value ;
2477
2478 if ((parms->next)&&(parms->next->value))
2479 {
2480 option = getoptionchar( TSD, parms->next->value, "DATATYPE", 2, "ABLMNSUWX", "" ) ;
2481 res = 1 ;
2482 cptr = string->value ;
2483 if ((Str_len(string)==0)&&(option!='X')&&(option!='B'))
2484 res = 0 ;
2485
2486 switch ( option )
2487 {
2488 case 'A':
2489 for (; cptr<Str_end(string); res = rx_isalnum(*cptr++) && res) ;
2490 res = ( res ) ? 1 : 0;
2491 break ;
2492
2493 case 'B':
2494 res = valid_binary_const( string );
2495 break ;
2496
2497 case 'L':
2498 for (; cptr<Str_end(string); res = rx_islower(*cptr++) && res ) ;
2499 res = ( res ) ? 1 : 0;
2500 break ;
2501
2502 case 'M':
2503 for (; cptr<Str_end(string); res = rx_isalpha(*cptr++) && res ) ;
2504 res = ( res ) ? 1 : 0;
2505 break ;
2506
2507 case 'N':
2508 res = myisnumber(TSD, string) ;
2509 break ;
2510
2511 case 'S':
2512 /*
2513 * According to ANSI 9.3.8, this should return the result of:
2514 * Symbol( string ) \= 'BAD'
2515 * Fixes bug #737151
2516 */
2517 parms_for_symbol.next = NULL;
2518 parms_for_symbol.dealloc = 0;
2519 parms_for_symbol.value = string;
2520 result = std_symbol( TSD, &parms_for_symbol );
2521 if ( result->len == 3 && memcmp( result->value, "BAD", 3 ) == 0 )
2522 res = 0;
2523 else
2524 res = 1;
2525 Free_string_TSD( TSD,result );
2526 break ;
2527
2528 case 'U':
2529 for (; cptr<Str_end(string); res = rx_isupper(*cptr++) && res ) ;
2530 res = ( res ) ? 1 : 0;
2531 break ;
2532
2533 case 'W':
2534 res = myiswnumber( TSD, string, NULL, 0 );
2535 break ;
2536
2537 case 'X':
2538 res = valid_hex_const( string ) ;
2539 break ;
2540
2541 default:
2542 /* shouldn't get here */
2543 break;
2544 }
2545 result = int_to_streng( TSD, res ) ;
2546 }
2547 else
2548 {
2549 cptr = (char *)( ( ( string->len ) && ( myisnumber( TSD, string ) ) ) ? "NUM" : "CHAR" ) ;
2550 result = Str_creTSD( cptr ) ;
2551 }
2552
2553 return result ;
2554 }
2555
2556
2557 streng *std_trace( tsd_t *TSD, cparamboxptr parms )
2558 {
2559 streng *result=NULL, *string=NULL ;
2560 int i=0 ;
2561 char tc;
2562
2563 checkparam( parms, 0, 1 , "TRACE" ) ;
2564
2565 result = Str_makeTSD( 3 ) ;
2566 if (TSD->systeminfo->interactive)
2567 result->value[i++] = '?' ;
2568
2569 result->value[i++] = (char) TSD->trace_stat ;
2570 result->len = i ;
2571
2572 if ( parms->value )
2573 {
2574 string = Str_dupTSD( parms->value );
2575 for (i = 0; i < string->len; i++ )
2576 {
2577 if ( string->value[ i ] == '?' )
2578 set_trace_char( TSD, '?' );
2579 else
2580 break;
2581 }
2582 /*
2583 * In opposite to ANSI this throws 40.21, too.
2584 * I assume this to be OK although "trace ?" throws 40.21.
2585 */
2586 tc = getoptionchar( TSD, Str_strp( string, '?', STRIP_LEADING ),
2587 "TRACE",
2588 1,
2589 "ACEFILNOR", "" ) ;
2590 set_trace_char( TSD, tc );
2591 Free_stringTSD( string );
2592 }
2593
2594 return result ;
2595 }
2596
2597 streng *std_changestr( tsd_t *TSD, cparamboxptr parms )
2598 {
2599 streng *needle=NULL, *heystack=NULL, *new_needle=NULL, *retval=NULL ;
2600 int neelen=0, heylen=0, newlen=0, newneelen=0, cnt=0, start=0, i=0, heypos=0, retpos=0 ;
2601
2602 checkparam( parms, 3, 3, "CHANGESTR" ) ;
2603 needle = parms->value ;
2604 heystack = parms->next->value ;
2605 new_needle = parms->next->next->value ;
2606
2607 neelen = Str_len(needle) ;
2608 heylen = Str_len(heystack) ;
2609 newneelen = Str_len(new_needle) ;
2610
2611 /* find number of occurrences of needle in heystack */
2612 if ((!needle->len)||(!heystack->len)||(needle->len>heystack->len))
2613 cnt = 0 ;
2614 else
2615 {
2616 for(;;)
2617 {
2618 start = bmstrstr(heystack, start, needle, 0);
2619 if (start == (-1))
2620 break;
2621 cnt++;
2622 start += needle->len;
2623 }
2624 }
2625 newlen = 1 + heylen + ((newneelen-neelen) * cnt);
2626 retval = Str_makeTSD(newlen) ;
2627
2628 if (!cnt)
2629 return (Str_ncpyTSD(retval,heystack,heylen));
2630
2631 start=heypos=retpos=0;
2632 for(;;)
2633 {
2634 start = bmstrstr(heystack, start, needle, 0);
2635 if (start == (-1))
2636 {
2637 cnt = heylen-heypos;
2638 for(i=0;i<cnt;retval->value[retpos++]=heystack->value[heypos++],i++) ;
2639 break;
2640 }
2641 cnt = start-heypos;
2642 for(i=0;i<cnt;retval->value[retpos++]=heystack->value[heypos++],i++) ;
2643 for(i=0;i<neelen;heypos++,i++) ;
2644 for(i=0;i<newneelen;retval->value[retpos++]=new_needle->value[i++]) ;
2645 start = heypos;
2646 }
2647
2648 retval->value[retpos] = '\0';
2649 retval->len=retpos;
2650 return retval ;
2651 }
2652
2653 streng *std_countstr( tsd_t *TSD, cparamboxptr parms )
2654 {
2655 int start=0, cnt=0 ;
2656 streng *needle=NULL, *heystack=NULL ;
2657 checkparam( parms, 2, 2 , "COUNTSTR" ) ;
2658
2659 needle = parms->value ;
2660 heystack = parms->next->value ;
2661
2662 if ((!needle->len)||(!heystack->len))
2663 cnt = 0 ;
2664 else
2665 {
2666 for(;;)
2667 {
2668 start = bmstrstr(heystack, start, needle, 0);
2669 if (start == (-1))
2670 break;
2671 cnt++;
2672 start += needle->len;
2673 }
2674 }
2675
2676 return (int_to_streng( TSD, cnt ) ) ;
2677 }
2678
2679 streng *rex_poolid( tsd_t *TSD, cparamboxptr parms )
2680 {
2681 checkparam( parms, 0, 0 , "POOLID" );
2682
2683 return ( int_to_streng( TSD, TSD->currlevel->pool ) );
2684 }
2685
2686 streng *rex_lower( tsd_t *TSD, cparamboxptr parms )
2687 {
2688 rx_64 rlength=0, length=0, start=1, i=0 ;
2689 int changecount;
2690 char padch=' ' ;
2691 streng *str=NULL, *ptr=NULL ;
2692 paramboxptr bptr=NULL ;
2693
2694 /*
2695 * Check that we have between 1 and 4 args
2696 * ( str [,start[,length[,pad]]] )
2697 */
2698 checkparam( parms, 1, 4 , "LOWER" ) ;
2699 str = parms->value ;
2700 rlength = Str_len( str ) ;
2701 /*
2702 * Get starting position, if supplied...
2703 */
2704 if ( parms->next != NULL
2705 && parms->next->value )
2706 start = atoposrx64( TSD, parms->next->value, "LOWER", 2 ) ;
2707 /*
2708 * Get length, if supplied...
2709 */
2710 if ( parms->next != NULL
2711 && ( (bptr = parms->next->next) != NULL )
2712 && ( parms->next->next->value ) )
2713 length = atozposrx64( TSD, parms->next->next->value, "LOWER", 3 ) ;
2714 else
2715 length = ( rlength >= start ) ? rlength - start + 1 : 0;
2716 /*
2717 * Get pad character, if supplied...
2718 */
2719 if ( (bptr )
2720 && ( bptr->next )
2721 && ( bptr->next->value ) )
2722 padch = getonechar( TSD, parms->next->next->next->value, "LOWER", 4) ;
2723 /*
2724 * Create our new starting; duplicate of input string
2725 */
2726 ptr = Str_makeTSD( rlength );
2727 memcpy( Str_val( ptr ), Str_val( str ), Str_len( str ) );
2728 /*
2729 * Determine where to start changing case...
2730 */
2731 i = ((rlength>=start)?start-1:rlength) ;
2732 /*
2733 * Determine how many characters to change case...
2734 */
2735 changecount = length > rlength ? rlength : length;
2736 /*
2737 * Change them
2738 */
2739 mem_lowerrx64( &ptr->value[i], changecount );
2740 /*
2741 * Append pad characters if required...
2742 */
2743 if (changecount < length)
2744 memset(&ptr->value[changecount], padch, length - changecount);
2745 /*
2746 * Determine length of return string...
2747 */
2748 ptr->len = (length > rlength) ? length : rlength ;
2749 return ptr ;
2750 }