interp()函式用了大量的巨集。IREF_NEXT只是其中一個巨集，但是出現的頻率很高。

但是透徹的理解這個巨集將為理解interp()函式提供便利。

它的定義形式如下：

#define IREF_NEXT(ip)/ ((const ref_packed *)((const ref *)(ip) + 1))

這句看似簡單的程式碼實際上不那麼容易理解，而後面一些列的巨集要麼與此類似，要麼間接的呼叫它。

而ref的定義是下面這個樣子：

struct ref_s { struct tas_s tas; union v { /* name the union to keep gdb happy */ int intval; ushort boolval; float realval; ulong saveid; byte *bytes; const byte *const_bytes; ref *refs; const ref *const_refs; name *pname; const name *const_pname; dict *pdict; const dict *const_pdict; /* * packed is the normal variant for referring to packed arrays, * but we need a writable variant for memory management and for * storing into packed dictionary key arrays. */ const ref_packed *packed; ref_packed *writable_packed; op_proc_t opproc; struct stream_s *pfile; struct gx_device_s *pdevice; obj_header_t *pstruct; } value; };

要使(const ref*)rp +1 變得有有意義，關鍵在於解析器是怎麼處理的。

我們以"{}"為例，來解釋它。

識別過程，是在scan_token()函式中辦到的，但是具體是怎樣辦到的？

看下面擷取的部分程式碼片段：

int scan_token(i_ctx_t *i_ctx_p, ref * pref, scanner_state * pstate) { ..................... case '{': /* 比較 {} 和 [] 的執行方式不同 */ if (pstack == 0) { /* outermost procedure */ if_not_spush1() { scan_putback(); scan_type = scanning_none; goto pause_ret; } /* pstack for very first { encountered, */ /* for error recovery */ pdepth = ref_stack_count_inline(&o_stack); } make_int(osp, pstack); pstack = ref_stack_count_inline(&o_stack);/* stack depth when starting current */ /* 從上面可以看出在這種形式下：pdepth != pstack，於是在下面的處理將發生改變 */ if_debug3('S', "[S{]d=%d, s=%d->%d/n", pdepth, (int)osp->value.intval, pstack); goto snext; ......................... case '}': if (pstack == 0) sreturn(e_syntaxerror); osp--; { /* 這是在操作符棧中，物件元素的個數 */ uint size = ref_stack_count_inline(&o_stack) - pstack; ref arr;/* 這樣做的目的實際上就想把運算元棧的所有物件放在arr中,指標指向。*/ if_debug4('S', "[S}]d=%d, s=%d->%d, c=%d/n", pdepth, pstack, (pstack == pdepth ? 0 : ref_stack_index(&o_stack, size)->value.intval), size + pstack); myref = (pstack == pdepth ? pref : &arr);/*上面已經解釋了，肯定不等。*/ if (check_only) { make_empty_array(myref, 0); ref_stack_pop(&o_stack, size); } else if (ref_array_packing.value.boolval) { retcode = make_packed_array(myref, &o_stack, size, idmemory, "scanner(packed)"); if (retcode < 0) { /* must be VMerror */ osp++; scan_putback(); scan_type = scanning_none; goto pause_ret; } r_set_attrs(myref, a_executable); } else {/*討論一種易於理解的方式*/ /* 為myref分配記憶體空間 */ retcode = ialloc_ref_array(myref, a_executable + a_all, size, "scanner(proc)"); if (retcode < 0) { /* must be VMerror */ osp++; scan_putback(); scan_type = scanning_none; goto pause_ret; }//ref_stack_store 這步非常重要：把o_stack中size個物件拷貝到myref中。 retcode = ref_stack_store(&o_stack, myref, size, 0, 1, false, idmemory, "scanner"); if (retcode < 0) { ifree_ref_array(myref, "scanner(proc)"); sreturn(retcode); } /*因為全部拷貝到myref中了，所以把所有的操作符棧中關於過程的物件全部pop*/ ref_stack_pop(&o_stack, size); } if (pstack == pdepth) { /* This was the top-level procedure. */ spop1(); pstack = 0; } else { if (osp < osbot) ref_stack_pop_block(&o_stack); pstack = osp->value.intval; *osp = arr; goto snext; } } break; ............. }

現在到了一個很關鍵的函式——ref_stack_store(const ref_stack_t *pstack, ref *parray, uint count,
  uint skip, int age, bool check, gs_dual_memory_t *idmemory,
  client_name_t cname);

這個函式能夠說明為什麼IREF_NEXT能以那樣的形式出現是正確的。

這個函式的原始碼如下：

int
ref_stack_store(const ref_stack_t *pstack, ref *parray, uint count,
  uint skip, int age, bool check, gs_dual_memory_t *idmemory,
  client_name_t cname)
{
    uint left, pass;
    ref *to;
    ref_stack_enum_t rsenum;

    if (count > ref_stack_count(pstack) || count > r_size(parray))
 return_error(e_rangecheck);
    if (check) {
 int code = ref_stack_store_check(pstack, parray, count, skip);

 if (code < 0)
     return code;
    }
    to = parray->value.refs + count;
    left = count, pass = skip;
    ref_stack_enum_begin(&rsenum, pstack);
    do {
 ref *from = rsenum.ptr;
 uint size = rsenum.size;

 if (size <= pass)
     pass -= size;
 else {
     if (pass != 0)
  size -= pass, pass = 0;
     from += size;
     if (size > left)
  size = left;
     left -= size;
     switch (age) {
     case -1:  /* not an array */
  while (size--) {
      from--, to--;
      ref_assign(to, from);
  }
  break;
     case 0:  /* old array */
  while (size--) {
      from--, to--;
      ref_assign_old(parray, to, from, cname);
  }
  break;
     case 1:  /* new array */
  while (size--) {
      from--, to--;
      ref_assign_new(to, from);
  }
  break;
     }
     if (left == 0)
  break;
 }
    } while (ref_stack_enum_next(&rsenum));
    r_set_size(parray, count);
    return 0;
}

由於傳入的age引數是1，所以進入case 1:這個階段。

加粗的黑體字程式碼表明瞭巨集所運用的方式是正確的。

這點可以通過執行除錯來斧正。