Changeset 1645

Show
Ignore:
Timestamp:
02/17/98 01:45:16 (11 years ago)
Author:
himi
Message:

Emacs 20.6 import

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/GNU/src/w32proc.c

    r1641 r1645  
    304304 
    305305static BOOL  
    306 create_child (char *exe, char *cmdline, char *env, int is_gui_app, 
     306create_child (char *exe, char *cmdline, char *env, 
    307307              int * pPid, child_process *cp) 
    308308{ 
     
    319319   
    320320#ifdef HAVE_NTGUI 
    321   if (NILP (Vw32_start_process_show_window) && !is_gui_app
     321  if (NILP (Vw32_start_process_show_window)
    322322    start.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; 
    323323  else 
     
    569569 
    570570void 
    571 w32_executable_type (char * filename, int * is_dos_app, int * is_cygnus_app, int * is_gui_app
     571w32_executable_type (char * filename, int * is_dos_app, int * is_cygnus_app
    572572{ 
    573573  file_data executable; 
     
    577577  *is_dos_app = FALSE; 
    578578  *is_cygnus_app = FALSE; 
    579   *is_gui_app = FALSE; 
    580579 
    581580  if (!open_input_file (&executable, filename)) 
     
    598597      p = egetenv ("COMSPEC"); 
    599598      if (p) 
    600         w32_executable_type (p, is_dos_app, is_cygnus_app, is_gui_app); 
     599        w32_executable_type (p, is_dos_app, is_cygnus_app); 
    601600    } 
    602601  else 
     
    650649                } 
    651650            } 
    652  
    653           /* Check whether app is marked as a console or windowed (aka 
    654              GUI) app.  Accept Posix and OS2 subsytem apps as console 
    655              apps.  */ 
    656           *is_gui_app = (nt_header->OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI); 
    657651        } 
    658652    } 
     
    716710  int pid; 
    717711  child_process *cp; 
    718   int is_dos_app, is_cygnus_app, is_gui_app
     712  int is_dos_app, is_cygnus_app
    719713  int do_quoting = 0; 
    720714  char escape_char; 
     
    758752     was compiled with the Cygnus GNU toolchain and hence relies on 
    759753     cygwin.dll to parse the command line - we use this to decide how to 
    760      escape quote chars in command line args that must be quoted). 
    761  
    762      Also determine whether it is a GUI app, so that we don't hide its 
    763      initial window unless specifically requested.  */ 
    764   w32_executable_type (cmdname, &is_dos_app, &is_cygnus_app, &is_gui_app); 
     754     escape quote chars in command line args that must be quoted). */ 
     755  w32_executable_type (cmdname, &is_dos_app, &is_cygnus_app); 
    765756 
    766757  /* On Windows 95, if cmdname is a DOS app, we invoke a helper 
     
    987978   
    988979  /* Now create the process.  */ 
    989   if (!create_child (cmdname, cmdline, env, is_gui_app, &pid, cp)) 
     980  if (!create_child (cmdname, cmdline, env, &pid, cp)) 
    990981    { 
    991982      delete_child (cp); 
     
    21492140               &Vw32_start_process_show_window, 
    21502141    "When nil, new child processes hide their windows.\n\ 
    2151 When non-nil, they show their window in the method of their choice.\n\ 
    2152 This variable doesn't affect GUI applications, which will never be hidden."); 
     2142When non-nil, they show their window in the method of their choice."); 
    21532143  Vw32_start_process_show_window = Qnil; 
    21542144 
  • branches/GNU/src/w32select.c

    r1625 r1645  
    2525#include "w32term.h"    /* for all of the w32 includes */ 
    2626#include "dispextern.h" /* frame.h seems to want this */ 
    27 #include "keyboard.h" 
    2827#include "frame.h"      /* Need this to get the X window of selected_frame */ 
    2928#include "blockinput.h" 
     
    3837static Lisp_Object Vselection_coding_system; 
    3938 
    40 /* Coding system for the next communicating with other Windows programs.  */ 
     39/* Coding system for the next communicating with other X clients.  */ 
    4140static Lisp_Object Vnext_selection_coding_system; 
    42  
    43 /* The last text we put into the clipboard.  This is used to prevent 
    44    passing back our own text from the clipboard, instead of using the 
    45    kill ring.  The former is undesirable because the clipboard data 
    46    could be MULEtilated by inappropriately chosen 
    47    (next-)selection-coding-system.  For this reason, we must store the 
    48    text *after* it was encoded/Unix-to-DOS-converted.  */ 
    49 static unsigned char *last_clipboard_text = NULL; 
    50 static size_t clipboard_storage_size = 0; 
    5141 
    5242#if 0 
     
    137127    /* Since we are now handling multilingual text, we must consider 
    138128       encoding text for the clipboard.  */ 
    139     int charset_info = find_charset_in_text (src, XSTRING (string)->size, 
    140                                              nbytes, NULL, Qnil); 
    141  
    142     if (charset_info == 0) 
     129    int charsets[MAX_CHARSET + 1]; 
     130    int num; 
     131 
     132    bzero (charsets, (MAX_CHARSET + 1) * sizeof (int)); 
     133    num = ((nbytes <= 1 /* Check the possibility of short cut.  */ 
     134            || !STRING_MULTIBYTE (string) 
     135            || nbytes == XSTRING (string)->size) 
     136           ? 0 
     137           : find_charset_in_str (src, nbytes, charsets, Qnil, 0, 1)); 
     138 
     139    if (!num || (num == 1 && charsets[CHARSET_ASCII])) 
    143140      { 
    144141        /* No multibyte character in OBJ.  We need not encode it.  */ 
     
    184181    else 
    185182      { 
    186         /* We must encode contents of OBJ to the selection coding 
    187            system. */ 
     183        /* We must encode contents of OBJ to compound text format. 
     184           The format is compatible with what the target `STRING' 
     185           expects if OBJ contains only ASCII and Latin-1 
     186           characters.  */ 
    188187        int bufsize; 
    189188        struct coding_system coding; 
     
    194193        setup_coding_system 
    195194          (Fcheck_coding_system (Vnext_selection_coding_system), &coding); 
    196         coding.src_multibyte = 1; 
    197         coding.dst_multibyte = 0; 
    198195        Vnext_selection_coding_system = Qnil; 
    199196        coding.mode |= CODING_MODE_LAST_BLOCK; 
     
    205202        encode_coding (&coding, src, dst, nbytes, bufsize); 
    206203        Vlast_coding_system_used = coding.symbol; 
    207  
    208         /* Stash away the data we are about to put into the clipboard, so we 
    209            could later check inside Fw32_get_clipboard_data whether 
    210            the clipboard still holds our data.  */ 
    211         if (clipboard_storage_size < coding.produced) 
    212           { 
    213             clipboard_storage_size = coding.produced + 100; 
    214             last_clipboard_text = (char *) xrealloc (last_clipboard_text, 
    215                                                      clipboard_storage_size); 
    216           } 
    217         if (last_clipboard_text) 
    218           memcpy (last_clipboard_text, dst, coding.produced); 
    219  
    220204        GlobalUnlock (htext); 
    221  
    222205        /* Shrink data block to actual size.  */ 
    223         htext2 = GlobalReAlloc (htext, coding.produced, 
    224                                 GMEM_MOVEABLE | GMEM_DDESHARE); 
     206        htext2 = GlobalReAlloc (htext, coding.produced, GMEM_MOVEABLE | GMEM_DDESHARE); 
    225207        if (htext2 != NULL) htext = htext2; 
    226208      } 
     
    229211  if (!OpenClipboard ((!NILP (frame) && FRAME_W32_P (XFRAME (frame))) ? FRAME_W32_WINDOW (XFRAME (frame)) : NULL)) 
    230212    goto error; 
    231  
     213   
    232214  ok = EmptyClipboard () && SetClipboardData (CF_TEXT, htext); 
    233215   
     
    240222  ok = FALSE; 
    241223  if (htext) GlobalFree (htext); 
    242   if (last_clipboard_text) 
    243     *last_clipboard_text = '\0'; 
    244  
     224   
    245225 done: 
    246226  UNBLOCK_INPUT; 
     
    280260    nbytes = strlen (src); 
    281261 
    282     /* If the text in clipboard is identical to what we put there 
    283        last time w32_set_clipboard_data was called, pretend there's no 
    284        data in the clipboard.  This is so we don't pass our own text 
    285        from the clipboard (which might be troublesome if the killed 
    286        text includes null characters).  */ 
    287     if (last_clipboard_text 
    288         && clipboard_storage_size >= nbytes 
    289         && memcmp(last_clipboard_text, src, nbytes) == 0) 
    290       goto closeclip; 
    291  
    292262    if ( 
    293263#if 1 
     
    298268        ) 
    299269      { 
     270#if 1 
     271        /* We have to assume clipboard might contain "compound" text (to 
     272           use the X terminology), since Emacs itself will default to 
     273           using iso-2022 encoding which doesn't contain non-ascii 
     274           characters.  */ 
     275        require_decoding = 1; 
     276#else 
    300277        /* If the clipboard data contains any non-ascii code, we 
    301278           need to decode it.  */ 
     
    310287              } 
    311288          } 
     289#endif 
    312290      } 
    313291     
     
    322300        setup_coding_system 
    323301          (Fcheck_coding_system (Vnext_selection_coding_system), &coding); 
    324         coding.src_multibyte = 0; 
    325         coding.dst_multibyte = 1; 
    326302        Vnext_selection_coding_system = Qnil; 
    327303        coding.mode |= CODING_MODE_LAST_BLOCK; 
     
    330306        decode_coding (&coding, src, buf, nbytes, bufsize); 
    331307        Vlast_coding_system_used = coding.symbol; 
    332         ret = make_string_from_bytes ((char *) buf, 
    333                                       coding.produced_char, coding.produced); 
     308        truelen = (coding.fake_multibyte 
     309                   ? multibyte_chars_in_text (buf, coding.produced) 
     310                   : coding.produced_char); 
     311        ret = make_string_from_bytes ((char *) buf, truelen, coding.produced); 
    334312        xfree (buf); 
    335313      } 
  • branches/GNU/src/xdisp.c

    r1617 r1645  
    19921992      XSETFASTINT (w->last_overlay_modified, 0); 
    19931993      if (startp < BEGV) startp = BEGV, startp_byte = BEGV_BYTE; 
    1994       if (startp > ZV)   startp = ZV, startp_byte = ZV_BYTE; 
     1994      if (startp > ZV)   startp = ZV, startp = ZV_BYTE; 
    19951995      try_window (window, startp); 
    19961996      if (cursor_vpos < 0) 
  • branches/fsf/src/ccl.c

    r837 r1645  
    628628#define CCL_NE          0x15    /* X = (X != Y) */ 
    629629 
    630 #define CCL_ENCODE_SJIS 0x16    /* X = HIGHER_BYTE (SJIS (Y, Z)) 
     630#define CCL_DECODE_SJIS 0x16    /* X = HIGHER_BYTE (DE-SJIS (Y, Z)) 
     631                                   r[7] = LOWER_BYTE (DE-SJIS (Y, Z)) */ 
     632#define CCL_ENCODE_SJIS 0x17    /* X = HIGHER_BYTE (SJIS (Y, Z)) 
    631633                                   r[7] = LOWER_BYTE (SJIS (Y, Z) */ 
    632 #define CCL_DECODE_SJIS 0x17    /* X = HIGHER_BYTE (DE-SJIS (Y, Z)) 
    633                                    r[7] = LOWER_BYTE (DE-SJIS (Y, Z)) */ 
    634634 
    635635/* Terminate CCL program successfully.  */ 
     
    637637  do {                                  \ 
    638638    ccl->status = CCL_STAT_SUCCESS;     \ 
    639     ccl->ic = CCL_HEADER_MAIN;          \ 
    640639    goto ccl_finish;                    \ 
    641640  } while (0) 
     
    671670        if (dst + len <= (dst_bytes ? dst_end : src))   \ 
    672671          {                                             \ 
    673             bcopy (str, dst, len);                      \ 
    674             dst += len;                                 \ 
     672            while (len--) *dst++ = *str++;              \ 
    675673          }                                             \ 
    676674        else                                            \ 
     
    710708 
    711709 
     710/* Set C to the character code made from CHARSET and CODE.  This is 
     711   like MAKE_CHAR but check the validity of CHARSET and CODE.  If they 
     712   are not valid, set C to (CODE & 0xFF) because that is usually the 
     713   case that CCL_ReadMultibyteChar2 read an invalid code and it set 
     714   CODE to that invalid byte.  */ 
     715 
     716#define CCL_MAKE_CHAR(charset, code, c)                         \ 
     717  do {                                                          \ 
     718    if (charset == CHARSET_ASCII)                               \ 
     719      c = code & 0xFF;                                          \ 
     720    else if (CHARSET_DEFINED_P (charset)                        \ 
     721             && (code & 0x7F) >= 32                             \ 
     722             && (code < 256 || ((code >> 7) & 0x7F) >= 32))     \ 
     723      {                                                         \ 
     724        int c1 = code & 0x7F, c2 = 0;                           \ 
     725                                                                \ 
     726        if (code >= 256)                                        \ 
     727          c2 = c1, c1 = (code >> 7) & 0x7F;                     \ 
     728        c = MAKE_NON_ASCII_CHAR (charset, c1, c2);              \ 
     729      }                                                         \ 
     730    else                                                        \ 
     731      c = code & 0xFF;                                  \ 
     732  } while (0) 
     733 
     734 
    712735/* Execute CCL code on SRC_BYTES length text at SOURCE.  The resulting 
    713736   text goes to a place pointed by DESTINATION, the length of which 
     
    729752    int ic;                     /* Instruction Counter.  */ 
    730753  }; 
     754 
     755/* For the moment, we only support depth 256 of stack.  */  
     756static struct ccl_prog_stack ccl_prog_stack_struct[256]; 
    731757 
    732758int 
     
    745771  int jump_address; 
    746772  int i, j, op; 
    747   int stack_idx = 0
    748   /* For the moment, we only support depth 256 of stack.  */  
    749   struct ccl_prog_stack ccl_prog_stack_struct[256]
     773  int stack_idx = ccl->stack_idx
     774  /* Instruction counter of the current CCL code. */ 
     775  int this_ic
    750776 
    751777  if (ic >= ccl->eof_ic) 
    752778    ic = CCL_HEADER_MAIN; 
     779 
     780  if (ccl->buf_magnification ==0) /* We can't produce any bytes.  */ 
     781    dst = NULL; 
    753782 
    754783#ifdef CCL_DEBUG 
     
    777806        } 
    778807 
     808      this_ic = ic; 
    779809      code = XINT (ccl_prog[ic]); ic++; 
    780810      field1 = code >> 8; 
     
    898928          j = XINT (ccl_prog[ic]); 
    899929          op = field1 >> 6; 
    900           ic++
     930          jump_address = ic + 1
    901931          goto ccl_set_expr; 
    902932 
     
    918948          j = reg[Rrr]; 
    919949          op = field1 >> 6; 
     950          jump_address = ic; 
    920951          goto ccl_set_expr; 
    921952 
     
    9741005              break; 
    9751006            } 
     1007          if (src) 
     1008            src = src_end; 
     1009          /* ccl->ic should points to this command code again to 
     1010             suppress further processing.  */ 
     1011          ic--; 
    9761012          CCL_SUCCESS; 
    9771013 
     
    10691105            case CCL_GE: reg[rrr] = i >= j; break; 
    10701106            case CCL_NE: reg[rrr] = i != j; break; 
     1107            case CCL_DECODE_SJIS: DECODE_SJIS (i, j, reg[rrr], reg[7]); break; 
    10711108            case CCL_ENCODE_SJIS: ENCODE_SJIS (i, j, reg[rrr], reg[7]); break; 
    1072             case CCL_DECODE_SJIS: DECODE_SJIS (i, j, reg[rrr], reg[7]); break; 
    10731109            default: CCL_INVALID_CMD; 
    10741110            } 
     
    10781114              i = reg[rrr]; 
    10791115              CCL_WRITE_CHAR (i); 
     1116              ic = jump_address; 
    10801117            } 
    10811118          else if (!reg[rrr]) 
     
    10891126              if (!src) 
    10901127                CCL_INVALID_CMD; 
     1128 
    10911129              do { 
    10921130                if (src >= src_end) 
     
    11081146                    else 
    11091147                      ccl->private_state = COMPOSING_NO_RULE_HEAD; 
     1148 
     1149                    continue; 
    11101150                  } 
    1111                 if (ccl->private_state != 0
     1151                if (ccl->private_state != COMPOSING_NO
    11121152                  { 
    11131153                    /* composite character */ 
    1114                     if (*src < 0xA0) 
    1115                       ccl->private_state = 0
     1154                    if (i < 0xA0) 
     1155                      ccl->private_state = COMPOSING_NO
    11161156                    else 
    11171157                      { 
     1158                        if (COMPOSING_WITH_RULE_RULE == ccl->private_state) 
     1159                          { 
     1160                            ccl->private_state = COMPOSING_WITH_RULE_HEAD; 
     1161                            continue; 
     1162                          } 
     1163                        else if (COMPOSING_WITH_RULE_HEAD == ccl->private_state) 
     1164                          ccl->private_state = COMPOSING_WITH_RULE_RULE; 
     1165 
    11181166                        if (i == 0xA0) 
    11191167                          { 
     
    11241172                        else 
    11251173                          i -= 0x20; 
    1126  
    1127                         if (COMPOSING_WITH_RULE_RULE == ccl->private_state) 
    1128                           { 
    1129                             ccl->private_state = COMPOSING_WITH_RULE_HEAD; 
    1130                             continue; 
    1131                           } 
    1132                         else if (COMPOSING_WITH_RULE_HEAD == ccl->private_state) 
    1133                           ccl->private_state = COMPOSING_WITH_RULE_RULE; 
    11341174                      } 
    11351175                  } 
     1176 
    11361177                if (i < 0x80) 
    11371178                  { 
     
    11761217                else 
    11771218                  { 
    1178                     /* INVALID CODE 
    1179                        Returned charset is -1.  */ 
    1180                     reg[RRR] = -1
     1219                    /* INVALID CODE.  Return a single byte character.  */ 
     1220                    reg[RRR] = CHARSET_ASCII; 
     1221                    reg[rrr] = i
    11811222                  } 
    1182               } while (0); 
     1223                break; 
     1224              } while (1); 
    11831225              break; 
    11841226 
     
    11981240              i = reg[RRR]; /* charset */ 
    11991241              if (i == CHARSET_ASCII) 
    1200                 i = reg[rrr] & 0x7F; 
     1242                i = reg[rrr] & 0xFF; 
    12011243              else if (i == CHARSET_COMPOSITION) 
    12021244                i = MAKE_COMPOSITE_CHAR (reg[rrr]); 
     
    12141256            case CCL_TranslateCharacter: 
    12151257              i = reg[RRR]; /* charset */ 
    1216               if (i == CHARSET_ASCII) 
    1217                 i = reg[rrr] & 0x7F; 
    1218               else if (i == CHARSET_COMPOSITION) 
     1258              if (i == CHARSET_COMPOSITION) 
    12191259                { 
    12201260                  reg[RRR] = -1; 
    12211261                  break; 
    12221262                } 
    1223               else if (CHARSET_DIMENSION (i) == 1) 
    1224                 i = ((i - 0x70) << 7) | (reg[rrr] & 0x7F); 
    1225               else if (i < MIN_CHARSET_PRIVATE_DIMENSION2) 
    1226                 i = ((i - 0x8F) << 14) | (reg[rrr] & 0x3FFF); 
    1227               else 
    1228                 i = ((i - 0xE0) << 14) | (reg[rrr] & 0x3FFF); 
    1229  
     1263              CCL_MAKE_CHAR (i, reg[rrr], i); 
    12301264              op = translate_char (GET_TRANSLATION_TABLE (reg[Rrr]), 
    12311265                                   i, -1, 0, 0); 
     
    12411275              ic++; 
    12421276              i = reg[RRR]; /* charset */ 
    1243               if (i == CHARSET_ASCII) 
    1244                 i = reg[rrr] & 0x7F; 
    1245               else if (i == CHARSET_COMPOSITION) 
     1277              if (i == CHARSET_COMPOSITION) 
    12461278                { 
    12471279                  reg[RRR] = -1; 
    12481280                  break; 
    12491281                } 
    1250               else if (CHARSET_DIMENSION (i) == 1) 
    1251                 i = ((i - 0x70) << 7) | (reg[rrr] & 0x7F); 
    1252               else if (i < MIN_CHARSET_PRIVATE_DIMENSION2) 
    1253                 i = ((i - 0x8F) << 14) | (reg[rrr] & 0x3FFF); 
    1254               else 
    1255                 i = ((i - 0xE0) << 14) | (reg[rrr] & 0x3FFF); 
    1256  
     1282              CCL_MAKE_CHAR (i, reg[rrr], i); 
    12571283              op = translate_char (GET_TRANSLATION_TABLE (op), i, -1, 0, 0); 
    12581284              SPLIT_CHAR (op, reg[RRR], i, j); 
     
    14611487                    else if (EQ (content, Qlambda)) 
    14621488                      { 
     1489                        reg[RRR] = i; 
    14631490                        break; 
    14641491                      } 
     
    15031530                else 
    15041531                  { 
     1532                    reg[RRR] = 0; 
    15051533                    content = XVECTOR (map)->contents[point]; 
    15061534                    if (NILP (content)) 
     
    15081536                    else if (NUMBERP (content)) 
    15091537                      reg[rrr] = XINT (content); 
    1510                     else if (EQ (content, Qt)) 
    1511                       reg[RRR] = i; 
     1538                    else if (EQ (content, Qt)); 
    15121539                    else if (CONSP (content)) 
    15131540                      { 
     
    15441571      int msglen; 
    15451572 
     1573      if (!dst) 
     1574        dst = destination; 
     1575 
    15461576      switch (ccl->status) 
    15471577        { 
    15481578        case CCL_STAT_INVALID_CMD: 
    15491579          sprintf(msg, "\nCCL: Invalid command %x (ccl_code = %x) at %d.", 
    1550                   code & 0x1F, code, ic); 
     1580                  code & 0x1F, code, this_ic); 
    15511581#ifdef CCL_DEBUG 
    15521582          { 
     
    15551585 
    15561586            msglen = strlen (msg); 
    1557             if (dst + msglen <= dst_end
     1587            if (dst + msglen <= (dst_bytes ? dst_end : src)
    15581588              { 
    15591589                bcopy (msg, dst, msglen); 
     
    15681598                sprintf(msg, " %d", ccl_backtrace_table[i]); 
    15691599                msglen = strlen (msg); 
    1570                 if (dst + msglen > dst_end
     1600                if (dst + msglen > (dst_bytes ? dst_end : src)
    15711601                  break; 
    15721602                bcopy (msg, dst, msglen); 
    15731603                dst += msglen; 
    15741604              } 
     1605            goto ccl_finish; 
    15751606          } 
    15761607#endif 
    1577           goto ccl_finish
     1608          break
    15781609 
    15791610        case CCL_STAT_QUIT: 
     
    15861617 
    15871618      msglen = strlen (msg); 
    1588       if (dst + msglen <= dst_end
     1619      if (dst + msglen <= (dst_bytes ? dst_end : src)
    15891620        { 
    15901621          bcopy (msg, dst, msglen); 
     
    15951626 ccl_finish: 
    15961627  ccl->ic = ic; 
     1628  ccl->stack_idx = stack_idx; 
     1629  ccl->prog = ccl_prog; 
    15971630  if (consumed) *consumed = src - source; 
    1598   return dst - destination
     1631  return (dst ? dst - destination : 0)
    15991632} 
    16001633 
    16011634/* Setup fields of the structure pointed by CCL appropriately for the 
    1602    execution of compiled CCL code in VEC (vector of integer).  */ 
     1635   execution of compiled CCL code in VEC (vector of integer). 
     1636   If VEC is nil, we skip setting ups based on VEC.  */ 
    16031637void 
    16041638setup_ccl_program (ccl, vec) 
     
    16081642  int i; 
    16091643 
    1610   ccl->size = XVECTOR (vec)->size; 
    1611   ccl->prog = XVECTOR (vec)->contents; 
     1644  if (VECTORP (vec)) 
     1645    { 
     1646      struct Lisp_Vector *vp = XVECTOR (vec); 
     1647 
     1648      ccl->size = vp->size; 
     1649      ccl->prog = vp->contents; 
     1650      ccl->eof_ic = XINT (vp->contents[CCL_HEADER_EOF]); 
     1651      ccl->buf_magnification = XINT (vp->contents[CCL_HEADER_BUF_MAG]); 
     1652    } 
    16121653  ccl->ic = CCL_HEADER_MAIN; 
    1613   ccl->eof_ic = XINT (XVECTOR (vec)->contents[CCL_HEADER_EOF]); 
    1614   ccl->buf_magnification = XINT (XVECTOR (vec)->contents[CCL_HEADER_BUF_MAG]); 
    16151654  for (i = 0; i < 8; i++) 
    16161655    ccl->reg[i] = 0; 
     
    16181657  ccl->private_state = 0; 
    16191658  ccl->status = 0; 
     1659  ccl->stack_idx = 0; 
    16201660} 
    16211661