Создание синхронного процесса

После создания синхронного процесса Emacs ожидает завершения процесса перед продолжением. Пример этого — запуск Dired на GNU или Unix²⁴: он выполняет ls в синхронном процессе, затем немного изменяет вывод. Поскольку процесс синхронный, весь список директорий появляется в буфере до того, как Emacs попытается с ним что-либо сделать.

Пока Emacs ожидает завершения синхронного подпроцесса, пользователь может выйти, нажав C-g. Первый C-g пытается убить подпроцесс с сигналом SIGINT; но он ожидает, пока подпроцесс фактически не завершит работу, прежде чем выйти. Если в это время пользователь нажимает еще один C-g, он убивает подпроцесс мгновенно с сигналом SIGKILL и немедленно выходит (за исключением MS-DOS, где убийство других процессов не работает). См. Выход.

Синхронные подпроцессы возвращают указание о том, как завершился процесс.

Вывод из синхронного подпроцесса обычно декодируется с помощью кодировки, так же, как текст, считываемый из файла. Ввод, отправленный подпроцессу функцией call-process-region, кодируется с помощью кодировки, подобно записи текста в файл. См. Системы кодирования.

Функция: call-process program &optional infile destination display &rest args

Эта функция вызывает program и ожидает его завершения.

Текущая рабочая директория подпроцесса устанавливается в значение текущего буфера default-directory, если оно локальное (как определяется unhandled-file-name-directory), или «~» в противном случае. Если вы хотите запустить процесс в удалённой директории, используйте process-file.

Стандартный ввод для нового процесса берется из файла infile, если infile не nil, и из устройства null в противном случае. Аргумент destination указывает, куда поместить вывод процесса. Вот возможные значения:

буфер

Вставить вывод в этот буфер перед курсором. Это включает в себя как поток стандартного вывода, так и поток стандартной ошибки процесса.

имя буфера (строка)

Вставить вывод в буфер с этим именем перед курсором.

t

Вставить вывод в текущий буфер перед курсором.

nil

Отбросить вывод.

0

Отбросить вывод и немедленно вернуть nil, не дожидаясь завершения подпроцесса.

В этом случае процесс не является истинно синхронным, поскольку он может выполняться параллельно с Emacs; но вы можете рассматривать его как синхронный в том смысле, что Emacs по существу закончил работу с подпроцессом как только эта функция возвращает значение.

MS-DOS не поддерживает асинхронные подпроцессы, поэтому этот вариант там не работает.

(:file file-name)

Отправить вывод в указанный файл, перезаписывая его, если он уже существует.

(real-destination error-destination)

Отделить поток стандартного вывода от потока стандартной ошибки; обработать обычный вывод в соответствии со значением real-destination, и обработать вывод ошибки в соответствии со значением error-destination. Если error-destination равно nil, значит отбросить вывод ошибки, t означает смешать его с обычным выводом, а строка задаёт имя файла, куда перенаправить вывод ошибки.

Вы не можете напрямую указать буфер для вывода ошибки; это слишком сложно для реализации. Но вы можете добиться этого, отправив вывод ошибки в временный файл, а затем вставить файл в буфер, когда подпроцесс завершится.

Если display не nil, то call-process перерисовывает буфер по мере вставки вывода. (Однако, если выбранная система кодирования для декодирования вывода — undecided, означающая вывод кодировки из данных, то перерисовка иногда не может продолжаться после появления символов, отличных от ASCII. Существуют фундаментальные причины, почему это сложно исправить; см. Вывод из процессов.)

В противном случае функция call-process не выполняет перерисовку, и результаты отображаются на экране только тогда, когда Emacs перерисовывает этот буфер в обычном режиме работы.

Остальные аргументы, args, являются строками, которые задают аргументы командной строки для программы. Каждая строка передаётся program как отдельный аргумент.

Возвращаемое значение call-process (если вы не сказали ему не ждать) указывает причину завершения процесса. Число даёт код завершения подпроцесса; 0 означает успех, а любое другое значение означает ошибку. Если процесс завершился с сигналом, call-process возвращает строку, описывающую сигнал. Если вы сказали call-process не ждать, то он возвращает nil.

В примерах ниже, текущим является буфер «foo».

(call-process "pwd" nil t)
     ⇒ 0

---------- Buffer: foo ----------
/home/lewis/manual
---------- Buffer: foo ----------

(call-process "grep" nil "bar" nil "lewis" "/etc/passwd")
     ⇒ 0

---------- Buffer: bar ----------
lewis:x:1001:1001:Bil Lewis,,,,:/home/lewis:/bin/bash

---------- Buffer: bar ----------

Вот пример использования call-process, как он был в определении функции insert-directory:

(call-process insert-directory-program nil t nil switches
              (if full-directory-p
                  (concat (file-name-as-directory file) ".")
                file))

Функция: process-file program &optional infile buffer display &rest args

Эта функция обрабатывает файлы синхронно в отдельном процессе. Она похожа на call-process, но может вызывать обработчик имён файлов, основанный на значении переменной default-directory, которая задаёт текущую рабочую директорию подпроцесса.

Аргументы обрабатываются почти так же, как и для call-process, с следующими отличиями:

Некоторые обработчики имён файлов могут не поддерживать все комбинации и формы аргументов infile, buffer и display. Например, некоторые обработчики могут вести себя так, как будто display было nil, независимо от фактически переданного значения. В качестве другого примера, некоторые обработчики могут не поддерживать разделение стандартного вывода и вывода ошибок с помощью аргумента buffer.

Если вызывается обработчик имён файлов, он определяет программу для запуска на основе первого аргумента program. Например, предположим, что вызывается обработчик для удалённых файлов. Тогда путь, используемый для поиска программы, может отличаться от exec-path.

Второй аргумент infile может вызвать обработчик имён файлов. Обработчик имён файлов может отличаться от обработчика, выбранного для функции process-file само по себе. (Например, default-directory может быть на одном удалённом узле, а infile на другом. Или default-directory может быть не специальным, а infile на удалённом узле.)

Если buffer является списком вида (real-destination error-destination), и error-destination задаёт имя файла, то те же замечания, что и для infile, применяются.

Остальные аргументы (args) будут переданы процессу дословно. Emacs не участвует в обработке имён файлов, которые присутствуют в args. Чтобы избежать путаницы, лучше избегать абсолютных путей в args, а вместо этого указывать все имена файлов относительно default-directory. Функция file-relative-name полезна для построения таких относительных имён файлов. В качестве альтернативы, вы можете использовать file-local-name (см. Магические имена файлов) для получения абсолютного имени файла с точки зрения удалённого узла.

Переменная: process-file-side-effects

Эта переменная указывает, изменяет ли вызов process-file удалённые файлы.

По умолчанию эта переменная всегда установлена в t, что означает, что вызов process-file потенциально может изменить любой файл на удалённом узле. При установке в nil, обработчик имён файлов может оптимизировать своё поведение относительно кеширования атрибутов удалённых файлов.

Вы должны изменять эту переменную только с помощью let-связывания; никогда с setq.

Пользовательский параметр: process-file-return-signal-string

Этот пользовательский параметр указывает, возвращает ли вызов process-file строку, описывающую сигнал, прерывающий удалённый процесс.

Когда процесс возвращает код выхода больше 128, он интерпретируется как сигнал. process-file требует возврата строки, описывающей этот сигнал.

Поскольку существуют процессы, нарушающие это правило, возвращающие коды выхода больше 128, которые не привязаны к сигналу, process-file всегда возвращает код выхода как целое число для удалённых процессов. Установка этого пользовательского параметра в значение, отличное от nil, принуждает process-file интерпретировать такие коды выхода как сигналы и возвращать соответствующую строку.

Функция: call-process-region start end program &optional delete destination display &rest args

Эта функция отправляет текст с start по end как стандартный ввод процессу, выполняющему program. Он удаляет отправленный текст, если delete не nil; это полезно, когда destination равно t, для вставки вывода в текущий буфер вместо ввода.

Аргументы destination и display управляют обработкой вывода подпроцесса и обновлением отображения по мере его поступления. Для получения подробностей см. описание call-process, выше. Если destination равно целому числу 0, call-process-region отбрасывает вывод и немедленно возвращает nil, не дожидаясь завершения подпроцесса (это работает только если поддерживаются асинхронные подпроцессы; т.е. не на MS-DOS).

Остальные аргументы, args, являются строками, которые задают аргументы командной строки для программы.

Возвращаемое значение call-process-region аналогично значению call-process: nil, если вы сказали ему вернуть значение без ожидания; в противном случае, число или строка, указывающие, как завершился подпроцесс.

В следующем примере мы используем call-process-region для запуска утилиты cat, со стандартным вводом, являющимся первыми пятью символами в буфере «foo» (слово «input»). cat копирует свой стандартный ввод в свой стандартный вывод. Поскольку аргумент destination равен t, этот вывод вставляется в текущий буфер.

---------- Buffer: foo ----------
input∗
---------- Buffer: foo ----------

(call-process-region 1 6 "cat" nil t)
     ⇒ 0

---------- Buffer: foo ----------
inputinput∗
---------- Buffer: foo ----------

Например, команда shell-command-on-region использует call-shell-region аналогичным образом:

(call-shell-region
 start end
 command              ; shell command
 nil                  ; do not delete region
 buffer)              ; send output to buffer

Функция: call-process-shell-command command &optional infile destination display

Эта функция синхронно выполняет командную строку command. Другие аргументы обрабатываются так же, как в call-process. Старая соглашение вызова позволяла передавать любое количество дополнительных аргументов после display, которые конкатенировались с command; это всё ещё поддерживается, но настоятельно не рекомендуется.

Функция: process-file-shell-command command &optional infile destination display

Эта функция похожа на call-process-shell-command, но использует process-file внутри. В зависимости от default-directory, command может быть выполнен и на удалённых хостах. Старая схема вызова позволяла передавать любое количество дополнительных аргументов после display, которые конкатенировались с command; эта возможность всё ещё поддерживается, но настоятельно не рекомендуется.

Функция: call-shell-region start end command &optional delete destination

Эта функция отправляет текст с start до end как стандартный ввод в подчиненную оболочку, выполняющую command. Эта функция похожа на call-process-region, где процесс — оболочка. Аргументы delete, destination и значение возврата аналогичны call-process-region. Обратите внимание, что эта функция не принимает дополнительные аргументы.

Функция: shell-command-to-string command

Эта функция выполняет command (строка) как команду оболочки и затем возвращает вывод команды как строку.

Функция: process-lines program &rest args

Эта функция запускает program, ждёт его завершения и возвращает вывод в виде списка строк. Каждая строка в списке содержит одну строку вывода программы; символы конца строки удаляются из каждой строки. Аргументы после program, args, — это строки, задающие аргументы командной строки для запуска программы.

Если program завершается с ненулевым кодом выхода, эта функция сигнализирует об ошибке.

Эта функция работает, вызывая call-process, поэтому вывод программы декодируется так же, как и для call-process.

Функция: process-lines-ignore-status program &rest args

Эта функция аналогична process-lines, но не сигнализирует об ошибке, если program завершается с ненулевым кодом выхода.