| 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 |
} |