| | @@ -1,7 +1,9 @@ |
| 1 | 1 | /* This is single source file, bootstrap version of Jim Tcl. See http://jim.tcl.tk/ */ |
| 2 | +#define _GNU_SOURCE |
| 2 | 3 | #define JIM_TCL_COMPAT |
| 4 | +#define JIM_REFERENCES |
| 3 | 5 | #define JIM_ANSIC |
| 4 | 6 | #define JIM_REGEXP |
| 5 | 7 | #define HAVE_NO_AUTOCONF |
| 6 | 8 | #define _JIMAUTOCONF_H |
| 7 | 9 | #define TCL_LIBRARY "." |
| | @@ -33,26 +35,20 @@ |
| 33 | 35 | #define HAVE_UNISTD_H |
| 34 | 36 | #else |
| 35 | 37 | #define TCL_PLATFORM_OS "unknown" |
| 36 | 38 | #define TCL_PLATFORM_PLATFORM "unix" |
| 37 | 39 | #define TCL_PLATFORM_PATH_SEPARATOR ":" |
| 38 | | -#ifdef _MINIX |
| 39 | | -#define vfork fork |
| 40 | | -#define _POSIX_SOURCE |
| 41 | | -#else |
| 42 | | -#define _GNU_SOURCE |
| 43 | | -#endif |
| 44 | 40 | #define HAVE_VFORK |
| 45 | 41 | #define HAVE_WAITPID |
| 46 | 42 | #define HAVE_ISATTY |
| 47 | 43 | #define HAVE_MKSTEMP |
| 48 | 44 | #define HAVE_LINK |
| 49 | 45 | #define HAVE_SYS_TIME_H |
| 50 | 46 | #define HAVE_DIRENT_H |
| 51 | 47 | #define HAVE_UNISTD_H |
| 52 | 48 | #endif |
| 53 | | -#define JIM_VERSION 77 |
| 49 | +#define JIM_VERSION 76 |
| 54 | 50 | #ifndef JIM_WIN32COMPAT_H |
| 55 | 51 | #define JIM_WIN32COMPAT_H |
| 56 | 52 | |
| 57 | 53 | |
| 58 | 54 | |
| | @@ -109,14 +105,14 @@ |
| 109 | 105 | struct dirent { |
| 110 | 106 | char *d_name; |
| 111 | 107 | }; |
| 112 | 108 | |
| 113 | 109 | typedef struct DIR { |
| 114 | | - long handle; |
| 110 | + long handle; |
| 115 | 111 | struct _finddata_t info; |
| 116 | | - struct dirent result; |
| 117 | | - char *name; |
| 112 | + struct dirent result; |
| 113 | + char *name; |
| 118 | 114 | } DIR; |
| 119 | 115 | |
| 120 | 116 | DIR *opendir(const char *name); |
| 121 | 117 | int closedir(DIR *dir); |
| 122 | 118 | struct dirent *readdir(DIR *dir); |
| | @@ -126,11 +122,11 @@ |
| 126 | 122 | #include <stdlib.h> |
| 127 | 123 | #define strtod __strtod |
| 128 | 124 | |
| 129 | 125 | #endif |
| 130 | 126 | |
| 131 | | -#endif |
| 127 | +#endif |
| 132 | 128 | |
| 133 | 129 | #ifdef __cplusplus |
| 134 | 130 | } |
| 135 | 131 | #endif |
| 136 | 132 | |
| | @@ -179,13 +175,13 @@ |
| 179 | 175 | extern "C" { |
| 180 | 176 | #endif |
| 181 | 177 | |
| 182 | 178 | #include <time.h> |
| 183 | 179 | #include <limits.h> |
| 184 | | -#include <stdio.h> |
| 185 | | -#include <stdlib.h> |
| 186 | | -#include <stdarg.h> |
| 180 | +#include <stdio.h> |
| 181 | +#include <stdlib.h> |
| 182 | +#include <stdarg.h> |
| 187 | 183 | |
| 188 | 184 | |
| 189 | 185 | #ifndef HAVE_NO_AUTOCONF |
| 190 | 186 | #endif |
| 191 | 187 | |
| | @@ -228,31 +224,31 @@ |
| 228 | 224 | #define JIM_SIGNAL 5 |
| 229 | 225 | #define JIM_EXIT 6 |
| 230 | 226 | |
| 231 | 227 | #define JIM_EVAL 7 |
| 232 | 228 | |
| 233 | | -#define JIM_MAX_CALLFRAME_DEPTH 1000 |
| 234 | | -#define JIM_MAX_EVAL_DEPTH 2000 |
| 229 | +#define JIM_MAX_CALLFRAME_DEPTH 1000 |
| 230 | +#define JIM_MAX_EVAL_DEPTH 2000 |
| 235 | 231 | |
| 236 | 232 | |
| 237 | 233 | #define JIM_PRIV_FLAG_SHIFT 20 |
| 238 | 234 | |
| 239 | | -#define JIM_NONE 0 |
| 240 | | -#define JIM_ERRMSG 1 |
| 241 | | -#define JIM_ENUM_ABBREV 2 |
| 242 | | -#define JIM_UNSHARED 4 |
| 243 | | -#define JIM_MUSTEXIST 8 |
| 244 | | - |
| 245 | | - |
| 246 | | -#define JIM_SUBST_NOVAR 1 |
| 247 | | -#define JIM_SUBST_NOCMD 2 |
| 248 | | -#define JIM_SUBST_NOESC 4 |
| 249 | | -#define JIM_SUBST_FLAG 128 |
| 250 | | - |
| 251 | | - |
| 252 | | -#define JIM_CASESENS 0 |
| 253 | | -#define JIM_NOCASE 1 |
| 235 | +#define JIM_NONE 0 |
| 236 | +#define JIM_ERRMSG 1 |
| 237 | +#define JIM_ENUM_ABBREV 2 |
| 238 | +#define JIM_UNSHARED 4 |
| 239 | +#define JIM_MUSTEXIST 8 |
| 240 | + |
| 241 | + |
| 242 | +#define JIM_SUBST_NOVAR 1 |
| 243 | +#define JIM_SUBST_NOCMD 2 |
| 244 | +#define JIM_SUBST_NOESC 4 |
| 245 | +#define JIM_SUBST_FLAG 128 |
| 246 | + |
| 247 | + |
| 248 | +#define JIM_CASESENS 0 |
| 249 | +#define JIM_NOCASE 1 |
| 254 | 250 | |
| 255 | 251 | |
| 256 | 252 | #define JIM_PATH_LEN 1024 |
| 257 | 253 | |
| 258 | 254 | |
| | @@ -343,79 +339,79 @@ |
| 343 | 339 | #define Jim_GetHashTableSize(ht) ((ht)->size) |
| 344 | 340 | #define Jim_GetHashTableUsed(ht) ((ht)->used) |
| 345 | 341 | |
| 346 | 342 | |
| 347 | 343 | typedef struct Jim_Obj { |
| 348 | | - char *bytes; |
| 349 | | - const struct Jim_ObjType *typePtr; |
| 350 | | - int refCount; |
| 351 | | - int length; |
| 352 | | - |
| 344 | + char *bytes; |
| 345 | + const struct Jim_ObjType *typePtr; |
| 346 | + int refCount; |
| 347 | + int length; |
| 348 | + |
| 353 | 349 | union { |
| 354 | | - |
| 350 | + |
| 355 | 351 | jim_wide wideValue; |
| 356 | | - |
| 352 | + |
| 357 | 353 | int intValue; |
| 358 | | - |
| 354 | + |
| 359 | 355 | double doubleValue; |
| 360 | | - |
| 356 | + |
| 361 | 357 | void *ptr; |
| 362 | | - |
| 358 | + |
| 363 | 359 | struct { |
| 364 | 360 | void *ptr1; |
| 365 | 361 | void *ptr2; |
| 366 | 362 | } twoPtrValue; |
| 367 | | - |
| 363 | + |
| 368 | 364 | struct { |
| 369 | 365 | struct Jim_Var *varPtr; |
| 370 | | - unsigned long callFrameId; |
| 371 | | - int global; |
| 366 | + unsigned long callFrameId; |
| 367 | + int global; |
| 372 | 368 | } varValue; |
| 373 | | - |
| 369 | + |
| 374 | 370 | struct { |
| 375 | 371 | struct Jim_Obj *nsObj; |
| 376 | 372 | struct Jim_Cmd *cmdPtr; |
| 377 | | - unsigned long procEpoch; |
| 373 | + unsigned long procEpoch; |
| 378 | 374 | } cmdValue; |
| 379 | | - |
| 375 | + |
| 380 | 376 | struct { |
| 381 | | - struct Jim_Obj **ele; |
| 382 | | - int len; |
| 383 | | - int maxLen; |
| 377 | + struct Jim_Obj **ele; |
| 378 | + int len; |
| 379 | + int maxLen; |
| 384 | 380 | } listValue; |
| 385 | | - |
| 381 | + |
| 386 | 382 | struct { |
| 387 | 383 | int maxLength; |
| 388 | | - int charLength; |
| 384 | + int charLength; |
| 389 | 385 | } strValue; |
| 390 | | - |
| 386 | + |
| 391 | 387 | struct { |
| 392 | 388 | unsigned long id; |
| 393 | 389 | struct Jim_Reference *refPtr; |
| 394 | 390 | } refValue; |
| 395 | | - |
| 391 | + |
| 396 | 392 | struct { |
| 397 | 393 | struct Jim_Obj *fileNameObj; |
| 398 | 394 | int lineNumber; |
| 399 | 395 | } sourceValue; |
| 400 | | - |
| 396 | + |
| 401 | 397 | struct { |
| 402 | 398 | struct Jim_Obj *varNameObjPtr; |
| 403 | 399 | struct Jim_Obj *indexObjPtr; |
| 404 | 400 | } dictSubstValue; |
| 405 | | - |
| 401 | + |
| 406 | 402 | struct { |
| 407 | | - void *compre; |
| 403 | + void *compre; |
| 408 | 404 | unsigned flags; |
| 409 | 405 | } regexpValue; |
| 410 | 406 | struct { |
| 411 | 407 | int line; |
| 412 | 408 | int argc; |
| 413 | 409 | } scriptLineValue; |
| 414 | 410 | } internalRep; |
| 415 | | - struct Jim_Obj *prevObjPtr; |
| 416 | | - struct Jim_Obj *nextObjPtr; |
| 411 | + struct Jim_Obj *prevObjPtr; |
| 412 | + struct Jim_Obj *nextObjPtr; |
| 417 | 413 | } Jim_Obj; |
| 418 | 414 | |
| 419 | 415 | |
| 420 | 416 | #define Jim_IncrRefCount(objPtr) \ |
| 421 | 417 | ++(objPtr)->refCount |
| | @@ -446,40 +442,40 @@ |
| 446 | 442 | typedef void (Jim_DupInternalRepProc)(struct Jim_Interp *interp, |
| 447 | 443 | struct Jim_Obj *srcPtr, Jim_Obj *dupPtr); |
| 448 | 444 | typedef void (Jim_UpdateStringProc)(struct Jim_Obj *objPtr); |
| 449 | 445 | |
| 450 | 446 | typedef struct Jim_ObjType { |
| 451 | | - const char *name; |
| 447 | + const char *name; |
| 452 | 448 | Jim_FreeInternalRepProc *freeIntRepProc; |
| 453 | 449 | Jim_DupInternalRepProc *dupIntRepProc; |
| 454 | 450 | Jim_UpdateStringProc *updateStringProc; |
| 455 | 451 | int flags; |
| 456 | 452 | } Jim_ObjType; |
| 457 | 453 | |
| 458 | 454 | |
| 459 | | -#define JIM_TYPE_NONE 0 |
| 460 | | -#define JIM_TYPE_REFERENCES 1 |
| 455 | +#define JIM_TYPE_NONE 0 |
| 456 | +#define JIM_TYPE_REFERENCES 1 |
| 461 | 457 | |
| 462 | 458 | |
| 463 | 459 | |
| 464 | 460 | typedef struct Jim_CallFrame { |
| 465 | | - unsigned long id; |
| 466 | | - int level; |
| 467 | | - struct Jim_HashTable vars; |
| 468 | | - struct Jim_HashTable *staticVars; |
| 469 | | - struct Jim_CallFrame *parent; |
| 470 | | - Jim_Obj *const *argv; |
| 471 | | - int argc; |
| 472 | | - Jim_Obj *procArgsObjPtr; |
| 473 | | - Jim_Obj *procBodyObjPtr; |
| 474 | | - struct Jim_CallFrame *next; |
| 475 | | - Jim_Obj *nsObj; |
| 476 | | - Jim_Obj *fileNameObj; |
| 461 | + unsigned long id; |
| 462 | + int level; |
| 463 | + struct Jim_HashTable vars; |
| 464 | + struct Jim_HashTable *staticVars; |
| 465 | + struct Jim_CallFrame *parent; |
| 466 | + Jim_Obj *const *argv; |
| 467 | + int argc; |
| 468 | + Jim_Obj *procArgsObjPtr; |
| 469 | + Jim_Obj *procBodyObjPtr; |
| 470 | + struct Jim_CallFrame *next; |
| 471 | + Jim_Obj *nsObj; |
| 472 | + Jim_Obj *fileNameObj; |
| 477 | 473 | int line; |
| 478 | | - Jim_Stack *localCommands; |
| 479 | | - struct Jim_Obj *tailcallObj; |
| 480 | | - struct Jim_Cmd *tailcallCmd; |
| 474 | + Jim_Stack *localCommands; |
| 475 | + struct Jim_Obj *tailcallObj; |
| 476 | + struct Jim_Cmd *tailcallCmd; |
| 481 | 477 | } Jim_CallFrame; |
| 482 | 478 | |
| 483 | 479 | typedef struct Jim_Var { |
| 484 | 480 | Jim_Obj *objPtr; |
| 485 | 481 | struct Jim_CallFrame *linkFramePtr; |
| | @@ -491,35 +487,35 @@ |
| 491 | 487 | typedef void Jim_DelCmdProc(struct Jim_Interp *interp, void *privData); |
| 492 | 488 | |
| 493 | 489 | |
| 494 | 490 | |
| 495 | 491 | typedef struct Jim_Cmd { |
| 496 | | - int inUse; |
| 497 | | - int isproc; |
| 498 | | - struct Jim_Cmd *prevCmd; |
| 492 | + int inUse; |
| 493 | + int isproc; |
| 494 | + struct Jim_Cmd *prevCmd; |
| 499 | 495 | union { |
| 500 | 496 | struct { |
| 501 | | - |
| 502 | | - Jim_CmdProc *cmdProc; |
| 503 | | - Jim_DelCmdProc *delProc; |
| 504 | | - void *privData; |
| 497 | + |
| 498 | + Jim_CmdProc *cmdProc; |
| 499 | + Jim_DelCmdProc *delProc; |
| 500 | + void *privData; |
| 505 | 501 | } native; |
| 506 | 502 | struct { |
| 507 | | - |
| 503 | + |
| 508 | 504 | Jim_Obj *argListObjPtr; |
| 509 | 505 | Jim_Obj *bodyObjPtr; |
| 510 | | - Jim_HashTable *staticVars; |
| 511 | | - int argListLen; |
| 512 | | - int reqArity; |
| 513 | | - int optArity; |
| 514 | | - int argsPos; |
| 515 | | - int upcall; |
| 506 | + Jim_HashTable *staticVars; |
| 507 | + int argListLen; |
| 508 | + int reqArity; |
| 509 | + int optArity; |
| 510 | + int argsPos; |
| 511 | + int upcall; |
| 516 | 512 | struct Jim_ProcArg { |
| 517 | | - Jim_Obj *nameObjPtr; |
| 518 | | - Jim_Obj *defaultObjPtr; |
| 513 | + Jim_Obj *nameObjPtr; |
| 514 | + Jim_Obj *defaultObjPtr; |
| 519 | 515 | } *arglist; |
| 520 | | - Jim_Obj *nsObj; |
| 516 | + Jim_Obj *nsObj; |
| 521 | 517 | } proc; |
| 522 | 518 | } u; |
| 523 | 519 | } Jim_Cmd; |
| 524 | 520 | |
| 525 | 521 | |
| | @@ -527,64 +523,64 @@ |
| 527 | 523 | unsigned char sbox[256]; |
| 528 | 524 | unsigned int i, j; |
| 529 | 525 | } Jim_PrngState; |
| 530 | 526 | |
| 531 | 527 | typedef struct Jim_Interp { |
| 532 | | - Jim_Obj *result; |
| 533 | | - int errorLine; |
| 534 | | - Jim_Obj *errorFileNameObj; |
| 535 | | - int addStackTrace; |
| 536 | | - int maxCallFrameDepth; |
| 537 | | - int maxEvalDepth; |
| 538 | | - int evalDepth; |
| 539 | | - int returnCode; |
| 540 | | - int returnLevel; |
| 541 | | - int exitCode; |
| 542 | | - long id; |
| 543 | | - int signal_level; |
| 544 | | - jim_wide sigmask; |
| 545 | | - int (*signal_set_result)(struct Jim_Interp *interp, jim_wide sigmask); |
| 546 | | - Jim_CallFrame *framePtr; |
| 547 | | - Jim_CallFrame *topFramePtr; |
| 548 | | - struct Jim_HashTable commands; |
| 528 | + Jim_Obj *result; |
| 529 | + int errorLine; |
| 530 | + Jim_Obj *errorFileNameObj; |
| 531 | + int addStackTrace; |
| 532 | + int maxCallFrameDepth; |
| 533 | + int maxEvalDepth; |
| 534 | + int evalDepth; |
| 535 | + int returnCode; |
| 536 | + int returnLevel; |
| 537 | + int exitCode; |
| 538 | + long id; |
| 539 | + int signal_level; |
| 540 | + jim_wide sigmask; |
| 541 | + int (*signal_set_result)(struct Jim_Interp *interp, jim_wide sigmask); |
| 542 | + Jim_CallFrame *framePtr; |
| 543 | + Jim_CallFrame *topFramePtr; |
| 544 | + struct Jim_HashTable commands; |
| 549 | 545 | unsigned long procEpoch; /* Incremented every time the result |
| 550 | 546 | of procedures names lookup caching |
| 551 | 547 | may no longer be valid. */ |
| 552 | 548 | unsigned long callFrameEpoch; /* Incremented every time a new |
| 553 | 549 | callframe is created. This id is used for the |
| 554 | 550 | 'ID' field contained in the Jim_CallFrame |
| 555 | 551 | structure. */ |
| 556 | | - int local; |
| 557 | | - Jim_Obj *liveList; |
| 558 | | - Jim_Obj *freeList; |
| 559 | | - Jim_Obj *currentScriptObj; |
| 560 | | - Jim_Obj *nullScriptObj; |
| 561 | | - Jim_Obj *emptyObj; |
| 562 | | - Jim_Obj *trueObj; |
| 563 | | - Jim_Obj *falseObj; |
| 564 | | - unsigned long referenceNextId; |
| 565 | | - struct Jim_HashTable references; |
| 552 | + int local; |
| 553 | + Jim_Obj *liveList; |
| 554 | + Jim_Obj *freeList; |
| 555 | + Jim_Obj *currentScriptObj; |
| 556 | + Jim_Obj *nullScriptObj; |
| 557 | + Jim_Obj *emptyObj; |
| 558 | + Jim_Obj *trueObj; |
| 559 | + Jim_Obj *falseObj; |
| 560 | + unsigned long referenceNextId; |
| 561 | + struct Jim_HashTable references; |
| 566 | 562 | unsigned long lastCollectId; /* reference max Id of the last GC |
| 567 | 563 | execution. It's set to -1 while the collection |
| 568 | 564 | is running as sentinel to avoid to recursive |
| 569 | 565 | calls via the [collect] command inside |
| 570 | 566 | finalizers. */ |
| 571 | | - time_t lastCollectTime; |
| 572 | | - Jim_Obj *stackTrace; |
| 573 | | - Jim_Obj *errorProc; |
| 574 | | - Jim_Obj *unknown; |
| 575 | | - int unknown_called; |
| 576 | | - int errorFlag; |
| 567 | + time_t lastCollectTime; |
| 568 | + Jim_Obj *stackTrace; |
| 569 | + Jim_Obj *errorProc; |
| 570 | + Jim_Obj *unknown; |
| 571 | + int unknown_called; |
| 572 | + int errorFlag; |
| 577 | 573 | void *cmdPrivData; /* Used to pass the private data pointer to |
| 578 | 574 | a command. It is set to what the user specified |
| 579 | 575 | via Jim_CreateCommand(). */ |
| 580 | 576 | |
| 581 | | - struct Jim_CallFrame *freeFramesList; |
| 582 | | - struct Jim_HashTable assocData; |
| 583 | | - Jim_PrngState *prngState; |
| 584 | | - struct Jim_HashTable packages; |
| 585 | | - Jim_Stack *loadHandles; |
| 577 | + struct Jim_CallFrame *freeFramesList; |
| 578 | + struct Jim_HashTable assocData; |
| 579 | + Jim_PrngState *prngState; |
| 580 | + struct Jim_HashTable packages; |
| 581 | + Jim_Stack *loadHandles; |
| 586 | 582 | } Jim_Interp; |
| 587 | 583 | |
| 588 | 584 | #define Jim_InterpIncrProcEpoch(i) (i)->procEpoch++ |
| 589 | 585 | #define Jim_SetResultString(i,s,l) Jim_SetResult(i, Jim_NewStringObj(i,s,l)) |
| 590 | 586 | #define Jim_SetResultInt(i,intval) Jim_SetResult(i, Jim_NewIntObj(i,intval)) |
| | @@ -835,14 +831,10 @@ |
| 835 | 831 | JIM_EXPORT int Jim_EvalExpression (Jim_Interp *interp, |
| 836 | 832 | Jim_Obj *exprObjPtr, Jim_Obj **exprResultPtrPtr); |
| 837 | 833 | JIM_EXPORT int Jim_GetBoolFromExpr (Jim_Interp *interp, |
| 838 | 834 | Jim_Obj *exprObjPtr, int *boolPtr); |
| 839 | 835 | |
| 840 | | - |
| 841 | | -JIM_EXPORT int Jim_GetBoolean(Jim_Interp *interp, Jim_Obj *objPtr, |
| 842 | | - int *booleanPtr); |
| 843 | | - |
| 844 | 836 | |
| 845 | 837 | JIM_EXPORT int Jim_GetWide (Jim_Interp *interp, Jim_Obj *objPtr, |
| 846 | 838 | jim_wide *widePtr); |
| 847 | 839 | JIM_EXPORT int Jim_GetLong (Jim_Interp *interp, Jim_Obj *objPtr, |
| 848 | 840 | long *longPtr); |
| | @@ -912,11 +904,11 @@ |
| 912 | 904 | |
| 913 | 905 | #ifdef __cplusplus |
| 914 | 906 | } |
| 915 | 907 | #endif |
| 916 | 908 | |
| 917 | | -#endif |
| 909 | +#endif |
| 918 | 910 | |
| 919 | 911 | #ifndef JIM_SUBCMD_H |
| 920 | 912 | #define JIM_SUBCMD_H |
| 921 | 913 | |
| 922 | 914 | |
| | @@ -923,24 +915,24 @@ |
| 923 | 915 | #ifdef __cplusplus |
| 924 | 916 | extern "C" { |
| 925 | 917 | #endif |
| 926 | 918 | |
| 927 | 919 | |
| 928 | | -#define JIM_MODFLAG_HIDDEN 0x0001 |
| 929 | | -#define JIM_MODFLAG_FULLARGV 0x0002 |
| 920 | +#define JIM_MODFLAG_HIDDEN 0x0001 |
| 921 | +#define JIM_MODFLAG_FULLARGV 0x0002 |
| 930 | 922 | |
| 931 | 923 | |
| 932 | 924 | |
| 933 | 925 | typedef int jim_subcmd_function(Jim_Interp *interp, int argc, Jim_Obj *const *argv); |
| 934 | 926 | |
| 935 | 927 | typedef struct { |
| 936 | | - const char *cmd; |
| 937 | | - const char *args; |
| 938 | | - jim_subcmd_function *function; |
| 939 | | - short minargs; |
| 940 | | - short maxargs; |
| 941 | | - unsigned short flags; |
| 928 | + const char *cmd; |
| 929 | + const char *args; |
| 930 | + jim_subcmd_function *function; |
| 931 | + short minargs; |
| 932 | + short maxargs; |
| 933 | + unsigned short flags; |
| 942 | 934 | } jim_subcmd_type; |
| 943 | 935 | |
| 944 | 936 | const jim_subcmd_type * |
| 945 | 937 | Jim_ParseSubCmd(Jim_Interp *interp, const jim_subcmd_type *command_table, int argc, Jim_Obj *const *argv); |
| 946 | 938 | |
| | @@ -968,36 +960,36 @@ |
| 968 | 960 | int rm_eo; |
| 969 | 961 | } regmatch_t; |
| 970 | 962 | |
| 971 | 963 | |
| 972 | 964 | typedef struct regexp { |
| 973 | | - |
| 974 | | - int re_nsub; |
| 975 | | - |
| 976 | | - |
| 977 | | - int cflags; |
| 978 | | - int err; |
| 979 | | - int regstart; |
| 980 | | - int reganch; |
| 981 | | - int regmust; |
| 982 | | - int regmlen; |
| 983 | | - int *program; |
| 984 | | - |
| 985 | | - |
| 986 | | - const char *regparse; |
| 987 | | - int p; |
| 988 | | - int proglen; |
| 989 | | - |
| 990 | | - |
| 991 | | - int eflags; |
| 992 | | - const char *start; |
| 993 | | - const char *reginput; |
| 994 | | - const char *regbol; |
| 995 | | - |
| 996 | | - |
| 997 | | - regmatch_t *pmatch; |
| 998 | | - int nmatch; |
| 965 | + |
| 966 | + int re_nsub; |
| 967 | + |
| 968 | + |
| 969 | + int cflags; |
| 970 | + int err; |
| 971 | + int regstart; |
| 972 | + int reganch; |
| 973 | + int regmust; |
| 974 | + int regmlen; |
| 975 | + int *program; |
| 976 | + |
| 977 | + |
| 978 | + const char *regparse; |
| 979 | + int p; |
| 980 | + int proglen; |
| 981 | + |
| 982 | + |
| 983 | + int eflags; |
| 984 | + const char *start; |
| 985 | + const char *reginput; |
| 986 | + const char *regbol; |
| 987 | + |
| 988 | + |
| 989 | + regmatch_t *pmatch; |
| 990 | + int nmatch; |
| 999 | 991 | } regexp; |
| 1000 | 992 | |
| 1001 | 993 | typedef regexp regex_t; |
| 1002 | 994 | |
| 1003 | 995 | #define REG_EXTENDED 0 |
| | @@ -1005,13 +997,13 @@ |
| 1005 | 997 | #define REG_ICASE 2 |
| 1006 | 998 | |
| 1007 | 999 | #define REG_NOTBOL 16 |
| 1008 | 1000 | |
| 1009 | 1001 | enum { |
| 1010 | | - REG_NOERROR, |
| 1011 | | - REG_NOMATCH, |
| 1012 | | - REG_BADPAT, |
| 1002 | + REG_NOERROR, |
| 1003 | + REG_NOMATCH, |
| 1004 | + REG_BADPAT, |
| 1013 | 1005 | REG_ERR_NULL_ARGUMENT, |
| 1014 | 1006 | REG_ERR_UNKNOWN, |
| 1015 | 1007 | REG_ERR_TOO_BIG, |
| 1016 | 1008 | REG_ERR_NOMEM, |
| 1017 | 1009 | REG_ERR_TOO_MANY_PAREN, |
| | @@ -1788,11 +1780,10 @@ |
| 1788 | 1780 | "}\n" |
| 1789 | 1781 | ); |
| 1790 | 1782 | } |
| 1791 | 1783 | |
| 1792 | 1784 | |
| 1793 | | -#define _GNU_SOURCE |
| 1794 | 1785 | #include <stdio.h> |
| 1795 | 1786 | #include <string.h> |
| 1796 | 1787 | #include <errno.h> |
| 1797 | 1788 | #include <fcntl.h> |
| 1798 | 1789 | #ifdef HAVE_UNISTD_H |
| | @@ -1817,12 +1808,12 @@ |
| 1817 | 1808 | #include <openssl/ssl.h> |
| 1818 | 1809 | #include <openssl/err.h> |
| 1819 | 1810 | #endif |
| 1820 | 1811 | |
| 1821 | 1812 | |
| 1822 | | -#define AIO_CMD_LEN 32 |
| 1823 | | -#define AIO_BUF_LEN 256 |
| 1813 | +#define AIO_CMD_LEN 32 |
| 1814 | +#define AIO_BUF_LEN 256 |
| 1824 | 1815 | |
| 1825 | 1816 | #ifndef HAVE_FTELLO |
| 1826 | 1817 | #define ftello ftell |
| 1827 | 1818 | #endif |
| 1828 | 1819 | #ifndef HAVE_FSEEKO |
| | @@ -1857,11 +1848,11 @@ |
| 1857 | 1848 | typedef struct AioFile |
| 1858 | 1849 | { |
| 1859 | 1850 | FILE *fp; |
| 1860 | 1851 | Jim_Obj *filename; |
| 1861 | 1852 | int type; |
| 1862 | | - int openFlags; |
| 1853 | + int openFlags; |
| 1863 | 1854 | int fd; |
| 1864 | 1855 | Jim_Obj *rEvent; |
| 1865 | 1856 | Jim_Obj *wEvent; |
| 1866 | 1857 | Jim_Obj *eEvent; |
| 1867 | 1858 | int addr_family; |
| | @@ -1888,11 +1879,11 @@ |
| 1888 | 1879 | { |
| 1889 | 1880 | if (!ferror(af->fp)) { |
| 1890 | 1881 | return JIM_OK; |
| 1891 | 1882 | } |
| 1892 | 1883 | clearerr(af->fp); |
| 1893 | | - |
| 1884 | + |
| 1894 | 1885 | if (feof(af->fp) || errno == EAGAIN || errno == EINTR) { |
| 1895 | 1886 | return JIM_OK; |
| 1896 | 1887 | } |
| 1897 | 1888 | #ifdef ECONNRESET |
| 1898 | 1889 | if (errno == ECONNRESET) { |
| | @@ -1954,12 +1945,12 @@ |
| 1954 | 1945 | JIM_NOTUSED(interp); |
| 1955 | 1946 | |
| 1956 | 1947 | Jim_DecrRefCount(interp, af->filename); |
| 1957 | 1948 | |
| 1958 | 1949 | #ifdef jim_ext_eventloop |
| 1959 | | - |
| 1960 | | - Jim_DeleteFileHandler(interp, af->fd, JIM_EVENT_READABLE | JIM_EVENT_WRITABLE | JIM_EVENT_EXCEPTION); |
| 1950 | + |
| 1951 | + Jim_DeleteFileHandler(interp, af->fp, JIM_EVENT_READABLE | JIM_EVENT_WRITABLE | JIM_EVENT_EXCEPTION); |
| 1961 | 1952 | #endif |
| 1962 | 1953 | |
| 1963 | 1954 | #if defined(JIM_SSL) |
| 1964 | 1955 | if (af->ssl != NULL) { |
| 1965 | 1956 | SSL_free(af->ssl); |
| | @@ -1977,11 +1968,11 @@ |
| 1977 | 1968 | { |
| 1978 | 1969 | AioFile *af = Jim_CmdPrivData(interp); |
| 1979 | 1970 | char buf[AIO_BUF_LEN]; |
| 1980 | 1971 | Jim_Obj *objPtr; |
| 1981 | 1972 | int nonewline = 0; |
| 1982 | | - jim_wide neededLen = -1; |
| 1973 | + jim_wide neededLen = -1; |
| 1983 | 1974 | |
| 1984 | 1975 | if (argc && Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) { |
| 1985 | 1976 | nonewline = 1; |
| 1986 | 1977 | argv++; |
| 1987 | 1978 | argc--; |
| | @@ -2016,11 +2007,11 @@ |
| 2016 | 2007 | } |
| 2017 | 2008 | } |
| 2018 | 2009 | if (retval != readlen) |
| 2019 | 2010 | break; |
| 2020 | 2011 | } |
| 2021 | | - |
| 2012 | + |
| 2022 | 2013 | if (JimCheckStreamError(interp, af)) { |
| 2023 | 2014 | Jim_FreeNewObj(interp, objPtr); |
| 2024 | 2015 | return JIM_ERR; |
| 2025 | 2016 | } |
| 2026 | 2017 | if (nonewline) { |
| | @@ -2038,11 +2029,11 @@ |
| 2038 | 2029 | |
| 2039 | 2030 | AioFile *Jim_AioFile(Jim_Interp *interp, Jim_Obj *command) |
| 2040 | 2031 | { |
| 2041 | 2032 | Jim_Cmd *cmdPtr = Jim_GetCommand(interp, command, JIM_ERRMSG); |
| 2042 | 2033 | |
| 2043 | | - |
| 2034 | + |
| 2044 | 2035 | if (cmdPtr && !cmdPtr->isproc && cmdPtr->u.native.cmdProc == JimAioSubCmdProc) { |
| 2045 | 2036 | return (AioFile *) cmdPtr->u.native.privData; |
| 2046 | 2037 | } |
| 2047 | 2038 | Jim_SetResultFormatted(interp, "Not a filehandle: \"%#s\"", command); |
| 2048 | 2039 | return NULL; |
| | @@ -2119,21 +2110,21 @@ |
| 2119 | 2110 | } |
| 2120 | 2111 | else { |
| 2121 | 2112 | len = strlen(buf); |
| 2122 | 2113 | |
| 2123 | 2114 | if (len && (buf[len - 1] == '\n')) { |
| 2124 | | - |
| 2115 | + |
| 2125 | 2116 | len--; |
| 2126 | 2117 | } |
| 2127 | 2118 | |
| 2128 | 2119 | Jim_AppendString(interp, objPtr, buf, len); |
| 2129 | 2120 | break; |
| 2130 | 2121 | } |
| 2131 | 2122 | } |
| 2132 | 2123 | |
| 2133 | 2124 | if (JimCheckStreamError(interp, af)) { |
| 2134 | | - |
| 2125 | + |
| 2135 | 2126 | Jim_FreeNewObj(interp, objPtr); |
| 2136 | 2127 | return JIM_ERR; |
| 2137 | 2128 | } |
| 2138 | 2129 | |
| 2139 | 2130 | if (argc) { |
| | @@ -2143,11 +2134,11 @@ |
| 2143 | 2134 | } |
| 2144 | 2135 | |
| 2145 | 2136 | len = Jim_Length(objPtr); |
| 2146 | 2137 | |
| 2147 | 2138 | if (len == 0 && feof(af->fp)) { |
| 2148 | | - |
| 2139 | + |
| 2149 | 2140 | len = -1; |
| 2150 | 2141 | } |
| 2151 | 2142 | Jim_SetResultInt(interp, len); |
| 2152 | 2143 | } |
| 2153 | 2144 | else { |
| | @@ -2373,33 +2364,33 @@ |
| 2373 | 2364 | |
| 2374 | 2365 | static int aio_eventinfo(Jim_Interp *interp, AioFile * af, unsigned mask, Jim_Obj **scriptHandlerObj, |
| 2375 | 2366 | int argc, Jim_Obj * const *argv) |
| 2376 | 2367 | { |
| 2377 | 2368 | if (argc == 0) { |
| 2378 | | - |
| 2369 | + |
| 2379 | 2370 | if (*scriptHandlerObj) { |
| 2380 | 2371 | Jim_SetResult(interp, *scriptHandlerObj); |
| 2381 | 2372 | } |
| 2382 | 2373 | return JIM_OK; |
| 2383 | 2374 | } |
| 2384 | 2375 | |
| 2385 | 2376 | if (*scriptHandlerObj) { |
| 2386 | | - |
| 2387 | | - Jim_DeleteFileHandler(interp, af->fd, mask); |
| 2377 | + |
| 2378 | + Jim_DeleteFileHandler(interp, af->fp, mask); |
| 2388 | 2379 | } |
| 2389 | 2380 | |
| 2390 | | - |
| 2381 | + |
| 2391 | 2382 | if (Jim_Length(argv[0]) == 0) { |
| 2392 | | - |
| 2383 | + |
| 2393 | 2384 | return JIM_OK; |
| 2394 | 2385 | } |
| 2395 | 2386 | |
| 2396 | | - |
| 2387 | + |
| 2397 | 2388 | Jim_IncrRefCount(argv[0]); |
| 2398 | 2389 | *scriptHandlerObj = argv[0]; |
| 2399 | 2390 | |
| 2400 | | - Jim_CreateFileHandler(interp, af->fd, mask, |
| 2391 | + Jim_CreateFileHandler(interp, af->fp, mask, |
| 2401 | 2392 | JimAioFileEventHandler, scriptHandlerObj, JimAioFileEventFinalizer); |
| 2402 | 2393 | |
| 2403 | 2394 | return JIM_OK; |
| 2404 | 2395 | } |
| 2405 | 2396 | |
| | @@ -2424,136 +2415,135 @@ |
| 2424 | 2415 | return aio_eventinfo(interp, af, JIM_EVENT_EXCEPTION, &af->eEvent, argc, argv); |
| 2425 | 2416 | } |
| 2426 | 2417 | #endif |
| 2427 | 2418 | |
| 2428 | 2419 | |
| 2429 | | - |
| 2430 | 2420 | static const jim_subcmd_type aio_command_table[] = { |
| 2431 | 2421 | { "read", |
| 2432 | 2422 | "?-nonewline? ?len?", |
| 2433 | 2423 | aio_cmd_read, |
| 2434 | 2424 | 0, |
| 2435 | 2425 | 2, |
| 2436 | | - |
| 2426 | + |
| 2437 | 2427 | }, |
| 2438 | 2428 | { "copyto", |
| 2439 | 2429 | "handle ?size?", |
| 2440 | 2430 | aio_cmd_copy, |
| 2441 | 2431 | 1, |
| 2442 | 2432 | 2, |
| 2443 | | - |
| 2433 | + |
| 2444 | 2434 | }, |
| 2445 | 2435 | { "gets", |
| 2446 | 2436 | "?var?", |
| 2447 | 2437 | aio_cmd_gets, |
| 2448 | 2438 | 0, |
| 2449 | 2439 | 1, |
| 2450 | | - |
| 2440 | + |
| 2451 | 2441 | }, |
| 2452 | 2442 | { "puts", |
| 2453 | 2443 | "?-nonewline? str", |
| 2454 | 2444 | aio_cmd_puts, |
| 2455 | 2445 | 1, |
| 2456 | 2446 | 2, |
| 2457 | | - |
| 2447 | + |
| 2458 | 2448 | }, |
| 2459 | 2449 | { "isatty", |
| 2460 | 2450 | NULL, |
| 2461 | 2451 | aio_cmd_isatty, |
| 2462 | 2452 | 0, |
| 2463 | 2453 | 0, |
| 2464 | | - |
| 2454 | + |
| 2465 | 2455 | }, |
| 2466 | 2456 | { "flush", |
| 2467 | 2457 | NULL, |
| 2468 | 2458 | aio_cmd_flush, |
| 2469 | 2459 | 0, |
| 2470 | 2460 | 0, |
| 2471 | | - |
| 2461 | + |
| 2472 | 2462 | }, |
| 2473 | 2463 | { "eof", |
| 2474 | 2464 | NULL, |
| 2475 | 2465 | aio_cmd_eof, |
| 2476 | 2466 | 0, |
| 2477 | 2467 | 0, |
| 2478 | | - |
| 2468 | + |
| 2479 | 2469 | }, |
| 2480 | 2470 | { "close", |
| 2481 | 2471 | "?r(ead)|w(rite)?", |
| 2482 | 2472 | aio_cmd_close, |
| 2483 | 2473 | 0, |
| 2484 | 2474 | 1, |
| 2485 | 2475 | JIM_MODFLAG_FULLARGV, |
| 2486 | | - |
| 2476 | + |
| 2487 | 2477 | }, |
| 2488 | 2478 | { "seek", |
| 2489 | 2479 | "offset ?start|current|end", |
| 2490 | 2480 | aio_cmd_seek, |
| 2491 | 2481 | 1, |
| 2492 | 2482 | 2, |
| 2493 | | - |
| 2483 | + |
| 2494 | 2484 | }, |
| 2495 | 2485 | { "tell", |
| 2496 | 2486 | NULL, |
| 2497 | 2487 | aio_cmd_tell, |
| 2498 | 2488 | 0, |
| 2499 | 2489 | 0, |
| 2500 | | - |
| 2490 | + |
| 2501 | 2491 | }, |
| 2502 | 2492 | { "filename", |
| 2503 | 2493 | NULL, |
| 2504 | 2494 | aio_cmd_filename, |
| 2505 | 2495 | 0, |
| 2506 | 2496 | 0, |
| 2507 | | - |
| 2497 | + |
| 2508 | 2498 | }, |
| 2509 | 2499 | #ifdef O_NDELAY |
| 2510 | 2500 | { "ndelay", |
| 2511 | 2501 | "?0|1?", |
| 2512 | 2502 | aio_cmd_ndelay, |
| 2513 | 2503 | 0, |
| 2514 | 2504 | 1, |
| 2515 | | - |
| 2505 | + |
| 2516 | 2506 | }, |
| 2517 | 2507 | #endif |
| 2518 | 2508 | #ifdef HAVE_FSYNC |
| 2519 | 2509 | { "sync", |
| 2520 | 2510 | NULL, |
| 2521 | 2511 | aio_cmd_sync, |
| 2522 | 2512 | 0, |
| 2523 | 2513 | 0, |
| 2524 | | - |
| 2514 | + |
| 2525 | 2515 | }, |
| 2526 | 2516 | #endif |
| 2527 | 2517 | { "buffering", |
| 2528 | 2518 | "none|line|full", |
| 2529 | 2519 | aio_cmd_buffering, |
| 2530 | 2520 | 1, |
| 2531 | 2521 | 1, |
| 2532 | | - |
| 2522 | + |
| 2533 | 2523 | }, |
| 2534 | 2524 | #ifdef jim_ext_eventloop |
| 2535 | 2525 | { "readable", |
| 2536 | 2526 | "?readable-script?", |
| 2537 | 2527 | aio_cmd_readable, |
| 2538 | 2528 | 0, |
| 2539 | 2529 | 1, |
| 2540 | | - |
| 2530 | + |
| 2541 | 2531 | }, |
| 2542 | 2532 | { "writable", |
| 2543 | 2533 | "?writable-script?", |
| 2544 | 2534 | aio_cmd_writable, |
| 2545 | 2535 | 0, |
| 2546 | 2536 | 1, |
| 2547 | | - |
| 2537 | + |
| 2548 | 2538 | }, |
| 2549 | 2539 | { "onexception", |
| 2550 | 2540 | "?exception-script?", |
| 2551 | 2541 | aio_cmd_onexception, |
| 2552 | 2542 | 0, |
| 2553 | 2543 | 1, |
| 2554 | | - |
| 2544 | + |
| 2555 | 2545 | }, |
| 2556 | 2546 | #endif |
| 2557 | 2547 | { NULL } |
| 2558 | 2548 | }; |
| 2559 | 2549 | |
| | @@ -2576,11 +2566,11 @@ |
| 2576 | 2566 | |
| 2577 | 2567 | #ifdef jim_ext_tclcompat |
| 2578 | 2568 | { |
| 2579 | 2569 | const char *filename = Jim_String(argv[1]); |
| 2580 | 2570 | |
| 2581 | | - |
| 2571 | + |
| 2582 | 2572 | if (*filename == '|') { |
| 2583 | 2573 | Jim_Obj *evalObj[3]; |
| 2584 | 2574 | |
| 2585 | 2575 | evalObj[0] = Jim_NewStringObj(interp, "::popen", -1); |
| 2586 | 2576 | evalObj[1] = Jim_NewStringObj(interp, filename + 1, -1); |
| | @@ -2633,11 +2623,11 @@ |
| 2633 | 2623 | Jim_DecrRefCount(interp, filename); |
| 2634 | 2624 | return NULL; |
| 2635 | 2625 | } |
| 2636 | 2626 | } |
| 2637 | 2627 | |
| 2638 | | - |
| 2628 | + |
| 2639 | 2629 | af = Jim_Alloc(sizeof(*af)); |
| 2640 | 2630 | memset(af, 0, sizeof(*af)); |
| 2641 | 2631 | af->fp = fh; |
| 2642 | 2632 | af->fd = fileno(fh); |
| 2643 | 2633 | af->filename = filename; |
| | @@ -2671,11 +2661,11 @@ |
| 2671 | 2661 | Jim_SetResult(interp, objPtr); |
| 2672 | 2662 | return JIM_OK; |
| 2673 | 2663 | } |
| 2674 | 2664 | } |
| 2675 | 2665 | |
| 2676 | | - |
| 2666 | + |
| 2677 | 2667 | close(p[0]); |
| 2678 | 2668 | close(p[1]); |
| 2679 | 2669 | JimAioSetError(interp, NULL); |
| 2680 | 2670 | return JIM_ERR; |
| 2681 | 2671 | } |
| | @@ -2705,15 +2695,15 @@ |
| 2705 | 2695 | } |
| 2706 | 2696 | |
| 2707 | 2697 | #if defined(S_IRWXG) && defined(S_IRWXO) |
| 2708 | 2698 | mask = umask(S_IXUSR | S_IRWXG | S_IRWXO); |
| 2709 | 2699 | #else |
| 2710 | | - |
| 2700 | + |
| 2711 | 2701 | mask = umask(S_IXUSR); |
| 2712 | 2702 | #endif |
| 2713 | 2703 | |
| 2714 | | - |
| 2704 | + |
| 2715 | 2705 | fd = mkstemp(filenameObj->bytes); |
| 2716 | 2706 | umask(mask); |
| 2717 | 2707 | if (fd < 0) { |
| 2718 | 2708 | JimAioSetError(interp, filenameObj); |
| 2719 | 2709 | Jim_FreeNewObj(interp, filenameObj); |
| | @@ -2741,11 +2731,11 @@ |
| 2741 | 2731 | Jim_CreateCommand(interp, "open", JimAioOpenCommand, NULL, NULL); |
| 2742 | 2732 | #ifndef JIM_ANSIC |
| 2743 | 2733 | Jim_CreateCommand(interp, "socket", JimAioSockCommand, NULL, NULL); |
| 2744 | 2734 | #endif |
| 2745 | 2735 | |
| 2746 | | - |
| 2736 | + |
| 2747 | 2737 | JimMakeChannel(interp, stdin, -1, NULL, "stdin", 0, "r"); |
| 2748 | 2738 | JimMakeChannel(interp, stdout, -1, NULL, "stdout", 0, "w"); |
| 2749 | 2739 | JimMakeChannel(interp, stderr, -1, NULL, "stderr", 0, "w"); |
| 2750 | 2740 | |
| 2751 | 2741 | return JIM_OK; |
| | @@ -2841,20 +2831,20 @@ |
| 2841 | 2831 | { |
| 2842 | 2832 | regex_t *compre; |
| 2843 | 2833 | const char *pattern; |
| 2844 | 2834 | int ret; |
| 2845 | 2835 | |
| 2846 | | - |
| 2836 | + |
| 2847 | 2837 | if (objPtr->typePtr == ®expObjType && |
| 2848 | 2838 | objPtr->internalRep.regexpValue.compre && objPtr->internalRep.regexpValue.flags == flags) { |
| 2849 | | - |
| 2839 | + |
| 2850 | 2840 | return objPtr->internalRep.regexpValue.compre; |
| 2851 | 2841 | } |
| 2852 | 2842 | |
| 2843 | + |
| 2853 | 2844 | |
| 2854 | | - |
| 2855 | | - |
| 2845 | + |
| 2856 | 2846 | pattern = Jim_String(objPtr); |
| 2857 | 2847 | compre = Jim_Alloc(sizeof(regex_t)); |
| 2858 | 2848 | |
| 2859 | 2849 | if ((ret = regcomp(compre, pattern, REG_EXTENDED | flags)) != 0) { |
| 2860 | 2850 | char buf[100]; |
| | @@ -3011,11 +3001,11 @@ |
| 3011 | 3001 | } |
| 3012 | 3002 | |
| 3013 | 3003 | num_matches++; |
| 3014 | 3004 | |
| 3015 | 3005 | if (opt_all && !opt_inline) { |
| 3016 | | - |
| 3006 | + |
| 3017 | 3007 | goto try_next_match; |
| 3018 | 3008 | } |
| 3019 | 3009 | |
| 3020 | 3010 | |
| 3021 | 3011 | j = 0; |
| | @@ -3051,11 +3041,11 @@ |
| 3051 | 3041 | |
| 3052 | 3042 | if (opt_inline) { |
| 3053 | 3043 | Jim_ListAppendElement(interp, resultListObj, resultObj); |
| 3054 | 3044 | } |
| 3055 | 3045 | else { |
| 3056 | | - |
| 3046 | + |
| 3057 | 3047 | result = Jim_SetVariable(interp, argv[i], resultObj); |
| 3058 | 3048 | |
| 3059 | 3049 | if (result != JIM_OK) { |
| 3060 | 3050 | Jim_FreeObj(interp, resultObj); |
| 3061 | 3051 | break; |
| | @@ -3178,11 +3168,11 @@ |
| 3178 | 3168 | |
| 3179 | 3169 | source_str = Jim_GetString(argv[i + 1], &source_len); |
| 3180 | 3170 | replace_str = Jim_GetString(argv[i + 2], &replace_len); |
| 3181 | 3171 | varname = argv[i + 3]; |
| 3182 | 3172 | |
| 3183 | | - |
| 3173 | + |
| 3184 | 3174 | resultObj = Jim_NewStringObj(interp, "", 0); |
| 3185 | 3175 | |
| 3186 | 3176 | if (offset) { |
| 3187 | 3177 | if (offset < 0) { |
| 3188 | 3178 | offset += source_len + 1; |
| | @@ -3193,11 +3183,11 @@ |
| 3193 | 3183 | else if (offset < 0) { |
| 3194 | 3184 | offset = 0; |
| 3195 | 3185 | } |
| 3196 | 3186 | } |
| 3197 | 3187 | |
| 3198 | | - |
| 3188 | + |
| 3199 | 3189 | Jim_AppendString(interp, resultObj, source_str, offset); |
| 3200 | 3190 | |
| 3201 | 3191 | |
| 3202 | 3192 | n = source_len - offset; |
| 3203 | 3193 | p = source_str + offset; |
| | @@ -3252,23 +3242,23 @@ |
| 3252 | 3242 | } |
| 3253 | 3243 | |
| 3254 | 3244 | p += pmatch[0].rm_eo; |
| 3255 | 3245 | n -= pmatch[0].rm_eo; |
| 3256 | 3246 | |
| 3257 | | - |
| 3247 | + |
| 3258 | 3248 | if (!opt_all || n == 0) { |
| 3259 | 3249 | break; |
| 3260 | 3250 | } |
| 3261 | 3251 | |
| 3262 | | - |
| 3252 | + |
| 3263 | 3253 | if ((regcomp_flags & REG_NEWLINE) == 0 && pattern[0] == '^') { |
| 3264 | 3254 | break; |
| 3265 | 3255 | } |
| 3266 | 3256 | |
| 3267 | | - |
| 3257 | + |
| 3268 | 3258 | if (pattern[0] == '\0' && n) { |
| 3269 | | - |
| 3259 | + |
| 3270 | 3260 | Jim_AppendString(interp, resultObj, p, 1); |
| 3271 | 3261 | p++; |
| 3272 | 3262 | n--; |
| 3273 | 3263 | } |
| 3274 | 3264 | |
| | @@ -3275,11 +3265,11 @@ |
| 3275 | 3265 | regexec_flags |= REG_NOTBOL; |
| 3276 | 3266 | } while (n); |
| 3277 | 3267 | |
| 3278 | 3268 | Jim_AppendString(interp, resultObj, p, -1); |
| 3279 | 3269 | |
| 3280 | | - |
| 3270 | + |
| 3281 | 3271 | if (argc - i == 4) { |
| 3282 | 3272 | result = Jim_SetVariable(interp, varname, resultObj); |
| 3283 | 3273 | |
| 3284 | 3274 | if (result == JIM_OK) { |
| 3285 | 3275 | Jim_SetResultInt(interp, num_matches); |
| | @@ -3381,11 +3371,11 @@ |
| 3381 | 3371 | Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, value)); |
| 3382 | 3372 | } |
| 3383 | 3373 | |
| 3384 | 3374 | static int StoreStatData(Jim_Interp *interp, Jim_Obj *varName, const struct stat *sb) |
| 3385 | 3375 | { |
| 3386 | | - |
| 3376 | + |
| 3387 | 3377 | Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0); |
| 3388 | 3378 | |
| 3389 | 3379 | AppendStatElement(interp, listObj, "dev", sb->st_dev); |
| 3390 | 3380 | AppendStatElement(interp, listObj, "ino", sb->st_ino); |
| 3391 | 3381 | AppendStatElement(interp, listObj, "mode", sb->st_mode); |
| | @@ -3397,25 +3387,25 @@ |
| 3397 | 3387 | AppendStatElement(interp, listObj, "mtime", sb->st_mtime); |
| 3398 | 3388 | AppendStatElement(interp, listObj, "ctime", sb->st_ctime); |
| 3399 | 3389 | Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "type", -1)); |
| 3400 | 3390 | Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, JimGetFileType((int)sb->st_mode), -1)); |
| 3401 | 3391 | |
| 3402 | | - |
| 3392 | + |
| 3403 | 3393 | if (varName) { |
| 3404 | 3394 | Jim_Obj *objPtr = Jim_GetVariable(interp, varName, JIM_NONE); |
| 3405 | 3395 | if (objPtr) { |
| 3406 | 3396 | if (Jim_DictSize(interp, objPtr) < 0) { |
| 3407 | | - |
| 3397 | + |
| 3408 | 3398 | Jim_SetResultFormatted(interp, "can't set \"%#s(dev)\": variable isn't array", varName); |
| 3409 | 3399 | Jim_FreeNewObj(interp, listObj); |
| 3410 | 3400 | return JIM_ERR; |
| 3411 | 3401 | } |
| 3412 | 3402 | |
| 3413 | 3403 | if (Jim_IsShared(objPtr)) |
| 3414 | 3404 | objPtr = Jim_DuplicateObj(interp, objPtr); |
| 3415 | 3405 | |
| 3416 | | - |
| 3406 | + |
| 3417 | 3407 | Jim_ListAppendList(interp, objPtr, listObj); |
| 3418 | 3408 | Jim_DictSize(interp, objPtr); |
| 3419 | 3409 | Jim_InvalidateStringRep(objPtr); |
| 3420 | 3410 | |
| 3421 | 3411 | Jim_FreeNewObj(interp, listObj); |
| | @@ -3422,11 +3412,11 @@ |
| 3422 | 3412 | listObj = objPtr; |
| 3423 | 3413 | } |
| 3424 | 3414 | Jim_SetVariable(interp, varName, listObj); |
| 3425 | 3415 | } |
| 3426 | 3416 | |
| 3427 | | - |
| 3417 | + |
| 3428 | 3418 | Jim_SetResult(interp, listObj); |
| 3429 | 3419 | |
| 3430 | 3420 | return JIM_OK; |
| 3431 | 3421 | } |
| 3432 | 3422 | |
| | @@ -3442,11 +3432,11 @@ |
| 3442 | 3432 | } |
| 3443 | 3433 | else if (p == path) { |
| 3444 | 3434 | Jim_SetResultString(interp, "/", -1); |
| 3445 | 3435 | } |
| 3446 | 3436 | else if (ISWINDOWS && p[-1] == ':') { |
| 3447 | | - |
| 3437 | + |
| 3448 | 3438 | Jim_SetResultString(interp, path, p - path + 1); |
| 3449 | 3439 | } |
| 3450 | 3440 | else { |
| 3451 | 3441 | Jim_SetResultString(interp, path, p - path); |
| 3452 | 3442 | } |
| | @@ -3522,35 +3512,35 @@ |
| 3522 | 3512 | char *newname = Jim_Alloc(MAXPATHLEN + 1); |
| 3523 | 3513 | char *last = newname; |
| 3524 | 3514 | |
| 3525 | 3515 | *newname = 0; |
| 3526 | 3516 | |
| 3527 | | - |
| 3517 | + |
| 3528 | 3518 | for (i = 0; i < argc; i++) { |
| 3529 | 3519 | int len; |
| 3530 | 3520 | const char *part = Jim_GetString(argv[i], &len); |
| 3531 | 3521 | |
| 3532 | 3522 | if (*part == '/') { |
| 3533 | | - |
| 3523 | + |
| 3534 | 3524 | last = newname; |
| 3535 | 3525 | } |
| 3536 | 3526 | else if (ISWINDOWS && strchr(part, ':')) { |
| 3537 | | - |
| 3527 | + |
| 3538 | 3528 | last = newname; |
| 3539 | 3529 | } |
| 3540 | 3530 | else if (part[0] == '.') { |
| 3541 | 3531 | if (part[1] == '/') { |
| 3542 | 3532 | part += 2; |
| 3543 | 3533 | len -= 2; |
| 3544 | 3534 | } |
| 3545 | 3535 | else if (part[1] == 0 && last != newname) { |
| 3546 | | - |
| 3536 | + |
| 3547 | 3537 | continue; |
| 3548 | 3538 | } |
| 3549 | 3539 | } |
| 3550 | 3540 | |
| 3551 | | - |
| 3541 | + |
| 3552 | 3542 | if (last != newname && last[-1] != '/') { |
| 3553 | 3543 | *last++ = '/'; |
| 3554 | 3544 | } |
| 3555 | 3545 | |
| 3556 | 3546 | if (len) { |
| | @@ -3561,22 +3551,22 @@ |
| 3561 | 3551 | } |
| 3562 | 3552 | memcpy(last, part, len); |
| 3563 | 3553 | last += len; |
| 3564 | 3554 | } |
| 3565 | 3555 | |
| 3566 | | - |
| 3556 | + |
| 3567 | 3557 | if (last > newname + 1 && last[-1] == '/') { |
| 3568 | | - |
| 3558 | + |
| 3569 | 3559 | if (!ISWINDOWS || !(last > newname + 2 && last[-2] == ':')) { |
| 3570 | 3560 | *--last = 0; |
| 3571 | 3561 | } |
| 3572 | 3562 | } |
| 3573 | 3563 | } |
| 3574 | 3564 | |
| 3575 | 3565 | *last = 0; |
| 3576 | 3566 | |
| 3577 | | - |
| 3567 | + |
| 3578 | 3568 | |
| 3579 | 3569 | Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, newname, last - newname)); |
| 3580 | 3570 | |
| 3581 | 3571 | return JIM_OK; |
| 3582 | 3572 | } |
| | @@ -3601,11 +3591,11 @@ |
| 3601 | 3591 | static int file_cmd_executable(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 3602 | 3592 | { |
| 3603 | 3593 | #ifdef X_OK |
| 3604 | 3594 | return file_access(interp, argv[0], X_OK); |
| 3605 | 3595 | #else |
| 3606 | | - |
| 3596 | + |
| 3607 | 3597 | Jim_SetResultBool(interp, 1); |
| 3608 | 3598 | return JIM_OK; |
| 3609 | 3599 | #endif |
| 3610 | 3600 | } |
| 3611 | 3601 | |
| | @@ -3626,11 +3616,11 @@ |
| 3626 | 3616 | while (argc--) { |
| 3627 | 3617 | const char *path = Jim_String(argv[0]); |
| 3628 | 3618 | |
| 3629 | 3619 | if (unlink(path) == -1 && errno != ENOENT) { |
| 3630 | 3620 | if (rmdir(path) == -1) { |
| 3631 | | - |
| 3621 | + |
| 3632 | 3622 | if (!force || Jim_EvalPrefix(interp, "file delete force", 1, argv) != JIM_OK) { |
| 3633 | 3623 | Jim_SetResultFormatted(interp, "couldn't delete file \"%s\": %s", path, |
| 3634 | 3624 | strerror(errno)); |
| 3635 | 3625 | return JIM_ERR; |
| 3636 | 3626 | } |
| | @@ -3649,15 +3639,15 @@ |
| 3649 | 3639 | |
| 3650 | 3640 | static int mkdir_all(char *path) |
| 3651 | 3641 | { |
| 3652 | 3642 | int ok = 1; |
| 3653 | 3643 | |
| 3654 | | - |
| 3644 | + |
| 3655 | 3645 | goto first; |
| 3656 | 3646 | |
| 3657 | 3647 | while (ok--) { |
| 3658 | | - |
| 3648 | + |
| 3659 | 3649 | { |
| 3660 | 3650 | char *slash = strrchr(path, '/'); |
| 3661 | 3651 | |
| 3662 | 3652 | if (slash && slash != path) { |
| 3663 | 3653 | *slash = 0; |
| | @@ -3670,24 +3660,24 @@ |
| 3670 | 3660 | first: |
| 3671 | 3661 | if (MKDIR_DEFAULT(path) == 0) { |
| 3672 | 3662 | return 0; |
| 3673 | 3663 | } |
| 3674 | 3664 | if (errno == ENOENT) { |
| 3675 | | - |
| 3665 | + |
| 3676 | 3666 | continue; |
| 3677 | 3667 | } |
| 3678 | | - |
| 3668 | + |
| 3679 | 3669 | if (errno == EEXIST) { |
| 3680 | 3670 | struct stat sb; |
| 3681 | 3671 | |
| 3682 | 3672 | if (stat(path, &sb) == 0 && S_ISDIR(sb.st_mode)) { |
| 3683 | 3673 | return 0; |
| 3684 | 3674 | } |
| 3685 | | - |
| 3675 | + |
| 3686 | 3676 | errno = EEXIST; |
| 3687 | 3677 | } |
| 3688 | | - |
| 3678 | + |
| 3689 | 3679 | break; |
| 3690 | 3680 | } |
| 3691 | 3681 | return -1; |
| 3692 | 3682 | } |
| 3693 | 3683 | |
| | @@ -3972,192 +3962,192 @@ |
| 3972 | 3962 | { "atime", |
| 3973 | 3963 | "name", |
| 3974 | 3964 | file_cmd_atime, |
| 3975 | 3965 | 1, |
| 3976 | 3966 | 1, |
| 3977 | | - |
| 3967 | + |
| 3978 | 3968 | }, |
| 3979 | 3969 | { "mtime", |
| 3980 | 3970 | "name ?time?", |
| 3981 | 3971 | file_cmd_mtime, |
| 3982 | 3972 | 1, |
| 3983 | 3973 | 2, |
| 3984 | | - |
| 3974 | + |
| 3985 | 3975 | }, |
| 3986 | 3976 | { "copy", |
| 3987 | 3977 | "?-force? source dest", |
| 3988 | 3978 | file_cmd_copy, |
| 3989 | 3979 | 2, |
| 3990 | 3980 | 3, |
| 3991 | | - |
| 3981 | + |
| 3992 | 3982 | }, |
| 3993 | 3983 | { "dirname", |
| 3994 | 3984 | "name", |
| 3995 | 3985 | file_cmd_dirname, |
| 3996 | 3986 | 1, |
| 3997 | 3987 | 1, |
| 3998 | | - |
| 3988 | + |
| 3999 | 3989 | }, |
| 4000 | 3990 | { "rootname", |
| 4001 | 3991 | "name", |
| 4002 | 3992 | file_cmd_rootname, |
| 4003 | 3993 | 1, |
| 4004 | 3994 | 1, |
| 4005 | | - |
| 3995 | + |
| 4006 | 3996 | }, |
| 4007 | 3997 | { "extension", |
| 4008 | 3998 | "name", |
| 4009 | 3999 | file_cmd_extension, |
| 4010 | 4000 | 1, |
| 4011 | 4001 | 1, |
| 4012 | | - |
| 4002 | + |
| 4013 | 4003 | }, |
| 4014 | 4004 | { "tail", |
| 4015 | 4005 | "name", |
| 4016 | 4006 | file_cmd_tail, |
| 4017 | 4007 | 1, |
| 4018 | 4008 | 1, |
| 4019 | | - |
| 4009 | + |
| 4020 | 4010 | }, |
| 4021 | 4011 | { "normalize", |
| 4022 | 4012 | "name", |
| 4023 | 4013 | file_cmd_normalize, |
| 4024 | 4014 | 1, |
| 4025 | 4015 | 1, |
| 4026 | | - |
| 4016 | + |
| 4027 | 4017 | }, |
| 4028 | 4018 | { "join", |
| 4029 | 4019 | "name ?name ...?", |
| 4030 | 4020 | file_cmd_join, |
| 4031 | 4021 | 1, |
| 4032 | 4022 | -1, |
| 4033 | | - |
| 4023 | + |
| 4034 | 4024 | }, |
| 4035 | 4025 | { "readable", |
| 4036 | 4026 | "name", |
| 4037 | 4027 | file_cmd_readable, |
| 4038 | 4028 | 1, |
| 4039 | 4029 | 1, |
| 4040 | | - |
| 4030 | + |
| 4041 | 4031 | }, |
| 4042 | 4032 | { "writable", |
| 4043 | 4033 | "name", |
| 4044 | 4034 | file_cmd_writable, |
| 4045 | 4035 | 1, |
| 4046 | 4036 | 1, |
| 4047 | | - |
| 4037 | + |
| 4048 | 4038 | }, |
| 4049 | 4039 | { "executable", |
| 4050 | 4040 | "name", |
| 4051 | 4041 | file_cmd_executable, |
| 4052 | 4042 | 1, |
| 4053 | 4043 | 1, |
| 4054 | | - |
| 4044 | + |
| 4055 | 4045 | }, |
| 4056 | 4046 | { "exists", |
| 4057 | 4047 | "name", |
| 4058 | 4048 | file_cmd_exists, |
| 4059 | 4049 | 1, |
| 4060 | 4050 | 1, |
| 4061 | | - |
| 4051 | + |
| 4062 | 4052 | }, |
| 4063 | 4053 | { "delete", |
| 4064 | 4054 | "?-force|--? name ...", |
| 4065 | 4055 | file_cmd_delete, |
| 4066 | 4056 | 1, |
| 4067 | 4057 | -1, |
| 4068 | | - |
| 4058 | + |
| 4069 | 4059 | }, |
| 4070 | 4060 | { "mkdir", |
| 4071 | 4061 | "dir ...", |
| 4072 | 4062 | file_cmd_mkdir, |
| 4073 | 4063 | 1, |
| 4074 | 4064 | -1, |
| 4075 | | - |
| 4065 | + |
| 4076 | 4066 | }, |
| 4077 | 4067 | { "tempfile", |
| 4078 | 4068 | "?template?", |
| 4079 | 4069 | file_cmd_tempfile, |
| 4080 | 4070 | 0, |
| 4081 | 4071 | 1, |
| 4082 | | - |
| 4072 | + |
| 4083 | 4073 | }, |
| 4084 | 4074 | { "rename", |
| 4085 | 4075 | "?-force? source dest", |
| 4086 | 4076 | file_cmd_rename, |
| 4087 | 4077 | 2, |
| 4088 | 4078 | 3, |
| 4089 | | - |
| 4079 | + |
| 4090 | 4080 | }, |
| 4091 | 4081 | #if defined(HAVE_LINK) && defined(HAVE_SYMLINK) |
| 4092 | 4082 | { "link", |
| 4093 | 4083 | "?-symbolic|-hard? newname target", |
| 4094 | 4084 | file_cmd_link, |
| 4095 | 4085 | 2, |
| 4096 | 4086 | 3, |
| 4097 | | - |
| 4087 | + |
| 4098 | 4088 | }, |
| 4099 | 4089 | #endif |
| 4100 | 4090 | #if defined(HAVE_READLINK) |
| 4101 | 4091 | { "readlink", |
| 4102 | 4092 | "name", |
| 4103 | 4093 | file_cmd_readlink, |
| 4104 | 4094 | 1, |
| 4105 | 4095 | 1, |
| 4106 | | - |
| 4096 | + |
| 4107 | 4097 | }, |
| 4108 | 4098 | #endif |
| 4109 | 4099 | { "size", |
| 4110 | 4100 | "name", |
| 4111 | 4101 | file_cmd_size, |
| 4112 | 4102 | 1, |
| 4113 | 4103 | 1, |
| 4114 | | - |
| 4104 | + |
| 4115 | 4105 | }, |
| 4116 | 4106 | { "stat", |
| 4117 | 4107 | "name ?var?", |
| 4118 | 4108 | file_cmd_stat, |
| 4119 | 4109 | 1, |
| 4120 | 4110 | 2, |
| 4121 | | - |
| 4111 | + |
| 4122 | 4112 | }, |
| 4123 | 4113 | { "lstat", |
| 4124 | 4114 | "name ?var?", |
| 4125 | 4115 | file_cmd_lstat, |
| 4126 | 4116 | 1, |
| 4127 | 4117 | 2, |
| 4128 | | - |
| 4118 | + |
| 4129 | 4119 | }, |
| 4130 | 4120 | { "type", |
| 4131 | 4121 | "name", |
| 4132 | 4122 | file_cmd_type, |
| 4133 | 4123 | 1, |
| 4134 | 4124 | 1, |
| 4135 | | - |
| 4125 | + |
| 4136 | 4126 | }, |
| 4137 | 4127 | #ifdef HAVE_GETEUID |
| 4138 | 4128 | { "owned", |
| 4139 | 4129 | "name", |
| 4140 | 4130 | file_cmd_owned, |
| 4141 | 4131 | 1, |
| 4142 | 4132 | 1, |
| 4143 | | - |
| 4133 | + |
| 4144 | 4134 | }, |
| 4145 | 4135 | #endif |
| 4146 | 4136 | { "isdirectory", |
| 4147 | 4137 | "name", |
| 4148 | 4138 | file_cmd_isdirectory, |
| 4149 | 4139 | 1, |
| 4150 | 4140 | 1, |
| 4151 | | - |
| 4141 | + |
| 4152 | 4142 | }, |
| 4153 | 4143 | { "isfile", |
| 4154 | 4144 | "name", |
| 4155 | 4145 | file_cmd_isfile, |
| 4156 | 4146 | 1, |
| 4157 | 4147 | 1, |
| 4158 | | - |
| 4148 | + |
| 4159 | 4149 | }, |
| 4160 | 4150 | { |
| 4161 | 4151 | NULL |
| 4162 | 4152 | } |
| 4163 | 4153 | }; |
| | @@ -4189,11 +4179,11 @@ |
| 4189 | 4179 | Jim_SetResultString(interp, "Failed to get pwd", -1); |
| 4190 | 4180 | Jim_Free(cwd); |
| 4191 | 4181 | return JIM_ERR; |
| 4192 | 4182 | } |
| 4193 | 4183 | else if (ISWINDOWS) { |
| 4194 | | - |
| 4184 | + |
| 4195 | 4185 | char *p = cwd; |
| 4196 | 4186 | while ((p = strchr(p, '\\')) != NULL) { |
| 4197 | 4187 | *p++ = '/'; |
| 4198 | 4188 | } |
| 4199 | 4189 | } |
| | @@ -4213,11 +4203,10 @@ |
| 4213 | 4203 | Jim_CreateCommand(interp, "pwd", Jim_PwdCmd, NULL, NULL); |
| 4214 | 4204 | Jim_CreateCommand(interp, "cd", Jim_CdCmd, NULL, NULL); |
| 4215 | 4205 | return JIM_OK; |
| 4216 | 4206 | } |
| 4217 | 4207 | |
| 4218 | | -#define _GNU_SOURCE |
| 4219 | 4208 | #include <string.h> |
| 4220 | 4209 | #include <ctype.h> |
| 4221 | 4210 | |
| 4222 | 4211 | |
| 4223 | 4212 | #if (!defined(HAVE_VFORK) || !defined(HAVE_WAITPID)) && !defined(__MINGW32__) |
| | @@ -4225,20 +4214,20 @@ |
| 4225 | 4214 | { |
| 4226 | 4215 | Jim_Obj *cmdlineObj = Jim_NewEmptyStringObj(interp); |
| 4227 | 4216 | int i, j; |
| 4228 | 4217 | int rc; |
| 4229 | 4218 | |
| 4230 | | - |
| 4219 | + |
| 4231 | 4220 | for (i = 1; i < argc; i++) { |
| 4232 | 4221 | int len; |
| 4233 | 4222 | const char *arg = Jim_GetString(argv[i], &len); |
| 4234 | 4223 | |
| 4235 | 4224 | if (i > 1) { |
| 4236 | 4225 | Jim_AppendString(interp, cmdlineObj, " ", 1); |
| 4237 | 4226 | } |
| 4238 | 4227 | if (strpbrk(arg, "\\\" ") == NULL) { |
| 4239 | | - |
| 4228 | + |
| 4240 | 4229 | Jim_AppendString(interp, cmdlineObj, arg, len); |
| 4241 | 4230 | continue; |
| 4242 | 4231 | } |
| 4243 | 4232 | |
| 4244 | 4233 | Jim_AppendString(interp, cmdlineObj, "\"", 1); |
| | @@ -4279,11 +4268,11 @@ |
| 4279 | 4268 | |
| 4280 | 4269 | #include <errno.h> |
| 4281 | 4270 | #include <signal.h> |
| 4282 | 4271 | |
| 4283 | 4272 | #if defined(__MINGW32__) |
| 4284 | | - |
| 4273 | + |
| 4285 | 4274 | #ifndef STRICT |
| 4286 | 4275 | #define STRICT |
| 4287 | 4276 | #endif |
| 4288 | 4277 | #define WIN32_LEAN_AND_MEAN |
| 4289 | 4278 | #include <windows.h> |
| | @@ -4405,14 +4394,14 @@ |
| 4405 | 4394 | if (!objPtr) { |
| 4406 | 4395 | return Jim_GetEnviron(); |
| 4407 | 4396 | } |
| 4408 | 4397 | |
| 4409 | 4398 | |
| 4410 | | - |
| 4399 | + |
| 4411 | 4400 | num = Jim_ListLength(interp, objPtr); |
| 4412 | 4401 | if (num % 2) { |
| 4413 | | - |
| 4402 | + |
| 4414 | 4403 | num--; |
| 4415 | 4404 | } |
| 4416 | 4405 | size = Jim_Length(objPtr) + 2; |
| 4417 | 4406 | |
| 4418 | 4407 | envptr = Jim_Alloc(sizeof(*envptr) * (num / 2 + 1) + size); |
| | @@ -4504,19 +4493,19 @@ |
| 4504 | 4493 | } |
| 4505 | 4494 | |
| 4506 | 4495 | |
| 4507 | 4496 | struct WaitInfo |
| 4508 | 4497 | { |
| 4509 | | - pidtype pid; |
| 4510 | | - int status; |
| 4511 | | - int flags; |
| 4498 | + pidtype pid; |
| 4499 | + int status; |
| 4500 | + int flags; |
| 4512 | 4501 | }; |
| 4513 | 4502 | |
| 4514 | 4503 | struct WaitInfoTable { |
| 4515 | | - struct WaitInfo *info; |
| 4516 | | - int size; |
| 4517 | | - int used; |
| 4504 | + struct WaitInfo *info; |
| 4505 | + int size; |
| 4506 | + int used; |
| 4518 | 4507 | }; |
| 4519 | 4508 | |
| 4520 | 4509 | |
| 4521 | 4510 | #define WI_DETACHED 2 |
| 4522 | 4511 | |
| | @@ -4539,12 +4528,12 @@ |
| 4539 | 4528 | return table; |
| 4540 | 4529 | } |
| 4541 | 4530 | |
| 4542 | 4531 | static int Jim_ExecCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 4543 | 4532 | { |
| 4544 | | - fdtype outputId; |
| 4545 | | - fdtype errorId; |
| 4533 | + fdtype outputId; |
| 4534 | + fdtype errorId; |
| 4546 | 4535 | pidtype *pidPtr; |
| 4547 | 4536 | int numPids, result; |
| 4548 | 4537 | int child_siginfo = 1; |
| 4549 | 4538 | Jim_Obj *childErrObj; |
| 4550 | 4539 | Jim_Obj *errStrObj; |
| | @@ -4556,11 +4545,11 @@ |
| 4556 | 4545 | argc--; |
| 4557 | 4546 | numPids = JimCreatePipeline(interp, argc - 1, argv + 1, &pidPtr, NULL, NULL, NULL); |
| 4558 | 4547 | if (numPids < 0) { |
| 4559 | 4548 | return JIM_ERR; |
| 4560 | 4549 | } |
| 4561 | | - |
| 4550 | + |
| 4562 | 4551 | listObj = Jim_NewListObj(interp, NULL, 0); |
| 4563 | 4552 | for (i = 0; i < numPids; i++) { |
| 4564 | 4553 | Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, (long)pidPtr[i])); |
| 4565 | 4554 | } |
| 4566 | 4555 | Jim_SetResult(interp, listObj); |
| | @@ -4578,19 +4567,19 @@ |
| 4578 | 4567 | |
| 4579 | 4568 | result = JIM_OK; |
| 4580 | 4569 | |
| 4581 | 4570 | errStrObj = Jim_NewStringObj(interp, "", 0); |
| 4582 | 4571 | |
| 4583 | | - |
| 4572 | + |
| 4584 | 4573 | if (outputId != JIM_BAD_FD) { |
| 4585 | 4574 | if (JimAppendStreamToString(interp, outputId, errStrObj) < 0) { |
| 4586 | 4575 | result = JIM_ERR; |
| 4587 | 4576 | Jim_SetResultErrno(interp, "error reading from output pipe"); |
| 4588 | 4577 | } |
| 4589 | 4578 | } |
| 4590 | 4579 | |
| 4591 | | - |
| 4580 | + |
| 4592 | 4581 | childErrObj = Jim_NewStringObj(interp, "", 0); |
| 4593 | 4582 | Jim_IncrRefCount(childErrObj); |
| 4594 | 4583 | |
| 4595 | 4584 | if (JimCleanupChildren(interp, numPids, pidPtr, childErrObj) != JIM_OK) { |
| 4596 | 4585 | result = JIM_ERR; |
| | @@ -4603,25 +4592,25 @@ |
| 4603 | 4592 | if (ret < 0) { |
| 4604 | 4593 | Jim_SetResultErrno(interp, "error reading from error pipe"); |
| 4605 | 4594 | result = JIM_ERR; |
| 4606 | 4595 | } |
| 4607 | 4596 | else if (ret > 0) { |
| 4608 | | - |
| 4597 | + |
| 4609 | 4598 | child_siginfo = 0; |
| 4610 | 4599 | } |
| 4611 | 4600 | } |
| 4612 | 4601 | |
| 4613 | 4602 | if (child_siginfo) { |
| 4614 | | - |
| 4603 | + |
| 4615 | 4604 | Jim_AppendObj(interp, errStrObj, childErrObj); |
| 4616 | 4605 | } |
| 4617 | 4606 | Jim_DecrRefCount(interp, childErrObj); |
| 4618 | 4607 | |
| 4619 | | - |
| 4608 | + |
| 4620 | 4609 | Jim_RemoveTrailingNewline(errStrObj); |
| 4621 | 4610 | |
| 4622 | | - |
| 4611 | + |
| 4623 | 4612 | Jim_SetResult(interp, errStrObj); |
| 4624 | 4613 | |
| 4625 | 4614 | return result; |
| 4626 | 4615 | } |
| 4627 | 4616 | |
| | @@ -4640,11 +4629,11 @@ |
| 4640 | 4629 | for (count = table->used; count > 0; waitPtr++, count--) { |
| 4641 | 4630 | if (waitPtr->flags & WI_DETACHED) { |
| 4642 | 4631 | int status; |
| 4643 | 4632 | pidtype pid = JimWaitPid(waitPtr->pid, &status, WNOHANG); |
| 4644 | 4633 | if (pid == waitPtr->pid) { |
| 4645 | | - |
| 4634 | + |
| 4646 | 4635 | table->used--; |
| 4647 | 4636 | continue; |
| 4648 | 4637 | } |
| 4649 | 4638 | } |
| 4650 | 4639 | if (waitPtr != &table->info[dest]) { |
| | @@ -4656,36 +4645,36 @@ |
| 4656 | 4645 | |
| 4657 | 4646 | static pidtype JimWaitForProcess(struct WaitInfoTable *table, pidtype pid, int *statusPtr) |
| 4658 | 4647 | { |
| 4659 | 4648 | int i; |
| 4660 | 4649 | |
| 4661 | | - |
| 4650 | + |
| 4662 | 4651 | for (i = 0; i < table->used; i++) { |
| 4663 | 4652 | if (pid == table->info[i].pid) { |
| 4664 | | - |
| 4653 | + |
| 4665 | 4654 | JimWaitPid(pid, statusPtr, 0); |
| 4666 | 4655 | |
| 4667 | | - |
| 4656 | + |
| 4668 | 4657 | if (i != table->used - 1) { |
| 4669 | 4658 | table->info[i] = table->info[table->used - 1]; |
| 4670 | 4659 | } |
| 4671 | 4660 | table->used--; |
| 4672 | 4661 | return pid; |
| 4673 | 4662 | } |
| 4674 | 4663 | } |
| 4675 | 4664 | |
| 4676 | | - |
| 4665 | + |
| 4677 | 4666 | return JIM_BAD_PID; |
| 4678 | 4667 | } |
| 4679 | 4668 | |
| 4680 | 4669 | static void JimDetachPids(Jim_Interp *interp, int numPids, const pidtype *pidPtr) |
| 4681 | 4670 | { |
| 4682 | 4671 | int j; |
| 4683 | 4672 | struct WaitInfoTable *table = Jim_CmdPrivData(interp); |
| 4684 | 4673 | |
| 4685 | 4674 | for (j = 0; j < numPids; j++) { |
| 4686 | | - |
| 4675 | + |
| 4687 | 4676 | int i; |
| 4688 | 4677 | for (i = 0; i < table->used; i++) { |
| 4689 | 4678 | if (pidPtr[j] == table->info[i].pid) { |
| 4690 | 4679 | table->info[i].flags |= WI_DETACHED; |
| 4691 | 4680 | break; |
| | @@ -4718,16 +4707,16 @@ |
| 4718 | 4707 | int cmdCount; /* Count of number of distinct commands |
| 4719 | 4708 | * found in argc/argv. */ |
| 4720 | 4709 | const char *input = NULL; /* Describes input for pipeline, depending |
| 4721 | 4710 | * on "inputFile". NULL means take input |
| 4722 | 4711 | * from stdin/pipe. */ |
| 4723 | | - int input_len = 0; |
| 4712 | + int input_len = 0; |
| 4724 | 4713 | |
| 4725 | | -#define FILE_NAME 0 |
| 4726 | | -#define FILE_APPEND 1 |
| 4727 | | -#define FILE_HANDLE 2 |
| 4728 | | -#define FILE_TEXT 3 |
| 4714 | +#define FILE_NAME 0 |
| 4715 | +#define FILE_APPEND 1 |
| 4716 | +#define FILE_HANDLE 2 |
| 4717 | +#define FILE_TEXT 3 |
| 4729 | 4718 | |
| 4730 | 4719 | int inputFile = FILE_NAME; /* 1 means input is name of input file. |
| 4731 | 4720 | * 2 means input is filehandle name. |
| 4732 | 4721 | * 0 means input holds actual |
| 4733 | 4722 | * text to be input to command. */ |
| | @@ -4748,20 +4737,20 @@ |
| 4748 | 4737 | * or NULL if stderr goes to stderr/pipe. */ |
| 4749 | 4738 | fdtype inputId = JIM_BAD_FD; |
| 4750 | 4739 | fdtype outputId = JIM_BAD_FD; |
| 4751 | 4740 | fdtype errorId = JIM_BAD_FD; |
| 4752 | 4741 | fdtype lastOutputId = JIM_BAD_FD; |
| 4753 | | - fdtype pipeIds[2]; |
| 4742 | + fdtype pipeIds[2]; |
| 4754 | 4743 | int firstArg, lastArg; /* Indexes of first and last arguments in |
| 4755 | 4744 | * current command. */ |
| 4756 | 4745 | int lastBar; |
| 4757 | 4746 | int i; |
| 4758 | 4747 | pidtype pid; |
| 4759 | 4748 | char **save_environ; |
| 4760 | 4749 | struct WaitInfoTable *table = Jim_CmdPrivData(interp); |
| 4761 | 4750 | |
| 4762 | | - |
| 4751 | + |
| 4763 | 4752 | char **arg_array = Jim_Alloc(sizeof(*arg_array) * (argc + 1)); |
| 4764 | 4753 | int arg_count = 0; |
| 4765 | 4754 | |
| 4766 | 4755 | JimReapDetachedPids(table); |
| 4767 | 4756 | |
| | @@ -4807,11 +4796,11 @@ |
| 4807 | 4796 | if (*output == '>') { |
| 4808 | 4797 | outputFile = FILE_APPEND; |
| 4809 | 4798 | output++; |
| 4810 | 4799 | } |
| 4811 | 4800 | if (*output == '&') { |
| 4812 | | - |
| 4801 | + |
| 4813 | 4802 | output++; |
| 4814 | 4803 | dup_error = 1; |
| 4815 | 4804 | } |
| 4816 | 4805 | if (*output == '@') { |
| 4817 | 4806 | outputFile = FILE_HANDLE; |
| | @@ -4848,11 +4837,11 @@ |
| 4848 | 4837 | goto badargs; |
| 4849 | 4838 | } |
| 4850 | 4839 | lastBar = i; |
| 4851 | 4840 | cmdCount++; |
| 4852 | 4841 | } |
| 4853 | | - |
| 4842 | + |
| 4854 | 4843 | arg_array[arg_count++] = (char *)arg; |
| 4855 | 4844 | continue; |
| 4856 | 4845 | } |
| 4857 | 4846 | |
| 4858 | 4847 | if (i >= argc) { |
| | @@ -4866,11 +4855,11 @@ |
| 4866 | 4855 | badargs: |
| 4867 | 4856 | Jim_Free(arg_array); |
| 4868 | 4857 | return -1; |
| 4869 | 4858 | } |
| 4870 | 4859 | |
| 4871 | | - |
| 4860 | + |
| 4872 | 4861 | save_environ = JimSaveEnv(JimBuildEnv(interp)); |
| 4873 | 4862 | |
| 4874 | 4863 | if (input != NULL) { |
| 4875 | 4864 | if (inputFile == FILE_TEXT) { |
| 4876 | 4865 | inputId = JimCreateTemp(interp, input, input_len); |
| | @@ -4877,11 +4866,11 @@ |
| 4877 | 4866 | if (inputId == JIM_BAD_FD) { |
| 4878 | 4867 | goto error; |
| 4879 | 4868 | } |
| 4880 | 4869 | } |
| 4881 | 4870 | else if (inputFile == FILE_HANDLE) { |
| 4882 | | - |
| 4871 | + |
| 4883 | 4872 | FILE *fh = JimGetAioFilehandle(interp, input); |
| 4884 | 4873 | |
| 4885 | 4874 | if (fh == NULL) { |
| 4886 | 4875 | goto error; |
| 4887 | 4876 | } |
| | @@ -4929,20 +4918,20 @@ |
| 4929 | 4918 | } |
| 4930 | 4919 | lastOutputId = pipeIds[1]; |
| 4931 | 4920 | *outPipePtr = pipeIds[0]; |
| 4932 | 4921 | pipeIds[0] = pipeIds[1] = JIM_BAD_FD; |
| 4933 | 4922 | } |
| 4934 | | - |
| 4923 | + |
| 4935 | 4924 | if (error != NULL) { |
| 4936 | 4925 | if (errorFile == FILE_HANDLE) { |
| 4937 | 4926 | if (strcmp(error, "1") == 0) { |
| 4938 | | - |
| 4927 | + |
| 4939 | 4928 | if (lastOutputId != JIM_BAD_FD) { |
| 4940 | 4929 | errorId = JimDupFd(lastOutputId); |
| 4941 | 4930 | } |
| 4942 | 4931 | else { |
| 4943 | | - |
| 4932 | + |
| 4944 | 4933 | error = "stdout"; |
| 4945 | 4934 | } |
| 4946 | 4935 | } |
| 4947 | 4936 | if (errorId == JIM_BAD_FD) { |
| 4948 | 4937 | FILE *fh = JimGetAioFilehandle(interp, error); |
| | @@ -4984,11 +4973,11 @@ |
| 4984 | 4973 | pipe_dup_err = 1; |
| 4985 | 4974 | } |
| 4986 | 4975 | break; |
| 4987 | 4976 | } |
| 4988 | 4977 | } |
| 4989 | | - |
| 4978 | + |
| 4990 | 4979 | arg_array[lastArg] = NULL; |
| 4991 | 4980 | if (lastArg == arg_count) { |
| 4992 | 4981 | outputId = lastOutputId; |
| 4993 | 4982 | } |
| 4994 | 4983 | else { |
| | @@ -4997,16 +4986,16 @@ |
| 4997 | 4986 | goto error; |
| 4998 | 4987 | } |
| 4999 | 4988 | outputId = pipeIds[1]; |
| 5000 | 4989 | } |
| 5001 | 4990 | |
| 5002 | | - |
| 4991 | + |
| 5003 | 4992 | if (pipe_dup_err) { |
| 5004 | 4993 | errorId = outputId; |
| 5005 | 4994 | } |
| 5006 | 4995 | |
| 5007 | | - |
| 4996 | + |
| 5008 | 4997 | |
| 5009 | 4998 | #ifdef __MINGW32__ |
| 5010 | 4999 | pid = JimStartWinProcess(interp, &arg_array[firstArg], save_environ ? save_environ[0] : NULL, inputId, outputId, errorId); |
| 5011 | 5000 | if (pid == JIM_BAD_PID) { |
| 5012 | 5001 | Jim_SetResultFormatted(interp, "couldn't exec \"%s\"", arg_array[firstArg]); |
| | @@ -5017,32 +5006,32 @@ |
| 5017 | 5006 | if (pid < 0) { |
| 5018 | 5007 | Jim_SetResultErrno(interp, "couldn't fork child process"); |
| 5019 | 5008 | goto error; |
| 5020 | 5009 | } |
| 5021 | 5010 | if (pid == 0) { |
| 5022 | | - |
| 5011 | + |
| 5023 | 5012 | |
| 5024 | 5013 | if (inputId != -1) dup2(inputId, 0); |
| 5025 | 5014 | if (outputId != -1) dup2(outputId, 1); |
| 5026 | 5015 | if (errorId != -1) dup2(errorId, 2); |
| 5027 | 5016 | |
| 5028 | 5017 | for (i = 3; (i <= outputId) || (i <= inputId) || (i <= errorId); i++) { |
| 5029 | 5018 | close(i); |
| 5030 | 5019 | } |
| 5031 | 5020 | |
| 5032 | | - |
| 5021 | + |
| 5033 | 5022 | (void)signal(SIGPIPE, SIG_DFL); |
| 5034 | 5023 | |
| 5035 | 5024 | execvpe(arg_array[firstArg], &arg_array[firstArg], Jim_GetEnviron()); |
| 5036 | 5025 | |
| 5037 | | - |
| 5026 | + |
| 5038 | 5027 | fprintf(stderr, "couldn't exec \"%s\"\n", arg_array[firstArg]); |
| 5039 | 5028 | _exit(127); |
| 5040 | 5029 | } |
| 5041 | 5030 | #endif |
| 5042 | 5031 | |
| 5043 | | - |
| 5032 | + |
| 5044 | 5033 | |
| 5045 | 5034 | if (table->used == table->size) { |
| 5046 | 5035 | table->size += WAIT_TABLE_GROW_BY; |
| 5047 | 5036 | table->info = Jim_Realloc(table->info, table->size * sizeof(*table->info)); |
| 5048 | 5037 | } |
| | @@ -5051,11 +5040,11 @@ |
| 5051 | 5040 | table->info[table->used].flags = 0; |
| 5052 | 5041 | table->used++; |
| 5053 | 5042 | |
| 5054 | 5043 | pidPtr[numPids] = pid; |
| 5055 | 5044 | |
| 5056 | | - |
| 5045 | + |
| 5057 | 5046 | errorId = origErrorId; |
| 5058 | 5047 | |
| 5059 | 5048 | |
| 5060 | 5049 | if (inputId != JIM_BAD_FD) { |
| 5061 | 5050 | JimCloseFd(inputId); |
| | @@ -5122,11 +5111,11 @@ |
| 5122 | 5111 | { |
| 5123 | 5112 | struct WaitInfoTable *table = Jim_CmdPrivData(interp); |
| 5124 | 5113 | int result = JIM_OK; |
| 5125 | 5114 | int i; |
| 5126 | 5115 | |
| 5127 | | - |
| 5116 | + |
| 5128 | 5117 | for (i = 0; i < numPids; i++) { |
| 5129 | 5118 | int waitStatus = 0; |
| 5130 | 5119 | if (JimWaitForProcess(table, pidPtr[i], &waitStatus) != JIM_BAD_PID) { |
| 5131 | 5120 | if (JimCheckWaitStatus(interp, pidPtr[i], waitStatus, errStrObj) != JIM_OK) { |
| 5132 | 5121 | result = JIM_ERR; |
| | @@ -5295,21 +5284,17 @@ |
| 5295 | 5284 | } |
| 5296 | 5285 | |
| 5297 | 5286 | static fdtype JimOpenForRead(const char *filename) |
| 5298 | 5287 | { |
| 5299 | 5288 | return CreateFile(filename, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, |
| 5300 | | - JimStdSecAttrs(), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); |
| 5289 | + JimStdSecAttrs(), OPEN_EXISTING, 0, NULL); |
| 5301 | 5290 | } |
| 5302 | 5291 | |
| 5303 | 5292 | static fdtype JimOpenForWrite(const char *filename, int append) |
| 5304 | 5293 | { |
| 5305 | | - fdtype fd = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, |
| 5306 | | - JimStdSecAttrs(), append ? OPEN_ALWAYS : CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, (HANDLE) NULL); |
| 5307 | | - if (append && fd != JIM_BAD_FD) { |
| 5308 | | - SetFilePointer(fd, 0, NULL, FILE_END); |
| 5309 | | - } |
| 5310 | | - return fd; |
| 5294 | + return CreateFile(filename, append ? FILE_APPEND_DATA : GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, |
| 5295 | + JimStdSecAttrs(), append ? OPEN_ALWAYS : CREATE_ALWAYS, 0, (HANDLE) NULL); |
| 5311 | 5296 | } |
| 5312 | 5297 | |
| 5313 | 5298 | static FILE *JimFdOpenForWrite(fdtype fd) |
| 5314 | 5299 | { |
| 5315 | 5300 | return _fdopen(_open_osfhandle((int)fd, _O_TEXT), "w"); |
| | @@ -5317,11 +5302,11 @@ |
| 5317 | 5302 | |
| 5318 | 5303 | static pidtype JimWaitPid(pidtype pid, int *status, int nohang) |
| 5319 | 5304 | { |
| 5320 | 5305 | DWORD ret = WaitForSingleObject(pid, nohang ? 0 : INFINITE); |
| 5321 | 5306 | if (ret == WAIT_TIMEOUT || ret == WAIT_FAILED) { |
| 5322 | | - |
| 5307 | + |
| 5323 | 5308 | return JIM_BAD_PID; |
| 5324 | 5309 | } |
| 5325 | 5310 | GetExitCodeProcess(pid, &ret); |
| 5326 | 5311 | *status = ret; |
| 5327 | 5312 | CloseHandle(pid); |
| | @@ -5344,11 +5329,11 @@ |
| 5344 | 5329 | if (handle == INVALID_HANDLE_VALUE) { |
| 5345 | 5330 | goto error; |
| 5346 | 5331 | } |
| 5347 | 5332 | |
| 5348 | 5333 | if (contents != NULL) { |
| 5349 | | - |
| 5334 | + |
| 5350 | 5335 | FILE *fh = JimFdOpenForWrite(JimDupFd(handle)); |
| 5351 | 5336 | if (fh == NULL) { |
| 5352 | 5337 | goto error; |
| 5353 | 5338 | } |
| 5354 | 5339 | |
| | @@ -5616,11 +5601,11 @@ |
| 5616 | 5601 | #include <sys/time.h> |
| 5617 | 5602 | #endif |
| 5618 | 5603 | |
| 5619 | 5604 | static int clock_cmd_format(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 5620 | 5605 | { |
| 5621 | | - |
| 5606 | + |
| 5622 | 5607 | char buf[100]; |
| 5623 | 5608 | time_t t; |
| 5624 | 5609 | long seconds; |
| 5625 | 5610 | |
| 5626 | 5611 | const char *format = "%a %b %d %H:%M:%S %Z %Y"; |
| | @@ -5657,20 +5642,20 @@ |
| 5657 | 5642 | |
| 5658 | 5643 | if (!Jim_CompareStringImmediate(interp, argv[1], "-format")) { |
| 5659 | 5644 | return -1; |
| 5660 | 5645 | } |
| 5661 | 5646 | |
| 5662 | | - |
| 5647 | + |
| 5663 | 5648 | localtime_r(&now, &tm); |
| 5664 | 5649 | |
| 5665 | 5650 | pt = strptime(Jim_String(argv[0]), Jim_String(argv[2]), &tm); |
| 5666 | 5651 | if (pt == 0 || *pt != 0) { |
| 5667 | 5652 | Jim_SetResultString(interp, "Failed to parse time according to format", -1); |
| 5668 | 5653 | return JIM_ERR; |
| 5669 | 5654 | } |
| 5670 | 5655 | |
| 5671 | | - |
| 5656 | + |
| 5672 | 5657 | Jim_SetResultInt(interp, mktime(&tm)); |
| 5673 | 5658 | |
| 5674 | 5659 | return JIM_OK; |
| 5675 | 5660 | } |
| 5676 | 5661 | #endif |
| | @@ -5708,47 +5693,47 @@ |
| 5708 | 5693 | { "seconds", |
| 5709 | 5694 | NULL, |
| 5710 | 5695 | clock_cmd_seconds, |
| 5711 | 5696 | 0, |
| 5712 | 5697 | 0, |
| 5713 | | - |
| 5698 | + |
| 5714 | 5699 | }, |
| 5715 | 5700 | { "clicks", |
| 5716 | 5701 | NULL, |
| 5717 | 5702 | clock_cmd_micros, |
| 5718 | 5703 | 0, |
| 5719 | 5704 | 0, |
| 5720 | | - |
| 5705 | + |
| 5721 | 5706 | }, |
| 5722 | 5707 | { "microseconds", |
| 5723 | 5708 | NULL, |
| 5724 | 5709 | clock_cmd_micros, |
| 5725 | 5710 | 0, |
| 5726 | 5711 | 0, |
| 5727 | | - |
| 5712 | + |
| 5728 | 5713 | }, |
| 5729 | 5714 | { "milliseconds", |
| 5730 | 5715 | NULL, |
| 5731 | 5716 | clock_cmd_millis, |
| 5732 | 5717 | 0, |
| 5733 | 5718 | 0, |
| 5734 | | - |
| 5719 | + |
| 5735 | 5720 | }, |
| 5736 | 5721 | { "format", |
| 5737 | 5722 | "seconds ?-format format?", |
| 5738 | 5723 | clock_cmd_format, |
| 5739 | 5724 | 1, |
| 5740 | 5725 | 3, |
| 5741 | | - |
| 5726 | + |
| 5742 | 5727 | }, |
| 5743 | 5728 | #ifdef HAVE_STRPTIME |
| 5744 | 5729 | { "scan", |
| 5745 | 5730 | "str -format format", |
| 5746 | 5731 | clock_cmd_scan, |
| 5747 | 5732 | 3, |
| 5748 | 5733 | 3, |
| 5749 | | - |
| 5734 | + |
| 5750 | 5735 | }, |
| 5751 | 5736 | #endif |
| 5752 | 5737 | { NULL } |
| 5753 | 5738 | }; |
| 5754 | 5739 | |
| | @@ -5768,11 +5753,11 @@ |
| 5768 | 5753 | #include <errno.h> |
| 5769 | 5754 | |
| 5770 | 5755 | |
| 5771 | 5756 | static int array_cmd_exists(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 5772 | 5757 | { |
| 5773 | | - |
| 5758 | + |
| 5774 | 5759 | Jim_SetResultInt(interp, Jim_GetVariable(interp, argv[0], 0) != 0); |
| 5775 | 5760 | return JIM_OK; |
| 5776 | 5761 | } |
| 5777 | 5762 | |
| 5778 | 5763 | static int array_cmd_get(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| | @@ -5784,20 +5769,20 @@ |
| 5784 | 5769 | return JIM_OK; |
| 5785 | 5770 | } |
| 5786 | 5771 | |
| 5787 | 5772 | patternObj = (argc == 1) ? NULL : argv[1]; |
| 5788 | 5773 | |
| 5789 | | - |
| 5774 | + |
| 5790 | 5775 | if (patternObj == NULL || Jim_CompareStringImmediate(interp, patternObj, "*")) { |
| 5791 | 5776 | if (Jim_IsList(objPtr) && Jim_ListLength(interp, objPtr) % 2 == 0) { |
| 5792 | | - |
| 5777 | + |
| 5793 | 5778 | Jim_SetResult(interp, objPtr); |
| 5794 | 5779 | return JIM_OK; |
| 5795 | 5780 | } |
| 5796 | 5781 | } |
| 5797 | 5782 | |
| 5798 | | - |
| 5783 | + |
| 5799 | 5784 | return Jim_DictValues(interp, objPtr, patternObj); |
| 5800 | 5785 | } |
| 5801 | 5786 | |
| 5802 | 5787 | static int array_cmd_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 5803 | 5788 | { |
| | @@ -5817,27 +5802,27 @@ |
| 5817 | 5802 | Jim_Obj *resultObj; |
| 5818 | 5803 | Jim_Obj *objPtr; |
| 5819 | 5804 | Jim_Obj **dictValuesObj; |
| 5820 | 5805 | |
| 5821 | 5806 | if (argc == 1 || Jim_CompareStringImmediate(interp, argv[1], "*")) { |
| 5822 | | - |
| 5807 | + |
| 5823 | 5808 | Jim_UnsetVariable(interp, argv[0], JIM_NONE); |
| 5824 | 5809 | return JIM_OK; |
| 5825 | 5810 | } |
| 5826 | 5811 | |
| 5827 | 5812 | objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE); |
| 5828 | 5813 | |
| 5829 | 5814 | if (objPtr == NULL) { |
| 5830 | | - |
| 5815 | + |
| 5831 | 5816 | return JIM_OK; |
| 5832 | 5817 | } |
| 5833 | 5818 | |
| 5834 | 5819 | if (Jim_DictPairs(interp, objPtr, &dictValuesObj, &len) != JIM_OK) { |
| 5835 | 5820 | return JIM_ERR; |
| 5836 | 5821 | } |
| 5837 | 5822 | |
| 5838 | | - |
| 5823 | + |
| 5839 | 5824 | resultObj = Jim_NewDictObj(interp, NULL, 0); |
| 5840 | 5825 | |
| 5841 | 5826 | for (i = 0; i < len; i += 2) { |
| 5842 | 5827 | if (!Jim_StringMatchObj(interp, argv[1], dictValuesObj[i], 0)) { |
| 5843 | 5828 | Jim_DictAddElement(interp, resultObj, dictValuesObj[i], dictValuesObj[i + 1]); |
| | @@ -5852,11 +5837,11 @@ |
| 5852 | 5837 | static int array_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 5853 | 5838 | { |
| 5854 | 5839 | Jim_Obj *objPtr; |
| 5855 | 5840 | int len = 0; |
| 5856 | 5841 | |
| 5857 | | - |
| 5842 | + |
| 5858 | 5843 | objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE); |
| 5859 | 5844 | if (objPtr) { |
| 5860 | 5845 | len = Jim_DictSize(interp, objPtr); |
| 5861 | 5846 | if (len < 0) { |
| 5862 | 5847 | return JIM_ERR; |
| | @@ -5891,11 +5876,11 @@ |
| 5891 | 5876 | return JIM_ERR; |
| 5892 | 5877 | } |
| 5893 | 5878 | |
| 5894 | 5879 | dictObj = Jim_GetVariable(interp, argv[0], JIM_UNSHARED); |
| 5895 | 5880 | if (!dictObj) { |
| 5896 | | - |
| 5881 | + |
| 5897 | 5882 | return Jim_SetVariable(interp, argv[0], listObj); |
| 5898 | 5883 | } |
| 5899 | 5884 | else if (Jim_DictSize(interp, dictObj) < 0) { |
| 5900 | 5885 | return JIM_ERR; |
| 5901 | 5886 | } |
| | @@ -5920,53 +5905,53 @@ |
| 5920 | 5905 | { "exists", |
| 5921 | 5906 | "arrayName", |
| 5922 | 5907 | array_cmd_exists, |
| 5923 | 5908 | 1, |
| 5924 | 5909 | 1, |
| 5925 | | - |
| 5910 | + |
| 5926 | 5911 | }, |
| 5927 | 5912 | { "get", |
| 5928 | 5913 | "arrayName ?pattern?", |
| 5929 | 5914 | array_cmd_get, |
| 5930 | 5915 | 1, |
| 5931 | 5916 | 2, |
| 5932 | | - |
| 5917 | + |
| 5933 | 5918 | }, |
| 5934 | 5919 | { "names", |
| 5935 | 5920 | "arrayName ?pattern?", |
| 5936 | 5921 | array_cmd_names, |
| 5937 | 5922 | 1, |
| 5938 | 5923 | 2, |
| 5939 | | - |
| 5924 | + |
| 5940 | 5925 | }, |
| 5941 | 5926 | { "set", |
| 5942 | 5927 | "arrayName list", |
| 5943 | 5928 | array_cmd_set, |
| 5944 | 5929 | 2, |
| 5945 | 5930 | 2, |
| 5946 | | - |
| 5931 | + |
| 5947 | 5932 | }, |
| 5948 | 5933 | { "size", |
| 5949 | 5934 | "arrayName", |
| 5950 | 5935 | array_cmd_size, |
| 5951 | 5936 | 1, |
| 5952 | 5937 | 1, |
| 5953 | | - |
| 5938 | + |
| 5954 | 5939 | }, |
| 5955 | 5940 | { "stat", |
| 5956 | 5941 | "arrayName", |
| 5957 | 5942 | array_cmd_stat, |
| 5958 | 5943 | 1, |
| 5959 | 5944 | 1, |
| 5960 | | - |
| 5945 | + |
| 5961 | 5946 | }, |
| 5962 | 5947 | { "unset", |
| 5963 | 5948 | "arrayName ?pattern?", |
| 5964 | 5949 | array_cmd_unset, |
| 5965 | 5950 | 1, |
| 5966 | 5951 | 2, |
| 5967 | | - |
| 5952 | + |
| 5968 | 5953 | }, |
| 5969 | 5954 | { NULL |
| 5970 | 5955 | } |
| 5971 | 5956 | }; |
| 5972 | 5957 | |
| | @@ -6002,12 +5987,11 @@ |
| 6002 | 5987 | Jim_arrayInit(interp); |
| 6003 | 5988 | Jim_stdlibInit(interp); |
| 6004 | 5989 | Jim_tclcompatInit(interp); |
| 6005 | 5990 | return JIM_OK; |
| 6006 | 5991 | } |
| 6007 | | -#define JIM_OPTIMIZATION |
| 6008 | | -#define _GNU_SOURCE |
| 5992 | +#define JIM_OPTIMIZATION |
| 6009 | 5993 | |
| 6010 | 5994 | #include <stdio.h> |
| 6011 | 5995 | #include <stdlib.h> |
| 6012 | 5996 | |
| 6013 | 5997 | #include <string.h> |
| | @@ -6072,16 +6056,10 @@ |
| 6072 | 6056 | #define JimPanic(X) JimPanicDump X |
| 6073 | 6057 | #else |
| 6074 | 6058 | #define JimPanic(X) |
| 6075 | 6059 | #endif |
| 6076 | 6060 | |
| 6077 | | -#ifdef JIM_OPTIMIZATION |
| 6078 | | -#define JIM_IF_OPTIM(X) X |
| 6079 | | -#else |
| 6080 | | -#define JIM_IF_OPTIM(X) |
| 6081 | | -#endif |
| 6082 | | - |
| 6083 | 6061 | |
| 6084 | 6062 | static char JimEmptyStringRep[] = ""; |
| 6085 | 6063 | |
| 6086 | 6064 | static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int action); |
| 6087 | 6065 | static int ListSetIndex(Jim_Interp *interp, Jim_Obj *listPtr, int listindex, Jim_Obj *newObjPtr, |
| | @@ -6134,34 +6112,34 @@ |
| 6134 | 6112 | if (*pattern == '^') { |
| 6135 | 6113 | not++; |
| 6136 | 6114 | pattern++; |
| 6137 | 6115 | } |
| 6138 | 6116 | |
| 6139 | | - |
| 6117 | + |
| 6140 | 6118 | if (*pattern == ']') { |
| 6141 | 6119 | goto first; |
| 6142 | 6120 | } |
| 6143 | 6121 | } |
| 6144 | 6122 | |
| 6145 | 6123 | while (*pattern && *pattern != ']') { |
| 6146 | | - |
| 6124 | + |
| 6147 | 6125 | if (pattern[0] == '\\') { |
| 6148 | 6126 | first: |
| 6149 | 6127 | pattern += utf8_tounicode_case(pattern, &pchar, nocase); |
| 6150 | 6128 | } |
| 6151 | 6129 | else { |
| 6152 | | - |
| 6130 | + |
| 6153 | 6131 | int start; |
| 6154 | 6132 | int end; |
| 6155 | 6133 | |
| 6156 | 6134 | pattern += utf8_tounicode_case(pattern, &start, nocase); |
| 6157 | 6135 | if (pattern[0] == '-' && pattern[1]) { |
| 6158 | | - |
| 6136 | + |
| 6159 | 6137 | pattern += utf8_tounicode(pattern, &pchar); |
| 6160 | 6138 | pattern += utf8_tounicode_case(pattern, &end, nocase); |
| 6161 | 6139 | |
| 6162 | | - |
| 6140 | + |
| 6163 | 6141 | if ((c >= start && c <= end) || (c >= end && c <= start)) { |
| 6164 | 6142 | match = 1; |
| 6165 | 6143 | } |
| 6166 | 6144 | continue; |
| 6167 | 6145 | } |
| | @@ -6191,19 +6169,19 @@ |
| 6191 | 6169 | while (pattern[1] == '*') { |
| 6192 | 6170 | pattern++; |
| 6193 | 6171 | } |
| 6194 | 6172 | pattern++; |
| 6195 | 6173 | if (!pattern[0]) { |
| 6196 | | - return 1; |
| 6174 | + return 1; |
| 6197 | 6175 | } |
| 6198 | 6176 | while (*string) { |
| 6199 | | - |
| 6177 | + |
| 6200 | 6178 | if (JimGlobMatch(pattern, string, nocase)) |
| 6201 | | - return 1; |
| 6179 | + return 1; |
| 6202 | 6180 | string += utf8_tounicode(string, &c); |
| 6203 | 6181 | } |
| 6204 | | - return 0; |
| 6182 | + return 0; |
| 6205 | 6183 | |
| 6206 | 6184 | case '?': |
| 6207 | 6185 | string += utf8_tounicode(string, &c); |
| 6208 | 6186 | break; |
| 6209 | 6187 | |
| | @@ -6212,20 +6190,20 @@ |
| 6212 | 6190 | pattern = JimCharsetMatch(pattern + 1, c, nocase ? JIM_NOCASE : 0); |
| 6213 | 6191 | if (!pattern) { |
| 6214 | 6192 | return 0; |
| 6215 | 6193 | } |
| 6216 | 6194 | if (!*pattern) { |
| 6217 | | - |
| 6195 | + |
| 6218 | 6196 | continue; |
| 6219 | 6197 | } |
| 6220 | 6198 | break; |
| 6221 | 6199 | } |
| 6222 | 6200 | case '\\': |
| 6223 | 6201 | if (pattern[1]) { |
| 6224 | 6202 | pattern++; |
| 6225 | 6203 | } |
| 6226 | | - |
| 6204 | + |
| 6227 | 6205 | default: |
| 6228 | 6206 | string += utf8_tounicode_case(string, &c, nocase); |
| 6229 | 6207 | utf8_tounicode_case(pattern, &pchar, nocase); |
| 6230 | 6208 | if (pchar != c) { |
| 6231 | 6209 | return 0; |
| | @@ -6271,11 +6249,11 @@ |
| 6271 | 6249 | maxchars--; |
| 6272 | 6250 | } |
| 6273 | 6251 | if (!maxchars) { |
| 6274 | 6252 | return 0; |
| 6275 | 6253 | } |
| 6276 | | - |
| 6254 | + |
| 6277 | 6255 | if (*s1) { |
| 6278 | 6256 | return 1; |
| 6279 | 6257 | } |
| 6280 | 6258 | if (*s2) { |
| 6281 | 6259 | return -1; |
| | @@ -6312,11 +6290,11 @@ |
| 6312 | 6290 | const char *p; |
| 6313 | 6291 | |
| 6314 | 6292 | if (!l1 || !l2 || l1 > l2) |
| 6315 | 6293 | return -1; |
| 6316 | 6294 | |
| 6317 | | - |
| 6295 | + |
| 6318 | 6296 | for (p = s2 + l2 - 1; p != s2 - 1; p--) { |
| 6319 | 6297 | if (*p == *s1 && memcmp(s1, p, l1) == 0) { |
| 6320 | 6298 | return p - s2; |
| 6321 | 6299 | } |
| 6322 | 6300 | } |
| | @@ -6371,28 +6349,28 @@ |
| 6371 | 6349 | } |
| 6372 | 6350 | *sign = 1; |
| 6373 | 6351 | } |
| 6374 | 6352 | |
| 6375 | 6353 | if (str[i] != '0') { |
| 6376 | | - |
| 6354 | + |
| 6377 | 6355 | return 0; |
| 6378 | 6356 | } |
| 6379 | 6357 | |
| 6380 | | - |
| 6358 | + |
| 6381 | 6359 | switch (str[i + 1]) { |
| 6382 | 6360 | case 'x': case 'X': *base = 16; break; |
| 6383 | 6361 | case 'o': case 'O': *base = 8; break; |
| 6384 | 6362 | case 'b': case 'B': *base = 2; break; |
| 6385 | 6363 | default: return 0; |
| 6386 | 6364 | } |
| 6387 | 6365 | i += 2; |
| 6388 | | - |
| 6366 | + |
| 6389 | 6367 | if (str[i] != '-' && str[i] != '+' && !isspace(UCHAR(str[i]))) { |
| 6390 | | - |
| 6368 | + |
| 6391 | 6369 | return i; |
| 6392 | 6370 | } |
| 6393 | | - |
| 6371 | + |
| 6394 | 6372 | *base = 10; |
| 6395 | 6373 | return 0; |
| 6396 | 6374 | } |
| 6397 | 6375 | |
| 6398 | 6376 | static long jim_strtol(const char *str, char **endptr) |
| | @@ -6406,11 +6384,11 @@ |
| 6406 | 6384 | if (endptr == NULL || *endptr != str + i) { |
| 6407 | 6385 | return value * sign; |
| 6408 | 6386 | } |
| 6409 | 6387 | } |
| 6410 | 6388 | |
| 6411 | | - |
| 6389 | + |
| 6412 | 6390 | return strtol(str, endptr, 10); |
| 6413 | 6391 | } |
| 6414 | 6392 | |
| 6415 | 6393 | |
| 6416 | 6394 | static jim_wide jim_strtoull(const char *str, char **endptr) |
| | @@ -6425,11 +6403,11 @@ |
| 6425 | 6403 | if (endptr == NULL || *endptr != str + i) { |
| 6426 | 6404 | return value * sign; |
| 6427 | 6405 | } |
| 6428 | 6406 | } |
| 6429 | 6407 | |
| 6430 | | - |
| 6408 | + |
| 6431 | 6409 | return strtoull(str, endptr, 10); |
| 6432 | 6410 | #else |
| 6433 | 6411 | return (unsigned long)jim_strtol(str, endptr); |
| 6434 | 6412 | #endif |
| 6435 | 6413 | } |
| | @@ -6450,40 +6428,26 @@ |
| 6450 | 6428 | |
| 6451 | 6429 | int Jim_StringToDouble(const char *str, double *doublePtr) |
| 6452 | 6430 | { |
| 6453 | 6431 | char *endptr; |
| 6454 | 6432 | |
| 6455 | | - |
| 6433 | + |
| 6456 | 6434 | errno = 0; |
| 6457 | 6435 | |
| 6458 | 6436 | *doublePtr = strtod(str, &endptr); |
| 6459 | 6437 | |
| 6460 | 6438 | return JimCheckConversion(str, endptr); |
| 6461 | 6439 | } |
| 6462 | 6440 | |
| 6463 | 6441 | static jim_wide JimPowWide(jim_wide b, jim_wide e) |
| 6464 | 6442 | { |
| 6465 | | - jim_wide res = 1; |
| 6466 | | - |
| 6467 | | - |
| 6468 | | - if (b == 1) { |
| 6469 | | - |
| 6470 | | - return 1; |
| 6471 | | - } |
| 6472 | | - if (e < 0) { |
| 6473 | | - if (b != -1) { |
| 6474 | | - return 0; |
| 6475 | | - } |
| 6476 | | - e = -e; |
| 6477 | | - } |
| 6478 | | - while (e) |
| 6479 | | - { |
| 6480 | | - if (e & 1) { |
| 6481 | | - res *= b; |
| 6482 | | - } |
| 6483 | | - e >>= 1; |
| 6484 | | - b *= b; |
| 6443 | + jim_wide i, res = 1; |
| 6444 | + |
| 6445 | + if ((b == 0 && e != 0) || (e < 0)) |
| 6446 | + return 0; |
| 6447 | + for (i = 0; i < e; i++) { |
| 6448 | + res *= b; |
| 6485 | 6449 | } |
| 6486 | 6450 | return res; |
| 6487 | 6451 | } |
| 6488 | 6452 | |
| 6489 | 6453 | #ifdef JIM_DEBUG_PANIC |
| | @@ -6545,11 +6509,11 @@ |
| 6545 | 6509 | char *Jim_StrDupLen(const char *s, int l) |
| 6546 | 6510 | { |
| 6547 | 6511 | char *copy = Jim_Alloc(l + 1); |
| 6548 | 6512 | |
| 6549 | 6513 | memcpy(copy, s, l + 1); |
| 6550 | | - copy[l] = 0; |
| 6514 | + copy[l] = 0; |
| 6551 | 6515 | return copy; |
| 6552 | 6516 | } |
| 6553 | 6517 | |
| 6554 | 6518 | |
| 6555 | 6519 | |
| | @@ -6634,52 +6598,52 @@ |
| 6634 | 6598 | } |
| 6635 | 6599 | |
| 6636 | 6600 | |
| 6637 | 6601 | void Jim_ExpandHashTable(Jim_HashTable *ht, unsigned int size) |
| 6638 | 6602 | { |
| 6639 | | - Jim_HashTable n; |
| 6603 | + Jim_HashTable n; |
| 6640 | 6604 | unsigned int realsize = JimHashTableNextPower(size), i; |
| 6641 | 6605 | |
| 6642 | 6606 | if (size <= ht->used) |
| 6643 | 6607 | return; |
| 6644 | 6608 | |
| 6645 | 6609 | Jim_InitHashTable(&n, ht->type, ht->privdata); |
| 6646 | 6610 | n.size = realsize; |
| 6647 | 6611 | n.sizemask = realsize - 1; |
| 6648 | 6612 | n.table = Jim_Alloc(realsize * sizeof(Jim_HashEntry *)); |
| 6649 | | - |
| 6613 | + |
| 6650 | 6614 | n.uniq = ht->uniq; |
| 6651 | 6615 | |
| 6652 | | - |
| 6616 | + |
| 6653 | 6617 | memset(n.table, 0, realsize * sizeof(Jim_HashEntry *)); |
| 6654 | 6618 | |
| 6655 | 6619 | n.used = ht->used; |
| 6656 | 6620 | for (i = 0; ht->used > 0; i++) { |
| 6657 | 6621 | Jim_HashEntry *he, *nextHe; |
| 6658 | 6622 | |
| 6659 | 6623 | if (ht->table[i] == NULL) |
| 6660 | 6624 | continue; |
| 6661 | 6625 | |
| 6662 | | - |
| 6626 | + |
| 6663 | 6627 | he = ht->table[i]; |
| 6664 | 6628 | while (he) { |
| 6665 | 6629 | unsigned int h; |
| 6666 | 6630 | |
| 6667 | 6631 | nextHe = he->next; |
| 6668 | | - |
| 6632 | + |
| 6669 | 6633 | h = Jim_HashKey(ht, he->key) & n.sizemask; |
| 6670 | 6634 | he->next = n.table[h]; |
| 6671 | 6635 | n.table[h] = he; |
| 6672 | 6636 | ht->used--; |
| 6673 | | - |
| 6637 | + |
| 6674 | 6638 | he = nextHe; |
| 6675 | 6639 | } |
| 6676 | 6640 | } |
| 6677 | 6641 | assert(ht->used == 0); |
| 6678 | 6642 | Jim_Free(ht->table); |
| 6679 | 6643 | |
| 6680 | | - |
| 6644 | + |
| 6681 | 6645 | *ht = n; |
| 6682 | 6646 | } |
| 6683 | 6647 | |
| 6684 | 6648 | |
| 6685 | 6649 | int Jim_AddHashEntry(Jim_HashTable *ht, const void *key, void *val) |
| | @@ -6688,11 +6652,11 @@ |
| 6688 | 6652 | |
| 6689 | 6653 | entry = JimInsertHashEntry(ht, key, 0); |
| 6690 | 6654 | if (entry == NULL) |
| 6691 | 6655 | return JIM_ERR; |
| 6692 | 6656 | |
| 6693 | | - |
| 6657 | + |
| 6694 | 6658 | Jim_SetHashKey(ht, entry, key); |
| 6695 | 6659 | Jim_SetHashVal(ht, entry, val); |
| 6696 | 6660 | return JIM_OK; |
| 6697 | 6661 | } |
| 6698 | 6662 | |
| | @@ -6714,11 +6678,11 @@ |
| 6714 | 6678 | Jim_SetHashVal(ht, entry, val); |
| 6715 | 6679 | } |
| 6716 | 6680 | existed = 1; |
| 6717 | 6681 | } |
| 6718 | 6682 | else { |
| 6719 | | - |
| 6683 | + |
| 6720 | 6684 | Jim_SetHashKey(ht, entry, key); |
| 6721 | 6685 | Jim_SetHashVal(ht, entry, val); |
| 6722 | 6686 | existed = 0; |
| 6723 | 6687 | } |
| 6724 | 6688 | |
| | @@ -6737,11 +6701,11 @@ |
| 6737 | 6701 | he = ht->table[h]; |
| 6738 | 6702 | |
| 6739 | 6703 | prevHe = NULL; |
| 6740 | 6704 | while (he) { |
| 6741 | 6705 | if (Jim_CompareHashKeys(ht, key, he->key)) { |
| 6742 | | - |
| 6706 | + |
| 6743 | 6707 | if (prevHe) |
| 6744 | 6708 | prevHe->next = he->next; |
| 6745 | 6709 | else |
| 6746 | 6710 | ht->table[h] = he->next; |
| 6747 | 6711 | Jim_FreeEntryKey(ht, he); |
| | @@ -6751,19 +6715,19 @@ |
| 6751 | 6715 | return JIM_OK; |
| 6752 | 6716 | } |
| 6753 | 6717 | prevHe = he; |
| 6754 | 6718 | he = he->next; |
| 6755 | 6719 | } |
| 6756 | | - return JIM_ERR; |
| 6720 | + return JIM_ERR; |
| 6757 | 6721 | } |
| 6758 | 6722 | |
| 6759 | 6723 | |
| 6760 | 6724 | int Jim_FreeHashTable(Jim_HashTable *ht) |
| 6761 | 6725 | { |
| 6762 | 6726 | unsigned int i; |
| 6763 | 6727 | |
| 6764 | | - |
| 6728 | + |
| 6765 | 6729 | for (i = 0; ht->used > 0; i++) { |
| 6766 | 6730 | Jim_HashEntry *he, *nextHe; |
| 6767 | 6731 | |
| 6768 | 6732 | if ((he = ht->table[i]) == NULL) |
| 6769 | 6733 | continue; |
| | @@ -6774,15 +6738,15 @@ |
| 6774 | 6738 | Jim_Free(he); |
| 6775 | 6739 | ht->used--; |
| 6776 | 6740 | he = nextHe; |
| 6777 | 6741 | } |
| 6778 | 6742 | } |
| 6779 | | - |
| 6743 | + |
| 6780 | 6744 | Jim_Free(ht->table); |
| 6781 | | - |
| 6745 | + |
| 6782 | 6746 | JimResetHashTable(ht); |
| 6783 | | - return JIM_OK; |
| 6747 | + return JIM_OK; |
| 6784 | 6748 | } |
| 6785 | 6749 | |
| 6786 | 6750 | Jim_HashEntry *Jim_FindHashEntry(Jim_HashTable *ht, const void *key) |
| 6787 | 6751 | { |
| 6788 | 6752 | Jim_HashEntry *he; |
| | @@ -6855,24 +6819,24 @@ |
| 6855 | 6819 | static Jim_HashEntry *JimInsertHashEntry(Jim_HashTable *ht, const void *key, int replace) |
| 6856 | 6820 | { |
| 6857 | 6821 | unsigned int h; |
| 6858 | 6822 | Jim_HashEntry *he; |
| 6859 | 6823 | |
| 6860 | | - |
| 6824 | + |
| 6861 | 6825 | JimExpandHashTableIfNeeded(ht); |
| 6862 | 6826 | |
| 6863 | | - |
| 6827 | + |
| 6864 | 6828 | h = Jim_HashKey(ht, key) & ht->sizemask; |
| 6865 | | - |
| 6829 | + |
| 6866 | 6830 | he = ht->table[h]; |
| 6867 | 6831 | while (he) { |
| 6868 | 6832 | if (Jim_CompareHashKeys(ht, key, he->key)) |
| 6869 | 6833 | return replace ? he : NULL; |
| 6870 | 6834 | he = he->next; |
| 6871 | 6835 | } |
| 6872 | 6836 | |
| 6873 | | - |
| 6837 | + |
| 6874 | 6838 | he = Jim_Alloc(sizeof(*he)); |
| 6875 | 6839 | he->next = ht->table[h]; |
| 6876 | 6840 | ht->table[h] = he; |
| 6877 | 6841 | ht->used++; |
| 6878 | 6842 | he->key = NULL; |
| | @@ -6901,16 +6865,16 @@ |
| 6901 | 6865 | { |
| 6902 | 6866 | Jim_Free(key); |
| 6903 | 6867 | } |
| 6904 | 6868 | |
| 6905 | 6869 | static const Jim_HashTableType JimPackageHashTableType = { |
| 6906 | | - JimStringCopyHTHashFunction, |
| 6907 | | - JimStringCopyHTDup, |
| 6908 | | - NULL, |
| 6909 | | - JimStringCopyHTKeyCompare, |
| 6910 | | - JimStringCopyHTKeyDestructor, |
| 6911 | | - NULL |
| 6870 | + JimStringCopyHTHashFunction, |
| 6871 | + JimStringCopyHTDup, |
| 6872 | + NULL, |
| 6873 | + JimStringCopyHTKeyCompare, |
| 6874 | + JimStringCopyHTKeyDestructor, |
| 6875 | + NULL |
| 6912 | 6876 | }; |
| 6913 | 6877 | |
| 6914 | 6878 | typedef struct AssocDataValue |
| 6915 | 6879 | { |
| 6916 | 6880 | Jim_InterpDeleteProc *delProc; |
| | @@ -6925,16 +6889,16 @@ |
| 6925 | 6889 | assocPtr->delProc((Jim_Interp *)privdata, assocPtr->data); |
| 6926 | 6890 | Jim_Free(data); |
| 6927 | 6891 | } |
| 6928 | 6892 | |
| 6929 | 6893 | static const Jim_HashTableType JimAssocDataHashTableType = { |
| 6930 | | - JimStringCopyHTHashFunction, |
| 6931 | | - JimStringCopyHTDup, |
| 6932 | | - NULL, |
| 6933 | | - JimStringCopyHTKeyCompare, |
| 6934 | | - JimStringCopyHTKeyDestructor, |
| 6935 | | - JimAssocDataHashTableValueDestructor |
| 6894 | + JimStringCopyHTHashFunction, |
| 6895 | + JimStringCopyHTDup, |
| 6896 | + NULL, |
| 6897 | + JimStringCopyHTKeyCompare, |
| 6898 | + JimStringCopyHTKeyDestructor, |
| 6899 | + JimAssocDataHashTableValueDestructor |
| 6936 | 6900 | }; |
| 6937 | 6901 | |
| 6938 | 6902 | void Jim_InitStack(Jim_Stack *stack) |
| 6939 | 6903 | { |
| 6940 | 6904 | stack->len = 0; |
| | @@ -6987,61 +6951,56 @@ |
| 6987 | 6951 | freeFunc(stack->vector[i]); |
| 6988 | 6952 | } |
| 6989 | 6953 | |
| 6990 | 6954 | |
| 6991 | 6955 | |
| 6992 | | -#define JIM_TT_NONE 0 |
| 6993 | | -#define JIM_TT_STR 1 |
| 6994 | | -#define JIM_TT_ESC 2 |
| 6995 | | -#define JIM_TT_VAR 3 |
| 6996 | | -#define JIM_TT_DICTSUGAR 4 |
| 6997 | | -#define JIM_TT_CMD 5 |
| 6998 | | - |
| 6999 | | -#define JIM_TT_SEP 6 |
| 7000 | | -#define JIM_TT_EOL 7 |
| 7001 | | -#define JIM_TT_EOF 8 |
| 7002 | | - |
| 7003 | | -#define JIM_TT_LINE 9 |
| 7004 | | -#define JIM_TT_WORD 10 |
| 6956 | +#define JIM_TT_NONE 0 |
| 6957 | +#define JIM_TT_STR 1 |
| 6958 | +#define JIM_TT_ESC 2 |
| 6959 | +#define JIM_TT_VAR 3 |
| 6960 | +#define JIM_TT_DICTSUGAR 4 |
| 6961 | +#define JIM_TT_CMD 5 |
| 6962 | + |
| 6963 | +#define JIM_TT_SEP 6 |
| 6964 | +#define JIM_TT_EOL 7 |
| 6965 | +#define JIM_TT_EOF 8 |
| 6966 | + |
| 6967 | +#define JIM_TT_LINE 9 |
| 6968 | +#define JIM_TT_WORD 10 |
| 7005 | 6969 | |
| 7006 | 6970 | |
| 7007 | 6971 | #define JIM_TT_SUBEXPR_START 11 |
| 7008 | 6972 | #define JIM_TT_SUBEXPR_END 12 |
| 7009 | 6973 | #define JIM_TT_SUBEXPR_COMMA 13 |
| 7010 | 6974 | #define JIM_TT_EXPR_INT 14 |
| 7011 | 6975 | #define JIM_TT_EXPR_DOUBLE 15 |
| 7012 | | -#define JIM_TT_EXPR_BOOLEAN 16 |
| 7013 | 6976 | |
| 7014 | | -#define JIM_TT_EXPRSUGAR 17 |
| 6977 | +#define JIM_TT_EXPRSUGAR 16 |
| 7015 | 6978 | |
| 7016 | 6979 | |
| 7017 | 6980 | #define JIM_TT_EXPR_OP 20 |
| 7018 | 6981 | |
| 7019 | 6982 | #define TOKEN_IS_SEP(type) (type >= JIM_TT_SEP && type <= JIM_TT_EOF) |
| 7020 | 6983 | |
| 7021 | | -#define TOKEN_IS_EXPR_START(type) (type == JIM_TT_NONE || type == JIM_TT_SUBEXPR_START || type == JIM_TT_SUBEXPR_COMMA) |
| 7022 | | - |
| 7023 | | -#define TOKEN_IS_EXPR_OP(type) (type >= JIM_TT_EXPR_OP) |
| 7024 | | - |
| 7025 | 6984 | struct JimParseMissing { |
| 7026 | | - int ch; |
| 7027 | | - int line; |
| 6985 | + int ch; |
| 6986 | + int line; |
| 7028 | 6987 | }; |
| 7029 | 6988 | |
| 7030 | 6989 | struct JimParserCtx |
| 7031 | 6990 | { |
| 7032 | | - const char *p; |
| 7033 | | - int len; |
| 7034 | | - int linenr; |
| 6991 | + const char *p; |
| 6992 | + int len; |
| 6993 | + int linenr; |
| 7035 | 6994 | const char *tstart; |
| 7036 | | - const char *tend; |
| 7037 | | - int tline; |
| 7038 | | - int tt; |
| 7039 | | - int eof; |
| 7040 | | - int inquote; |
| 7041 | | - int comment; |
| 7042 | | - struct JimParseMissing missing; |
| 6995 | + const char *tend; |
| 6996 | + int tline; |
| 6997 | + int tt; |
| 6998 | + int eof; |
| 6999 | + int inquote; |
| 7000 | + int comment; |
| 7001 | + struct JimParseMissing missing; |
| 7043 | 7002 | }; |
| 7044 | 7003 | |
| 7045 | 7004 | static int JimParseScript(struct JimParserCtx *pc); |
| 7046 | 7005 | static int JimParseSep(struct JimParserCtx *pc); |
| 7047 | 7006 | static int JimParseEol(struct JimParserCtx *pc); |
| | @@ -7071,11 +7030,11 @@ |
| 7071 | 7030 | pc->missing.line = linenr; |
| 7072 | 7031 | } |
| 7073 | 7032 | |
| 7074 | 7033 | static int JimParseScript(struct JimParserCtx *pc) |
| 7075 | 7034 | { |
| 7076 | | - while (1) { |
| 7035 | + while (1) { |
| 7077 | 7036 | if (!pc->len) { |
| 7078 | 7037 | pc->tstart = pc->p; |
| 7079 | 7038 | pc->tend = pc->p - 1; |
| 7080 | 7039 | pc->tline = pc->linenr; |
| 7081 | 7040 | pc->tt = JIM_TT_EOL; |
| | @@ -7107,11 +7066,11 @@ |
| 7107 | 7066 | pc->comment = 0; |
| 7108 | 7067 | return JimParseCmd(pc); |
| 7109 | 7068 | case '$': |
| 7110 | 7069 | pc->comment = 0; |
| 7111 | 7070 | if (JimParseVar(pc) == JIM_ERR) { |
| 7112 | | - |
| 7071 | + |
| 7113 | 7072 | pc->tstart = pc->tend = pc->p++; |
| 7114 | 7073 | pc->len--; |
| 7115 | 7074 | pc->tt = JIM_TT_ESC; |
| 7116 | 7075 | } |
| 7117 | 7076 | return JIM_OK; |
| | @@ -7168,11 +7127,11 @@ |
| 7168 | 7127 | |
| 7169 | 7128 | static void JimParseSubBrace(struct JimParserCtx *pc) |
| 7170 | 7129 | { |
| 7171 | 7130 | int level = 1; |
| 7172 | 7131 | |
| 7173 | | - |
| 7132 | + |
| 7174 | 7133 | pc->p++; |
| 7175 | 7134 | pc->len--; |
| 7176 | 7135 | while (pc->len) { |
| 7177 | 7136 | switch (*pc->p) { |
| 7178 | 7137 | case '\\': |
| | @@ -7212,11 +7171,11 @@ |
| 7212 | 7171 | static int JimParseSubQuote(struct JimParserCtx *pc) |
| 7213 | 7172 | { |
| 7214 | 7173 | int tt = JIM_TT_STR; |
| 7215 | 7174 | int line = pc->tline; |
| 7216 | 7175 | |
| 7217 | | - |
| 7176 | + |
| 7218 | 7177 | pc->p++; |
| 7219 | 7178 | pc->len--; |
| 7220 | 7179 | while (pc->len) { |
| 7221 | 7180 | switch (*pc->p) { |
| 7222 | 7181 | case '\\': |
| | @@ -7261,11 +7220,11 @@ |
| 7261 | 7220 | { |
| 7262 | 7221 | int level = 1; |
| 7263 | 7222 | int startofword = 1; |
| 7264 | 7223 | int line = pc->tline; |
| 7265 | 7224 | |
| 7266 | | - |
| 7225 | + |
| 7267 | 7226 | pc->p++; |
| 7268 | 7227 | pc->len--; |
| 7269 | 7228 | while (pc->len) { |
| 7270 | 7229 | switch (*pc->p) { |
| 7271 | 7230 | case '\\': |
| | @@ -7341,17 +7300,17 @@ |
| 7341 | 7300 | return JIM_OK; |
| 7342 | 7301 | } |
| 7343 | 7302 | |
| 7344 | 7303 | static int JimParseVar(struct JimParserCtx *pc) |
| 7345 | 7304 | { |
| 7346 | | - |
| 7305 | + |
| 7347 | 7306 | pc->p++; |
| 7348 | 7307 | pc->len--; |
| 7349 | 7308 | |
| 7350 | 7309 | #ifdef EXPRSUGAR_BRACKET |
| 7351 | 7310 | if (*pc->p == '[') { |
| 7352 | | - |
| 7311 | + |
| 7353 | 7312 | JimParseCmd(pc); |
| 7354 | 7313 | pc->tt = JIM_TT_EXPRSUGAR; |
| 7355 | 7314 | return JIM_OK; |
| 7356 | 7315 | } |
| 7357 | 7316 | #endif |
| | @@ -7377,11 +7336,11 @@ |
| 7377 | 7336 | pc->len--; |
| 7378 | 7337 | } |
| 7379 | 7338 | } |
| 7380 | 7339 | else { |
| 7381 | 7340 | while (1) { |
| 7382 | | - |
| 7341 | + |
| 7383 | 7342 | if (pc->p[0] == ':' && pc->p[1] == ':') { |
| 7384 | 7343 | while (*pc->p == ':') { |
| 7385 | 7344 | pc->p++; |
| 7386 | 7345 | pc->len--; |
| 7387 | 7346 | } |
| | @@ -7392,11 +7351,11 @@ |
| 7392 | 7351 | pc->len--; |
| 7393 | 7352 | continue; |
| 7394 | 7353 | } |
| 7395 | 7354 | break; |
| 7396 | 7355 | } |
| 7397 | | - |
| 7356 | + |
| 7398 | 7357 | if (*pc->p == '(') { |
| 7399 | 7358 | int count = 1; |
| 7400 | 7359 | const char *paren = NULL; |
| 7401 | 7360 | |
| 7402 | 7361 | pc->tt = JIM_TT_DICTSUGAR; |
| | @@ -7419,11 +7378,11 @@ |
| 7419 | 7378 | if (count == 0) { |
| 7420 | 7379 | pc->p++; |
| 7421 | 7380 | pc->len--; |
| 7422 | 7381 | } |
| 7423 | 7382 | else if (paren) { |
| 7424 | | - |
| 7383 | + |
| 7425 | 7384 | paren++; |
| 7426 | 7385 | pc->len += (pc->p - paren); |
| 7427 | 7386 | pc->p = paren; |
| 7428 | 7387 | } |
| 7429 | 7388 | #ifndef EXPRSUGAR_BRACKET |
| | @@ -7444,19 +7403,19 @@ |
| 7444 | 7403 | |
| 7445 | 7404 | static int JimParseStr(struct JimParserCtx *pc) |
| 7446 | 7405 | { |
| 7447 | 7406 | if (pc->tt == JIM_TT_SEP || pc->tt == JIM_TT_EOL || |
| 7448 | 7407 | pc->tt == JIM_TT_NONE || pc->tt == JIM_TT_STR) { |
| 7449 | | - |
| 7408 | + |
| 7450 | 7409 | if (*pc->p == '{') { |
| 7451 | 7410 | return JimParseBrace(pc); |
| 7452 | 7411 | } |
| 7453 | 7412 | if (*pc->p == '"') { |
| 7454 | 7413 | pc->inquote = 1; |
| 7455 | 7414 | pc->p++; |
| 7456 | 7415 | pc->len--; |
| 7457 | | - |
| 7416 | + |
| 7458 | 7417 | pc->missing.line = pc->tline; |
| 7459 | 7418 | } |
| 7460 | 7419 | } |
| 7461 | 7420 | pc->tstart = pc->p; |
| 7462 | 7421 | pc->tline = pc->linenr; |
| | @@ -7482,25 +7441,25 @@ |
| 7482 | 7441 | } |
| 7483 | 7442 | pc->p++; |
| 7484 | 7443 | pc->len--; |
| 7485 | 7444 | } |
| 7486 | 7445 | else if (pc->len == 1) { |
| 7487 | | - |
| 7446 | + |
| 7488 | 7447 | pc->missing.ch = '\\'; |
| 7489 | 7448 | } |
| 7490 | 7449 | break; |
| 7491 | 7450 | case '(': |
| 7492 | | - |
| 7451 | + |
| 7493 | 7452 | if (pc->len > 1 && pc->p[1] != '$') { |
| 7494 | 7453 | break; |
| 7495 | 7454 | } |
| 7496 | | - |
| 7455 | + |
| 7497 | 7456 | case ')': |
| 7498 | | - |
| 7457 | + |
| 7499 | 7458 | if (*pc->p == '(' || pc->tt == JIM_TT_VAR) { |
| 7500 | 7459 | if (pc->p == pc->tstart) { |
| 7501 | | - |
| 7460 | + |
| 7502 | 7461 | pc->p++; |
| 7503 | 7462 | pc->len--; |
| 7504 | 7463 | } |
| 7505 | 7464 | pc->tend = pc->p - 1; |
| 7506 | 7465 | pc->tt = JIM_TT_ESC; |
| | @@ -7540,11 +7499,11 @@ |
| 7540 | 7499 | break; |
| 7541 | 7500 | } |
| 7542 | 7501 | pc->p++; |
| 7543 | 7502 | pc->len--; |
| 7544 | 7503 | } |
| 7545 | | - return JIM_OK; |
| 7504 | + return JIM_OK; |
| 7546 | 7505 | } |
| 7547 | 7506 | |
| 7548 | 7507 | static int JimParseComment(struct JimParserCtx *pc) |
| 7549 | 7508 | { |
| 7550 | 7509 | while (*pc->p) { |
| | @@ -7651,34 +7610,34 @@ |
| 7651 | 7610 | if (c == -1) { |
| 7652 | 7611 | break; |
| 7653 | 7612 | } |
| 7654 | 7613 | val = (val << 4) | c; |
| 7655 | 7614 | } |
| 7656 | | - |
| 7615 | + |
| 7657 | 7616 | if (s[i] == '{') { |
| 7658 | 7617 | if (k == 0 || val > 0x1fffff || s[i + k + 1] != '}') { |
| 7659 | | - |
| 7618 | + |
| 7660 | 7619 | i--; |
| 7661 | 7620 | k = 0; |
| 7662 | 7621 | } |
| 7663 | 7622 | else { |
| 7664 | | - |
| 7623 | + |
| 7665 | 7624 | k++; |
| 7666 | 7625 | } |
| 7667 | 7626 | } |
| 7668 | 7627 | if (k) { |
| 7669 | | - |
| 7628 | + |
| 7670 | 7629 | if (s[i] == 'x') { |
| 7671 | 7630 | *p++ = val; |
| 7672 | 7631 | } |
| 7673 | 7632 | else { |
| 7674 | 7633 | p += utf8_fromunicode(p, val); |
| 7675 | 7634 | } |
| 7676 | 7635 | i += k; |
| 7677 | 7636 | break; |
| 7678 | 7637 | } |
| 7679 | | - |
| 7638 | + |
| 7680 | 7639 | *p++ = s[i]; |
| 7681 | 7640 | } |
| 7682 | 7641 | break; |
| 7683 | 7642 | case 'v': |
| 7684 | 7643 | *p++ = 0xb; |
| | @@ -7687,11 +7646,11 @@ |
| 7687 | 7646 | case '\0': |
| 7688 | 7647 | *p++ = '\\'; |
| 7689 | 7648 | i++; |
| 7690 | 7649 | break; |
| 7691 | 7650 | case '\n': |
| 7692 | | - |
| 7651 | + |
| 7693 | 7652 | *p++ = ' '; |
| 7694 | 7653 | do { |
| 7695 | 7654 | i++; |
| 7696 | 7655 | } while (s[i + 1] == ' ' || s[i + 1] == '\t'); |
| 7697 | 7656 | break; |
| | @@ -7701,11 +7660,11 @@ |
| 7701 | 7660 | case '3': |
| 7702 | 7661 | case '4': |
| 7703 | 7662 | case '5': |
| 7704 | 7663 | case '6': |
| 7705 | 7664 | case '7': |
| 7706 | | - |
| 7665 | + |
| 7707 | 7666 | { |
| 7708 | 7667 | int val = 0; |
| 7709 | 7668 | int c = odigitval(s[i + 1]); |
| 7710 | 7669 | |
| 7711 | 7670 | val = c; |
| | @@ -7758,16 +7717,16 @@ |
| 7758 | 7717 | } |
| 7759 | 7718 | else { |
| 7760 | 7719 | len = (end - start) + 1; |
| 7761 | 7720 | token = Jim_Alloc(len + 1); |
| 7762 | 7721 | if (pc->tt != JIM_TT_ESC) { |
| 7763 | | - |
| 7722 | + |
| 7764 | 7723 | memcpy(token, start, len); |
| 7765 | 7724 | token[len] = '\0'; |
| 7766 | 7725 | } |
| 7767 | 7726 | else { |
| 7768 | | - |
| 7727 | + |
| 7769 | 7728 | len = JimEscape(token, start, len); |
| 7770 | 7729 | } |
| 7771 | 7730 | } |
| 7772 | 7731 | |
| 7773 | 7732 | return Jim_NewStringObjNoAlloc(interp, token, len); |
| | @@ -7831,11 +7790,11 @@ |
| 7831 | 7790 | while (pc->len) { |
| 7832 | 7791 | switch (*pc->p) { |
| 7833 | 7792 | case '\\': |
| 7834 | 7793 | pc->tt = JIM_TT_ESC; |
| 7835 | 7794 | if (--pc->len == 0) { |
| 7836 | | - |
| 7795 | + |
| 7837 | 7796 | pc->tend = pc->p; |
| 7838 | 7797 | return JIM_OK; |
| 7839 | 7798 | } |
| 7840 | 7799 | pc->p++; |
| 7841 | 7800 | break; |
| | @@ -7867,11 +7826,11 @@ |
| 7867 | 7826 | pc->tend = pc->p - 1; |
| 7868 | 7827 | return JIM_OK; |
| 7869 | 7828 | } |
| 7870 | 7829 | if (*pc->p == '\\') { |
| 7871 | 7830 | if (--pc->len == 0) { |
| 7872 | | - |
| 7831 | + |
| 7873 | 7832 | pc->tend = pc->p; |
| 7874 | 7833 | return JIM_OK; |
| 7875 | 7834 | } |
| 7876 | 7835 | pc->tt = JIM_TT_ESC; |
| 7877 | 7836 | pc->p++; |
| | @@ -7887,24 +7846,24 @@ |
| 7887 | 7846 | |
| 7888 | 7847 | Jim_Obj *Jim_NewObj(Jim_Interp *interp) |
| 7889 | 7848 | { |
| 7890 | 7849 | Jim_Obj *objPtr; |
| 7891 | 7850 | |
| 7892 | | - |
| 7851 | + |
| 7893 | 7852 | if (interp->freeList != NULL) { |
| 7894 | | - |
| 7853 | + |
| 7895 | 7854 | objPtr = interp->freeList; |
| 7896 | 7855 | interp->freeList = objPtr->nextObjPtr; |
| 7897 | 7856 | } |
| 7898 | 7857 | else { |
| 7899 | | - |
| 7858 | + |
| 7900 | 7859 | objPtr = Jim_Alloc(sizeof(*objPtr)); |
| 7901 | 7860 | } |
| 7902 | 7861 | |
| 7903 | 7862 | objPtr->refCount = 0; |
| 7904 | 7863 | |
| 7905 | | - |
| 7864 | + |
| 7906 | 7865 | objPtr->prevObjPtr = NULL; |
| 7907 | 7866 | objPtr->nextObjPtr = interp->liveList; |
| 7908 | 7867 | if (interp->liveList) |
| 7909 | 7868 | interp->liveList->prevObjPtr = objPtr; |
| 7910 | 7869 | interp->liveList = objPtr; |
| | @@ -7912,32 +7871,32 @@ |
| 7912 | 7871 | return objPtr; |
| 7913 | 7872 | } |
| 7914 | 7873 | |
| 7915 | 7874 | void Jim_FreeObj(Jim_Interp *interp, Jim_Obj *objPtr) |
| 7916 | 7875 | { |
| 7917 | | - |
| 7876 | + |
| 7918 | 7877 | JimPanic((objPtr->refCount != 0, "!!!Object %p freed with bad refcount %d, type=%s", objPtr, |
| 7919 | 7878 | objPtr->refCount, objPtr->typePtr ? objPtr->typePtr->name : "<none>")); |
| 7920 | 7879 | |
| 7921 | | - |
| 7880 | + |
| 7922 | 7881 | Jim_FreeIntRep(interp, objPtr); |
| 7923 | | - |
| 7882 | + |
| 7924 | 7883 | if (objPtr->bytes != NULL) { |
| 7925 | 7884 | if (objPtr->bytes != JimEmptyStringRep) |
| 7926 | 7885 | Jim_Free(objPtr->bytes); |
| 7927 | 7886 | } |
| 7928 | | - |
| 7887 | + |
| 7929 | 7888 | if (objPtr->prevObjPtr) |
| 7930 | 7889 | objPtr->prevObjPtr->nextObjPtr = objPtr->nextObjPtr; |
| 7931 | 7890 | if (objPtr->nextObjPtr) |
| 7932 | 7891 | objPtr->nextObjPtr->prevObjPtr = objPtr->prevObjPtr; |
| 7933 | 7892 | if (interp->liveList == objPtr) |
| 7934 | 7893 | interp->liveList = objPtr->nextObjPtr; |
| 7935 | 7894 | #ifdef JIM_DISABLE_OBJECT_POOL |
| 7936 | 7895 | Jim_Free(objPtr); |
| 7937 | 7896 | #else |
| 7938 | | - |
| 7897 | + |
| 7939 | 7898 | objPtr->prevObjPtr = NULL; |
| 7940 | 7899 | objPtr->nextObjPtr = interp->freeList; |
| 7941 | 7900 | if (interp->freeList) |
| 7942 | 7901 | interp->freeList->prevObjPtr = objPtr; |
| 7943 | 7902 | interp->freeList = objPtr; |
| | @@ -7960,45 +7919,45 @@ |
| 7960 | 7919 | { |
| 7961 | 7920 | Jim_Obj *dupPtr; |
| 7962 | 7921 | |
| 7963 | 7922 | dupPtr = Jim_NewObj(interp); |
| 7964 | 7923 | if (objPtr->bytes == NULL) { |
| 7965 | | - |
| 7924 | + |
| 7966 | 7925 | dupPtr->bytes = NULL; |
| 7967 | 7926 | } |
| 7968 | 7927 | else if (objPtr->length == 0) { |
| 7969 | | - |
| 7928 | + |
| 7970 | 7929 | dupPtr->bytes = JimEmptyStringRep; |
| 7971 | 7930 | dupPtr->length = 0; |
| 7972 | 7931 | dupPtr->typePtr = NULL; |
| 7973 | 7932 | return dupPtr; |
| 7974 | 7933 | } |
| 7975 | 7934 | else { |
| 7976 | 7935 | dupPtr->bytes = Jim_Alloc(objPtr->length + 1); |
| 7977 | 7936 | dupPtr->length = objPtr->length; |
| 7978 | | - |
| 7937 | + |
| 7979 | 7938 | memcpy(dupPtr->bytes, objPtr->bytes, objPtr->length + 1); |
| 7980 | 7939 | } |
| 7981 | 7940 | |
| 7982 | | - |
| 7941 | + |
| 7983 | 7942 | dupPtr->typePtr = objPtr->typePtr; |
| 7984 | 7943 | if (objPtr->typePtr != NULL) { |
| 7985 | 7944 | if (objPtr->typePtr->dupIntRepProc == NULL) { |
| 7986 | 7945 | dupPtr->internalRep = objPtr->internalRep; |
| 7987 | 7946 | } |
| 7988 | 7947 | else { |
| 7989 | | - |
| 7948 | + |
| 7990 | 7949 | objPtr->typePtr->dupIntRepProc(interp, objPtr, dupPtr); |
| 7991 | 7950 | } |
| 7992 | 7951 | } |
| 7993 | 7952 | return dupPtr; |
| 7994 | 7953 | } |
| 7995 | 7954 | |
| 7996 | 7955 | const char *Jim_GetString(Jim_Obj *objPtr, int *lenPtr) |
| 7997 | 7956 | { |
| 7998 | 7957 | if (objPtr->bytes == NULL) { |
| 7999 | | - |
| 7958 | + |
| 8000 | 7959 | JimPanic((objPtr->typePtr->updateStringProc == NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name)); |
| 8001 | 7960 | objPtr->typePtr->updateStringProc(objPtr); |
| 8002 | 7961 | } |
| 8003 | 7962 | if (lenPtr) |
| 8004 | 7963 | *lenPtr = objPtr->length; |
| | @@ -8007,11 +7966,11 @@ |
| 8007 | 7966 | |
| 8008 | 7967 | |
| 8009 | 7968 | int Jim_Length(Jim_Obj *objPtr) |
| 8010 | 7969 | { |
| 8011 | 7970 | if (objPtr->bytes == NULL) { |
| 8012 | | - |
| 7971 | + |
| 8013 | 7972 | JimPanic((objPtr->typePtr->updateStringProc == NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name)); |
| 8014 | 7973 | objPtr->typePtr->updateStringProc(objPtr); |
| 8015 | 7974 | } |
| 8016 | 7975 | return objPtr->length; |
| 8017 | 7976 | } |
| | @@ -8018,11 +7977,11 @@ |
| 8018 | 7977 | |
| 8019 | 7978 | |
| 8020 | 7979 | const char *Jim_String(Jim_Obj *objPtr) |
| 8021 | 7980 | { |
| 8022 | 7981 | if (objPtr->bytes == NULL) { |
| 8023 | | - |
| 7982 | + |
| 8024 | 7983 | JimPanic((objPtr->typePtr == NULL, "UpdateStringProc called against typeless value.")); |
| 8025 | 7984 | JimPanic((objPtr->typePtr->updateStringProc == NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name)); |
| 8026 | 7985 | objPtr->typePtr->updateStringProc(objPtr); |
| 8027 | 7986 | } |
| 8028 | 7987 | return objPtr->bytes; |
| | @@ -8078,22 +8037,22 @@ |
| 8078 | 8037 | } |
| 8079 | 8038 | |
| 8080 | 8039 | static int SetStringFromAny(Jim_Interp *interp, Jim_Obj *objPtr) |
| 8081 | 8040 | { |
| 8082 | 8041 | if (objPtr->typePtr != &stringObjType) { |
| 8083 | | - |
| 8042 | + |
| 8084 | 8043 | if (objPtr->bytes == NULL) { |
| 8085 | | - |
| 8044 | + |
| 8086 | 8045 | JimPanic((objPtr->typePtr->updateStringProc == NULL, "UpdateStringProc called against '%s' type.", objPtr->typePtr->name)); |
| 8087 | 8046 | objPtr->typePtr->updateStringProc(objPtr); |
| 8088 | 8047 | } |
| 8089 | | - |
| 8048 | + |
| 8090 | 8049 | Jim_FreeIntRep(interp, objPtr); |
| 8091 | | - |
| 8050 | + |
| 8092 | 8051 | objPtr->typePtr = &stringObjType; |
| 8093 | 8052 | objPtr->internalRep.strValue.maxLength = objPtr->length; |
| 8094 | | - |
| 8053 | + |
| 8095 | 8054 | objPtr->internalRep.strValue.charLength = -1; |
| 8096 | 8055 | } |
| 8097 | 8056 | return JIM_OK; |
| 8098 | 8057 | } |
| 8099 | 8058 | |
| | @@ -8114,14 +8073,14 @@ |
| 8114 | 8073 | |
| 8115 | 8074 | Jim_Obj *Jim_NewStringObj(Jim_Interp *interp, const char *s, int len) |
| 8116 | 8075 | { |
| 8117 | 8076 | Jim_Obj *objPtr = Jim_NewObj(interp); |
| 8118 | 8077 | |
| 8119 | | - |
| 8078 | + |
| 8120 | 8079 | if (len == -1) |
| 8121 | 8080 | len = strlen(s); |
| 8122 | | - |
| 8081 | + |
| 8123 | 8082 | if (len == 0) { |
| 8124 | 8083 | objPtr->bytes = JimEmptyStringRep; |
| 8125 | 8084 | } |
| 8126 | 8085 | else { |
| 8127 | 8086 | objPtr->bytes = Jim_Alloc(len + 1); |
| | @@ -8128,25 +8087,25 @@ |
| 8128 | 8087 | memcpy(objPtr->bytes, s, len); |
| 8129 | 8088 | objPtr->bytes[len] = '\0'; |
| 8130 | 8089 | } |
| 8131 | 8090 | objPtr->length = len; |
| 8132 | 8091 | |
| 8133 | | - |
| 8092 | + |
| 8134 | 8093 | objPtr->typePtr = NULL; |
| 8135 | 8094 | return objPtr; |
| 8136 | 8095 | } |
| 8137 | 8096 | |
| 8138 | 8097 | |
| 8139 | 8098 | Jim_Obj *Jim_NewStringObjUtf8(Jim_Interp *interp, const char *s, int charlen) |
| 8140 | 8099 | { |
| 8141 | 8100 | #ifdef JIM_UTF8 |
| 8142 | | - |
| 8101 | + |
| 8143 | 8102 | int bytelen = utf8_index(s, charlen); |
| 8144 | 8103 | |
| 8145 | 8104 | Jim_Obj *objPtr = Jim_NewStringObj(interp, s, bytelen); |
| 8146 | 8105 | |
| 8147 | | - |
| 8106 | + |
| 8148 | 8107 | objPtr->typePtr = &stringObjType; |
| 8149 | 8108 | objPtr->internalRep.strValue.maxLength = bytelen; |
| 8150 | 8109 | objPtr->internalRep.strValue.charLength = charlen; |
| 8151 | 8110 | |
| 8152 | 8111 | return objPtr; |
| | @@ -8173,11 +8132,11 @@ |
| 8173 | 8132 | len = strlen(str); |
| 8174 | 8133 | needlen = objPtr->length + len; |
| 8175 | 8134 | if (objPtr->internalRep.strValue.maxLength < needlen || |
| 8176 | 8135 | objPtr->internalRep.strValue.maxLength == 0) { |
| 8177 | 8136 | needlen *= 2; |
| 8178 | | - |
| 8137 | + |
| 8179 | 8138 | if (needlen < 7) { |
| 8180 | 8139 | needlen = 7; |
| 8181 | 8140 | } |
| 8182 | 8141 | if (objPtr->bytes == JimEmptyStringRep) { |
| 8183 | 8142 | objPtr->bytes = Jim_Alloc(needlen + 1); |
| | @@ -8189,11 +8148,11 @@ |
| 8189 | 8148 | } |
| 8190 | 8149 | memcpy(objPtr->bytes + objPtr->length, str, len); |
| 8191 | 8150 | objPtr->bytes[objPtr->length + len] = '\0'; |
| 8192 | 8151 | |
| 8193 | 8152 | if (objPtr->internalRep.strValue.charLength >= 0) { |
| 8194 | | - |
| 8153 | + |
| 8195 | 8154 | objPtr->internalRep.strValue.charLength += utf8_strlen(objPtr->bytes + objPtr->length, len); |
| 8196 | 8155 | } |
| 8197 | 8156 | objPtr->length += len; |
| 8198 | 8157 | } |
| 8199 | 8158 | |
| | @@ -8251,11 +8210,11 @@ |
| 8251 | 8210 | int l1, l2; |
| 8252 | 8211 | const char *s1 = Jim_GetString(firstObjPtr, &l1); |
| 8253 | 8212 | const char *s2 = Jim_GetString(secondObjPtr, &l2); |
| 8254 | 8213 | |
| 8255 | 8214 | if (nocase) { |
| 8256 | | - |
| 8215 | + |
| 8257 | 8216 | return JimStringCompareLen(s1, s2, -1, nocase); |
| 8258 | 8217 | } |
| 8259 | 8218 | return JimStringCompare(s1, l1, s2, l2); |
| 8260 | 8219 | } |
| 8261 | 8220 | |
| | @@ -8353,11 +8312,11 @@ |
| 8353 | 8312 | |
| 8354 | 8313 | if (first == 0 && rangeLen == len) { |
| 8355 | 8314 | return strObjPtr; |
| 8356 | 8315 | } |
| 8357 | 8316 | if (len == bytelen) { |
| 8358 | | - |
| 8317 | + |
| 8359 | 8318 | return Jim_NewStringObj(interp, str + first, rangeLen); |
| 8360 | 8319 | } |
| 8361 | 8320 | return Jim_NewStringObjUtf8(interp, str + utf8_index(str, first), rangeLen); |
| 8362 | 8321 | #else |
| 8363 | 8322 | return Jim_StringByteRangeObj(interp, strObjPtr, firstObjPtr, lastObjPtr); |
| | @@ -8382,19 +8341,19 @@ |
| 8382 | 8341 | return strObjPtr; |
| 8383 | 8342 | } |
| 8384 | 8343 | |
| 8385 | 8344 | str = Jim_String(strObjPtr); |
| 8386 | 8345 | |
| 8387 | | - |
| 8346 | + |
| 8388 | 8347 | objPtr = Jim_NewStringObjUtf8(interp, str, first); |
| 8389 | 8348 | |
| 8390 | | - |
| 8349 | + |
| 8391 | 8350 | if (newStrObj) { |
| 8392 | 8351 | Jim_AppendObj(interp, objPtr, newStrObj); |
| 8393 | 8352 | } |
| 8394 | 8353 | |
| 8395 | | - |
| 8354 | + |
| 8396 | 8355 | Jim_AppendString(interp, objPtr, str + utf8_index(str, last + 1), len - last - 1); |
| 8397 | 8356 | |
| 8398 | 8357 | return objPtr; |
| 8399 | 8358 | } |
| 8400 | 8359 | |
| | @@ -8493,11 +8452,11 @@ |
| 8493 | 8452 | while (len) { |
| 8494 | 8453 | int c; |
| 8495 | 8454 | int n = utf8_tounicode(str, &c); |
| 8496 | 8455 | |
| 8497 | 8456 | if (utf8_memchr(trimchars, trimlen, c) == NULL) { |
| 8498 | | - |
| 8457 | + |
| 8499 | 8458 | break; |
| 8500 | 8459 | } |
| 8501 | 8460 | str += n; |
| 8502 | 8461 | len -= n; |
| 8503 | 8462 | } |
| | @@ -8564,41 +8523,41 @@ |
| 8564 | 8523 | |
| 8565 | 8524 | len = Jim_Length(strObjPtr); |
| 8566 | 8525 | nontrim = JimFindTrimRight(strObjPtr->bytes, len, trimchars, trimcharslen); |
| 8567 | 8526 | |
| 8568 | 8527 | if (nontrim == NULL) { |
| 8569 | | - |
| 8528 | + |
| 8570 | 8529 | return Jim_NewEmptyStringObj(interp); |
| 8571 | 8530 | } |
| 8572 | 8531 | if (nontrim == strObjPtr->bytes + len) { |
| 8573 | | - |
| 8532 | + |
| 8574 | 8533 | return strObjPtr; |
| 8575 | 8534 | } |
| 8576 | 8535 | |
| 8577 | 8536 | if (Jim_IsShared(strObjPtr)) { |
| 8578 | 8537 | strObjPtr = Jim_NewStringObj(interp, strObjPtr->bytes, (nontrim - strObjPtr->bytes)); |
| 8579 | 8538 | } |
| 8580 | 8539 | else { |
| 8581 | | - |
| 8540 | + |
| 8582 | 8541 | strObjPtr->bytes[nontrim - strObjPtr->bytes] = 0; |
| 8583 | 8542 | strObjPtr->length = (nontrim - strObjPtr->bytes); |
| 8584 | 8543 | } |
| 8585 | 8544 | |
| 8586 | 8545 | return strObjPtr; |
| 8587 | 8546 | } |
| 8588 | 8547 | |
| 8589 | 8548 | static Jim_Obj *JimStringTrim(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *trimcharsObjPtr) |
| 8590 | 8549 | { |
| 8591 | | - |
| 8550 | + |
| 8592 | 8551 | Jim_Obj *objPtr = JimStringTrimLeft(interp, strObjPtr, trimcharsObjPtr); |
| 8593 | 8552 | |
| 8594 | | - |
| 8553 | + |
| 8595 | 8554 | strObjPtr = JimStringTrimRight(interp, objPtr, trimcharsObjPtr); |
| 8596 | 8555 | |
| 8597 | | - |
| 8556 | + |
| 8598 | 8557 | if (objPtr != strObjPtr && objPtr->refCount == 0) { |
| 8599 | | - |
| 8558 | + |
| 8600 | 8559 | Jim_FreeNewObj(interp, objPtr); |
| 8601 | 8560 | } |
| 8602 | 8561 | |
| 8603 | 8562 | return strObjPtr; |
| 8604 | 8563 | } |
| | @@ -8616,17 +8575,17 @@ |
| 8616 | 8575 | static int JimStringIs(Jim_Interp *interp, Jim_Obj *strObjPtr, Jim_Obj *strClass, int strict) |
| 8617 | 8576 | { |
| 8618 | 8577 | static const char * const strclassnames[] = { |
| 8619 | 8578 | "integer", "alpha", "alnum", "ascii", "digit", |
| 8620 | 8579 | "double", "lower", "upper", "space", "xdigit", |
| 8621 | | - "control", "print", "graph", "punct", "boolean", |
| 8580 | + "control", "print", "graph", "punct", |
| 8622 | 8581 | NULL |
| 8623 | 8582 | }; |
| 8624 | 8583 | enum { |
| 8625 | 8584 | STR_IS_INTEGER, STR_IS_ALPHA, STR_IS_ALNUM, STR_IS_ASCII, STR_IS_DIGIT, |
| 8626 | 8585 | STR_IS_DOUBLE, STR_IS_LOWER, STR_IS_UPPER, STR_IS_SPACE, STR_IS_XDIGIT, |
| 8627 | | - STR_IS_CONTROL, STR_IS_PRINT, STR_IS_GRAPH, STR_IS_PUNCT, STR_IS_BOOLEAN, |
| 8586 | + STR_IS_CONTROL, STR_IS_PRINT, STR_IS_GRAPH, STR_IS_PUNCT |
| 8628 | 8587 | }; |
| 8629 | 8588 | int strclass; |
| 8630 | 8589 | int len; |
| 8631 | 8590 | int i; |
| 8632 | 8591 | const char *str; |
| | @@ -8655,17 +8614,10 @@ |
| 8655 | 8614 | double d; |
| 8656 | 8615 | Jim_SetResultBool(interp, Jim_GetDouble(interp, strObjPtr, &d) == JIM_OK && errno != ERANGE); |
| 8657 | 8616 | return JIM_OK; |
| 8658 | 8617 | } |
| 8659 | 8618 | |
| 8660 | | - case STR_IS_BOOLEAN: |
| 8661 | | - { |
| 8662 | | - int b; |
| 8663 | | - Jim_SetResultBool(interp, Jim_GetBoolean(interp, strObjPtr, &b) == JIM_OK); |
| 8664 | | - return JIM_OK; |
| 8665 | | - } |
| 8666 | | - |
| 8667 | 8619 | case STR_IS_ALPHA: isclassfunc = isalpha; break; |
| 8668 | 8620 | case STR_IS_ALNUM: isclassfunc = isalnum; break; |
| 8669 | 8621 | case STR_IS_ASCII: isclassfunc = jim_isascii; break; |
| 8670 | 8622 | case STR_IS_DIGIT: isclassfunc = isdigit; break; |
| 8671 | 8623 | case STR_IS_LOWER: isclassfunc = islower; break; |
| | @@ -8713,11 +8665,11 @@ |
| 8713 | 8665 | |
| 8714 | 8666 | if (objPtr->typePtr != &comparedStringObjType) { |
| 8715 | 8667 | Jim_FreeIntRep(interp, objPtr); |
| 8716 | 8668 | objPtr->typePtr = &comparedStringObjType; |
| 8717 | 8669 | } |
| 8718 | | - objPtr->internalRep.ptr = (char *)str; |
| 8670 | + objPtr->internalRep.ptr = (char *)str; |
| 8719 | 8671 | return 1; |
| 8720 | 8672 | } |
| 8721 | 8673 | } |
| 8722 | 8674 | |
| 8723 | 8675 | static int qsortCompareStringPointers(const void *a, const void *b) |
| | @@ -8806,20 +8758,20 @@ |
| 8806 | 8758 | int type; |
| 8807 | 8759 | } ScriptToken; |
| 8808 | 8760 | |
| 8809 | 8761 | typedef struct ScriptObj |
| 8810 | 8762 | { |
| 8811 | | - ScriptToken *token; |
| 8812 | | - Jim_Obj *fileNameObj; |
| 8813 | | - int len; |
| 8814 | | - int substFlags; |
| 8763 | + ScriptToken *token; |
| 8764 | + Jim_Obj *fileNameObj; |
| 8765 | + int len; |
| 8766 | + int substFlags; |
| 8815 | 8767 | int inUse; /* Used to share a ScriptObj. Currently |
| 8816 | 8768 | only used by Jim_EvalObj() as protection against |
| 8817 | 8769 | shimmering of the currently evaluated object. */ |
| 8818 | | - int firstline; |
| 8819 | | - int linenr; |
| 8820 | | - int missing; |
| 8770 | + int firstline; |
| 8771 | + int linenr; |
| 8772 | + int missing; |
| 8821 | 8773 | } ScriptObj; |
| 8822 | 8774 | |
| 8823 | 8775 | static void JimSetScriptFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr); |
| 8824 | 8776 | static int JimParseCheckMissing(Jim_Interp *interp, int ch); |
| 8825 | 8777 | static ScriptObj *JimGetScript(Jim_Interp *interp, Jim_Obj *objPtr); |
| | @@ -8847,23 +8799,23 @@ |
| 8847 | 8799 | dupPtr->typePtr = NULL; |
| 8848 | 8800 | } |
| 8849 | 8801 | |
| 8850 | 8802 | typedef struct |
| 8851 | 8803 | { |
| 8852 | | - const char *token; |
| 8853 | | - int len; |
| 8854 | | - int type; |
| 8855 | | - int line; |
| 8804 | + const char *token; |
| 8805 | + int len; |
| 8806 | + int type; |
| 8807 | + int line; |
| 8856 | 8808 | } ParseToken; |
| 8857 | 8809 | |
| 8858 | 8810 | typedef struct |
| 8859 | 8811 | { |
| 8860 | | - |
| 8861 | | - ParseToken *list; |
| 8862 | | - int size; |
| 8863 | | - int count; |
| 8864 | | - ParseToken static_list[20]; |
| 8812 | + |
| 8813 | + ParseToken *list; |
| 8814 | + int size; |
| 8815 | + int count; |
| 8816 | + ParseToken static_list[20]; |
| 8865 | 8817 | } ParseTokenList; |
| 8866 | 8818 | |
| 8867 | 8819 | static void ScriptTokenListInit(ParseTokenList *tokenlist) |
| 8868 | 8820 | { |
| 8869 | 8821 | tokenlist->list = tokenlist->static_list; |
| | @@ -8882,18 +8834,18 @@ |
| 8882 | 8834 | int line) |
| 8883 | 8835 | { |
| 8884 | 8836 | ParseToken *t; |
| 8885 | 8837 | |
| 8886 | 8838 | if (tokenlist->count == tokenlist->size) { |
| 8887 | | - |
| 8839 | + |
| 8888 | 8840 | tokenlist->size *= 2; |
| 8889 | 8841 | if (tokenlist->list != tokenlist->static_list) { |
| 8890 | 8842 | tokenlist->list = |
| 8891 | 8843 | Jim_Realloc(tokenlist->list, tokenlist->size * sizeof(*tokenlist->list)); |
| 8892 | 8844 | } |
| 8893 | 8845 | else { |
| 8894 | | - |
| 8846 | + |
| 8895 | 8847 | tokenlist->list = Jim_Alloc(tokenlist->size * sizeof(*tokenlist->list)); |
| 8896 | 8848 | memcpy(tokenlist->list, tokenlist->static_list, |
| 8897 | 8849 | tokenlist->count * sizeof(*tokenlist->list)); |
| 8898 | 8850 | } |
| 8899 | 8851 | } |
| | @@ -8907,20 +8859,20 @@ |
| 8907 | 8859 | static int JimCountWordTokens(ParseToken *t) |
| 8908 | 8860 | { |
| 8909 | 8861 | int expand = 1; |
| 8910 | 8862 | int count = 0; |
| 8911 | 8863 | |
| 8912 | | - |
| 8864 | + |
| 8913 | 8865 | if (t->type == JIM_TT_STR && !TOKEN_IS_SEP(t[1].type)) { |
| 8914 | 8866 | if ((t->len == 1 && *t->token == '*') || (t->len == 6 && strncmp(t->token, "expand", 6) == 0)) { |
| 8915 | | - |
| 8867 | + |
| 8916 | 8868 | expand = -1; |
| 8917 | 8869 | t++; |
| 8918 | 8870 | } |
| 8919 | 8871 | } |
| 8920 | 8872 | |
| 8921 | | - |
| 8873 | + |
| 8922 | 8874 | while (!TOKEN_IS_SEP(t->type)) { |
| 8923 | 8875 | t++; |
| 8924 | 8876 | count++; |
| 8925 | 8877 | } |
| 8926 | 8878 | |
| | @@ -8930,11 +8882,11 @@ |
| 8930 | 8882 | static Jim_Obj *JimMakeScriptObj(Jim_Interp *interp, const ParseToken *t) |
| 8931 | 8883 | { |
| 8932 | 8884 | Jim_Obj *objPtr; |
| 8933 | 8885 | |
| 8934 | 8886 | if (t->type == JIM_TT_ESC && memchr(t->token, '\\', t->len) != NULL) { |
| 8935 | | - |
| 8887 | + |
| 8936 | 8888 | int len = t->len; |
| 8937 | 8889 | char *str = Jim_Alloc(len + 1); |
| 8938 | 8890 | len = JimEscape(str, t->token, len); |
| 8939 | 8891 | objPtr = Jim_NewStringObjNoAlloc(interp, str, len); |
| 8940 | 8892 | } |
| | @@ -8947,13 +8899,13 @@ |
| 8947 | 8899 | static void ScriptObjAddTokens(Jim_Interp *interp, struct ScriptObj *script, |
| 8948 | 8900 | ParseTokenList *tokenlist) |
| 8949 | 8901 | { |
| 8950 | 8902 | int i; |
| 8951 | 8903 | struct ScriptToken *token; |
| 8952 | | - |
| 8904 | + |
| 8953 | 8905 | int lineargs = 0; |
| 8954 | | - |
| 8906 | + |
| 8955 | 8907 | ScriptToken *linefirst; |
| 8956 | 8908 | int count; |
| 8957 | 8909 | int linenr; |
| 8958 | 8910 | |
| 8959 | 8911 | #ifdef DEBUG_SHOW_SCRIPT_TOKENS |
| | @@ -8962,11 +8914,11 @@ |
| 8962 | 8914 | printf("[%2d]@%d %s '%.*s'\n", i, tokenlist->list[i].line, jim_tt_name(tokenlist->list[i].type), |
| 8963 | 8915 | tokenlist->list[i].len, tokenlist->list[i].token); |
| 8964 | 8916 | } |
| 8965 | 8917 | #endif |
| 8966 | 8918 | |
| 8967 | | - |
| 8919 | + |
| 8968 | 8920 | count = tokenlist->count; |
| 8969 | 8921 | for (i = 0; i < tokenlist->count; i++) { |
| 8970 | 8922 | if (tokenlist->list[i].type == JIM_TT_EOL) { |
| 8971 | 8923 | count++; |
| 8972 | 8924 | } |
| | @@ -8973,59 +8925,59 @@ |
| 8973 | 8925 | } |
| 8974 | 8926 | linenr = script->firstline = tokenlist->list[0].line; |
| 8975 | 8927 | |
| 8976 | 8928 | token = script->token = Jim_Alloc(sizeof(ScriptToken) * count); |
| 8977 | 8929 | |
| 8978 | | - |
| 8930 | + |
| 8979 | 8931 | linefirst = token++; |
| 8980 | 8932 | |
| 8981 | 8933 | for (i = 0; i < tokenlist->count; ) { |
| 8982 | | - |
| 8934 | + |
| 8983 | 8935 | int wordtokens; |
| 8984 | 8936 | |
| 8985 | | - |
| 8937 | + |
| 8986 | 8938 | while (tokenlist->list[i].type == JIM_TT_SEP) { |
| 8987 | 8939 | i++; |
| 8988 | 8940 | } |
| 8989 | 8941 | |
| 8990 | 8942 | wordtokens = JimCountWordTokens(tokenlist->list + i); |
| 8991 | 8943 | |
| 8992 | 8944 | if (wordtokens == 0) { |
| 8993 | | - |
| 8945 | + |
| 8994 | 8946 | if (lineargs) { |
| 8995 | 8947 | linefirst->type = JIM_TT_LINE; |
| 8996 | 8948 | linefirst->objPtr = JimNewScriptLineObj(interp, lineargs, linenr); |
| 8997 | 8949 | Jim_IncrRefCount(linefirst->objPtr); |
| 8998 | 8950 | |
| 8999 | | - |
| 8951 | + |
| 9000 | 8952 | lineargs = 0; |
| 9001 | 8953 | linefirst = token++; |
| 9002 | 8954 | } |
| 9003 | 8955 | i++; |
| 9004 | 8956 | continue; |
| 9005 | 8957 | } |
| 9006 | 8958 | else if (wordtokens != 1) { |
| 9007 | | - |
| 8959 | + |
| 9008 | 8960 | token->type = JIM_TT_WORD; |
| 9009 | 8961 | token->objPtr = Jim_NewIntObj(interp, wordtokens); |
| 9010 | 8962 | Jim_IncrRefCount(token->objPtr); |
| 9011 | 8963 | token++; |
| 9012 | 8964 | if (wordtokens < 0) { |
| 9013 | | - |
| 8965 | + |
| 9014 | 8966 | i++; |
| 9015 | 8967 | wordtokens = -wordtokens - 1; |
| 9016 | 8968 | lineargs--; |
| 9017 | 8969 | } |
| 9018 | 8970 | } |
| 9019 | 8971 | |
| 9020 | 8972 | if (lineargs == 0) { |
| 9021 | | - |
| 8973 | + |
| 9022 | 8974 | linenr = tokenlist->list[i].line; |
| 9023 | 8975 | } |
| 9024 | 8976 | lineargs++; |
| 9025 | 8977 | |
| 9026 | | - |
| 8978 | + |
| 9027 | 8979 | while (wordtokens--) { |
| 9028 | 8980 | const ParseToken *t = &tokenlist->list[i++]; |
| 9029 | 8981 | |
| 9030 | 8982 | token->type = t->type; |
| 9031 | 8983 | token->objPtr = JimMakeScriptObj(interp, t); |
| | @@ -9097,11 +9049,11 @@ |
| 9097 | 9049 | token = script->token = Jim_Alloc(sizeof(ScriptToken) * tokenlist->count); |
| 9098 | 9050 | |
| 9099 | 9051 | for (i = 0; i < tokenlist->count; i++) { |
| 9100 | 9052 | const ParseToken *t = &tokenlist->list[i]; |
| 9101 | 9053 | |
| 9102 | | - |
| 9054 | + |
| 9103 | 9055 | token->type = t->type; |
| 9104 | 9056 | token->objPtr = JimMakeScriptObj(interp, t); |
| 9105 | 9057 | Jim_IncrRefCount(token->objPtr); |
| 9106 | 9058 | token++; |
| 9107 | 9059 | } |
| | @@ -9116,29 +9068,29 @@ |
| 9116 | 9068 | struct JimParserCtx parser; |
| 9117 | 9069 | struct ScriptObj *script; |
| 9118 | 9070 | ParseTokenList tokenlist; |
| 9119 | 9071 | int line = 1; |
| 9120 | 9072 | |
| 9121 | | - |
| 9073 | + |
| 9122 | 9074 | if (objPtr->typePtr == &sourceObjType) { |
| 9123 | 9075 | line = objPtr->internalRep.sourceValue.lineNumber; |
| 9124 | 9076 | } |
| 9125 | 9077 | |
| 9126 | | - |
| 9078 | + |
| 9127 | 9079 | ScriptTokenListInit(&tokenlist); |
| 9128 | 9080 | |
| 9129 | 9081 | JimParserInit(&parser, scriptText, scriptTextLen, line); |
| 9130 | 9082 | while (!parser.eof) { |
| 9131 | 9083 | JimParseScript(&parser); |
| 9132 | 9084 | ScriptAddToken(&tokenlist, parser.tstart, parser.tend - parser.tstart + 1, parser.tt, |
| 9133 | 9085 | parser.tline); |
| 9134 | 9086 | } |
| 9135 | 9087 | |
| 9136 | | - |
| 9088 | + |
| 9137 | 9089 | ScriptAddToken(&tokenlist, scriptText + scriptTextLen, 0, JIM_TT_EOF, 0); |
| 9138 | 9090 | |
| 9139 | | - |
| 9091 | + |
| 9140 | 9092 | script = Jim_Alloc(sizeof(*script)); |
| 9141 | 9093 | memset(script, 0, sizeof(*script)); |
| 9142 | 9094 | script->inUse = 1; |
| 9143 | 9095 | if (objPtr->typePtr == &sourceObjType) { |
| 9144 | 9096 | script->fileNameObj = objPtr->internalRep.sourceValue.fileNameObj; |
| | @@ -9150,14 +9102,14 @@ |
| 9150 | 9102 | script->missing = parser.missing.ch; |
| 9151 | 9103 | script->linenr = parser.missing.line; |
| 9152 | 9104 | |
| 9153 | 9105 | ScriptObjAddTokens(interp, script, &tokenlist); |
| 9154 | 9106 | |
| 9155 | | - |
| 9107 | + |
| 9156 | 9108 | ScriptTokenListFree(&tokenlist); |
| 9157 | 9109 | |
| 9158 | | - |
| 9110 | + |
| 9159 | 9111 | Jim_FreeIntRep(interp, objPtr); |
| 9160 | 9112 | Jim_SetIntRepPtr(objPtr, script); |
| 9161 | 9113 | objPtr->typePtr = &scriptObjType; |
| 9162 | 9114 | } |
| 9163 | 9115 | |
| | @@ -9164,11 +9116,11 @@ |
| 9164 | 9116 | static void JimAddErrorToStack(Jim_Interp *interp, ScriptObj *script); |
| 9165 | 9117 | |
| 9166 | 9118 | static ScriptObj *JimGetScript(Jim_Interp *interp, Jim_Obj *objPtr) |
| 9167 | 9119 | { |
| 9168 | 9120 | if (objPtr == interp->emptyObj) { |
| 9169 | | - |
| 9121 | + |
| 9170 | 9122 | objPtr = interp->nullScriptObj; |
| 9171 | 9123 | } |
| 9172 | 9124 | |
| 9173 | 9125 | if (objPtr->typePtr != &scriptObjType || ((struct ScriptObj *)Jim_GetIntRepPtr(objPtr))->substFlags) { |
| 9174 | 9126 | JimSetScriptFromAny(interp, objPtr); |
| | @@ -9203,17 +9155,17 @@ |
| 9203 | 9155 | Jim_FreeHashTable(cmdPtr->u.proc.staticVars); |
| 9204 | 9156 | Jim_Free(cmdPtr->u.proc.staticVars); |
| 9205 | 9157 | } |
| 9206 | 9158 | } |
| 9207 | 9159 | else { |
| 9208 | | - |
| 9160 | + |
| 9209 | 9161 | if (cmdPtr->u.native.delProc) { |
| 9210 | 9162 | cmdPtr->u.native.delProc(interp, cmdPtr->u.native.privData); |
| 9211 | 9163 | } |
| 9212 | 9164 | } |
| 9213 | 9165 | if (cmdPtr->prevCmd) { |
| 9214 | | - |
| 9166 | + |
| 9215 | 9167 | JimDecrCmdRefCount(interp, cmdPtr->prevCmd); |
| 9216 | 9168 | } |
| 9217 | 9169 | Jim_Free(cmdPtr); |
| 9218 | 9170 | } |
| 9219 | 9171 | } |
| | @@ -9224,46 +9176,46 @@ |
| 9224 | 9176 | Jim_DecrRefCount(interp, ((Jim_Var *)val)->objPtr); |
| 9225 | 9177 | Jim_Free(val); |
| 9226 | 9178 | } |
| 9227 | 9179 | |
| 9228 | 9180 | static const Jim_HashTableType JimVariablesHashTableType = { |
| 9229 | | - JimStringCopyHTHashFunction, |
| 9230 | | - JimStringCopyHTDup, |
| 9231 | | - NULL, |
| 9232 | | - JimStringCopyHTKeyCompare, |
| 9233 | | - JimStringCopyHTKeyDestructor, |
| 9234 | | - JimVariablesHTValDestructor |
| 9181 | + JimStringCopyHTHashFunction, |
| 9182 | + JimStringCopyHTDup, |
| 9183 | + NULL, |
| 9184 | + JimStringCopyHTKeyCompare, |
| 9185 | + JimStringCopyHTKeyDestructor, |
| 9186 | + JimVariablesHTValDestructor |
| 9235 | 9187 | }; |
| 9236 | 9188 | |
| 9237 | 9189 | static void JimCommandsHT_ValDestructor(void *interp, void *val) |
| 9238 | 9190 | { |
| 9239 | 9191 | JimDecrCmdRefCount(interp, val); |
| 9240 | 9192 | } |
| 9241 | 9193 | |
| 9242 | 9194 | static const Jim_HashTableType JimCommandsHashTableType = { |
| 9243 | | - JimStringCopyHTHashFunction, |
| 9244 | | - JimStringCopyHTDup, |
| 9245 | | - NULL, |
| 9246 | | - JimStringCopyHTKeyCompare, |
| 9247 | | - JimStringCopyHTKeyDestructor, |
| 9248 | | - JimCommandsHT_ValDestructor |
| 9195 | + JimStringCopyHTHashFunction, |
| 9196 | + JimStringCopyHTDup, |
| 9197 | + NULL, |
| 9198 | + JimStringCopyHTKeyCompare, |
| 9199 | + JimStringCopyHTKeyDestructor, |
| 9200 | + JimCommandsHT_ValDestructor |
| 9249 | 9201 | }; |
| 9250 | 9202 | |
| 9251 | 9203 | |
| 9252 | 9204 | |
| 9253 | 9205 | #ifdef jim_ext_namespace |
| 9254 | 9206 | static Jim_Obj *JimQualifyNameObj(Jim_Interp *interp, Jim_Obj *nsObj) |
| 9255 | 9207 | { |
| 9256 | 9208 | const char *name = Jim_String(nsObj); |
| 9257 | 9209 | if (name[0] == ':' && name[1] == ':') { |
| 9258 | | - |
| 9210 | + |
| 9259 | 9211 | while (*++name == ':') { |
| 9260 | 9212 | } |
| 9261 | 9213 | nsObj = Jim_NewStringObj(interp, name, -1); |
| 9262 | 9214 | } |
| 9263 | 9215 | else if (Jim_Length(interp->framePtr->nsObj)) { |
| 9264 | | - |
| 9216 | + |
| 9265 | 9217 | nsObj = Jim_DuplicateObj(interp, interp->framePtr->nsObj); |
| 9266 | 9218 | Jim_AppendStrings(interp, nsObj, "::", name, NULL); |
| 9267 | 9219 | } |
| 9268 | 9220 | return nsObj; |
| 9269 | 9221 | } |
| | @@ -9287,16 +9239,16 @@ |
| 9287 | 9239 | static const char *JimQualifyName(Jim_Interp *interp, const char *name, Jim_Obj **objPtrPtr) |
| 9288 | 9240 | { |
| 9289 | 9241 | Jim_Obj *objPtr = interp->emptyObj; |
| 9290 | 9242 | |
| 9291 | 9243 | if (name[0] == ':' && name[1] == ':') { |
| 9292 | | - |
| 9244 | + |
| 9293 | 9245 | while (*++name == ':') { |
| 9294 | 9246 | } |
| 9295 | 9247 | } |
| 9296 | 9248 | else if (Jim_Length(interp->framePtr->nsObj)) { |
| 9297 | | - |
| 9249 | + |
| 9298 | 9250 | objPtr = Jim_DuplicateObj(interp, interp->framePtr->nsObj); |
| 9299 | 9251 | Jim_AppendStrings(interp, objPtr, "::", name, NULL); |
| 9300 | 9252 | name = Jim_String(objPtr); |
| 9301 | 9253 | } |
| 9302 | 9254 | Jim_IncrRefCount(objPtr); |
| | @@ -9305,11 +9257,11 @@ |
| 9305 | 9257 | } |
| 9306 | 9258 | |
| 9307 | 9259 | #define JimFreeQualifiedName(INTERP, OBJ) Jim_DecrRefCount((INTERP), (OBJ)) |
| 9308 | 9260 | |
| 9309 | 9261 | #else |
| 9310 | | - |
| 9262 | + |
| 9311 | 9263 | #define JimQualifyName(INTERP, NAME, DUMMY) (((NAME)[0] == ':' && (NAME)[1] == ':') ? (NAME) + 2 : (NAME)) |
| 9312 | 9264 | #define JimFreeQualifiedName(INTERP, DUMMY) (void)(DUMMY) |
| 9313 | 9265 | |
| 9314 | 9266 | Jim_Obj *Jim_MakeGlobalNamespaceName(Jim_Interp *interp, Jim_Obj *nameObjPtr) |
| 9315 | 9267 | { |
| | @@ -9324,17 +9276,17 @@ |
| 9324 | 9276 | |
| 9325 | 9277 | Jim_InterpIncrProcEpoch(interp); |
| 9326 | 9278 | } |
| 9327 | 9279 | |
| 9328 | 9280 | if (he && interp->local) { |
| 9329 | | - |
| 9281 | + |
| 9330 | 9282 | cmd->prevCmd = Jim_GetHashEntryVal(he); |
| 9331 | 9283 | Jim_SetHashVal(&interp->commands, he, cmd); |
| 9332 | 9284 | } |
| 9333 | 9285 | else { |
| 9334 | 9286 | if (he) { |
| 9335 | | - |
| 9287 | + |
| 9336 | 9288 | Jim_DeleteHashEntry(&interp->commands, name); |
| 9337 | 9289 | } |
| 9338 | 9290 | |
| 9339 | 9291 | Jim_AddHashEntry(&interp->commands, name, cmd); |
| 9340 | 9292 | } |
| | @@ -9345,11 +9297,11 @@ |
| 9345 | 9297 | int Jim_CreateCommand(Jim_Interp *interp, const char *cmdNameStr, |
| 9346 | 9298 | Jim_CmdProc *cmdProc, void *privData, Jim_DelCmdProc *delProc) |
| 9347 | 9299 | { |
| 9348 | 9300 | Jim_Cmd *cmdPtr = Jim_Alloc(sizeof(*cmdPtr)); |
| 9349 | 9301 | |
| 9350 | | - |
| 9302 | + |
| 9351 | 9303 | memset(cmdPtr, 0, sizeof(*cmdPtr)); |
| 9352 | 9304 | cmdPtr->inUse = 1; |
| 9353 | 9305 | cmdPtr->u.native.delProc = delProc; |
| 9354 | 9306 | cmdPtr->u.native.cmdProc = cmdProc; |
| 9355 | 9307 | cmdPtr->u.native.privData = privData; |
| | @@ -9374,11 +9326,11 @@ |
| 9374 | 9326 | Jim_Obj *objPtr, *initObjPtr, *nameObjPtr; |
| 9375 | 9327 | Jim_Var *varPtr; |
| 9376 | 9328 | int subLen; |
| 9377 | 9329 | |
| 9378 | 9330 | objPtr = Jim_ListGetIndex(interp, staticsListObjPtr, i); |
| 9379 | | - |
| 9331 | + |
| 9380 | 9332 | subLen = Jim_ListLength(interp, objPtr); |
| 9381 | 9333 | if (subLen == 1 || subLen == 2) { |
| 9382 | 9334 | nameObjPtr = Jim_ListGetIndex(interp, objPtr, 0); |
| 9383 | 9335 | if (subLen == 1) { |
| 9384 | 9336 | initObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_NONE); |
| | @@ -9420,19 +9372,19 @@ |
| 9420 | 9372 | |
| 9421 | 9373 | static void JimUpdateProcNamespace(Jim_Interp *interp, Jim_Cmd *cmdPtr, const char *cmdname) |
| 9422 | 9374 | { |
| 9423 | 9375 | #ifdef jim_ext_namespace |
| 9424 | 9376 | if (cmdPtr->isproc) { |
| 9425 | | - |
| 9377 | + |
| 9426 | 9378 | const char *pt = strrchr(cmdname, ':'); |
| 9427 | 9379 | if (pt && pt != cmdname && pt[-1] == ':') { |
| 9428 | 9380 | Jim_DecrRefCount(interp, cmdPtr->u.proc.nsObj); |
| 9429 | 9381 | cmdPtr->u.proc.nsObj = Jim_NewStringObj(interp, cmdname, pt - cmdname - 1); |
| 9430 | 9382 | Jim_IncrRefCount(cmdPtr->u.proc.nsObj); |
| 9431 | 9383 | |
| 9432 | 9384 | if (Jim_FindHashEntry(&interp->commands, pt + 1)) { |
| 9433 | | - |
| 9385 | + |
| 9434 | 9386 | Jim_InterpIncrProcEpoch(interp); |
| 9435 | 9387 | } |
| 9436 | 9388 | } |
| 9437 | 9389 | } |
| 9438 | 9390 | #endif |
| | @@ -9445,11 +9397,11 @@ |
| 9445 | 9397 | int argListLen; |
| 9446 | 9398 | int i; |
| 9447 | 9399 | |
| 9448 | 9400 | argListLen = Jim_ListLength(interp, argListObjPtr); |
| 9449 | 9401 | |
| 9450 | | - |
| 9402 | + |
| 9451 | 9403 | cmdPtr = Jim_Alloc(sizeof(*cmdPtr) + sizeof(struct Jim_ProcArg) * argListLen); |
| 9452 | 9404 | memset(cmdPtr, 0, sizeof(*cmdPtr)); |
| 9453 | 9405 | cmdPtr->inUse = 1; |
| 9454 | 9406 | cmdPtr->isproc = 1; |
| 9455 | 9407 | cmdPtr->u.proc.argListObjPtr = argListObjPtr; |
| | @@ -9460,24 +9412,24 @@ |
| 9460 | 9412 | cmdPtr->u.proc.nsObj = nsObj ? nsObj : interp->emptyObj; |
| 9461 | 9413 | Jim_IncrRefCount(argListObjPtr); |
| 9462 | 9414 | Jim_IncrRefCount(bodyObjPtr); |
| 9463 | 9415 | Jim_IncrRefCount(cmdPtr->u.proc.nsObj); |
| 9464 | 9416 | |
| 9465 | | - |
| 9417 | + |
| 9466 | 9418 | if (staticsListObjPtr && JimCreateProcedureStatics(interp, cmdPtr, staticsListObjPtr) != JIM_OK) { |
| 9467 | 9419 | goto err; |
| 9468 | 9420 | } |
| 9469 | 9421 | |
| 9470 | | - |
| 9471 | | - |
| 9422 | + |
| 9423 | + |
| 9472 | 9424 | for (i = 0; i < argListLen; i++) { |
| 9473 | 9425 | Jim_Obj *argPtr; |
| 9474 | 9426 | Jim_Obj *nameObjPtr; |
| 9475 | 9427 | Jim_Obj *defaultObjPtr; |
| 9476 | 9428 | int len; |
| 9477 | 9429 | |
| 9478 | | - |
| 9430 | + |
| 9479 | 9431 | argPtr = Jim_ListGetIndex(interp, argListObjPtr, i); |
| 9480 | 9432 | len = Jim_ListLength(interp, argPtr); |
| 9481 | 9433 | if (len == 0) { |
| 9482 | 9434 | Jim_SetResultString(interp, "argument with no name", -1); |
| 9483 | 9435 | err: |
| | @@ -9488,16 +9440,16 @@ |
| 9488 | 9440 | Jim_SetResultFormatted(interp, "too many fields in argument specifier \"%#s\"", argPtr); |
| 9489 | 9441 | goto err; |
| 9490 | 9442 | } |
| 9491 | 9443 | |
| 9492 | 9444 | if (len == 2) { |
| 9493 | | - |
| 9445 | + |
| 9494 | 9446 | nameObjPtr = Jim_ListGetIndex(interp, argPtr, 0); |
| 9495 | 9447 | defaultObjPtr = Jim_ListGetIndex(interp, argPtr, 1); |
| 9496 | 9448 | } |
| 9497 | 9449 | else { |
| 9498 | | - |
| 9450 | + |
| 9499 | 9451 | nameObjPtr = argPtr; |
| 9500 | 9452 | defaultObjPtr = NULL; |
| 9501 | 9453 | } |
| 9502 | 9454 | |
| 9503 | 9455 | |
| | @@ -9558,29 +9510,29 @@ |
| 9558 | 9510 | } |
| 9559 | 9511 | |
| 9560 | 9512 | fqold = JimQualifyName(interp, oldName, &qualifiedOldNameObj); |
| 9561 | 9513 | fqnew = JimQualifyName(interp, newName, &qualifiedNewNameObj); |
| 9562 | 9514 | |
| 9563 | | - |
| 9515 | + |
| 9564 | 9516 | he = Jim_FindHashEntry(&interp->commands, fqold); |
| 9565 | 9517 | if (he == NULL) { |
| 9566 | 9518 | Jim_SetResultFormatted(interp, "can't rename \"%s\": command doesn't exist", oldName); |
| 9567 | 9519 | } |
| 9568 | 9520 | else if (Jim_FindHashEntry(&interp->commands, fqnew)) { |
| 9569 | 9521 | Jim_SetResultFormatted(interp, "can't rename to \"%s\": command already exists", newName); |
| 9570 | 9522 | } |
| 9571 | 9523 | else { |
| 9572 | | - |
| 9524 | + |
| 9573 | 9525 | cmdPtr = Jim_GetHashEntryVal(he); |
| 9574 | 9526 | JimIncrCmdRefCount(cmdPtr); |
| 9575 | 9527 | JimUpdateProcNamespace(interp, cmdPtr, fqnew); |
| 9576 | 9528 | Jim_AddHashEntry(&interp->commands, fqnew, cmdPtr); |
| 9577 | 9529 | |
| 9578 | | - |
| 9530 | + |
| 9579 | 9531 | Jim_DeleteHashEntry(&interp->commands, fqold); |
| 9580 | 9532 | |
| 9581 | | - |
| 9533 | + |
| 9582 | 9534 | Jim_InterpIncrProcEpoch(interp); |
| 9583 | 9535 | |
| 9584 | 9536 | ret = JIM_OK; |
| 9585 | 9537 | } |
| 9586 | 9538 | |
| | @@ -9619,23 +9571,23 @@ |
| 9619 | 9571 | objPtr->internalRep.cmdValue.procEpoch != interp->procEpoch |
| 9620 | 9572 | #ifdef jim_ext_namespace |
| 9621 | 9573 | || !Jim_StringEqObj(objPtr->internalRep.cmdValue.nsObj, interp->framePtr->nsObj) |
| 9622 | 9574 | #endif |
| 9623 | 9575 | ) { |
| 9576 | + |
| 9624 | 9577 | |
| 9625 | | - |
| 9626 | | - |
| 9578 | + |
| 9627 | 9579 | const char *name = Jim_String(objPtr); |
| 9628 | 9580 | Jim_HashEntry *he; |
| 9629 | 9581 | |
| 9630 | 9582 | if (name[0] == ':' && name[1] == ':') { |
| 9631 | 9583 | while (*++name == ':') { |
| 9632 | 9584 | } |
| 9633 | 9585 | } |
| 9634 | 9586 | #ifdef jim_ext_namespace |
| 9635 | 9587 | else if (Jim_Length(interp->framePtr->nsObj)) { |
| 9636 | | - |
| 9588 | + |
| 9637 | 9589 | Jim_Obj *nameObj = Jim_DuplicateObj(interp, interp->framePtr->nsObj); |
| 9638 | 9590 | Jim_AppendStrings(interp, nameObj, "::", name, NULL); |
| 9639 | 9591 | he = Jim_FindHashEntry(&interp->commands, Jim_String(nameObj)); |
| 9640 | 9592 | Jim_FreeNewObj(interp, nameObj); |
| 9641 | 9593 | if (he) { |
| | @@ -9642,11 +9594,11 @@ |
| 9642 | 9594 | goto found; |
| 9643 | 9595 | } |
| 9644 | 9596 | } |
| 9645 | 9597 | #endif |
| 9646 | 9598 | |
| 9647 | | - |
| 9599 | + |
| 9648 | 9600 | he = Jim_FindHashEntry(&interp->commands, name); |
| 9649 | 9601 | if (he == NULL) { |
| 9650 | 9602 | if (flags & JIM_ERRMSG) { |
| 9651 | 9603 | Jim_SetResultFormatted(interp, "invalid command name \"%#s\"", objPtr); |
| 9652 | 9604 | } |
| | @@ -9655,11 +9607,11 @@ |
| 9655 | 9607 | #ifdef jim_ext_namespace |
| 9656 | 9608 | found: |
| 9657 | 9609 | #endif |
| 9658 | 9610 | cmd = Jim_GetHashEntryVal(he); |
| 9659 | 9611 | |
| 9660 | | - |
| 9612 | + |
| 9661 | 9613 | Jim_FreeIntRep(interp, objPtr); |
| 9662 | 9614 | objPtr->typePtr = &commandObjType; |
| 9663 | 9615 | objPtr->internalRep.cmdValue.procEpoch = interp->procEpoch; |
| 9664 | 9616 | objPtr->internalRep.cmdValue.cmdPtr = cmd; |
| 9665 | 9617 | objPtr->internalRep.cmdValue.nsObj = interp->framePtr->nsObj; |
| | @@ -9674,11 +9626,11 @@ |
| 9674 | 9626 | return cmd; |
| 9675 | 9627 | } |
| 9676 | 9628 | |
| 9677 | 9629 | |
| 9678 | 9630 | |
| 9679 | | -#define JIM_DICT_SUGAR 100 |
| 9631 | +#define JIM_DICT_SUGAR 100 |
| 9680 | 9632 | |
| 9681 | 9633 | static int SetVariableFromAny(Jim_Interp *interp, struct Jim_Obj *objPtr); |
| 9682 | 9634 | |
| 9683 | 9635 | static const Jim_ObjType variableObjType = { |
| 9684 | 9636 | "variable", |
| | @@ -9688,11 +9640,11 @@ |
| 9688 | 9640 | JIM_TYPE_REFERENCES, |
| 9689 | 9641 | }; |
| 9690 | 9642 | |
| 9691 | 9643 | static int JimValidName(Jim_Interp *interp, const char *type, Jim_Obj *nameObjPtr) |
| 9692 | 9644 | { |
| 9693 | | - |
| 9645 | + |
| 9694 | 9646 | if (nameObjPtr->typePtr != &variableObjType) { |
| 9695 | 9647 | int len; |
| 9696 | 9648 | const char *str = Jim_GetString(nameObjPtr, &len); |
| 9697 | 9649 | if (memchr(str, '\0', len)) { |
| 9698 | 9650 | Jim_SetResultFormatted(interp, "%s name contains embedded null", type); |
| | @@ -9708,18 +9660,18 @@ |
| 9708 | 9660 | Jim_CallFrame *framePtr; |
| 9709 | 9661 | Jim_HashEntry *he; |
| 9710 | 9662 | int global; |
| 9711 | 9663 | int len; |
| 9712 | 9664 | |
| 9713 | | - |
| 9665 | + |
| 9714 | 9666 | if (objPtr->typePtr == &variableObjType) { |
| 9715 | 9667 | framePtr = objPtr->internalRep.varValue.global ? interp->topFramePtr : interp->framePtr; |
| 9716 | 9668 | if (objPtr->internalRep.varValue.callFrameId == framePtr->id) { |
| 9717 | | - |
| 9669 | + |
| 9718 | 9670 | return JIM_OK; |
| 9719 | 9671 | } |
| 9720 | | - |
| 9672 | + |
| 9721 | 9673 | } |
| 9722 | 9674 | else if (objPtr->typePtr == &dictSubstObjType) { |
| 9723 | 9675 | return JIM_DICT_SUGAR; |
| 9724 | 9676 | } |
| 9725 | 9677 | else if (JimValidName(interp, "variable", objPtr) != JIM_OK) { |
| | @@ -9727,11 +9679,11 @@ |
| 9727 | 9679 | } |
| 9728 | 9680 | |
| 9729 | 9681 | |
| 9730 | 9682 | varName = Jim_GetString(objPtr, &len); |
| 9731 | 9683 | |
| 9732 | | - |
| 9684 | + |
| 9733 | 9685 | if (len && varName[len - 1] == ')' && strchr(varName, '(') != NULL) { |
| 9734 | 9686 | return JIM_DICT_SUGAR; |
| 9735 | 9687 | } |
| 9736 | 9688 | |
| 9737 | 9689 | if (varName[0] == ':' && varName[1] == ':') { |
| | @@ -9743,23 +9695,23 @@ |
| 9743 | 9695 | else { |
| 9744 | 9696 | global = 0; |
| 9745 | 9697 | framePtr = interp->framePtr; |
| 9746 | 9698 | } |
| 9747 | 9699 | |
| 9748 | | - |
| 9700 | + |
| 9749 | 9701 | he = Jim_FindHashEntry(&framePtr->vars, varName); |
| 9750 | 9702 | if (he == NULL) { |
| 9751 | 9703 | if (!global && framePtr->staticVars) { |
| 9752 | | - |
| 9704 | + |
| 9753 | 9705 | he = Jim_FindHashEntry(framePtr->staticVars, varName); |
| 9754 | 9706 | } |
| 9755 | 9707 | if (he == NULL) { |
| 9756 | 9708 | return JIM_ERR; |
| 9757 | 9709 | } |
| 9758 | 9710 | } |
| 9759 | 9711 | |
| 9760 | | - |
| 9712 | + |
| 9761 | 9713 | Jim_FreeIntRep(interp, objPtr); |
| 9762 | 9714 | objPtr->typePtr = &variableObjType; |
| 9763 | 9715 | objPtr->internalRep.varValue.callFrameId = framePtr->id; |
| 9764 | 9716 | objPtr->internalRep.varValue.varPtr = Jim_GetHashEntryVal(he); |
| 9765 | 9717 | objPtr->internalRep.varValue.global = global; |
| | @@ -9774,11 +9726,11 @@ |
| 9774 | 9726 | { |
| 9775 | 9727 | const char *name; |
| 9776 | 9728 | Jim_CallFrame *framePtr; |
| 9777 | 9729 | int global; |
| 9778 | 9730 | |
| 9779 | | - |
| 9731 | + |
| 9780 | 9732 | Jim_Var *var = Jim_Alloc(sizeof(*var)); |
| 9781 | 9733 | |
| 9782 | 9734 | var->objPtr = valObjPtr; |
| 9783 | 9735 | Jim_IncrRefCount(valObjPtr); |
| 9784 | 9736 | var->linkFramePtr = NULL; |
| | @@ -9793,14 +9745,14 @@ |
| 9793 | 9745 | else { |
| 9794 | 9746 | framePtr = interp->framePtr; |
| 9795 | 9747 | global = 0; |
| 9796 | 9748 | } |
| 9797 | 9749 | |
| 9798 | | - |
| 9750 | + |
| 9799 | 9751 | Jim_AddHashEntry(&framePtr->vars, name, var); |
| 9800 | 9752 | |
| 9801 | | - |
| 9753 | + |
| 9802 | 9754 | Jim_FreeIntRep(interp, nameObjPtr); |
| 9803 | 9755 | nameObjPtr->typePtr = &variableObjType; |
| 9804 | 9756 | nameObjPtr->internalRep.varValue.callFrameId = framePtr->id; |
| 9805 | 9757 | nameObjPtr->internalRep.varValue.varPtr = var; |
| 9806 | 9758 | nameObjPtr->internalRep.varValue.global = global; |
| | @@ -9830,11 +9782,11 @@ |
| 9830 | 9782 | if (var->linkFramePtr == NULL) { |
| 9831 | 9783 | Jim_IncrRefCount(valObjPtr); |
| 9832 | 9784 | Jim_DecrRefCount(interp, var->objPtr); |
| 9833 | 9785 | var->objPtr = valObjPtr; |
| 9834 | 9786 | } |
| 9835 | | - else { |
| 9787 | + else { |
| 9836 | 9788 | Jim_CallFrame *savedCallFrame; |
| 9837 | 9789 | |
| 9838 | 9790 | savedCallFrame = interp->framePtr; |
| 9839 | 9791 | interp->framePtr = var->linkFramePtr; |
| 9840 | 9792 | err = Jim_SetVariable(interp, var->objPtr, valObjPtr); |
| | @@ -9891,14 +9843,14 @@ |
| 9891 | 9843 | const char *varName; |
| 9892 | 9844 | const char *targetName; |
| 9893 | 9845 | Jim_CallFrame *framePtr; |
| 9894 | 9846 | Jim_Var *varPtr; |
| 9895 | 9847 | |
| 9896 | | - |
| 9848 | + |
| 9897 | 9849 | switch (SetVariableFromAny(interp, nameObjPtr)) { |
| 9898 | 9850 | case JIM_DICT_SUGAR: |
| 9899 | | - |
| 9851 | + |
| 9900 | 9852 | Jim_SetResultFormatted(interp, "bad variable name \"%#s\": upvar won't create a scalar variable that looks like an array element", nameObjPtr); |
| 9901 | 9853 | return JIM_ERR; |
| 9902 | 9854 | |
| 9903 | 9855 | case JIM_OK: |
| 9904 | 9856 | varPtr = nameObjPtr->internalRep.varValue.varPtr; |
| | @@ -9906,23 +9858,23 @@ |
| 9906 | 9858 | if (varPtr->linkFramePtr == NULL) { |
| 9907 | 9859 | Jim_SetResultFormatted(interp, "variable \"%#s\" already exists", nameObjPtr); |
| 9908 | 9860 | return JIM_ERR; |
| 9909 | 9861 | } |
| 9910 | 9862 | |
| 9911 | | - |
| 9863 | + |
| 9912 | 9864 | varPtr->linkFramePtr = NULL; |
| 9913 | 9865 | break; |
| 9914 | 9866 | } |
| 9915 | 9867 | |
| 9916 | | - |
| 9917 | | - |
| 9868 | + |
| 9869 | + |
| 9918 | 9870 | varName = Jim_String(nameObjPtr); |
| 9919 | 9871 | |
| 9920 | 9872 | if (varName[0] == ':' && varName[1] == ':') { |
| 9921 | 9873 | while (*++varName == ':') { |
| 9922 | 9874 | } |
| 9923 | | - |
| 9875 | + |
| 9924 | 9876 | framePtr = interp->topFramePtr; |
| 9925 | 9877 | } |
| 9926 | 9878 | else { |
| 9927 | 9879 | framePtr = interp->framePtr; |
| 9928 | 9880 | } |
| | @@ -9942,15 +9894,15 @@ |
| 9942 | 9894 | nameObjPtr); |
| 9943 | 9895 | Jim_DecrRefCount(interp, targetNameObjPtr); |
| 9944 | 9896 | return JIM_ERR; |
| 9945 | 9897 | } |
| 9946 | 9898 | |
| 9947 | | - |
| 9899 | + |
| 9948 | 9900 | if (framePtr == targetCallFrame) { |
| 9949 | 9901 | Jim_Obj *objPtr = targetNameObjPtr; |
| 9950 | 9902 | |
| 9951 | | - |
| 9903 | + |
| 9952 | 9904 | while (1) { |
| 9953 | 9905 | if (strcmp(Jim_String(objPtr), varName) == 0) { |
| 9954 | 9906 | Jim_SetResultString(interp, "can't upvar from variable to itself", -1); |
| 9955 | 9907 | Jim_DecrRefCount(interp, targetNameObjPtr); |
| 9956 | 9908 | return JIM_ERR; |
| | @@ -9962,13 +9914,13 @@ |
| 9962 | 9914 | break; |
| 9963 | 9915 | objPtr = varPtr->objPtr; |
| 9964 | 9916 | } |
| 9965 | 9917 | } |
| 9966 | 9918 | |
| 9967 | | - |
| 9919 | + |
| 9968 | 9920 | Jim_SetVariable(interp, nameObjPtr, targetNameObjPtr); |
| 9969 | | - |
| 9921 | + |
| 9970 | 9922 | nameObjPtr->internalRep.varValue.varPtr->linkFramePtr = targetCallFrame; |
| 9971 | 9923 | Jim_DecrRefCount(interp, targetNameObjPtr); |
| 9972 | 9924 | return JIM_OK; |
| 9973 | 9925 | } |
| 9974 | 9926 | |
| | @@ -9982,26 +9934,26 @@ |
| 9982 | 9934 | return varPtr->objPtr; |
| 9983 | 9935 | } |
| 9984 | 9936 | else { |
| 9985 | 9937 | Jim_Obj *objPtr; |
| 9986 | 9938 | |
| 9987 | | - |
| 9939 | + |
| 9988 | 9940 | Jim_CallFrame *savedCallFrame = interp->framePtr; |
| 9989 | 9941 | |
| 9990 | 9942 | interp->framePtr = varPtr->linkFramePtr; |
| 9991 | 9943 | objPtr = Jim_GetVariable(interp, varPtr->objPtr, flags); |
| 9992 | 9944 | interp->framePtr = savedCallFrame; |
| 9993 | 9945 | if (objPtr) { |
| 9994 | 9946 | return objPtr; |
| 9995 | 9947 | } |
| 9996 | | - |
| 9948 | + |
| 9997 | 9949 | } |
| 9998 | 9950 | } |
| 9999 | 9951 | break; |
| 10000 | 9952 | |
| 10001 | 9953 | case JIM_DICT_SUGAR: |
| 10002 | | - |
| 9954 | + |
| 10003 | 9955 | return JimDictSugarGet(interp, nameObjPtr, flags); |
| 10004 | 9956 | } |
| 10005 | 9957 | if (flags & JIM_ERRMSG) { |
| 10006 | 9958 | Jim_SetResultFormatted(interp, "can't read \"%#s\": no such variable", nameObjPtr); |
| 10007 | 9959 | } |
| | @@ -10051,17 +10003,17 @@ |
| 10051 | 10003 | int retval; |
| 10052 | 10004 | Jim_CallFrame *framePtr; |
| 10053 | 10005 | |
| 10054 | 10006 | retval = SetVariableFromAny(interp, nameObjPtr); |
| 10055 | 10007 | if (retval == JIM_DICT_SUGAR) { |
| 10056 | | - |
| 10008 | + |
| 10057 | 10009 | return JimDictSugarSet(interp, nameObjPtr, NULL); |
| 10058 | 10010 | } |
| 10059 | 10011 | else if (retval == JIM_OK) { |
| 10060 | 10012 | varPtr = nameObjPtr->internalRep.varValue.varPtr; |
| 10061 | 10013 | |
| 10062 | | - |
| 10014 | + |
| 10063 | 10015 | if (varPtr->linkFramePtr) { |
| 10064 | 10016 | framePtr = interp->framePtr; |
| 10065 | 10017 | interp->framePtr = varPtr->linkFramePtr; |
| 10066 | 10018 | retval = Jim_UnsetVariable(interp, varPtr->objPtr, JIM_NONE); |
| 10067 | 10019 | interp->framePtr = framePtr; |
| | @@ -10076,11 +10028,11 @@ |
| 10076 | 10028 | framePtr = interp->framePtr; |
| 10077 | 10029 | } |
| 10078 | 10030 | |
| 10079 | 10031 | retval = Jim_DeleteHashEntry(&framePtr->vars, name); |
| 10080 | 10032 | if (retval == JIM_OK) { |
| 10081 | | - |
| 10033 | + |
| 10082 | 10034 | framePtr->id = interp->callFrameEpoch++; |
| 10083 | 10035 | } |
| 10084 | 10036 | } |
| 10085 | 10037 | } |
| 10086 | 10038 | if (retval != JIM_OK && (flags & JIM_ERRMSG)) { |
| | @@ -10109,11 +10061,11 @@ |
| 10109 | 10061 | keyLen = (str + len) - p; |
| 10110 | 10062 | if (str[len - 1] == ')') { |
| 10111 | 10063 | keyLen--; |
| 10112 | 10064 | } |
| 10113 | 10065 | |
| 10114 | | - |
| 10066 | + |
| 10115 | 10067 | keyObjPtr = Jim_NewStringObj(interp, p, keyLen); |
| 10116 | 10068 | |
| 10117 | 10069 | Jim_IncrRefCount(varObjPtr); |
| 10118 | 10070 | Jim_IncrRefCount(keyObjPtr); |
| 10119 | 10071 | *varPtrPtr = varObjPtr; |
| | @@ -10128,23 +10080,23 @@ |
| 10128 | 10080 | |
| 10129 | 10081 | err = Jim_SetDictKeysVector(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr, |
| 10130 | 10082 | &objPtr->internalRep.dictSubstValue.indexObjPtr, 1, valObjPtr, JIM_MUSTEXIST); |
| 10131 | 10083 | |
| 10132 | 10084 | if (err == JIM_OK) { |
| 10133 | | - |
| 10085 | + |
| 10134 | 10086 | Jim_SetEmptyResult(interp); |
| 10135 | 10087 | } |
| 10136 | 10088 | else { |
| 10137 | 10089 | if (!valObjPtr) { |
| 10138 | | - |
| 10090 | + |
| 10139 | 10091 | if (Jim_GetVariable(interp, objPtr->internalRep.dictSubstValue.varNameObjPtr, JIM_NONE)) { |
| 10140 | 10092 | Jim_SetResultFormatted(interp, "can't unset \"%#s\": no such element in array", |
| 10141 | 10093 | objPtr); |
| 10142 | 10094 | return err; |
| 10143 | 10095 | } |
| 10144 | 10096 | } |
| 10145 | | - |
| 10097 | + |
| 10146 | 10098 | Jim_SetResultFormatted(interp, "can't %s \"%#s\": variable isn't array", |
| 10147 | 10099 | (valObjPtr ? "set" : "unset"), objPtr); |
| 10148 | 10100 | } |
| 10149 | 10101 | return err; |
| 10150 | 10102 | } |
| | @@ -10166,11 +10118,11 @@ |
| 10166 | 10118 | Jim_SetResultFormatted(interp, |
| 10167 | 10119 | "can't read \"%#s(%#s)\": %s array", varObjPtr, keyObjPtr, |
| 10168 | 10120 | ret < 0 ? "variable isn't" : "no such element in"); |
| 10169 | 10121 | } |
| 10170 | 10122 | else if ((flags & JIM_UNSHARED) && Jim_IsShared(dictObjPtr)) { |
| 10171 | | - |
| 10123 | + |
| 10172 | 10124 | Jim_SetVariable(interp, varObjPtr, Jim_DuplicateObj(interp, dictObjPtr)); |
| 10173 | 10125 | } |
| 10174 | 10126 | |
| 10175 | 10127 | return resObjPtr; |
| 10176 | 10128 | } |
| | @@ -10208,11 +10160,11 @@ |
| 10208 | 10160 | { |
| 10209 | 10161 | if (objPtr->typePtr != &dictSubstObjType) { |
| 10210 | 10162 | Jim_Obj *varObjPtr, *keyObjPtr; |
| 10211 | 10163 | |
| 10212 | 10164 | if (objPtr->typePtr == &interpolatedObjType) { |
| 10213 | | - |
| 10165 | + |
| 10214 | 10166 | |
| 10215 | 10167 | varObjPtr = objPtr->internalRep.dictSubstValue.varNameObjPtr; |
| 10216 | 10168 | keyObjPtr = objPtr->internalRep.dictSubstValue.indexObjPtr; |
| 10217 | 10169 | |
| 10218 | 10170 | Jim_IncrRefCount(varObjPtr); |
| | @@ -10253,11 +10205,11 @@ |
| 10253 | 10205 | static Jim_Obj *JimExpandExprSugar(Jim_Interp *interp, Jim_Obj *objPtr) |
| 10254 | 10206 | { |
| 10255 | 10207 | Jim_Obj *resultObjPtr; |
| 10256 | 10208 | |
| 10257 | 10209 | if (Jim_EvalExpression(interp, objPtr, &resultObjPtr) == JIM_OK) { |
| 10258 | | - |
| 10210 | + |
| 10259 | 10211 | resultObjPtr->refCount--; |
| 10260 | 10212 | return resultObjPtr; |
| 10261 | 10213 | } |
| 10262 | 10214 | return NULL; |
| 10263 | 10215 | } |
| | @@ -10297,11 +10249,11 @@ |
| 10297 | 10249 | return cf; |
| 10298 | 10250 | } |
| 10299 | 10251 | |
| 10300 | 10252 | static int JimDeleteLocalProcs(Jim_Interp *interp, Jim_Stack *localCommands) |
| 10301 | 10253 | { |
| 10302 | | - |
| 10254 | + |
| 10303 | 10255 | if (localCommands) { |
| 10304 | 10256 | Jim_Obj *cmdNameObj; |
| 10305 | 10257 | |
| 10306 | 10258 | while ((cmdNameObj = Jim_StackPop(localCommands)) != NULL) { |
| 10307 | 10259 | Jim_HashEntry *he; |
| | @@ -10316,20 +10268,20 @@ |
| 10316 | 10268 | Jim_Cmd *cmd = Jim_GetHashEntryVal(he); |
| 10317 | 10269 | if (cmd->prevCmd) { |
| 10318 | 10270 | Jim_Cmd *prevCmd = cmd->prevCmd; |
| 10319 | 10271 | cmd->prevCmd = NULL; |
| 10320 | 10272 | |
| 10321 | | - |
| 10273 | + |
| 10322 | 10274 | JimDecrCmdRefCount(interp, cmd); |
| 10323 | 10275 | |
| 10324 | | - |
| 10276 | + |
| 10325 | 10277 | Jim_SetHashVal(ht, he, prevCmd); |
| 10326 | 10278 | } |
| 10327 | 10279 | else { |
| 10328 | 10280 | Jim_DeleteHashEntry(ht, fqname); |
| 10281 | + Jim_InterpIncrProcEpoch(interp); |
| 10329 | 10282 | } |
| 10330 | | - Jim_InterpIncrProcEpoch(interp); |
| 10331 | 10283 | } |
| 10332 | 10284 | Jim_DecrRefCount(interp, cmdNameObj); |
| 10333 | 10285 | JimFreeQualifiedName(interp, fqObjName); |
| 10334 | 10286 | } |
| 10335 | 10287 | Jim_FreeStack(localCommands); |
| | @@ -10337,12 +10289,12 @@ |
| 10337 | 10289 | } |
| 10338 | 10290 | return JIM_OK; |
| 10339 | 10291 | } |
| 10340 | 10292 | |
| 10341 | 10293 | |
| 10342 | | -#define JIM_FCF_FULL 0 |
| 10343 | | -#define JIM_FCF_REUSE 1 |
| 10294 | +#define JIM_FCF_FULL 0 |
| 10295 | +#define JIM_FCF_REUSE 1 |
| 10344 | 10296 | static void JimFreeCallFrame(Jim_Interp *interp, Jim_CallFrame *cf, int action) |
| 10345 | 10297 | { |
| 10346 | 10298 | JimDeleteLocalProcs(interp, cf->localCommands); |
| 10347 | 10299 | |
| 10348 | 10300 | if (cf->procArgsObjPtr) |
| | @@ -10375,10 +10327,263 @@ |
| 10375 | 10327 | cf->next = interp->freeFramesList; |
| 10376 | 10328 | interp->freeFramesList = cf; |
| 10377 | 10329 | } |
| 10378 | 10330 | |
| 10379 | 10331 | |
| 10332 | +#ifdef JIM_REFERENCES |
| 10333 | + |
| 10334 | +static void JimReferencesHTValDestructor(void *interp, void *val) |
| 10335 | +{ |
| 10336 | + Jim_Reference *refPtr = (void *)val; |
| 10337 | + |
| 10338 | + Jim_DecrRefCount(interp, refPtr->objPtr); |
| 10339 | + if (refPtr->finalizerCmdNamePtr != NULL) { |
| 10340 | + Jim_DecrRefCount(interp, refPtr->finalizerCmdNamePtr); |
| 10341 | + } |
| 10342 | + Jim_Free(val); |
| 10343 | +} |
| 10344 | + |
| 10345 | +static unsigned int JimReferencesHTHashFunction(const void *key) |
| 10346 | +{ |
| 10347 | + |
| 10348 | + const unsigned long *widePtr = key; |
| 10349 | + unsigned int intValue = (unsigned int)*widePtr; |
| 10350 | + |
| 10351 | + return Jim_IntHashFunction(intValue); |
| 10352 | +} |
| 10353 | + |
| 10354 | +static void *JimReferencesHTKeyDup(void *privdata, const void *key) |
| 10355 | +{ |
| 10356 | + void *copy = Jim_Alloc(sizeof(unsigned long)); |
| 10357 | + |
| 10358 | + JIM_NOTUSED(privdata); |
| 10359 | + |
| 10360 | + memcpy(copy, key, sizeof(unsigned long)); |
| 10361 | + return copy; |
| 10362 | +} |
| 10363 | + |
| 10364 | +static int JimReferencesHTKeyCompare(void *privdata, const void *key1, const void *key2) |
| 10365 | +{ |
| 10366 | + JIM_NOTUSED(privdata); |
| 10367 | + |
| 10368 | + return memcmp(key1, key2, sizeof(unsigned long)) == 0; |
| 10369 | +} |
| 10370 | + |
| 10371 | +static void JimReferencesHTKeyDestructor(void *privdata, void *key) |
| 10372 | +{ |
| 10373 | + JIM_NOTUSED(privdata); |
| 10374 | + |
| 10375 | + Jim_Free(key); |
| 10376 | +} |
| 10377 | + |
| 10378 | +static const Jim_HashTableType JimReferencesHashTableType = { |
| 10379 | + JimReferencesHTHashFunction, |
| 10380 | + JimReferencesHTKeyDup, |
| 10381 | + NULL, |
| 10382 | + JimReferencesHTKeyCompare, |
| 10383 | + JimReferencesHTKeyDestructor, |
| 10384 | + JimReferencesHTValDestructor |
| 10385 | +}; |
| 10386 | + |
| 10387 | + |
| 10388 | + |
| 10389 | +#define JIM_REFERENCE_SPACE (35+JIM_REFERENCE_TAGLEN) |
| 10390 | + |
| 10391 | +static int JimFormatReference(char *buf, Jim_Reference *refPtr, unsigned long id) |
| 10392 | +{ |
| 10393 | + const char *fmt = "<reference.<%s>.%020lu>"; |
| 10394 | + |
| 10395 | + sprintf(buf, fmt, refPtr->tag, id); |
| 10396 | + return JIM_REFERENCE_SPACE; |
| 10397 | +} |
| 10398 | + |
| 10399 | +static void UpdateStringOfReference(struct Jim_Obj *objPtr); |
| 10400 | + |
| 10401 | +static const Jim_ObjType referenceObjType = { |
| 10402 | + "reference", |
| 10403 | + NULL, |
| 10404 | + NULL, |
| 10405 | + UpdateStringOfReference, |
| 10406 | + JIM_TYPE_REFERENCES, |
| 10407 | +}; |
| 10408 | + |
| 10409 | +static void UpdateStringOfReference(struct Jim_Obj *objPtr) |
| 10410 | +{ |
| 10411 | + char buf[JIM_REFERENCE_SPACE + 1]; |
| 10412 | + |
| 10413 | + JimFormatReference(buf, objPtr->internalRep.refValue.refPtr, objPtr->internalRep.refValue.id); |
| 10414 | + JimSetStringBytes(objPtr, buf); |
| 10415 | +} |
| 10416 | + |
| 10417 | +static int isrefchar(int c) |
| 10418 | +{ |
| 10419 | + return (c == '_' || isalnum(c)); |
| 10420 | +} |
| 10421 | + |
| 10422 | +static int SetReferenceFromAny(Jim_Interp *interp, Jim_Obj *objPtr) |
| 10423 | +{ |
| 10424 | + unsigned long value; |
| 10425 | + int i, len; |
| 10426 | + const char *str, *start, *end; |
| 10427 | + char refId[21]; |
| 10428 | + Jim_Reference *refPtr; |
| 10429 | + Jim_HashEntry *he; |
| 10430 | + char *endptr; |
| 10431 | + |
| 10432 | + |
| 10433 | + str = Jim_GetString(objPtr, &len); |
| 10434 | + |
| 10435 | + if (len < JIM_REFERENCE_SPACE) |
| 10436 | + goto badformat; |
| 10437 | + |
| 10438 | + start = str; |
| 10439 | + end = str + len - 1; |
| 10440 | + while (*start == ' ') |
| 10441 | + start++; |
| 10442 | + while (*end == ' ' && end > start) |
| 10443 | + end--; |
| 10444 | + if (end - start + 1 != JIM_REFERENCE_SPACE) |
| 10445 | + goto badformat; |
| 10446 | + |
| 10447 | + if (memcmp(start, "<reference.<", 12) != 0) |
| 10448 | + goto badformat; |
| 10449 | + if (start[12 + JIM_REFERENCE_TAGLEN] != '>' || end[0] != '>') |
| 10450 | + goto badformat; |
| 10451 | + |
| 10452 | + for (i = 0; i < JIM_REFERENCE_TAGLEN; i++) { |
| 10453 | + if (!isrefchar(start[12 + i])) |
| 10454 | + goto badformat; |
| 10455 | + } |
| 10456 | + |
| 10457 | + memcpy(refId, start + 14 + JIM_REFERENCE_TAGLEN, 20); |
| 10458 | + refId[20] = '\0'; |
| 10459 | + |
| 10460 | + value = strtoul(refId, &endptr, 10); |
| 10461 | + if (JimCheckConversion(refId, endptr) != JIM_OK) |
| 10462 | + goto badformat; |
| 10463 | + |
| 10464 | + he = Jim_FindHashEntry(&interp->references, &value); |
| 10465 | + if (he == NULL) { |
| 10466 | + Jim_SetResultFormatted(interp, "invalid reference id \"%#s\"", objPtr); |
| 10467 | + return JIM_ERR; |
| 10468 | + } |
| 10469 | + refPtr = Jim_GetHashEntryVal(he); |
| 10470 | + |
| 10471 | + Jim_FreeIntRep(interp, objPtr); |
| 10472 | + objPtr->typePtr = &referenceObjType; |
| 10473 | + objPtr->internalRep.refValue.id = value; |
| 10474 | + objPtr->internalRep.refValue.refPtr = refPtr; |
| 10475 | + return JIM_OK; |
| 10476 | + |
| 10477 | + badformat: |
| 10478 | + Jim_SetResultFormatted(interp, "expected reference but got \"%#s\"", objPtr); |
| 10479 | + return JIM_ERR; |
| 10480 | +} |
| 10481 | + |
| 10482 | +Jim_Obj *Jim_NewReference(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *tagPtr, Jim_Obj *cmdNamePtr) |
| 10483 | +{ |
| 10484 | + struct Jim_Reference *refPtr; |
| 10485 | + unsigned long id; |
| 10486 | + Jim_Obj *refObjPtr; |
| 10487 | + const char *tag; |
| 10488 | + int tagLen, i; |
| 10489 | + |
| 10490 | + |
| 10491 | + Jim_CollectIfNeeded(interp); |
| 10492 | + |
| 10493 | + refPtr = Jim_Alloc(sizeof(*refPtr)); |
| 10494 | + refPtr->objPtr = objPtr; |
| 10495 | + Jim_IncrRefCount(objPtr); |
| 10496 | + refPtr->finalizerCmdNamePtr = cmdNamePtr; |
| 10497 | + if (cmdNamePtr) |
| 10498 | + Jim_IncrRefCount(cmdNamePtr); |
| 10499 | + id = interp->referenceNextId++; |
| 10500 | + Jim_AddHashEntry(&interp->references, &id, refPtr); |
| 10501 | + refObjPtr = Jim_NewObj(interp); |
| 10502 | + refObjPtr->typePtr = &referenceObjType; |
| 10503 | + refObjPtr->bytes = NULL; |
| 10504 | + refObjPtr->internalRep.refValue.id = id; |
| 10505 | + refObjPtr->internalRep.refValue.refPtr = refPtr; |
| 10506 | + interp->referenceNextId++; |
| 10507 | + tag = Jim_GetString(tagPtr, &tagLen); |
| 10508 | + if (tagLen > JIM_REFERENCE_TAGLEN) |
| 10509 | + tagLen = JIM_REFERENCE_TAGLEN; |
| 10510 | + for (i = 0; i < JIM_REFERENCE_TAGLEN; i++) { |
| 10511 | + if (i < tagLen && isrefchar(tag[i])) |
| 10512 | + refPtr->tag[i] = tag[i]; |
| 10513 | + else |
| 10514 | + refPtr->tag[i] = '_'; |
| 10515 | + } |
| 10516 | + refPtr->tag[JIM_REFERENCE_TAGLEN] = '\0'; |
| 10517 | + return refObjPtr; |
| 10518 | +} |
| 10519 | + |
| 10520 | +Jim_Reference *Jim_GetReference(Jim_Interp *interp, Jim_Obj *objPtr) |
| 10521 | +{ |
| 10522 | + if (objPtr->typePtr != &referenceObjType && SetReferenceFromAny(interp, objPtr) == JIM_ERR) |
| 10523 | + return NULL; |
| 10524 | + return objPtr->internalRep.refValue.refPtr; |
| 10525 | +} |
| 10526 | + |
| 10527 | +int Jim_SetFinalizer(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj *cmdNamePtr) |
| 10528 | +{ |
| 10529 | + Jim_Reference *refPtr; |
| 10530 | + |
| 10531 | + if ((refPtr = Jim_GetReference(interp, objPtr)) == NULL) |
| 10532 | + return JIM_ERR; |
| 10533 | + Jim_IncrRefCount(cmdNamePtr); |
| 10534 | + if (refPtr->finalizerCmdNamePtr) |
| 10535 | + Jim_DecrRefCount(interp, refPtr->finalizerCmdNamePtr); |
| 10536 | + refPtr->finalizerCmdNamePtr = cmdNamePtr; |
| 10537 | + return JIM_OK; |
| 10538 | +} |
| 10539 | + |
| 10540 | +int Jim_GetFinalizer(Jim_Interp *interp, Jim_Obj *objPtr, Jim_Obj **cmdNamePtrPtr) |
| 10541 | +{ |
| 10542 | + Jim_Reference *refPtr; |
| 10543 | + |
| 10544 | + if ((refPtr = Jim_GetReference(interp, objPtr)) == NULL) |
| 10545 | + return JIM_ERR; |
| 10546 | + *cmdNamePtrPtr = refPtr->finalizerCmdNamePtr; |
| 10547 | + return JIM_OK; |
| 10548 | +} |
| 10549 | + |
| 10550 | + |
| 10551 | + |
| 10552 | +static const Jim_HashTableType JimRefMarkHashTableType = { |
| 10553 | + JimReferencesHTHashFunction, |
| 10554 | + JimReferencesHTKeyDup, |
| 10555 | + NULL, |
| 10556 | + JimReferencesHTKeyCompare, |
| 10557 | + JimReferencesHTKeyDestructor, |
| 10558 | + NULL |
| 10559 | +}; |
| 10560 | + |
| 10561 | + |
| 10562 | +int Jim_Collect(Jim_Interp *interp) |
| 10563 | +{ |
| 10564 | + int collected = 0; |
| 10565 | + return collected; |
| 10566 | +} |
| 10567 | + |
| 10568 | +#define JIM_COLLECT_ID_PERIOD 5000 |
| 10569 | +#define JIM_COLLECT_TIME_PERIOD 300 |
| 10570 | + |
| 10571 | +void Jim_CollectIfNeeded(Jim_Interp *interp) |
| 10572 | +{ |
| 10573 | + unsigned long elapsedId; |
| 10574 | + int elapsedTime; |
| 10575 | + |
| 10576 | + elapsedId = interp->referenceNextId - interp->lastCollectId; |
| 10577 | + elapsedTime = time(NULL) - interp->lastCollectTime; |
| 10578 | + |
| 10579 | + |
| 10580 | + if (elapsedId > JIM_COLLECT_ID_PERIOD || elapsedTime > JIM_COLLECT_TIME_PERIOD) { |
| 10581 | + Jim_Collect(interp); |
| 10582 | + } |
| 10583 | +} |
| 10584 | +#endif |
| 10380 | 10585 | |
| 10381 | 10586 | int Jim_IsBigEndian(void) |
| 10382 | 10587 | { |
| 10383 | 10588 | union { |
| 10384 | 10589 | unsigned short s; |
| | @@ -10425,11 +10630,11 @@ |
| 10425 | 10630 | Jim_IncrRefCount(i->nullScriptObj); |
| 10426 | 10631 | Jim_IncrRefCount(i->errorProc); |
| 10427 | 10632 | Jim_IncrRefCount(i->trueObj); |
| 10428 | 10633 | Jim_IncrRefCount(i->falseObj); |
| 10429 | 10634 | |
| 10430 | | - |
| 10635 | + |
| 10431 | 10636 | Jim_SetVariableStrWithStr(i, JIM_LIBPATH, TCL_LIBRARY); |
| 10432 | 10637 | Jim_SetVariableStrWithStr(i, JIM_INTERACTIVE, "0"); |
| 10433 | 10638 | |
| 10434 | 10639 | Jim_SetVariableStrWithStr(i, "tcl_platform(engine)", "Jim"); |
| 10435 | 10640 | Jim_SetVariableStrWithStr(i, "tcl_platform(os)", TCL_PLATFORM_OS); |
| | @@ -10447,11 +10652,11 @@ |
| 10447 | 10652 | { |
| 10448 | 10653 | Jim_CallFrame *cf, *cfx; |
| 10449 | 10654 | |
| 10450 | 10655 | Jim_Obj *objPtr, *nextObjPtr; |
| 10451 | 10656 | |
| 10452 | | - |
| 10657 | + |
| 10453 | 10658 | for (cf = i->framePtr; cf; cf = cfx) { |
| 10454 | 10659 | cfx = cf->parent; |
| 10455 | 10660 | JimFreeCallFrame(i, cf, JIM_FCF_FULL); |
| 10456 | 10661 | } |
| 10457 | 10662 | |
| | @@ -10500,27 +10705,27 @@ |
| 10500 | 10705 | printf("-------------------------------------\n\n"); |
| 10501 | 10706 | JimPanic((1, "Live list non empty freeing the interpreter! Leak?")); |
| 10502 | 10707 | } |
| 10503 | 10708 | #endif |
| 10504 | 10709 | |
| 10505 | | - |
| 10710 | + |
| 10506 | 10711 | objPtr = i->freeList; |
| 10507 | 10712 | while (objPtr) { |
| 10508 | 10713 | nextObjPtr = objPtr->nextObjPtr; |
| 10509 | 10714 | Jim_Free(objPtr); |
| 10510 | 10715 | objPtr = nextObjPtr; |
| 10511 | 10716 | } |
| 10512 | 10717 | |
| 10513 | | - |
| 10718 | + |
| 10514 | 10719 | for (cf = i->freeFramesList; cf; cf = cfx) { |
| 10515 | 10720 | cfx = cf->next; |
| 10516 | 10721 | if (cf->vars.table) |
| 10517 | 10722 | Jim_FreeHashTable(&cf->vars); |
| 10518 | 10723 | Jim_Free(cf); |
| 10519 | 10724 | } |
| 10520 | 10725 | |
| 10521 | | - |
| 10726 | + |
| 10522 | 10727 | Jim_Free(i); |
| 10523 | 10728 | } |
| 10524 | 10729 | |
| 10525 | 10730 | Jim_CallFrame *Jim_GetCallFrameByLevel(Jim_Interp *interp, Jim_Obj *levelObjPtr) |
| 10526 | 10731 | { |
| | @@ -10541,25 +10746,25 @@ |
| 10541 | 10746 | else { |
| 10542 | 10747 | if (Jim_GetLong(interp, levelObjPtr, &level) != JIM_OK || level < 0) { |
| 10543 | 10748 | level = -1; |
| 10544 | 10749 | } |
| 10545 | 10750 | else { |
| 10546 | | - |
| 10751 | + |
| 10547 | 10752 | level = interp->framePtr->level - level; |
| 10548 | 10753 | } |
| 10549 | 10754 | } |
| 10550 | 10755 | } |
| 10551 | 10756 | else { |
| 10552 | | - str = "1"; |
| 10757 | + str = "1"; |
| 10553 | 10758 | level = interp->framePtr->level - 1; |
| 10554 | 10759 | } |
| 10555 | 10760 | |
| 10556 | 10761 | if (level == 0) { |
| 10557 | 10762 | return interp->topFramePtr; |
| 10558 | 10763 | } |
| 10559 | 10764 | if (level > 0) { |
| 10560 | | - |
| 10765 | + |
| 10561 | 10766 | for (framePtr = interp->framePtr; framePtr; framePtr = framePtr->parent) { |
| 10562 | 10767 | if (framePtr->level == level) { |
| 10563 | 10768 | return framePtr; |
| 10564 | 10769 | } |
| 10565 | 10770 | } |
| | @@ -10574,19 +10779,19 @@ |
| 10574 | 10779 | long level; |
| 10575 | 10780 | Jim_CallFrame *framePtr; |
| 10576 | 10781 | |
| 10577 | 10782 | if (Jim_GetLong(interp, levelObjPtr, &level) == JIM_OK) { |
| 10578 | 10783 | if (level <= 0) { |
| 10579 | | - |
| 10784 | + |
| 10580 | 10785 | level = interp->framePtr->level + level; |
| 10581 | 10786 | } |
| 10582 | 10787 | |
| 10583 | 10788 | if (level == 0) { |
| 10584 | 10789 | return interp->topFramePtr; |
| 10585 | 10790 | } |
| 10586 | 10791 | |
| 10587 | | - |
| 10792 | + |
| 10588 | 10793 | for (framePtr = interp->framePtr; framePtr; framePtr = framePtr->parent) { |
| 10589 | 10794 | if (framePtr->level == level) { |
| 10590 | 10795 | return framePtr; |
| 10591 | 10796 | } |
| 10592 | 10797 | } |
| | @@ -10605,11 +10810,11 @@ |
| 10605 | 10810 | |
| 10606 | 10811 | static void JimSetStackTrace(Jim_Interp *interp, Jim_Obj *stackTraceObj) |
| 10607 | 10812 | { |
| 10608 | 10813 | int len; |
| 10609 | 10814 | |
| 10610 | | - |
| 10815 | + |
| 10611 | 10816 | Jim_IncrRefCount(stackTraceObj); |
| 10612 | 10817 | Jim_DecrRefCount(interp, interp->stackTrace); |
| 10613 | 10818 | interp->stackTrace = stackTraceObj; |
| 10614 | 10819 | interp->errorFlag = 1; |
| 10615 | 10820 | |
| | @@ -10626,32 +10831,32 @@ |
| 10626 | 10831 | { |
| 10627 | 10832 | if (strcmp(procname, "unknown") == 0) { |
| 10628 | 10833 | procname = ""; |
| 10629 | 10834 | } |
| 10630 | 10835 | if (!*procname && !Jim_Length(fileNameObj)) { |
| 10631 | | - |
| 10836 | + |
| 10632 | 10837 | return; |
| 10633 | 10838 | } |
| 10634 | 10839 | |
| 10635 | 10840 | if (Jim_IsShared(interp->stackTrace)) { |
| 10636 | 10841 | Jim_DecrRefCount(interp, interp->stackTrace); |
| 10637 | 10842 | interp->stackTrace = Jim_DuplicateObj(interp, interp->stackTrace); |
| 10638 | 10843 | Jim_IncrRefCount(interp->stackTrace); |
| 10639 | 10844 | } |
| 10640 | 10845 | |
| 10641 | | - |
| 10846 | + |
| 10642 | 10847 | if (!*procname && Jim_Length(fileNameObj)) { |
| 10643 | | - |
| 10848 | + |
| 10644 | 10849 | int len = Jim_ListLength(interp, interp->stackTrace); |
| 10645 | 10850 | |
| 10646 | 10851 | if (len >= 3) { |
| 10647 | 10852 | Jim_Obj *objPtr = Jim_ListGetIndex(interp, interp->stackTrace, len - 3); |
| 10648 | 10853 | if (Jim_Length(objPtr)) { |
| 10649 | | - |
| 10854 | + |
| 10650 | 10855 | objPtr = Jim_ListGetIndex(interp, interp->stackTrace, len - 2); |
| 10651 | 10856 | if (Jim_Length(objPtr) == 0) { |
| 10652 | | - |
| 10857 | + |
| 10653 | 10858 | ListSetIndex(interp, interp->stackTrace, len - 2, fileNameObj, 0); |
| 10654 | 10859 | ListSetIndex(interp, interp->stackTrace, len - 1, Jim_NewIntObj(interp, linenr), 0); |
| 10655 | 10860 | return; |
| 10656 | 10861 | } |
| 10657 | 10862 | } |
| | @@ -10753,18 +10958,18 @@ |
| 10753 | 10958 | { |
| 10754 | 10959 | jim_wide wideValue; |
| 10755 | 10960 | const char *str; |
| 10756 | 10961 | |
| 10757 | 10962 | if (objPtr->typePtr == &coercedDoubleObjType) { |
| 10758 | | - |
| 10963 | + |
| 10759 | 10964 | objPtr->typePtr = &intObjType; |
| 10760 | 10965 | return JIM_OK; |
| 10761 | 10966 | } |
| 10762 | 10967 | |
| 10763 | | - |
| 10968 | + |
| 10764 | 10969 | str = Jim_String(objPtr); |
| 10765 | | - |
| 10970 | + |
| 10766 | 10971 | if (Jim_StringToWide(str, &wideValue, 0) != JIM_OK) { |
| 10767 | 10972 | if (flags & JIM_ERRMSG) { |
| 10768 | 10973 | Jim_SetResultFormatted(interp, "expected integer but got \"%#s\"", objPtr); |
| 10769 | 10974 | } |
| 10770 | 10975 | return JIM_ERR; |
| | @@ -10771,11 +10976,11 @@ |
| 10771 | 10976 | } |
| 10772 | 10977 | if ((wideValue == JIM_WIDE_MIN || wideValue == JIM_WIDE_MAX) && errno == ERANGE) { |
| 10773 | 10978 | Jim_SetResultString(interp, "Integer value too big to be represented", -1); |
| 10774 | 10979 | return JIM_ERR; |
| 10775 | 10980 | } |
| 10776 | | - |
| 10981 | + |
| 10777 | 10982 | Jim_FreeIntRep(interp, objPtr); |
| 10778 | 10983 | objPtr->typePtr = &intObjType; |
| 10779 | 10984 | objPtr->internalRep.wideValue = wideValue; |
| 10780 | 10985 | return JIM_OK; |
| 10781 | 10986 | } |
| | @@ -10870,17 +11075,17 @@ |
| 10870 | 11075 | { |
| 10871 | 11076 | char buf[JIM_DOUBLE_SPACE + 1]; |
| 10872 | 11077 | int i; |
| 10873 | 11078 | int len = sprintf(buf, "%.12g", value); |
| 10874 | 11079 | |
| 10875 | | - |
| 11080 | + |
| 10876 | 11081 | for (i = 0; i < len; i++) { |
| 10877 | 11082 | if (buf[i] == '.' || buf[i] == 'e') { |
| 10878 | 11083 | #if defined(JIM_SPRINTF_DOUBLE_NEEDS_FIX) |
| 10879 | 11084 | char *e = strchr(buf, 'e'); |
| 10880 | 11085 | if (e && (e[1] == '-' || e[1] == '+') && e[2] == '0') { |
| 10881 | | - |
| 11086 | + |
| 10882 | 11087 | e += 2; |
| 10883 | 11088 | memmove(e, e + 1, len - (e - buf)); |
| 10884 | 11089 | } |
| 10885 | 11090 | #endif |
| 10886 | 11091 | break; |
| | @@ -10902,38 +11107,38 @@ |
| 10902 | 11107 | const char *str; |
| 10903 | 11108 | |
| 10904 | 11109 | str = Jim_String(objPtr); |
| 10905 | 11110 | |
| 10906 | 11111 | #ifdef HAVE_LONG_LONG |
| 10907 | | - |
| 11112 | + |
| 10908 | 11113 | #define MIN_INT_IN_DOUBLE -(1LL << 53) |
| 10909 | 11114 | #define MAX_INT_IN_DOUBLE -(MIN_INT_IN_DOUBLE + 1) |
| 10910 | 11115 | |
| 10911 | 11116 | if (objPtr->typePtr == &intObjType |
| 10912 | 11117 | && JimWideValue(objPtr) >= MIN_INT_IN_DOUBLE |
| 10913 | 11118 | && JimWideValue(objPtr) <= MAX_INT_IN_DOUBLE) { |
| 10914 | 11119 | |
| 10915 | | - |
| 11120 | + |
| 10916 | 11121 | objPtr->typePtr = &coercedDoubleObjType; |
| 10917 | 11122 | return JIM_OK; |
| 10918 | 11123 | } |
| 10919 | 11124 | else |
| 10920 | 11125 | #endif |
| 10921 | 11126 | if (Jim_StringToWide(str, &wideValue, 10) == JIM_OK) { |
| 10922 | | - |
| 11127 | + |
| 10923 | 11128 | Jim_FreeIntRep(interp, objPtr); |
| 10924 | 11129 | objPtr->typePtr = &coercedDoubleObjType; |
| 10925 | 11130 | objPtr->internalRep.wideValue = wideValue; |
| 10926 | 11131 | return JIM_OK; |
| 10927 | 11132 | } |
| 10928 | 11133 | else { |
| 10929 | | - |
| 11134 | + |
| 10930 | 11135 | if (Jim_StringToDouble(str, &doubleValue) != JIM_OK) { |
| 10931 | 11136 | Jim_SetResultFormatted(interp, "expected floating-point number but got \"%#s\"", objPtr); |
| 10932 | 11137 | return JIM_ERR; |
| 10933 | 11138 | } |
| 10934 | | - |
| 11139 | + |
| 10935 | 11140 | Jim_FreeIntRep(interp, objPtr); |
| 10936 | 11141 | } |
| 10937 | 11142 | objPtr->typePtr = &doubleObjType; |
| 10938 | 11143 | objPtr->internalRep.doubleValue = doubleValue; |
| 10939 | 11144 | return JIM_OK; |
| | @@ -10966,50 +11171,10 @@ |
| 10966 | 11171 | objPtr->bytes = NULL; |
| 10967 | 11172 | objPtr->internalRep.doubleValue = doubleValue; |
| 10968 | 11173 | return objPtr; |
| 10969 | 11174 | } |
| 10970 | 11175 | |
| 10971 | | -static int SetBooleanFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags); |
| 10972 | | - |
| 10973 | | -int Jim_GetBoolean(Jim_Interp *interp, Jim_Obj *objPtr, int * booleanPtr) |
| 10974 | | -{ |
| 10975 | | - if (objPtr->typePtr != &intObjType && SetBooleanFromAny(interp, objPtr, JIM_ERRMSG) == JIM_ERR) |
| 10976 | | - return JIM_ERR; |
| 10977 | | - *booleanPtr = (int) JimWideValue(objPtr); |
| 10978 | | - return JIM_OK; |
| 10979 | | -} |
| 10980 | | - |
| 10981 | | -static int SetBooleanFromAny(Jim_Interp *interp, Jim_Obj *objPtr, int flags) |
| 10982 | | -{ |
| 10983 | | - static const char * const falses[] = { |
| 10984 | | - "0", "false", "no", "off", NULL |
| 10985 | | - }; |
| 10986 | | - static const char * const trues[] = { |
| 10987 | | - "1", "true", "yes", "on", NULL |
| 10988 | | - }; |
| 10989 | | - |
| 10990 | | - int boolean; |
| 10991 | | - |
| 10992 | | - int index; |
| 10993 | | - if (Jim_GetEnum(interp, objPtr, falses, &index, NULL, 0) == JIM_OK) { |
| 10994 | | - boolean = 0; |
| 10995 | | - } else if (Jim_GetEnum(interp, objPtr, trues, &index, NULL, 0) == JIM_OK) { |
| 10996 | | - boolean = 1; |
| 10997 | | - } else { |
| 10998 | | - if (flags & JIM_ERRMSG) { |
| 10999 | | - Jim_SetResultFormatted(interp, "expected boolean but got \"%#s\"", objPtr); |
| 11000 | | - } |
| 11001 | | - return JIM_ERR; |
| 11002 | | - } |
| 11003 | | - |
| 11004 | | - |
| 11005 | | - Jim_FreeIntRep(interp, objPtr); |
| 11006 | | - objPtr->typePtr = &intObjType; |
| 11007 | | - objPtr->internalRep.wideValue = boolean; |
| 11008 | | - return JIM_OK; |
| 11009 | | -} |
| 11010 | | - |
| 11011 | 11176 | static void ListInsertElements(Jim_Obj *listPtr, int idx, int elemc, Jim_Obj *const *elemVec); |
| 11012 | 11177 | static void ListAppendElement(Jim_Obj *listPtr, Jim_Obj *objPtr); |
| 11013 | 11178 | static void FreeListInternalRep(Jim_Interp *interp, Jim_Obj *objPtr); |
| 11014 | 11179 | static void DupListInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr); |
| 11015 | 11180 | static void UpdateStringOfList(struct Jim_Obj *objPtr); |
| | @@ -11056,11 +11221,11 @@ |
| 11056 | 11221 | #define JIM_ELESTR_QUOTE 2 |
| 11057 | 11222 | static unsigned char ListElementQuotingType(const char *s, int len) |
| 11058 | 11223 | { |
| 11059 | 11224 | int i, level, blevel, trySimple = 1; |
| 11060 | 11225 | |
| 11061 | | - |
| 11226 | + |
| 11062 | 11227 | if (len == 0) |
| 11063 | 11228 | return JIM_ELESTR_BRACE; |
| 11064 | 11229 | if (s[0] == '"' || s[0] == '{') { |
| 11065 | 11230 | trySimple = 0; |
| 11066 | 11231 | goto testbrace; |
| | @@ -11078,20 +11243,20 @@ |
| 11078 | 11243 | case '\n': |
| 11079 | 11244 | case '\t': |
| 11080 | 11245 | case '\f': |
| 11081 | 11246 | case '\v': |
| 11082 | 11247 | trySimple = 0; |
| 11083 | | - |
| 11248 | + |
| 11084 | 11249 | case '{': |
| 11085 | 11250 | case '}': |
| 11086 | 11251 | goto testbrace; |
| 11087 | 11252 | } |
| 11088 | 11253 | } |
| 11089 | 11254 | return JIM_ELESTR_SIMPLE; |
| 11090 | 11255 | |
| 11091 | 11256 | testbrace: |
| 11092 | | - |
| 11257 | + |
| 11093 | 11258 | if (s[len - 1] == '\\') |
| 11094 | 11259 | return JIM_ELESTR_QUOTE; |
| 11095 | 11260 | level = 0; |
| 11096 | 11261 | blevel = 0; |
| 11097 | 11262 | for (i = 0; i < len; i++) { |
| | @@ -11207,11 +11372,11 @@ |
| 11207 | 11372 | int i, bufLen, realLength; |
| 11208 | 11373 | const char *strRep; |
| 11209 | 11374 | char *p; |
| 11210 | 11375 | unsigned char *quotingType, staticQuoting[STATIC_QUOTING_LEN]; |
| 11211 | 11376 | |
| 11212 | | - |
| 11377 | + |
| 11213 | 11378 | if (objc > STATIC_QUOTING_LEN) { |
| 11214 | 11379 | quotingType = Jim_Alloc(objc); |
| 11215 | 11380 | } |
| 11216 | 11381 | else { |
| 11217 | 11382 | quotingType = staticQuoting; |
| | @@ -11226,25 +11391,25 @@ |
| 11226 | 11391 | case JIM_ELESTR_SIMPLE: |
| 11227 | 11392 | if (i != 0 || strRep[0] != '#') { |
| 11228 | 11393 | bufLen += len; |
| 11229 | 11394 | break; |
| 11230 | 11395 | } |
| 11231 | | - |
| 11396 | + |
| 11232 | 11397 | quotingType[i] = JIM_ELESTR_BRACE; |
| 11233 | | - |
| 11398 | + |
| 11234 | 11399 | case JIM_ELESTR_BRACE: |
| 11235 | 11400 | bufLen += len + 2; |
| 11236 | 11401 | break; |
| 11237 | 11402 | case JIM_ELESTR_QUOTE: |
| 11238 | 11403 | bufLen += len * 2; |
| 11239 | 11404 | break; |
| 11240 | 11405 | } |
| 11241 | | - bufLen++; |
| 11406 | + bufLen++; |
| 11242 | 11407 | } |
| 11243 | 11408 | bufLen++; |
| 11244 | 11409 | |
| 11245 | | - |
| 11410 | + |
| 11246 | 11411 | p = objPtr->bytes = Jim_Alloc(bufLen + 1); |
| 11247 | 11412 | realLength = 0; |
| 11248 | 11413 | for (i = 0; i < objc; i++) { |
| 11249 | 11414 | int len, qlen; |
| 11250 | 11415 | |
| | @@ -11271,17 +11436,17 @@ |
| 11271 | 11436 | qlen = BackslashQuoteString(strRep, len, p); |
| 11272 | 11437 | p += qlen; |
| 11273 | 11438 | realLength += qlen; |
| 11274 | 11439 | break; |
| 11275 | 11440 | } |
| 11276 | | - |
| 11441 | + |
| 11277 | 11442 | if (i + 1 != objc) { |
| 11278 | 11443 | *p++ = ' '; |
| 11279 | 11444 | realLength++; |
| 11280 | 11445 | } |
| 11281 | 11446 | } |
| 11282 | | - *p = '\0'; |
| 11447 | + *p = '\0'; |
| 11283 | 11448 | objPtr->length = realLength; |
| 11284 | 11449 | |
| 11285 | 11450 | if (quotingType != staticQuoting) { |
| 11286 | 11451 | Jim_Free(quotingType); |
| 11287 | 11452 | } |
| | @@ -11312,21 +11477,21 @@ |
| 11312 | 11477 | listObjPtrPtr = JimDictPairs(objPtr, &len); |
| 11313 | 11478 | for (i = 0; i < len; i++) { |
| 11314 | 11479 | Jim_IncrRefCount(listObjPtrPtr[i]); |
| 11315 | 11480 | } |
| 11316 | 11481 | |
| 11317 | | - |
| 11482 | + |
| 11318 | 11483 | Jim_FreeIntRep(interp, objPtr); |
| 11319 | 11484 | objPtr->typePtr = &listObjType; |
| 11320 | 11485 | objPtr->internalRep.listValue.len = len; |
| 11321 | 11486 | objPtr->internalRep.listValue.maxLen = len; |
| 11322 | 11487 | objPtr->internalRep.listValue.ele = listObjPtrPtr; |
| 11323 | 11488 | |
| 11324 | 11489 | return JIM_OK; |
| 11325 | 11490 | } |
| 11326 | 11491 | |
| 11327 | | - |
| 11492 | + |
| 11328 | 11493 | if (objPtr->typePtr == &sourceObjType) { |
| 11329 | 11494 | fileNameObj = objPtr->internalRep.sourceValue.fileNameObj; |
| 11330 | 11495 | linenr = objPtr->internalRep.sourceValue.lineNumber; |
| 11331 | 11496 | } |
| 11332 | 11497 | else { |
| | @@ -11333,20 +11498,20 @@ |
| 11333 | 11498 | fileNameObj = interp->emptyObj; |
| 11334 | 11499 | linenr = 1; |
| 11335 | 11500 | } |
| 11336 | 11501 | Jim_IncrRefCount(fileNameObj); |
| 11337 | 11502 | |
| 11338 | | - |
| 11503 | + |
| 11339 | 11504 | str = Jim_GetString(objPtr, &strLen); |
| 11340 | 11505 | |
| 11341 | 11506 | Jim_FreeIntRep(interp, objPtr); |
| 11342 | 11507 | objPtr->typePtr = &listObjType; |
| 11343 | 11508 | objPtr->internalRep.listValue.len = 0; |
| 11344 | 11509 | objPtr->internalRep.listValue.maxLen = 0; |
| 11345 | 11510 | objPtr->internalRep.listValue.ele = NULL; |
| 11346 | 11511 | |
| 11347 | | - |
| 11512 | + |
| 11348 | 11513 | if (strLen) { |
| 11349 | 11514 | JimParserInit(&parser, str, strLen, linenr); |
| 11350 | 11515 | while (!parser.eof) { |
| 11351 | 11516 | Jim_Obj *elementPtr; |
| 11352 | 11517 | |
| | @@ -11476,11 +11641,11 @@ |
| 11476 | 11641 | Jim_Obj *compare_script; |
| 11477 | 11642 | int rc; |
| 11478 | 11643 | |
| 11479 | 11644 | jim_wide ret = 0; |
| 11480 | 11645 | |
| 11481 | | - |
| 11646 | + |
| 11482 | 11647 | compare_script = Jim_DuplicateObj(sort_info->interp, sort_info->command); |
| 11483 | 11648 | Jim_ListAppendElement(sort_info->interp, compare_script, *lhsObj); |
| 11484 | 11649 | Jim_ListAppendElement(sort_info->interp, compare_script, *rhsObj); |
| 11485 | 11650 | |
| 11486 | 11651 | rc = Jim_EvalObj(sort_info->interp, compare_script); |
| | @@ -11498,23 +11663,23 @@ |
| 11498 | 11663 | int dst = 0; |
| 11499 | 11664 | Jim_Obj **ele = listObjPtr->internalRep.listValue.ele; |
| 11500 | 11665 | |
| 11501 | 11666 | for (src = 1; src < listObjPtr->internalRep.listValue.len; src++) { |
| 11502 | 11667 | if (comp(&ele[dst], &ele[src]) == 0) { |
| 11503 | | - |
| 11668 | + |
| 11504 | 11669 | Jim_DecrRefCount(sort_info->interp, ele[dst]); |
| 11505 | 11670 | } |
| 11506 | 11671 | else { |
| 11507 | | - |
| 11672 | + |
| 11508 | 11673 | dst++; |
| 11509 | 11674 | } |
| 11510 | 11675 | ele[dst] = ele[src]; |
| 11511 | 11676 | } |
| 11512 | | - |
| 11677 | + |
| 11513 | 11678 | ele[++dst] = ele[src]; |
| 11514 | 11679 | |
| 11515 | | - |
| 11680 | + |
| 11516 | 11681 | listObjPtr->internalRep.listValue.len = dst; |
| 11517 | 11682 | } |
| 11518 | 11683 | |
| 11519 | 11684 | |
| 11520 | 11685 | static int ListSortElements(Jim_Interp *interp, Jim_Obj *listObjPtr, struct lsort_info *info) |
| | @@ -11528,11 +11693,11 @@ |
| 11528 | 11693 | int rc; |
| 11529 | 11694 | |
| 11530 | 11695 | JimPanic((Jim_IsShared(listObjPtr), "ListSortElements called with shared object")); |
| 11531 | 11696 | SetListFromAny(interp, listObjPtr); |
| 11532 | 11697 | |
| 11533 | | - |
| 11698 | + |
| 11534 | 11699 | prev_info = sort_info; |
| 11535 | 11700 | sort_info = info; |
| 11536 | 11701 | |
| 11537 | 11702 | vector = listObjPtr->internalRep.listValue.ele; |
| 11538 | 11703 | len = listObjPtr->internalRep.listValue.len; |
| | @@ -11551,17 +11716,17 @@ |
| 11551 | 11716 | break; |
| 11552 | 11717 | case JIM_LSORT_COMMAND: |
| 11553 | 11718 | fn = ListSortCommand; |
| 11554 | 11719 | break; |
| 11555 | 11720 | default: |
| 11556 | | - fn = NULL; |
| 11721 | + fn = NULL; |
| 11557 | 11722 | JimPanic((1, "ListSort called with invalid sort type")); |
| 11558 | | - return -1; |
| 11723 | + return -1; |
| 11559 | 11724 | } |
| 11560 | 11725 | |
| 11561 | 11726 | if (info->indexed) { |
| 11562 | | - |
| 11727 | + |
| 11563 | 11728 | info->subfn = fn; |
| 11564 | 11729 | fn = ListSortIndexHelper; |
| 11565 | 11730 | } |
| 11566 | 11731 | |
| 11567 | 11732 | if ((rc = setjmp(info->jmpbuf)) == 0) { |
| | @@ -11585,11 +11750,11 @@ |
| 11585 | 11750 | int i; |
| 11586 | 11751 | Jim_Obj **point; |
| 11587 | 11752 | |
| 11588 | 11753 | if (requiredLen > listPtr->internalRep.listValue.maxLen) { |
| 11589 | 11754 | if (requiredLen < 2) { |
| 11590 | | - |
| 11755 | + |
| 11591 | 11756 | requiredLen = 4; |
| 11592 | 11757 | } |
| 11593 | 11758 | else { |
| 11594 | 11759 | requiredLen *= 2; |
| 11595 | 11760 | } |
| | @@ -11771,34 +11936,34 @@ |
| 11771 | 11936 | for (i = 0; i < objc; i++) |
| 11772 | 11937 | ListAppendList(objPtr, objv[i]); |
| 11773 | 11938 | return objPtr; |
| 11774 | 11939 | } |
| 11775 | 11940 | else { |
| 11776 | | - |
| 11941 | + |
| 11777 | 11942 | int len = 0, objLen; |
| 11778 | 11943 | char *bytes, *p; |
| 11779 | 11944 | |
| 11780 | | - |
| 11945 | + |
| 11781 | 11946 | for (i = 0; i < objc; i++) { |
| 11782 | 11947 | len += Jim_Length(objv[i]); |
| 11783 | 11948 | } |
| 11784 | 11949 | if (objc) |
| 11785 | 11950 | len += objc - 1; |
| 11786 | | - |
| 11951 | + |
| 11787 | 11952 | p = bytes = Jim_Alloc(len + 1); |
| 11788 | 11953 | for (i = 0; i < objc; i++) { |
| 11789 | 11954 | const char *s = Jim_GetString(objv[i], &objLen); |
| 11790 | 11955 | |
| 11791 | | - |
| 11956 | + |
| 11792 | 11957 | while (objLen && isspace(UCHAR(*s))) { |
| 11793 | 11958 | s++; |
| 11794 | 11959 | objLen--; |
| 11795 | 11960 | len--; |
| 11796 | 11961 | } |
| 11797 | | - |
| 11962 | + |
| 11798 | 11963 | while (objLen && isspace(UCHAR(s[objLen - 1]))) { |
| 11799 | | - |
| 11964 | + |
| 11800 | 11965 | if (objLen > 1 && s[objLen - 2] == '\\') { |
| 11801 | 11966 | break; |
| 11802 | 11967 | } |
| 11803 | 11968 | objLen--; |
| 11804 | 11969 | len--; |
| | @@ -11825,11 +11990,11 @@ |
| 11825 | 11990 | int len, rangeLen; |
| 11826 | 11991 | |
| 11827 | 11992 | if (Jim_GetIndex(interp, firstObjPtr, &first) != JIM_OK || |
| 11828 | 11993 | Jim_GetIndex(interp, lastObjPtr, &last) != JIM_OK) |
| 11829 | 11994 | return NULL; |
| 11830 | | - len = Jim_ListLength(interp, listObjPtr); |
| 11995 | + len = Jim_ListLength(interp, listObjPtr); |
| 11831 | 11996 | first = JimRelToAbsIndex(len, first); |
| 11832 | 11997 | last = JimRelToAbsIndex(len, last); |
| 11833 | 11998 | JimRelToAbsRange(len, &first, &last, &rangeLen); |
| 11834 | 11999 | if (first == 0 && last == len) { |
| 11835 | 12000 | return listObjPtr; |
| | @@ -11865,16 +12030,16 @@ |
| 11865 | 12030 | { |
| 11866 | 12031 | Jim_DecrRefCount(interp, (Jim_Obj *)val); |
| 11867 | 12032 | } |
| 11868 | 12033 | |
| 11869 | 12034 | static const Jim_HashTableType JimDictHashTableType = { |
| 11870 | | - JimObjectHTHashFunction, |
| 11871 | | - JimObjectHTKeyValDup, |
| 11872 | | - JimObjectHTKeyValDup, |
| 11873 | | - JimObjectHTKeyCompare, |
| 11874 | | - JimObjectHTKeyValDestructor, |
| 11875 | | - JimObjectHTKeyValDestructor |
| 12035 | + JimObjectHTHashFunction, |
| 12036 | + JimObjectHTKeyValDup, |
| 12037 | + JimObjectHTKeyValDup, |
| 12038 | + JimObjectHTKeyCompare, |
| 12039 | + JimObjectHTKeyValDestructor, |
| 12040 | + JimObjectHTKeyValDestructor |
| 11876 | 12041 | }; |
| 11877 | 12042 | |
| 11878 | 12043 | static const Jim_ObjType dictObjType = { |
| 11879 | 12044 | "dict", |
| 11880 | 12045 | FreeDictInternalRep, |
| | @@ -11895,17 +12060,17 @@ |
| 11895 | 12060 | { |
| 11896 | 12061 | Jim_HashTable *ht, *dupHt; |
| 11897 | 12062 | Jim_HashTableIterator htiter; |
| 11898 | 12063 | Jim_HashEntry *he; |
| 11899 | 12064 | |
| 11900 | | - |
| 12065 | + |
| 11901 | 12066 | ht = srcPtr->internalRep.ptr; |
| 11902 | 12067 | dupHt = Jim_Alloc(sizeof(*dupHt)); |
| 11903 | 12068 | Jim_InitHashTable(dupHt, &JimDictHashTableType, interp); |
| 11904 | 12069 | if (ht->size != 0) |
| 11905 | 12070 | Jim_ExpandHashTable(dupHt, ht->size); |
| 11906 | | - |
| 12071 | + |
| 11907 | 12072 | JimInitHashTableIterator(ht, &htiter); |
| 11908 | 12073 | while ((he = Jim_NextHashEntry(&htiter)) != NULL) { |
| 11909 | 12074 | Jim_AddHashEntry(dupHt, he->key, he->u.val); |
| 11910 | 12075 | } |
| 11911 | 12076 | |
| | @@ -11921,11 +12086,11 @@ |
| 11921 | 12086 | Jim_Obj **objv; |
| 11922 | 12087 | int i; |
| 11923 | 12088 | |
| 11924 | 12089 | ht = dictPtr->internalRep.ptr; |
| 11925 | 12090 | |
| 11926 | | - |
| 12091 | + |
| 11927 | 12092 | objv = Jim_Alloc((ht->used * 2) * sizeof(Jim_Obj *)); |
| 11928 | 12093 | JimInitHashTableIterator(ht, &htiter); |
| 11929 | 12094 | i = 0; |
| 11930 | 12095 | while ((he = Jim_NextHashEntry(&htiter)) != NULL) { |
| 11931 | 12096 | objv[i++] = Jim_GetHashEntryKey(he); |
| | @@ -11935,15 +12100,15 @@ |
| 11935 | 12100 | return objv; |
| 11936 | 12101 | } |
| 11937 | 12102 | |
| 11938 | 12103 | static void UpdateStringOfDict(struct Jim_Obj *objPtr) |
| 11939 | 12104 | { |
| 11940 | | - |
| 12105 | + |
| 11941 | 12106 | int len; |
| 11942 | 12107 | Jim_Obj **objv = JimDictPairs(objPtr, &len); |
| 11943 | 12108 | |
| 11944 | | - |
| 12109 | + |
| 11945 | 12110 | JimMakeListStringRep(objPtr, objv, len); |
| 11946 | 12111 | |
| 11947 | 12112 | Jim_Free(objv); |
| 11948 | 12113 | } |
| 11949 | 12114 | |
| | @@ -11957,18 +12122,18 @@ |
| 11957 | 12122 | |
| 11958 | 12123 | if (Jim_IsList(objPtr) && Jim_IsShared(objPtr)) { |
| 11959 | 12124 | Jim_String(objPtr); |
| 11960 | 12125 | } |
| 11961 | 12126 | |
| 11962 | | - |
| 12127 | + |
| 11963 | 12128 | listlen = Jim_ListLength(interp, objPtr); |
| 11964 | 12129 | if (listlen % 2) { |
| 11965 | 12130 | Jim_SetResultString(interp, "missing value to go with key", -1); |
| 11966 | 12131 | return JIM_ERR; |
| 11967 | 12132 | } |
| 11968 | 12133 | else { |
| 11969 | | - |
| 12134 | + |
| 11970 | 12135 | Jim_HashTable *ht; |
| 11971 | 12136 | int i; |
| 11972 | 12137 | |
| 11973 | 12138 | ht = Jim_Alloc(sizeof(*ht)); |
| 11974 | 12139 | Jim_InitHashTable(ht, &JimDictHashTableType, interp); |
| | @@ -11993,11 +12158,11 @@ |
| 11993 | 12158 | static int DictAddElement(Jim_Interp *interp, Jim_Obj *objPtr, |
| 11994 | 12159 | Jim_Obj *keyObjPtr, Jim_Obj *valueObjPtr) |
| 11995 | 12160 | { |
| 11996 | 12161 | Jim_HashTable *ht = objPtr->internalRep.ptr; |
| 11997 | 12162 | |
| 11998 | | - if (valueObjPtr == NULL) { |
| 12163 | + if (valueObjPtr == NULL) { |
| 11999 | 12164 | return Jim_DeleteHashEntry(ht, keyObjPtr); |
| 12000 | 12165 | } |
| 12001 | 12166 | Jim_ReplaceHashEntry(ht, keyObjPtr, valueObjPtr); |
| 12002 | 12167 | return JIM_OK; |
| 12003 | 12168 | } |
| | @@ -12093,11 +12258,11 @@ |
| 12093 | 12258 | int shared, i; |
| 12094 | 12259 | |
| 12095 | 12260 | varObjPtr = objPtr = Jim_GetVariable(interp, varNamePtr, flags); |
| 12096 | 12261 | if (objPtr == NULL) { |
| 12097 | 12262 | if (newObjPtr == NULL && (flags & JIM_MUSTEXIST)) { |
| 12098 | | - |
| 12263 | + |
| 12099 | 12264 | return JIM_ERR; |
| 12100 | 12265 | } |
| 12101 | 12266 | varObjPtr = objPtr = Jim_NewDictObj(interp, NULL, 0); |
| 12102 | 12267 | if (Jim_SetVariable(interp, varNamePtr, objPtr) != JIM_OK) { |
| 12103 | 12268 | Jim_FreeNewObj(interp, varObjPtr); |
| | @@ -12107,26 +12272,26 @@ |
| 12107 | 12272 | if ((shared = Jim_IsShared(objPtr))) |
| 12108 | 12273 | varObjPtr = objPtr = Jim_DuplicateObj(interp, objPtr); |
| 12109 | 12274 | for (i = 0; i < keyc; i++) { |
| 12110 | 12275 | dictObjPtr = objPtr; |
| 12111 | 12276 | |
| 12112 | | - |
| 12277 | + |
| 12113 | 12278 | if (SetDictFromAny(interp, dictObjPtr) != JIM_OK) { |
| 12114 | 12279 | goto err; |
| 12115 | 12280 | } |
| 12116 | 12281 | |
| 12117 | 12282 | if (i == keyc - 1) { |
| 12118 | | - |
| 12283 | + |
| 12119 | 12284 | if (Jim_DictAddElement(interp, objPtr, keyv[keyc - 1], newObjPtr) != JIM_OK) { |
| 12120 | 12285 | if (newObjPtr || (flags & JIM_MUSTEXIST)) { |
| 12121 | 12286 | goto err; |
| 12122 | 12287 | } |
| 12123 | 12288 | } |
| 12124 | 12289 | break; |
| 12125 | 12290 | } |
| 12126 | 12291 | |
| 12127 | | - |
| 12292 | + |
| 12128 | 12293 | Jim_InvalidateStringRep(dictObjPtr); |
| 12129 | 12294 | if (Jim_DictKey(interp, dictObjPtr, keyv[i], &objPtr, |
| 12130 | 12295 | newObjPtr ? JIM_NONE : JIM_ERRMSG) == JIM_OK) { |
| 12131 | 12296 | if (Jim_IsShared(objPtr)) { |
| 12132 | 12297 | objPtr = Jim_DuplicateObj(interp, objPtr); |
| | @@ -12139,11 +12304,11 @@ |
| 12139 | 12304 | } |
| 12140 | 12305 | objPtr = Jim_NewDictObj(interp, NULL, 0); |
| 12141 | 12306 | DictAddElement(interp, dictObjPtr, keyv[i], objPtr); |
| 12142 | 12307 | } |
| 12143 | 12308 | } |
| 12144 | | - |
| 12309 | + |
| 12145 | 12310 | Jim_InvalidateStringRep(objPtr); |
| 12146 | 12311 | Jim_InvalidateStringRep(varObjPtr); |
| 12147 | 12312 | if (Jim_SetVariable(interp, varNamePtr, varObjPtr) != JIM_OK) { |
| 12148 | 12313 | goto err; |
| 12149 | 12314 | } |
| | @@ -12176,11 +12341,11 @@ |
| 12176 | 12341 | char buf[JIM_INTEGER_SPACE + 1]; |
| 12177 | 12342 | if (objPtr->internalRep.intValue >= 0) { |
| 12178 | 12343 | sprintf(buf, "%d", objPtr->internalRep.intValue); |
| 12179 | 12344 | } |
| 12180 | 12345 | else { |
| 12181 | | - |
| 12346 | + |
| 12182 | 12347 | sprintf(buf, "end%d", objPtr->internalRep.intValue + 1); |
| 12183 | 12348 | } |
| 12184 | 12349 | JimSetStringBytes(objPtr, buf); |
| 12185 | 12350 | } |
| 12186 | 12351 | } |
| | @@ -12189,14 +12354,14 @@ |
| 12189 | 12354 | { |
| 12190 | 12355 | int idx, end = 0; |
| 12191 | 12356 | const char *str; |
| 12192 | 12357 | char *endptr; |
| 12193 | 12358 | |
| 12194 | | - |
| 12359 | + |
| 12195 | 12360 | str = Jim_String(objPtr); |
| 12196 | 12361 | |
| 12197 | | - |
| 12362 | + |
| 12198 | 12363 | if (strncmp(str, "end", 3) == 0) { |
| 12199 | 12364 | end = 1; |
| 12200 | 12365 | str += 3; |
| 12201 | 12366 | idx = 0; |
| 12202 | 12367 | } |
| | @@ -12207,21 +12372,21 @@ |
| 12207 | 12372 | goto badindex; |
| 12208 | 12373 | } |
| 12209 | 12374 | str = endptr; |
| 12210 | 12375 | } |
| 12211 | 12376 | |
| 12212 | | - |
| 12377 | + |
| 12213 | 12378 | if (*str == '+' || *str == '-') { |
| 12214 | 12379 | int sign = (*str == '+' ? 1 : -1); |
| 12215 | 12380 | |
| 12216 | 12381 | idx += sign * jim_strtol(++str, &endptr); |
| 12217 | 12382 | if (str == endptr || *endptr) { |
| 12218 | 12383 | goto badindex; |
| 12219 | 12384 | } |
| 12220 | 12385 | str = endptr; |
| 12221 | 12386 | } |
| 12222 | | - |
| 12387 | + |
| 12223 | 12388 | while (isspace(UCHAR(*str))) { |
| 12224 | 12389 | str++; |
| 12225 | 12390 | } |
| 12226 | 12391 | if (*str) { |
| 12227 | 12392 | goto badindex; |
| | @@ -12229,19 +12394,19 @@ |
| 12229 | 12394 | if (end) { |
| 12230 | 12395 | if (idx > 0) { |
| 12231 | 12396 | idx = INT_MAX; |
| 12232 | 12397 | } |
| 12233 | 12398 | else { |
| 12234 | | - |
| 12399 | + |
| 12235 | 12400 | idx--; |
| 12236 | 12401 | } |
| 12237 | 12402 | } |
| 12238 | 12403 | else if (idx < 0) { |
| 12239 | 12404 | idx = -INT_MAX; |
| 12240 | 12405 | } |
| 12241 | 12406 | |
| 12242 | | - |
| 12407 | + |
| 12243 | 12408 | Jim_FreeIntRep(interp, objPtr); |
| 12244 | 12409 | objPtr->typePtr = &indexObjType; |
| 12245 | 12410 | objPtr->internalRep.intValue = idx; |
| 12246 | 12411 | return JIM_OK; |
| 12247 | 12412 | |
| | @@ -12251,11 +12416,11 @@ |
| 12251 | 12416 | return JIM_ERR; |
| 12252 | 12417 | } |
| 12253 | 12418 | |
| 12254 | 12419 | int Jim_GetIndex(Jim_Interp *interp, Jim_Obj *objPtr, int *indexPtr) |
| 12255 | 12420 | { |
| 12256 | | - |
| 12421 | + |
| 12257 | 12422 | if (objPtr->typePtr == &intObjType) { |
| 12258 | 12423 | jim_wide val = JimWideValue(objPtr); |
| 12259 | 12424 | |
| 12260 | 12425 | if (val < 0) |
| 12261 | 12426 | *indexPtr = -INT_MAX; |
| | @@ -12308,18 +12473,18 @@ |
| 12308 | 12473 | static int SetReturnCodeFromAny(Jim_Interp *interp, Jim_Obj *objPtr) |
| 12309 | 12474 | { |
| 12310 | 12475 | int returnCode; |
| 12311 | 12476 | jim_wide wideValue; |
| 12312 | 12477 | |
| 12313 | | - |
| 12478 | + |
| 12314 | 12479 | if (JimGetWideNoErr(interp, objPtr, &wideValue) != JIM_ERR) |
| 12315 | 12480 | returnCode = (int)wideValue; |
| 12316 | 12481 | else if (Jim_GetEnum(interp, objPtr, jimReturnCodes, &returnCode, NULL, JIM_NONE) != JIM_OK) { |
| 12317 | 12482 | Jim_SetResultFormatted(interp, "expected return code but got \"%#s\"", objPtr); |
| 12318 | 12483 | return JIM_ERR; |
| 12319 | 12484 | } |
| 12320 | | - |
| 12485 | + |
| 12321 | 12486 | Jim_FreeIntRep(interp, objPtr); |
| 12322 | 12487 | objPtr->typePtr = &returnCodeObjType; |
| 12323 | 12488 | objPtr->internalRep.intValue = returnCode; |
| 12324 | 12489 | return JIM_OK; |
| 12325 | 12490 | } |
| | @@ -12333,20 +12498,19 @@ |
| 12333 | 12498 | } |
| 12334 | 12499 | |
| 12335 | 12500 | static int JimParseExprOperator(struct JimParserCtx *pc); |
| 12336 | 12501 | static int JimParseExprNumber(struct JimParserCtx *pc); |
| 12337 | 12502 | static int JimParseExprIrrational(struct JimParserCtx *pc); |
| 12338 | | -static int JimParseExprBoolean(struct JimParserCtx *pc); |
| 12339 | 12503 | |
| 12340 | 12504 | |
| 12341 | 12505 | |
| 12342 | 12506 | |
| 12343 | 12507 | enum |
| 12344 | 12508 | { |
| 12345 | | - |
| 12346 | | - |
| 12347 | | - JIM_EXPROP_MUL = JIM_TT_EXPR_OP, |
| 12509 | + |
| 12510 | + |
| 12511 | + JIM_EXPROP_MUL = JIM_TT_EXPR_OP, |
| 12348 | 12512 | JIM_EXPROP_DIV, |
| 12349 | 12513 | JIM_EXPROP_MOD, |
| 12350 | 12514 | JIM_EXPROP_SUB, |
| 12351 | 12515 | JIM_EXPROP_ADD, |
| 12352 | 12516 | JIM_EXPROP_LSHIFT, |
| | @@ -12357,67 +12521,66 @@ |
| 12357 | 12521 | JIM_EXPROP_GT, |
| 12358 | 12522 | JIM_EXPROP_LTE, |
| 12359 | 12523 | JIM_EXPROP_GTE, |
| 12360 | 12524 | JIM_EXPROP_NUMEQ, |
| 12361 | 12525 | JIM_EXPROP_NUMNE, |
| 12362 | | - JIM_EXPROP_BITAND, |
| 12526 | + JIM_EXPROP_BITAND, |
| 12363 | 12527 | JIM_EXPROP_BITXOR, |
| 12364 | 12528 | JIM_EXPROP_BITOR, |
| 12365 | 12529 | |
| 12366 | | - |
| 12367 | | - JIM_EXPROP_LOGICAND, |
| 12530 | + |
| 12531 | + JIM_EXPROP_LOGICAND, |
| 12368 | 12532 | JIM_EXPROP_LOGICAND_LEFT, |
| 12369 | 12533 | JIM_EXPROP_LOGICAND_RIGHT, |
| 12370 | 12534 | |
| 12371 | | - |
| 12372 | | - JIM_EXPROP_LOGICOR, |
| 12535 | + |
| 12536 | + JIM_EXPROP_LOGICOR, |
| 12373 | 12537 | JIM_EXPROP_LOGICOR_LEFT, |
| 12374 | 12538 | JIM_EXPROP_LOGICOR_RIGHT, |
| 12375 | 12539 | |
| 12376 | | - |
| 12377 | | - |
| 12378 | | - JIM_EXPROP_TERNARY, |
| 12540 | + |
| 12541 | + |
| 12542 | + JIM_EXPROP_TERNARY, |
| 12379 | 12543 | JIM_EXPROP_TERNARY_LEFT, |
| 12380 | 12544 | JIM_EXPROP_TERNARY_RIGHT, |
| 12381 | 12545 | |
| 12382 | | - |
| 12383 | | - JIM_EXPROP_COLON, |
| 12546 | + |
| 12547 | + JIM_EXPROP_COLON, |
| 12384 | 12548 | JIM_EXPROP_COLON_LEFT, |
| 12385 | 12549 | JIM_EXPROP_COLON_RIGHT, |
| 12386 | 12550 | |
| 12387 | | - JIM_EXPROP_POW, |
| 12551 | + JIM_EXPROP_POW, |
| 12388 | 12552 | |
| 12389 | 12553 | |
| 12390 | | - JIM_EXPROP_STREQ, |
| 12554 | + JIM_EXPROP_STREQ, |
| 12391 | 12555 | JIM_EXPROP_STRNE, |
| 12392 | 12556 | JIM_EXPROP_STRIN, |
| 12393 | 12557 | JIM_EXPROP_STRNI, |
| 12394 | 12558 | |
| 12395 | 12559 | |
| 12396 | | - JIM_EXPROP_NOT, |
| 12560 | + JIM_EXPROP_NOT, |
| 12397 | 12561 | JIM_EXPROP_BITNOT, |
| 12398 | 12562 | JIM_EXPROP_UNARYMINUS, |
| 12399 | 12563 | JIM_EXPROP_UNARYPLUS, |
| 12400 | 12564 | |
| 12401 | | - |
| 12402 | | - JIM_EXPROP_FUNC_FIRST, |
| 12565 | + |
| 12566 | + JIM_EXPROP_FUNC_FIRST, |
| 12403 | 12567 | JIM_EXPROP_FUNC_INT = JIM_EXPROP_FUNC_FIRST, |
| 12404 | 12568 | JIM_EXPROP_FUNC_WIDE, |
| 12405 | 12569 | JIM_EXPROP_FUNC_ABS, |
| 12406 | 12570 | JIM_EXPROP_FUNC_DOUBLE, |
| 12407 | 12571 | JIM_EXPROP_FUNC_ROUND, |
| 12408 | 12572 | JIM_EXPROP_FUNC_RAND, |
| 12409 | 12573 | JIM_EXPROP_FUNC_SRAND, |
| 12410 | 12574 | |
| 12411 | | - |
| 12412 | | - JIM_EXPROP_FUNC_SIN, |
| 12575 | + |
| 12576 | + JIM_EXPROP_FUNC_SIN, |
| 12413 | 12577 | JIM_EXPROP_FUNC_COS, |
| 12414 | 12578 | JIM_EXPROP_FUNC_TAN, |
| 12415 | 12579 | JIM_EXPROP_FUNC_ASIN, |
| 12416 | 12580 | JIM_EXPROP_FUNC_ACOS, |
| 12417 | 12581 | JIM_EXPROP_FUNC_ATAN, |
| 12418 | | - JIM_EXPROP_FUNC_ATAN2, |
| 12419 | 12582 | JIM_EXPROP_FUNC_SINH, |
| 12420 | 12583 | JIM_EXPROP_FUNC_COSH, |
| 12421 | 12584 | JIM_EXPROP_FUNC_TANH, |
| 12422 | 12585 | JIM_EXPROP_FUNC_CEIL, |
| 12423 | 12586 | JIM_EXPROP_FUNC_FLOOR, |
| | @@ -12424,12 +12587,10 @@ |
| 12424 | 12587 | JIM_EXPROP_FUNC_EXP, |
| 12425 | 12588 | JIM_EXPROP_FUNC_LOG, |
| 12426 | 12589 | JIM_EXPROP_FUNC_LOG10, |
| 12427 | 12590 | JIM_EXPROP_FUNC_SQRT, |
| 12428 | 12591 | JIM_EXPROP_FUNC_POW, |
| 12429 | | - JIM_EXPROP_FUNC_HYPOT, |
| 12430 | | - JIM_EXPROP_FUNC_FMOD, |
| 12431 | 12592 | }; |
| 12432 | 12593 | |
| 12433 | 12594 | struct JimExprState |
| 12434 | 12595 | { |
| 12435 | 12596 | Jim_Obj **stack; |
| | @@ -12506,15 +12667,11 @@ |
| 12506 | 12667 | case JIM_EXPROP_UNARYPLUS: |
| 12507 | 12668 | dC = dA; |
| 12508 | 12669 | intresult = 0; |
| 12509 | 12670 | break; |
| 12510 | 12671 | case JIM_EXPROP_FUNC_ABS: |
| 12511 | | -#ifdef JIM_MATH_FUNCTIONS |
| 12512 | | - dC = fabs(dA); |
| 12513 | | -#else |
| 12514 | 12672 | dC = dA >= 0 ? dA : -dA; |
| 12515 | | -#endif |
| 12516 | 12673 | intresult = 0; |
| 12517 | 12674 | break; |
| 12518 | 12675 | case JIM_EXPROP_UNARYMINUS: |
| 12519 | 12676 | dC = -dA; |
| 12520 | 12677 | intresult = 0; |
| | @@ -12702,16 +12859,16 @@ |
| 12702 | 12859 | } |
| 12703 | 12860 | } |
| 12704 | 12861 | break; |
| 12705 | 12862 | case JIM_EXPROP_ROTL: |
| 12706 | 12863 | case JIM_EXPROP_ROTR:{ |
| 12707 | | - |
| 12864 | + |
| 12708 | 12865 | unsigned long uA = (unsigned long)wA; |
| 12709 | 12866 | unsigned long uB = (unsigned long)wB; |
| 12710 | 12867 | const unsigned int S = sizeof(unsigned long) * 8; |
| 12711 | 12868 | |
| 12712 | | - |
| 12869 | + |
| 12713 | 12870 | uB %= S; |
| 12714 | 12871 | |
| 12715 | 12872 | if (e->opcode == JIM_EXPROP_ROTR) { |
| 12716 | 12873 | uB = S - uB; |
| 12717 | 12874 | } |
| | @@ -12733,10 +12890,11 @@ |
| 12733 | 12890 | |
| 12734 | 12891 | |
| 12735 | 12892 | |
| 12736 | 12893 | static int JimExprOpBin(Jim_Interp *interp, struct JimExprState *e) |
| 12737 | 12894 | { |
| 12895 | + int intresult = 1; |
| 12738 | 12896 | int rc = JIM_OK; |
| 12739 | 12897 | double dA, dB, dC = 0; |
| 12740 | 12898 | jim_wide wA, wB, wC = 0; |
| 12741 | 12899 | |
| 12742 | 12900 | Jim_Obj *B = ExprPop(e); |
| | @@ -12744,36 +12902,30 @@ |
| 12744 | 12902 | |
| 12745 | 12903 | if ((A->typePtr != &doubleObjType || A->bytes) && |
| 12746 | 12904 | (B->typePtr != &doubleObjType || B->bytes) && |
| 12747 | 12905 | JimGetWideNoErr(interp, A, &wA) == JIM_OK && JimGetWideNoErr(interp, B, &wB) == JIM_OK) { |
| 12748 | 12906 | |
| 12749 | | - |
| 12907 | + |
| 12750 | 12908 | |
| 12751 | 12909 | switch (e->opcode) { |
| 12752 | 12910 | case JIM_EXPROP_POW: |
| 12753 | 12911 | case JIM_EXPROP_FUNC_POW: |
| 12754 | | - if (wA == 0 && wB < 0) { |
| 12755 | | - Jim_SetResultString(interp, "exponentiation of zero by negative power", -1); |
| 12756 | | - rc = JIM_ERR; |
| 12757 | | - goto done; |
| 12758 | | - } |
| 12759 | 12912 | wC = JimPowWide(wA, wB); |
| 12760 | | - goto intresult; |
| 12913 | + break; |
| 12761 | 12914 | case JIM_EXPROP_ADD: |
| 12762 | 12915 | wC = wA + wB; |
| 12763 | | - goto intresult; |
| 12916 | + break; |
| 12764 | 12917 | case JIM_EXPROP_SUB: |
| 12765 | 12918 | wC = wA - wB; |
| 12766 | | - goto intresult; |
| 12919 | + break; |
| 12767 | 12920 | case JIM_EXPROP_MUL: |
| 12768 | 12921 | wC = wA * wB; |
| 12769 | | - goto intresult; |
| 12922 | + break; |
| 12770 | 12923 | case JIM_EXPROP_DIV: |
| 12771 | 12924 | if (wB == 0) { |
| 12772 | 12925 | Jim_SetResultString(interp, "Division by zero", -1); |
| 12773 | 12926 | rc = JIM_ERR; |
| 12774 | | - goto done; |
| 12775 | 12927 | } |
| 12776 | 12928 | else { |
| 12777 | 12929 | if (wB < 0) { |
| 12778 | 12930 | wB = -wB; |
| 12779 | 12931 | wA = -wA; |
| | @@ -12780,67 +12932,55 @@ |
| 12780 | 12932 | } |
| 12781 | 12933 | wC = wA / wB; |
| 12782 | 12934 | if (wA % wB < 0) { |
| 12783 | 12935 | wC--; |
| 12784 | 12936 | } |
| 12785 | | - goto intresult; |
| 12786 | | - } |
| 12787 | | - case JIM_EXPROP_LT: |
| 12788 | | - wC = wA < wB; |
| 12789 | | - goto intresult; |
| 12790 | | - case JIM_EXPROP_GT: |
| 12791 | | - wC = wA > wB; |
| 12792 | | - goto intresult; |
| 12793 | | - case JIM_EXPROP_LTE: |
| 12794 | | - wC = wA <= wB; |
| 12795 | | - goto intresult; |
| 12796 | | - case JIM_EXPROP_GTE: |
| 12797 | | - wC = wA >= wB; |
| 12798 | | - goto intresult; |
| 12799 | | - case JIM_EXPROP_NUMEQ: |
| 12800 | | - wC = wA == wB; |
| 12801 | | - goto intresult; |
| 12802 | | - case JIM_EXPROP_NUMNE: |
| 12803 | | - wC = wA != wB; |
| 12804 | | - goto intresult; |
| 12805 | | - } |
| 12806 | | - } |
| 12807 | | - if (Jim_GetDouble(interp, A, &dA) == JIM_OK && Jim_GetDouble(interp, B, &dB) == JIM_OK) { |
| 12808 | | - switch (e->opcode) { |
| 12809 | | -#ifndef JIM_MATH_FUNCTIONS |
| 12810 | | - case JIM_EXPROP_POW: |
| 12811 | | - case JIM_EXPROP_FUNC_POW: |
| 12812 | | - case JIM_EXPROP_FUNC_ATAN2: |
| 12813 | | - case JIM_EXPROP_FUNC_HYPOT: |
| 12814 | | - case JIM_EXPROP_FUNC_FMOD: |
| 12815 | | - Jim_SetResultString(interp, "unsupported", -1); |
| 12816 | | - rc = JIM_ERR; |
| 12817 | | - goto done; |
| 12818 | | -#else |
| 12819 | | - case JIM_EXPROP_POW: |
| 12820 | | - case JIM_EXPROP_FUNC_POW: |
| 12821 | | - dC = pow(dA, dB); |
| 12822 | | - goto doubleresult; |
| 12823 | | - case JIM_EXPROP_FUNC_ATAN2: |
| 12824 | | - dC = atan2(dA, dB); |
| 12825 | | - goto doubleresult; |
| 12826 | | - case JIM_EXPROP_FUNC_HYPOT: |
| 12827 | | - dC = hypot(dA, dB); |
| 12828 | | - goto doubleresult; |
| 12829 | | - case JIM_EXPROP_FUNC_FMOD: |
| 12830 | | - dC = fmod(dA, dB); |
| 12831 | | - goto doubleresult; |
| 12832 | | -#endif |
| 12833 | | - case JIM_EXPROP_ADD: |
| 12834 | | - dC = dA + dB; |
| 12835 | | - goto doubleresult; |
| 12836 | | - case JIM_EXPROP_SUB: |
| 12837 | | - dC = dA - dB; |
| 12838 | | - goto doubleresult; |
| 12839 | | - case JIM_EXPROP_MUL: |
| 12840 | | - dC = dA * dB; |
| 12841 | | - goto doubleresult; |
| 12937 | + } |
| 12938 | + break; |
| 12939 | + case JIM_EXPROP_LT: |
| 12940 | + wC = wA < wB; |
| 12941 | + break; |
| 12942 | + case JIM_EXPROP_GT: |
| 12943 | + wC = wA > wB; |
| 12944 | + break; |
| 12945 | + case JIM_EXPROP_LTE: |
| 12946 | + wC = wA <= wB; |
| 12947 | + break; |
| 12948 | + case JIM_EXPROP_GTE: |
| 12949 | + wC = wA >= wB; |
| 12950 | + break; |
| 12951 | + case JIM_EXPROP_NUMEQ: |
| 12952 | + wC = wA == wB; |
| 12953 | + break; |
| 12954 | + case JIM_EXPROP_NUMNE: |
| 12955 | + wC = wA != wB; |
| 12956 | + break; |
| 12957 | + default: |
| 12958 | + abort(); |
| 12959 | + } |
| 12960 | + } |
| 12961 | + else if (Jim_GetDouble(interp, A, &dA) == JIM_OK && Jim_GetDouble(interp, B, &dB) == JIM_OK) { |
| 12962 | + intresult = 0; |
| 12963 | + switch (e->opcode) { |
| 12964 | + case JIM_EXPROP_POW: |
| 12965 | + case JIM_EXPROP_FUNC_POW: |
| 12966 | +#ifdef JIM_MATH_FUNCTIONS |
| 12967 | + dC = pow(dA, dB); |
| 12968 | +#else |
| 12969 | + Jim_SetResultString(interp, "unsupported", -1); |
| 12970 | + rc = JIM_ERR; |
| 12971 | +#endif |
| 12972 | + break; |
| 12973 | + case JIM_EXPROP_ADD: |
| 12974 | + dC = dA + dB; |
| 12975 | + break; |
| 12976 | + case JIM_EXPROP_SUB: |
| 12977 | + dC = dA - dB; |
| 12978 | + break; |
| 12979 | + case JIM_EXPROP_MUL: |
| 12980 | + dC = dA * dB; |
| 12981 | + break; |
| 12842 | 12982 | case JIM_EXPROP_DIV: |
| 12843 | 12983 | if (dB == 0) { |
| 12844 | 12984 | #ifdef INFINITY |
| 12845 | 12985 | dC = dA < 0 ? -INFINITY : INFINITY; |
| 12846 | 12986 | #else |
| | @@ -12848,70 +12988,83 @@ |
| 12848 | 12988 | #endif |
| 12849 | 12989 | } |
| 12850 | 12990 | else { |
| 12851 | 12991 | dC = dA / dB; |
| 12852 | 12992 | } |
| 12853 | | - goto doubleresult; |
| 12993 | + break; |
| 12854 | 12994 | case JIM_EXPROP_LT: |
| 12855 | 12995 | wC = dA < dB; |
| 12856 | | - goto intresult; |
| 12996 | + intresult = 1; |
| 12997 | + break; |
| 12857 | 12998 | case JIM_EXPROP_GT: |
| 12858 | 12999 | wC = dA > dB; |
| 12859 | | - goto intresult; |
| 13000 | + intresult = 1; |
| 13001 | + break; |
| 12860 | 13002 | case JIM_EXPROP_LTE: |
| 12861 | 13003 | wC = dA <= dB; |
| 12862 | | - goto intresult; |
| 13004 | + intresult = 1; |
| 13005 | + break; |
| 12863 | 13006 | case JIM_EXPROP_GTE: |
| 12864 | 13007 | wC = dA >= dB; |
| 12865 | | - goto intresult; |
| 13008 | + intresult = 1; |
| 13009 | + break; |
| 12866 | 13010 | case JIM_EXPROP_NUMEQ: |
| 12867 | 13011 | wC = dA == dB; |
| 12868 | | - goto intresult; |
| 13012 | + intresult = 1; |
| 13013 | + break; |
| 12869 | 13014 | case JIM_EXPROP_NUMNE: |
| 12870 | 13015 | wC = dA != dB; |
| 12871 | | - goto intresult; |
| 13016 | + intresult = 1; |
| 13017 | + break; |
| 13018 | + default: |
| 13019 | + abort(); |
| 12872 | 13020 | } |
| 12873 | 13021 | } |
| 12874 | 13022 | else { |
| 13023 | + |
| 12875 | 13024 | |
| 12876 | | - |
| 12877 | | - |
| 13025 | + |
| 12878 | 13026 | int i = Jim_StringCompareObj(interp, A, B, 0); |
| 12879 | 13027 | |
| 12880 | 13028 | switch (e->opcode) { |
| 12881 | 13029 | case JIM_EXPROP_LT: |
| 12882 | 13030 | wC = i < 0; |
| 12883 | | - goto intresult; |
| 13031 | + break; |
| 12884 | 13032 | case JIM_EXPROP_GT: |
| 12885 | 13033 | wC = i > 0; |
| 12886 | | - goto intresult; |
| 13034 | + break; |
| 12887 | 13035 | case JIM_EXPROP_LTE: |
| 12888 | 13036 | wC = i <= 0; |
| 12889 | | - goto intresult; |
| 13037 | + break; |
| 12890 | 13038 | case JIM_EXPROP_GTE: |
| 12891 | 13039 | wC = i >= 0; |
| 12892 | | - goto intresult; |
| 13040 | + break; |
| 12893 | 13041 | case JIM_EXPROP_NUMEQ: |
| 12894 | 13042 | wC = i == 0; |
| 12895 | | - goto intresult; |
| 13043 | + break; |
| 12896 | 13044 | case JIM_EXPROP_NUMNE: |
| 12897 | 13045 | wC = i != 0; |
| 12898 | | - goto intresult; |
| 13046 | + break; |
| 13047 | + default: |
| 13048 | + rc = JIM_ERR; |
| 13049 | + break; |
| 12899 | 13050 | } |
| 12900 | 13051 | } |
| 12901 | 13052 | |
| 12902 | | - rc = JIM_ERR; |
| 12903 | | -done: |
| 13053 | + if (rc == JIM_OK) { |
| 13054 | + if (intresult) { |
| 13055 | + ExprPush(e, Jim_NewIntObj(interp, wC)); |
| 13056 | + } |
| 13057 | + else { |
| 13058 | + ExprPush(e, Jim_NewDoubleObj(interp, dC)); |
| 13059 | + } |
| 13060 | + } |
| 13061 | + |
| 12904 | 13062 | Jim_DecrRefCount(interp, A); |
| 12905 | 13063 | Jim_DecrRefCount(interp, B); |
| 13064 | + |
| 12906 | 13065 | return rc; |
| 12907 | | -intresult: |
| 12908 | | - ExprPush(e, Jim_NewIntObj(interp, wC)); |
| 12909 | | - goto done; |
| 12910 | | -doubleresult: |
| 12911 | | - ExprPush(e, Jim_NewDoubleObj(interp, dC)); |
| 12912 | | - goto done; |
| 12913 | 13066 | } |
| 12914 | 13067 | |
| 12915 | 13068 | static int JimSearchList(Jim_Interp *interp, Jim_Obj *listObjPtr, Jim_Obj *valObj) |
| 12916 | 13069 | { |
| 12917 | 13070 | int listlen; |
| | @@ -12960,21 +13113,17 @@ |
| 12960 | 13113 | |
| 12961 | 13114 | static int ExprBool(Jim_Interp *interp, Jim_Obj *obj) |
| 12962 | 13115 | { |
| 12963 | 13116 | long l; |
| 12964 | 13117 | double d; |
| 12965 | | - int b; |
| 12966 | 13118 | |
| 12967 | 13119 | if (Jim_GetLong(interp, obj, &l) == JIM_OK) { |
| 12968 | 13120 | return l != 0; |
| 12969 | 13121 | } |
| 12970 | 13122 | if (Jim_GetDouble(interp, obj, &d) == JIM_OK) { |
| 12971 | 13123 | return d != 0; |
| 12972 | 13124 | } |
| 12973 | | - if (Jim_GetBoolean(interp, obj, &b) == JIM_OK) { |
| 12974 | | - return b != 0; |
| 12975 | | - } |
| 12976 | 13125 | return -1; |
| 12977 | 13126 | } |
| 12978 | 13127 | |
| 12979 | 13128 | static int JimExprOpAndLeft(Jim_Interp *interp, struct JimExprState *e) |
| 12980 | 13129 | { |
| | @@ -12982,21 +13131,21 @@ |
| 12982 | 13131 | Jim_Obj *A = ExprPop(e); |
| 12983 | 13132 | int rc = JIM_OK; |
| 12984 | 13133 | |
| 12985 | 13134 | switch (ExprBool(interp, A)) { |
| 12986 | 13135 | case 0: |
| 12987 | | - |
| 13136 | + |
| 12988 | 13137 | e->skip = JimWideValue(skip); |
| 12989 | 13138 | ExprPush(e, Jim_NewIntObj(interp, 0)); |
| 12990 | 13139 | break; |
| 12991 | 13140 | |
| 12992 | 13141 | case 1: |
| 12993 | | - |
| 13142 | + |
| 12994 | 13143 | break; |
| 12995 | 13144 | |
| 12996 | 13145 | case -1: |
| 12997 | | - |
| 13146 | + |
| 12998 | 13147 | rc = JIM_ERR; |
| 12999 | 13148 | } |
| 13000 | 13149 | Jim_DecrRefCount(interp, A); |
| 13001 | 13150 | Jim_DecrRefCount(interp, skip); |
| 13002 | 13151 | |
| | @@ -13009,21 +13158,21 @@ |
| 13009 | 13158 | Jim_Obj *A = ExprPop(e); |
| 13010 | 13159 | int rc = JIM_OK; |
| 13011 | 13160 | |
| 13012 | 13161 | switch (ExprBool(interp, A)) { |
| 13013 | 13162 | case 0: |
| 13014 | | - |
| 13163 | + |
| 13015 | 13164 | break; |
| 13016 | 13165 | |
| 13017 | 13166 | case 1: |
| 13018 | | - |
| 13167 | + |
| 13019 | 13168 | e->skip = JimWideValue(skip); |
| 13020 | 13169 | ExprPush(e, Jim_NewIntObj(interp, 1)); |
| 13021 | 13170 | break; |
| 13022 | 13171 | |
| 13023 | 13172 | case -1: |
| 13024 | | - |
| 13173 | + |
| 13025 | 13174 | rc = JIM_ERR; |
| 13026 | 13175 | break; |
| 13027 | 13176 | } |
| 13028 | 13177 | Jim_DecrRefCount(interp, A); |
| 13029 | 13178 | Jim_DecrRefCount(interp, skip); |
| | @@ -13044,11 +13193,11 @@ |
| 13044 | 13193 | case 1: |
| 13045 | 13194 | ExprPush(e, Jim_NewIntObj(interp, 1)); |
| 13046 | 13195 | break; |
| 13047 | 13196 | |
| 13048 | 13197 | case -1: |
| 13049 | | - |
| 13198 | + |
| 13050 | 13199 | rc = JIM_ERR; |
| 13051 | 13200 | break; |
| 13052 | 13201 | } |
| 13053 | 13202 | Jim_DecrRefCount(interp, A); |
| 13054 | 13203 | |
| | @@ -13059,27 +13208,27 @@ |
| 13059 | 13208 | { |
| 13060 | 13209 | Jim_Obj *skip = ExprPop(e); |
| 13061 | 13210 | Jim_Obj *A = ExprPop(e); |
| 13062 | 13211 | int rc = JIM_OK; |
| 13063 | 13212 | |
| 13064 | | - |
| 13213 | + |
| 13065 | 13214 | ExprPush(e, A); |
| 13066 | 13215 | |
| 13067 | 13216 | switch (ExprBool(interp, A)) { |
| 13068 | 13217 | case 0: |
| 13069 | | - |
| 13218 | + |
| 13070 | 13219 | e->skip = JimWideValue(skip); |
| 13071 | | - |
| 13220 | + |
| 13072 | 13221 | ExprPush(e, Jim_NewIntObj(interp, 0)); |
| 13073 | 13222 | break; |
| 13074 | 13223 | |
| 13075 | 13224 | case 1: |
| 13076 | | - |
| 13225 | + |
| 13077 | 13226 | break; |
| 13078 | 13227 | |
| 13079 | 13228 | case -1: |
| 13080 | | - |
| 13229 | + |
| 13081 | 13230 | rc = JIM_ERR; |
| 13082 | 13231 | break; |
| 13083 | 13232 | } |
| 13084 | 13233 | Jim_DecrRefCount(interp, A); |
| 13085 | 13234 | Jim_DecrRefCount(interp, skip); |
| | @@ -13091,15 +13240,15 @@ |
| 13091 | 13240 | { |
| 13092 | 13241 | Jim_Obj *skip = ExprPop(e); |
| 13093 | 13242 | Jim_Obj *B = ExprPop(e); |
| 13094 | 13243 | Jim_Obj *A = ExprPop(e); |
| 13095 | 13244 | |
| 13096 | | - |
| 13245 | + |
| 13097 | 13246 | if (ExprBool(interp, A)) { |
| 13098 | | - |
| 13247 | + |
| 13099 | 13248 | e->skip = JimWideValue(skip); |
| 13100 | | - |
| 13249 | + |
| 13101 | 13250 | ExprPush(e, B); |
| 13102 | 13251 | } |
| 13103 | 13252 | |
| 13104 | 13253 | Jim_DecrRefCount(interp, skip); |
| 13105 | 13254 | Jim_DecrRefCount(interp, A); |
| | @@ -13115,16 +13264,15 @@ |
| 13115 | 13264 | enum |
| 13116 | 13265 | { |
| 13117 | 13266 | LAZY_NONE, |
| 13118 | 13267 | LAZY_OP, |
| 13119 | 13268 | LAZY_LEFT, |
| 13120 | | - LAZY_RIGHT, |
| 13121 | | - RIGHT_ASSOC, |
| 13269 | + LAZY_RIGHT |
| 13122 | 13270 | }; |
| 13123 | 13271 | |
| 13124 | | -#define OPRINIT_ATTR(N, P, ARITY, F, ATTR) {N, F, P, ARITY, ATTR, sizeof(N) - 1} |
| 13125 | | -#define OPRINIT(N, P, ARITY, F) OPRINIT_ATTR(N, P, ARITY, F, LAZY_NONE) |
| 13272 | +#define OPRINIT(N, P, A, F) {N, F, P, A, LAZY_NONE, sizeof(N) - 1} |
| 13273 | +#define OPRINIT_LAZY(N, P, A, F, L) {N, F, P, A, L, sizeof(N) - 1} |
| 13126 | 13274 | |
| 13127 | 13275 | static const struct Jim_ExprOperator Jim_ExprOperators[] = { |
| 13128 | 13276 | OPRINIT("*", 110, 2, JimExprOpBin), |
| 13129 | 13277 | OPRINIT("/", 110, 2, JimExprOpBin), |
| 13130 | 13278 | OPRINIT("%", 110, 2, JimExprOpIntBin), |
| | @@ -13148,28 +13296,27 @@ |
| 13148 | 13296 | |
| 13149 | 13297 | OPRINIT("&", 50, 2, JimExprOpIntBin), |
| 13150 | 13298 | OPRINIT("^", 49, 2, JimExprOpIntBin), |
| 13151 | 13299 | OPRINIT("|", 48, 2, JimExprOpIntBin), |
| 13152 | 13300 | |
| 13153 | | - OPRINIT_ATTR("&&", 10, 2, NULL, LAZY_OP), |
| 13154 | | - OPRINIT_ATTR(NULL, 10, 2, JimExprOpAndLeft, LAZY_LEFT), |
| 13155 | | - OPRINIT_ATTR(NULL, 10, 2, JimExprOpAndOrRight, LAZY_RIGHT), |
| 13156 | | - |
| 13157 | | - OPRINIT_ATTR("||", 9, 2, NULL, LAZY_OP), |
| 13158 | | - OPRINIT_ATTR(NULL, 9, 2, JimExprOpOrLeft, LAZY_LEFT), |
| 13159 | | - OPRINIT_ATTR(NULL, 9, 2, JimExprOpAndOrRight, LAZY_RIGHT), |
| 13160 | | - |
| 13161 | | - OPRINIT_ATTR("?", 5, 2, JimExprOpNull, LAZY_OP), |
| 13162 | | - OPRINIT_ATTR(NULL, 5, 2, JimExprOpTernaryLeft, LAZY_LEFT), |
| 13163 | | - OPRINIT_ATTR(NULL, 5, 2, JimExprOpNull, LAZY_RIGHT), |
| 13164 | | - |
| 13165 | | - OPRINIT_ATTR(":", 5, 2, JimExprOpNull, LAZY_OP), |
| 13166 | | - OPRINIT_ATTR(NULL, 5, 2, JimExprOpColonLeft, LAZY_LEFT), |
| 13167 | | - OPRINIT_ATTR(NULL, 5, 2, JimExprOpNull, LAZY_RIGHT), |
| 13168 | | - |
| 13169 | | - |
| 13170 | | - OPRINIT_ATTR("**", 120, 2, JimExprOpBin, RIGHT_ASSOC), |
| 13301 | + OPRINIT_LAZY("&&", 10, 2, NULL, LAZY_OP), |
| 13302 | + OPRINIT_LAZY(NULL, 10, 2, JimExprOpAndLeft, LAZY_LEFT), |
| 13303 | + OPRINIT_LAZY(NULL, 10, 2, JimExprOpAndOrRight, LAZY_RIGHT), |
| 13304 | + |
| 13305 | + OPRINIT_LAZY("||", 9, 2, NULL, LAZY_OP), |
| 13306 | + OPRINIT_LAZY(NULL, 9, 2, JimExprOpOrLeft, LAZY_LEFT), |
| 13307 | + OPRINIT_LAZY(NULL, 9, 2, JimExprOpAndOrRight, LAZY_RIGHT), |
| 13308 | + |
| 13309 | + OPRINIT_LAZY("?", 5, 2, JimExprOpNull, LAZY_OP), |
| 13310 | + OPRINIT_LAZY(NULL, 5, 2, JimExprOpTernaryLeft, LAZY_LEFT), |
| 13311 | + OPRINIT_LAZY(NULL, 5, 2, JimExprOpNull, LAZY_RIGHT), |
| 13312 | + |
| 13313 | + OPRINIT_LAZY(":", 5, 2, JimExprOpNull, LAZY_OP), |
| 13314 | + OPRINIT_LAZY(NULL, 5, 2, JimExprOpColonLeft, LAZY_LEFT), |
| 13315 | + OPRINIT_LAZY(NULL, 5, 2, JimExprOpNull, LAZY_RIGHT), |
| 13316 | + |
| 13317 | + OPRINIT("**", 250, 2, JimExprOpBin), |
| 13171 | 13318 | |
| 13172 | 13319 | OPRINIT("eq", 60, 2, JimExprOpStrBin), |
| 13173 | 13320 | OPRINIT("ne", 60, 2, JimExprOpStrBin), |
| 13174 | 13321 | |
| 13175 | 13322 | OPRINIT("in", 55, 2, JimExprOpStrBin), |
| | @@ -13195,11 +13342,10 @@ |
| 13195 | 13342 | OPRINIT("cos", 200, 1, JimExprOpDoubleUnary), |
| 13196 | 13343 | OPRINIT("tan", 200, 1, JimExprOpDoubleUnary), |
| 13197 | 13344 | OPRINIT("asin", 200, 1, JimExprOpDoubleUnary), |
| 13198 | 13345 | OPRINIT("acos", 200, 1, JimExprOpDoubleUnary), |
| 13199 | 13346 | OPRINIT("atan", 200, 1, JimExprOpDoubleUnary), |
| 13200 | | - OPRINIT("atan2", 200, 2, JimExprOpBin), |
| 13201 | 13347 | OPRINIT("sinh", 200, 1, JimExprOpDoubleUnary), |
| 13202 | 13348 | OPRINIT("cosh", 200, 1, JimExprOpDoubleUnary), |
| 13203 | 13349 | OPRINIT("tanh", 200, 1, JimExprOpDoubleUnary), |
| 13204 | 13350 | OPRINIT("ceil", 200, 1, JimExprOpDoubleUnary), |
| 13205 | 13351 | OPRINIT("floor", 200, 1, JimExprOpDoubleUnary), |
| | @@ -13206,12 +13352,10 @@ |
| 13206 | 13352 | OPRINIT("exp", 200, 1, JimExprOpDoubleUnary), |
| 13207 | 13353 | OPRINIT("log", 200, 1, JimExprOpDoubleUnary), |
| 13208 | 13354 | OPRINIT("log10", 200, 1, JimExprOpDoubleUnary), |
| 13209 | 13355 | OPRINIT("sqrt", 200, 1, JimExprOpDoubleUnary), |
| 13210 | 13356 | OPRINIT("pow", 200, 2, JimExprOpBin), |
| 13211 | | - OPRINIT("hypot", 200, 2, JimExprOpBin), |
| 13212 | | - OPRINIT("fmod", 200, 2, JimExprOpBin), |
| 13213 | 13357 | #endif |
| 13214 | 13358 | }; |
| 13215 | 13359 | #undef OPRINIT |
| 13216 | 13360 | #undef OPRINIT_LAZY |
| 13217 | 13361 | |
| | @@ -13218,20 +13362,20 @@ |
| 13218 | 13362 | #define JIM_EXPR_OPERATORS_NUM \ |
| 13219 | 13363 | (sizeof(Jim_ExprOperators)/sizeof(struct Jim_ExprOperator)) |
| 13220 | 13364 | |
| 13221 | 13365 | static int JimParseExpression(struct JimParserCtx *pc) |
| 13222 | 13366 | { |
| 13223 | | - |
| 13367 | + |
| 13224 | 13368 | while (isspace(UCHAR(*pc->p)) || (*(pc->p) == '\\' && *(pc->p + 1) == '\n')) { |
| 13225 | 13369 | if (*pc->p == '\n') { |
| 13226 | 13370 | pc->linenr++; |
| 13227 | 13371 | } |
| 13228 | 13372 | pc->p++; |
| 13229 | 13373 | pc->len--; |
| 13230 | 13374 | } |
| 13231 | 13375 | |
| 13232 | | - |
| 13376 | + |
| 13233 | 13377 | pc->tline = pc->linenr; |
| 13234 | 13378 | pc->tstart = pc->p; |
| 13235 | 13379 | |
| 13236 | 13380 | if (pc->len == 0) { |
| 13237 | 13381 | pc->tend = pc->p; |
| | @@ -13257,11 +13401,11 @@ |
| 13257 | 13401 | return JimParseCmd(pc); |
| 13258 | 13402 | case '$': |
| 13259 | 13403 | if (JimParseVar(pc) == JIM_ERR) |
| 13260 | 13404 | return JimParseExprOperator(pc); |
| 13261 | 13405 | else { |
| 13262 | | - |
| 13406 | + |
| 13263 | 13407 | if (pc->tt == JIM_TT_EXPRSUGAR) { |
| 13264 | 13408 | return JIM_ERR; |
| 13265 | 13409 | } |
| 13266 | 13410 | return JIM_OK; |
| 13267 | 13411 | } |
| | @@ -13286,18 +13430,10 @@ |
| 13286 | 13430 | case 'N': |
| 13287 | 13431 | case 'I': |
| 13288 | 13432 | case 'n': |
| 13289 | 13433 | case 'i': |
| 13290 | 13434 | if (JimParseExprIrrational(pc) == JIM_ERR) |
| 13291 | | - if (JimParseExprBoolean(pc) == JIM_ERR) |
| 13292 | | - return JimParseExprOperator(pc); |
| 13293 | | - break; |
| 13294 | | - case 't': |
| 13295 | | - case 'f': |
| 13296 | | - case 'o': |
| 13297 | | - case 'y': |
| 13298 | | - if (JimParseExprBoolean(pc) == JIM_ERR) |
| 13299 | 13435 | return JimParseExprOperator(pc); |
| 13300 | 13436 | break; |
| 13301 | 13437 | default: |
| 13302 | 13438 | return JimParseExprOperator(pc); |
| 13303 | 13439 | break; |
| | @@ -13307,21 +13443,21 @@ |
| 13307 | 13443 | |
| 13308 | 13444 | static int JimParseExprNumber(struct JimParserCtx *pc) |
| 13309 | 13445 | { |
| 13310 | 13446 | char *end; |
| 13311 | 13447 | |
| 13312 | | - |
| 13448 | + |
| 13313 | 13449 | pc->tt = JIM_TT_EXPR_INT; |
| 13314 | 13450 | |
| 13315 | 13451 | jim_strtoull(pc->p, (char **)&pc->p); |
| 13316 | | - |
| 13452 | + |
| 13317 | 13453 | if (strchr("eENnIi.", *pc->p) || pc->p == pc->tstart) { |
| 13318 | | - if (strtod(pc->tstart, &end)) { } |
| 13454 | + if (strtod(pc->tstart, &end)) { } |
| 13319 | 13455 | if (end == pc->tstart) |
| 13320 | 13456 | return JIM_ERR; |
| 13321 | 13457 | if (end > pc->p) { |
| 13322 | | - |
| 13458 | + |
| 13323 | 13459 | pc->tt = JIM_TT_EXPR_DOUBLE; |
| 13324 | 13460 | pc->p = end; |
| 13325 | 13461 | } |
| 13326 | 13462 | } |
| 13327 | 13463 | pc->tend = pc->p - 1; |
| | @@ -13346,37 +13482,16 @@ |
| 13346 | 13482 | } |
| 13347 | 13483 | } |
| 13348 | 13484 | return JIM_ERR; |
| 13349 | 13485 | } |
| 13350 | 13486 | |
| 13351 | | -static int JimParseExprBoolean(struct JimParserCtx *pc) |
| 13352 | | -{ |
| 13353 | | - const char *booleans[] = { "false", "no", "off", "true", "yes", "on", NULL }; |
| 13354 | | - const int lengths[] = { 5, 2, 3, 4, 3, 2, 0 }; |
| 13355 | | - int i; |
| 13356 | | - |
| 13357 | | - for (i = 0; booleans[i]; i++) { |
| 13358 | | - const char *boolean = booleans[i]; |
| 13359 | | - int length = lengths[i]; |
| 13360 | | - |
| 13361 | | - if (strncmp(boolean, pc->p, length) == 0) { |
| 13362 | | - pc->p += length; |
| 13363 | | - pc->len -= length; |
| 13364 | | - pc->tend = pc->p - 1; |
| 13365 | | - pc->tt = JIM_TT_EXPR_BOOLEAN; |
| 13366 | | - return JIM_OK; |
| 13367 | | - } |
| 13368 | | - } |
| 13369 | | - return JIM_ERR; |
| 13370 | | -} |
| 13371 | | - |
| 13372 | 13487 | static int JimParseExprOperator(struct JimParserCtx *pc) |
| 13373 | 13488 | { |
| 13374 | 13489 | int i; |
| 13375 | 13490 | int bestIdx = -1, bestLen = 0; |
| 13376 | 13491 | |
| 13377 | | - |
| 13492 | + |
| 13378 | 13493 | for (i = 0; i < (signed)JIM_EXPR_OPERATORS_NUM; i++) { |
| 13379 | 13494 | const char * const opname = Jim_ExprOperators[i].name; |
| 13380 | 13495 | const int oplen = Jim_ExprOperators[i].namelen; |
| 13381 | 13496 | |
| 13382 | 13497 | if (opname == NULL || opname[0] != pc->p[0]) { |
| | @@ -13390,11 +13505,11 @@ |
| 13390 | 13505 | } |
| 13391 | 13506 | if (bestIdx == -1) { |
| 13392 | 13507 | return JIM_ERR; |
| 13393 | 13508 | } |
| 13394 | 13509 | |
| 13395 | | - |
| 13510 | + |
| 13396 | 13511 | if (bestIdx >= JIM_EXPROP_FUNC_FIRST) { |
| 13397 | 13512 | const char *p = pc->p + bestLen; |
| 13398 | 13513 | int len = pc->len - bestLen; |
| 13399 | 13514 | |
| 13400 | 13515 | while (len && isspace(UCHAR(*p))) { |
| | @@ -13424,20 +13539,14 @@ |
| 13424 | 13539 | |
| 13425 | 13540 | const char *jim_tt_name(int type) |
| 13426 | 13541 | { |
| 13427 | 13542 | static const char * const tt_names[JIM_TT_EXPR_OP] = |
| 13428 | 13543 | { "NIL", "STR", "ESC", "VAR", "ARY", "CMD", "SEP", "EOL", "EOF", "LIN", "WRD", "(((", ")))", ",,,", "INT", |
| 13429 | | - "DBL", "BOO", "$()" }; |
| 13544 | + "DBL", "$()" }; |
| 13430 | 13545 | if (type < JIM_TT_EXPR_OP) { |
| 13431 | 13546 | return tt_names[type]; |
| 13432 | 13547 | } |
| 13433 | | - else if (type == JIM_EXPROP_UNARYMINUS) { |
| 13434 | | - return "-VE"; |
| 13435 | | - } |
| 13436 | | - else if (type == JIM_EXPROP_UNARYPLUS) { |
| 13437 | | - return "+VE"; |
| 13438 | | - } |
| 13439 | 13548 | else { |
| 13440 | 13549 | const struct Jim_ExprOperator *op = JimExprOperatorInfoByOpcode(type); |
| 13441 | 13550 | static char buf[20]; |
| 13442 | 13551 | |
| 13443 | 13552 | if (op->name) { |
| | @@ -13461,13 +13570,13 @@ |
| 13461 | 13570 | }; |
| 13462 | 13571 | |
| 13463 | 13572 | |
| 13464 | 13573 | typedef struct ExprByteCode |
| 13465 | 13574 | { |
| 13466 | | - ScriptToken *token; |
| 13467 | | - int len; |
| 13468 | | - int inUse; |
| 13575 | + ScriptToken *token; |
| 13576 | + int len; |
| 13577 | + int inUse; |
| 13469 | 13578 | } ExprByteCode; |
| 13470 | 13579 | |
| 13471 | 13580 | static void ExprFreeByteCode(Jim_Interp *interp, ExprByteCode * expr) |
| 13472 | 13581 | { |
| 13473 | 13582 | int i; |
| | @@ -13495,29 +13604,26 @@ |
| 13495 | 13604 | static void DupExprInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr) |
| 13496 | 13605 | { |
| 13497 | 13606 | JIM_NOTUSED(interp); |
| 13498 | 13607 | JIM_NOTUSED(srcPtr); |
| 13499 | 13608 | |
| 13500 | | - |
| 13609 | + |
| 13501 | 13610 | dupPtr->typePtr = NULL; |
| 13502 | 13611 | } |
| 13503 | 13612 | |
| 13504 | | -static int ExprCheckCorrectness(Jim_Interp *interp, Jim_Obj *exprObjPtr, ExprByteCode * expr) |
| 13613 | + |
| 13614 | +static int ExprCheckCorrectness(ExprByteCode * expr) |
| 13505 | 13615 | { |
| 13506 | 13616 | int i; |
| 13507 | 13617 | int stacklen = 0; |
| 13508 | 13618 | int ternary = 0; |
| 13509 | | - int lasttt = JIM_TT_NONE; |
| 13510 | | - const char *errmsg; |
| 13511 | 13619 | |
| 13512 | 13620 | for (i = 0; i < expr->len; i++) { |
| 13513 | 13621 | ScriptToken *t = &expr->token[i]; |
| 13514 | 13622 | const struct Jim_ExprOperator *op = JimExprOperatorInfoByOpcode(t->type); |
| 13515 | | - lasttt = t->type; |
| 13516 | 13623 | |
| 13517 | 13624 | stacklen -= op->arity; |
| 13518 | | - |
| 13519 | 13625 | if (stacklen < 0) { |
| 13520 | 13626 | break; |
| 13521 | 13627 | } |
| 13522 | 13628 | if (t->type == JIM_EXPROP_TERNARY || t->type == JIM_EXPROP_TERNARY_LEFT) { |
| 13523 | 13629 | ternary++; |
| | @@ -13524,47 +13630,26 @@ |
| 13524 | 13630 | } |
| 13525 | 13631 | else if (t->type == JIM_EXPROP_COLON || t->type == JIM_EXPROP_COLON_LEFT) { |
| 13526 | 13632 | ternary--; |
| 13527 | 13633 | } |
| 13528 | 13634 | |
| 13529 | | - |
| 13635 | + |
| 13530 | 13636 | stacklen++; |
| 13531 | 13637 | } |
| 13532 | | - if (stacklen == 1 && ternary == 0) { |
| 13533 | | - return JIM_OK; |
| 13534 | | - } |
| 13535 | | - |
| 13536 | | - if (stacklen <= 0) { |
| 13537 | | - |
| 13538 | | - if (lasttt >= JIM_EXPROP_FUNC_FIRST) { |
| 13539 | | - errmsg = "too few arguments for math function"; |
| 13540 | | - Jim_SetResultString(interp, "too few arguments for math function", -1); |
| 13541 | | - } else { |
| 13542 | | - errmsg = "premature end of expression"; |
| 13543 | | - } |
| 13544 | | - } |
| 13545 | | - else if (stacklen > 1) { |
| 13546 | | - if (lasttt >= JIM_EXPROP_FUNC_FIRST) { |
| 13547 | | - errmsg = "too many arguments for math function"; |
| 13548 | | - } else { |
| 13549 | | - errmsg = "extra tokens at end of expression"; |
| 13550 | | - } |
| 13551 | | - } |
| 13552 | | - else { |
| 13553 | | - errmsg = "invalid ternary expression"; |
| 13554 | | - } |
| 13555 | | - Jim_SetResultFormatted(interp, "syntax error in expression \"%#s\": %s", exprObjPtr, errmsg); |
| 13556 | | - return JIM_ERR; |
| 13638 | + if (stacklen != 1 || ternary != 0) { |
| 13639 | + return JIM_ERR; |
| 13640 | + } |
| 13641 | + return JIM_OK; |
| 13557 | 13642 | } |
| 13558 | 13643 | |
| 13559 | 13644 | static int ExprAddLazyOperator(Jim_Interp *interp, ExprByteCode * expr, ParseToken *t) |
| 13560 | 13645 | { |
| 13561 | 13646 | int i; |
| 13562 | 13647 | |
| 13563 | 13648 | int leftindex, arity, offset; |
| 13564 | 13649 | |
| 13565 | | - |
| 13650 | + |
| 13566 | 13651 | leftindex = expr->len - 1; |
| 13567 | 13652 | |
| 13568 | 13653 | arity = 1; |
| 13569 | 13654 | while (arity) { |
| 13570 | 13655 | ScriptToken *tt = &expr->token[leftindex]; |
| | @@ -13577,11 +13662,11 @@ |
| 13577 | 13662 | return JIM_ERR; |
| 13578 | 13663 | } |
| 13579 | 13664 | } |
| 13580 | 13665 | leftindex++; |
| 13581 | 13666 | |
| 13582 | | - |
| 13667 | + |
| 13583 | 13668 | memmove(&expr->token[leftindex + 2], &expr->token[leftindex], |
| 13584 | 13669 | sizeof(*expr->token) * (expr->len - leftindex)); |
| 13585 | 13670 | expr->len += 2; |
| 13586 | 13671 | offset = (expr->len - leftindex) - 1; |
| 13587 | 13672 | |
| | @@ -13589,16 +13674,16 @@ |
| 13589 | 13674 | expr->token[leftindex + 1].objPtr = interp->emptyObj; |
| 13590 | 13675 | |
| 13591 | 13676 | expr->token[leftindex].type = JIM_TT_EXPR_INT; |
| 13592 | 13677 | expr->token[leftindex].objPtr = Jim_NewIntObj(interp, offset); |
| 13593 | 13678 | |
| 13594 | | - |
| 13679 | + |
| 13595 | 13680 | expr->token[expr->len].objPtr = interp->emptyObj; |
| 13596 | 13681 | expr->token[expr->len].type = t->type + 2; |
| 13597 | 13682 | expr->len++; |
| 13598 | 13683 | |
| 13599 | | - |
| 13684 | + |
| 13600 | 13685 | for (i = leftindex - 1; i > 0; i--) { |
| 13601 | 13686 | const struct Jim_ExprOperator *op = JimExprOperatorInfoByOpcode(expr->token[i].type); |
| 13602 | 13687 | if (op->lazy == LAZY_LEFT) { |
| 13603 | 13688 | if (JimWideValue(expr->token[i - 1].objPtr) + i - 1 >= leftindex) { |
| 13604 | 13689 | JimWideValue(expr->token[i - 1].objPtr) += 2; |
| | @@ -13644,11 +13729,11 @@ |
| 13644 | 13729 | return right_index; |
| 13645 | 13730 | } |
| 13646 | 13731 | right_index--; |
| 13647 | 13732 | } |
| 13648 | 13733 | |
| 13649 | | - |
| 13734 | + |
| 13650 | 13735 | return -1; |
| 13651 | 13736 | } |
| 13652 | 13737 | |
| 13653 | 13738 | static int ExprTernaryGetMoveIndices(ExprByteCode *expr, int right_index, int *prev_right_index, int *prev_left_index) |
| 13654 | 13739 | { |
| | @@ -13686,11 +13771,11 @@ |
| 13686 | 13771 | |
| 13687 | 13772 | if (expr->token[i].type != JIM_EXPROP_COLON_RIGHT) { |
| 13688 | 13773 | continue; |
| 13689 | 13774 | } |
| 13690 | 13775 | |
| 13691 | | - |
| 13776 | + |
| 13692 | 13777 | if (ExprTernaryGetMoveIndices(expr, i, &prev_right_index, &prev_left_index) == 0) { |
| 13693 | 13778 | continue; |
| 13694 | 13779 | } |
| 13695 | 13780 | |
| 13696 | 13781 | tmp = expr->token[prev_right_index]; |
| | @@ -13699,25 +13784,25 @@ |
| 13699 | 13784 | } |
| 13700 | 13785 | expr->token[i] = tmp; |
| 13701 | 13786 | |
| 13702 | 13787 | JimWideValue(expr->token[prev_left_index-1].objPtr) += (i - prev_right_index); |
| 13703 | 13788 | |
| 13704 | | - |
| 13789 | + |
| 13705 | 13790 | i++; |
| 13706 | 13791 | } |
| 13707 | 13792 | } |
| 13708 | 13793 | |
| 13709 | | -static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList *tokenlist, Jim_Obj *exprObjPtr, Jim_Obj *fileNameObj) |
| 13794 | +static ExprByteCode *ExprCreateByteCode(Jim_Interp *interp, const ParseTokenList *tokenlist, Jim_Obj *fileNameObj) |
| 13710 | 13795 | { |
| 13711 | 13796 | Jim_Stack stack; |
| 13712 | 13797 | ExprByteCode *expr; |
| 13713 | 13798 | int ok = 1; |
| 13714 | 13799 | int i; |
| 13715 | 13800 | int prevtt = JIM_TT_NONE; |
| 13716 | 13801 | int have_ternary = 0; |
| 13717 | 13802 | |
| 13718 | | - |
| 13803 | + |
| 13719 | 13804 | int count = tokenlist->count - 1; |
| 13720 | 13805 | |
| 13721 | 13806 | expr = Jim_Alloc(sizeof(*expr)); |
| 13722 | 13807 | expr->inUse = 1; |
| 13723 | 13808 | expr->len = 0; |
| | @@ -13728,11 +13813,11 @@ |
| 13728 | 13813 | ParseToken *t = &tokenlist->list[i]; |
| 13729 | 13814 | const struct Jim_ExprOperator *op = JimExprOperatorInfoByOpcode(t->type); |
| 13730 | 13815 | |
| 13731 | 13816 | if (op->lazy == LAZY_OP) { |
| 13732 | 13817 | count += 2; |
| 13733 | | - |
| 13818 | + |
| 13734 | 13819 | if (t->type == JIM_EXPROP_TERNARY) { |
| 13735 | 13820 | have_ternary = 1; |
| 13736 | 13821 | } |
| 13737 | 13822 | } |
| 13738 | 13823 | } |
| | @@ -13740,128 +13825,128 @@ |
| 13740 | 13825 | expr->token = Jim_Alloc(sizeof(ScriptToken) * count); |
| 13741 | 13826 | |
| 13742 | 13827 | for (i = 0; i < tokenlist->count && ok; i++) { |
| 13743 | 13828 | ParseToken *t = &tokenlist->list[i]; |
| 13744 | 13829 | |
| 13745 | | - |
| 13830 | + |
| 13746 | 13831 | struct ScriptToken *token = &expr->token[expr->len]; |
| 13747 | 13832 | |
| 13748 | 13833 | if (t->type == JIM_TT_EOL) { |
| 13749 | 13834 | break; |
| 13750 | 13835 | } |
| 13751 | 13836 | |
| 13752 | | - if (TOKEN_IS_EXPR_OP(t->type)) { |
| 13753 | | - const struct Jim_ExprOperator *op; |
| 13754 | | - ParseToken *tt; |
| 13755 | | - |
| 13756 | | - |
| 13757 | | - if (prevtt == JIM_TT_NONE || prevtt == JIM_TT_SUBEXPR_START || prevtt == JIM_TT_SUBEXPR_COMMA || prevtt >= JIM_TT_EXPR_OP) { |
| 13758 | | - if (t->type == JIM_EXPROP_SUB) { |
| 13759 | | - t->type = JIM_EXPROP_UNARYMINUS; |
| 13760 | | - } |
| 13761 | | - else if (t->type == JIM_EXPROP_ADD) { |
| 13762 | | - t->type = JIM_EXPROP_UNARYPLUS; |
| 13763 | | - } |
| 13764 | | - } |
| 13765 | | - |
| 13766 | | - op = JimExprOperatorInfoByOpcode(t->type); |
| 13767 | | - |
| 13768 | | - |
| 13769 | | - while ((tt = Jim_StackPeek(&stack)) != NULL) { |
| 13770 | | - const struct Jim_ExprOperator *tt_op = |
| 13771 | | - JimExprOperatorInfoByOpcode(tt->type); |
| 13772 | | - |
| 13773 | | - |
| 13774 | | - if (op->arity != 1 && tt_op->precedence >= op->precedence) { |
| 13775 | | - |
| 13776 | | - if (tt_op->precedence == op->precedence && tt_op->lazy == RIGHT_ASSOC) { |
| 13777 | | - break; |
| 13778 | | - } |
| 13779 | | - if (ExprAddOperator(interp, expr, tt) != JIM_OK) { |
| 13780 | | - ok = 0; |
| 13781 | | - goto err; |
| 13782 | | - } |
| 13783 | | - Jim_StackPop(&stack); |
| 13784 | | - } |
| 13785 | | - else { |
| 13786 | | - break; |
| 13787 | | - } |
| 13788 | | - } |
| 13789 | | - Jim_StackPush(&stack, t); |
| 13790 | | - } |
| 13791 | | - else if (t->type == JIM_TT_SUBEXPR_START) { |
| 13792 | | - Jim_StackPush(&stack, t); |
| 13793 | | - } |
| 13794 | | - else if (t->type == JIM_TT_SUBEXPR_END || t->type == JIM_TT_SUBEXPR_COMMA) { |
| 13795 | | - |
| 13796 | | - ok = 0; |
| 13797 | | - while (Jim_StackLen(&stack)) { |
| 13798 | | - ParseToken *tt = Jim_StackPop(&stack); |
| 13799 | | - |
| 13800 | | - if (tt->type == JIM_TT_SUBEXPR_START || tt->type == JIM_TT_SUBEXPR_COMMA) { |
| 13801 | | - if (t->type == JIM_TT_SUBEXPR_COMMA) { |
| 13802 | | - |
| 13803 | | - Jim_StackPush(&stack, tt); |
| 13804 | | - } |
| 13805 | | - ok = 1; |
| 13806 | | - break; |
| 13807 | | - } |
| 13808 | | - if (ExprAddOperator(interp, expr, tt) != JIM_OK) { |
| 13809 | | - goto err; |
| 13810 | | - } |
| 13811 | | - } |
| 13812 | | - if (!ok) { |
| 13813 | | - Jim_SetResultFormatted(interp, "Unexpected close parenthesis in expression: \"%#s\"", exprObjPtr); |
| 13814 | | - goto err; |
| 13815 | | - } |
| 13816 | | - } |
| 13817 | | - else { |
| 13818 | | - Jim_Obj *objPtr = NULL; |
| 13819 | | - |
| 13820 | | - |
| 13821 | | - token->type = t->type; |
| 13822 | | - |
| 13823 | | - |
| 13824 | | - if (!TOKEN_IS_EXPR_START(prevtt) && !TOKEN_IS_EXPR_OP(prevtt)) { |
| 13825 | | - Jim_SetResultFormatted(interp, "missing operator in expression: \"%#s\"", exprObjPtr); |
| 13826 | | - ok = 0; |
| 13827 | | - goto err; |
| 13828 | | - } |
| 13829 | | - |
| 13830 | | - |
| 13831 | | - if (t->type == JIM_TT_EXPR_INT || t->type == JIM_TT_EXPR_DOUBLE) { |
| 13832 | | - char *endptr; |
| 13833 | | - if (t->type == JIM_TT_EXPR_INT) { |
| 13834 | | - objPtr = Jim_NewIntObj(interp, jim_strtoull(t->token, &endptr)); |
| 13835 | | - } |
| 13836 | | - else { |
| 13837 | | - objPtr = Jim_NewDoubleObj(interp, strtod(t->token, &endptr)); |
| 13838 | | - } |
| 13839 | | - if (endptr != t->token + t->len) { |
| 13840 | | - |
| 13841 | | - Jim_FreeNewObj(interp, objPtr); |
| 13842 | | - objPtr = NULL; |
| 13843 | | - } |
| 13844 | | - } |
| 13845 | | - |
| 13846 | | - if (objPtr) { |
| 13847 | | - token->objPtr = objPtr; |
| 13848 | | - } |
| 13849 | | - else { |
| 13850 | | - |
| 13851 | | - token->objPtr = Jim_NewStringObj(interp, t->token, t->len); |
| 13852 | | - if (t->type == JIM_TT_CMD) { |
| 13853 | | - |
| 13854 | | - JimSetSourceInfo(interp, token->objPtr, fileNameObj, t->line); |
| 13855 | | - } |
| 13856 | | - } |
| 13857 | | - expr->len++; |
| 13837 | + switch (t->type) { |
| 13838 | + case JIM_TT_STR: |
| 13839 | + case JIM_TT_ESC: |
| 13840 | + case JIM_TT_VAR: |
| 13841 | + case JIM_TT_DICTSUGAR: |
| 13842 | + case JIM_TT_EXPRSUGAR: |
| 13843 | + case JIM_TT_CMD: |
| 13844 | + token->type = t->type; |
| 13845 | +strexpr: |
| 13846 | + token->objPtr = Jim_NewStringObj(interp, t->token, t->len); |
| 13847 | + if (t->type == JIM_TT_CMD) { |
| 13848 | + |
| 13849 | + JimSetSourceInfo(interp, token->objPtr, fileNameObj, t->line); |
| 13850 | + } |
| 13851 | + expr->len++; |
| 13852 | + break; |
| 13853 | + |
| 13854 | + case JIM_TT_EXPR_INT: |
| 13855 | + case JIM_TT_EXPR_DOUBLE: |
| 13856 | + { |
| 13857 | + char *endptr; |
| 13858 | + if (t->type == JIM_TT_EXPR_INT) { |
| 13859 | + token->objPtr = Jim_NewIntObj(interp, jim_strtoull(t->token, &endptr)); |
| 13860 | + } |
| 13861 | + else { |
| 13862 | + token->objPtr = Jim_NewDoubleObj(interp, strtod(t->token, &endptr)); |
| 13863 | + } |
| 13864 | + if (endptr != t->token + t->len) { |
| 13865 | + |
| 13866 | + Jim_FreeNewObj(interp, token->objPtr); |
| 13867 | + token->type = JIM_TT_STR; |
| 13868 | + goto strexpr; |
| 13869 | + } |
| 13870 | + token->type = t->type; |
| 13871 | + expr->len++; |
| 13872 | + } |
| 13873 | + break; |
| 13874 | + |
| 13875 | + case JIM_TT_SUBEXPR_START: |
| 13876 | + Jim_StackPush(&stack, t); |
| 13877 | + prevtt = JIM_TT_NONE; |
| 13878 | + continue; |
| 13879 | + |
| 13880 | + case JIM_TT_SUBEXPR_COMMA: |
| 13881 | + |
| 13882 | + continue; |
| 13883 | + |
| 13884 | + case JIM_TT_SUBEXPR_END: |
| 13885 | + ok = 0; |
| 13886 | + while (Jim_StackLen(&stack)) { |
| 13887 | + ParseToken *tt = Jim_StackPop(&stack); |
| 13888 | + |
| 13889 | + if (tt->type == JIM_TT_SUBEXPR_START) { |
| 13890 | + ok = 1; |
| 13891 | + break; |
| 13892 | + } |
| 13893 | + |
| 13894 | + if (ExprAddOperator(interp, expr, tt) != JIM_OK) { |
| 13895 | + goto err; |
| 13896 | + } |
| 13897 | + } |
| 13898 | + if (!ok) { |
| 13899 | + Jim_SetResultString(interp, "Unexpected close parenthesis", -1); |
| 13900 | + goto err; |
| 13901 | + } |
| 13902 | + break; |
| 13903 | + |
| 13904 | + |
| 13905 | + default:{ |
| 13906 | + |
| 13907 | + const struct Jim_ExprOperator *op; |
| 13908 | + ParseToken *tt; |
| 13909 | + |
| 13910 | + |
| 13911 | + if (prevtt == JIM_TT_NONE || prevtt >= JIM_TT_EXPR_OP) { |
| 13912 | + if (t->type == JIM_EXPROP_SUB) { |
| 13913 | + t->type = JIM_EXPROP_UNARYMINUS; |
| 13914 | + } |
| 13915 | + else if (t->type == JIM_EXPROP_ADD) { |
| 13916 | + t->type = JIM_EXPROP_UNARYPLUS; |
| 13917 | + } |
| 13918 | + } |
| 13919 | + |
| 13920 | + op = JimExprOperatorInfoByOpcode(t->type); |
| 13921 | + |
| 13922 | + |
| 13923 | + while ((tt = Jim_StackPeek(&stack)) != NULL) { |
| 13924 | + const struct Jim_ExprOperator *tt_op = |
| 13925 | + JimExprOperatorInfoByOpcode(tt->type); |
| 13926 | + |
| 13927 | + |
| 13928 | + |
| 13929 | + if (op->arity != 1 && tt_op->precedence >= op->precedence) { |
| 13930 | + if (ExprAddOperator(interp, expr, tt) != JIM_OK) { |
| 13931 | + ok = 0; |
| 13932 | + goto err; |
| 13933 | + } |
| 13934 | + Jim_StackPop(&stack); |
| 13935 | + } |
| 13936 | + else { |
| 13937 | + break; |
| 13938 | + } |
| 13939 | + } |
| 13940 | + Jim_StackPush(&stack, t); |
| 13941 | + break; |
| 13942 | + } |
| 13858 | 13943 | } |
| 13859 | 13944 | prevtt = t->type; |
| 13860 | 13945 | } |
| 13861 | 13946 | |
| 13862 | | - |
| 13947 | + |
| 13863 | 13948 | while (Jim_StackLen(&stack)) { |
| 13864 | 13949 | ParseToken *tt = Jim_StackPop(&stack); |
| 13865 | 13950 | |
| 13866 | 13951 | if (tt->type == JIM_TT_SUBEXPR_START) { |
| 13867 | 13952 | ok = 0; |
| | @@ -13877,11 +13962,11 @@ |
| 13877 | 13962 | if (have_ternary) { |
| 13878 | 13963 | ExprTernaryReorderExpression(interp, expr); |
| 13879 | 13964 | } |
| 13880 | 13965 | |
| 13881 | 13966 | err: |
| 13882 | | - |
| 13967 | + |
| 13883 | 13968 | Jim_FreeStack(&stack); |
| 13884 | 13969 | |
| 13885 | 13970 | for (i = 0; i < expr->len; i++) { |
| 13886 | 13971 | Jim_IncrRefCount(expr->token[i].objPtr); |
| 13887 | 13972 | } |
| | @@ -13904,11 +13989,11 @@ |
| 13904 | 13989 | ParseTokenList tokenlist; |
| 13905 | 13990 | int line; |
| 13906 | 13991 | Jim_Obj *fileNameObj; |
| 13907 | 13992 | int rc = JIM_ERR; |
| 13908 | 13993 | |
| 13909 | | - |
| 13994 | + |
| 13910 | 13995 | if (objPtr->typePtr == &sourceObjType) { |
| 13911 | 13996 | fileNameObj = objPtr->internalRep.sourceValue.fileNameObj; |
| 13912 | 13997 | line = objPtr->internalRep.sourceValue.lineNumber; |
| 13913 | 13998 | } |
| 13914 | 13999 | else { |
| | @@ -13917,17 +14002,18 @@ |
| 13917 | 14002 | } |
| 13918 | 14003 | Jim_IncrRefCount(fileNameObj); |
| 13919 | 14004 | |
| 13920 | 14005 | exprText = Jim_GetString(objPtr, &exprTextLen); |
| 13921 | 14006 | |
| 13922 | | - |
| 14007 | + |
| 13923 | 14008 | ScriptTokenListInit(&tokenlist); |
| 13924 | 14009 | |
| 13925 | 14010 | JimParserInit(&parser, exprText, exprTextLen, line); |
| 13926 | 14011 | while (!parser.eof) { |
| 13927 | 14012 | if (JimParseExpression(&parser) != JIM_OK) { |
| 13928 | 14013 | ScriptTokenListFree(&tokenlist); |
| 14014 | + invalidexpr: |
| 13929 | 14015 | Jim_SetResultFormatted(interp, "syntax error in expression: \"%#s\"", objPtr); |
| 13930 | 14016 | expr = NULL; |
| 13931 | 14017 | goto err; |
| 13932 | 14018 | } |
| 13933 | 14019 | |
| | @@ -13950,14 +14036,14 @@ |
| 13950 | 14036 | ScriptTokenListFree(&tokenlist); |
| 13951 | 14037 | Jim_DecrRefCount(interp, fileNameObj); |
| 13952 | 14038 | return JIM_ERR; |
| 13953 | 14039 | } |
| 13954 | 14040 | |
| 14041 | + |
| 14042 | + expr = ExprCreateByteCode(interp, &tokenlist, fileNameObj); |
| 13955 | 14043 | |
| 13956 | | - expr = ExprCreateByteCode(interp, &tokenlist, objPtr, fileNameObj); |
| 13957 | | - |
| 13958 | | - |
| 14044 | + |
| 13959 | 14045 | ScriptTokenListFree(&tokenlist); |
| 13960 | 14046 | |
| 13961 | 14047 | if (!expr) { |
| 13962 | 14048 | goto err; |
| 13963 | 14049 | } |
| | @@ -13973,22 +14059,20 @@ |
| 13973 | 14059 | printf("[%2d] %s '%s'\n", i, jim_tt_name(t->type), Jim_String(t->objPtr)); |
| 13974 | 14060 | } |
| 13975 | 14061 | } |
| 13976 | 14062 | #endif |
| 13977 | 14063 | |
| 13978 | | - |
| 13979 | | - if (ExprCheckCorrectness(interp, objPtr, expr) != JIM_OK) { |
| 13980 | | - |
| 14064 | + |
| 14065 | + if (ExprCheckCorrectness(expr) != JIM_OK) { |
| 13981 | 14066 | ExprFreeByteCode(interp, expr); |
| 13982 | | - expr = NULL; |
| 13983 | | - goto err; |
| 14067 | + goto invalidexpr; |
| 13984 | 14068 | } |
| 13985 | 14069 | |
| 13986 | 14070 | rc = JIM_OK; |
| 13987 | 14071 | |
| 13988 | 14072 | err: |
| 13989 | | - |
| 14073 | + |
| 13990 | 14074 | Jim_DecrRefCount(interp, fileNameObj); |
| 13991 | 14075 | Jim_FreeIntRep(interp, objPtr); |
| 13992 | 14076 | Jim_SetIntRepPtr(objPtr, expr); |
| 13993 | 14077 | objPtr->typePtr = &exprObjType; |
| 13994 | 14078 | return rc; |
| | @@ -14028,11 +14112,11 @@ |
| 14028 | 14112 | int retcode = JIM_OK; |
| 14029 | 14113 | struct JimExprState e; |
| 14030 | 14114 | |
| 14031 | 14115 | expr = JimGetExpression(interp, exprObjPtr); |
| 14032 | 14116 | if (!expr) { |
| 14033 | | - return JIM_ERR; |
| 14117 | + return JIM_ERR; |
| 14034 | 14118 | } |
| 14035 | 14119 | |
| 14036 | 14120 | #ifdef JIM_OPTIMIZATION |
| 14037 | 14121 | { |
| 14038 | 14122 | Jim_Obj *objPtr; |
| | @@ -14101,27 +14185,26 @@ |
| 14101 | 14185 | noopt: |
| 14102 | 14186 | #endif |
| 14103 | 14187 | |
| 14104 | 14188 | expr->inUse++; |
| 14105 | 14189 | |
| 14106 | | - |
| 14190 | + |
| 14107 | 14191 | |
| 14108 | 14192 | if (expr->len > JIM_EE_STATICSTACK_LEN) |
| 14109 | 14193 | e.stack = Jim_Alloc(sizeof(Jim_Obj *) * expr->len); |
| 14110 | 14194 | else |
| 14111 | 14195 | e.stack = staticStack; |
| 14112 | 14196 | |
| 14113 | 14197 | e.stacklen = 0; |
| 14114 | 14198 | |
| 14115 | | - |
| 14199 | + |
| 14116 | 14200 | for (i = 0; i < expr->len && retcode == JIM_OK; i++) { |
| 14117 | 14201 | Jim_Obj *objPtr; |
| 14118 | 14202 | |
| 14119 | 14203 | switch (expr->token[i].type) { |
| 14120 | 14204 | case JIM_TT_EXPR_INT: |
| 14121 | 14205 | case JIM_TT_EXPR_DOUBLE: |
| 14122 | | - case JIM_TT_EXPR_BOOLEAN: |
| 14123 | 14206 | case JIM_TT_STR: |
| 14124 | 14207 | ExprPush(&e, expr->token[i].objPtr); |
| 14125 | 14208 | break; |
| 14126 | 14209 | |
| 14127 | 14210 | case JIM_TT_VAR: |
| | @@ -14157,16 +14240,16 @@ |
| 14157 | 14240 | ExprPush(&e, Jim_GetResult(interp)); |
| 14158 | 14241 | } |
| 14159 | 14242 | break; |
| 14160 | 14243 | |
| 14161 | 14244 | default:{ |
| 14162 | | - |
| 14245 | + |
| 14163 | 14246 | e.skip = 0; |
| 14164 | 14247 | e.opcode = expr->token[i].type; |
| 14165 | 14248 | |
| 14166 | 14249 | retcode = JimExprOperatorInfoByOpcode(e.opcode)->funcop(interp, &e); |
| 14167 | | - |
| 14250 | + |
| 14168 | 14251 | i += e.skip; |
| 14169 | 14252 | continue; |
| 14170 | 14253 | } |
| 14171 | 14254 | } |
| 14172 | 14255 | } |
| | @@ -14190,27 +14273,20 @@ |
| 14190 | 14273 | int Jim_GetBoolFromExpr(Jim_Interp *interp, Jim_Obj *exprObjPtr, int *boolPtr) |
| 14191 | 14274 | { |
| 14192 | 14275 | int retcode; |
| 14193 | 14276 | jim_wide wideValue; |
| 14194 | 14277 | double doubleValue; |
| 14195 | | - int booleanValue; |
| 14196 | 14278 | Jim_Obj *exprResultPtr; |
| 14197 | 14279 | |
| 14198 | 14280 | retcode = Jim_EvalExpression(interp, exprObjPtr, &exprResultPtr); |
| 14199 | 14281 | if (retcode != JIM_OK) |
| 14200 | 14282 | return retcode; |
| 14201 | 14283 | |
| 14202 | 14284 | if (JimGetWideNoErr(interp, exprResultPtr, &wideValue) != JIM_OK) { |
| 14203 | 14285 | if (Jim_GetDouble(interp, exprResultPtr, &doubleValue) != JIM_OK) { |
| 14204 | | - if (Jim_GetBoolean(interp, exprResultPtr, &booleanValue) != JIM_OK) { |
| 14205 | | - Jim_DecrRefCount(interp, exprResultPtr); |
| 14206 | | - return JIM_ERR; |
| 14207 | | - } else { |
| 14208 | | - Jim_DecrRefCount(interp, exprResultPtr); |
| 14209 | | - *boolPtr = booleanValue; |
| 14210 | | - return JIM_OK; |
| 14211 | | - } |
| 14286 | + Jim_DecrRefCount(interp, exprResultPtr); |
| 14287 | + return JIM_ERR; |
| 14212 | 14288 | } |
| 14213 | 14289 | else { |
| 14214 | 14290 | Jim_DecrRefCount(interp, exprResultPtr); |
| 14215 | 14291 | *boolPtr = doubleValue != 0; |
| 14216 | 14292 | return JIM_OK; |
| | @@ -14225,29 +14301,29 @@ |
| 14225 | 14301 | |
| 14226 | 14302 | |
| 14227 | 14303 | |
| 14228 | 14304 | typedef struct ScanFmtPartDescr |
| 14229 | 14305 | { |
| 14230 | | - char *arg; |
| 14231 | | - char *prefix; |
| 14232 | | - size_t width; |
| 14233 | | - int pos; |
| 14234 | | - char type; |
| 14235 | | - char modifier; |
| 14306 | + char *arg; |
| 14307 | + char *prefix; |
| 14308 | + size_t width; |
| 14309 | + int pos; |
| 14310 | + char type; |
| 14311 | + char modifier; |
| 14236 | 14312 | } ScanFmtPartDescr; |
| 14237 | 14313 | |
| 14238 | 14314 | |
| 14239 | 14315 | typedef struct ScanFmtStringObj |
| 14240 | 14316 | { |
| 14241 | | - jim_wide size; |
| 14242 | | - char *stringRep; |
| 14243 | | - size_t count; |
| 14244 | | - size_t convCount; |
| 14245 | | - size_t maxPos; |
| 14246 | | - const char *error; |
| 14247 | | - char *scratch; |
| 14248 | | - ScanFmtPartDescr descr[1]; |
| 14317 | + jim_wide size; |
| 14318 | + char *stringRep; |
| 14319 | + size_t count; |
| 14320 | + size_t convCount; |
| 14321 | + size_t maxPos; |
| 14322 | + const char *error; |
| 14323 | + char *scratch; |
| 14324 | + ScanFmtPartDescr descr[1]; |
| 14249 | 14325 | } ScanFmtStringObj; |
| 14250 | 14326 | |
| 14251 | 14327 | |
| 14252 | 14328 | static void FreeScanFmtInternalRep(Jim_Interp *interp, Jim_Obj *objPtr); |
| 14253 | 14329 | static void DupScanFmtInternalRep(Jim_Interp *interp, Jim_Obj *srcPtr, Jim_Obj *dupPtr); |
| | @@ -14294,22 +14370,22 @@ |
| 14294 | 14370 | int maxFmtLen = objPtr->length; |
| 14295 | 14371 | const char *fmtEnd = fmt + maxFmtLen; |
| 14296 | 14372 | int curr; |
| 14297 | 14373 | |
| 14298 | 14374 | Jim_FreeIntRep(interp, objPtr); |
| 14299 | | - |
| 14375 | + |
| 14300 | 14376 | for (i = 0, maxCount = 0; i < maxFmtLen; ++i) |
| 14301 | 14377 | if (fmt[i] == '%') |
| 14302 | 14378 | ++maxCount; |
| 14303 | | - |
| 14304 | | - approxSize = sizeof(ScanFmtStringObj) |
| 14305 | | - +(maxCount + 1) * sizeof(ScanFmtPartDescr) |
| 14306 | | - +maxFmtLen * sizeof(char) + 3 + 1 |
| 14307 | | - + maxFmtLen * sizeof(char) + 1 |
| 14308 | | - + maxFmtLen * sizeof(char) |
| 14309 | | - +(maxCount + 1) * sizeof(char) |
| 14310 | | - +1; |
| 14379 | + |
| 14380 | + approxSize = sizeof(ScanFmtStringObj) |
| 14381 | + +(maxCount + 1) * sizeof(ScanFmtPartDescr) |
| 14382 | + +maxFmtLen * sizeof(char) + 3 + 1 |
| 14383 | + + maxFmtLen * sizeof(char) + 1 |
| 14384 | + + maxFmtLen * sizeof(char) |
| 14385 | + +(maxCount + 1) * sizeof(char) |
| 14386 | + +1; |
| 14311 | 14387 | fmtObj = (ScanFmtStringObj *) Jim_Alloc(approxSize); |
| 14312 | 14388 | memset(fmtObj, 0, approxSize); |
| 14313 | 14389 | fmtObj->size = approxSize; |
| 14314 | 14390 | fmtObj->maxPos = 0; |
| 14315 | 14391 | fmtObj->scratch = (char *)&fmtObj->descr[maxCount + 1]; |
| | @@ -14321,12 +14397,12 @@ |
| 14321 | 14397 | for (i = 0, curr = 0; fmt < fmtEnd; ++fmt) { |
| 14322 | 14398 | int width = 0, skip; |
| 14323 | 14399 | ScanFmtPartDescr *descr = &fmtObj->descr[curr]; |
| 14324 | 14400 | |
| 14325 | 14401 | fmtObj->count++; |
| 14326 | | - descr->width = 0; |
| 14327 | | - |
| 14402 | + descr->width = 0; |
| 14403 | + |
| 14328 | 14404 | if (*fmt != '%' || fmt[1] == '%') { |
| 14329 | 14405 | descr->type = 0; |
| 14330 | 14406 | descr->prefix = &buffer[i]; |
| 14331 | 14407 | for (; fmt < fmtEnd; ++fmt) { |
| 14332 | 14408 | if (*fmt == '%') { |
| | @@ -14336,65 +14412,65 @@ |
| 14336 | 14412 | } |
| 14337 | 14413 | buffer[i++] = *fmt; |
| 14338 | 14414 | } |
| 14339 | 14415 | buffer[i++] = 0; |
| 14340 | 14416 | } |
| 14341 | | - |
| 14417 | + |
| 14342 | 14418 | ++fmt; |
| 14343 | | - |
| 14419 | + |
| 14344 | 14420 | if (fmt >= fmtEnd) |
| 14345 | 14421 | goto done; |
| 14346 | | - descr->pos = 0; |
| 14422 | + descr->pos = 0; |
| 14347 | 14423 | if (*fmt == '*') { |
| 14348 | | - descr->pos = -1; |
| 14424 | + descr->pos = -1; |
| 14349 | 14425 | ++fmt; |
| 14350 | 14426 | } |
| 14351 | 14427 | else |
| 14352 | | - fmtObj->convCount++; |
| 14353 | | - |
| 14428 | + fmtObj->convCount++; |
| 14429 | + |
| 14354 | 14430 | if (sscanf(fmt, "%d%n", &width, &skip) == 1) { |
| 14355 | 14431 | fmt += skip; |
| 14356 | | - |
| 14432 | + |
| 14357 | 14433 | if (descr->pos != -1 && *fmt == '$') { |
| 14358 | 14434 | int prev; |
| 14359 | 14435 | |
| 14360 | 14436 | ++fmt; |
| 14361 | 14437 | descr->pos = width; |
| 14362 | 14438 | width = 0; |
| 14363 | | - |
| 14439 | + |
| 14364 | 14440 | if ((lastPos == 0 && descr->pos > 0) |
| 14365 | 14441 | || (lastPos > 0 && descr->pos == 0)) { |
| 14366 | 14442 | fmtObj->error = "cannot mix \"%\" and \"%n$\" conversion specifiers"; |
| 14367 | 14443 | return JIM_ERR; |
| 14368 | 14444 | } |
| 14369 | | - |
| 14445 | + |
| 14370 | 14446 | for (prev = 0; prev < curr; ++prev) { |
| 14371 | 14447 | if (fmtObj->descr[prev].pos == -1) |
| 14372 | 14448 | continue; |
| 14373 | 14449 | if (fmtObj->descr[prev].pos == descr->pos) { |
| 14374 | 14450 | fmtObj->error = |
| 14375 | 14451 | "variable is assigned by multiple \"%n$\" conversion specifiers"; |
| 14376 | 14452 | return JIM_ERR; |
| 14377 | 14453 | } |
| 14378 | 14454 | } |
| 14379 | | - |
| 14455 | + |
| 14380 | 14456 | if (sscanf(fmt, "%d%n", &width, &skip) == 1) { |
| 14381 | 14457 | descr->width = width; |
| 14382 | 14458 | fmt += skip; |
| 14383 | 14459 | } |
| 14384 | 14460 | if (descr->pos > 0 && (size_t) descr->pos > fmtObj->maxPos) |
| 14385 | 14461 | fmtObj->maxPos = descr->pos; |
| 14386 | 14462 | } |
| 14387 | 14463 | else { |
| 14388 | | - |
| 14464 | + |
| 14389 | 14465 | descr->width = width; |
| 14390 | 14466 | } |
| 14391 | 14467 | } |
| 14392 | | - |
| 14468 | + |
| 14393 | 14469 | if (lastPos == -1) |
| 14394 | 14470 | lastPos = descr->pos; |
| 14395 | | - |
| 14471 | + |
| 14396 | 14472 | if (*fmt == '[') { |
| 14397 | 14473 | int swapped = 1, beg = i, end, j; |
| 14398 | 14474 | |
| 14399 | 14475 | descr->type = '['; |
| 14400 | 14476 | descr->arg = &buffer[i]; |
| | @@ -14409,11 +14485,11 @@ |
| 14409 | 14485 | fmtObj->error = "unmatched [ in format string"; |
| 14410 | 14486 | return JIM_ERR; |
| 14411 | 14487 | } |
| 14412 | 14488 | end = i; |
| 14413 | 14489 | buffer[i++] = 0; |
| 14414 | | - |
| 14490 | + |
| 14415 | 14491 | while (swapped) { |
| 14416 | 14492 | swapped = 0; |
| 14417 | 14493 | for (j = beg + 1; j < end - 1; ++j) { |
| 14418 | 14494 | if (buffer[j] == '-' && buffer[j - 1] > buffer[j + 1]) { |
| 14419 | 14495 | char tmp = buffer[j - 1]; |
| | @@ -14424,11 +14500,11 @@ |
| 14424 | 14500 | } |
| 14425 | 14501 | } |
| 14426 | 14502 | } |
| 14427 | 14503 | } |
| 14428 | 14504 | else { |
| 14429 | | - |
| 14505 | + |
| 14430 | 14506 | if (strchr("hlL", *fmt) != 0) |
| 14431 | 14507 | descr->modifier = tolower((int)*fmt++); |
| 14432 | 14508 | |
| 14433 | 14509 | descr->type = *fmt; |
| 14434 | 14510 | if (strchr("efgcsndoxui", *fmt) == 0) { |
| | @@ -14467,11 +14543,11 @@ |
| 14467 | 14543 | while (*str) { |
| 14468 | 14544 | int c; |
| 14469 | 14545 | int n; |
| 14470 | 14546 | |
| 14471 | 14547 | if (!sdescr && isspace(UCHAR(*str))) |
| 14472 | | - break; |
| 14548 | + break; |
| 14473 | 14549 | |
| 14474 | 14550 | n = utf8_tounicode(str, &c); |
| 14475 | 14551 | if (sdescr && !JimCharsetMatch(sdescr, c, JIM_CHARSET_SCAN)) |
| 14476 | 14552 | break; |
| 14477 | 14553 | while (n--) |
| | @@ -14490,89 +14566,89 @@ |
| 14490 | 14566 | size_t scanned = 0; |
| 14491 | 14567 | size_t anchor = pos; |
| 14492 | 14568 | int i; |
| 14493 | 14569 | Jim_Obj *tmpObj = NULL; |
| 14494 | 14570 | |
| 14495 | | - |
| 14571 | + |
| 14496 | 14572 | *valObjPtr = 0; |
| 14497 | 14573 | if (descr->prefix) { |
| 14498 | 14574 | for (i = 0; pos < strLen && descr->prefix[i]; ++i) { |
| 14499 | | - |
| 14575 | + |
| 14500 | 14576 | if (isspace(UCHAR(descr->prefix[i]))) |
| 14501 | 14577 | while (pos < strLen && isspace(UCHAR(str[pos]))) |
| 14502 | 14578 | ++pos; |
| 14503 | 14579 | else if (descr->prefix[i] != str[pos]) |
| 14504 | | - break; |
| 14580 | + break; |
| 14505 | 14581 | else |
| 14506 | | - ++pos; |
| 14582 | + ++pos; |
| 14507 | 14583 | } |
| 14508 | 14584 | if (pos >= strLen) { |
| 14509 | | - return -1; |
| 14585 | + return -1; |
| 14510 | 14586 | } |
| 14511 | 14587 | else if (descr->prefix[i] != 0) |
| 14512 | | - return 0; |
| 14588 | + return 0; |
| 14513 | 14589 | } |
| 14514 | | - |
| 14590 | + |
| 14515 | 14591 | if (descr->type != 'c' && descr->type != '[' && descr->type != 'n') |
| 14516 | 14592 | while (isspace(UCHAR(str[pos]))) |
| 14517 | 14593 | ++pos; |
| 14518 | | - |
| 14594 | + |
| 14519 | 14595 | scanned = pos - anchor; |
| 14520 | 14596 | |
| 14521 | | - |
| 14597 | + |
| 14522 | 14598 | if (descr->type == 'n') { |
| 14523 | | - |
| 14599 | + |
| 14524 | 14600 | *valObjPtr = Jim_NewIntObj(interp, anchor + scanned); |
| 14525 | 14601 | } |
| 14526 | 14602 | else if (pos >= strLen) { |
| 14527 | | - |
| 14603 | + |
| 14528 | 14604 | return -1; |
| 14529 | 14605 | } |
| 14530 | 14606 | else if (descr->type == 'c') { |
| 14531 | 14607 | int c; |
| 14532 | 14608 | scanned += utf8_tounicode(&str[pos], &c); |
| 14533 | 14609 | *valObjPtr = Jim_NewIntObj(interp, c); |
| 14534 | 14610 | return scanned; |
| 14535 | 14611 | } |
| 14536 | 14612 | else { |
| 14537 | | - |
| 14613 | + |
| 14538 | 14614 | if (descr->width > 0) { |
| 14539 | 14615 | size_t sLen = utf8_strlen(&str[pos], strLen - pos); |
| 14540 | 14616 | size_t tLen = descr->width > sLen ? sLen : descr->width; |
| 14541 | 14617 | |
| 14542 | 14618 | tmpObj = Jim_NewStringObjUtf8(interp, str + pos, tLen); |
| 14543 | 14619 | tok = tmpObj->bytes; |
| 14544 | 14620 | } |
| 14545 | 14621 | else { |
| 14546 | | - |
| 14622 | + |
| 14547 | 14623 | tok = &str[pos]; |
| 14548 | 14624 | } |
| 14549 | 14625 | switch (descr->type) { |
| 14550 | 14626 | case 'd': |
| 14551 | 14627 | case 'o': |
| 14552 | 14628 | case 'x': |
| 14553 | 14629 | case 'u': |
| 14554 | 14630 | case 'i':{ |
| 14555 | | - char *endp; |
| 14631 | + char *endp; |
| 14556 | 14632 | jim_wide w; |
| 14557 | 14633 | |
| 14558 | 14634 | int base = descr->type == 'o' ? 8 |
| 14559 | 14635 | : descr->type == 'x' ? 16 : descr->type == 'i' ? 0 : 10; |
| 14560 | 14636 | |
| 14561 | | - |
| 14637 | + |
| 14562 | 14638 | if (base == 0) { |
| 14563 | 14639 | w = jim_strtoull(tok, &endp); |
| 14564 | 14640 | } |
| 14565 | 14641 | else { |
| 14566 | 14642 | w = strtoull(tok, &endp, base); |
| 14567 | 14643 | } |
| 14568 | 14644 | |
| 14569 | 14645 | if (endp != tok) { |
| 14570 | | - |
| 14646 | + |
| 14571 | 14647 | *valObjPtr = Jim_NewIntObj(interp, w); |
| 14572 | 14648 | |
| 14573 | | - |
| 14649 | + |
| 14574 | 14650 | scanned += endp - tok; |
| 14575 | 14651 | } |
| 14576 | 14652 | else { |
| 14577 | 14653 | scanned = *tok ? 0 : -1; |
| 14578 | 14654 | } |
| | @@ -14589,13 +14665,13 @@ |
| 14589 | 14665 | case 'g':{ |
| 14590 | 14666 | char *endp; |
| 14591 | 14667 | double value = strtod(tok, &endp); |
| 14592 | 14668 | |
| 14593 | 14669 | if (endp != tok) { |
| 14594 | | - |
| 14670 | + |
| 14595 | 14671 | *valObjPtr = Jim_NewDoubleObj(interp, value); |
| 14596 | | - |
| 14672 | + |
| 14597 | 14673 | scanned += endp - tok; |
| 14598 | 14674 | } |
| 14599 | 14675 | else { |
| 14600 | 14676 | scanned = *tok ? 0 : -1; |
| 14601 | 14677 | } |
| | @@ -14620,65 +14696,65 @@ |
| 14620 | 14696 | Jim_Obj **resultVec = 0; |
| 14621 | 14697 | int resultc; |
| 14622 | 14698 | Jim_Obj *emptyStr = 0; |
| 14623 | 14699 | ScanFmtStringObj *fmtObj; |
| 14624 | 14700 | |
| 14625 | | - |
| 14701 | + |
| 14626 | 14702 | JimPanic((fmtObjPtr->typePtr != &scanFmtStringObjType, "Jim_ScanString() for non-scan format")); |
| 14627 | 14703 | |
| 14628 | 14704 | fmtObj = (ScanFmtStringObj *) fmtObjPtr->internalRep.ptr; |
| 14629 | | - |
| 14705 | + |
| 14630 | 14706 | if (fmtObj->error != 0) { |
| 14631 | 14707 | if (flags & JIM_ERRMSG) |
| 14632 | 14708 | Jim_SetResultString(interp, fmtObj->error, -1); |
| 14633 | 14709 | return 0; |
| 14634 | 14710 | } |
| 14635 | | - |
| 14711 | + |
| 14636 | 14712 | emptyStr = Jim_NewEmptyStringObj(interp); |
| 14637 | 14713 | Jim_IncrRefCount(emptyStr); |
| 14638 | | - |
| 14714 | + |
| 14639 | 14715 | resultList = Jim_NewListObj(interp, NULL, 0); |
| 14640 | 14716 | if (fmtObj->maxPos > 0) { |
| 14641 | 14717 | for (i = 0; i < fmtObj->maxPos; ++i) |
| 14642 | 14718 | Jim_ListAppendElement(interp, resultList, emptyStr); |
| 14643 | 14719 | JimListGetElements(interp, resultList, &resultc, &resultVec); |
| 14644 | 14720 | } |
| 14645 | | - |
| 14721 | + |
| 14646 | 14722 | for (i = 0, pos = 0; i < fmtObj->count; ++i) { |
| 14647 | 14723 | ScanFmtPartDescr *descr = &(fmtObj->descr[i]); |
| 14648 | 14724 | Jim_Obj *value = 0; |
| 14649 | 14725 | |
| 14650 | | - |
| 14726 | + |
| 14651 | 14727 | if (descr->type == 0) |
| 14652 | 14728 | continue; |
| 14653 | | - |
| 14729 | + |
| 14654 | 14730 | if (scanned > 0) |
| 14655 | 14731 | scanned = ScanOneEntry(interp, str, pos, strLen, fmtObj, i, &value); |
| 14656 | | - |
| 14732 | + |
| 14657 | 14733 | if (scanned == -1 && i == 0) |
| 14658 | 14734 | goto eof; |
| 14659 | | - |
| 14735 | + |
| 14660 | 14736 | pos += scanned; |
| 14661 | 14737 | |
| 14662 | | - |
| 14738 | + |
| 14663 | 14739 | if (value == 0) |
| 14664 | 14740 | value = Jim_NewEmptyStringObj(interp); |
| 14665 | | - |
| 14741 | + |
| 14666 | 14742 | if (descr->pos == -1) { |
| 14667 | 14743 | Jim_FreeNewObj(interp, value); |
| 14668 | 14744 | } |
| 14669 | 14745 | else if (descr->pos == 0) |
| 14670 | | - |
| 14746 | + |
| 14671 | 14747 | Jim_ListAppendElement(interp, resultList, value); |
| 14672 | 14748 | else if (resultVec[descr->pos - 1] == emptyStr) { |
| 14673 | | - |
| 14749 | + |
| 14674 | 14750 | Jim_DecrRefCount(interp, resultVec[descr->pos - 1]); |
| 14675 | 14751 | Jim_IncrRefCount(value); |
| 14676 | 14752 | resultVec[descr->pos - 1] = value; |
| 14677 | 14753 | } |
| 14678 | 14754 | else { |
| 14679 | | - |
| 14755 | + |
| 14680 | 14756 | Jim_FreeNewObj(interp, value); |
| 14681 | 14757 | goto err; |
| 14682 | 14758 | } |
| 14683 | 14759 | } |
| 14684 | 14760 | Jim_DecrRefCount(interp, emptyStr); |
| | @@ -14716,15 +14792,15 @@ |
| 14716 | 14792 | { |
| 14717 | 14793 | Jim_PrngState *prng; |
| 14718 | 14794 | unsigned char *destByte = (unsigned char *)dest; |
| 14719 | 14795 | unsigned int si, sj, x; |
| 14720 | 14796 | |
| 14721 | | - |
| 14797 | + |
| 14722 | 14798 | if (interp->prngState == NULL) |
| 14723 | 14799 | JimPrngInit(interp); |
| 14724 | 14800 | prng = interp->prngState; |
| 14725 | | - |
| 14801 | + |
| 14726 | 14802 | for (x = 0; x < len; x++) { |
| 14727 | 14803 | prng->i = (prng->i + 1) & 0xff; |
| 14728 | 14804 | si = prng->sbox[prng->i]; |
| 14729 | 14805 | prng->j = (prng->j + si) & 0xff; |
| 14730 | 14806 | sj = prng->sbox[prng->j]; |
| | @@ -14738,19 +14814,19 @@ |
| 14738 | 14814 | static void JimPrngSeed(Jim_Interp *interp, unsigned char *seed, int seedLen) |
| 14739 | 14815 | { |
| 14740 | 14816 | int i; |
| 14741 | 14817 | Jim_PrngState *prng; |
| 14742 | 14818 | |
| 14743 | | - |
| 14819 | + |
| 14744 | 14820 | if (interp->prngState == NULL) |
| 14745 | 14821 | JimPrngInit(interp); |
| 14746 | 14822 | prng = interp->prngState; |
| 14747 | 14823 | |
| 14748 | | - |
| 14824 | + |
| 14749 | 14825 | for (i = 0; i < 256; i++) |
| 14750 | 14826 | prng->sbox[i] = i; |
| 14751 | | - |
| 14827 | + |
| 14752 | 14828 | for (i = 0; i < seedLen; i++) { |
| 14753 | 14829 | unsigned char t; |
| 14754 | 14830 | |
| 14755 | 14831 | t = prng->sbox[i & 0xFF]; |
| 14756 | 14832 | prng->sbox[i & 0xFF] = prng->sbox[seed[i]]; |
| | @@ -14777,11 +14853,11 @@ |
| 14777 | 14853 | if (Jim_GetWide(interp, argv[2], &increment) != JIM_OK) |
| 14778 | 14854 | return JIM_ERR; |
| 14779 | 14855 | } |
| 14780 | 14856 | intObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED); |
| 14781 | 14857 | if (!intObjPtr) { |
| 14782 | | - |
| 14858 | + |
| 14783 | 14859 | wideValue = 0; |
| 14784 | 14860 | } |
| 14785 | 14861 | else if (Jim_GetWide(interp, intObjPtr, &wideValue) != JIM_OK) { |
| 14786 | 14862 | return JIM_ERR; |
| 14787 | 14863 | } |
| | @@ -14791,26 +14867,26 @@ |
| 14791 | 14867 | Jim_FreeNewObj(interp, intObjPtr); |
| 14792 | 14868 | return JIM_ERR; |
| 14793 | 14869 | } |
| 14794 | 14870 | } |
| 14795 | 14871 | else { |
| 14796 | | - |
| 14872 | + |
| 14797 | 14873 | Jim_InvalidateStringRep(intObjPtr); |
| 14798 | 14874 | JimWideValue(intObjPtr) = wideValue + increment; |
| 14799 | 14875 | |
| 14800 | 14876 | if (argv[1]->typePtr != &variableObjType) { |
| 14801 | | - |
| 14877 | + |
| 14802 | 14878 | Jim_SetVariable(interp, argv[1], intObjPtr); |
| 14803 | 14879 | } |
| 14804 | 14880 | } |
| 14805 | 14881 | Jim_SetResult(interp, intObjPtr); |
| 14806 | 14882 | return JIM_OK; |
| 14807 | 14883 | } |
| 14808 | 14884 | |
| 14809 | 14885 | |
| 14810 | | -#define JIM_EVAL_SARGV_LEN 8 |
| 14811 | | -#define JIM_EVAL_SINTV_LEN 8 |
| 14886 | +#define JIM_EVAL_SARGV_LEN 8 |
| 14887 | +#define JIM_EVAL_SINTV_LEN 8 |
| 14812 | 14888 | |
| 14813 | 14889 | |
| 14814 | 14890 | static int JimUnknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 14815 | 14891 | { |
| 14816 | 14892 | int retcode; |
| | @@ -14818,16 +14894,16 @@ |
| 14818 | 14894 | if (interp->unknown_called > 50) { |
| 14819 | 14895 | return JIM_ERR; |
| 14820 | 14896 | } |
| 14821 | 14897 | |
| 14822 | 14898 | |
| 14823 | | - |
| 14899 | + |
| 14824 | 14900 | if (Jim_GetCommand(interp, interp->unknown, JIM_NONE) == NULL) |
| 14825 | 14901 | return JIM_ERR; |
| 14826 | 14902 | |
| 14827 | 14903 | interp->unknown_called++; |
| 14828 | | - |
| 14904 | + |
| 14829 | 14905 | retcode = Jim_EvalObjPrefix(interp, interp->unknown, argc, argv); |
| 14830 | 14906 | interp->unknown_called--; |
| 14831 | 14907 | |
| 14832 | 14908 | return retcode; |
| 14833 | 14909 | } |
| | @@ -14845,11 +14921,11 @@ |
| 14845 | 14921 | } |
| 14846 | 14922 | printf("\n"); |
| 14847 | 14923 | #endif |
| 14848 | 14924 | |
| 14849 | 14925 | if (interp->framePtr->tailcallCmd) { |
| 14850 | | - |
| 14926 | + |
| 14851 | 14927 | cmdPtr = interp->framePtr->tailcallCmd; |
| 14852 | 14928 | interp->framePtr->tailcallCmd = NULL; |
| 14853 | 14929 | } |
| 14854 | 14930 | else { |
| 14855 | 14931 | cmdPtr = Jim_GetCommand(interp, objv[0], JIM_ERRMSG); |
| | @@ -14864,11 +14940,11 @@ |
| 14864 | 14940 | retcode = JIM_ERR; |
| 14865 | 14941 | goto out; |
| 14866 | 14942 | } |
| 14867 | 14943 | interp->evalDepth++; |
| 14868 | 14944 | |
| 14869 | | - |
| 14945 | + |
| 14870 | 14946 | Jim_SetEmptyResult(interp); |
| 14871 | 14947 | if (cmdPtr->isproc) { |
| 14872 | 14948 | retcode = JimCallProcedure(interp, cmdPtr, objc, objv); |
| 14873 | 14949 | } |
| 14874 | 14950 | else { |
| | @@ -14885,17 +14961,17 @@ |
| 14885 | 14961 | |
| 14886 | 14962 | int Jim_EvalObjVector(Jim_Interp *interp, int objc, Jim_Obj *const *objv) |
| 14887 | 14963 | { |
| 14888 | 14964 | int i, retcode; |
| 14889 | 14965 | |
| 14890 | | - |
| 14966 | + |
| 14891 | 14967 | for (i = 0; i < objc; i++) |
| 14892 | 14968 | Jim_IncrRefCount(objv[i]); |
| 14893 | 14969 | |
| 14894 | 14970 | retcode = JimInvokeCommand(interp, objc, objv); |
| 14895 | 14971 | |
| 14896 | | - |
| 14972 | + |
| 14897 | 14973 | for (i = 0; i < objc; i++) |
| 14898 | 14974 | Jim_DecrRefCount(interp, objv[i]); |
| 14899 | 14975 | |
| 14900 | 14976 | return retcode; |
| 14901 | 14977 | } |
| | @@ -14913,25 +14989,25 @@ |
| 14913 | 14989 | } |
| 14914 | 14990 | |
| 14915 | 14991 | static void JimAddErrorToStack(Jim_Interp *interp, ScriptObj *script) |
| 14916 | 14992 | { |
| 14917 | 14993 | if (!interp->errorFlag) { |
| 14918 | | - |
| 14994 | + |
| 14919 | 14995 | interp->errorFlag = 1; |
| 14920 | 14996 | Jim_IncrRefCount(script->fileNameObj); |
| 14921 | 14997 | Jim_DecrRefCount(interp, interp->errorFileNameObj); |
| 14922 | 14998 | interp->errorFileNameObj = script->fileNameObj; |
| 14923 | 14999 | interp->errorLine = script->linenr; |
| 14924 | 15000 | |
| 14925 | 15001 | JimResetStackTrace(interp); |
| 14926 | | - |
| 15002 | + |
| 14927 | 15003 | interp->addStackTrace++; |
| 14928 | 15004 | } |
| 14929 | 15005 | |
| 14930 | | - |
| 15006 | + |
| 14931 | 15007 | if (interp->addStackTrace > 0) { |
| 14932 | | - |
| 15008 | + |
| 14933 | 15009 | |
| 14934 | 15010 | JimAppendStackTrace(interp, Jim_String(interp->errorProc), script->fileNameObj, script->linenr); |
| 14935 | 15011 | |
| 14936 | 15012 | if (Jim_Length(script->fileNameObj)) { |
| 14937 | 15013 | interp->addStackTrace = 0; |
| | @@ -14966,14 +15042,14 @@ |
| 14966 | 15042 | case JIM_OK: |
| 14967 | 15043 | case JIM_RETURN: |
| 14968 | 15044 | objPtr = interp->result; |
| 14969 | 15045 | break; |
| 14970 | 15046 | case JIM_BREAK: |
| 14971 | | - |
| 15047 | + |
| 14972 | 15048 | return JIM_BREAK; |
| 14973 | 15049 | case JIM_CONTINUE: |
| 14974 | | - |
| 15050 | + |
| 14975 | 15051 | return JIM_CONTINUE; |
| 14976 | 15052 | default: |
| 14977 | 15053 | return JIM_ERR; |
| 14978 | 15054 | } |
| 14979 | 15055 | break; |
| | @@ -15008,23 +15084,23 @@ |
| 15008 | 15084 | case JIM_OK: |
| 15009 | 15085 | case JIM_RETURN: |
| 15010 | 15086 | break; |
| 15011 | 15087 | case JIM_BREAK: |
| 15012 | 15088 | if (flags & JIM_SUBST_FLAG) { |
| 15013 | | - |
| 15089 | + |
| 15014 | 15090 | tokens = i; |
| 15015 | 15091 | continue; |
| 15016 | 15092 | } |
| 15017 | | - |
| 15018 | | - |
| 15093 | + |
| 15094 | + |
| 15019 | 15095 | case JIM_CONTINUE: |
| 15020 | 15096 | if (flags & JIM_SUBST_FLAG) { |
| 15021 | 15097 | intv[i] = NULL; |
| 15022 | 15098 | continue; |
| 15023 | 15099 | } |
| 15024 | | - |
| 15025 | | - |
| 15100 | + |
| 15101 | + |
| 15026 | 15102 | default: |
| 15027 | 15103 | while (i--) { |
| 15028 | 15104 | Jim_DecrRefCount(interp, intv[i]); |
| 15029 | 15105 | } |
| 15030 | 15106 | if (intv != sintv) { |
| | @@ -15035,28 +15111,28 @@ |
| 15035 | 15111 | Jim_IncrRefCount(intv[i]); |
| 15036 | 15112 | Jim_String(intv[i]); |
| 15037 | 15113 | totlen += intv[i]->length; |
| 15038 | 15114 | } |
| 15039 | 15115 | |
| 15040 | | - |
| 15116 | + |
| 15041 | 15117 | if (tokens == 1 && intv[0] && intv == sintv) { |
| 15042 | 15118 | Jim_DecrRefCount(interp, intv[0]); |
| 15043 | 15119 | return intv[0]; |
| 15044 | 15120 | } |
| 15045 | 15121 | |
| 15046 | 15122 | objPtr = Jim_NewStringObjNoAlloc(interp, NULL, 0); |
| 15047 | 15123 | |
| 15048 | 15124 | if (tokens == 4 && token[0].type == JIM_TT_ESC && token[1].type == JIM_TT_ESC |
| 15049 | 15125 | && token[2].type == JIM_TT_VAR) { |
| 15050 | | - |
| 15126 | + |
| 15051 | 15127 | objPtr->typePtr = &interpolatedObjType; |
| 15052 | 15128 | objPtr->internalRep.dictSubstValue.varNameObjPtr = token[0].objPtr; |
| 15053 | 15129 | objPtr->internalRep.dictSubstValue.indexObjPtr = intv[2]; |
| 15054 | 15130 | Jim_IncrRefCount(intv[2]); |
| 15055 | 15131 | } |
| 15056 | 15132 | else if (tokens && intv[0] && intv[0]->typePtr == &sourceObjType) { |
| 15057 | | - |
| 15133 | + |
| 15058 | 15134 | JimSetSourceInfo(interp, objPtr, intv[0]->internalRep.sourceValue.fileNameObj, intv[0]->internalRep.sourceValue.lineNumber); |
| 15059 | 15135 | } |
| 15060 | 15136 | |
| 15061 | 15137 | |
| 15062 | 15138 | s = objPtr->bytes = Jim_Alloc(totlen + 1); |
| | @@ -15067,11 +15143,11 @@ |
| 15067 | 15143 | s += intv[i]->length; |
| 15068 | 15144 | Jim_DecrRefCount(interp, intv[i]); |
| 15069 | 15145 | } |
| 15070 | 15146 | } |
| 15071 | 15147 | objPtr->bytes[totlen] = '\0'; |
| 15072 | | - |
| 15148 | + |
| 15073 | 15149 | if (intv != sintv) { |
| 15074 | 15150 | Jim_Free(intv); |
| 15075 | 15151 | } |
| 15076 | 15152 | |
| 15077 | 15153 | return objPtr; |
| | @@ -15111,11 +15187,11 @@ |
| 15111 | 15187 | |
| 15112 | 15188 | if (Jim_IsList(scriptObjPtr) && scriptObjPtr->bytes == NULL) { |
| 15113 | 15189 | return JimEvalObjList(interp, scriptObjPtr); |
| 15114 | 15190 | } |
| 15115 | 15191 | |
| 15116 | | - Jim_IncrRefCount(scriptObjPtr); |
| 15192 | + Jim_IncrRefCount(scriptObjPtr); |
| 15117 | 15193 | script = JimGetScript(interp, scriptObjPtr); |
| 15118 | 15194 | if (!JimScriptValid(interp, script)) { |
| 15119 | 15195 | Jim_DecrRefCount(interp, scriptObjPtr); |
| 15120 | 15196 | return JIM_ERR; |
| 15121 | 15197 | } |
| | @@ -15147,11 +15223,11 @@ |
| 15147 | 15223 | } |
| 15148 | 15224 | #endif |
| 15149 | 15225 | |
| 15150 | 15226 | script->inUse++; |
| 15151 | 15227 | |
| 15152 | | - |
| 15228 | + |
| 15153 | 15229 | prevScriptObj = interp->currentScriptObj; |
| 15154 | 15230 | interp->currentScriptObj = scriptObjPtr; |
| 15155 | 15231 | |
| 15156 | 15232 | interp->errorFlag = 0; |
| 15157 | 15233 | argv = sargv; |
| | @@ -15158,19 +15234,19 @@ |
| 15158 | 15234 | |
| 15159 | 15235 | for (i = 0; i < script->len && retcode == JIM_OK; ) { |
| 15160 | 15236 | int argc; |
| 15161 | 15237 | int j; |
| 15162 | 15238 | |
| 15163 | | - |
| 15239 | + |
| 15164 | 15240 | argc = token[i].objPtr->internalRep.scriptLineValue.argc; |
| 15165 | 15241 | script->linenr = token[i].objPtr->internalRep.scriptLineValue.line; |
| 15166 | 15242 | |
| 15167 | | - |
| 15243 | + |
| 15168 | 15244 | if (argc > JIM_EVAL_SARGV_LEN) |
| 15169 | 15245 | argv = Jim_Alloc(sizeof(Jim_Obj *) * argc); |
| 15170 | 15246 | |
| 15171 | | - |
| 15247 | + |
| 15172 | 15248 | i++; |
| 15173 | 15249 | |
| 15174 | 15250 | for (j = 0; j < argc; j++) { |
| 15175 | 15251 | long wordtokens = 1; |
| 15176 | 15252 | int expand = 0; |
| | @@ -15226,11 +15302,11 @@ |
| 15226 | 15302 | |
| 15227 | 15303 | if (!expand) { |
| 15228 | 15304 | argv[j] = wordObjPtr; |
| 15229 | 15305 | } |
| 15230 | 15306 | else { |
| 15231 | | - |
| 15307 | + |
| 15232 | 15308 | int len = Jim_ListLength(interp, wordObjPtr); |
| 15233 | 15309 | int newargc = argc + len - 1; |
| 15234 | 15310 | int k; |
| 15235 | 15311 | |
| 15236 | 15312 | if (len > 1) { |
| | @@ -15239,39 +15315,39 @@ |
| 15239 | 15315 | argv = Jim_Alloc(sizeof(*argv) * newargc); |
| 15240 | 15316 | memcpy(argv, sargv, sizeof(*argv) * j); |
| 15241 | 15317 | } |
| 15242 | 15318 | } |
| 15243 | 15319 | else { |
| 15244 | | - |
| 15320 | + |
| 15245 | 15321 | argv = Jim_Realloc(argv, sizeof(*argv) * newargc); |
| 15246 | 15322 | } |
| 15247 | 15323 | } |
| 15248 | 15324 | |
| 15249 | | - |
| 15325 | + |
| 15250 | 15326 | for (k = 0; k < len; k++) { |
| 15251 | 15327 | argv[j++] = wordObjPtr->internalRep.listValue.ele[k]; |
| 15252 | 15328 | Jim_IncrRefCount(wordObjPtr->internalRep.listValue.ele[k]); |
| 15253 | 15329 | } |
| 15254 | 15330 | |
| 15255 | 15331 | Jim_DecrRefCount(interp, wordObjPtr); |
| 15256 | 15332 | |
| 15257 | | - |
| 15333 | + |
| 15258 | 15334 | j--; |
| 15259 | 15335 | argc += len - 1; |
| 15260 | 15336 | } |
| 15261 | 15337 | } |
| 15262 | 15338 | |
| 15263 | 15339 | if (retcode == JIM_OK && argc) { |
| 15264 | | - |
| 15340 | + |
| 15265 | 15341 | retcode = JimInvokeCommand(interp, argc, argv); |
| 15266 | | - |
| 15342 | + |
| 15267 | 15343 | if (Jim_CheckSignal(interp)) { |
| 15268 | 15344 | retcode = JIM_SIGNAL; |
| 15269 | 15345 | } |
| 15270 | 15346 | } |
| 15271 | 15347 | |
| 15272 | | - |
| 15348 | + |
| 15273 | 15349 | while (j-- > 0) { |
| 15274 | 15350 | Jim_DecrRefCount(interp, argv[j]); |
| 15275 | 15351 | } |
| 15276 | 15352 | |
| 15277 | 15353 | if (argv != sargv) { |
| | @@ -15278,21 +15354,21 @@ |
| 15278 | 15354 | Jim_Free(argv); |
| 15279 | 15355 | argv = sargv; |
| 15280 | 15356 | } |
| 15281 | 15357 | } |
| 15282 | 15358 | |
| 15283 | | - |
| 15359 | + |
| 15284 | 15360 | if (retcode == JIM_ERR) { |
| 15285 | 15361 | JimAddErrorToStack(interp, script); |
| 15286 | 15362 | } |
| 15287 | | - |
| 15363 | + |
| 15288 | 15364 | else if (retcode != JIM_RETURN || interp->returnCode != JIM_ERR) { |
| 15289 | | - |
| 15365 | + |
| 15290 | 15366 | interp->addStackTrace = 0; |
| 15291 | 15367 | } |
| 15292 | 15368 | |
| 15293 | | - |
| 15369 | + |
| 15294 | 15370 | interp->currentScriptObj = prevScriptObj; |
| 15295 | 15371 | |
| 15296 | 15372 | Jim_FreeIntRep(interp, scriptObjPtr); |
| 15297 | 15373 | scriptObjPtr->typePtr = &scriptObjType; |
| 15298 | 15374 | Jim_SetIntRepPtr(scriptObjPtr, script); |
| | @@ -15302,14 +15378,14 @@ |
| 15302 | 15378 | } |
| 15303 | 15379 | |
| 15304 | 15380 | static int JimSetProcArg(Jim_Interp *interp, Jim_Obj *argNameObj, Jim_Obj *argValObj) |
| 15305 | 15381 | { |
| 15306 | 15382 | int retcode; |
| 15307 | | - |
| 15383 | + |
| 15308 | 15384 | const char *varname = Jim_String(argNameObj); |
| 15309 | 15385 | if (*varname == '&') { |
| 15310 | | - |
| 15386 | + |
| 15311 | 15387 | Jim_Obj *objPtr; |
| 15312 | 15388 | Jim_CallFrame *savedCallFrame = interp->framePtr; |
| 15313 | 15389 | |
| 15314 | 15390 | interp->framePtr = interp->framePtr->parent; |
| 15315 | 15391 | objPtr = Jim_GetVariable(interp, argValObj, JIM_ERRMSG); |
| | @@ -15316,11 +15392,11 @@ |
| 15316 | 15392 | interp->framePtr = savedCallFrame; |
| 15317 | 15393 | if (!objPtr) { |
| 15318 | 15394 | return JIM_ERR; |
| 15319 | 15395 | } |
| 15320 | 15396 | |
| 15321 | | - |
| 15397 | + |
| 15322 | 15398 | objPtr = Jim_NewStringObj(interp, varname + 1, -1); |
| 15323 | 15399 | Jim_IncrRefCount(objPtr); |
| 15324 | 15400 | retcode = Jim_SetVariableLink(interp, objPtr, argValObj, interp->framePtr->parent); |
| 15325 | 15401 | Jim_DecrRefCount(interp, objPtr); |
| 15326 | 15402 | } |
| | @@ -15330,26 +15406,26 @@ |
| 15330 | 15406 | return retcode; |
| 15331 | 15407 | } |
| 15332 | 15408 | |
| 15333 | 15409 | static void JimSetProcWrongArgs(Jim_Interp *interp, Jim_Obj *procNameObj, Jim_Cmd *cmd) |
| 15334 | 15410 | { |
| 15335 | | - |
| 15411 | + |
| 15336 | 15412 | Jim_Obj *argmsg = Jim_NewStringObj(interp, "", 0); |
| 15337 | 15413 | int i; |
| 15338 | 15414 | |
| 15339 | 15415 | for (i = 0; i < cmd->u.proc.argListLen; i++) { |
| 15340 | 15416 | Jim_AppendString(interp, argmsg, " ", 1); |
| 15341 | 15417 | |
| 15342 | 15418 | if (i == cmd->u.proc.argsPos) { |
| 15343 | 15419 | if (cmd->u.proc.arglist[i].defaultObjPtr) { |
| 15344 | | - |
| 15420 | + |
| 15345 | 15421 | Jim_AppendString(interp, argmsg, "?", 1); |
| 15346 | 15422 | Jim_AppendObj(interp, argmsg, cmd->u.proc.arglist[i].defaultObjPtr); |
| 15347 | 15423 | Jim_AppendString(interp, argmsg, " ...?", -1); |
| 15348 | 15424 | } |
| 15349 | 15425 | else { |
| 15350 | | - |
| 15426 | + |
| 15351 | 15427 | Jim_AppendString(interp, argmsg, "?arg...?", -1); |
| 15352 | 15428 | } |
| 15353 | 15429 | } |
| 15354 | 15430 | else { |
| 15355 | 15431 | if (cmd->u.proc.arglist[i].defaultObjPtr) { |
| | @@ -15374,11 +15450,11 @@ |
| 15374 | 15450 | int Jim_EvalNamespace(Jim_Interp *interp, Jim_Obj *scriptObj, Jim_Obj *nsObj) |
| 15375 | 15451 | { |
| 15376 | 15452 | Jim_CallFrame *callFramePtr; |
| 15377 | 15453 | int retcode; |
| 15378 | 15454 | |
| 15379 | | - |
| 15455 | + |
| 15380 | 15456 | callFramePtr = JimCreateCallFrame(interp, interp->framePtr, nsObj); |
| 15381 | 15457 | callFramePtr->argv = &interp->emptyObj; |
| 15382 | 15458 | callFramePtr->argc = 0; |
| 15383 | 15459 | callFramePtr->procArgsObjPtr = NULL; |
| 15384 | 15460 | callFramePtr->procBodyObjPtr = scriptObj; |
| | @@ -15386,21 +15462,21 @@ |
| 15386 | 15462 | callFramePtr->fileNameObj = interp->emptyObj; |
| 15387 | 15463 | callFramePtr->line = 0; |
| 15388 | 15464 | Jim_IncrRefCount(scriptObj); |
| 15389 | 15465 | interp->framePtr = callFramePtr; |
| 15390 | 15466 | |
| 15391 | | - |
| 15467 | + |
| 15392 | 15468 | if (interp->framePtr->level == interp->maxCallFrameDepth) { |
| 15393 | 15469 | Jim_SetResultString(interp, "Too many nested calls. Infinite recursion?", -1); |
| 15394 | 15470 | retcode = JIM_ERR; |
| 15395 | 15471 | } |
| 15396 | 15472 | else { |
| 15397 | | - |
| 15473 | + |
| 15398 | 15474 | retcode = Jim_EvalObj(interp, scriptObj); |
| 15399 | 15475 | } |
| 15400 | 15476 | |
| 15401 | | - |
| 15477 | + |
| 15402 | 15478 | interp->framePtr = interp->framePtr->parent; |
| 15403 | 15479 | JimFreeCallFrame(interp, callFramePtr, JIM_FCF_REUSE); |
| 15404 | 15480 | |
| 15405 | 15481 | return retcode; |
| 15406 | 15482 | } |
| | @@ -15410,62 +15486,62 @@ |
| 15410 | 15486 | { |
| 15411 | 15487 | Jim_CallFrame *callFramePtr; |
| 15412 | 15488 | int i, d, retcode, optargs; |
| 15413 | 15489 | ScriptObj *script; |
| 15414 | 15490 | |
| 15415 | | - |
| 15491 | + |
| 15416 | 15492 | if (argc - 1 < cmd->u.proc.reqArity || |
| 15417 | 15493 | (cmd->u.proc.argsPos < 0 && argc - 1 > cmd->u.proc.reqArity + cmd->u.proc.optArity)) { |
| 15418 | 15494 | JimSetProcWrongArgs(interp, argv[0], cmd); |
| 15419 | 15495 | return JIM_ERR; |
| 15420 | 15496 | } |
| 15421 | 15497 | |
| 15422 | 15498 | if (Jim_Length(cmd->u.proc.bodyObjPtr) == 0) { |
| 15423 | | - |
| 15499 | + |
| 15424 | 15500 | return JIM_OK; |
| 15425 | 15501 | } |
| 15426 | 15502 | |
| 15427 | | - |
| 15503 | + |
| 15428 | 15504 | if (interp->framePtr->level == interp->maxCallFrameDepth) { |
| 15429 | 15505 | Jim_SetResultString(interp, "Too many nested calls. Infinite recursion?", -1); |
| 15430 | 15506 | return JIM_ERR; |
| 15431 | 15507 | } |
| 15432 | 15508 | |
| 15433 | | - |
| 15509 | + |
| 15434 | 15510 | callFramePtr = JimCreateCallFrame(interp, interp->framePtr, cmd->u.proc.nsObj); |
| 15435 | 15511 | callFramePtr->argv = argv; |
| 15436 | 15512 | callFramePtr->argc = argc; |
| 15437 | 15513 | callFramePtr->procArgsObjPtr = cmd->u.proc.argListObjPtr; |
| 15438 | 15514 | callFramePtr->procBodyObjPtr = cmd->u.proc.bodyObjPtr; |
| 15439 | 15515 | callFramePtr->staticVars = cmd->u.proc.staticVars; |
| 15440 | 15516 | |
| 15441 | | - |
| 15517 | + |
| 15442 | 15518 | script = JimGetScript(interp, interp->currentScriptObj); |
| 15443 | 15519 | callFramePtr->fileNameObj = script->fileNameObj; |
| 15444 | 15520 | callFramePtr->line = script->linenr; |
| 15445 | 15521 | |
| 15446 | 15522 | Jim_IncrRefCount(cmd->u.proc.argListObjPtr); |
| 15447 | 15523 | Jim_IncrRefCount(cmd->u.proc.bodyObjPtr); |
| 15448 | 15524 | interp->framePtr = callFramePtr; |
| 15449 | 15525 | |
| 15450 | | - |
| 15526 | + |
| 15451 | 15527 | optargs = (argc - 1 - cmd->u.proc.reqArity); |
| 15452 | 15528 | |
| 15453 | | - |
| 15529 | + |
| 15454 | 15530 | i = 1; |
| 15455 | 15531 | for (d = 0; d < cmd->u.proc.argListLen; d++) { |
| 15456 | 15532 | Jim_Obj *nameObjPtr = cmd->u.proc.arglist[d].nameObjPtr; |
| 15457 | 15533 | if (d == cmd->u.proc.argsPos) { |
| 15458 | | - |
| 15534 | + |
| 15459 | 15535 | Jim_Obj *listObjPtr; |
| 15460 | 15536 | int argsLen = 0; |
| 15461 | 15537 | if (cmd->u.proc.reqArity + cmd->u.proc.optArity < argc - 1) { |
| 15462 | 15538 | argsLen = argc - 1 - (cmd->u.proc.reqArity + cmd->u.proc.optArity); |
| 15463 | 15539 | } |
| 15464 | 15540 | listObjPtr = Jim_NewListObj(interp, &argv[i], argsLen); |
| 15465 | 15541 | |
| 15466 | | - |
| 15542 | + |
| 15467 | 15543 | if (cmd->u.proc.arglist[d].defaultObjPtr) { |
| 15468 | 15544 | nameObjPtr =cmd->u.proc.arglist[d].defaultObjPtr; |
| 15469 | 15545 | } |
| 15470 | 15546 | retcode = Jim_SetVariable(interp, nameObjPtr, listObjPtr); |
| 15471 | 15547 | if (retcode != JIM_OK) { |
| | @@ -15474,33 +15550,33 @@ |
| 15474 | 15550 | |
| 15475 | 15551 | i += argsLen; |
| 15476 | 15552 | continue; |
| 15477 | 15553 | } |
| 15478 | 15554 | |
| 15479 | | - |
| 15555 | + |
| 15480 | 15556 | if (cmd->u.proc.arglist[d].defaultObjPtr == NULL || optargs-- > 0) { |
| 15481 | 15557 | retcode = JimSetProcArg(interp, nameObjPtr, argv[i++]); |
| 15482 | 15558 | } |
| 15483 | 15559 | else { |
| 15484 | | - |
| 15560 | + |
| 15485 | 15561 | retcode = Jim_SetVariable(interp, nameObjPtr, cmd->u.proc.arglist[d].defaultObjPtr); |
| 15486 | 15562 | } |
| 15487 | 15563 | if (retcode != JIM_OK) { |
| 15488 | 15564 | goto badargset; |
| 15489 | 15565 | } |
| 15490 | 15566 | } |
| 15491 | 15567 | |
| 15492 | | - |
| 15568 | + |
| 15493 | 15569 | retcode = Jim_EvalObj(interp, cmd->u.proc.bodyObjPtr); |
| 15494 | 15570 | |
| 15495 | 15571 | badargset: |
| 15496 | 15572 | |
| 15497 | | - |
| 15573 | + |
| 15498 | 15574 | interp->framePtr = interp->framePtr->parent; |
| 15499 | 15575 | JimFreeCallFrame(interp, callFramePtr, JIM_FCF_REUSE); |
| 15500 | 15576 | |
| 15501 | | - |
| 15577 | + |
| 15502 | 15578 | if (interp->framePtr->tailcallObj) { |
| 15503 | 15579 | do { |
| 15504 | 15580 | Jim_Obj *tailcallObj = interp->framePtr->tailcallObj; |
| 15505 | 15581 | |
| 15506 | 15582 | interp->framePtr->tailcallObj = NULL; |
| | @@ -15512,18 +15588,18 @@ |
| 15512 | 15588 | } |
| 15513 | 15589 | } |
| 15514 | 15590 | Jim_DecrRefCount(interp, tailcallObj); |
| 15515 | 15591 | } while (interp->framePtr->tailcallObj); |
| 15516 | 15592 | |
| 15517 | | - |
| 15593 | + |
| 15518 | 15594 | if (interp->framePtr->tailcallCmd) { |
| 15519 | 15595 | JimDecrCmdRefCount(interp, interp->framePtr->tailcallCmd); |
| 15520 | 15596 | interp->framePtr->tailcallCmd = NULL; |
| 15521 | 15597 | } |
| 15522 | 15598 | } |
| 15523 | 15599 | |
| 15524 | | - |
| 15600 | + |
| 15525 | 15601 | if (retcode == JIM_RETURN) { |
| 15526 | 15602 | if (--interp->returnLevel <= 0) { |
| 15527 | 15603 | retcode = interp->returnCode; |
| 15528 | 15604 | interp->returnCode = JIM_OK; |
| 15529 | 15605 | interp->returnLevel = 0; |
| | @@ -15635,20 +15711,20 @@ |
| 15635 | 15711 | prevScriptObj = interp->currentScriptObj; |
| 15636 | 15712 | interp->currentScriptObj = scriptObjPtr; |
| 15637 | 15713 | |
| 15638 | 15714 | retcode = Jim_EvalObj(interp, scriptObjPtr); |
| 15639 | 15715 | |
| 15640 | | - |
| 15716 | + |
| 15641 | 15717 | if (retcode == JIM_RETURN) { |
| 15642 | 15718 | if (--interp->returnLevel <= 0) { |
| 15643 | 15719 | retcode = interp->returnCode; |
| 15644 | 15720 | interp->returnCode = JIM_OK; |
| 15645 | 15721 | interp->returnLevel = 0; |
| 15646 | 15722 | } |
| 15647 | 15723 | } |
| 15648 | 15724 | if (retcode == JIM_ERR) { |
| 15649 | | - |
| 15725 | + |
| 15650 | 15726 | interp->addStackTrace++; |
| 15651 | 15727 | } |
| 15652 | 15728 | |
| 15653 | 15729 | interp->currentScriptObj = prevScriptObj; |
| 15654 | 15730 | |
| | @@ -15674,11 +15750,11 @@ |
| 15674 | 15750 | } |
| 15675 | 15751 | if (*pc->p == '$' && !(flags & JIM_SUBST_NOVAR)) { |
| 15676 | 15752 | if (JimParseVar(pc) == JIM_OK) { |
| 15677 | 15753 | return; |
| 15678 | 15754 | } |
| 15679 | | - |
| 15755 | + |
| 15680 | 15756 | pc->tstart = pc->p; |
| 15681 | 15757 | flags |= JIM_SUBST_NOVAR; |
| 15682 | 15758 | } |
| 15683 | 15759 | while (pc->len) { |
| 15684 | 15760 | if (*pc->p == '$' && !(flags & JIM_SUBST_NOVAR)) { |
| | @@ -15705,32 +15781,32 @@ |
| 15705 | 15781 | const char *scriptText = Jim_GetString(objPtr, &scriptTextLen); |
| 15706 | 15782 | struct JimParserCtx parser; |
| 15707 | 15783 | struct ScriptObj *script = Jim_Alloc(sizeof(*script)); |
| 15708 | 15784 | ParseTokenList tokenlist; |
| 15709 | 15785 | |
| 15710 | | - |
| 15786 | + |
| 15711 | 15787 | ScriptTokenListInit(&tokenlist); |
| 15712 | 15788 | |
| 15713 | 15789 | JimParserInit(&parser, scriptText, scriptTextLen, 1); |
| 15714 | 15790 | while (1) { |
| 15715 | 15791 | JimParseSubst(&parser, flags); |
| 15716 | 15792 | if (parser.eof) { |
| 15717 | | - |
| 15793 | + |
| 15718 | 15794 | break; |
| 15719 | 15795 | } |
| 15720 | 15796 | ScriptAddToken(&tokenlist, parser.tstart, parser.tend - parser.tstart + 1, parser.tt, |
| 15721 | 15797 | parser.tline); |
| 15722 | 15798 | } |
| 15723 | 15799 | |
| 15724 | | - |
| 15800 | + |
| 15725 | 15801 | script->inUse = 1; |
| 15726 | 15802 | script->substFlags = flags; |
| 15727 | 15803 | script->fileNameObj = interp->emptyObj; |
| 15728 | 15804 | Jim_IncrRefCount(script->fileNameObj); |
| 15729 | 15805 | SubstObjAddTokens(interp, script, &tokenlist); |
| 15730 | 15806 | |
| 15731 | | - |
| 15807 | + |
| 15732 | 15808 | ScriptTokenListFree(&tokenlist); |
| 15733 | 15809 | |
| 15734 | 15810 | #ifdef DEBUG_SHOW_SUBST |
| 15735 | 15811 | { |
| 15736 | 15812 | int i; |
| | @@ -15741,11 +15817,11 @@ |
| 15741 | 15817 | Jim_String(script->token[i].objPtr)); |
| 15742 | 15818 | } |
| 15743 | 15819 | } |
| 15744 | 15820 | #endif |
| 15745 | 15821 | |
| 15746 | | - |
| 15822 | + |
| 15747 | 15823 | Jim_FreeIntRep(interp, objPtr); |
| 15748 | 15824 | Jim_SetIntRepPtr(objPtr, script); |
| 15749 | 15825 | objPtr->typePtr = &scriptObjType; |
| 15750 | 15826 | return JIM_OK; |
| 15751 | 15827 | } |
| | @@ -15759,11 +15835,11 @@ |
| 15759 | 15835 | |
| 15760 | 15836 | int Jim_SubstObj(Jim_Interp *interp, Jim_Obj *substObjPtr, Jim_Obj **resObjPtrPtr, int flags) |
| 15761 | 15837 | { |
| 15762 | 15838 | ScriptObj *script = Jim_GetSubst(interp, substObjPtr, flags); |
| 15763 | 15839 | |
| 15764 | | - Jim_IncrRefCount(substObjPtr); |
| 15840 | + Jim_IncrRefCount(substObjPtr); |
| 15765 | 15841 | script->inUse++; |
| 15766 | 15842 | |
| 15767 | 15843 | *resObjPtrPtr = JimInterpolateTokens(interp, script->token, script->len, flags); |
| 15768 | 15844 | |
| 15769 | 15845 | script->inUse--; |
| | @@ -15775,15 +15851,11 @@ |
| 15775 | 15851 | } |
| 15776 | 15852 | |
| 15777 | 15853 | void Jim_WrongNumArgs(Jim_Interp *interp, int argc, Jim_Obj *const *argv, const char *msg) |
| 15778 | 15854 | { |
| 15779 | 15855 | Jim_Obj *objPtr; |
| 15780 | | - Jim_Obj *listObjPtr; |
| 15781 | | - |
| 15782 | | - JimPanic((argc == 0, "Jim_WrongNumArgs() called with argc=0")); |
| 15783 | | - |
| 15784 | | - listObjPtr = Jim_NewListObj(interp, argv, argc); |
| 15856 | + Jim_Obj *listObjPtr = Jim_NewListObj(interp, argv, argc); |
| 15785 | 15857 | |
| 15786 | 15858 | if (*msg) { |
| 15787 | 15859 | Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, msg, -1)); |
| 15788 | 15860 | } |
| 15789 | 15861 | Jim_IncrRefCount(listObjPtr); |
| | @@ -15804,11 +15876,11 @@ |
| 15804 | 15876 | JimHashtableIteratorCallbackType *callback, int type) |
| 15805 | 15877 | { |
| 15806 | 15878 | Jim_HashEntry *he; |
| 15807 | 15879 | Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0); |
| 15808 | 15880 | |
| 15809 | | - |
| 15881 | + |
| 15810 | 15882 | if (patternObjPtr && JimTrivialMatch(Jim_String(patternObjPtr))) { |
| 15811 | 15883 | he = Jim_FindHashEntry(ht, Jim_String(patternObjPtr)); |
| 15812 | 15884 | if (he) { |
| 15813 | 15885 | callback(interp, listObjPtr, he, type); |
| 15814 | 15886 | } |
| | @@ -15835,11 +15907,11 @@ |
| 15835 | 15907 | { |
| 15836 | 15908 | Jim_Cmd *cmdPtr = Jim_GetHashEntryVal(he); |
| 15837 | 15909 | Jim_Obj *objPtr; |
| 15838 | 15910 | |
| 15839 | 15911 | if (type == JIM_CMDLIST_PROCS && !cmdPtr->isproc) { |
| 15840 | | - |
| 15912 | + |
| 15841 | 15913 | return; |
| 15842 | 15914 | } |
| 15843 | 15915 | |
| 15844 | 15916 | objPtr = Jim_NewStringObj(interp, he->key, -1); |
| 15845 | 15917 | Jim_IncrRefCount(objPtr); |
| | @@ -15895,11 +15967,11 @@ |
| 15895 | 15967 | |
| 15896 | 15968 | targetCallFrame = JimGetCallFrameByInteger(interp, levelObjPtr); |
| 15897 | 15969 | if (targetCallFrame == NULL) { |
| 15898 | 15970 | return JIM_ERR; |
| 15899 | 15971 | } |
| 15900 | | - |
| 15972 | + |
| 15901 | 15973 | if (targetCallFrame == interp->topFramePtr) { |
| 15902 | 15974 | Jim_SetResultFormatted(interp, "bad level \"%#s\"", levelObjPtr); |
| 15903 | 15975 | return JIM_ERR; |
| 15904 | 15976 | } |
| 15905 | 15977 | if (info_level_cmd) { |
| | @@ -16082,11 +16154,11 @@ |
| 16082 | 16154 | if (!objPtr) |
| 16083 | 16155 | return JIM_ERR; |
| 16084 | 16156 | Jim_SetResult(interp, objPtr); |
| 16085 | 16157 | return JIM_OK; |
| 16086 | 16158 | } |
| 16087 | | - |
| 16159 | + |
| 16088 | 16160 | if (Jim_SetVariable(interp, argv[1], argv[2]) != JIM_OK) |
| 16089 | 16161 | return JIM_ERR; |
| 16090 | 16162 | Jim_SetResult(interp, argv[2]); |
| 16091 | 16163 | return JIM_OK; |
| 16092 | 16164 | } |
| | @@ -16125,11 +16197,11 @@ |
| 16125 | 16197 | if (argc != 3) { |
| 16126 | 16198 | Jim_WrongNumArgs(interp, 1, argv, "condition body"); |
| 16127 | 16199 | return JIM_ERR; |
| 16128 | 16200 | } |
| 16129 | 16201 | |
| 16130 | | - |
| 16202 | + |
| 16131 | 16203 | while (1) { |
| 16132 | 16204 | int boolean, retval; |
| 16133 | 16205 | |
| 16134 | 16206 | if ((retval = Jim_GetBoolFromExpr(interp, argv[1], &boolean)) != JIM_OK) |
| 16135 | 16207 | return retval; |
| | @@ -16165,11 +16237,11 @@ |
| 16165 | 16237 | if (argc != 5) { |
| 16166 | 16238 | Jim_WrongNumArgs(interp, 1, argv, "start test next body"); |
| 16167 | 16239 | return JIM_ERR; |
| 16168 | 16240 | } |
| 16169 | 16241 | |
| 16170 | | - |
| 16242 | + |
| 16171 | 16243 | if ((retval = Jim_EvalObj(interp, argv[1])) != JIM_OK) { |
| 16172 | 16244 | return retval; |
| 16173 | 16245 | } |
| 16174 | 16246 | |
| 16175 | 16247 | retval = Jim_GetBoolFromExpr(interp, argv[2], &boolean); |
| | @@ -16181,19 +16253,19 @@ |
| 16181 | 16253 | ExprByteCode *expr; |
| 16182 | 16254 | jim_wide stop, currentVal; |
| 16183 | 16255 | Jim_Obj *objPtr; |
| 16184 | 16256 | int cmpOffset; |
| 16185 | 16257 | |
| 16186 | | - |
| 16258 | + |
| 16187 | 16259 | expr = JimGetExpression(interp, argv[2]); |
| 16188 | 16260 | incrScript = JimGetScript(interp, argv[3]); |
| 16189 | 16261 | |
| 16190 | | - |
| 16262 | + |
| 16191 | 16263 | if (incrScript == NULL || incrScript->len != 3 || !expr || expr->len != 3) { |
| 16192 | 16264 | goto evalstart; |
| 16193 | 16265 | } |
| 16194 | | - |
| 16266 | + |
| 16195 | 16267 | if (incrScript->token[1].type != JIM_TT_ESC || |
| 16196 | 16268 | expr->token[0].type != JIM_TT_VAR || |
| 16197 | 16269 | (expr->token[1].type != JIM_TT_EXPR_INT && expr->token[1].type != JIM_TT_VAR)) { |
| 16198 | 16270 | goto evalstart; |
| 16199 | 16271 | } |
| | @@ -16206,48 +16278,48 @@ |
| 16206 | 16278 | } |
| 16207 | 16279 | else { |
| 16208 | 16280 | goto evalstart; |
| 16209 | 16281 | } |
| 16210 | 16282 | |
| 16211 | | - |
| 16283 | + |
| 16212 | 16284 | if (!Jim_CompareStringImmediate(interp, incrScript->token[1].objPtr, "incr")) { |
| 16213 | 16285 | goto evalstart; |
| 16214 | 16286 | } |
| 16215 | 16287 | |
| 16216 | | - |
| 16288 | + |
| 16217 | 16289 | if (!Jim_StringEqObj(incrScript->token[2].objPtr, expr->token[0].objPtr)) { |
| 16218 | 16290 | goto evalstart; |
| 16219 | 16291 | } |
| 16220 | 16292 | |
| 16221 | | - |
| 16293 | + |
| 16222 | 16294 | if (expr->token[1].type == JIM_TT_EXPR_INT) { |
| 16223 | 16295 | if (Jim_GetWide(interp, expr->token[1].objPtr, &stop) == JIM_ERR) { |
| 16224 | 16296 | goto evalstart; |
| 16225 | 16297 | } |
| 16226 | 16298 | } |
| 16227 | 16299 | else { |
| 16228 | 16300 | stopVarNamePtr = expr->token[1].objPtr; |
| 16229 | 16301 | Jim_IncrRefCount(stopVarNamePtr); |
| 16230 | | - |
| 16302 | + |
| 16231 | 16303 | stop = 0; |
| 16232 | 16304 | } |
| 16233 | 16305 | |
| 16234 | | - |
| 16306 | + |
| 16235 | 16307 | varNamePtr = expr->token[0].objPtr; |
| 16236 | 16308 | Jim_IncrRefCount(varNamePtr); |
| 16237 | 16309 | |
| 16238 | 16310 | objPtr = Jim_GetVariable(interp, varNamePtr, JIM_NONE); |
| 16239 | 16311 | if (objPtr == NULL || Jim_GetWide(interp, objPtr, ¤tVal) != JIM_OK) { |
| 16240 | 16312 | goto testcond; |
| 16241 | 16313 | } |
| 16242 | 16314 | |
| 16243 | | - |
| 16315 | + |
| 16244 | 16316 | while (retval == JIM_OK) { |
| 16317 | + |
| 16318 | + |
| 16245 | 16319 | |
| 16246 | | - |
| 16247 | | - |
| 16248 | | - |
| 16320 | + |
| 16249 | 16321 | if (stopVarNamePtr) { |
| 16250 | 16322 | objPtr = Jim_GetVariable(interp, stopVarNamePtr, JIM_NONE); |
| 16251 | 16323 | if (objPtr == NULL || Jim_GetWide(interp, objPtr, &stop) != JIM_OK) { |
| 16252 | 16324 | goto testcond; |
| 16253 | 16325 | } |
| | @@ -16255,18 +16327,18 @@ |
| 16255 | 16327 | |
| 16256 | 16328 | if (currentVal >= stop + cmpOffset) { |
| 16257 | 16329 | break; |
| 16258 | 16330 | } |
| 16259 | 16331 | |
| 16260 | | - |
| 16332 | + |
| 16261 | 16333 | retval = Jim_EvalObj(interp, argv[4]); |
| 16262 | 16334 | if (retval == JIM_OK || retval == JIM_CONTINUE) { |
| 16263 | 16335 | retval = JIM_OK; |
| 16264 | 16336 | |
| 16265 | 16337 | objPtr = Jim_GetVariable(interp, varNamePtr, JIM_ERRMSG); |
| 16266 | 16338 | |
| 16267 | | - |
| 16339 | + |
| 16268 | 16340 | if (objPtr == NULL) { |
| 16269 | 16341 | retval = JIM_ERR; |
| 16270 | 16342 | goto out; |
| 16271 | 16343 | } |
| 16272 | 16344 | if (!Jim_IsShared(objPtr) && objPtr->typePtr == &intObjType) { |
| | @@ -16286,25 +16358,25 @@ |
| 16286 | 16358 | } |
| 16287 | 16359 | evalstart: |
| 16288 | 16360 | #endif |
| 16289 | 16361 | |
| 16290 | 16362 | while (boolean && (retval == JIM_OK || retval == JIM_CONTINUE)) { |
| 16291 | | - |
| 16363 | + |
| 16292 | 16364 | retval = Jim_EvalObj(interp, argv[4]); |
| 16293 | 16365 | |
| 16294 | 16366 | if (retval == JIM_OK || retval == JIM_CONTINUE) { |
| 16295 | | - |
| 16296 | | -JIM_IF_OPTIM(evalnext:) |
| 16367 | + |
| 16368 | + evalnext: |
| 16297 | 16369 | retval = Jim_EvalObj(interp, argv[3]); |
| 16298 | 16370 | if (retval == JIM_OK || retval == JIM_CONTINUE) { |
| 16299 | | - |
| 16300 | | -JIM_IF_OPTIM(testcond:) |
| 16371 | + |
| 16372 | + testcond: |
| 16301 | 16373 | retval = Jim_GetBoolFromExpr(interp, argv[2], &boolean); |
| 16302 | 16374 | } |
| 16303 | 16375 | } |
| 16304 | 16376 | } |
| 16305 | | -JIM_IF_OPTIM(out:) |
| 16377 | + out: |
| 16306 | 16378 | if (stopVarNamePtr) { |
| 16307 | 16379 | Jim_DecrRefCount(interp, stopVarNamePtr); |
| 16308 | 16380 | } |
| 16309 | 16381 | if (varNamePtr) { |
| 16310 | 16382 | Jim_DecrRefCount(interp, varNamePtr); |
| | @@ -16346,11 +16418,11 @@ |
| 16346 | 16418 | if (retval == JIM_OK || retval == JIM_CONTINUE) { |
| 16347 | 16419 | Jim_Obj *objPtr = Jim_GetVariable(interp, argv[1], JIM_ERRMSG); |
| 16348 | 16420 | |
| 16349 | 16421 | retval = JIM_OK; |
| 16350 | 16422 | |
| 16351 | | - |
| 16423 | + |
| 16352 | 16424 | i += incr; |
| 16353 | 16425 | |
| 16354 | 16426 | if (objPtr && !Jim_IsShared(objPtr) && objPtr->typePtr == &intObjType) { |
| 16355 | 16427 | if (argv[1]->typePtr != &variableObjType) { |
| 16356 | 16428 | if (Jim_SetVariable(interp, argv[1], objPtr) != JIM_OK) { |
| | @@ -16411,21 +16483,21 @@ |
| 16411 | 16483 | |
| 16412 | 16484 | static int JimForeachMapHelper(Jim_Interp *interp, int argc, Jim_Obj *const *argv, int doMap) |
| 16413 | 16485 | { |
| 16414 | 16486 | int result = JIM_OK; |
| 16415 | 16487 | int i, numargs; |
| 16416 | | - Jim_ListIter twoiters[2]; |
| 16488 | + Jim_ListIter twoiters[2]; |
| 16417 | 16489 | Jim_ListIter *iters; |
| 16418 | 16490 | Jim_Obj *script; |
| 16419 | 16491 | Jim_Obj *resultObj; |
| 16420 | 16492 | |
| 16421 | 16493 | if (argc < 4 || argc % 2 != 0) { |
| 16422 | 16494 | Jim_WrongNumArgs(interp, 1, argv, "varList list ?varList list ...? script"); |
| 16423 | 16495 | return JIM_ERR; |
| 16424 | 16496 | } |
| 16425 | | - script = argv[argc - 1]; |
| 16426 | | - numargs = (argc - 1 - 1); |
| 16497 | + script = argv[argc - 1]; |
| 16498 | + numargs = (argc - 1 - 1); |
| 16427 | 16499 | |
| 16428 | 16500 | if (numargs == 2) { |
| 16429 | 16501 | iters = twoiters; |
| 16430 | 16502 | } |
| 16431 | 16503 | else { |
| | @@ -16449,34 +16521,34 @@ |
| 16449 | 16521 | resultObj = interp->emptyObj; |
| 16450 | 16522 | } |
| 16451 | 16523 | Jim_IncrRefCount(resultObj); |
| 16452 | 16524 | |
| 16453 | 16525 | while (1) { |
| 16454 | | - |
| 16526 | + |
| 16455 | 16527 | for (i = 0; i < numargs; i += 2) { |
| 16456 | 16528 | if (!JimListIterDone(interp, &iters[i + 1])) { |
| 16457 | 16529 | break; |
| 16458 | 16530 | } |
| 16459 | 16531 | } |
| 16460 | 16532 | if (i == numargs) { |
| 16461 | | - |
| 16533 | + |
| 16462 | 16534 | break; |
| 16463 | 16535 | } |
| 16464 | 16536 | |
| 16465 | | - |
| 16537 | + |
| 16466 | 16538 | for (i = 0; i < numargs; i += 2) { |
| 16467 | 16539 | Jim_Obj *varName; |
| 16468 | 16540 | |
| 16469 | | - |
| 16541 | + |
| 16470 | 16542 | JimListIterInit(&iters[i], argv[i + 1]); |
| 16471 | 16543 | while ((varName = JimListIterNext(interp, &iters[i])) != NULL) { |
| 16472 | 16544 | Jim_Obj *valObj = JimListIterNext(interp, &iters[i + 1]); |
| 16473 | 16545 | if (!valObj) { |
| 16474 | | - |
| 16546 | + |
| 16475 | 16547 | valObj = interp->emptyObj; |
| 16476 | 16548 | } |
| 16477 | | - |
| 16549 | + |
| 16478 | 16550 | Jim_IncrRefCount(valObj); |
| 16479 | 16551 | result = Jim_SetVariable(interp, varName, valObj); |
| 16480 | 16552 | Jim_DecrRefCount(interp, valObj); |
| 16481 | 16553 | if (result != JIM_OK) { |
| 16482 | 16554 | goto err; |
| | @@ -16558,41 +16630,41 @@ |
| 16558 | 16630 | { |
| 16559 | 16631 | int boolean, retval, current = 1, falsebody = 0; |
| 16560 | 16632 | |
| 16561 | 16633 | if (argc >= 3) { |
| 16562 | 16634 | while (1) { |
| 16563 | | - |
| 16635 | + |
| 16564 | 16636 | if (current >= argc) |
| 16565 | 16637 | goto err; |
| 16566 | 16638 | if ((retval = Jim_GetBoolFromExpr(interp, argv[current++], &boolean)) |
| 16567 | 16639 | != JIM_OK) |
| 16568 | 16640 | return retval; |
| 16569 | | - |
| 16641 | + |
| 16570 | 16642 | if (current >= argc) |
| 16571 | 16643 | goto err; |
| 16572 | 16644 | if (Jim_CompareStringImmediate(interp, argv[current], "then")) |
| 16573 | 16645 | current++; |
| 16574 | | - |
| 16646 | + |
| 16575 | 16647 | if (current >= argc) |
| 16576 | 16648 | goto err; |
| 16577 | 16649 | if (boolean) |
| 16578 | 16650 | return Jim_EvalObj(interp, argv[current]); |
| 16579 | | - |
| 16651 | + |
| 16580 | 16652 | if (++current >= argc) { |
| 16581 | 16653 | Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); |
| 16582 | 16654 | return JIM_OK; |
| 16583 | 16655 | } |
| 16584 | 16656 | falsebody = current++; |
| 16585 | 16657 | if (Jim_CompareStringImmediate(interp, argv[falsebody], "else")) { |
| 16586 | | - |
| 16658 | + |
| 16587 | 16659 | if (current != argc - 1) |
| 16588 | 16660 | goto err; |
| 16589 | 16661 | return Jim_EvalObj(interp, argv[current]); |
| 16590 | 16662 | } |
| 16591 | 16663 | else if (Jim_CompareStringImmediate(interp, argv[falsebody], "elseif")) |
| 16592 | 16664 | continue; |
| 16593 | | - |
| 16665 | + |
| 16594 | 16666 | else if (falsebody != argc - 1) |
| 16595 | 16667 | goto err; |
| 16596 | 16668 | return Jim_EvalObj(interp, argv[falsebody]); |
| 16597 | 16669 | } |
| 16598 | 16670 | return JIM_OK; |
| | @@ -16700,21 +16772,21 @@ |
| 16700 | 16772 | if (Jim_StringMatchObj(interp, patObj, strObj, 0)) |
| 16701 | 16773 | script = caseList[i + 1]; |
| 16702 | 16774 | break; |
| 16703 | 16775 | case SWITCH_RE: |
| 16704 | 16776 | command = Jim_NewStringObj(interp, "regexp", -1); |
| 16705 | | - |
| 16777 | + |
| 16706 | 16778 | case SWITCH_CMD:{ |
| 16707 | 16779 | int rc = Jim_CommandMatchObj(interp, command, patObj, strObj, 0); |
| 16708 | 16780 | |
| 16709 | 16781 | if (argc - opt == 1) { |
| 16710 | 16782 | Jim_Obj **vector; |
| 16711 | 16783 | |
| 16712 | 16784 | JimListGetElements(interp, argv[opt], &patCount, &vector); |
| 16713 | 16785 | caseList = vector; |
| 16714 | 16786 | } |
| 16715 | | - |
| 16787 | + |
| 16716 | 16788 | if (rc < 0) { |
| 16717 | 16789 | return -rc; |
| 16718 | 16790 | } |
| 16719 | 16791 | if (rc) |
| 16720 | 16792 | script = caseList[i + 1]; |
| | @@ -16848,11 +16920,11 @@ |
| 16848 | 16920 | case OPT_COMMAND: |
| 16849 | 16921 | if (i >= argc - 2) { |
| 16850 | 16922 | goto wrongargs; |
| 16851 | 16923 | } |
| 16852 | 16924 | commandObj = argv[++i]; |
| 16853 | | - |
| 16925 | + |
| 16854 | 16926 | case OPT_EXACT: |
| 16855 | 16927 | case OPT_GLOB: |
| 16856 | 16928 | case OPT_REGEXP: |
| 16857 | 16929 | opt_match = option; |
| 16858 | 16930 | break; |
| | @@ -16896,17 +16968,17 @@ |
| 16896 | 16968 | goto done; |
| 16897 | 16969 | } |
| 16898 | 16970 | break; |
| 16899 | 16971 | } |
| 16900 | 16972 | |
| 16901 | | - |
| 16973 | + |
| 16902 | 16974 | if (!eq && opt_bool && opt_not && !opt_all) { |
| 16903 | 16975 | continue; |
| 16904 | 16976 | } |
| 16905 | 16977 | |
| 16906 | 16978 | if ((!opt_bool && eq == !opt_not) || (opt_bool && (eq || opt_all))) { |
| 16907 | | - |
| 16979 | + |
| 16908 | 16980 | Jim_Obj *resultObj; |
| 16909 | 16981 | |
| 16910 | 16982 | if (opt_bool) { |
| 16911 | 16983 | resultObj = Jim_NewIntObj(interp, eq ^ opt_not); |
| 16912 | 16984 | } |
| | @@ -16929,11 +17001,11 @@ |
| 16929 | 17001 | |
| 16930 | 17002 | if (opt_all) { |
| 16931 | 17003 | Jim_SetResult(interp, listObjPtr); |
| 16932 | 17004 | } |
| 16933 | 17005 | else { |
| 16934 | | - |
| 17006 | + |
| 16935 | 17007 | if (opt_bool) { |
| 16936 | 17008 | Jim_SetResultBool(interp, opt_not); |
| 16937 | 17009 | } |
| 16938 | 17010 | else if (!opt_inline) { |
| 16939 | 17011 | Jim_SetResultInt(interp, -1); |
| | @@ -16958,11 +17030,11 @@ |
| 16958 | 17030 | Jim_WrongNumArgs(interp, 1, argv, "varName ?value value ...?"); |
| 16959 | 17031 | return JIM_ERR; |
| 16960 | 17032 | } |
| 16961 | 17033 | listObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED); |
| 16962 | 17034 | if (!listObjPtr) { |
| 16963 | | - |
| 17035 | + |
| 16964 | 17036 | listObjPtr = Jim_NewListObj(interp, NULL, 0); |
| 16965 | 17037 | new_obj = 1; |
| 16966 | 17038 | } |
| 16967 | 17039 | else if (Jim_IsShared(listObjPtr)) { |
| 16968 | 17040 | listObjPtr = Jim_DuplicateObj(interp, listObjPtr); |
| | @@ -17031,31 +17103,31 @@ |
| 17031 | 17103 | first = JimRelToAbsIndex(len, first); |
| 17032 | 17104 | last = JimRelToAbsIndex(len, last); |
| 17033 | 17105 | JimRelToAbsRange(len, &first, &last, &rangeLen); |
| 17034 | 17106 | |
| 17035 | 17107 | |
| 17036 | | - |
| 17108 | + |
| 17037 | 17109 | if (first < len) { |
| 17038 | | - |
| 17110 | + |
| 17039 | 17111 | } |
| 17040 | 17112 | else if (len == 0) { |
| 17041 | | - |
| 17113 | + |
| 17042 | 17114 | first = 0; |
| 17043 | 17115 | } |
| 17044 | 17116 | else { |
| 17045 | 17117 | Jim_SetResultString(interp, "list doesn't contain element ", -1); |
| 17046 | 17118 | Jim_AppendObj(interp, Jim_GetResult(interp), argv[2]); |
| 17047 | 17119 | return JIM_ERR; |
| 17048 | 17120 | } |
| 17049 | 17121 | |
| 17050 | | - |
| 17122 | + |
| 17051 | 17123 | newListObj = Jim_NewListObj(interp, listObj->internalRep.listValue.ele, first); |
| 17052 | 17124 | |
| 17053 | | - |
| 17125 | + |
| 17054 | 17126 | ListInsertElements(newListObj, -1, argc - 4, argv + 4); |
| 17055 | 17127 | |
| 17056 | | - |
| 17128 | + |
| 17057 | 17129 | ListInsertElements(newListObj, -1, len - first - rangeLen, listObj->internalRep.listValue.ele + first + rangeLen); |
| 17058 | 17130 | |
| 17059 | 17131 | Jim_SetResult(interp, newListObj); |
| 17060 | 17132 | return JIM_OK; |
| 17061 | 17133 | } |
| | @@ -17066,11 +17138,11 @@ |
| 17066 | 17138 | if (argc < 3) { |
| 17067 | 17139 | Jim_WrongNumArgs(interp, 1, argv, "listVar ?index...? newVal"); |
| 17068 | 17140 | return JIM_ERR; |
| 17069 | 17141 | } |
| 17070 | 17142 | else if (argc == 3) { |
| 17071 | | - |
| 17143 | + |
| 17072 | 17144 | if (Jim_SetVariable(interp, argv[1], argv[2]) != JIM_OK) |
| 17073 | 17145 | return JIM_ERR; |
| 17074 | 17146 | Jim_SetResult(interp, argv[2]); |
| 17075 | 17147 | return JIM_OK; |
| 17076 | 17148 | } |
| | @@ -17181,11 +17253,11 @@ |
| 17181 | 17253 | } |
| 17182 | 17254 | else { |
| 17183 | 17255 | int new_obj = 0; |
| 17184 | 17256 | stringObjPtr = Jim_GetVariable(interp, argv[1], JIM_UNSHARED); |
| 17185 | 17257 | if (!stringObjPtr) { |
| 17186 | | - |
| 17258 | + |
| 17187 | 17259 | stringObjPtr = Jim_NewEmptyStringObj(interp); |
| 17188 | 17260 | new_obj = 1; |
| 17189 | 17261 | } |
| 17190 | 17262 | else if (Jim_IsShared(stringObjPtr)) { |
| 17191 | 17263 | new_obj = 1; |
| | @@ -17230,11 +17302,11 @@ |
| 17230 | 17302 | else { |
| 17231 | 17303 | rc = Jim_EvalObj(interp, Jim_ConcatObj(interp, argc - 1, argv + 1)); |
| 17232 | 17304 | } |
| 17233 | 17305 | |
| 17234 | 17306 | if (rc == JIM_ERR) { |
| 17235 | | - |
| 17307 | + |
| 17236 | 17308 | interp->addStackTrace++; |
| 17237 | 17309 | } |
| 17238 | 17310 | return rc; |
| 17239 | 17311 | } |
| 17240 | 17312 | |
| | @@ -17244,14 +17316,14 @@ |
| 17244 | 17316 | if (argc >= 2) { |
| 17245 | 17317 | int retcode; |
| 17246 | 17318 | Jim_CallFrame *savedCallFrame, *targetCallFrame; |
| 17247 | 17319 | const char *str; |
| 17248 | 17320 | |
| 17249 | | - |
| 17321 | + |
| 17250 | 17322 | savedCallFrame = interp->framePtr; |
| 17251 | 17323 | |
| 17252 | | - |
| 17324 | + |
| 17253 | 17325 | str = Jim_String(argv[1]); |
| 17254 | 17326 | if ((str[0] >= '0' && str[0] <= '9') || str[0] == '#') { |
| 17255 | 17327 | targetCallFrame = Jim_GetCallFrameByLevel(interp, argv[1]); |
| 17256 | 17328 | argc--; |
| 17257 | 17329 | argv++; |
| | @@ -17264,11 +17336,11 @@ |
| 17264 | 17336 | } |
| 17265 | 17337 | if (argc < 2) { |
| 17266 | 17338 | Jim_WrongNumArgs(interp, 1, argv - 1, "?level? command ?arg ...?"); |
| 17267 | 17339 | return JIM_ERR; |
| 17268 | 17340 | } |
| 17269 | | - |
| 17341 | + |
| 17270 | 17342 | interp->framePtr = targetCallFrame; |
| 17271 | 17343 | if (argc == 2) { |
| 17272 | 17344 | retcode = Jim_EvalObj(interp, argv[1]); |
| 17273 | 17345 | } |
| 17274 | 17346 | else { |
| | @@ -17366,15 +17438,15 @@ |
| 17366 | 17438 | if (i != argc - 1 && i != argc) { |
| 17367 | 17439 | Jim_WrongNumArgs(interp, 1, argv, |
| 17368 | 17440 | "?-code code? ?-errorinfo stacktrace? ?-level level? ?result?"); |
| 17369 | 17441 | } |
| 17370 | 17442 | |
| 17371 | | - |
| 17443 | + |
| 17372 | 17444 | if (stackTraceObj && returnCode == JIM_ERR) { |
| 17373 | 17445 | JimSetStackTrace(interp, stackTraceObj); |
| 17374 | 17446 | } |
| 17375 | | - |
| 17447 | + |
| 17376 | 17448 | if (errorCodeObj && returnCode == JIM_ERR) { |
| 17377 | 17449 | Jim_SetGlobalVariableStr(interp, "errorCode", errorCodeObj); |
| 17378 | 17450 | } |
| 17379 | 17451 | interp->returnCode = returnCode; |
| 17380 | 17452 | interp->returnLevel = level; |
| | @@ -17391,31 +17463,31 @@ |
| 17391 | 17463 | if (interp->framePtr->level == 0) { |
| 17392 | 17464 | Jim_SetResultString(interp, "tailcall can only be called from a proc or lambda", -1); |
| 17393 | 17465 | return JIM_ERR; |
| 17394 | 17466 | } |
| 17395 | 17467 | else if (argc >= 2) { |
| 17396 | | - |
| 17468 | + |
| 17397 | 17469 | Jim_CallFrame *cf = interp->framePtr->parent; |
| 17398 | 17470 | |
| 17399 | 17471 | Jim_Cmd *cmdPtr = Jim_GetCommand(interp, argv[1], JIM_ERRMSG); |
| 17400 | 17472 | if (cmdPtr == NULL) { |
| 17401 | 17473 | return JIM_ERR; |
| 17402 | 17474 | } |
| 17403 | 17475 | |
| 17404 | 17476 | JimPanic((cf->tailcallCmd != NULL, "Already have a tailcallCmd")); |
| 17405 | 17477 | |
| 17406 | | - |
| 17478 | + |
| 17407 | 17479 | JimIncrCmdRefCount(cmdPtr); |
| 17408 | 17480 | cf->tailcallCmd = cmdPtr; |
| 17409 | 17481 | |
| 17410 | | - |
| 17482 | + |
| 17411 | 17483 | JimPanic((cf->tailcallObj != NULL, "Already have a tailcallobj")); |
| 17412 | 17484 | |
| 17413 | 17485 | cf->tailcallObj = Jim_NewListObj(interp, argv + 1, argc - 1); |
| 17414 | 17486 | Jim_IncrRefCount(cf->tailcallObj); |
| 17415 | 17487 | |
| 17416 | | - |
| 17488 | + |
| 17417 | 17489 | return JIM_EVAL; |
| 17418 | 17490 | } |
| 17419 | 17491 | return JIM_OK; |
| 17420 | 17492 | } |
| 17421 | 17493 | |
| | @@ -17422,11 +17494,11 @@ |
| 17422 | 17494 | static int JimAliasCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 17423 | 17495 | { |
| 17424 | 17496 | Jim_Obj *cmdList; |
| 17425 | 17497 | Jim_Obj *prefixListObj = Jim_CmdPrivData(interp); |
| 17426 | 17498 | |
| 17427 | | - |
| 17499 | + |
| 17428 | 17500 | cmdList = Jim_DuplicateObj(interp, prefixListObj); |
| 17429 | 17501 | Jim_ListInsertElements(interp, cmdList, Jim_ListLength(interp, cmdList), argc - 1, argv + 1); |
| 17430 | 17502 | |
| 17431 | 17503 | return JimEvalObjList(interp, cmdList); |
| 17432 | 17504 | } |
| | @@ -17480,22 +17552,22 @@ |
| 17480 | 17552 | else { |
| 17481 | 17553 | cmd = JimCreateProcedureCmd(interp, argv[2], argv[3], argv[4], NULL); |
| 17482 | 17554 | } |
| 17483 | 17555 | |
| 17484 | 17556 | if (cmd) { |
| 17485 | | - |
| 17557 | + |
| 17486 | 17558 | Jim_Obj *qualifiedCmdNameObj; |
| 17487 | 17559 | const char *cmdname = JimQualifyName(interp, Jim_String(argv[1]), &qualifiedCmdNameObj); |
| 17488 | 17560 | |
| 17489 | 17561 | JimCreateCommand(interp, cmdname, cmd); |
| 17490 | 17562 | |
| 17491 | | - |
| 17563 | + |
| 17492 | 17564 | JimUpdateProcNamespace(interp, cmd, cmdname); |
| 17493 | 17565 | |
| 17494 | 17566 | JimFreeQualifiedName(interp, qualifiedCmdNameObj); |
| 17495 | 17567 | |
| 17496 | | - |
| 17568 | + |
| 17497 | 17569 | Jim_SetResult(interp, argv[1]); |
| 17498 | 17570 | return JIM_OK; |
| 17499 | 17571 | } |
| 17500 | 17572 | return JIM_ERR; |
| 17501 | 17573 | } |
| | @@ -17508,17 +17580,17 @@ |
| 17508 | 17580 | if (argc < 2) { |
| 17509 | 17581 | Jim_WrongNumArgs(interp, 1, argv, "cmd ?args ...?"); |
| 17510 | 17582 | return JIM_ERR; |
| 17511 | 17583 | } |
| 17512 | 17584 | |
| 17513 | | - |
| 17585 | + |
| 17514 | 17586 | interp->local++; |
| 17515 | 17587 | retcode = Jim_EvalObjVector(interp, argc - 1, argv + 1); |
| 17516 | 17588 | interp->local--; |
| 17517 | 17589 | |
| 17518 | 17590 | |
| 17519 | | - |
| 17591 | + |
| 17520 | 17592 | if (retcode == 0) { |
| 17521 | 17593 | Jim_Obj *cmdNameObj = Jim_GetResult(interp); |
| 17522 | 17594 | |
| 17523 | 17595 | if (Jim_GetCommand(interp, cmdNameObj, JIM_ERRMSG) == NULL) { |
| 17524 | 17596 | return JIM_ERR; |
| | @@ -17547,18 +17619,18 @@ |
| 17547 | 17619 | Jim_Cmd *cmdPtr = Jim_GetCommand(interp, argv[1], JIM_ERRMSG); |
| 17548 | 17620 | if (cmdPtr == NULL || !cmdPtr->isproc || !cmdPtr->prevCmd) { |
| 17549 | 17621 | Jim_SetResultFormatted(interp, "no previous command: \"%#s\"", argv[1]); |
| 17550 | 17622 | return JIM_ERR; |
| 17551 | 17623 | } |
| 17552 | | - |
| 17624 | + |
| 17553 | 17625 | cmdPtr->u.proc.upcall++; |
| 17554 | 17626 | JimIncrCmdRefCount(cmdPtr); |
| 17555 | 17627 | |
| 17556 | | - |
| 17628 | + |
| 17557 | 17629 | retcode = Jim_EvalObjVector(interp, argc - 1, argv + 1); |
| 17558 | 17630 | |
| 17559 | | - |
| 17631 | + |
| 17560 | 17632 | cmdPtr->u.proc.upcall--; |
| 17561 | 17633 | JimDecrCmdRefCount(interp, cmdPtr); |
| 17562 | 17634 | |
| 17563 | 17635 | return retcode; |
| 17564 | 17636 | } |
| | @@ -17585,11 +17657,11 @@ |
| 17585 | 17657 | return JIM_ERR; |
| 17586 | 17658 | } |
| 17587 | 17659 | |
| 17588 | 17660 | if (len == 3) { |
| 17589 | 17661 | #ifdef jim_ext_namespace |
| 17590 | | - |
| 17662 | + |
| 17591 | 17663 | nsObj = JimQualifyNameObj(interp, Jim_ListGetIndex(interp, argv[1], 2)); |
| 17592 | 17664 | #else |
| 17593 | 17665 | Jim_SetResultString(interp, "namespaces not enabled", -1); |
| 17594 | 17666 | return JIM_ERR; |
| 17595 | 17667 | #endif |
| | @@ -17598,11 +17670,11 @@ |
| 17598 | 17670 | bodyObjPtr = Jim_ListGetIndex(interp, argv[1], 1); |
| 17599 | 17671 | |
| 17600 | 17672 | cmd = JimCreateProcedureCmd(interp, argListObjPtr, NULL, bodyObjPtr, nsObj); |
| 17601 | 17673 | |
| 17602 | 17674 | if (cmd) { |
| 17603 | | - |
| 17675 | + |
| 17604 | 17676 | nargv = Jim_Alloc((argc - 2 + 1) * sizeof(*nargv)); |
| 17605 | 17677 | nargv[0] = Jim_NewStringObj(interp, "apply lambdaExpr", -1); |
| 17606 | 17678 | Jim_IncrRefCount(nargv[0]); |
| 17607 | 17679 | memcpy(&nargv[1], argv + 2, (argc - 2) * sizeof(*nargv)); |
| 17608 | 17680 | ret = JimCallProcedure(interp, cmd, argc - 2 + 1, nargv); |
| | @@ -17628,11 +17700,11 @@ |
| 17628 | 17700 | static int Jim_UpvarCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 17629 | 17701 | { |
| 17630 | 17702 | int i; |
| 17631 | 17703 | Jim_CallFrame *targetCallFrame; |
| 17632 | 17704 | |
| 17633 | | - |
| 17705 | + |
| 17634 | 17706 | if (argc > 3 && (argc % 2 == 0)) { |
| 17635 | 17707 | targetCallFrame = Jim_GetCallFrameByLevel(interp, argv[1]); |
| 17636 | 17708 | argc--; |
| 17637 | 17709 | argv++; |
| 17638 | 17710 | } |
| | @@ -17641,17 +17713,17 @@ |
| 17641 | 17713 | } |
| 17642 | 17714 | if (targetCallFrame == NULL) { |
| 17643 | 17715 | return JIM_ERR; |
| 17644 | 17716 | } |
| 17645 | 17717 | |
| 17646 | | - |
| 17718 | + |
| 17647 | 17719 | if (argc < 3) { |
| 17648 | 17720 | Jim_WrongNumArgs(interp, 1, argv, "?level? otherVar localVar ?otherVar localVar ...?"); |
| 17649 | 17721 | return JIM_ERR; |
| 17650 | 17722 | } |
| 17651 | 17723 | |
| 17652 | | - |
| 17724 | + |
| 17653 | 17725 | for (i = 1; i < argc; i += 2) { |
| 17654 | 17726 | if (Jim_SetVariableLink(interp, argv[i + 1], argv[i], targetCallFrame) != JIM_OK) |
| 17655 | 17727 | return JIM_ERR; |
| 17656 | 17728 | } |
| 17657 | 17729 | return JIM_OK; |
| | @@ -17664,15 +17736,15 @@ |
| 17664 | 17736 | |
| 17665 | 17737 | if (argc < 2) { |
| 17666 | 17738 | Jim_WrongNumArgs(interp, 1, argv, "varName ?varName ...?"); |
| 17667 | 17739 | return JIM_ERR; |
| 17668 | 17740 | } |
| 17669 | | - |
| 17741 | + |
| 17670 | 17742 | if (interp->framePtr->level == 0) |
| 17671 | | - return JIM_OK; |
| 17743 | + return JIM_OK; |
| 17672 | 17744 | for (i = 1; i < argc; i++) { |
| 17673 | | - |
| 17745 | + |
| 17674 | 17746 | const char *name = Jim_String(argv[i]); |
| 17675 | 17747 | if (name[0] != ':' || name[1] != ':') { |
| 17676 | 17748 | if (Jim_SetVariableLink(interp, argv[i], argv[i], interp->topFramePtr) != JIM_OK) |
| 17677 | 17749 | return JIM_ERR; |
| 17678 | 17750 | } |
| | @@ -17695,21 +17767,21 @@ |
| 17695 | 17767 | } |
| 17696 | 17768 | |
| 17697 | 17769 | str = Jim_String(objPtr); |
| 17698 | 17770 | strLen = Jim_Utf8Length(interp, objPtr); |
| 17699 | 17771 | |
| 17700 | | - |
| 17772 | + |
| 17701 | 17773 | resultObjPtr = Jim_NewStringObj(interp, "", 0); |
| 17702 | 17774 | while (strLen) { |
| 17703 | 17775 | for (i = 0; i < numMaps; i += 2) { |
| 17704 | | - Jim_Obj *eachObjPtr; |
| 17776 | + Jim_Obj *objPtr; |
| 17705 | 17777 | const char *k; |
| 17706 | 17778 | int kl; |
| 17707 | 17779 | |
| 17708 | | - eachObjPtr = Jim_ListGetIndex(interp, mapListObjPtr, i); |
| 17709 | | - k = Jim_String(eachObjPtr); |
| 17710 | | - kl = Jim_Utf8Length(interp, eachObjPtr); |
| 17780 | + objPtr = Jim_ListGetIndex(interp, mapListObjPtr, i); |
| 17781 | + k = Jim_String(objPtr); |
| 17782 | + kl = Jim_Utf8Length(interp, objPtr); |
| 17711 | 17783 | |
| 17712 | 17784 | if (strLen >= kl && kl) { |
| 17713 | 17785 | int rc; |
| 17714 | 17786 | rc = JimStringCompareLen(str, k, kl, nocase); |
| 17715 | 17787 | if (rc == 0) { |
| | @@ -17722,11 +17794,11 @@ |
| 17722 | 17794 | strLen -= kl; |
| 17723 | 17795 | break; |
| 17724 | 17796 | } |
| 17725 | 17797 | } |
| 17726 | 17798 | } |
| 17727 | | - if (i == numMaps) { |
| 17799 | + if (i == numMaps) { |
| 17728 | 17800 | int c; |
| 17729 | 17801 | if (noMatchStart == NULL) |
| 17730 | 17802 | noMatchStart = str; |
| 17731 | 17803 | str += utf8_tounicode(str, &c); |
| 17732 | 17804 | strLen--; |
| | @@ -17787,11 +17859,11 @@ |
| 17787 | 17859 | return JIM_OK; |
| 17788 | 17860 | |
| 17789 | 17861 | case OPT_CAT:{ |
| 17790 | 17862 | Jim_Obj *objPtr; |
| 17791 | 17863 | if (argc == 3) { |
| 17792 | | - |
| 17864 | + |
| 17793 | 17865 | objPtr = argv[2]; |
| 17794 | 17866 | } |
| 17795 | 17867 | else { |
| 17796 | 17868 | int i; |
| 17797 | 17869 | |
| | @@ -17806,11 +17878,11 @@ |
| 17806 | 17878 | } |
| 17807 | 17879 | |
| 17808 | 17880 | case OPT_COMPARE: |
| 17809 | 17881 | case OPT_EQUAL: |
| 17810 | 17882 | { |
| 17811 | | - |
| 17883 | + |
| 17812 | 17884 | long opt_length = -1; |
| 17813 | 17885 | int n = argc - 4; |
| 17814 | 17886 | int i = 2; |
| 17815 | 17887 | while (n > 0) { |
| 17816 | 17888 | int subopt; |
| | @@ -17819,16 +17891,16 @@ |
| 17819 | 17891 | badcompareargs: |
| 17820 | 17892 | Jim_WrongNumArgs(interp, 2, argv, "?-nocase? ?-length int? string1 string2"); |
| 17821 | 17893 | return JIM_ERR; |
| 17822 | 17894 | } |
| 17823 | 17895 | if (subopt == 0) { |
| 17824 | | - |
| 17896 | + |
| 17825 | 17897 | opt_case = 0; |
| 17826 | 17898 | n--; |
| 17827 | 17899 | } |
| 17828 | 17900 | else { |
| 17829 | | - |
| 17901 | + |
| 17830 | 17902 | if (n < 2) { |
| 17831 | 17903 | goto badcompareargs; |
| 17832 | 17904 | } |
| 17833 | 17905 | if (Jim_GetLong(interp, argv[i++], &opt_length) != JIM_OK) { |
| 17834 | 17906 | return JIM_ERR; |
| | @@ -17839,11 +17911,11 @@ |
| 17839 | 17911 | if (n) { |
| 17840 | 17912 | goto badcompareargs; |
| 17841 | 17913 | } |
| 17842 | 17914 | argv += argc - 2; |
| 17843 | 17915 | if (opt_length < 0 && option != OPT_COMPARE && opt_case) { |
| 17844 | | - |
| 17916 | + |
| 17845 | 17917 | Jim_SetResultBool(interp, Jim_StringEqObj(argv[0], argv[1])); |
| 17846 | 17918 | } |
| 17847 | 17919 | else { |
| 17848 | 17920 | if (opt_length >= 0) { |
| 17849 | 17921 | n = JimStringCompareLen(Jim_String(argv[0]), Jim_String(argv[1]), opt_length, !opt_case); |
| | @@ -17953,10 +18025,11 @@ |
| 17953 | 18025 | } |
| 17954 | 18026 | |
| 17955 | 18027 | case OPT_REVERSE:{ |
| 17956 | 18028 | char *buf, *p; |
| 17957 | 18029 | const char *str; |
| 18030 | + int len; |
| 17958 | 18031 | int i; |
| 17959 | 18032 | |
| 17960 | 18033 | if (argc != 3) { |
| 17961 | 18034 | Jim_WrongNumArgs(interp, 2, argv, "string"); |
| 17962 | 18035 | return JIM_ERR; |
| | @@ -17996,11 +18069,11 @@ |
| 17996 | 18069 | } |
| 17997 | 18070 | if (idx < 0 || idx >= len || str == NULL) { |
| 17998 | 18071 | Jim_SetResultString(interp, "", 0); |
| 17999 | 18072 | } |
| 18000 | 18073 | else if (len == Jim_Length(argv[2])) { |
| 18001 | | - |
| 18074 | + |
| 18002 | 18075 | Jim_SetResultString(interp, str + idx, 1); |
| 18003 | 18076 | } |
| 18004 | 18077 | else { |
| 18005 | 18078 | int c; |
| 18006 | 18079 | int i = utf8_index(str, idx); |
| | @@ -18150,11 +18223,11 @@ |
| 18150 | 18223 | { |
| 18151 | 18224 | int exitCode = 0; |
| 18152 | 18225 | int i; |
| 18153 | 18226 | int sig = 0; |
| 18154 | 18227 | |
| 18155 | | - |
| 18228 | + |
| 18156 | 18229 | jim_wide ignore_mask = (1 << JIM_EXIT) | (1 << JIM_EVAL) | (1 << JIM_SIGNAL); |
| 18157 | 18230 | static const int max_ignore_code = sizeof(ignore_mask) * 8; |
| 18158 | 18231 | |
| 18159 | 18232 | Jim_SetGlobalVariableStr(interp, "errorCode", Jim_NewStringObj(interp, "NONE", -1)); |
| 18160 | 18233 | |
| | @@ -18161,11 +18234,11 @@ |
| 18161 | 18234 | for (i = 1; i < argc - 1; i++) { |
| 18162 | 18235 | const char *arg = Jim_String(argv[i]); |
| 18163 | 18236 | jim_wide option; |
| 18164 | 18237 | int ignore; |
| 18165 | 18238 | |
| 18166 | | - |
| 18239 | + |
| 18167 | 18240 | if (strcmp(arg, "--") == 0) { |
| 18168 | 18241 | i++; |
| 18169 | 18242 | break; |
| 18170 | 18243 | } |
| 18171 | 18244 | if (*arg != '-') { |
| | @@ -18212,28 +18285,28 @@ |
| 18212 | 18285 | sig++; |
| 18213 | 18286 | } |
| 18214 | 18287 | |
| 18215 | 18288 | interp->signal_level += sig; |
| 18216 | 18289 | if (Jim_CheckSignal(interp)) { |
| 18217 | | - |
| 18290 | + |
| 18218 | 18291 | exitCode = JIM_SIGNAL; |
| 18219 | 18292 | } |
| 18220 | 18293 | else { |
| 18221 | 18294 | exitCode = Jim_EvalObj(interp, argv[0]); |
| 18222 | | - |
| 18295 | + |
| 18223 | 18296 | interp->errorFlag = 0; |
| 18224 | 18297 | } |
| 18225 | 18298 | interp->signal_level -= sig; |
| 18226 | 18299 | |
| 18227 | | - |
| 18300 | + |
| 18228 | 18301 | if (exitCode >= 0 && exitCode < max_ignore_code && (((unsigned jim_wide)1 << exitCode) & ignore_mask)) { |
| 18229 | | - |
| 18302 | + |
| 18230 | 18303 | return exitCode; |
| 18231 | 18304 | } |
| 18232 | 18305 | |
| 18233 | 18306 | if (sig && exitCode == JIM_SIGNAL) { |
| 18234 | | - |
| 18307 | + |
| 18235 | 18308 | if (interp->signal_set_result) { |
| 18236 | 18309 | interp->signal_set_result(interp, interp->sigmask); |
| 18237 | 18310 | } |
| 18238 | 18311 | else { |
| 18239 | 18312 | Jim_SetResultInt(interp, interp->sigmask); |
| | @@ -18272,10 +18345,125 @@ |
| 18272 | 18345 | } |
| 18273 | 18346 | Jim_SetResultInt(interp, exitCode); |
| 18274 | 18347 | return JIM_OK; |
| 18275 | 18348 | } |
| 18276 | 18349 | |
| 18350 | +#ifdef JIM_REFERENCES |
| 18351 | + |
| 18352 | + |
| 18353 | +static int Jim_RefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 18354 | +{ |
| 18355 | + if (argc != 3 && argc != 4) { |
| 18356 | + Jim_WrongNumArgs(interp, 1, argv, "string tag ?finalizer?"); |
| 18357 | + return JIM_ERR; |
| 18358 | + } |
| 18359 | + if (argc == 3) { |
| 18360 | + Jim_SetResult(interp, Jim_NewReference(interp, argv[1], argv[2], NULL)); |
| 18361 | + } |
| 18362 | + else { |
| 18363 | + Jim_SetResult(interp, Jim_NewReference(interp, argv[1], argv[2], argv[3])); |
| 18364 | + } |
| 18365 | + return JIM_OK; |
| 18366 | +} |
| 18367 | + |
| 18368 | + |
| 18369 | +static int Jim_GetrefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 18370 | +{ |
| 18371 | + Jim_Reference *refPtr; |
| 18372 | + |
| 18373 | + if (argc != 2) { |
| 18374 | + Jim_WrongNumArgs(interp, 1, argv, "reference"); |
| 18375 | + return JIM_ERR; |
| 18376 | + } |
| 18377 | + if ((refPtr = Jim_GetReference(interp, argv[1])) == NULL) |
| 18378 | + return JIM_ERR; |
| 18379 | + Jim_SetResult(interp, refPtr->objPtr); |
| 18380 | + return JIM_OK; |
| 18381 | +} |
| 18382 | + |
| 18383 | + |
| 18384 | +static int Jim_SetrefCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 18385 | +{ |
| 18386 | + Jim_Reference *refPtr; |
| 18387 | + |
| 18388 | + if (argc != 3) { |
| 18389 | + Jim_WrongNumArgs(interp, 1, argv, "reference newValue"); |
| 18390 | + return JIM_ERR; |
| 18391 | + } |
| 18392 | + if ((refPtr = Jim_GetReference(interp, argv[1])) == NULL) |
| 18393 | + return JIM_ERR; |
| 18394 | + Jim_IncrRefCount(argv[2]); |
| 18395 | + Jim_DecrRefCount(interp, refPtr->objPtr); |
| 18396 | + refPtr->objPtr = argv[2]; |
| 18397 | + Jim_SetResult(interp, argv[2]); |
| 18398 | + return JIM_OK; |
| 18399 | +} |
| 18400 | + |
| 18401 | + |
| 18402 | +static int Jim_CollectCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 18403 | +{ |
| 18404 | + if (argc != 1) { |
| 18405 | + Jim_WrongNumArgs(interp, 1, argv, ""); |
| 18406 | + return JIM_ERR; |
| 18407 | + } |
| 18408 | + Jim_SetResultInt(interp, Jim_Collect(interp)); |
| 18409 | + |
| 18410 | + |
| 18411 | + while (interp->freeList) { |
| 18412 | + Jim_Obj *nextObjPtr = interp->freeList->nextObjPtr; |
| 18413 | + Jim_Free(interp->freeList); |
| 18414 | + interp->freeList = nextObjPtr; |
| 18415 | + } |
| 18416 | + |
| 18417 | + return JIM_OK; |
| 18418 | +} |
| 18419 | + |
| 18420 | + |
| 18421 | +static int Jim_FinalizeCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 18422 | +{ |
| 18423 | + if (argc != 2 && argc != 3) { |
| 18424 | + Jim_WrongNumArgs(interp, 1, argv, "reference ?finalizerProc?"); |
| 18425 | + return JIM_ERR; |
| 18426 | + } |
| 18427 | + if (argc == 2) { |
| 18428 | + Jim_Obj *cmdNamePtr; |
| 18429 | + |
| 18430 | + if (Jim_GetFinalizer(interp, argv[1], &cmdNamePtr) != JIM_OK) |
| 18431 | + return JIM_ERR; |
| 18432 | + if (cmdNamePtr != NULL) |
| 18433 | + Jim_SetResult(interp, cmdNamePtr); |
| 18434 | + } |
| 18435 | + else { |
| 18436 | + if (Jim_SetFinalizer(interp, argv[1], argv[2]) != JIM_OK) |
| 18437 | + return JIM_ERR; |
| 18438 | + Jim_SetResult(interp, argv[2]); |
| 18439 | + } |
| 18440 | + return JIM_OK; |
| 18441 | +} |
| 18442 | + |
| 18443 | + |
| 18444 | +static int JimInfoReferences(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 18445 | +{ |
| 18446 | + Jim_Obj *listObjPtr; |
| 18447 | + Jim_HashTableIterator htiter; |
| 18448 | + Jim_HashEntry *he; |
| 18449 | + |
| 18450 | + listObjPtr = Jim_NewListObj(interp, NULL, 0); |
| 18451 | + |
| 18452 | + JimInitHashTableIterator(&interp->references, &htiter); |
| 18453 | + while ((he = Jim_NextHashEntry(&htiter)) != NULL) { |
| 18454 | + char buf[JIM_REFERENCE_SPACE + 1]; |
| 18455 | + Jim_Reference *refPtr = Jim_GetHashEntryVal(he); |
| 18456 | + const unsigned long *refId = he->key; |
| 18457 | + |
| 18458 | + JimFormatReference(buf, refPtr, *refId); |
| 18459 | + Jim_ListAppendElement(interp, listObjPtr, Jim_NewStringObj(interp, buf, -1)); |
| 18460 | + } |
| 18461 | + Jim_SetResult(interp, listObjPtr); |
| 18462 | + return JIM_OK; |
| 18463 | +} |
| 18464 | +#endif |
| 18277 | 18465 | |
| 18278 | 18466 | |
| 18279 | 18467 | static int Jim_RenameCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 18280 | 18468 | { |
| 18281 | 18469 | if (argc != 3) { |
| | @@ -18306,11 +18494,11 @@ |
| 18306 | 18494 | JimDictMatchCallbackType *callback, int type) |
| 18307 | 18495 | { |
| 18308 | 18496 | Jim_HashEntry *he; |
| 18309 | 18497 | Jim_Obj *listObjPtr = Jim_NewListObj(interp, NULL, 0); |
| 18310 | 18498 | |
| 18311 | | - |
| 18499 | + |
| 18312 | 18500 | Jim_HashTableIterator htiter; |
| 18313 | 18501 | JimInitHashTableIterator(ht, &htiter); |
| 18314 | 18502 | while ((he = Jim_NextHashEntry(&htiter)) != NULL) { |
| 18315 | 18503 | if (patternObjPtr == NULL || JimGlobMatch(Jim_String(patternObjPtr), Jim_String((Jim_Obj *)he->key), 0)) { |
| 18316 | 18504 | callback(interp, listObjPtr, he, type); |
| | @@ -18356,11 +18544,11 @@ |
| 18356 | 18544 | return JIM_ERR; |
| 18357 | 18545 | } |
| 18358 | 18546 | |
| 18359 | 18547 | ht = (Jim_HashTable *)objPtr->internalRep.ptr; |
| 18360 | 18548 | |
| 18361 | | - |
| 18549 | + |
| 18362 | 18550 | printf("%d entries in table, %d buckets\n", ht->used, ht->size); |
| 18363 | 18551 | |
| 18364 | 18552 | for (i = 0; i < ht->size; i++) { |
| 18365 | 18553 | Jim_HashEntry *he = ht->table[i]; |
| 18366 | 18554 | |
| | @@ -18480,16 +18668,16 @@ |
| 18480 | 18668 | return JIM_OK; |
| 18481 | 18669 | } |
| 18482 | 18670 | if (Jim_DictSize(interp, argv[2]) < 0) { |
| 18483 | 18671 | return JIM_ERR; |
| 18484 | 18672 | } |
| 18485 | | - |
| 18673 | + |
| 18486 | 18674 | break; |
| 18487 | 18675 | |
| 18488 | 18676 | case OPT_UPDATE: |
| 18489 | 18677 | if (argc < 6 || argc % 2) { |
| 18490 | | - |
| 18678 | + |
| 18491 | 18679 | argc = 2; |
| 18492 | 18680 | } |
| 18493 | 18681 | break; |
| 18494 | 18682 | |
| 18495 | 18683 | case OPT_CREATE: |
| | @@ -18506,11 +18694,11 @@ |
| 18506 | 18694 | Jim_WrongNumArgs(interp, 2, argv, "dictionary"); |
| 18507 | 18695 | return JIM_ERR; |
| 18508 | 18696 | } |
| 18509 | 18697 | return Jim_DictInfo(interp, argv[2]); |
| 18510 | 18698 | } |
| 18511 | | - |
| 18699 | + |
| 18512 | 18700 | return Jim_EvalEnsemble(interp, "dict", options[option], argc - 2, argv + 2); |
| 18513 | 18701 | } |
| 18514 | 18702 | |
| 18515 | 18703 | |
| 18516 | 18704 | static int Jim_SubstCoreCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| | @@ -18576,11 +18764,11 @@ |
| 18576 | 18764 | |
| 18577 | 18765 | #ifdef jim_ext_namespace |
| 18578 | 18766 | int nons = 0; |
| 18579 | 18767 | |
| 18580 | 18768 | if (argc > 2 && Jim_CompareStringImmediate(interp, argv[1], "-nons")) { |
| 18581 | | - |
| 18769 | + |
| 18582 | 18770 | argc--; |
| 18583 | 18771 | argv++; |
| 18584 | 18772 | nons = 1; |
| 18585 | 18773 | } |
| 18586 | 18774 | #endif |
| | @@ -18592,11 +18780,11 @@ |
| 18592 | 18780 | if (Jim_GetEnum(interp, argv[1], commands, &cmd, "subcommand", JIM_ERRMSG | JIM_ENUM_ABBREV) |
| 18593 | 18781 | != JIM_OK) { |
| 18594 | 18782 | return JIM_ERR; |
| 18595 | 18783 | } |
| 18596 | 18784 | |
| 18597 | | - |
| 18785 | + |
| 18598 | 18786 | switch (cmd) { |
| 18599 | 18787 | case INFO_EXISTS: |
| 18600 | 18788 | if (argc != 3) { |
| 18601 | 18789 | Jim_WrongNumArgs(interp, 2, argv, "varName"); |
| 18602 | 18790 | return JIM_ERR; |
| | @@ -18621,21 +18809,21 @@ |
| 18621 | 18809 | Jim_SetResult(interp, (Jim_Obj *)cmdPtr->u.native.privData); |
| 18622 | 18810 | return JIM_OK; |
| 18623 | 18811 | } |
| 18624 | 18812 | |
| 18625 | 18813 | case INFO_CHANNELS: |
| 18626 | | - mode++; |
| 18814 | + mode++; |
| 18627 | 18815 | #ifndef jim_ext_aio |
| 18628 | 18816 | Jim_SetResultString(interp, "aio not enabled", -1); |
| 18629 | 18817 | return JIM_ERR; |
| 18630 | 18818 | #endif |
| 18631 | | - |
| 18819 | + |
| 18632 | 18820 | case INFO_PROCS: |
| 18633 | | - mode++; |
| 18634 | | - |
| 18821 | + mode++; |
| 18822 | + |
| 18635 | 18823 | case INFO_COMMANDS: |
| 18636 | | - |
| 18824 | + |
| 18637 | 18825 | if (argc != 2 && argc != 3) { |
| 18638 | 18826 | Jim_WrongNumArgs(interp, 2, argv, "?pattern?"); |
| 18639 | 18827 | return JIM_ERR; |
| 18640 | 18828 | } |
| 18641 | 18829 | #ifdef jim_ext_namespace |
| | @@ -18647,17 +18835,17 @@ |
| 18647 | 18835 | #endif |
| 18648 | 18836 | Jim_SetResult(interp, JimCommandsList(interp, (argc == 3) ? argv[2] : NULL, mode)); |
| 18649 | 18837 | break; |
| 18650 | 18838 | |
| 18651 | 18839 | case INFO_VARS: |
| 18652 | | - mode++; |
| 18653 | | - |
| 18840 | + mode++; |
| 18841 | + |
| 18654 | 18842 | case INFO_LOCALS: |
| 18655 | | - mode++; |
| 18656 | | - |
| 18843 | + mode++; |
| 18844 | + |
| 18657 | 18845 | case INFO_GLOBALS: |
| 18658 | | - |
| 18846 | + |
| 18659 | 18847 | if (argc != 2 && argc != 3) { |
| 18660 | 18848 | Jim_WrongNumArgs(interp, 2, argv, "?pattern?"); |
| 18661 | 18849 | return JIM_ERR; |
| 18662 | 18850 | } |
| 18663 | 18851 | #ifdef jim_ext_namespace |
| | @@ -18763,12 +18951,13 @@ |
| 18763 | 18951 | case INFO_ARGS: |
| 18764 | 18952 | Jim_SetResult(interp, cmdPtr->u.proc.argListObjPtr); |
| 18765 | 18953 | break; |
| 18766 | 18954 | case INFO_STATICS: |
| 18767 | 18955 | if (cmdPtr->u.proc.staticVars) { |
| 18956 | + int mode = JIM_VARLIST_LOCALS | JIM_VARLIST_VALUES; |
| 18768 | 18957 | Jim_SetResult(interp, JimHashtablePatternMatch(interp, cmdPtr->u.proc.staticVars, |
| 18769 | | - NULL, JimVariablesMatch, JIM_VARLIST_LOCALS | JIM_VARLIST_VALUES)); |
| 18958 | + NULL, JimVariablesMatch, mode)); |
| 18770 | 18959 | } |
| 18771 | 18960 | break; |
| 18772 | 18961 | } |
| 18773 | 18962 | break; |
| 18774 | 18963 | } |
| | @@ -18796,15 +18985,15 @@ |
| 18796 | 18985 | } |
| 18797 | 18986 | } |
| 18798 | 18987 | break; |
| 18799 | 18988 | |
| 18800 | 18989 | case INFO_HOSTNAME: |
| 18801 | | - |
| 18990 | + |
| 18802 | 18991 | return Jim_Eval(interp, "os.gethostname"); |
| 18803 | 18992 | |
| 18804 | 18993 | case INFO_NAMEOFEXECUTABLE: |
| 18805 | | - |
| 18994 | + |
| 18806 | 18995 | return Jim_Eval(interp, "{info nameofexecutable}"); |
| 18807 | 18996 | |
| 18808 | 18997 | case INFO_RETURNCODES: |
| 18809 | 18998 | if (argc == 2) { |
| 18810 | 18999 | int i; |
| | @@ -18881,11 +19070,11 @@ |
| 18881 | 19070 | |
| 18882 | 19071 | if (option == OPT_VAR) { |
| 18883 | 19072 | result = Jim_GetVariable(interp, objPtr, 0) != NULL; |
| 18884 | 19073 | } |
| 18885 | 19074 | else { |
| 18886 | | - |
| 19075 | + |
| 18887 | 19076 | Jim_Cmd *cmd = Jim_GetCommand(interp, objPtr, JIM_NONE); |
| 18888 | 19077 | |
| 18889 | 19078 | if (cmd) { |
| 18890 | 19079 | switch (option) { |
| 18891 | 19080 | case OPT_COMMAND: |
| | @@ -18924,11 +19113,11 @@ |
| 18924 | 19113 | if (len == 0) { |
| 18925 | 19114 | return JIM_OK; |
| 18926 | 19115 | } |
| 18927 | 19116 | strLen = Jim_Utf8Length(interp, argv[1]); |
| 18928 | 19117 | |
| 18929 | | - |
| 19118 | + |
| 18930 | 19119 | if (argc == 2) { |
| 18931 | 19120 | splitChars = " \n\t\r"; |
| 18932 | 19121 | splitLen = 4; |
| 18933 | 19122 | } |
| 18934 | 19123 | else { |
| | @@ -18937,11 +19126,11 @@ |
| 18937 | 19126 | } |
| 18938 | 19127 | |
| 18939 | 19128 | noMatchStart = str; |
| 18940 | 19129 | resObjPtr = Jim_NewListObj(interp, NULL, 0); |
| 18941 | 19130 | |
| 18942 | | - |
| 19131 | + |
| 18943 | 19132 | if (splitLen) { |
| 18944 | 19133 | Jim_Obj *objPtr; |
| 18945 | 19134 | while (strLen--) { |
| 18946 | 19135 | const char *sc = splitChars; |
| 18947 | 19136 | int scLen = splitLen; |
| | @@ -18966,11 +19155,11 @@ |
| 18966 | 19155 | #define NUM_COMMON (128 - 9) |
| 18967 | 19156 | while (strLen--) { |
| 18968 | 19157 | int n = utf8_tounicode(str, &c); |
| 18969 | 19158 | #ifdef JIM_OPTIMIZATION |
| 18970 | 19159 | if (c >= 9 && c < 128) { |
| 18971 | | - |
| 19160 | + |
| 18972 | 19161 | c -= 9; |
| 18973 | 19162 | if (!commonObj) { |
| 18974 | 19163 | commonObj = Jim_Alloc(sizeof(*commonObj) * NUM_COMMON); |
| 18975 | 19164 | memset(commonObj, 0, sizeof(*commonObj) * NUM_COMMON); |
| 18976 | 19165 | } |
| | @@ -19000,11 +19189,11 @@ |
| 19000 | 19189 | |
| 19001 | 19190 | if (argc != 2 && argc != 3) { |
| 19002 | 19191 | Jim_WrongNumArgs(interp, 1, argv, "list ?joinString?"); |
| 19003 | 19192 | return JIM_ERR; |
| 19004 | 19193 | } |
| 19005 | | - |
| 19194 | + |
| 19006 | 19195 | if (argc == 2) { |
| 19007 | 19196 | joinStr = " "; |
| 19008 | 19197 | joinStrLen = 1; |
| 19009 | 19198 | } |
| 19010 | 19199 | else { |
| | @@ -19279,13 +19468,13 @@ |
| 19279 | 19468 | return -1; |
| 19280 | 19469 | else if (step < 0 && end > start) |
| 19281 | 19470 | return -1; |
| 19282 | 19471 | len = end - start; |
| 19283 | 19472 | if (len < 0) |
| 19284 | | - len = -len; |
| 19473 | + len = -len; |
| 19285 | 19474 | if (step < 0) |
| 19286 | | - step = -step; |
| 19475 | + step = -step; |
| 19287 | 19476 | len = 1 + ((len - 1) / step); |
| 19288 | 19477 | if (len > INT_MAX) |
| 19289 | 19478 | len = INT_MAX; |
| 19290 | 19479 | return (int)((len < 0) ? -1 : len); |
| 19291 | 19480 | } |
| | @@ -19499,11 +19688,11 @@ |
| 19499 | 19688 | |
| 19500 | 19689 | *indexPtr = -1; |
| 19501 | 19690 | |
| 19502 | 19691 | for (entryPtr = tablePtr, i = 0; *entryPtr != NULL; entryPtr++, i++) { |
| 19503 | 19692 | if (Jim_CompareStringImmediate(interp, objPtr, *entryPtr)) { |
| 19504 | | - |
| 19693 | + |
| 19505 | 19694 | *indexPtr = i; |
| 19506 | 19695 | return JIM_OK; |
| 19507 | 19696 | } |
| 19508 | 19697 | if (flags & JIM_ENUM_ABBREV) { |
| 19509 | 19698 | if (strncmp(arg, *entryPtr, arglen) == 0) { |
| | @@ -19517,11 +19706,11 @@ |
| 19517 | 19706 | match = i; |
| 19518 | 19707 | } |
| 19519 | 19708 | } |
| 19520 | 19709 | } |
| 19521 | 19710 | |
| 19522 | | - |
| 19711 | + |
| 19523 | 19712 | if (match >= 0) { |
| 19524 | 19713 | *indexPtr = match; |
| 19525 | 19714 | return JIM_OK; |
| 19526 | 19715 | } |
| 19527 | 19716 | |
| | @@ -19554,11 +19743,11 @@ |
| 19554 | 19743 | return objPtr->typePtr == &listObjType; |
| 19555 | 19744 | } |
| 19556 | 19745 | |
| 19557 | 19746 | void Jim_SetResultFormatted(Jim_Interp *interp, const char *format, ...) |
| 19558 | 19747 | { |
| 19559 | | - |
| 19748 | + |
| 19560 | 19749 | int len = strlen(format); |
| 19561 | 19750 | int extra = 0; |
| 19562 | 19751 | int n = 0; |
| 19563 | 19752 | const char *params[5]; |
| 19564 | 19753 | char *buf; |
| | @@ -19619,11 +19808,11 @@ |
| 19619 | 19808 | #include <string.h> |
| 19620 | 19809 | |
| 19621 | 19810 | |
| 19622 | 19811 | static int subcmd_null(Jim_Interp *interp, int argc, Jim_Obj *const *argv) |
| 19623 | 19812 | { |
| 19624 | | - |
| 19813 | + |
| 19625 | 19814 | return JIM_OK; |
| 19626 | 19815 | } |
| 19627 | 19816 | |
| 19628 | 19817 | static const jim_subcmd_type dummy_subcmd = { |
| 19629 | 19818 | "dummy", NULL, subcmd_null, 0, 0, JIM_MODFLAG_HIDDEN |
| | @@ -19698,43 +19887,43 @@ |
| 19698 | 19887 | return 0; |
| 19699 | 19888 | } |
| 19700 | 19889 | |
| 19701 | 19890 | cmd = argv[1]; |
| 19702 | 19891 | |
| 19703 | | - |
| 19892 | + |
| 19704 | 19893 | if (Jim_CompareStringImmediate(interp, cmd, "-help")) { |
| 19705 | 19894 | if (argc == 2) { |
| 19706 | | - |
| 19895 | + |
| 19707 | 19896 | show_cmd_usage(interp, command_table, argc, argv); |
| 19708 | 19897 | return &dummy_subcmd; |
| 19709 | 19898 | } |
| 19710 | 19899 | help = 1; |
| 19711 | 19900 | |
| 19712 | | - |
| 19901 | + |
| 19713 | 19902 | cmd = argv[2]; |
| 19714 | 19903 | } |
| 19715 | 19904 | |
| 19716 | | - |
| 19905 | + |
| 19717 | 19906 | if (Jim_CompareStringImmediate(interp, cmd, "-commands")) { |
| 19718 | | - |
| 19907 | + |
| 19719 | 19908 | Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); |
| 19720 | 19909 | add_commands(interp, command_table, " "); |
| 19721 | 19910 | return &dummy_subcmd; |
| 19722 | 19911 | } |
| 19723 | 19912 | |
| 19724 | 19913 | cmdstr = Jim_GetString(cmd, &cmdlen); |
| 19725 | 19914 | |
| 19726 | 19915 | for (ct = command_table; ct->cmd; ct++) { |
| 19727 | 19916 | if (Jim_CompareStringImmediate(interp, cmd, ct->cmd)) { |
| 19728 | | - |
| 19917 | + |
| 19729 | 19918 | break; |
| 19730 | 19919 | } |
| 19731 | 19920 | if (strncmp(cmdstr, ct->cmd, cmdlen) == 0) { |
| 19732 | 19921 | if (partial) { |
| 19733 | | - |
| 19922 | + |
| 19734 | 19923 | if (help) { |
| 19735 | | - |
| 19924 | + |
| 19736 | 19925 | show_cmd_usage(interp, command_table, argc, argv); |
| 19737 | 19926 | return &dummy_subcmd; |
| 19738 | 19927 | } |
| 19739 | 19928 | bad_subcmd(interp, command_table, "ambiguous", argv[0], argv[1 + help]); |
| 19740 | 19929 | return 0; |
| | @@ -19742,44 +19931,44 @@ |
| 19742 | 19931 | partial = ct; |
| 19743 | 19932 | } |
| 19744 | 19933 | continue; |
| 19745 | 19934 | } |
| 19746 | 19935 | |
| 19747 | | - |
| 19936 | + |
| 19748 | 19937 | if (partial && !ct->cmd) { |
| 19749 | 19938 | ct = partial; |
| 19750 | 19939 | } |
| 19751 | 19940 | |
| 19752 | 19941 | if (!ct->cmd) { |
| 19753 | | - |
| 19942 | + |
| 19754 | 19943 | if (help) { |
| 19755 | | - |
| 19944 | + |
| 19756 | 19945 | show_cmd_usage(interp, command_table, argc, argv); |
| 19757 | 19946 | return &dummy_subcmd; |
| 19758 | 19947 | } |
| 19759 | 19948 | bad_subcmd(interp, command_table, "unknown", argv[0], argv[1 + help]); |
| 19760 | 19949 | return 0; |
| 19761 | 19950 | } |
| 19762 | 19951 | |
| 19763 | 19952 | if (help) { |
| 19764 | 19953 | Jim_SetResultString(interp, "Usage: ", -1); |
| 19765 | | - |
| 19954 | + |
| 19766 | 19955 | add_cmd_usage(interp, ct, argv[0]); |
| 19767 | 19956 | return &dummy_subcmd; |
| 19768 | 19957 | } |
| 19769 | 19958 | |
| 19770 | | - |
| 19959 | + |
| 19771 | 19960 | if (argc - 2 < ct->minargs || (ct->maxargs >= 0 && argc - 2 > ct->maxargs)) { |
| 19772 | 19961 | Jim_SetResultString(interp, "wrong # args: should be \"", -1); |
| 19773 | | - |
| 19962 | + |
| 19774 | 19963 | add_cmd_usage(interp, ct, argv[0]); |
| 19775 | 19964 | Jim_AppendStrings(interp, Jim_GetResult(interp), "\"", NULL); |
| 19776 | 19965 | |
| 19777 | 19966 | return 0; |
| 19778 | 19967 | } |
| 19779 | 19968 | |
| 19780 | | - |
| 19969 | + |
| 19781 | 19970 | return ct; |
| 19782 | 19971 | } |
| 19783 | 19972 | |
| 19784 | 19973 | int Jim_CallSubCmd(Jim_Interp *interp, const jim_subcmd_type * ct, int argc, Jim_Obj *const *argv) |
| 19785 | 19974 | { |
| | @@ -19830,11 +20019,11 @@ |
| 19830 | 20019 | *p++ = 0xe0 | ((uc & 0xf000) >> 12); |
| 19831 | 20020 | *p++ = 0x80 | ((uc & 0xfc0) >> 6); |
| 19832 | 20021 | *p = 0x80 | (uc & 0x3f); |
| 19833 | 20022 | return 3; |
| 19834 | 20023 | } |
| 19835 | | - |
| 20024 | + |
| 19836 | 20025 | else { |
| 19837 | 20026 | *p++ = 0xf0 | ((uc & 0x1c0000) >> 18); |
| 19838 | 20027 | *p++ = 0x80 | ((uc & 0x3f000) >> 12); |
| 19839 | 20028 | *p++ = 0x80 | ((uc & 0xfc0) >> 6); |
| 19840 | 20029 | *p = 0x80 | (uc & 0x3f); |
| | @@ -20021,11 +20210,11 @@ |
| 20021 | 20210 | if (ch == 'h') { |
| 20022 | 20211 | useShort = 1; |
| 20023 | 20212 | format += step; |
| 20024 | 20213 | step = utf8_tounicode(format, &ch); |
| 20025 | 20214 | } else if (ch == 'l') { |
| 20026 | | - |
| 20215 | + |
| 20027 | 20216 | format += step; |
| 20028 | 20217 | step = utf8_tounicode(format, &ch); |
| 20029 | 20218 | if (ch == 'l') { |
| 20030 | 20219 | format += step; |
| 20031 | 20220 | step = utf8_tounicode(format, &ch); |
| | @@ -20048,11 +20237,11 @@ |
| 20048 | 20237 | goto errorMsg; |
| 20049 | 20238 | case 's': { |
| 20050 | 20239 | formatted_buf = Jim_GetString(objv[objIndex], &formatted_bytes); |
| 20051 | 20240 | formatted_chars = Jim_Utf8Length(interp, objv[objIndex]); |
| 20052 | 20241 | if (gotPrecision && (precision < formatted_chars)) { |
| 20053 | | - |
| 20242 | + |
| 20054 | 20243 | formatted_chars = precision; |
| 20055 | 20244 | formatted_bytes = utf8_index(formatted_buf, precision); |
| 20056 | 20245 | } |
| 20057 | 20246 | break; |
| 20058 | 20247 | } |
| | @@ -20060,11 +20249,11 @@ |
| 20060 | 20249 | jim_wide code; |
| 20061 | 20250 | |
| 20062 | 20251 | if (Jim_GetWide(interp, objv[objIndex], &code) != JIM_OK) { |
| 20063 | 20252 | goto error; |
| 20064 | 20253 | } |
| 20065 | | - |
| 20254 | + |
| 20066 | 20255 | formatted_bytes = utf8_getchars(spec, code); |
| 20067 | 20256 | formatted_buf = spec; |
| 20068 | 20257 | formatted_chars = 1; |
| 20069 | 20258 | break; |
| 20070 | 20259 | } |
| | @@ -20078,11 +20267,11 @@ |
| 20078 | 20267 | goto error; |
| 20079 | 20268 | } |
| 20080 | 20269 | length = sizeof(w) * 8; |
| 20081 | 20270 | |
| 20082 | 20271 | |
| 20083 | | - |
| 20272 | + |
| 20084 | 20273 | if (num_buffer_size < length + 1) { |
| 20085 | 20274 | num_buffer_size = length + 1; |
| 20086 | 20275 | num_buffer = Jim_Realloc(num_buffer, num_buffer_size); |
| 20087 | 20276 | } |
| 20088 | 20277 | |
| | @@ -20106,29 +20295,29 @@ |
| 20106 | 20295 | case 'E': |
| 20107 | 20296 | case 'f': |
| 20108 | 20297 | case 'g': |
| 20109 | 20298 | case 'G': |
| 20110 | 20299 | doubleType = 1; |
| 20111 | | - |
| 20300 | + |
| 20112 | 20301 | case 'd': |
| 20113 | 20302 | case 'u': |
| 20114 | 20303 | case 'o': |
| 20115 | 20304 | case 'x': |
| 20116 | 20305 | case 'X': { |
| 20117 | 20306 | jim_wide w; |
| 20118 | 20307 | double d; |
| 20119 | 20308 | int length; |
| 20120 | 20309 | |
| 20121 | | - |
| 20310 | + |
| 20122 | 20311 | if (width) { |
| 20123 | 20312 | p += sprintf(p, "%ld", width); |
| 20124 | 20313 | } |
| 20125 | 20314 | if (gotPrecision) { |
| 20126 | 20315 | p += sprintf(p, ".%ld", precision); |
| 20127 | 20316 | } |
| 20128 | 20317 | |
| 20129 | | - |
| 20318 | + |
| 20130 | 20319 | if (doubleType) { |
| 20131 | 20320 | if (Jim_GetDouble(interp, objv[objIndex], &d) != JIM_OK) { |
| 20132 | 20321 | goto error; |
| 20133 | 20322 | } |
| 20134 | 20323 | length = MAX_FLOAT_WIDTH; |
| | @@ -20155,19 +20344,19 @@ |
| 20155 | 20344 | } |
| 20156 | 20345 | |
| 20157 | 20346 | *p++ = (char) ch; |
| 20158 | 20347 | *p = '\0'; |
| 20159 | 20348 | |
| 20160 | | - |
| 20349 | + |
| 20161 | 20350 | if (width > length) { |
| 20162 | 20351 | length = width; |
| 20163 | 20352 | } |
| 20164 | 20353 | if (gotPrecision) { |
| 20165 | 20354 | length += precision; |
| 20166 | 20355 | } |
| 20167 | 20356 | |
| 20168 | | - |
| 20357 | + |
| 20169 | 20358 | if (num_buffer_size < length + 1) { |
| 20170 | 20359 | num_buffer_size = length + 1; |
| 20171 | 20360 | num_buffer = Jim_Realloc(num_buffer, num_buffer_size); |
| 20172 | 20361 | } |
| 20173 | 20362 | |
| | @@ -20181,11 +20370,11 @@ |
| 20181 | 20370 | formatted_buf = num_buffer; |
| 20182 | 20371 | break; |
| 20183 | 20372 | } |
| 20184 | 20373 | |
| 20185 | 20374 | default: { |
| 20186 | | - |
| 20375 | + |
| 20187 | 20376 | spec[0] = ch; |
| 20188 | 20377 | spec[1] = '\0'; |
| 20189 | 20378 | Jim_SetResultFormatted(interp, "bad field specifier \"%s\"", spec); |
| 20190 | 20379 | goto error; |
| 20191 | 20380 | } |
| | @@ -20233,37 +20422,37 @@ |
| 20233 | 20422 | |
| 20234 | 20423 | #define REG_MAX_PAREN 100 |
| 20235 | 20424 | |
| 20236 | 20425 | |
| 20237 | 20426 | |
| 20238 | | -#define END 0 |
| 20239 | | -#define BOL 1 |
| 20240 | | -#define EOL 2 |
| 20241 | | -#define ANY 3 |
| 20242 | | -#define ANYOF 4 |
| 20243 | | -#define ANYBUT 5 |
| 20244 | | -#define BRANCH 6 |
| 20245 | | -#define BACK 7 |
| 20246 | | -#define EXACTLY 8 |
| 20247 | | -#define NOTHING 9 |
| 20248 | | -#define REP 10 |
| 20249 | | -#define REPMIN 11 |
| 20250 | | -#define REPX 12 |
| 20251 | | -#define REPXMIN 13 |
| 20252 | | -#define BOLX 14 |
| 20253 | | -#define EOLX 15 |
| 20254 | | -#define WORDA 16 |
| 20255 | | -#define WORDZ 17 |
| 20256 | | - |
| 20257 | | -#define OPENNC 1000 |
| 20258 | | -#define OPEN 1001 |
| 20259 | | - |
| 20260 | | - |
| 20261 | | - |
| 20262 | | - |
| 20263 | | -#define CLOSENC 2000 |
| 20264 | | -#define CLOSE 2001 |
| 20427 | +#define END 0 |
| 20428 | +#define BOL 1 |
| 20429 | +#define EOL 2 |
| 20430 | +#define ANY 3 |
| 20431 | +#define ANYOF 4 |
| 20432 | +#define ANYBUT 5 |
| 20433 | +#define BRANCH 6 |
| 20434 | +#define BACK 7 |
| 20435 | +#define EXACTLY 8 |
| 20436 | +#define NOTHING 9 |
| 20437 | +#define REP 10 |
| 20438 | +#define REPMIN 11 |
| 20439 | +#define REPX 12 |
| 20440 | +#define REPXMIN 13 |
| 20441 | +#define BOLX 14 |
| 20442 | +#define EOLX 15 |
| 20443 | +#define WORDA 16 |
| 20444 | +#define WORDZ 17 |
| 20445 | + |
| 20446 | +#define OPENNC 1000 |
| 20447 | +#define OPEN 1001 |
| 20448 | + |
| 20449 | + |
| 20450 | + |
| 20451 | + |
| 20452 | +#define CLOSENC 2000 |
| 20453 | +#define CLOSE 2001 |
| 20265 | 20454 | #define CLOSE_END (CLOSE+REG_MAX_PAREN) |
| 20266 | 20455 | |
| 20267 | 20456 | #define REG_MAGIC 0xFADED00D |
| 20268 | 20457 | |
| 20269 | 20458 | |
| | @@ -20276,18 +20465,18 @@ |
| 20276 | 20465 | |
| 20277 | 20466 | #define FAIL(R,M) { (R)->err = (M); return (M); } |
| 20278 | 20467 | #define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?' || (c) == '{') |
| 20279 | 20468 | #define META "^$.[()|?{+*" |
| 20280 | 20469 | |
| 20281 | | -#define HASWIDTH 1 |
| 20282 | | -#define SIMPLE 2 |
| 20283 | | -#define SPSTART 4 |
| 20284 | | -#define WORST 0 |
| 20470 | +#define HASWIDTH 1 |
| 20471 | +#define SIMPLE 2 |
| 20472 | +#define SPSTART 4 |
| 20473 | +#define WORST 0 |
| 20285 | 20474 | |
| 20286 | 20475 | #define MAX_REP_COUNT 1000000 |
| 20287 | 20476 | |
| 20288 | | -static int reg(regex_t *preg, int paren, int *flagp ); |
| 20477 | +static int reg(regex_t *preg, int paren , int *flagp ); |
| 20289 | 20478 | static int regpiece(regex_t *preg, int *flagp ); |
| 20290 | 20479 | static int regbranch(regex_t *preg, int *flagp ); |
| 20291 | 20480 | static int regatom(regex_t *preg, int *flagp ); |
| 20292 | 20481 | static int regnode(regex_t *preg, int op ); |
| 20293 | 20482 | static int regnext(regex_t *preg, int p ); |
| | @@ -20331,15 +20520,15 @@ |
| 20331 | 20520 | memset(preg, 0, sizeof(*preg)); |
| 20332 | 20521 | |
| 20333 | 20522 | if (exp == NULL) |
| 20334 | 20523 | FAIL(preg, REG_ERR_NULL_ARGUMENT); |
| 20335 | 20524 | |
| 20336 | | - |
| 20525 | + |
| 20337 | 20526 | preg->cflags = cflags; |
| 20338 | 20527 | preg->regparse = exp; |
| 20339 | 20528 | |
| 20340 | | - |
| 20529 | + |
| 20341 | 20530 | preg->proglen = (strlen(exp) + 1) * 5; |
| 20342 | 20531 | preg->program = malloc(preg->proglen * sizeof(int)); |
| 20343 | 20532 | if (preg->program == NULL) |
| 20344 | 20533 | FAIL(preg, REG_ERR_NOMEM); |
| 20345 | 20534 | |
| | @@ -20346,24 +20535,24 @@ |
| 20346 | 20535 | regc(preg, REG_MAGIC); |
| 20347 | 20536 | if (reg(preg, 0, &flags) == 0) { |
| 20348 | 20537 | return preg->err; |
| 20349 | 20538 | } |
| 20350 | 20539 | |
| 20351 | | - |
| 20352 | | - if (preg->re_nsub >= REG_MAX_PAREN) |
| 20540 | + |
| 20541 | + if (preg->re_nsub >= REG_MAX_PAREN) |
| 20353 | 20542 | FAIL(preg,REG_ERR_TOO_BIG); |
| 20354 | 20543 | |
| 20355 | | - |
| 20356 | | - preg->regstart = 0; |
| 20544 | + |
| 20545 | + preg->regstart = 0; |
| 20357 | 20546 | preg->reganch = 0; |
| 20358 | 20547 | preg->regmust = 0; |
| 20359 | 20548 | preg->regmlen = 0; |
| 20360 | | - scan = 1; |
| 20361 | | - if (OP(preg, regnext(preg, scan)) == END) { |
| 20549 | + scan = 1; |
| 20550 | + if (OP(preg, regnext(preg, scan)) == END) { |
| 20362 | 20551 | scan = OPERAND(scan); |
| 20363 | 20552 | |
| 20364 | | - |
| 20553 | + |
| 20365 | 20554 | if (OP(preg, scan) == EXACTLY) { |
| 20366 | 20555 | preg->regstart = preg->program[OPERAND(scan)]; |
| 20367 | 20556 | } |
| 20368 | 20557 | else if (OP(preg, scan) == BOL) |
| 20369 | 20558 | preg->reganch++; |
| | @@ -20390,24 +20579,24 @@ |
| 20390 | 20579 | #endif |
| 20391 | 20580 | |
| 20392 | 20581 | return 0; |
| 20393 | 20582 | } |
| 20394 | 20583 | |
| 20395 | | -static int reg(regex_t *preg, int paren, int *flagp ) |
| 20584 | +static int reg(regex_t *preg, int paren , int *flagp ) |
| 20396 | 20585 | { |
| 20397 | 20586 | int ret; |
| 20398 | 20587 | int br; |
| 20399 | 20588 | int ender; |
| 20400 | 20589 | int parno = 0; |
| 20401 | 20590 | int flags; |
| 20402 | 20591 | |
| 20403 | | - *flagp = HASWIDTH; |
| 20592 | + *flagp = HASWIDTH; |
| 20404 | 20593 | |
| 20405 | | - |
| 20594 | + |
| 20406 | 20595 | if (paren) { |
| 20407 | 20596 | if (preg->regparse[0] == '?' && preg->regparse[1] == ':') { |
| 20408 | | - |
| 20597 | + |
| 20409 | 20598 | preg->regparse += 2; |
| 20410 | 20599 | parno = -1; |
| 20411 | 20600 | } |
| 20412 | 20601 | else { |
| 20413 | 20602 | parno = ++preg->re_nsub; |
| | @@ -20414,16 +20603,16 @@ |
| 20414 | 20603 | } |
| 20415 | 20604 | ret = regnode(preg, OPEN+parno); |
| 20416 | 20605 | } else |
| 20417 | 20606 | ret = 0; |
| 20418 | 20607 | |
| 20419 | | - |
| 20608 | + |
| 20420 | 20609 | br = regbranch(preg, &flags); |
| 20421 | 20610 | if (br == 0) |
| 20422 | 20611 | return 0; |
| 20423 | 20612 | if (ret != 0) |
| 20424 | | - regtail(preg, ret, br); |
| 20613 | + regtail(preg, ret, br); |
| 20425 | 20614 | else |
| 20426 | 20615 | ret = br; |
| 20427 | 20616 | if (!(flags&HASWIDTH)) |
| 20428 | 20617 | *flagp &= ~HASWIDTH; |
| 20429 | 20618 | *flagp |= flags&SPSTART; |
| | @@ -20430,25 +20619,25 @@ |
| 20430 | 20619 | while (*preg->regparse == '|') { |
| 20431 | 20620 | preg->regparse++; |
| 20432 | 20621 | br = regbranch(preg, &flags); |
| 20433 | 20622 | if (br == 0) |
| 20434 | 20623 | return 0; |
| 20435 | | - regtail(preg, ret, br); |
| 20624 | + regtail(preg, ret, br); |
| 20436 | 20625 | if (!(flags&HASWIDTH)) |
| 20437 | 20626 | *flagp &= ~HASWIDTH; |
| 20438 | 20627 | *flagp |= flags&SPSTART; |
| 20439 | 20628 | } |
| 20440 | 20629 | |
| 20441 | | - |
| 20630 | + |
| 20442 | 20631 | ender = regnode(preg, (paren) ? CLOSE+parno : END); |
| 20443 | 20632 | regtail(preg, ret, ender); |
| 20444 | 20633 | |
| 20445 | | - |
| 20634 | + |
| 20446 | 20635 | for (br = ret; br != 0; br = regnext(preg, br)) |
| 20447 | 20636 | regoptail(preg, br, ender); |
| 20448 | 20637 | |
| 20449 | | - |
| 20638 | + |
| 20450 | 20639 | if (paren && *preg->regparse++ != ')') { |
| 20451 | 20640 | preg->err = REG_ERR_UNMATCHED_PAREN; |
| 20452 | 20641 | return 0; |
| 20453 | 20642 | } else if (!paren && *preg->regparse != '\0') { |
| 20454 | 20643 | if (*preg->regparse == ')') { |
| | @@ -20468,11 +20657,11 @@ |
| 20468 | 20657 | int ret; |
| 20469 | 20658 | int chain; |
| 20470 | 20659 | int latest; |
| 20471 | 20660 | int flags; |
| 20472 | 20661 | |
| 20473 | | - *flagp = WORST; |
| 20662 | + *flagp = WORST; |
| 20474 | 20663 | |
| 20475 | 20664 | ret = regnode(preg, BRANCH); |
| 20476 | 20665 | chain = 0; |
| 20477 | 20666 | while (*preg->regparse != '\0' && *preg->regparse != ')' && |
| 20478 | 20667 | *preg->regparse != '|') { |
| | @@ -20486,11 +20675,11 @@ |
| 20486 | 20675 | else { |
| 20487 | 20676 | regtail(preg, chain, latest); |
| 20488 | 20677 | } |
| 20489 | 20678 | chain = latest; |
| 20490 | 20679 | } |
| 20491 | | - if (chain == 0) |
| 20680 | + if (chain == 0) |
| 20492 | 20681 | (void) regnode(preg, NOTHING); |
| 20493 | 20682 | |
| 20494 | 20683 | return(ret); |
| 20495 | 20684 | } |
| 20496 | 20685 | |
| | @@ -20516,11 +20705,11 @@ |
| 20516 | 20705 | if (!(flags&HASWIDTH) && op != '?') { |
| 20517 | 20706 | preg->err = REG_ERR_OPERAND_COULD_BE_EMPTY; |
| 20518 | 20707 | return 0; |
| 20519 | 20708 | } |
| 20520 | 20709 | |
| 20521 | | - |
| 20710 | + |
| 20522 | 20711 | if (op == '{') { |
| 20523 | 20712 | char *end; |
| 20524 | 20713 | |
| 20525 | 20714 | min = strtoul(preg->regparse + 1, &end, 10); |
| 20526 | 20715 | if (end == preg->regparse + 1) { |
| | @@ -20588,11 +20777,11 @@ |
| 20588 | 20777 | static void reg_addrange(regex_t *preg, int lower, int upper) |
| 20589 | 20778 | { |
| 20590 | 20779 | if (lower > upper) { |
| 20591 | 20780 | reg_addrange(preg, upper, lower); |
| 20592 | 20781 | } |
| 20593 | | - |
| 20782 | + |
| 20594 | 20783 | regc(preg, upper - lower + 1); |
| 20595 | 20784 | regc(preg, lower); |
| 20596 | 20785 | } |
| 20597 | 20786 | |
| 20598 | 20787 | static void reg_addrange_str(regex_t *preg, const char *str) |
| | @@ -20656,17 +20845,17 @@ |
| 20656 | 20845 | case 'r': *ch = '\r'; break; |
| 20657 | 20846 | case 't': *ch = '\t'; break; |
| 20658 | 20847 | case 'v': *ch = '\v'; break; |
| 20659 | 20848 | case 'u': |
| 20660 | 20849 | if (*s == '{') { |
| 20661 | | - |
| 20850 | + |
| 20662 | 20851 | n = parse_hex(s + 1, 6, ch); |
| 20663 | 20852 | if (n > 0 && s[n + 1] == '}' && *ch >= 0 && *ch <= 0x1fffff) { |
| 20664 | 20853 | s += n + 2; |
| 20665 | 20854 | } |
| 20666 | 20855 | else { |
| 20667 | | - |
| 20856 | + |
| 20668 | 20857 | *ch = 'u'; |
| 20669 | 20858 | } |
| 20670 | 20859 | } |
| 20671 | 20860 | else if ((n = parse_hex(s, 4, ch)) > 0) { |
| 20672 | 20861 | s += n; |
| | @@ -20697,15 +20886,15 @@ |
| 20697 | 20886 | int nocase = (preg->cflags & REG_ICASE); |
| 20698 | 20887 | |
| 20699 | 20888 | int ch; |
| 20700 | 20889 | int n = reg_utf8_tounicode_case(preg->regparse, &ch, nocase); |
| 20701 | 20890 | |
| 20702 | | - *flagp = WORST; |
| 20891 | + *flagp = WORST; |
| 20703 | 20892 | |
| 20704 | 20893 | preg->regparse += n; |
| 20705 | 20894 | switch (ch) { |
| 20706 | | - |
| 20895 | + |
| 20707 | 20896 | case '^': |
| 20708 | 20897 | ret = regnode(preg, BOL); |
| 20709 | 20898 | break; |
| 20710 | 20899 | case '$': |
| 20711 | 20900 | ret = regnode(preg, EOL); |
| | @@ -20715,24 +20904,24 @@ |
| 20715 | 20904 | *flagp |= HASWIDTH|SIMPLE; |
| 20716 | 20905 | break; |
| 20717 | 20906 | case '[': { |
| 20718 | 20907 | const char *pattern = preg->regparse; |
| 20719 | 20908 | |
| 20720 | | - if (*pattern == '^') { |
| 20909 | + if (*pattern == '^') { |
| 20721 | 20910 | ret = regnode(preg, ANYBUT); |
| 20722 | 20911 | pattern++; |
| 20723 | 20912 | } else |
| 20724 | 20913 | ret = regnode(preg, ANYOF); |
| 20725 | 20914 | |
| 20726 | | - |
| 20915 | + |
| 20727 | 20916 | if (*pattern == ']' || *pattern == '-') { |
| 20728 | 20917 | reg_addrange(preg, *pattern, *pattern); |
| 20729 | 20918 | pattern++; |
| 20730 | 20919 | } |
| 20731 | 20920 | |
| 20732 | 20921 | while (*pattern && *pattern != ']') { |
| 20733 | | - |
| 20922 | + |
| 20734 | 20923 | int start; |
| 20735 | 20924 | int end; |
| 20736 | 20925 | |
| 20737 | 20926 | pattern += reg_utf8_tounicode_case(pattern, &start, nocase); |
| 20738 | 20927 | if (start == '\\') { |
| | @@ -20741,11 +20930,11 @@ |
| 20741 | 20930 | preg->err = REG_ERR_NULL_CHAR; |
| 20742 | 20931 | return 0; |
| 20743 | 20932 | } |
| 20744 | 20933 | } |
| 20745 | 20934 | if (pattern[0] == '-' && pattern[1] && pattern[1] != ']') { |
| 20746 | | - |
| 20935 | + |
| 20747 | 20936 | pattern += utf8_tounicode(pattern, &end); |
| 20748 | 20937 | pattern += reg_utf8_tounicode_case(pattern, &end, nocase); |
| 20749 | 20938 | if (end == '\\') { |
| 20750 | 20939 | pattern += reg_decode_escape(pattern, &end); |
| 20751 | 20940 | if (end == 0) { |
| | @@ -20768,22 +20957,22 @@ |
| 20768 | 20957 | CC_NUM |
| 20769 | 20958 | }; |
| 20770 | 20959 | int i; |
| 20771 | 20960 | |
| 20772 | 20961 | for (i = 0; i < CC_NUM; i++) { |
| 20773 | | - n = strlen(character_class[i]); |
| 20962 | + int n = strlen(character_class[i]); |
| 20774 | 20963 | if (strncmp(pattern, character_class[i], n) == 0) { |
| 20775 | | - |
| 20964 | + |
| 20776 | 20965 | pattern += n + 1; |
| 20777 | 20966 | break; |
| 20778 | 20967 | } |
| 20779 | 20968 | } |
| 20780 | 20969 | if (i != CC_NUM) { |
| 20781 | 20970 | switch (i) { |
| 20782 | 20971 | case CC_ALNUM: |
| 20783 | 20972 | reg_addrange(preg, '0', '9'); |
| 20784 | | - |
| 20973 | + |
| 20785 | 20974 | case CC_ALPHA: |
| 20786 | 20975 | if ((preg->cflags & REG_ICASE) == 0) { |
| 20787 | 20976 | reg_addrange(preg, 'a', 'z'); |
| 20788 | 20977 | } |
| 20789 | 20978 | reg_addrange(preg, 'A', 'Z'); |
| | @@ -20801,11 +20990,11 @@ |
| 20801 | 20990 | reg_addrange(preg, 'a', 'z'); |
| 20802 | 20991 | break; |
| 20803 | 20992 | case CC_XDIGIT: |
| 20804 | 20993 | reg_addrange(preg, 'a', 'f'); |
| 20805 | 20994 | reg_addrange(preg, 'A', 'F'); |
| 20806 | | - |
| 20995 | + |
| 20807 | 20996 | case CC_DIGIT: |
| 20808 | 20997 | reg_addrange(preg, '0', '9'); |
| 20809 | 20998 | break; |
| 20810 | 20999 | case CC_CNTRL: |
| 20811 | 21000 | reg_addrange(preg, 0, 31); |
| | @@ -20825,11 +21014,11 @@ |
| 20825 | 21014 | break; |
| 20826 | 21015 | } |
| 20827 | 21016 | continue; |
| 20828 | 21017 | } |
| 20829 | 21018 | } |
| 20830 | | - |
| 21019 | + |
| 20831 | 21020 | reg_addrange(preg, start, start); |
| 20832 | 21021 | } |
| 20833 | 21022 | regc(preg, '\0'); |
| 20834 | 21023 | |
| 20835 | 21024 | if (*pattern) { |
| | @@ -20848,11 +21037,11 @@ |
| 20848 | 21037 | break; |
| 20849 | 21038 | case '\0': |
| 20850 | 21039 | case '|': |
| 20851 | 21040 | case ')': |
| 20852 | 21041 | preg->err = REG_ERR_INTERNAL; |
| 20853 | | - return 0; |
| 21042 | + return 0; |
| 20854 | 21043 | case '?': |
| 20855 | 21044 | case '+': |
| 20856 | 21045 | case '*': |
| 20857 | 21046 | case '{': |
| 20858 | 21047 | preg->err = REG_ERR_COUNT_FOLLOWS_NOTHING; |
| | @@ -20901,34 +21090,34 @@ |
| 20901 | 21090 | ret = regnode(preg, ch == 's' ? ANYOF : ANYBUT); |
| 20902 | 21091 | reg_addrange_str(preg," \t\r\n\f\v"); |
| 20903 | 21092 | regc(preg, '\0'); |
| 20904 | 21093 | *flagp |= HASWIDTH|SIMPLE; |
| 20905 | 21094 | break; |
| 20906 | | - |
| 21095 | + |
| 20907 | 21096 | default: |
| 20908 | | - |
| 20909 | | - |
| 21097 | + |
| 21098 | + |
| 20910 | 21099 | preg->regparse--; |
| 20911 | 21100 | goto de_fault; |
| 20912 | 21101 | } |
| 20913 | 21102 | break; |
| 20914 | 21103 | de_fault: |
| 20915 | 21104 | default: { |
| 20916 | 21105 | int added = 0; |
| 20917 | 21106 | |
| 20918 | | - |
| 21107 | + |
| 20919 | 21108 | preg->regparse -= n; |
| 20920 | 21109 | |
| 20921 | 21110 | ret = regnode(preg, EXACTLY); |
| 20922 | 21111 | |
| 20923 | 21112 | |
| 20924 | | - |
| 21113 | + |
| 20925 | 21114 | while (*preg->regparse && strchr(META, *preg->regparse) == NULL) { |
| 20926 | 21115 | n = reg_utf8_tounicode_case(preg->regparse, &ch, (preg->cflags & REG_ICASE)); |
| 20927 | 21116 | if (ch == '\\' && preg->regparse[n]) { |
| 20928 | 21117 | if (strchr("<>mMwWdDsSAZ", preg->regparse[n])) { |
| 20929 | | - |
| 21118 | + |
| 20930 | 21119 | break; |
| 20931 | 21120 | } |
| 20932 | 21121 | n += reg_decode_escape(preg->regparse + n, &ch); |
| 20933 | 21122 | if (ch == 0) { |
| 20934 | 21123 | preg->err = REG_ERR_NULL_CHAR; |
| | @@ -20936,23 +21125,23 @@ |
| 20936 | 21125 | } |
| 20937 | 21126 | } |
| 20938 | 21127 | |
| 20939 | 21128 | |
| 20940 | 21129 | if (ISMULT(preg->regparse[n])) { |
| 20941 | | - |
| 21130 | + |
| 20942 | 21131 | if (added) { |
| 20943 | | - |
| 21132 | + |
| 20944 | 21133 | break; |
| 20945 | 21134 | } |
| 20946 | | - |
| 21135 | + |
| 20947 | 21136 | regc(preg, ch); |
| 20948 | 21137 | added++; |
| 20949 | 21138 | preg->regparse += n; |
| 20950 | 21139 | break; |
| 20951 | 21140 | } |
| 20952 | 21141 | |
| 20953 | | - |
| 21142 | + |
| 20954 | 21143 | regc(preg, ch); |
| 20955 | 21144 | added++; |
| 20956 | 21145 | preg->regparse += n; |
| 20957 | 21146 | } |
| 20958 | 21147 | regc(preg, '\0'); |
| | @@ -20979,15 +21168,15 @@ |
| 20979 | 21168 | |
| 20980 | 21169 | static int regnode(regex_t *preg, int op) |
| 20981 | 21170 | { |
| 20982 | 21171 | reg_grow(preg, 2); |
| 20983 | 21172 | |
| 20984 | | - |
| 21173 | + |
| 20985 | 21174 | preg->program[preg->p++] = op; |
| 20986 | 21175 | preg->program[preg->p++] = 0; |
| 20987 | 21176 | |
| 20988 | | - |
| 21177 | + |
| 20989 | 21178 | return preg->p - 2; |
| 20990 | 21179 | } |
| 20991 | 21180 | |
| 20992 | 21181 | static void regc(regex_t *preg, int b ) |
| 20993 | 21182 | { |
| | @@ -20997,13 +21186,13 @@ |
| 20997 | 21186 | |
| 20998 | 21187 | static int reginsert(regex_t *preg, int op, int size, int opnd ) |
| 20999 | 21188 | { |
| 21000 | 21189 | reg_grow(preg, size); |
| 21001 | 21190 | |
| 21002 | | - |
| 21191 | + |
| 21003 | 21192 | memmove(preg->program + opnd + size, preg->program + opnd, sizeof(int) * (preg->p - opnd)); |
| 21004 | | - |
| 21193 | + |
| 21005 | 21194 | memset(preg->program + opnd, 0, sizeof(int) * size); |
| 21006 | 21195 | |
| 21007 | 21196 | preg->program[opnd] = op; |
| 21008 | 21197 | |
| 21009 | 21198 | preg->p += size; |
| | @@ -21015,11 +21204,11 @@ |
| 21015 | 21204 | { |
| 21016 | 21205 | int scan; |
| 21017 | 21206 | int temp; |
| 21018 | 21207 | int offset; |
| 21019 | 21208 | |
| 21020 | | - |
| 21209 | + |
| 21021 | 21210 | scan = p; |
| 21022 | 21211 | for (;;) { |
| 21023 | 21212 | temp = regnext(preg, scan); |
| 21024 | 21213 | if (temp == 0) |
| 21025 | 21214 | break; |
| | @@ -21035,11 +21224,11 @@ |
| 21035 | 21224 | } |
| 21036 | 21225 | |
| 21037 | 21226 | |
| 21038 | 21227 | static void regoptail(regex_t *preg, int p, int val ) |
| 21039 | 21228 | { |
| 21040 | | - |
| 21229 | + |
| 21041 | 21230 | if (p != 0 && OP(preg, p) == BRANCH) { |
| 21042 | 21231 | regtail(preg, OPERAND(p), val); |
| 21043 | 21232 | } |
| 21044 | 21233 | } |
| 21045 | 21234 | |
| | @@ -21051,16 +21240,16 @@ |
| 21051 | 21240 | int regexec(regex_t *preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags) |
| 21052 | 21241 | { |
| 21053 | 21242 | const char *s; |
| 21054 | 21243 | int scan; |
| 21055 | 21244 | |
| 21056 | | - |
| 21245 | + |
| 21057 | 21246 | if (preg == NULL || preg->program == NULL || string == NULL) { |
| 21058 | 21247 | return REG_ERR_NULL_ARGUMENT; |
| 21059 | 21248 | } |
| 21060 | 21249 | |
| 21061 | | - |
| 21250 | + |
| 21062 | 21251 | if (*preg->program != REG_MAGIC) { |
| 21063 | 21252 | return REG_ERR_CORRUPTED; |
| 21064 | 21253 | } |
| 21065 | 21254 | |
| 21066 | 21255 | #ifdef DEBUG |
| | @@ -21069,51 +21258,51 @@ |
| 21069 | 21258 | #endif |
| 21070 | 21259 | |
| 21071 | 21260 | preg->eflags = eflags; |
| 21072 | 21261 | preg->pmatch = pmatch; |
| 21073 | 21262 | preg->nmatch = nmatch; |
| 21074 | | - preg->start = string; |
| 21263 | + preg->start = string; |
| 21075 | 21264 | |
| 21076 | | - |
| 21265 | + |
| 21077 | 21266 | for (scan = OPERAND(1); scan != 0; scan += regopsize(preg, scan)) { |
| 21078 | 21267 | int op = OP(preg, scan); |
| 21079 | 21268 | if (op == END) |
| 21080 | 21269 | break; |
| 21081 | 21270 | if (op == REPX || op == REPXMIN) |
| 21082 | 21271 | preg->program[scan + 4] = 0; |
| 21083 | 21272 | } |
| 21084 | 21273 | |
| 21085 | | - |
| 21274 | + |
| 21086 | 21275 | if (preg->regmust != 0) { |
| 21087 | 21276 | s = string; |
| 21088 | 21277 | while ((s = str_find(s, preg->program[preg->regmust], preg->cflags & REG_ICASE)) != NULL) { |
| 21089 | 21278 | if (prefix_cmp(preg->program + preg->regmust, preg->regmlen, s, preg->cflags & REG_ICASE) >= 0) { |
| 21090 | 21279 | break; |
| 21091 | 21280 | } |
| 21092 | 21281 | s++; |
| 21093 | 21282 | } |
| 21094 | | - if (s == NULL) |
| 21283 | + if (s == NULL) |
| 21095 | 21284 | return REG_NOMATCH; |
| 21096 | 21285 | } |
| 21097 | 21286 | |
| 21098 | | - |
| 21287 | + |
| 21099 | 21288 | preg->regbol = string; |
| 21100 | 21289 | |
| 21101 | | - |
| 21290 | + |
| 21102 | 21291 | if (preg->reganch) { |
| 21103 | 21292 | if (eflags & REG_NOTBOL) { |
| 21104 | | - |
| 21293 | + |
| 21105 | 21294 | goto nextline; |
| 21106 | 21295 | } |
| 21107 | 21296 | while (1) { |
| 21108 | 21297 | if (regtry(preg, string)) { |
| 21109 | 21298 | return REG_NOERROR; |
| 21110 | 21299 | } |
| 21111 | 21300 | if (*string) { |
| 21112 | 21301 | nextline: |
| 21113 | 21302 | if (preg->cflags & REG_NEWLINE) { |
| 21114 | | - |
| 21303 | + |
| 21115 | 21304 | string = strchr(string, '\n'); |
| 21116 | 21305 | if (string) { |
| 21117 | 21306 | preg->regbol = ++string; |
| 21118 | 21307 | continue; |
| 21119 | 21308 | } |
| | @@ -21121,22 +21310,22 @@ |
| 21121 | 21310 | } |
| 21122 | 21311 | return REG_NOMATCH; |
| 21123 | 21312 | } |
| 21124 | 21313 | } |
| 21125 | 21314 | |
| 21126 | | - |
| 21315 | + |
| 21127 | 21316 | s = string; |
| 21128 | 21317 | if (preg->regstart != '\0') { |
| 21129 | | - |
| 21318 | + |
| 21130 | 21319 | while ((s = str_find(s, preg->regstart, preg->cflags & REG_ICASE)) != NULL) { |
| 21131 | 21320 | if (regtry(preg, s)) |
| 21132 | 21321 | return REG_NOERROR; |
| 21133 | 21322 | s++; |
| 21134 | 21323 | } |
| 21135 | 21324 | } |
| 21136 | 21325 | else |
| 21137 | | - |
| 21326 | + |
| 21138 | 21327 | while (1) { |
| 21139 | 21328 | if (regtry(preg, s)) |
| 21140 | 21329 | return REG_NOERROR; |
| 21141 | 21330 | if (*s == '\0') { |
| 21142 | 21331 | break; |
| | @@ -21145,15 +21334,15 @@ |
| 21145 | 21334 | int c; |
| 21146 | 21335 | s += utf8_tounicode(s, &c); |
| 21147 | 21336 | } |
| 21148 | 21337 | } |
| 21149 | 21338 | |
| 21150 | | - |
| 21339 | + |
| 21151 | 21340 | return REG_NOMATCH; |
| 21152 | 21341 | } |
| 21153 | 21342 | |
| 21154 | | - |
| 21343 | + |
| 21155 | 21344 | static int regtry( regex_t *preg, const char *string ) |
| 21156 | 21345 | { |
| 21157 | 21346 | int i; |
| 21158 | 21347 | |
| 21159 | 21348 | preg->reginput = string; |
| | @@ -21190,11 +21379,11 @@ |
| 21190 | 21379 | } |
| 21191 | 21380 | |
| 21192 | 21381 | static int reg_range_find(const int *range, int c) |
| 21193 | 21382 | { |
| 21194 | 21383 | while (*range) { |
| 21195 | | - |
| 21384 | + |
| 21196 | 21385 | if (c >= range[1] && c <= (range[0] + range[1] - 1)) { |
| 21197 | 21386 | return 1; |
| 21198 | 21387 | } |
| 21199 | 21388 | range += 2; |
| 21200 | 21389 | } |
| | @@ -21202,11 +21391,11 @@ |
| 21202 | 21391 | } |
| 21203 | 21392 | |
| 21204 | 21393 | static const char *str_find(const char *string, int c, int nocase) |
| 21205 | 21394 | { |
| 21206 | 21395 | if (nocase) { |
| 21207 | | - |
| 21396 | + |
| 21208 | 21397 | c = utf8_upper(c); |
| 21209 | 21398 | } |
| 21210 | 21399 | while (*string) { |
| 21211 | 21400 | int ch; |
| 21212 | 21401 | int n = reg_utf8_tounicode_case(string, &ch, nocase); |
| | @@ -21246,15 +21435,15 @@ |
| 21246 | 21435 | no = regrepeat(preg, scan + 5, max); |
| 21247 | 21436 | if (no < min) { |
| 21248 | 21437 | return 0; |
| 21249 | 21438 | } |
| 21250 | 21439 | if (matchmin) { |
| 21251 | | - |
| 21440 | + |
| 21252 | 21441 | max = no; |
| 21253 | 21442 | no = min; |
| 21254 | 21443 | } |
| 21255 | | - |
| 21444 | + |
| 21256 | 21445 | while (1) { |
| 21257 | 21446 | if (matchmin) { |
| 21258 | 21447 | if (no > max) { |
| 21259 | 21448 | break; |
| 21260 | 21449 | } |
| | @@ -21264,22 +21453,22 @@ |
| 21264 | 21453 | break; |
| 21265 | 21454 | } |
| 21266 | 21455 | } |
| 21267 | 21456 | preg->reginput = save + utf8_index(save, no); |
| 21268 | 21457 | reg_utf8_tounicode_case(preg->reginput, &c, (preg->cflags & REG_ICASE)); |
| 21269 | | - |
| 21458 | + |
| 21270 | 21459 | if (reg_iseol(preg, nextch) || c == nextch) { |
| 21271 | 21460 | if (regmatch(preg, next)) { |
| 21272 | 21461 | return(1); |
| 21273 | 21462 | } |
| 21274 | 21463 | } |
| 21275 | 21464 | if (matchmin) { |
| 21276 | | - |
| 21465 | + |
| 21277 | 21466 | no++; |
| 21278 | 21467 | } |
| 21279 | 21468 | else { |
| 21280 | | - |
| 21469 | + |
| 21281 | 21470 | no--; |
| 21282 | 21471 | } |
| 21283 | 21472 | } |
| 21284 | 21473 | return(0); |
| 21285 | 21474 | } |
| | @@ -21289,13 +21478,13 @@ |
| 21289 | 21478 | int *scanpt = preg->program + scan; |
| 21290 | 21479 | |
| 21291 | 21480 | int max = scanpt[2]; |
| 21292 | 21481 | int min = scanpt[3]; |
| 21293 | 21482 | |
| 21294 | | - |
| 21483 | + |
| 21295 | 21484 | if (scanpt[4] < min) { |
| 21296 | | - |
| 21485 | + |
| 21297 | 21486 | scanpt[4]++; |
| 21298 | 21487 | if (regmatch(preg, scan + 5)) { |
| 21299 | 21488 | return 1; |
| 21300 | 21489 | } |
| 21301 | 21490 | scanpt[4]--; |
| | @@ -21304,39 +21493,39 @@ |
| 21304 | 21493 | if (scanpt[4] > max) { |
| 21305 | 21494 | return 0; |
| 21306 | 21495 | } |
| 21307 | 21496 | |
| 21308 | 21497 | if (matchmin) { |
| 21309 | | - |
| 21498 | + |
| 21310 | 21499 | if (regmatch(preg, regnext(preg, scan))) { |
| 21311 | 21500 | return 1; |
| 21312 | 21501 | } |
| 21313 | | - |
| 21502 | + |
| 21314 | 21503 | scanpt[4]++; |
| 21315 | 21504 | if (regmatch(preg, scan + 5)) { |
| 21316 | 21505 | return 1; |
| 21317 | 21506 | } |
| 21318 | 21507 | scanpt[4]--; |
| 21319 | 21508 | return 0; |
| 21320 | 21509 | } |
| 21321 | | - |
| 21510 | + |
| 21322 | 21511 | if (scanpt[4] < max) { |
| 21323 | 21512 | scanpt[4]++; |
| 21324 | 21513 | if (regmatch(preg, scan + 5)) { |
| 21325 | 21514 | return 1; |
| 21326 | 21515 | } |
| 21327 | 21516 | scanpt[4]--; |
| 21328 | 21517 | } |
| 21329 | | - |
| 21518 | + |
| 21330 | 21519 | return regmatch(preg, regnext(preg, scan)); |
| 21331 | 21520 | } |
| 21332 | 21521 | |
| 21333 | 21522 | |
| 21334 | 21523 | static int regmatch(regex_t *preg, int prog) |
| 21335 | 21524 | { |
| 21336 | | - int scan; |
| 21337 | | - int next; |
| 21525 | + int scan; |
| 21526 | + int next; |
| 21338 | 21527 | const char *save; |
| 21339 | 21528 | |
| 21340 | 21529 | scan = prog; |
| 21341 | 21530 | |
| 21342 | 21531 | #ifdef DEBUG |
| | @@ -21346,11 +21535,11 @@ |
| 21346 | 21535 | while (scan != 0) { |
| 21347 | 21536 | int n; |
| 21348 | 21537 | int c; |
| 21349 | 21538 | #ifdef DEBUG |
| 21350 | 21539 | if (regnarrate) { |
| 21351 | | - fprintf(stderr, "%3d: %s...\n", scan, regprop(OP(preg, scan))); |
| 21540 | + fprintf(stderr, "%3d: %s...\n", scan, regprop(OP(preg, scan))); |
| 21352 | 21541 | } |
| 21353 | 21542 | #endif |
| 21354 | 21543 | next = regnext(preg, scan); |
| 21355 | 21544 | n = reg_utf8_tounicode_case(preg->reginput, &c, (preg->cflags & REG_ICASE)); |
| 21356 | 21545 | |
| | @@ -21357,49 +21546,49 @@ |
| 21357 | 21546 | switch (OP(preg, scan)) { |
| 21358 | 21547 | case BOLX: |
| 21359 | 21548 | if ((preg->eflags & REG_NOTBOL)) { |
| 21360 | 21549 | return(0); |
| 21361 | 21550 | } |
| 21362 | | - |
| 21551 | + |
| 21363 | 21552 | case BOL: |
| 21364 | 21553 | if (preg->reginput != preg->regbol) { |
| 21365 | 21554 | return(0); |
| 21366 | 21555 | } |
| 21367 | 21556 | break; |
| 21368 | 21557 | case EOLX: |
| 21369 | 21558 | if (c != 0) { |
| 21370 | | - |
| 21559 | + |
| 21371 | 21560 | return 0; |
| 21372 | 21561 | } |
| 21373 | 21562 | break; |
| 21374 | 21563 | case EOL: |
| 21375 | 21564 | if (!reg_iseol(preg, c)) { |
| 21376 | 21565 | return(0); |
| 21377 | 21566 | } |
| 21378 | 21567 | break; |
| 21379 | 21568 | case WORDA: |
| 21380 | | - |
| 21569 | + |
| 21381 | 21570 | if ((!isalnum(UCHAR(c))) && c != '_') |
| 21382 | 21571 | return(0); |
| 21383 | | - |
| 21572 | + |
| 21384 | 21573 | if (preg->reginput > preg->regbol && |
| 21385 | 21574 | (isalnum(UCHAR(preg->reginput[-1])) || preg->reginput[-1] == '_')) |
| 21386 | 21575 | return(0); |
| 21387 | 21576 | break; |
| 21388 | 21577 | case WORDZ: |
| 21389 | | - |
| 21578 | + |
| 21390 | 21579 | if (preg->reginput > preg->regbol) { |
| 21391 | | - |
| 21580 | + |
| 21392 | 21581 | if (reg_iseol(preg, c) || !isalnum(UCHAR(c)) || c != '_') { |
| 21393 | 21582 | c = preg->reginput[-1]; |
| 21394 | | - |
| 21583 | + |
| 21395 | 21584 | if (isalnum(UCHAR(c)) || c == '_') { |
| 21396 | 21585 | break; |
| 21397 | 21586 | } |
| 21398 | 21587 | } |
| 21399 | 21588 | } |
| 21400 | | - |
| 21589 | + |
| 21401 | 21590 | return(0); |
| 21402 | 21591 | |
| 21403 | 21592 | case ANY: |
| 21404 | 21593 | if (reg_iseol(preg, c)) |
| 21405 | 21594 | return 0; |
| | @@ -21435,12 +21624,12 @@ |
| 21435 | 21624 | case NOTHING: |
| 21436 | 21625 | break; |
| 21437 | 21626 | case BACK: |
| 21438 | 21627 | break; |
| 21439 | 21628 | case BRANCH: |
| 21440 | | - if (OP(preg, next) != BRANCH) |
| 21441 | | - next = OPERAND(scan); |
| 21629 | + if (OP(preg, next) != BRANCH) |
| 21630 | + next = OPERAND(scan); |
| 21442 | 21631 | else { |
| 21443 | 21632 | do { |
| 21444 | 21633 | save = preg->reginput; |
| 21445 | 21634 | if (regmatch(preg, OPERAND(scan))) { |
| 21446 | 21635 | return(1); |
| | @@ -21447,11 +21636,11 @@ |
| 21447 | 21636 | } |
| 21448 | 21637 | preg->reginput = save; |
| 21449 | 21638 | scan = regnext(preg, scan); |
| 21450 | 21639 | } while (scan != 0 && OP(preg, scan) == BRANCH); |
| 21451 | 21640 | return(0); |
| 21452 | | - |
| 21641 | + |
| 21453 | 21642 | } |
| 21454 | 21643 | break; |
| 21455 | 21644 | case REP: |
| 21456 | 21645 | case REPMIN: |
| 21457 | 21646 | return regmatchsimplerepeat(preg, scan, OP(preg, scan) == REPMIN); |
| | @@ -21459,11 +21648,11 @@ |
| 21459 | 21648 | case REPX: |
| 21460 | 21649 | case REPXMIN: |
| 21461 | 21650 | return regmatchrepeat(preg, scan, OP(preg, scan) == REPXMIN); |
| 21462 | 21651 | |
| 21463 | 21652 | case END: |
| 21464 | | - return 1; |
| 21653 | + return 1; |
| 21465 | 21654 | |
| 21466 | 21655 | case OPENNC: |
| 21467 | 21656 | case CLOSENC: |
| 21468 | 21657 | return regmatch(preg, next); |
| 21469 | 21658 | |
| | @@ -21506,11 +21695,11 @@ |
| 21506 | 21695 | |
| 21507 | 21696 | scan = preg->reginput; |
| 21508 | 21697 | opnd = OPERAND(p); |
| 21509 | 21698 | switch (OP(preg, p)) { |
| 21510 | 21699 | case ANY: |
| 21511 | | - |
| 21700 | + |
| 21512 | 21701 | while (!reg_iseol(preg, *scan) && count < max) { |
| 21513 | 21702 | count++; |
| 21514 | 21703 | scan++; |
| 21515 | 21704 | } |
| 21516 | 21705 | break; |
| | @@ -21542,13 +21731,13 @@ |
| 21542 | 21731 | } |
| 21543 | 21732 | count++; |
| 21544 | 21733 | scan += n; |
| 21545 | 21734 | } |
| 21546 | 21735 | break; |
| 21547 | | - default: |
| 21736 | + default: |
| 21548 | 21737 | preg->err = REG_ERR_INTERNAL; |
| 21549 | | - count = 0; |
| 21738 | + count = 0; |
| 21550 | 21739 | break; |
| 21551 | 21740 | } |
| 21552 | 21741 | preg->reginput = scan; |
| 21553 | 21742 | |
| 21554 | 21743 | return(count); |
| | @@ -21569,11 +21758,11 @@ |
| 21569 | 21758 | return(p+offset); |
| 21570 | 21759 | } |
| 21571 | 21760 | |
| 21572 | 21761 | static int regopsize(regex_t *preg, int p ) |
| 21573 | 21762 | { |
| 21574 | | - |
| 21763 | + |
| 21575 | 21764 | switch (OP(preg, p)) { |
| 21576 | 21765 | case REP: |
| 21577 | 21766 | case REPMIN: |
| 21578 | 21767 | case REPX: |
| 21579 | 21768 | case REPXMIN: |
| | @@ -21690,26 +21879,26 @@ |
| 21690 | 21879 | { |
| 21691 | 21880 | DIR *dir = 0; |
| 21692 | 21881 | |
| 21693 | 21882 | if (name && name[0]) { |
| 21694 | 21883 | size_t base_length = strlen(name); |
| 21695 | | - const char *all = |
| 21884 | + const char *all = |
| 21696 | 21885 | strchr("/\\", name[base_length - 1]) ? "*" : "/*"; |
| 21697 | 21886 | |
| 21698 | 21887 | if ((dir = (DIR *) Jim_Alloc(sizeof *dir)) != 0 && |
| 21699 | 21888 | (dir->name = (char *)Jim_Alloc(base_length + strlen(all) + 1)) != 0) { |
| 21700 | 21889 | strcat(strcpy(dir->name, name), all); |
| 21701 | 21890 | |
| 21702 | 21891 | if ((dir->handle = (long)_findfirst(dir->name, &dir->info)) != -1) |
| 21703 | 21892 | dir->result.d_name = 0; |
| 21704 | | - else { |
| 21893 | + else { |
| 21705 | 21894 | Jim_Free(dir->name); |
| 21706 | 21895 | Jim_Free(dir); |
| 21707 | 21896 | dir = 0; |
| 21708 | 21897 | } |
| 21709 | 21898 | } |
| 21710 | | - else { |
| 21899 | + else { |
| 21711 | 21900 | Jim_Free(dir); |
| 21712 | 21901 | dir = 0; |
| 21713 | 21902 | errno = ENOMEM; |
| 21714 | 21903 | } |
| 21715 | 21904 | } |
| | @@ -21727,11 +21916,11 @@ |
| 21727 | 21916 | if (dir->handle != -1) |
| 21728 | 21917 | result = _findclose(dir->handle); |
| 21729 | 21918 | Jim_Free(dir->name); |
| 21730 | 21919 | Jim_Free(dir); |
| 21731 | 21920 | } |
| 21732 | | - if (result == -1) |
| 21921 | + if (result == -1) |
| 21733 | 21922 | errno = EBADF; |
| 21734 | 21923 | return result; |
| 21735 | 21924 | } |
| 21736 | 21925 | |
| 21737 | 21926 | struct dirent *readdir(DIR * dir) |
| | @@ -21810,11 +21999,11 @@ |
| 21810 | 21999 | } |
| 21811 | 22000 | |
| 21812 | 22001 | void Jim_HistoryShow(void) |
| 21813 | 22002 | { |
| 21814 | 22003 | #ifdef USE_LINENOISE |
| 21815 | | - |
| 22004 | + |
| 21816 | 22005 | int i; |
| 21817 | 22006 | int len; |
| 21818 | 22007 | char **history = linenoiseHistory(&len); |
| 21819 | 22008 | for (i = 0; i < len; i++) { |
| 21820 | 22009 | printf("%4d %s\n", i + 1, history[i]); |
| | @@ -21876,11 +22065,11 @@ |
| 21876 | 22065 | Jim_DecrRefCount(interp, scriptObjPtr); |
| 21877 | 22066 | retcode = JIM_OK; |
| 21878 | 22067 | goto out; |
| 21879 | 22068 | } |
| 21880 | 22069 | if (Jim_Length(scriptObjPtr) != 0) { |
| 21881 | | - |
| 22070 | + |
| 21882 | 22071 | Jim_AppendString(interp, scriptObjPtr, "\n", 1); |
| 21883 | 22072 | } |
| 21884 | 22073 | Jim_AppendString(interp, scriptObjPtr, line, -1); |
| 21885 | 22074 | free(line); |
| 21886 | 22075 | if (Jim_ScriptIsComplete(interp, scriptObjPtr, &state)) |
| | @@ -21888,11 +22077,11 @@ |
| 21888 | 22077 | |
| 21889 | 22078 | snprintf(prompt, sizeof(prompt), "%c> ", state); |
| 21890 | 22079 | } |
| 21891 | 22080 | #ifdef USE_LINENOISE |
| 21892 | 22081 | if (strcmp(Jim_String(scriptObjPtr), "h") == 0) { |
| 21893 | | - |
| 22082 | + |
| 21894 | 22083 | Jim_HistoryShow(); |
| 21895 | 22084 | Jim_DecrRefCount(interp, scriptObjPtr); |
| 21896 | 22085 | continue; |
| 21897 | 22086 | } |
| 21898 | 22087 | |
| | @@ -21931,11 +22120,11 @@ |
| 21931 | 22120 | static void JimSetArgv(Jim_Interp *interp, int argc, char *const argv[]) |
| 21932 | 22121 | { |
| 21933 | 22122 | int n; |
| 21934 | 22123 | Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0); |
| 21935 | 22124 | |
| 21936 | | - |
| 22125 | + |
| 21937 | 22126 | for (n = 0; n < argc; n++) { |
| 21938 | 22127 | Jim_Obj *obj = Jim_NewStringObj(interp, argv[n], -1); |
| 21939 | 22128 | |
| 21940 | 22129 | Jim_ListAppendElement(interp, listObj, obj); |
| 21941 | 22130 | } |
| | @@ -21971,47 +22160,47 @@ |
| 21971 | 22160 | { |
| 21972 | 22161 | int retcode; |
| 21973 | 22162 | Jim_Interp *interp; |
| 21974 | 22163 | char *const orig_argv0 = argv[0]; |
| 21975 | 22164 | |
| 21976 | | - |
| 22165 | + |
| 21977 | 22166 | if (argc > 1 && strcmp(argv[1], "--version") == 0) { |
| 21978 | 22167 | printf("%d.%d\n", JIM_VERSION / 100, JIM_VERSION % 100); |
| 21979 | 22168 | return 0; |
| 21980 | 22169 | } |
| 21981 | 22170 | else if (argc > 1 && strcmp(argv[1], "--help") == 0) { |
| 21982 | 22171 | usage(argv[0]); |
| 21983 | 22172 | return 0; |
| 21984 | 22173 | } |
| 21985 | 22174 | |
| 21986 | | - |
| 22175 | + |
| 21987 | 22176 | interp = Jim_CreateInterp(); |
| 21988 | 22177 | Jim_RegisterCoreCommands(interp); |
| 21989 | 22178 | |
| 21990 | | - |
| 22179 | + |
| 21991 | 22180 | if (Jim_InitStaticExtensions(interp) != JIM_OK) { |
| 21992 | 22181 | JimPrintErrorMessage(interp); |
| 21993 | 22182 | } |
| 21994 | 22183 | |
| 21995 | 22184 | Jim_SetVariableStrWithStr(interp, "jim::argv0", orig_argv0); |
| 21996 | 22185 | Jim_SetVariableStrWithStr(interp, JIM_INTERACTIVE, argc == 1 ? "1" : "0"); |
| 21997 | 22186 | retcode = Jim_initjimshInit(interp); |
| 21998 | 22187 | |
| 21999 | 22188 | if (argc == 1) { |
| 22000 | | - |
| 22189 | + |
| 22001 | 22190 | if (retcode == JIM_ERR) { |
| 22002 | 22191 | JimPrintErrorMessage(interp); |
| 22003 | 22192 | } |
| 22004 | 22193 | if (retcode != JIM_EXIT) { |
| 22005 | 22194 | JimSetArgv(interp, 0, NULL); |
| 22006 | 22195 | retcode = Jim_InteractivePrompt(interp); |
| 22007 | 22196 | } |
| 22008 | 22197 | } |
| 22009 | 22198 | else { |
| 22010 | | - |
| 22199 | + |
| 22011 | 22200 | if (argc > 2 && strcmp(argv[1], "-e") == 0) { |
| 22012 | | - |
| 22201 | + |
| 22013 | 22202 | JimSetArgv(interp, argc - 3, argv + 3); |
| 22014 | 22203 | retcode = Jim_Eval(interp, argv[2]); |
| 22015 | 22204 | if (retcode != JIM_ERR) { |
| 22016 | 22205 | printf("%s\n", Jim_String(Jim_GetResult(interp))); |
| 22017 | 22206 | } |
| 22018 | 22207 | |