/[emacs]/emacs/src/callproc.c
ViewVC logotype

Diff of /emacs/src/callproc.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.181 by rms, Fri Dec 7 06:45:39 2001 UTC revision 1.181.2.1 by handa, Fri Mar 1 01:11:12 2002 UTC
# Line 75  extern int errno; Line 75  extern int errno;
75  #include "lisp.h"  #include "lisp.h"
76  #include "commands.h"  #include "commands.h"
77  #include "buffer.h"  #include "buffer.h"
78  #include "charset.h"  #include "character.h"
79  #include "ccl.h"  #include "ccl.h"
80  #include "coding.h"  #include "coding.h"
81  #include "composite.h"  #include "composite.h"
# Line 401  usage: (call-process PROGRAM &optional I Line 401  usage: (call-process PROGRAM &optional I
401          {          {
402            argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);            argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);
403            if (CODING_REQUIRE_ENCODING (&argument_coding))            if (CODING_REQUIRE_ENCODING (&argument_coding))
404              {              /* We must encode this argument.  */
405                /* We must encode this argument.  */              args[i] = encode_coding_string (&argument_coding, args[i], 1);
               args[i] = encode_coding_string (args[i], &argument_coding, 1);  
               if (argument_coding.type == coding_type_ccl)  
                 setup_ccl_program (&(argument_coding.spec.ccl.encoder), Qnil);  
             }  
406            new_argv[i - 3] = XSTRING (args[i])->data;            new_argv[i - 3] = XSTRING (args[i])->data;
407          }          }
408        UNGCPRO;        UNGCPRO;
# Line 714  usage: (call-process PROGRAM &optional I Line 710  usage: (call-process PROGRAM &optional I
710            else            else
711              val = Qnil;              val = Qnil;
712          }          }
713        setup_coding_system (Fcheck_coding_system (val), &process_coding);        Fcheck_coding_system (val);
714        /* In unibyte mode, character code conversion should not take        /* In unibyte mode, character code conversion should not take
715           place but EOL conversion should.  So, setup raw-text or one           place but EOL conversion should.  So, setup raw-text or one
716           of the subsidiary according to the information just setup.  */           of the subsidiary according to the information just setup.  */
717        if (NILP (current_buffer->enable_multibyte_characters)        if (NILP (current_buffer->enable_multibyte_characters)
718            && !NILP (val))            && !NILP (val))
719          setup_raw_text_coding_system (&process_coding);          val = raw_text_coding_system (val);
720          setup_coding_system (val, &process_coding);
721      }      }
   process_coding.src_multibyte = 0;  
   process_coding.dst_multibyte  
     = (BUFFERP (buffer)  
        ? ! NILP (XBUFFER (buffer)->enable_multibyte_characters)  
        : ! NILP (current_buffer->enable_multibyte_characters));  
722    
723    immediate_quit = 1;    immediate_quit = 1;
724    QUIT;    QUIT;
# Line 742  usage: (call-process PROGRAM &optional I Line 734  usage: (call-process PROGRAM &optional I
734      int inserted;      int inserted;
735    
736      saved_coding = process_coding;      saved_coding = process_coding;
     if (process_coding.composing != COMPOSITION_DISABLED)  
       coding_allocate_composition_data (&process_coding, PT);  
737      while (1)      while (1)
738        {        {
739          /* Repeatedly read until we've filled as much as possible          /* Repeatedly read until we've filled as much as possible
# Line 780  usage: (call-process PROGRAM &optional I Line 770  usage: (call-process PROGRAM &optional I
770                insert_1_both (bufptr, nread, nread, 0, 1, 0);                insert_1_both (bufptr, nread, nread, 0, 1, 0);
771              else              else
772                {                 /* We have to decode the input.  */                {                 /* We have to decode the input.  */
773                  int size;                  decode_coding_c_string (&process_coding, bufptr, nread,
774                  char *decoding_buf;                                          buffer);
   
               repeat_decoding:  
                 size = decoding_buffer_size (&process_coding, nread);  
                 decoding_buf = (char *) xmalloc (size);  
                   
                 if (process_coding.cmp_data)  
                   process_coding.cmp_data->char_offset = PT;  
                   
                 decode_coding (&process_coding, bufptr, decoding_buf,  
                                nread, size);  
                   
775                  if (display_on_the_fly                  if (display_on_the_fly
776                      && saved_coding.type == coding_type_undecided                      && CODING_REQUIRE_DETECTION (&saved_coding)
777                      && process_coding.type != coding_type_undecided)                      && ! CODING_REQUIRE_DETECTION (&process_coding))
778                    {                    {
779                      /* We have detected some coding system.  But,                      /* We have detected some coding system.  But,
780                         there's a possibility that the detection was                         there's a possibility that the detection was
781                         done by insufficient data.  So, we give up                         done by insufficient data.  So, we give up
782                         displaying on the fly.  */                         displaying on the fly.  */
783                      xfree (decoding_buf);                      if (process_coding.produced > 0)
784                          del_range_2 (process_coding.dst_pos,
785                                       process_coding.dst_pos_byte,
786                                       process_coding.dst_pos
787                                       + process_coding.produced_char,
788                                       process_coding.dst_pos_byte
789                                       + process_coding.produced, 0);
790                      display_on_the_fly = 0;                      display_on_the_fly = 0;
791                      process_coding = saved_coding;                      process_coding = saved_coding;
792                      carryover = nread;                      carryover = nread;
793                      continue;                      continue;
794                    }                    }
795                                    
                 if (process_coding.produced > 0)  
                   insert_1_both (decoding_buf, process_coding.produced_char,  
                                  process_coding.produced, 0, 1, 0);  
                 xfree (decoding_buf);  
   
                 if (process_coding.result == CODING_FINISH_INCONSISTENT_EOL)  
                   {  
                     Lisp_Object eol_type, coding;  
   
                     if (process_coding.eol_type == CODING_EOL_CR)  
                       {  
                         /* CRs have been replaced with LFs.  Undo  
                            that in the text inserted above.  */  
                         unsigned char *p;  
                           
                         move_gap_both (PT, PT_BYTE);  
                           
                         p = BYTE_POS_ADDR (pt_byte_orig);  
                         for (; p < GPT_ADDR; ++p)  
                           if (*p == '\n')  
                             *p = '\r';  
                       }  
                     else if (process_coding.eol_type == CODING_EOL_CRLF)  
                       {  
                         /* CR LFs have been replaced with LFs.  Undo  
                            that by inserting CRs in front of LFs in  
                            the text inserted above.  */  
                         EMACS_INT bytepos, old_pt, old_pt_byte, nCR;  
   
                         old_pt = PT;  
                         old_pt_byte = PT_BYTE;  
                         nCR = 0;  
                           
                         for (bytepos = PT_BYTE - 1;  
                              bytepos >= pt_byte_orig;  
                              --bytepos)  
                           if (FETCH_BYTE (bytepos) == '\n')  
                             {  
                               EMACS_INT charpos = BYTE_TO_CHAR (bytepos);  
                               TEMP_SET_PT_BOTH (charpos, bytepos);  
                               insert_1_both ("\r", 1, 1, 0, 1, 0);  
                               ++nCR;  
                             }  
   
                         TEMP_SET_PT_BOTH (old_pt + nCR, old_pt_byte + nCR);  
                       }  
   
                     /* Set the coding system symbol to that for  
                        Unix-like EOL.  */  
                     eol_type = Fget (saved_coding.symbol, Qeol_type);  
                     if (VECTORP (eol_type)  
                         && ASIZE (eol_type) == 3  
                         && SYMBOLP (AREF (eol_type, CODING_EOL_LF)))  
                       coding = AREF (eol_type, CODING_EOL_LF);  
                     else  
                       coding = saved_coding.symbol;  
                       
                     process_coding.symbol = coding;  
                     process_coding.eol_type = CODING_EOL_LF;  
                     process_coding.mode  
                       &= ~CODING_MODE_INHIBIT_INCONSISTENT_EOL;  
                   }  
                   
796                  nread -= process_coding.consumed;                  nread -= process_coding.consumed;
797                  carryover = nread;                  carryover = nread;
798                  if (carryover > 0)                  if (carryover > 0)
# Line 878  usage: (call-process PROGRAM &optional I Line 800  usage: (call-process PROGRAM &optional I
800                       better avoid overhead of bcopy.  */                       better avoid overhead of bcopy.  */
801                    BCOPY_SHORT (bufptr + process_coding.consumed, bufptr,                    BCOPY_SHORT (bufptr + process_coding.consumed, bufptr,
802                                 carryover);                                 carryover);
                 if (process_coding.result == CODING_FINISH_INSUFFICIENT_CMP)  
                   {  
                     /* The decoding ended because of insufficient data  
                        area to record information about composition.  
                        We must try decoding with additional data area  
                        before reading more output for the process.  */  
                     coding_allocate_composition_data (&process_coding, PT);  
                     goto repeat_decoding;  
                   }  
803                }                }
804            }            }
805    
# Line 917  usage: (call-process PROGRAM &optional I Line 830  usage: (call-process PROGRAM &optional I
830        }        }
831    give_up: ;    give_up: ;
832    
833      if (!NILP (buffer)      Vlast_coding_system_used = CODING_ID_NAME (process_coding.id);
834          && process_coding.cmp_data)      /* If the caller required, let the buffer inherit the
835        {         coding-system used to decode the process output.  */
836          coding_restore_composition (&process_coding, Fcurrent_buffer ());      if (inherit_process_coding_system)
837          coding_free_composition_data (&process_coding);        call1 (intern ("after-insert-file-set-buffer-file-coding-system"),
       }  
   
     {  
       int post_read_count = specpdl_ptr - specpdl;  
   
       record_unwind_protect (save_excursion_restore, save_excursion_save ());  
       inserted = PT - pt_orig;  
       TEMP_SET_PT_BOTH (pt_orig, pt_byte_orig);  
       if (SYMBOLP (process_coding.post_read_conversion)  
           && !NILP (Ffboundp (process_coding.post_read_conversion)))  
         call1 (process_coding.post_read_conversion, make_number (inserted));  
   
       Vlast_coding_system_used = process_coding.symbol;  
   
       /* If the caller required, let the buffer inherit the  
          coding-system used to decode the process output.  */  
       if (inherit_process_coding_system)  
         call1 (intern ("after-insert-file-set-buffer-file-coding-system"),  
838                 make_number (total_read));                 make_number (total_read));
   
       unbind_to (post_read_count, Qnil);  
     }  
839    }    }
840    
841    /* Wait for it to terminate, unless it already has.  */    /* Wait for it to terminate, unless it already has.  */

Legend:
Removed from v.1.181  
changed lines
  Added in v.1.181.2.1

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26