(USE_XIM): New define.

[bpt/emacs.git] / src / bytecode.c

diff --git a/src/bytecode.c b/src/bytecode.c
index 06f644e..22c4192 100644 (file)
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1,5 +1,5 @@
 /* Execution of byte code produced by bytecomp.el.
-   Copyright (C) 1985, 1986, 1987, 1988, 1993 Free Software Foundation, Inc.
+   Copyright (C) 1985, 1986, 1987, 1988, 1993, 2000 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -401,12 +401,12 @@ If the third argument is incorrect, Emacs may crash.")
 #endif
   int op;
   /* Lisp_Object v1, v2; */
-  Lisp_Object *vectorp = XVECTOR (vector)->contents;
+  Lisp_Object *vectorp;
 #ifdef BYTE_CODE_SAFE
   int const_length = XVECTOR (vector)->size;
   Lisp_Object *stacke;
 #endif
-  int bytestr_length = STRING_BYTES (XSTRING (bytestr));
+  int bytestr_length;
   struct byte_stack stack;
   Lisp_Object *top;
   Lisp_Object result;
@@ -416,6 +416,17 @@ If the third argument is incorrect, Emacs may crash.")
     vector = wrong_type_argument (Qvectorp, vector);
   CHECK_NUMBER (maxdepth, 2);
 
+  if (STRING_MULTIBYTE (bytestr))
+    /* BYTESTR must have been produced by Emacs 20.2 or the earlier
+       because they produced a raw 8-bit string for byte-code and now
+       such a byte-code string is loaded as multibyte while raw 8-bit
+       characters converted to multibyte form.  Thus, now we must
+       convert them back to the original unibyte form.  */
+    bytestr = Fstring_as_unibyte (bytestr);
+
+  bytestr_length = STRING_BYTES (XSTRING (bytestr));
+  vectorp = XVECTOR (vector)->contents;
+
   stack.byte_string = bytestr;
   stack.pc = stack.byte_string_start = XSTRING (bytestr)->data;
   stack.constants = vector;
@@ -475,10 +486,18 @@ If the third argument is incorrect, Emacs may crash.")
              {
                v2 = XSYMBOL (v1)->value;
                if (MISCP (v2) || EQ (v2, Qunbound))
-                 v2 = Fsymbol_value (v1);
+                 {
+                   BEFORE_POTENTIAL_GC ();
+                   v2 = Fsymbol_value (v1);
+                   AFTER_POTENTIAL_GC ();
+                 }
              }
            else
-             v2 = Fsymbol_value (v1);
+             {
+               BEFORE_POTENTIAL_GC ();
+               v2 = Fsymbol_value (v1);
+               AFTER_POTENTIAL_GC ();
+             }
            PUSH (v2);
            break;
          }
@@ -522,8 +541,10 @@ If the third argument is incorrect, Emacs may crash.")
        case Bmemq:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fmemq (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
@@ -562,10 +583,9 @@ If the third argument is incorrect, Emacs may crash.")
        varset:
          {
            Lisp_Object sym, val;
-           extern int keyword_symbols_constant_flag;
              
            sym = vectorp[op];
-           val = POP;
+           val = TOP;
 
            /* Inline the most common case.  */
            if (SYMBOLP (sym)
@@ -579,12 +599,16 @@ If the third argument is incorrect, Emacs may crash.")
                && !EQ (sym, Qt)
                && !(XSYMBOL (sym)->name->data[0] == ':'
                     && EQ (XSYMBOL (sym)->obarray, initial_obarray)
-                    && keyword_symbols_constant_flag
                     && !EQ (val, sym)))
              XSYMBOL (sym)->value = val;
            else
-             set_internal (sym, val, current_buffer, 0);
+             {
+               BEFORE_POTENTIAL_GC ();
+               set_internal (sym, val, current_buffer, 0);
+               AFTER_POTENTIAL_GC ();
+             }
          }
+         POP;
          break;
 
        case Bdup:
@@ -811,8 +835,8 @@ If the third argument is incorrect, Emacs may crash.")
        case Bcatch:
          {
            Lisp_Object v1;
-           v1 = POP;
            BEFORE_POTENTIAL_GC ();
+           v1 = POP;
            TOP = internal_catch (TOP, Feval, v1);
            AFTER_POTENTIAL_GC ();
            break;
@@ -844,8 +868,8 @@ If the third argument is incorrect, Emacs may crash.")
        case Btemp_output_buffer_show:
          {
            Lisp_Object v1;
-           v1 = POP;
            BEFORE_POTENTIAL_GC ();
+           v1 = POP;
            temp_output_buffer_show (TOP);
            TOP = v1;
            /* pop binding of standard-output */
@@ -857,9 +881,9 @@ If the third argument is incorrect, Emacs may crash.")
        case Bnth:
          {
            Lisp_Object v1, v2;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            v2 = TOP;
-           BEFORE_POTENTIAL_GC ();
            CHECK_NUMBER (v2, 0);
            AFTER_POTENTIAL_GC ();
            op = XINT (v2);
@@ -949,86 +973,110 @@ If the third argument is incorrect, Emacs may crash.")
          break;
 
        case Blength:
+         BEFORE_POTENTIAL_GC ();
          TOP = Flength (TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Baref:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Faref (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Baset:
          {
            Lisp_Object v1, v2;
+           BEFORE_POTENTIAL_GC ();
            v2 = POP; v1 = POP;
            TOP = Faset (TOP, v1, v2);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bsymbol_value:
+         BEFORE_POTENTIAL_GC ();
          TOP = Fsymbol_value (TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bsymbol_function:
+         BEFORE_POTENTIAL_GC ();
          TOP = Fsymbol_function (TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bset:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fset (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bfset:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Ffset (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bget:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fget (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bsubstring:
          {
            Lisp_Object v1, v2;
-           v2 = POP; v1 = POP;
            BEFORE_POTENTIAL_GC ();
+           v2 = POP; v1 = POP;
            TOP = Fsubstring (TOP, v1, v2);
            AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bconcat2:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (1);
          TOP = Fconcat (2, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bconcat3:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (2);
          TOP = Fconcat (3, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bconcat4:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (3);
          TOP = Fconcat (4, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case BconcatN:
          op = FETCH;
+         BEFORE_POTENTIAL_GC ();
          DISCARD (op - 1);
          TOP = Fconcat (op, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bsub1:
@@ -1055,15 +1103,19 @@ If the third argument is incorrect, Emacs may crash.")
                TOP = v1;
              }
            else
-             TOP = Fadd1 (v1);
+             {
+               BEFORE_POTENTIAL_GC ();
+               TOP = Fadd1 (v1);
+               AFTER_POTENTIAL_GC ();
+             }
            break;
          }
 
        case Beqlsign:
          {
            Lisp_Object v1, v2;
-           v2 = POP; v1 = TOP;
            BEFORE_POTENTIAL_GC ();
+           v2 = POP; v1 = TOP;
            CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v1, 0);
            CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (v2, 0);
            AFTER_POTENTIAL_GC ();
@@ -1083,24 +1135,30 @@ If the third argument is incorrect, Emacs may crash.")
        case Bgtr:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fgtr (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Blss:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Flss (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bleq:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fleq (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
@@ -1113,8 +1171,10 @@ If the third argument is incorrect, Emacs may crash.")
          }
 
        case Bdiff:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (1);
          TOP = Fminus (2, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bnegate:
@@ -1127,40 +1187,56 @@ If the third argument is incorrect, Emacs may crash.")
                TOP = v1;
              }
            else
-             TOP = Fminus (1, &TOP);
+             {
+               BEFORE_POTENTIAL_GC ();
+               TOP = Fminus (1, &TOP);
+               AFTER_POTENTIAL_GC ();
+             }
            break;
          }
 
        case Bplus:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (1);
          TOP = Fplus (2, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bmax:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (1);
          TOP = Fmax (2, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bmin:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (1);
          TOP = Fmin (2, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bmult:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (1);
          TOP = Ftimes (2, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bquo:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (1);
          TOP = Fquo (2, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Brem:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Frem (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
@@ -1209,13 +1285,17 @@ If the third argument is incorrect, Emacs may crash.")
          }
 
        case Bchar_after:
+         BEFORE_POTENTIAL_GC ();
          TOP = Fchar_after (TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bfollowing_char:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = Ffollowing_char ();
+           AFTER_POTENTIAL_GC ();
            PUSH (v1);
            break;
          }
@@ -1223,7 +1303,9 @@ If the third argument is incorrect, Emacs may crash.")
        case Bpreceding_char:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = Fprevious_char ();
+           AFTER_POTENTIAL_GC ();
            PUSH (v1);
            break;
          }
@@ -1287,8 +1369,8 @@ If the third argument is incorrect, Emacs may crash.")
        case Bskip_chars_forward:
          {
            Lisp_Object v1;
-           v1 = POP;
            BEFORE_POTENTIAL_GC ();
+           v1 = POP;
            TOP = Fskip_chars_forward (TOP, v1);
            AFTER_POTENTIAL_GC ();
            break;
@@ -1297,8 +1379,8 @@ If the third argument is incorrect, Emacs may crash.")
        case Bskip_chars_backward:
          {
            Lisp_Object v1;
-           v1 = POP;
            BEFORE_POTENTIAL_GC ();
+           v1 = POP;
            TOP = Fskip_chars_backward (TOP, v1);
            AFTER_POTENTIAL_GC ();
            break;
@@ -1320,8 +1402,8 @@ If the third argument is incorrect, Emacs may crash.")
        case Bbuffer_substring:
          {
            Lisp_Object v1;
-           v1 = POP;
            BEFORE_POTENTIAL_GC ();
+           v1 = POP;
            TOP = Fbuffer_substring (TOP, v1);
            AFTER_POTENTIAL_GC ();
            break;
@@ -1330,8 +1412,8 @@ If the third argument is incorrect, Emacs may crash.")
        case Bdelete_region:
          {
            Lisp_Object v1;
-           v1 = POP;
            BEFORE_POTENTIAL_GC ();
+           v1 = POP;
            TOP = Fdelete_region (TOP, v1);
            AFTER_POTENTIAL_GC ();
            break;
@@ -1340,8 +1422,8 @@ If the third argument is incorrect, Emacs may crash.")
        case Bnarrow_to_region:
          {
            Lisp_Object v1;
-           v1 = POP;
            BEFORE_POTENTIAL_GC ();
+           v1 = POP;
            TOP = Fnarrow_to_region (TOP, v1);
            AFTER_POTENTIAL_GC ();
            break;
@@ -1362,41 +1444,55 @@ If the third argument is incorrect, Emacs may crash.")
        case Bset_marker:
          {
            Lisp_Object v1, v2;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            v2 = POP;
            TOP = Fset_marker (TOP, v2, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bmatch_beginning:
+         BEFORE_POTENTIAL_GC ();
          TOP = Fmatch_beginning (TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bmatch_end:
+         BEFORE_POTENTIAL_GC ();
          TOP = Fmatch_end (TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bupcase:
+         BEFORE_POTENTIAL_GC ();
          TOP = Fupcase (TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bdowncase:
+         BEFORE_POTENTIAL_GC ();
          TOP = Fdowncase (TOP);
+         AFTER_POTENTIAL_GC ();
        break;
 
        case Bstringeqlsign:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fstring_equal (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bstringlss:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fstring_lessp (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
@@ -1411,8 +1507,10 @@ If the third argument is incorrect, Emacs may crash.")
        case Bnthcdr:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fnthcdr (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
@@ -1422,9 +1520,9 @@ If the third argument is incorrect, Emacs may crash.")
            if (CONSP (TOP))
              {
                /* Exchange args and then do nth.  */
+               BEFORE_POTENTIAL_GC ();
                v2 = POP;
                v1 = TOP;
-               BEFORE_POTENTIAL_GC ();
                CHECK_NUMBER (v2, 0);
                AFTER_POTENTIAL_GC ();
                op = XINT (v2);
@@ -1457,8 +1555,10 @@ If the third argument is incorrect, Emacs may crash.")
              }
            else
              {
+               BEFORE_POTENTIAL_GC ();
                v1 = POP;
                TOP = Felt (TOP, v1);
+               AFTER_POTENTIAL_GC ();
              }
            break;
          }
@@ -1466,36 +1566,46 @@ If the third argument is incorrect, Emacs may crash.")
        case Bmember:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fmember (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bassq:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fassq (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bnreverse:
+         BEFORE_POTENTIAL_GC ();
          TOP = Fnreverse (TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bsetcar:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fsetcar (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
        case Bsetcdr:
          {
            Lisp_Object v1;
+           BEFORE_POTENTIAL_GC ();
            v1 = POP;
            TOP = Fsetcdr (TOP, v1);
+           AFTER_POTENTIAL_GC ();
            break;
          }
 
@@ -1522,8 +1632,10 @@ If the third argument is incorrect, Emacs may crash.")
          }
 
        case Bnconc:
+         BEFORE_POTENTIAL_GC ();
          DISCARD (1);
          TOP = Fnconc (2, &TOP);
+         AFTER_POTENTIAL_GC ();
          break;
 
        case Bnumberp: