| READLINE(3) READLINE(3) |
| |
| |
| |
| NNAAMMEE |
| readline - get a line from a user with editing |
| |
| SSYYNNOOPPSSIISS |
| ##iinncclluuddee <<ssttddiioo..hh>> |
| ##iinncclluuddee <<rreeaaddlliinnee//rreeaaddlliinnee..hh>> |
| ##iinncclluuddee <<rreeaaddlliinnee//hhiissttoorryy..hh>> |
| |
| _c_h_a_r _* |
| rreeaaddlliinnee (_c_o_n_s_t _c_h_a_r _*_p_r_o_m_p_t); |
| |
| CCOOPPYYRRIIGGHHTT |
| Readline is Copyright (C) 1989-2004 by the Free Software Foundation, |
| Inc. |
| |
| DDEESSCCRRIIPPTTIIOONN |
| rreeaaddlliinnee will read a line from the terminal and return it, using pprroommpptt |
| as a prompt. If pprroommpptt is NNUULLLL or the empty string, no prompt is |
| issued. The line returned is allocated with _m_a_l_l_o_c(3); the caller must |
| free it when finished. The line returned has the final newline |
| removed, so only the text of the line remains. |
| |
| rreeaaddlliinnee offers editing capabilities while the user is entering the |
| line. By default, the line editing commands are similar to those of |
| emacs. A vi-style line editing interface is also available. |
| |
| This manual page describes only the most basic use of rreeaaddlliinnee. Much |
| more functionality is available; see _T_h_e _G_N_U _R_e_a_d_l_i_n_e _L_i_b_r_a_r_y and _T_h_e |
| _G_N_U _H_i_s_t_o_r_y _L_i_b_r_a_r_y for additional information. |
| |
| RREETTUURRNN VVAALLUUEE |
| rreeaaddlliinnee returns the text of the line read. A blank line returns the |
| empty string. If EEOOFF is encountered while reading a line, and the line |
| is empty, NNUULLLL is returned. If an EEOOFF is read with a non-empty line, |
| it is treated as a newline. |
| |
| NNOOTTAATTIIOONN |
| An emacs-style notation is used to denote keystrokes. Control keys are |
| denoted by C-_k_e_y, e.g., C-n means Control-N. Similarly, _m_e_t_a keys are |
| denoted by M-_k_e_y, so M-x means Meta-X. (On keyboards without a _m_e_t_a |
| key, M-_x means ESC _x, i.e., press the Escape key then the _x key. This |
| makes ESC the _m_e_t_a _p_r_e_f_i_x. The combination M-C-_x means ESC-Control-_x, |
| or press the Escape key then hold the Control key while pressing the _x |
| key.) |
| |
| Readline commands may be given numeric _a_r_g_u_m_e_n_t_s, which normally act as |
| a repeat count. Sometimes, however, it is the sign of the argument |
| that is significant. Passing a negative argument to a command that |
| acts in the forward direction (e.g., kkiillll--lliinnee) causes that command to |
| act in a backward direction. Commands whose behavior with arguments |
| deviates from this are noted. |
| |
| When a command is described as _k_i_l_l_i_n_g text, the text deleted is saved |
| for possible future retrieval (_y_a_n_k_i_n_g). The killed text is saved in a |
| _k_i_l_l _r_i_n_g. Consecutive kills cause the text to be accumulated into one |
| unit, which can be yanked all at once. Commands which do not kill text |
| separate the chunks of text on the kill ring. |
| |
| IINNIITTIIAALLIIZZAATTIIOONN FFIILLEE |
| Readline is customized by putting commands in an initialization file |
| (the _i_n_p_u_t_r_c file). The name of this file is taken from the value of |
| the IINNPPUUTTRRCC environment variable. If that variable is unset, the |
| default is _~_/_._i_n_p_u_t_r_c. When a program which uses the readline library |
| starts up, the init file is read, and the key bindings and variables |
| are set. There are only a few basic constructs allowed in the readline |
| init file. Blank lines are ignored. Lines beginning with a ## are com- |
| ments. Lines beginning with a $$ indicate conditional constructs. |
| Other lines denote key bindings and variable settings. Each program |
| using this library may add its own commands and bindings. |
| |
| For example, placing |
| |
| M-Control-u: universal-argument |
| or |
| C-Meta-u: universal-argument |
| |
| into the _i_n_p_u_t_r_c would make M-C-u execute the readline command _u_n_i_v_e_r_- |
| _s_a_l_-_a_r_g_u_m_e_n_t. |
| |
| The following symbolic character names are recognized while processing |
| key bindings: _D_E_L, _E_S_C, _E_S_C_A_P_E, _L_F_D, _N_E_W_L_I_N_E, _R_E_T, _R_E_T_U_R_N, _R_U_B_O_U_T, |
| _S_P_A_C_E, _S_P_C, and _T_A_B. |
| |
| In addition to command names, readline allows keys to be bound to a |
| string that is inserted when the key is pressed (a _m_a_c_r_o). |
| |
| |
| KKeeyy BBiinnddiinnggss |
| The syntax for controlling key bindings in the _i_n_p_u_t_r_c file is simple. |
| All that is required is the name of the command or the text of a macro |
| and a key sequence to which it should be bound. The name may be speci- |
| fied in one of two ways: as a symbolic key name, possibly with _M_e_t_a_- or |
| _C_o_n_t_r_o_l_- prefixes, or as a key sequence. |
| |
| When using the form kkeeyynnaammee:_f_u_n_c_t_i_o_n_-_n_a_m_e or _m_a_c_r_o, _k_e_y_n_a_m_e is the name |
| of a key spelled out in English. For example: |
| |
| Control-u: universal-argument |
| Meta-Rubout: backward-kill-word |
| Control-o: "> output" |
| |
| In the above example, _C_-_u is bound to the function uunniivveerrssaall--aarrgguummeenntt, |
| _M_-_D_E_L is bound to the function bbaacckkwwaarrdd--kkiillll--wwoorrdd, and _C_-_o is bound to |
| run the macro expressed on the right hand side (that is, to insert the |
| text ``> output'' into the line). |
| |
| In the second form, ""kkeeyysseeqq"":_f_u_n_c_t_i_o_n_-_n_a_m_e or _m_a_c_r_o, kkeeyysseeqq differs |
| from kkeeyynnaammee above in that strings denoting an entire key sequence may |
| be specified by placing the sequence within double quotes. Some GNU |
| Emacs style key escapes can be used, as in the following example, but |
| the symbolic character names are not recognized. |
| |
| "\C-u": universal-argument |
| "\C-x\C-r": re-read-init-file |
| "\e[11~": "Function Key 1" |
| |
| In this example, _C_-_u is again bound to the function uunniivveerrssaall--aarrgguummeenntt. |
| _C_-_x _C_-_r is bound to the function rree--rreeaadd--iinniitt--ffiillee, and _E_S_C _[ _1 _1 _~ is |
| bound to insert the text ``Function Key 1''. |
| |
| The full set of GNU Emacs style escape sequences available when speci- |
| fying key sequences is |
| \\CC-- control prefix |
| \\MM-- meta prefix |
| \\ee an escape character |
| \\\\ backslash |
| \\"" literal ", a double quote |
| \\'' literal ', a single quote |
| |
| In addition to the GNU Emacs style escape sequences, a second set of |
| backslash escapes is available: |
| \\aa alert (bell) |
| \\bb backspace |
| \\dd delete |
| \\ff form feed |
| \\nn newline |
| \\rr carriage return |
| \\tt horizontal tab |
| \\vv vertical tab |
| \\_n_n_n the eight-bit character whose value is the octal value |
| _n_n_n (one to three digits) |
| \\xx_H_H the eight-bit character whose value is the hexadecimal |
| value _H_H (one or two hex digits) |
| |
| When entering the text of a macro, single or double quotes should be |
| used to indicate a macro definition. Unquoted text is assumed to be a |
| function name. In the macro body, the backslash escapes described |
| above are expanded. Backslash will quote any other character in the |
| macro text, including " and '. |
| |
| BBaasshh allows the current readline key bindings to be displayed or modi- |
| fied with the bbiinndd builtin command. The editing mode may be switched |
| during interactive use by using the --oo option to the sseett builtin com- |
| mand. Other programs using this library provide similar mechanisms. |
| The _i_n_p_u_t_r_c file may be edited and re-read if a program does not pro- |
| vide any other means to incorporate new bindings. |
| |
| VVaarriiaabblleess |
| Readline has variables that can be used to further customize its behav- |
| ior. A variable may be set in the _i_n_p_u_t_r_c file with a statement of the |
| form |
| |
| sseett _v_a_r_i_a_b_l_e_-_n_a_m_e _v_a_l_u_e |
| |
| Except where noted, readline variables can take the values OOnn or OOffff |
| (without regard to case). Unrecognized variable names are ignored. |
| When a variable value is read, empty or null values, "on" (case-insen- |
| sitive), and "1" are equivalent to OOnn. All other values are equivalent |
| to OOffff. The variables and their default values are: |
| |
| bbeellll--ssttyyllee ((aauuddiibbllee)) |
| Controls what happens when readline wants to ring the terminal |
| bell. If set to nnoonnee, readline never rings the bell. If set to |
| vviissiibbllee, readline uses a visible bell if one is available. If |
| set to aauuddiibbllee, readline attempts to ring the terminal's bell. |
| bbiinndd--ttttyy--ssppeecciiaall--cchhaarrss ((OOnn)) |
| If set to OOnn, readline attempts to bind the control characters |
| treated specially by the kernel's terminal driver to their read- |
| line equivalents. |
| ccoommmmeenntt--bbeeggiinn ((````##'''')) |
| The string that is inserted in vvii mode when the iinnsseerrtt--ccoommmmeenntt |
| command is executed. This command is bound to MM--## in emacs mode |
| and to ## in vi command mode. |
| ccoommpplleettiioonn--iiggnnoorree--ccaassee ((OOffff)) |
| If set to OOnn, readline performs filename matching and completion |
| in a case-insensitive fashion. |
| ccoommpplleettiioonn--qquueerryy--iitteemmss ((110000)) |
| This determines when the user is queried about viewing the num- |
| ber of possible completions generated by the ppoossssiibbllee--ccoommppllee-- |
| ttiioonnss command. It may be set to any integer value greater than |
| or equal to zero. If the number of possible completions is |
| greater than or equal to the value of this variable, the user is |
| asked whether or not he wishes to view them; otherwise they are |
| simply listed on the terminal. A negative value causes readline |
| to never ask. |
| ccoonnvveerrtt--mmeettaa ((OOnn)) |
| If set to OOnn, readline will convert characters with the eighth |
| bit set to an ASCII key sequence by stripping the eighth bit and |
| prefixing it with an escape character (in effect, using escape |
| as the _m_e_t_a _p_r_e_f_i_x). |
| ddiissaabbllee--ccoommpplleettiioonn ((OOffff)) |
| If set to OOnn, readline will inhibit word completion. Completion |
| characters will be inserted into the line as if they had been |
| mapped to sseellff--iinnsseerrtt. |
| eeddiittiinngg--mmooddee ((eemmaaccss)) |
| Controls whether readline begins with a set of key bindings sim- |
| ilar to emacs or vi. eeddiittiinngg--mmooddee can be set to either eemmaaccss or |
| vvii. |
| eennaabbllee--kkeeyyppaadd ((OOffff)) |
| When set to OOnn, readline will try to enable the application key- |
| pad when it is called. Some systems need this to enable the |
| arrow keys. |
| eexxppaanndd--ttiillddee ((OOffff)) |
| If set to oonn, tilde expansion is performed when readline |
| attempts word completion. |
| hhiissttoorryy--pprreesseerrvvee--ppooiinntt ((OOffff)) |
| If set to oonn, the history code attempts to place point at the |
| same location on each history line retrieved with pprreevviioouuss--hhiiss-- |
| ttoorryy or nneexxtt--hhiissttoorryy. |
| hhoorriizzoonnttaall--ssccrroollll--mmooddee ((OOffff)) |
| When set to OOnn, makes readline use a single line for display, |
| scrolling the input horizontally on a single screen line when it |
| becomes longer than the screen width rather than wrapping to a |
| new line. |
| iinnppuutt--mmeettaa ((OOffff)) |
| If set to OOnn, readline will enable eight-bit input (that is, it |
| will not clear the eighth bit in the characters it reads), |
| regardless of what the terminal claims it can support. The name |
| mmeettaa--ffllaagg is a synonym for this variable. |
| iisseeaarrcchh--tteerrmmiinnaattoorrss ((````CC--[[ CC--JJ'''')) |
| The string of characters that should terminate an incremental |
| search without subsequently executing the character as a com- |
| mand. If this variable has not been given a value, the charac- |
| ters _E_S_C and _C_-_J will terminate an incremental search. |
| kkeeyymmaapp ((eemmaaccss)) |
| Set the current readline keymap. The set of legal keymap names |
| is _e_m_a_c_s_, _e_m_a_c_s_-_s_t_a_n_d_a_r_d_, _e_m_a_c_s_-_m_e_t_a_, _e_m_a_c_s_-_c_t_l_x_, _v_i_, _v_i_-_m_o_v_e_, |
| _v_i_-_c_o_m_m_a_n_d, and _v_i_-_i_n_s_e_r_t. _v_i is equivalent to _v_i_-_c_o_m_m_a_n_d; |
| _e_m_a_c_s is equivalent to _e_m_a_c_s_-_s_t_a_n_d_a_r_d. The default value is |
| _e_m_a_c_s. The value of eeddiittiinngg--mmooddee also affects the default |
| keymap. |
| mmaarrkk--ddiirreeccttoorriieess ((OOnn)) |
| If set to OOnn, completed directory names have a slash appended. |
| mmaarrkk--mmooddiiffiieedd--lliinneess ((OOffff)) |
| If set to OOnn, history lines that have been modified are dis- |
| played with a preceding asterisk (**). |
| mmaarrkk--ssyymmlliinnkkeedd--ddiirreeccttoorriieess ((OOffff)) |
| If set to OOnn, completed names which are symbolic links to direc- |
| tories have a slash appended (subject to the value of |
| mmaarrkk--ddiirreeccttoorriieess). |
| mmaattcchh--hhiiddddeenn--ffiilleess ((OOnn)) |
| This variable, when set to OOnn, causes readline to match files |
| whose names begin with a `.' (hidden files) when performing |
| filename completion, unless the leading `.' is supplied by the |
| user in the filename to be completed. |
| oouuttppuutt--mmeettaa ((OOffff)) |
| If set to OOnn, readline will display characters with the eighth |
| bit set directly rather than as a meta-prefixed escape sequence. |
| ppaaggee--ccoommpplleettiioonnss ((OOnn)) |
| If set to OOnn, readline uses an internal _m_o_r_e-like pager to dis- |
| play a screenful of possible completions at a time. |
| pprriinntt--ccoommpplleettiioonnss--hhoorriizzoonnttaallllyy ((OOffff)) |
| If set to OOnn, readline will display completions with matches |
| sorted horizontally in alphabetical order, rather than down the |
| screen. |
| sshhooww--aallll--iiff--aammbbiigguuoouuss ((OOffff)) |
| This alters the default behavior of the completion functions. |
| If set to oonn, words which have more than one possible completion |
| cause the matches to be listed immediately instead of ringing |
| the bell. |
| sshhooww--aallll--iiff--uunnmmooddiiffiieedd ((OOffff)) |
| This alters the default behavior of the completion functions in |
| a fashion similar to sshhooww--aallll--iiff--aammbbiigguuoouuss. If set to oonn, words |
| which have more than one possible completion without any possi- |
| ble partial completion (the possible completions don't share a |
| common prefix) cause the matches to be listed immediately |
| instead of ringing the bell. |
| vviissiibbllee--ssttaattss ((OOffff)) |
| If set to OOnn, a character denoting a file's type as reported by |
| _s_t_a_t(2) is appended to the filename when listing possible com- |
| pletions. |
| |
| CCoonnddiittiioonnaall CCoonnssttrruuccttss |
| Readline implements a facility similar in spirit to the conditional |
| compilation features of the C preprocessor which allows key bindings |
| and variable settings to be performed as the result of tests. There |
| are four parser directives used. |
| |
| $$iiff The $$iiff construct allows bindings to be made based on the edit- |
| ing mode, the terminal being used, or the application using |
| readline. The text of the test extends to the end of the line; |
| no characters are required to isolate it. |
| |
| mmooddee The mmooddee== form of the $$iiff directive is used to test |
| whether readline is in emacs or vi mode. This may be |
| used in conjunction with the sseett kkeeyymmaapp command, for |
| instance, to set bindings in the _e_m_a_c_s_-_s_t_a_n_d_a_r_d and |
| _e_m_a_c_s_-_c_t_l_x keymaps only if readline is starting out in |
| emacs mode. |
| |
| tteerrmm The tteerrmm== form may be used to include terminal-specific |
| key bindings, perhaps to bind the key sequences output by |
| the terminal's function keys. The word on the right side |
| of the == is tested against the full name of the terminal |
| and the portion of the terminal name before the first --. |
| This allows _s_u_n to match both _s_u_n and _s_u_n_-_c_m_d, for |
| instance. |
| |
| aapppplliiccaattiioonn |
| The aapppplliiccaattiioonn construct is used to include application- |
| specific settings. Each program using the readline |
| library sets the _a_p_p_l_i_c_a_t_i_o_n _n_a_m_e, and an initialization |
| file can test for a particular value. This could be used |
| to bind key sequences to functions useful for a specific |
| program. For instance, the following command adds a key |
| sequence that quotes the current or previous word in |
| Bash: |
| |
| $$iiff Bash |
| # Quote the current or previous word |
| "\C-xq": "\eb\"\ef\"" |
| $$eennddiiff |
| |
| $$eennddiiff This command, as seen in the previous example, terminates an $$iiff |
| command. |
| |
| $$eellssee Commands in this branch of the $$iiff directive are executed if the |
| test fails. |
| |
| $$iinncclluuddee |
| This directive takes a single filename as an argument and reads |
| commands and bindings from that file. For example, the follow- |
| ing directive would read _/_e_t_c_/_i_n_p_u_t_r_c: |
| |
| $$iinncclluuddee _/_e_t_c_/_i_n_p_u_t_r_c |
| |
| SSEEAARRCCHHIINNGG |
| Readline provides commands for searching through the command history |
| for lines containing a specified string. There are two search modes: |
| _i_n_c_r_e_m_e_n_t_a_l and _n_o_n_-_i_n_c_r_e_m_e_n_t_a_l. |
| |
| Incremental searches begin before the user has finished typing the |
| search string. As each character of the search string is typed, read- |
| line displays the next entry from the history matching the string typed |
| so far. An incremental search requires only as many characters as |
| needed to find the desired history entry. To search backward in the |
| history for a particular string, type CC--rr. Typing CC--ss searches forward |
| through the history. The characters present in the value of the |
| iisseeaarrcchh--tteerrmmiinnaattoorrss variable are used to terminate an incremental |
| search. If that variable has not been assigned a value the _E_s_c_a_p_e and |
| CC--JJ characters will terminate an incremental search. CC--GG will abort an |
| incremental search and restore the original line. When the search is |
| terminated, the history entry containing the search string becomes the |
| current line. |
| |
| To find other matching entries in the history list, type CC--ss or CC--rr as |
| appropriate. This will search backward or forward in the history for |
| the next line matching the search string typed so far. Any other key |
| sequence bound to a readline command will terminate the search and exe- |
| cute that command. For instance, a newline will terminate the search |
| and accept the line, thereby executing the command from the history |
| list. A movement command will terminate the search, make the last line |
| found the current line, and begin editing. |
| |
| Non-incremental searches read the entire search string before starting |
| to search for matching history lines. The search string may be typed |
| by the user or be part of the contents of the current line. |
| |
| EEDDIITTIINNGG CCOOMMMMAANNDDSS |
| The following is a list of the names of the commands and the default |
| key sequences to which they are bound. Command names without an accom- |
| panying key sequence are unbound by default. |
| |
| In the following descriptions, _p_o_i_n_t refers to the current cursor posi- |
| tion, and _m_a_r_k refers to a cursor position saved by the sseett--mmaarrkk com- |
| mand. The text between the point and mark is referred to as the |
| _r_e_g_i_o_n. |
| |
| CCoommmmaannddss ffoorr MMoovviinngg |
| bbeeggiinnnniinngg--ooff--lliinnee ((CC--aa)) |
| Move to the start of the current line. |
| eenndd--ooff--lliinnee ((CC--ee)) |
| Move to the end of the line. |
| ffoorrwwaarrdd--cchhaarr ((CC--ff)) |
| Move forward a character. |
| bbaacckkwwaarrdd--cchhaarr ((CC--bb)) |
| Move back a character. |
| ffoorrwwaarrdd--wwoorrdd ((MM--ff)) |
| Move forward to the end of the next word. Words are composed of |
| alphanumeric characters (letters and digits). |
| bbaacckkwwaarrdd--wwoorrdd ((MM--bb)) |
| Move back to the start of the current or previous word. Words |
| are composed of alphanumeric characters (letters and digits). |
| cclleeaarr--ssccrreeeenn ((CC--ll)) |
| Clear the screen leaving the current line at the top of the |
| screen. With an argument, refresh the current line without |
| clearing the screen. |
| rreeddrraaww--ccuurrrreenntt--lliinnee |
| Refresh the current line. |
| |
| CCoommmmaannddss ffoorr MMaanniippuullaattiinngg tthhee HHiissttoorryy |
| aacccceepptt--lliinnee ((NNeewwlliinnee,, RReettuurrnn)) |
| Accept the line regardless of where the cursor is. If this line |
| is non-empty, it may be added to the history list for future |
| recall with aadddd__hhiissttoorryy(()). If the line is a modified history |
| line, the history line is restored to its original state. |
| pprreevviioouuss--hhiissttoorryy ((CC--pp)) |
| Fetch the previous command from the history list, moving back in |
| the list. |
| nneexxtt--hhiissttoorryy ((CC--nn)) |
| Fetch the next command from the history list, moving forward in |
| the list. |
| bbeeggiinnnniinngg--ooff--hhiissttoorryy ((MM--<<)) |
| Move to the first line in the history. |
| eenndd--ooff--hhiissttoorryy ((MM-->>)) |
| Move to the end of the input history, i.e., the line currently |
| being entered. |
| rreevveerrssee--sseeaarrcchh--hhiissttoorryy ((CC--rr)) |
| Search backward starting at the current line and moving `up' |
| through the history as necessary. This is an incremental |
| search. |
| ffoorrwwaarrdd--sseeaarrcchh--hhiissttoorryy ((CC--ss)) |
| Search forward starting at the current line and moving `down' |
| through the history as necessary. This is an incremental |
| search. |
| nnoonn--iinnccrreemmeennttaall--rreevveerrssee--sseeaarrcchh--hhiissttoorryy ((MM--pp)) |
| Search backward through the history starting at the current line |
| using a non-incremental search for a string supplied by the |
| user. |
| nnoonn--iinnccrreemmeennttaall--ffoorrwwaarrdd--sseeaarrcchh--hhiissttoorryy ((MM--nn)) |
| Search forward through the history using a non-incremental |
| search for a string supplied by the user. |
| hhiissttoorryy--sseeaarrcchh--ffoorrwwaarrdd |
| Search forward through the history for the string of characters |
| between the start of the current line and the current cursor |
| position (the _p_o_i_n_t). This is a non-incremental search. |
| hhiissttoorryy--sseeaarrcchh--bbaacckkwwaarrdd |
| Search backward through the history for the string of characters |
| between the start of the current line and the point. This is a |
| non-incremental search. |
| yyaannkk--nntthh--aarrgg ((MM--CC--yy)) |
| Insert the first argument to the previous command (usually the |
| second word on the previous line) at point. With an argument _n, |
| insert the _nth word from the previous command (the words in the |
| previous command begin with word 0). A negative argument |
| inserts the _nth word from the end of the previous command. Once |
| the argument _n is computed, the argument is extracted as if the |
| "!_n" history expansion had been specified. |
| yyaannkk--llaasstt--aarrgg ((MM--..,, MM--__)) |
| Insert the last argument to the previous command (the last word |
| of the previous history entry). With an argument, behave |
| exactly like yyaannkk--nntthh--aarrgg. Successive calls to yyaannkk--llaasstt--aarrgg |
| move back through the history list, inserting the last argument |
| of each line in turn. The history expansion facilities are used |
| to extract the last argument, as if the "!$" history expansion |
| had been specified. |
| |
| CCoommmmaannddss ffoorr CChhaannggiinngg TTeexxtt |
| ddeelleettee--cchhaarr ((CC--dd)) |
| Delete the character at point. If point is at the beginning of |
| the line, there are no characters in the line, and the last |
| character typed was not bound to ddeelleettee--cchhaarr, then return EEOOFF. |
| bbaacckkwwaarrdd--ddeelleettee--cchhaarr ((RRuubboouutt)) |
| Delete the character behind the cursor. When given a numeric |
| argument, save the deleted text on the kill ring. |
| ffoorrwwaarrdd--bbaacckkwwaarrdd--ddeelleettee--cchhaarr |
| Delete the character under the cursor, unless the cursor is at |
| the end of the line, in which case the character behind the cur- |
| sor is deleted. |
| qquuootteedd--iinnsseerrtt ((CC--qq,, CC--vv)) |
| Add the next character that you type to the line verbatim. This |
| is how to insert characters like CC--qq, for example. |
| ttaabb--iinnsseerrtt ((MM--TTAABB)) |
| Insert a tab character. |
| sseellff--iinnsseerrtt ((aa,, bb,, AA,, 11,, !!,, ......)) |
| Insert the character typed. |
| ttrraannssppoossee--cchhaarrss ((CC--tt)) |
| Drag the character before point forward over the character at |
| point, moving point forward as well. If point is at the end of |
| the line, then this transposes the two characters before point. |
| Negative arguments have no effect. |
| ttrraannssppoossee--wwoorrddss ((MM--tt)) |
| Drag the word before point past the word after point, moving |
| point over that word as well. If point is at the end of the |
| line, this transposes the last two words on the line. |
| uuppccaassee--wwoorrdd ((MM--uu)) |
| Uppercase the current (or following) word. With a negative |
| argument, uppercase the previous word, but do not move point. |
| ddoowwnnccaassee--wwoorrdd ((MM--ll)) |
| Lowercase the current (or following) word. With a negative |
| argument, lowercase the previous word, but do not move point. |
| ccaappiittaalliizzee--wwoorrdd ((MM--cc)) |
| Capitalize the current (or following) word. With a negative |
| argument, capitalize the previous word, but do not move point. |
| oovveerrwwrriittee--mmooddee |
| Toggle overwrite mode. With an explicit positive numeric argu- |
| ment, switches to overwrite mode. With an explicit non-positive |
| numeric argument, switches to insert mode. This command affects |
| only eemmaaccss mode; vvii mode does overwrite differently. Each call |
| to _r_e_a_d_l_i_n_e_(_) starts in insert mode. In overwrite mode, charac- |
| ters bound to sseellff--iinnsseerrtt replace the text at point rather than |
| pushing the text to the right. Characters bound to bbaacckk-- |
| wwaarrdd--ddeelleettee--cchhaarr replace the character before point with a |
| space. By default, this command is unbound. |
| |
| KKiilllliinngg aanndd YYaannkkiinngg |
| kkiillll--lliinnee ((CC--kk)) |
| Kill the text from point to the end of the line. |
| bbaacckkwwaarrdd--kkiillll--lliinnee ((CC--xx RRuubboouutt)) |
| Kill backward to the beginning of the line. |
| uunniixx--lliinnee--ddiissccaarrdd ((CC--uu)) |
| Kill backward from point to the beginning of the line. The |
| killed text is saved on the kill-ring. |
| kkiillll--wwhhoollee--lliinnee |
| Kill all characters on the current line, no matter where point |
| is. |
| kkiillll--wwoorrdd ((MM--dd)) |
| Kill from point the end of the current word, or if between |
| words, to the end of the next word. Word boundaries are the |
| same as those used by ffoorrwwaarrdd--wwoorrdd. |
| bbaacckkwwaarrdd--kkiillll--wwoorrdd ((MM--RRuubboouutt)) |
| Kill the word behind point. Word boundaries are the same as |
| those used by bbaacckkwwaarrdd--wwoorrdd. |
| uunniixx--wwoorrdd--rruubboouutt ((CC--ww)) |
| Kill the word behind point, using white space as a word bound- |
| ary. The killed text is saved on the kill-ring. |
| uunniixx--ffiilleennaammee--rruubboouutt |
| Kill the word behind point, using white space and the slash |
| character as the word boundaries. The killed text is saved on |
| the kill-ring. |
| ddeelleettee--hhoorriizzoonnttaall--ssppaaccee ((MM--\\)) |
| Delete all spaces and tabs around point. |
| kkiillll--rreeggiioonn |
| Kill the text between the point and _m_a_r_k (saved cursor posi- |
| tion). This text is referred to as the _r_e_g_i_o_n. |
| ccooppyy--rreeggiioonn--aass--kkiillll |
| Copy the text in the region to the kill buffer. |
| ccooppyy--bbaacckkwwaarrdd--wwoorrdd |
| Copy the word before point to the kill buffer. The word bound- |
| aries are the same as bbaacckkwwaarrdd--wwoorrdd. |
| ccooppyy--ffoorrwwaarrdd--wwoorrdd |
| Copy the word following point to the kill buffer. The word |
| boundaries are the same as ffoorrwwaarrdd--wwoorrdd. |
| yyaannkk ((CC--yy)) |
| Yank the top of the kill ring into the buffer at point. |
| yyaannkk--ppoopp ((MM--yy)) |
| Rotate the kill ring, and yank the new top. Only works follow- |
| ing yyaannkk or yyaannkk--ppoopp. |
| |
| NNuummeerriicc AArrgguummeennttss |
| ddiiggiitt--aarrgguummeenntt ((MM--00,, MM--11,, ......,, MM----)) |
| Add this digit to the argument already accumulating, or start a |
| new argument. M-- starts a negative argument. |
| uunniivveerrssaall--aarrgguummeenntt |
| This is another way to specify an argument. If this command is |
| followed by one or more digits, optionally with a leading minus |
| sign, those digits define the argument. If the command is fol- |
| lowed by digits, executing uunniivveerrssaall--aarrgguummeenntt again ends the |
| numeric argument, but is otherwise ignored. As a special case, |
| if this command is immediately followed by a character that is |
| neither a digit or minus sign, the argument count for the next |
| command is multiplied by four. The argument count is initially |
| one, so executing this function the first time makes the argu- |
| ment count four, a second time makes the argument count sixteen, |
| and so on. |
| |
| CCoommpplleettiinngg |
| ccoommpplleettee ((TTAABB)) |
| Attempt to perform completion on the text before point. The |
| actual completion performed is application-specific. BBaasshh, for |
| instance, attempts completion treating the text as a variable |
| (if the text begins with $$), username (if the text begins with |
| ~~), hostname (if the text begins with @@), or command (including |
| aliases and functions) in turn. If none of these produces a |
| match, filename completion is attempted. GGddbb, on the other |
| hand, allows completion of program functions and variables, and |
| only attempts filename completion under certain circumstances. |
| ppoossssiibbllee--ccoommpplleettiioonnss ((MM--??)) |
| List the possible completions of the text before point. |
| iinnsseerrtt--ccoommpplleettiioonnss ((MM--**)) |
| Insert all completions of the text before point that would have |
| been generated by ppoossssiibbllee--ccoommpplleettiioonnss. |
| mmeennuu--ccoommpplleettee |
| Similar to ccoommpplleettee, but replaces the word to be completed with |
| a single match from the list of possible completions. Repeated |
| execution of mmeennuu--ccoommpplleettee steps through the list of possible |
| completions, inserting each match in turn. At the end of the |
| list of completions, the bell is rung (subject to the setting of |
| bbeellll--ssttyyllee) and the original text is restored. An argument of _n |
| moves _n positions forward in the list of matches; a negative |
| argument may be used to move backward through the list. This |
| command is intended to be bound to TTAABB, but is unbound by |
| default. |
| ddeelleettee--cchhaarr--oorr--lliisstt |
| Deletes the character under the cursor if not at the beginning |
| or end of the line (like ddeelleettee--cchhaarr). If at the end of the |
| line, behaves identically to ppoossssiibbllee--ccoommpplleettiioonnss. |
| |
| KKeeyybbooaarrdd MMaaccrrooss |
| ssttaarrtt--kkbbdd--mmaaccrroo ((CC--xx (()) |
| Begin saving the characters typed into the current keyboard |
| macro. |
| eenndd--kkbbdd--mmaaccrroo ((CC--xx )))) |
| Stop saving the characters typed into the current keyboard macro |
| and store the definition. |
| ccaallll--llaasstt--kkbbdd--mmaaccrroo ((CC--xx ee)) |
| Re-execute the last keyboard macro defined, by making the char- |
| acters in the macro appear as if typed at the keyboard. |
| |
| MMiisscceellllaanneeoouuss |
| rree--rreeaadd--iinniitt--ffiillee ((CC--xx CC--rr)) |
| Read in the contents of the _i_n_p_u_t_r_c file, and incorporate any |
| bindings or variable assignments found there. |
| aabboorrtt ((CC--gg)) |
| Abort the current editing command and ring the terminal's bell |
| (subject to the setting of bbeellll--ssttyyllee). |
| ddoo--uuppppeerrccaassee--vveerrssiioonn ((MM--aa,, MM--bb,, MM--_x,, ......)) |
| If the metafied character _x is lowercase, run the command that |
| is bound to the corresponding uppercase character. |
| pprreeffiixx--mmeettaa ((EESSCC)) |
| Metafy the next character typed. EESSCC ff is equivalent to MMeettaa--ff. |
| uunnddoo ((CC--__,, CC--xx CC--uu)) |
| Incremental undo, separately remembered for each line. |
| rreevveerrtt--lliinnee ((MM--rr)) |
| Undo all changes made to this line. This is like executing the |
| uunnddoo command enough times to return the line to its initial |
| state. |
| ttiillddee--eexxppaanndd ((MM--&&)) |
| Perform tilde expansion on the current word. |
| sseett--mmaarrkk ((CC--@@,, MM--<<ssppaaccee>>)) |
| Set the mark to the point. If a numeric argument is supplied, |
| the mark is set to that position. |
| eexxcchhaannggee--ppooiinntt--aanndd--mmaarrkk ((CC--xx CC--xx)) |
| Swap the point with the mark. The current cursor position is |
| set to the saved position, and the old cursor position is saved |
| as the mark. |
| cchhaarraacctteerr--sseeaarrcchh ((CC--]])) |
| A character is read and point is moved to the next occurrence of |
| that character. A negative count searches for previous occur- |
| rences. |
| cchhaarraacctteerr--sseeaarrcchh--bbaacckkwwaarrdd ((MM--CC--]])) |
| A character is read and point is moved to the previous occur- |
| rence of that character. A negative count searches for subse- |
| quent occurrences. |
| iinnsseerrtt--ccoommmmeenntt ((MM--##)) |
| Without a numeric argument, the value of the readline ccoomm-- |
| mmeenntt--bbeeggiinn variable is inserted at the beginning of the current |
| line. If a numeric argument is supplied, this command acts as a |
| toggle: if the characters at the beginning of the line do not |
| match the value of ccoommmmeenntt--bbeeggiinn, the value is inserted, other- |
| wise the characters in ccoommmmeenntt--bbeeggiinn are deleted from the begin- |
| ning of the line. In either case, the line is accepted as if a |
| newline had been typed. The default value of ccoommmmeenntt--bbeeggiinn |
| makes the current line a shell comment. If a numeric argument |
| causes the comment character to be removed, the line will be |
| executed by the shell. |
| dduummpp--ffuunnccttiioonnss |
| Print all of the functions and their key bindings to the read- |
| line output stream. If a numeric argument is supplied, the out- |
| put is formatted in such a way that it can be made part of an |
| _i_n_p_u_t_r_c file. |
| dduummpp--vvaarriiaabblleess |
| Print all of the settable variables and their values to the |
| readline output stream. If a numeric argument is supplied, the |
| output is formatted in such a way that it can be made part of an |
| _i_n_p_u_t_r_c file. |
| dduummpp--mmaaccrrooss |
| Print all of the readline key sequences bound to macros and the |
| strings they output. If a numeric argument is supplied, the |
| output is formatted in such a way that it can be made part of an |
| _i_n_p_u_t_r_c file. |
| eemmaaccss--eeddiittiinngg--mmooddee ((CC--ee)) |
| When in vvii command mode, this causes a switch to eemmaaccss editing |
| mode. |
| vvii--eeddiittiinngg--mmooddee ((MM--CC--jj)) |
| When in eemmaaccss editing mode, this causes a switch to vvii editing |
| mode. |
| |
| DDEEFFAAUULLTT KKEEYY BBIINNDDIINNGGSS |
| The following is a list of the default emacs and vi bindings. Charac- |
| ters with the eighth bit set are written as M-<character>, and are |
| referred to as _m_e_t_a_f_i_e_d characters. The printable ASCII characters not |
| mentioned in the list of emacs standard bindings are bound to the |
| sseellff--iinnsseerrtt function, which just inserts the given character into the |
| input line. In vi insertion mode, all characters not specifically men- |
| tioned are bound to sseellff--iinnsseerrtt. Characters assigned to signal genera- |
| tion by _s_t_t_y(1) or the terminal driver, such as C-Z or C-C, retain that |
| function. Upper and lower case metafied characters are bound to the |
| same function in the emacs mode meta keymap. The remaining characters |
| are unbound, which causes readline to ring the bell (subject to the |
| setting of the bbeellll--ssttyyllee variable). |
| |
| EEmmaaccss MMooddee |
| Emacs Standard bindings |
| |
| "C-@" set-mark |
| "C-A" beginning-of-line |
| "C-B" backward-char |
| "C-D" delete-char |
| "C-E" end-of-line |
| "C-F" forward-char |
| "C-G" abort |
| "C-H" backward-delete-char |
| "C-I" complete |
| "C-J" accept-line |
| "C-K" kill-line |
| "C-L" clear-screen |
| "C-M" accept-line |
| "C-N" next-history |
| "C-P" previous-history |
| "C-Q" quoted-insert |
| "C-R" reverse-search-history |
| "C-S" forward-search-history |
| "C-T" transpose-chars |
| "C-U" unix-line-discard |
| "C-V" quoted-insert |
| "C-W" unix-word-rubout |
| "C-Y" yank |
| "C-]" character-search |
| "C-_" undo |
| " " to "/" self-insert |
| "0" to "9" self-insert |
| ":" to "~" self-insert |
| "C-?" backward-delete-char |
| |
| Emacs Meta bindings |
| |
| "M-C-G" abort |
| "M-C-H" backward-kill-word |
| "M-C-I" tab-insert |
| "M-C-J" vi-editing-mode |
| "M-C-M" vi-editing-mode |
| "M-C-R" revert-line |
| "M-C-Y" yank-nth-arg |
| "M-C-[" complete |
| "M-C-]" character-search-backward |
| "M-space" set-mark |
| "M-#" insert-comment |
| "M-&" tilde-expand |
| "M-*" insert-completions |
| "M--" digit-argument |
| "M-." yank-last-arg |
| "M-0" digit-argument |
| "M-1" digit-argument |
| "M-2" digit-argument |
| "M-3" digit-argument |
| "M-4" digit-argument |
| "M-5" digit-argument |
| "M-6" digit-argument |
| "M-7" digit-argument |
| "M-8" digit-argument |
| "M-9" digit-argument |
| "M-<" beginning-of-history |
| "M-=" possible-completions |
| "M->" end-of-history |
| "M-?" possible-completions |
| "M-B" backward-word |
| "M-C" capitalize-word |
| "M-D" kill-word |
| "M-F" forward-word |
| "M-L" downcase-word |
| "M-N" non-incremental-forward-search-history |
| "M-P" non-incremental-reverse-search-history |
| "M-R" revert-line |
| "M-T" transpose-words |
| "M-U" upcase-word |
| "M-Y" yank-pop |
| "M-\" delete-horizontal-space |
| "M-~" tilde-expand |
| "M-C-?" backward-kill-word |
| "M-_" yank-last-arg |
| |
| Emacs Control-X bindings |
| |
| "C-XC-G" abort |
| "C-XC-R" re-read-init-file |
| "C-XC-U" undo |
| "C-XC-X" exchange-point-and-mark |
| "C-X(" start-kbd-macro |
| "C-X)" end-kbd-macro |
| "C-XE" call-last-kbd-macro |
| "C-XC-?" backward-kill-line |
| |
| |
| VVII MMooddee bbiinnddiinnggss |
| VI Insert Mode functions |
| |
| "C-D" vi-eof-maybe |
| "C-H" backward-delete-char |
| "C-I" complete |
| "C-J" accept-line |
| "C-M" accept-line |
| "C-R" reverse-search-history |
| "C-S" forward-search-history |
| "C-T" transpose-chars |
| "C-U" unix-line-discard |
| "C-V" quoted-insert |
| "C-W" unix-word-rubout |
| "C-Y" yank |
| "C-[" vi-movement-mode |
| "C-_" undo |
| " " to "~" self-insert |
| "C-?" backward-delete-char |
| |
| VI Command Mode functions |
| |
| "C-D" vi-eof-maybe |
| "C-E" emacs-editing-mode |
| "C-G" abort |
| "C-H" backward-char |
| "C-J" accept-line |
| "C-K" kill-line |
| "C-L" clear-screen |
| "C-M" accept-line |
| "C-N" next-history |
| "C-P" previous-history |
| "C-Q" quoted-insert |
| "C-R" reverse-search-history |
| "C-S" forward-search-history |
| "C-T" transpose-chars |
| "C-U" unix-line-discard |
| "C-V" quoted-insert |
| "C-W" unix-word-rubout |
| "C-Y" yank |
| "C-_" vi-undo |
| " " forward-char |
| "#" insert-comment |
| "$" end-of-line |
| "%" vi-match |
| "&" vi-tilde-expand |
| "*" vi-complete |
| "+" next-history |
| "," vi-char-search |
| "-" previous-history |
| "." vi-redo |
| "/" vi-search |
| "0" beginning-of-line |
| "1" to "9" vi-arg-digit |
| ";" vi-char-search |
| "=" vi-complete |
| "?" vi-search |
| "A" vi-append-eol |
| "B" vi-prev-word |
| "C" vi-change-to |
| "D" vi-delete-to |
| "E" vi-end-word |
| "F" vi-char-search |
| "G" vi-fetch-history |
| "I" vi-insert-beg |
| "N" vi-search-again |
| "P" vi-put |
| "R" vi-replace |
| "S" vi-subst |
| "T" vi-char-search |
| "U" revert-line |
| "W" vi-next-word |
| "X" backward-delete-char |
| "Y" vi-yank-to |
| "\" vi-complete |
| "^" vi-first-print |
| "_" vi-yank-arg |
| "`" vi-goto-mark |
| "a" vi-append-mode |
| "b" vi-prev-word |
| "c" vi-change-to |
| "d" vi-delete-to |
| "e" vi-end-word |
| "f" vi-char-search |
| "h" backward-char |
| "i" vi-insertion-mode |
| "j" next-history |
| "k" prev-history |
| "l" forward-char |
| "m" vi-set-mark |
| "n" vi-search-again |
| "p" vi-put |
| "r" vi-change-char |
| "s" vi-subst |
| "t" vi-char-search |
| "u" vi-undo |
| "w" vi-next-word |
| "x" vi-delete |
| "y" vi-yank-to |
| "|" vi-column |
| "~" vi-change-case |
| |
| SSEEEE AALLSSOO |
| _T_h_e _G_n_u _R_e_a_d_l_i_n_e _L_i_b_r_a_r_y, Brian Fox and Chet Ramey |
| _T_h_e _G_n_u _H_i_s_t_o_r_y _L_i_b_r_a_r_y, Brian Fox and Chet Ramey |
| _b_a_s_h(1) |
| |
| FFIILLEESS |
| _~_/_._i_n_p_u_t_r_c |
| Individual rreeaaddlliinnee initialization file |
| |
| AAUUTTHHOORRSS |
| Brian Fox, Free Software Foundation |
| bfox@gnu.org |
| |
| Chet Ramey, Case Western Reserve University |
| chet@ins.CWRU.Edu |
| |
| BBUUGG RREEPPOORRTTSS |
| If you find a bug in rreeaaddlliinnee,, you should report it. But first, you |
| should make sure that it really is a bug, and that it appears in the |
| latest version of the rreeaaddlliinnee library that you have. |
| |
| Once you have determined that a bug actually exists, mail a bug report |
| to _b_u_g_-_r_e_a_d_l_i_n_e@_g_n_u_._o_r_g. If you have a fix, you are welcome to mail |
| that as well! Suggestions and `philosophical' bug reports may be |
| mailed to _b_u_g_-_r_e_a_d_l_i_n_e@_g_n_u_._o_r_g or posted to the Usenet newsgroup |
| ggnnuu..bbaasshh..bbuugg. |
| |
| Comments and bug reports concerning this manual page should be directed |
| to _c_h_e_t_@_i_n_s_._C_W_R_U_._E_d_u. |
| |
| BBUUGGSS |
| It's too big and too slow. |
| |
| |
| |
| GNU Readline 5.1-beta1 2005 Sep 13 READLINE(3) |
