PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/readline - readline.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 125 205 61.0 %
Date: 2015-04-14 Functions: 13 21 61.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2015 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Author: Thies C. Arntzen <thies@thieso.net>                          |
      16             :    +----------------------------------------------------------------------+
      17             : */
      18             : 
      19             : /* $Id$ */
      20             : 
      21             : /* {{{ includes & prototypes */
      22             : 
      23             : #ifdef HAVE_CONFIG_H
      24             : #include "config.h"
      25             : #endif
      26             : 
      27             : #include "php.h"
      28             : #include "php_readline.h"
      29             : #include "readline_cli.h"
      30             : 
      31             : #if HAVE_LIBREADLINE || HAVE_LIBEDIT
      32             : 
      33             : #ifndef HAVE_RL_COMPLETION_MATCHES
      34             : #define rl_completion_matches completion_matches
      35             : #endif
      36             : 
      37             : #ifdef HAVE_LIBEDIT
      38             : #include <editline/readline.h>
      39             : #else
      40             : #include <readline/readline.h>
      41             : #include <readline/history.h>
      42             : #endif
      43             : 
      44             : PHP_FUNCTION(readline);
      45             : PHP_FUNCTION(readline_add_history);
      46             : PHP_FUNCTION(readline_info);
      47             : PHP_FUNCTION(readline_clear_history);
      48             : #ifndef HAVE_LIBEDIT
      49             : PHP_FUNCTION(readline_list_history);
      50             : #endif
      51             : PHP_FUNCTION(readline_read_history);
      52             : PHP_FUNCTION(readline_write_history);
      53             : PHP_FUNCTION(readline_completion_function);
      54             : 
      55             : #if HAVE_RL_CALLBACK_READ_CHAR
      56             : PHP_FUNCTION(readline_callback_handler_install);
      57             : PHP_FUNCTION(readline_callback_read_char);
      58             : PHP_FUNCTION(readline_callback_handler_remove);
      59             : PHP_FUNCTION(readline_redisplay);
      60             : PHP_FUNCTION(readline_on_new_line);
      61             : 
      62             : static zval _prepped_callback;
      63             : 
      64             : #endif
      65             : 
      66             : static zval _readline_completion;
      67             : static zval _readline_array;
      68             : 
      69             : PHP_MINIT_FUNCTION(readline);
      70             : PHP_MSHUTDOWN_FUNCTION(readline);
      71             : PHP_RSHUTDOWN_FUNCTION(readline);
      72             : PHP_MINFO_FUNCTION(readline);
      73             : 
      74             : /* }}} */
      75             : 
      76             : /* {{{ arginfo */
      77             : ZEND_BEGIN_ARG_INFO_EX(arginfo_readline, 0, 0, 0)
      78             :         ZEND_ARG_INFO(0, prompt)
      79             : ZEND_END_ARG_INFO()
      80             : 
      81             : ZEND_BEGIN_ARG_INFO_EX(arginfo_readline_info, 0, 0, 0)
      82             :         ZEND_ARG_INFO(0, varname)
      83             :         ZEND_ARG_INFO(0, newvalue)
      84             : ZEND_END_ARG_INFO()
      85             : 
      86             : ZEND_BEGIN_ARG_INFO_EX(arginfo_readline_add_history, 0, 0, 1)
      87             :         ZEND_ARG_INFO(0, prompt)
      88             : ZEND_END_ARG_INFO()
      89             : 
      90             : ZEND_BEGIN_ARG_INFO(arginfo_readline_clear_history, 0)
      91             : ZEND_END_ARG_INFO()
      92             : 
      93             : #ifndef HAVE_LIBEDIT
      94             : ZEND_BEGIN_ARG_INFO(arginfo_readline_list_history, 0)
      95             : ZEND_END_ARG_INFO()
      96             : #endif
      97             : 
      98             : ZEND_BEGIN_ARG_INFO_EX(arginfo_readline_read_history, 0, 0, 0)
      99             :         ZEND_ARG_INFO(0, filename)
     100             : ZEND_END_ARG_INFO()
     101             : 
     102             : ZEND_BEGIN_ARG_INFO_EX(arginfo_readline_write_history, 0, 0, 0)
     103             :         ZEND_ARG_INFO(0, filename)
     104             : ZEND_END_ARG_INFO()
     105             : 
     106             : ZEND_BEGIN_ARG_INFO_EX(arginfo_readline_completion_function, 0, 0, 1)
     107             :         ZEND_ARG_INFO(0, funcname)
     108             : ZEND_END_ARG_INFO()
     109             : 
     110             : #if HAVE_RL_CALLBACK_READ_CHAR
     111             : ZEND_BEGIN_ARG_INFO_EX(arginfo_readline_callback_handler_install, 0, 0, 2)
     112             :         ZEND_ARG_INFO(0, prompt)
     113             :         ZEND_ARG_INFO(0, callback)
     114             : ZEND_END_ARG_INFO()
     115             : 
     116             : ZEND_BEGIN_ARG_INFO(arginfo_readline_callback_read_char, 0)
     117             : ZEND_END_ARG_INFO()
     118             : 
     119             : ZEND_BEGIN_ARG_INFO(arginfo_readline_callback_handler_remove, 0)
     120             : ZEND_END_ARG_INFO()
     121             : 
     122             : ZEND_BEGIN_ARG_INFO(arginfo_readline_redisplay, 0)
     123             : ZEND_END_ARG_INFO()
     124             : 
     125             : ZEND_BEGIN_ARG_INFO(arginfo_readline_on_new_line, 0)
     126             : ZEND_END_ARG_INFO()
     127             : #endif
     128             : /* }}} */
     129             : 
     130             : /* {{{ module stuff */
     131             : static const zend_function_entry php_readline_functions[] = {
     132             :         PHP_FE(readline,                                arginfo_readline)
     133             :         PHP_FE(readline_info,               arginfo_readline_info)
     134             :         PHP_FE(readline_add_history,            arginfo_readline_add_history)
     135             :         PHP_FE(readline_clear_history,          arginfo_readline_clear_history)
     136             : #ifndef HAVE_LIBEDIT
     137             :         PHP_FE(readline_list_history,           arginfo_readline_list_history)
     138             : #endif
     139             :         PHP_FE(readline_read_history,           arginfo_readline_read_history)
     140             :         PHP_FE(readline_write_history,          arginfo_readline_write_history)
     141             :         PHP_FE(readline_completion_function,arginfo_readline_completion_function)
     142             : #if HAVE_RL_CALLBACK_READ_CHAR
     143             :         PHP_FE(readline_callback_handler_install, arginfo_readline_callback_handler_install)
     144             :         PHP_FE(readline_callback_read_char,                     arginfo_readline_callback_read_char)
     145             :         PHP_FE(readline_callback_handler_remove,        arginfo_readline_callback_handler_remove)
     146             :         PHP_FE(readline_redisplay, arginfo_readline_redisplay)
     147             : #endif
     148             : #if HAVE_RL_ON_NEW_LINE
     149             :         PHP_FE(readline_on_new_line, arginfo_readline_on_new_line)
     150             : #endif
     151             :         PHP_FE_END
     152             : };
     153             : 
     154             : zend_module_entry readline_module_entry = {
     155             :         STANDARD_MODULE_HEADER,
     156             :         "readline",
     157             :         php_readline_functions,
     158             :         PHP_MINIT(readline),
     159             :         PHP_MSHUTDOWN(readline),
     160             :         NULL,
     161             :         PHP_RSHUTDOWN(readline),
     162             :         PHP_MINFO(readline),
     163             :         PHP_VERSION,
     164             :         STANDARD_MODULE_PROPERTIES
     165             : };
     166             : 
     167             : #ifdef COMPILE_DL_READLINE
     168             : ZEND_GET_MODULE(readline)
     169             : #endif
     170             : 
     171       20871 : PHP_MINIT_FUNCTION(readline)
     172             : {
     173             : #if HAVE_LIBREADLINE
     174             :                 /* libedit don't need this call which set the tty in cooked mode */
     175       20871 :         using_history();
     176             : #endif
     177       20871 :         ZVAL_UNDEF(&_readline_completion);
     178             : #if HAVE_RL_CALLBACK_READ_CHAR
     179       20871 :         ZVAL_UNDEF(&_prepped_callback);
     180             : #endif
     181       20871 :         return PHP_MINIT(cli_readline)(INIT_FUNC_ARGS_PASSTHRU);
     182             : }
     183             : 
     184       20905 : PHP_MSHUTDOWN_FUNCTION(readline)
     185             : {
     186       20905 :         return PHP_MSHUTDOWN(cli_readline)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
     187             : }
     188             : 
     189       20864 : PHP_RSHUTDOWN_FUNCTION(readline)
     190             : {
     191             :         zval_dtor(&_readline_completion);
     192       20864 :         ZVAL_UNDEF(&_readline_completion);
     193             : #if HAVE_RL_CALLBACK_READ_CHAR
     194       20864 :         if (Z_TYPE(_prepped_callback) != IS_UNDEF) {
     195           1 :                 rl_callback_handler_remove();
     196           1 :                 zval_ptr_dtor(&_prepped_callback);
     197           1 :                 ZVAL_UNDEF(&_prepped_callback);
     198             :         }
     199             : #endif
     200             : 
     201       20864 :         return SUCCESS;
     202             : }
     203             : 
     204         145 : PHP_MINFO_FUNCTION(readline)
     205             : {
     206         145 :         PHP_MINFO(cli_readline)(ZEND_MODULE_INFO_FUNC_ARGS_PASSTHRU);
     207         145 : }
     208             : 
     209             : /* }}} */
     210             : 
     211             : /* {{{ proto string readline([string prompt])
     212             :    Reads a line */
     213           0 : PHP_FUNCTION(readline)
     214             : {
     215           0 :         char *prompt = NULL;
     216             :         size_t prompt_len;
     217             :         char *result;
     218             : 
     219           0 :         if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "|s!", &prompt, &prompt_len)) {
     220           0 :                 RETURN_FALSE;
     221             :         }
     222             : 
     223           0 :         result = readline(prompt);
     224             : 
     225           0 :         if (! result) {
     226           0 :                 RETURN_FALSE;
     227             :         } else {
     228           0 :                 RETVAL_STRING(result);
     229           0 :                 free(result);
     230             :         }
     231             : }
     232             : 
     233             : /* }}} */
     234             : 
     235             : #define SAFE_STRING(s) ((s)?(char*)(s):"")
     236             : 
     237             : /* {{{ proto mixed readline_info([string varname [, string newvalue]])
     238             :    Gets/sets various internal readline variables. */
     239          11 : PHP_FUNCTION(readline_info)
     240             : {
     241          11 :         char *what = NULL;
     242          11 :         zval *value = NULL;
     243             :         size_t what_len, oldval;
     244             :         char *oldstr;
     245             : 
     246          11 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|sz", &what, &what_len, &value) == FAILURE) {
     247           0 :                 return;
     248             :         }
     249             : 
     250          11 :         if (!what) {
     251           1 :                 array_init(return_value);
     252           1 :                 add_assoc_string(return_value,"line_buffer",SAFE_STRING(rl_line_buffer));
     253           1 :                 add_assoc_long(return_value,"point",rl_point);
     254           1 :                 add_assoc_long(return_value,"end",rl_end);
     255             : #ifdef HAVE_LIBREADLINE
     256           1 :                 add_assoc_long(return_value,"mark",rl_mark);
     257           1 :                 add_assoc_long(return_value,"done",rl_done);
     258           1 :                 add_assoc_long(return_value,"pending_input",rl_pending_input);
     259           1 :                 add_assoc_string(return_value,"prompt",SAFE_STRING(rl_prompt));
     260           1 :                 add_assoc_string(return_value,"terminal_name",(char *)SAFE_STRING(rl_terminal_name));
     261             : #endif
     262             : #if HAVE_ERASE_EMPTY_LINE
     263             :                 add_assoc_long(return_value,"erase_empty_line",rl_erase_empty_line);
     264             : #endif
     265           1 :                 add_assoc_string(return_value,"library_version",(char *)SAFE_STRING(rl_library_version));
     266           1 :                 add_assoc_string(return_value,"readline_name",(char *)SAFE_STRING(rl_readline_name));
     267           1 :                 add_assoc_long(return_value,"attempted_completion_over",rl_attempted_completion_over);
     268             :         } else {
     269          10 :                 if (!strcasecmp(what,"line_buffer")) {
     270           1 :                         oldstr = rl_line_buffer;
     271           1 :                         if (value) {
     272             :                                 /* XXX if (rl_line_buffer) free(rl_line_buffer); */
     273           0 :                                 convert_to_string_ex(value);
     274           0 :                                 rl_line_buffer = strdup(Z_STRVAL_P(value));
     275             :                         }
     276           2 :                         RETVAL_STRING(SAFE_STRING(oldstr));
     277           9 :                 } else if (!strcasecmp(what, "point")) {
     278           0 :                         RETVAL_LONG(rl_point);
     279           9 :                 } else if (!strcasecmp(what, "end")) {
     280           0 :                         RETVAL_LONG(rl_end);
     281             : #ifdef HAVE_LIBREADLINE
     282           9 :                 } else if (!strcasecmp(what, "mark")) {
     283           0 :                         RETVAL_LONG(rl_mark);
     284           9 :                 } else if (!strcasecmp(what, "done")) {
     285           2 :                         oldval = rl_done;
     286           2 :                         if (value) {
     287           0 :                                 convert_to_long_ex(value);
     288           0 :                                 rl_done = Z_LVAL_P(value);
     289             :                         }
     290           2 :                         RETVAL_LONG(oldval);
     291           7 :                 } else if (!strcasecmp(what, "pending_input")) {
     292           0 :                         oldval = rl_pending_input;
     293           0 :                         if (value) {
     294           0 :                                 convert_to_string_ex(value);
     295           0 :                                 rl_pending_input = Z_STRVAL_P(value)[0];
     296             :                         }
     297           0 :                         RETVAL_LONG(oldval);
     298           7 :                 } else if (!strcasecmp(what, "prompt")) {
     299           0 :                         RETVAL_STRING(SAFE_STRING(rl_prompt));
     300           7 :                 } else if (!strcasecmp(what, "terminal_name")) {
     301           0 :                         RETVAL_STRING((char *)SAFE_STRING(rl_terminal_name));
     302             : #endif
     303             : #if HAVE_ERASE_EMPTY_LINE
     304             :                 } else if (!strcasecmp(what, "erase_empty_line")) {
     305             :                         oldval = rl_erase_empty_line;
     306             :                         if (value) {
     307             :                                 convert_to_long_ex(value);
     308             :                                 rl_erase_empty_line = Z_LVAL_PP(value);
     309             :                         }
     310             :                         RETVAL_LONG(oldval);
     311             : #endif
     312           7 :                 } else if (!strcasecmp(what,"library_version")) {
     313           0 :                         RETVAL_STRING((char *)SAFE_STRING(rl_library_version));
     314           7 :                 } else if (!strcasecmp(what, "readline_name")) {
     315           3 :                         oldstr = (char*)rl_readline_name;
     316           3 :                         if (value) {
     317             :                                 /* XXX if (rl_readline_name) free(rl_readline_name); */
     318           3 :                                 convert_to_string_ex(value);
     319           1 :                                 rl_readline_name = strdup(Z_STRVAL_P(value));;
     320             :                         }
     321           6 :                         RETVAL_STRING(SAFE_STRING(oldstr));
     322           4 :                 } else if (!strcasecmp(what, "attempted_completion_over")) {
     323           2 :                         oldval = rl_attempted_completion_over;
     324           2 :                         if (value) {
     325           2 :                                 convert_to_long_ex(value);
     326           1 :                                 rl_attempted_completion_over = Z_LVAL_P(value);
     327             :                         }
     328           2 :                         RETVAL_LONG(oldval);
     329             :                 }
     330             :         }
     331             : }
     332             : 
     333             : /* }}} */
     334             : /* {{{ proto bool readline_add_history(string prompt)
     335             :    Adds a line to the history */
     336           8 : PHP_FUNCTION(readline_add_history)
     337             : {
     338             :         char *arg;
     339             :         size_t arg_len;
     340             : 
     341           8 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &arg, &arg_len) == FAILURE) {
     342           1 :                 return;
     343             :         }
     344             : 
     345           7 :         add_history(arg);
     346             : 
     347           7 :         RETURN_TRUE;
     348             : }
     349             : 
     350             : /* }}} */
     351             : /* {{{ proto bool readline_clear_history(void)
     352             :    Clears the history */
     353           4 : PHP_FUNCTION(readline_clear_history)
     354             : {
     355           4 :         if (zend_parse_parameters_none() == FAILURE) {
     356           1 :                 return;
     357             :         }
     358             : 
     359             : #if HAVE_LIBEDIT
     360             :         /* clear_history is the only function where rl_initialize
     361             :            is not call to ensure correct allocation */
     362             :         using_history();
     363             : #endif
     364           3 :         clear_history();
     365             : 
     366           3 :         RETURN_TRUE;
     367             : }
     368             : 
     369             : /* }}} */
     370             : /* {{{ proto array readline_list_history(void)
     371             :    Lists the history */
     372             : #ifndef HAVE_LIBEDIT
     373           5 : PHP_FUNCTION(readline_list_history)
     374             : {
     375             :         HIST_ENTRY **history;
     376             : 
     377           5 :         if (zend_parse_parameters_none() == FAILURE) {
     378           1 :                 return;
     379             :         }
     380             : 
     381           4 :         history = history_list();
     382             : 
     383           4 :         array_init(return_value);
     384             : 
     385           4 :         if (history) {
     386             :                 int i;
     387           7 :                 for (i = 0; history[i]; i++) {
     388           4 :                         add_next_index_string(return_value,history[i]->line);
     389             :                 }
     390             :         }
     391             : }
     392             : #endif
     393             : /* }}} */
     394             : /* {{{ proto bool readline_read_history([string filename])
     395             :    Reads the history */
     396           3 : PHP_FUNCTION(readline_read_history)
     397             : {
     398           3 :         char *arg = NULL;
     399             :         size_t arg_len;
     400             : 
     401           3 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|p", &arg, &arg_len) == FAILURE) {
     402           0 :                 return;
     403             :         }
     404             : 
     405           3 :         if (php_check_open_basedir(arg)) {
     406           0 :                 RETURN_FALSE;
     407             :         }
     408             : 
     409             :         /* XXX from & to NYI */
     410           3 :         if (read_history(arg)) {
     411           2 :                 RETURN_FALSE;
     412             :         } else {
     413           1 :                 RETURN_TRUE;
     414             :         }
     415             : }
     416             : 
     417             : /* }}} */
     418             : /* {{{ proto bool readline_write_history([string filename])
     419             :    Writes the history */
     420           2 : PHP_FUNCTION(readline_write_history)
     421             : {
     422           2 :         char *arg = NULL;
     423             :         size_t arg_len;
     424             : 
     425           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|p", &arg, &arg_len) == FAILURE) {
     426           0 :                 return;
     427             :         }
     428             : 
     429           2 :         if (php_check_open_basedir(arg)) {
     430           0 :                 RETURN_FALSE;
     431             :         }
     432             : 
     433           2 :         if (write_history(arg)) {
     434           0 :                 RETURN_FALSE;
     435             :         } else {
     436           2 :                 RETURN_TRUE;
     437             :         }
     438             : }
     439             : 
     440             : /* }}} */
     441             : /* {{{ proto bool readline_completion_function(string funcname)
     442             :    Readline completion function? */
     443             : 
     444           0 : static char *_readline_command_generator(const char *text, int state)
     445             : {
     446           0 :         HashTable  *myht = Z_ARRVAL(_readline_array);
     447             :         zval *entry;
     448             : 
     449           0 :         if (!state) {
     450           0 :                 zend_hash_internal_pointer_reset(myht);
     451             :         }
     452             : 
     453           0 :         while ((entry = zend_hash_get_current_data(myht)) != NULL) {
     454           0 :                 zend_hash_move_forward(myht);
     455             : 
     456           0 :                 convert_to_string_ex(entry);
     457           0 :                 if (strncmp (Z_STRVAL_P(entry), text, strlen(text)) == 0) {
     458           0 :                         return (strdup(Z_STRVAL_P(entry)));
     459             :                 }
     460             :         }
     461             : 
     462           0 :         return NULL;
     463             : }
     464             : 
     465           0 : static void _readline_string_zval(zval *ret, const char *str)
     466             : {
     467           0 :         if (str) {
     468           0 :                 ZVAL_STRING(ret, (char*)str);
     469             :         } else {
     470           0 :                 ZVAL_NULL(ret);
     471             :         }
     472           0 : }
     473             : 
     474           0 : static void _readline_long_zval(zval *ret, long l)
     475             : {
     476           0 :         ZVAL_LONG(ret, l);
     477           0 : }
     478             : 
     479           0 : static char **_readline_completion_cb(const char *text, int start, int end)
     480             : {
     481             :         zval params[3];
     482             :         int i;
     483           0 :         char **matches = NULL;
     484             : 
     485           0 :         _readline_string_zval(&params[0], text);
     486           0 :         _readline_long_zval(&params[1], start);
     487           0 :         _readline_long_zval(&params[2], end);
     488             : 
     489           0 :         if (call_user_function(CG(function_table), NULL, &_readline_completion, &_readline_array, 3, params) == SUCCESS) {
     490           0 :                 if (Z_TYPE(_readline_array) == IS_ARRAY) {
     491           0 :                         if (zend_hash_num_elements(Z_ARRVAL(_readline_array))) {
     492           0 :                                 matches = rl_completion_matches(text,_readline_command_generator);
     493             :                         } else {
     494           0 :                                 matches = malloc(sizeof(char *) * 2);
     495           0 :                                 if (!matches) {
     496           0 :                                         return NULL;
     497             :                                 }
     498           0 :                                 matches[0] = strdup("");
     499           0 :                                 matches[1] = '\0';
     500             :                         }
     501             :                 }
     502             :         }
     503             : 
     504           0 :         for (i = 0; i < 3; i++) {
     505           0 :                 zval_ptr_dtor(&params[i]);
     506             :         }
     507             :         zval_dtor(&_readline_array);
     508             : 
     509           0 :         return matches;
     510             : }
     511             : 
     512           4 : PHP_FUNCTION(readline_completion_function)
     513             : {
     514           4 :         zval *arg = NULL;
     515           4 :         zend_string *name = NULL;
     516             : 
     517           4 :         if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg)) {
     518           0 :                 RETURN_FALSE;
     519             :         }
     520             : 
     521           4 :         if (!zend_is_callable(arg, 0, &name)) {
     522           2 :                 php_error_docref(NULL, E_WARNING, "%s is not callable", name->val);
     523           2 :                 zend_string_release(name);
     524           2 :                 RETURN_FALSE;
     525             :         }
     526           2 :         zend_string_release(name);
     527             : 
     528             :         zval_dtor(&_readline_completion);
     529           2 :         ZVAL_DUP(&_readline_completion, arg);
     530             : 
     531           2 :         rl_attempted_completion_function = _readline_completion_cb;
     532           2 :         if (rl_attempted_completion_function == NULL) {
     533           0 :                 RETURN_FALSE;
     534             :         }
     535           2 :         RETURN_TRUE;
     536             : }
     537             : 
     538             : /* }}} */
     539             : 
     540             : #if HAVE_RL_CALLBACK_READ_CHAR
     541             : 
     542           0 : static void php_rl_callback_handler(char *the_line)
     543             : {
     544             :         zval params[1];
     545             :         zval dummy;
     546             : 
     547           0 :         ZVAL_NULL(&dummy);
     548             : 
     549           0 :         _readline_string_zval(&params[0], the_line);
     550             : 
     551           0 :         call_user_function(CG(function_table), NULL, &_prepped_callback, &dummy, 1, params);
     552             : 
     553           0 :         zval_ptr_dtor(&params[0]);
     554             :         zval_dtor(&dummy);
     555           0 : }
     556             : 
     557             : /* {{{ proto void readline_callback_handler_install(string prompt, mixed callback)
     558             :    Initializes the readline callback interface and terminal, prints the prompt and returns immediately */
     559           5 : PHP_FUNCTION(readline_callback_handler_install)
     560             : {
     561             :         zval *callback;
     562           5 :         zend_string *name = NULL;
     563             :         char *prompt;
     564             :         size_t prompt_len;
     565             : 
     566           5 :         if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "sz", &prompt, &prompt_len, &callback)) {
     567           1 :                 return;
     568             :         }
     569             : 
     570           4 :         if (!zend_is_callable(callback, 0, &name)) {
     571           1 :                 php_error_docref(NULL, E_WARNING, "%s is not callable", name->val);
     572           1 :                 zend_string_release(name);
     573           1 :                 RETURN_FALSE;
     574             :         }
     575           3 :         zend_string_release(name);
     576             : 
     577           3 :         if (Z_TYPE(_prepped_callback) != IS_UNDEF) {
     578           1 :                 rl_callback_handler_remove();
     579             :                 zval_dtor(&_prepped_callback);
     580             :         }
     581             : 
     582           3 :         ZVAL_DUP(&_prepped_callback, callback);
     583             : 
     584           3 :         rl_callback_handler_install(prompt, php_rl_callback_handler);
     585             : 
     586           3 :         RETURN_TRUE;
     587             : }
     588             : /* }}} */
     589             : 
     590             : /* {{{ proto void readline_callback_read_char()
     591             :    Informs the readline callback interface that a character is ready for input */
     592           0 : PHP_FUNCTION(readline_callback_read_char)
     593             : {
     594           0 :         if (Z_TYPE(_prepped_callback) != IS_UNDEF) {
     595           0 :                 rl_callback_read_char();
     596             :         }
     597           0 : }
     598             : /* }}} */
     599             : 
     600             : /* {{{ proto bool readline_callback_handler_remove()
     601             :    Removes a previously installed callback handler and restores terminal settings */
     602           2 : PHP_FUNCTION(readline_callback_handler_remove)
     603             : {
     604           2 :         if (Z_TYPE(_prepped_callback) != IS_UNDEF) {
     605           1 :                 rl_callback_handler_remove();
     606             :                 zval_dtor(&_prepped_callback);
     607           1 :                 ZVAL_UNDEF(&_prepped_callback);
     608           1 :                 RETURN_TRUE;
     609             :         }
     610           1 :         RETURN_FALSE;
     611             : }
     612             : /* }}} */
     613             : 
     614             : /* {{{ proto void readline_redisplay(void)
     615             :    Ask readline to redraw the display */
     616           0 : PHP_FUNCTION(readline_redisplay)
     617             : {
     618           0 :         rl_redisplay();
     619           0 : }
     620             : /* }}} */
     621             : 
     622             : #endif
     623             : 
     624             : #if HAVE_RL_ON_NEW_LINE
     625             : /* {{{ proto void readline_on_new_line(void)
     626             :    Inform readline that the cursor has moved to a new line */
     627             : PHP_FUNCTION(readline_on_new_line)
     628             : {
     629             :         rl_on_new_line();
     630             : }
     631             : /* }}} */
     632             : 
     633             : #endif
     634             : 
     635             : 
     636             : #endif /* HAVE_LIBREADLINE */
     637             : 
     638             : /*
     639             :  * Local variables:
     640             :  * tab-width: 4
     641             :  * c-basic-offset: 4
     642             :  * End:
     643             :  */

Generated by: LCOV version 1.10

Generated at Tue, 14 Apr 2015 11:48:49 +0000 (5 days ago)

Copyright © 2005-2015 The PHP Group
All rights reserved.