RAPL

Diff
Login

Diff

Annotate Patch Side-by-side Diff

Differences From Artifact [9b69d3e30a]:

To Artifact [5ca4284e97]:

︙
61
62
63
64
65
66
67
68

69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

87
88
89
90
91
92
93

61
62
63
64
65
66
67

68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94








-
+


















+








  my_name: "RaplEvalStatement",

  /* ==================== substOneToken ===================================== */
  substOneToken: function (token, idx) {
    var stmt = this;
    var obj_ptr;

//print("SUBST1!"+token.token+"!"+token.obj_ptr.mySelf()+"!"+token.obj_ptr.getString()+"!");
print("SUBST1!"+token.token+"!"+stmt.getTokenString(token.token)+"!"+token.obj_ptr.mySelf()+"!"+token.obj_ptr.getString()+"!");

    switch (token.token) {
    case stmt.TOKEN_STR:
    case stmt.TOKEN_ESC:
    case stmt.TOKEN_QUOTE_ESC:
      obj_ptr = token.obj_ptr;
      break;
    case stmt.TOKEN_VAR_ARRAY_NAME:
    case stmt.TOKEN_VAR:
      obj_ptr = stmt.interp.variable_obj_type.getVariable(token.obj_ptr, 0);
      break;
    case stmt.TOKEN_ARRAY_NAME_VAR:
      obj_ptr = JimExpandDictSugar(stmt.interp, token.obj_ptr);
      break;
    case stmt._EXPRSUGAR:
      obj_ptr = JimExpandExprSugar(stmt.interp, token.obj_ptr);
      break;
    case stmt.TOKEN_CMD:
print("CMD!"+token.obj_ptr.toDebugString()+"!");
      switch (stmt.evalObj(token.obj_ptr)) {
      case stmt.OK:
      case stmt.RETURN:
        obj_ptr = stmt.interp.result;
        break;
      case stmt.BREAK:
        /* Stop substituting */
︙
239
240
241
242
243
244
245
246

247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273



274
275

276
277
278


279
280
281


282
283
284
285
286
287
288
289
290








291
292
293
294
295
296
297
298







299
300
301
302
303




304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335





































336
337
338
339
340
341
342






343
344
345


346
347
348
349
350
351
352
353







354
355
356
357
358
359





360
361
362
363
364
365






366
367
368
369
370




371
372
373
374
375
376
377

240
241
242
243
244
245
246

247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

265

266
267
268
269



270
271
272
273

274
275


276
277



278
279









280
281
282
283
284
285
286
287
288







289
290
291
292
293
294
295





296
297
298
299
































300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336







337
338
339
340
341
342



343
344








345
346
347
348
349
350
351
352





353
354
355
356
357






358
359
360
361
362
363
364




365
366
367
368
369
370
371
372
373
374
375








-
+

















-

-




-
-
-
+
+
+

-
+

-
-
+
+
-
-
-
+
+
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+

-
-
-
-
-
-
-
+
+
+
+
+
+
+
-
-
-
-
-
+
+
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
-
+
+
+
+
+
+
-
-
-
+
+
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+

-
-
-
-
-
+
+
+
+
+
-
-
-
-
-
-
+
+
+
+
+
+

-
-
-
-
+
+
+
+








        && script.script_object.tokens[1].obj_ptr.cmdValue.cmdPtr.isproc == 0
        && script.script_object.tokens[1].obj_ptr.cmdValue.cmdPtr.u.native.cmdProc == Jim_IncrCoreCommand
        && script.script_object.tokens[2].obj_ptr.obj_typ.name == "variable") {

      var obj_ptr = stmt.interp.getVariable(script.script_object.tokens[2].obj_ptr, stmt.TOKENNONE);

      if (obj_ptr && !obj_ptr.isShared() && obj_ptrobj_type.name == "int") {
//            JimWideValue(obj_ptr)++;
//        JimWideValue(obj_ptr)++;
        obj_ptr.invalidateStringRep();
        script_obj_ptr.decrRefCount();
        stmt.interp.setResult(obj_ptr);
        return stmt.OK;
      }
    }

    /* Now we have to make sure the internal repr will not be
     * freed on shimmering.
     *
     * Think for example to this:
     *
     * set x {llength $x; ... some more code ...}; eval $x
     *
     * In order to preserve the internal rep, we increment the
     * inUse field of the script internal rep structure. */
    script.in_use++;

    token = script.script_object.tokens;

    /* Execute every command sequentially until the end of the script
     * or an error occurs.
     */
    for (i = 0; i < script.len && retcode == stmt.OK; ) {
        var argc;
        var j;
        var cmd;
      var argc;
      var j;
      var cmd;

        /* First token of the line is always TOKEN_LINE */
      /* First token of the line is always TOKEN_LINE */
//print("I!"+i+"!"+script.getTokenString(token[i].token)+"!");
        argc = token[i].obj_ptr.scriptLineValue.argc();
        linenr = token[i].obj_ptr.scriptLineValue.line();
      argc = token[i].obj_ptr.scriptLineValue.argc();
      linenr = token[i].obj_ptr.scriptLineValue.line();

        /* Skip the TOKEN_LINE token */
        i++;
      /* Skip the TOKEN_LINE token */
      i++;

        /* Populate the arguments objects.
         * If an error occurs, retcode will be set and
         * 'j' will be set to the number of args expanded
         */
        for (j = 0; j < argc; j++) {
          var word_tokens = 1;
          var expand = 0;
          var word_obj_ptr = null;
      /* Populate the arguments objects.
       * If an error occurs, retcode will be set and
       * 'j' will be set to the number of args expanded
       */
      for (j = 0; j < argc; j++) {
        var word_tokens = 1;
        var expand = 0;
        var word_obj_ptr = null;

          if (token[i].token == stmt.TOKEN_WORD) {
            word_tokens = token[i++].obj_ptr.wideValue();
            if (word_tokens < 0) {
              expand = 1;
              word_tokens = -word_tokens;
            }
          }
        if (token[i].token == stmt.TOKEN_WORD) {
          word_tokens = token[i++].obj_ptr.wideValue();
          if (word_tokens < 0) {
            expand = 1;
            word_tokens = -word_tokens;
          }
        }

          if (word_tokens == 1) {
            /* Fast path if the token does not
             * need interpolation 
	     */
        if (word_tokens == 1) {
          /* Fast path if the token does not
           * need interpolation 
           */

            switch (token[i].token) {
            case stmt.TOKEN_ESC:
            case stmt.TOKEN_QUOTE_ESC:
            case stmt.TOKEN_STR:
            case stmt.TOKEN_BRACE:
              word_obj_ptr = token[i].obj_ptr;
              break;
            case stmt.TOKEN_VAR:
              word_obj_ptr = stmt.interp.variable_obj_type.getVariable(token[i].obj_ptr, stmt.VAR_LOOKUP_LEAVE_ERR_MSG);
              break;
            case stmt.TOKEN_EXPRSUGAR:
              word_obj_ptr = stmt.expandExprSugar(token[i].obj_ptr);
              break;
            case stmt.TOKEN_ARRAY_NAME_VAR:
              word_obj_ptr = stmt.expandDictSugar(token[i].obj_ptr);
              break;
            case stmt.TOKEN_CMD:
              retcode = stmt.evalObj(token[i].obj_ptr);
              if (retcode == stmt.OK) {
                word_obj_ptr = stmt.interp.result;
              }
              break;
            default:
              stmt.panic(1, "default token type reached in evalObj(): "+stmt.getTokenString(token[i].token));
            }
          } else {
            /* For interpolation we call a helper
             * function to do the work for us. 
	     */
            word_obj_ptr = stmt.interpolateTokens(token, i, word_tokens, stmt.TOKEN_NONE);
          }
          switch (token[i].token) {
          case stmt.TOKEN_ESC:
          case stmt.TOKEN_QUOTE_ESC:
          case stmt.TOKEN_STR:
          case stmt.TOKEN_BRACE:
            word_obj_ptr = token[i].obj_ptr;
            break;
          case stmt.TOKEN_VAR_ARRAY_NAME:
print("VAN!"+token[i].obj_ptr.toDebugString()+"!");
            word_obj_ptr = stmt.interp.array_obj_type.expandArray(token[i].obj_ptr);
print("VAN2!"+token[i].obj_ptr.toDebugString()+"!");
            word_obj_ptr = stmt.interp.variable_obj_type.getVariable(token[i].obj_ptr, stmt.VAR_LOOKUP_LEAVE_ERR_MSG);
            break;
          case stmt.TOKEN_VAR:
            word_obj_ptr = stmt.interp.variable_obj_type.getVariable(token[i].obj_ptr, stmt.VAR_LOOKUP_LEAVE_ERR_MSG);
            break;
          case stmt.TOKEN_EXPRSUGAR:
            word_obj_ptr = stmt.expandExprSugar(token[i].obj_ptr);
            break;
          case stmt.TOKEN_ARRAY_NAME_VAR:
            word_obj_ptr = stmt.expandDictSugar(token[i].obj_ptr);
            break;
          case stmt.TOKEN_CMD:
            retcode = stmt.evalObj(token[i].obj_ptr);
            if (retcode == stmt.OK) {
              word_obj_ptr = stmt.interp.result;
            }
            break;
          default:
            stmt.panic(1, "default token type reached in evalObj(): "+stmt.getTokenString(token[i].token));
          }
        } else {
          /* For interpolation we call a helper
           * function to do the work for us. 
           */
          word_obj_ptr = stmt.interpolateTokens(token, i, word_tokens, stmt.TOKEN_NONE);
        }

          if (!word_obj_ptr) {
            if (retcode == stmt.OK) {
              retcode = stmt.ERROR;
            }
            break;
          }
        if (!word_obj_ptr) {
          if (retcode == stmt.OK) {
            retcode = stmt.ERROR;
          }
          break;
        }

          word_obj_ptr.incrRefCount();
          i += word_tokens;
        word_obj_ptr.incrRefCount();
        i += word_tokens;

          if (!expand) {
            argv[j] = word_obj_ptr;
          } else {
            /* Need to expand word_obj_ptr into multiple args from argv[j] ... */
            var len = listLength(word_obj_ptr);
            var newargc = argc + len - 1;
            var k;
        if (!expand) {
          argv[j] = word_obj_ptr;
        } else {
          /* Need to expand word_obj_ptr into multiple args from argv[j] ... */
          var len = listLength(word_obj_ptr);
          var newargc = argc + len - 1;
          var k;

            /* Now copy in the expanded version */
            for (k = 0; k < len; k++) {
              argv[j++] = word_obj_ptr.listValue.elem[k];
              word_obj_ptr.listValue.elem[k].incrRefCount();
            }
          /* Now copy in the expanded version */
          for (k = 0; k < len; k++) {
            argv[j++] = word_obj_ptr.listValue.elem[k];
            word_obj_ptr.listValue.elem[k].incrRefCount();
          }

            /* The original object reference is no longer needed,
             * after the expansion it is no longer present on
             * the argument vector, but the single elements are
             * in its place. */
            word_obj_ptr.decrRefCount();
          /* The original object reference is no longer needed,
           * after the expansion it is no longer present on
           * the argument vector, but the single elements are
           * in its place. 
	   */
          word_obj_ptr.decrRefCount();

            /* And update the indexes */
            j--;
            argc += len - 1;
          }
          /* And update the indexes */
          j--;
          argc += len - 1;
        }
      }

      if (retcode == stmt.OK && argc) {
        /* Lookup the command to call */
//print("A0!"+argv[0]+"!");
        cmd = stmt.interp.getCommand(argv[0], stmt.VAR_LOOKUP_LEAVE_ERR_MSG);
        if (cmd != null) {
︙