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: 124 205 60.5 %
Date: 2014-09-27 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-2014 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       20352 : PHP_MINIT_FUNCTION(readline)
     172             : {
     173             : #if HAVE_LIBREADLINE
     174             :                 /* libedit don't need this call which set the tty in cooked mode */
     175       20352 :         using_history();
     176             : #endif
     177       20352 :         ZVAL_UNDEF(&_readline_completion);
     178             : #if HAVE_RL_CALLBACK_READ_CHAR
     179       20352 :         ZVAL_UNDEF(&_prepped_callback);
     180             : #endif
     181       20352 :         return PHP_MINIT(cli_readline)(INIT_FUNC_ARGS_PASSTHRU);
     182             : }
     183             : 
     184       20386 : PHP_MSHUTDOWN_FUNCTION(readline)
     185             : {
     186       20386 :         return PHP_MSHUTDOWN(cli_readline)(SHUTDOWN_FUNC_ARGS_PASSTHRU);
     187             : }
     188             : 
     189       20345 : PHP_RSHUTDOWN_FUNCTION(readline)
     190             : {
     191             :         zval_dtor(&_readline_completion);
     192       20345 :         ZVAL_UNDEF(&_readline_completion);
     193             : #if HAVE_RL_CALLBACK_READ_CHAR
     194       20345 :         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       20345 :         return SUCCESS;
     202             : }
     203             : 
     204         143 : PHP_MINFO_FUNCTION(readline)
     205             : {
     206         143 :         PHP_MINFO(cli_readline)(ZEND_MODULE_INFO_FUNC_ARGS_PASSTHRU);
     207         143 : }
     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() TSRMLS_CC, "|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() TSRMLS_CC, "|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() TSRMLS_CC, "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           1 : PHP_FUNCTION(readline_read_history)
     397             : {
     398           1 :         char *arg = NULL;
     399             :         size_t arg_len;
     400             : 
     401           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|p", &arg, &arg_len) == FAILURE) {
     402           0 :                 return;
     403             :         }
     404             : 
     405           1 :         if (php_check_open_basedir(arg TSRMLS_CC)) {
     406           0 :                 RETURN_FALSE;
     407             :         }
     408             : 
     409             :         /* XXX from & to NYI */
     410           1 :         if (read_history(arg)) {
     411           0 :                 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() TSRMLS_CC, "|p", &arg, &arg_len) == FAILURE) {
     426           0 :                 return;
     427             :         }
     428             : 
     429           2 :         if (php_check_open_basedir(arg TSRMLS_CC)) {
     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             :         TSRMLS_FETCH();
     485             : 
     486           0 :         _readline_string_zval(&params[0], text);
     487           0 :         _readline_long_zval(&params[1], start);
     488           0 :         _readline_long_zval(&params[2], end);
     489             : 
     490           0 :         if (call_user_function(CG(function_table), NULL, &_readline_completion, &_readline_array, 3, params TSRMLS_CC) == SUCCESS) {
     491           0 :                 if (Z_TYPE(_readline_array) == IS_ARRAY) {
     492           0 :                         if (zend_hash_num_elements(Z_ARRVAL(_readline_array))) {
     493           0 :                                 matches = rl_completion_matches(text,_readline_command_generator);
     494             :                         } else {
     495           0 :                                 matches = malloc(sizeof(char *) * 2);
     496           0 :                                 if (!matches) {
     497           0 :                                         return NULL;
     498             :                                 }
     499           0 :                                 matches[0] = strdup("");
     500           0 :                                 matches[1] = '\0';
     501             :                         }
     502             :                 }
     503             :         }
     504             :         
     505           0 :         for (i = 0; i < 3; i++) {
     506           0 :                 zval_ptr_dtor(&params[i]);
     507             :         }
     508             :         zval_dtor(&_readline_array);
     509             :         
     510           0 :         return matches; 
     511             : }
     512             : 
     513           4 : PHP_FUNCTION(readline_completion_function)
     514             : {
     515           4 :         zval *arg = NULL;
     516           4 :         zend_string *name = NULL;
     517             : 
     518           4 :         if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg)) {
     519           0 :                 RETURN_FALSE;
     520             :         }
     521             : 
     522           4 :         if (!zend_is_callable(arg, 0, &name TSRMLS_CC)) {
     523           2 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not callable", name->val);
     524           2 :                 zend_string_release(name);
     525           2 :                 RETURN_FALSE;
     526             :         }
     527           2 :         zend_string_release(name);
     528             : 
     529             :         zval_dtor(&_readline_completion);
     530           2 :         ZVAL_DUP(&_readline_completion, arg);
     531             : 
     532           2 :         rl_attempted_completion_function = _readline_completion_cb;
     533           2 :         if (rl_attempted_completion_function == NULL) {
     534           0 :                 RETURN_FALSE;
     535             :         }
     536           2 :         RETURN_TRUE;
     537             : }
     538             : 
     539             : /* }}} */
     540             : 
     541             : #if HAVE_RL_CALLBACK_READ_CHAR
     542             : 
     543           0 : static void php_rl_callback_handler(char *the_line)
     544             : {
     545             :         zval params[1];
     546             :         zval dummy;
     547             :         TSRMLS_FETCH();
     548             : 
     549           0 :         ZVAL_NULL(&dummy);
     550             : 
     551           0 :         _readline_string_zval(&params[0], the_line);
     552             : 
     553           0 :         call_user_function(CG(function_table), NULL, &_prepped_callback, &dummy, 1, params TSRMLS_CC);
     554             : 
     555           0 :         zval_ptr_dtor(&params[0]);
     556             :         zval_dtor(&dummy);
     557           0 : }
     558             : 
     559             : /* {{{ proto void readline_callback_handler_install(string prompt, mixed callback)
     560             :    Initializes the readline callback interface and terminal, prints the prompt and returns immediately */
     561           5 : PHP_FUNCTION(readline_callback_handler_install)
     562             : {
     563             :         zval *callback;
     564           5 :         zend_string *name = NULL;
     565             :         char *prompt;
     566             :         size_t prompt_len;
     567             : 
     568           5 :         if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &prompt, &prompt_len, &callback)) {
     569           1 :                 return;
     570             :         }
     571             : 
     572           4 :         if (!zend_is_callable(callback, 0, &name TSRMLS_CC)) {
     573           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not callable", name->val);
     574           1 :                 zend_string_release(name);
     575           1 :                 RETURN_FALSE;
     576             :         }
     577           3 :         zend_string_release(name);
     578             : 
     579           3 :         if (Z_TYPE(_prepped_callback) != IS_UNDEF) {
     580           1 :                 rl_callback_handler_remove();
     581             :                 zval_dtor(&_prepped_callback);
     582             :         }
     583             : 
     584           3 :         ZVAL_DUP(&_prepped_callback, callback);
     585             : 
     586           3 :         rl_callback_handler_install(prompt, php_rl_callback_handler);
     587             : 
     588           3 :         RETURN_TRUE;
     589             : }
     590             : /* }}} */
     591             : 
     592             : /* {{{ proto void readline_callback_read_char()
     593             :    Informs the readline callback interface that a character is ready for input */
     594           0 : PHP_FUNCTION(readline_callback_read_char)
     595             : {
     596           0 :         if (Z_TYPE(_prepped_callback) != IS_UNDEF) {
     597           0 :                 rl_callback_read_char();
     598             :         }
     599           0 : }
     600             : /* }}} */
     601             : 
     602             : /* {{{ proto bool readline_callback_handler_remove()
     603             :    Removes a previously installed callback handler and restores terminal settings */
     604           2 : PHP_FUNCTION(readline_callback_handler_remove)
     605             : {
     606           2 :         if (Z_TYPE(_prepped_callback) != IS_UNDEF) {
     607           1 :                 rl_callback_handler_remove();
     608             :                 zval_dtor(&_prepped_callback);
     609           1 :                 ZVAL_UNDEF(&_prepped_callback);
     610           1 :                 RETURN_TRUE;
     611             :         }
     612           1 :         RETURN_FALSE;
     613             : }
     614             : /* }}} */
     615             : 
     616             : /* {{{ proto void readline_redisplay(void)
     617             :    Ask readline to redraw the display */
     618           0 : PHP_FUNCTION(readline_redisplay)
     619             : {
     620           0 :         rl_redisplay();
     621           0 : }
     622             : /* }}} */
     623             : 
     624             : #endif
     625             : 
     626             : #if HAVE_RL_ON_NEW_LINE
     627             : /* {{{ proto void readline_on_new_line(void)
     628             :    Inform readline that the cursor has moved to a new line */
     629             : PHP_FUNCTION(readline_on_new_line)
     630             : {
     631             :         rl_on_new_line();
     632             : }
     633             : /* }}} */
     634             : 
     635             : #endif
     636             : 
     637             : 
     638             : #endif /* HAVE_LIBREADLINE */
     639             : 
     640             : /*
     641             :  * Local variables:
     642             :  * tab-width: 4
     643             :  * c-basic-offset: 4
     644             :  * End:
     645             :  */

Generated by: LCOV version 1.10

Generated at Sat, 27 Sep 2014 16:43:16 +0000 (4 days ago)

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