| 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-2002 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 allo- |
| cated with _m_a_l_l_o_c(3); the caller must free it when fin- |
| ished. 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 addi- |
| tional 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 Con- |
| trol-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 Con- |
| trol 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 argu- |
| ments 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 initial- |
| ization 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 comments. 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 specified 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 uunniivveerr-- |
| ssaall--aarrgguummeenntt, _M_-_D_E_L is bound to the function bbaacckk-- |
| wwaarrdd--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, kkeeyy-- |
| sseeqq 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 uunnii-- |
| vveerrssaall--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 specifying 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. Back- |
| slash will quote any other character in the macro text, |
| including " and '. |
| |
| BBaasshh allows the current readline key bindings to be dis- |
| played or modified with the bbiinndd builtin command. The |
| editing mode may be switched during interactive use by |
| using the --oo option to the sseett builtin command. 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 provide any other means to incorporate new bind- |
| ings. |
| |
| VVaarriiaabblleess |
| Readline has variables that can be used to further cus- |
| tomize its behavior. 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). 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 aauuddii-- |
| bbllee, readline attempts to ring the terminal's bell. |
| 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 com- |
| mand 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 number of possible completions gener- |
| ated by the ppoossssiibbllee--ccoommpplleettiioonnss 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 vari- |
| able, the user is asked whether or not he wishes to |
| view them; otherwise they are simply listed on the |
| terminal. |
| 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 comple- |
| tion. 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 similar 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 keypad 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 |
| If set to oonn, the history code attempts to place |
| point at the same location on each history line |
| retrived with pprreevviioouuss--hhiissttoorryy 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 termi- |
| nal 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 command. If this variable has |
| not been given a value, the characters _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 displayed with a preceding asterisk (**). |
| mmaarrkk--ssyymmlliinnkkeedd--ddiirreeccttoorriieess ((OOffff)) |
| If set to OOnn, completed names which are symbolic |
| links to directories 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 display a screenful of possible comple- |
| tions 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. |
| 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 completions. |
| |
| 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 per- |
| formed as the result of tests. There are four parser |
| directives used. |
| |
| $$iiff The $$iiff construct allows bindings to be made based |
| on the editing 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 termi- |
| nal-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 use- |
| ful 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, ter- |
| minates 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 argu- |
| ment and reads commands and bindings from that |
| file. For example, the following 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 com- |
| mand 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, readline 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 his- |
| tory for a particular string, type CC--rr. Typing CC--ss |
| searches forward through the history. The characters pre- |
| sent 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 charac- |
| ters 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 com- |
| mand from the history list. A movement command will ter- |
| minate 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. Com- |
| mand names without an accompanying key sequence are |
| unbound by default. |
| |
| In the following descriptions, _p_o_i_n_t refers to the current |
| cursor position, and _m_a_r_k refers to a cursor position |
| saved by the sseett--mmaarrkk command. 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 charac- |
| ters (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, mov- |
| ing 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 previ- |
| ous command begin with word 0). A negative argu- |
| ment inserts the _nth word from the end of the pre- |
| vious command. |
| 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. |
| |
| 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 cursor 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. Nega- |
| tive 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 argument, 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 over- |
| write mode, characters 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 ffoorr-- |
| wwaarrdd--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 boundary. 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 position). 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 boundaries 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 following yyaannkk or yyaannkk--ppoopp. |
| |
| NNuummeerriicc AArrgguummeennttss |
| ddiiggiitt--aarrgguummeenntt ((MM--00,, MM--11,, ......,, MM----)) |
| Add this digit to the argument already accumulat- |
| ing, or start a new argument. M-- starts a nega- |
| tive 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 followed by |
| digits, executing uunniivveerrssaall--aarrgguummeenntt again ends the |
| numeric argument, but is otherwise ignored. As a |
| special case, if this command is immediately fol- |
| lowed 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 ini- |
| tially one, so executing this function the first |
| time makes the argument 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 applica- |
| tion-specific. BBaasshh, for instance, attempts com- |
| pletion 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 comple- |
| tion 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--ccoommppllee-- |
| ttiioonnss. |
| mmeennuu--ccoommpplleettee |
| Similar to ccoommpplleettee, but replaces the word to be |
| completed with a single match from the list of pos- |
| sible completions. Repeated execution of mmeennuu--ccoomm-- |
| pplleettee steps through the list of possible comple- |
| tions, inserting each match in turn. At the end of |
| the list of completions, the bell is rung (subject |
| to the setting of 00aanndd tthhee oorriiggiinnaall tteexxtt iiss |
| rreessttoorreedd.. AAnn aarrgguummeenntt ooff _n mmoovveess _n ppoossiittiioonnss ffoorr-- |
| wwaarrdd iinn tthhee lliisstt ooff mmaattcchheess;; aa nneeggaattiivvee aarrgguummeenntt |
| mmaayy bbee uusseedd ttoo mmoovvee bbaacckkwwaarrdd tthhrroouugghh tthhee lliisstt.. |
| TThhiiss ccoommmmaanndd iiss iinntteennddeedd ttoo bbee bboouunndd ttoo TTAABB,, bbuutt iiss |
| uunnbboouunndd bbyy ddeeffaauulltt.. |
| 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 identi- |
| cally 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 mak- |
| ing the characters 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 ter- |
| minal'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 upper- |
| case character. |
| pprreeffiixx--mmeettaa ((EESSCC)) |
| Metafy the next character typed. EESSCC ff is equiva- |
| lent 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 occurrences. |
| cchhaarraacctteerr--sseeaarrcchh--bbaacckkwwaarrdd ((MM--CC--]])) |
| A character is read and point is moved to the pre- |
| vious occurrence of that character. A negative |
| count searches for subsequent occurrences. |
| iinnsseerrtt--ccoommmmeenntt ((MM--##)) |
| Without a numeric argument, the value of the read- |
| line ccoommmmeenntt--bbeeggiinn variable is inserted at the |
| beginning of the current line. If a numeric argu- |
| ment 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, otherwise the characters in ccoommmmeenntt--bbeeggiinn |
| are deleted from the beginning 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 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--vvaarriiaabblleess |
| Print all of the settable variables and their val- |
| ues 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 ouput. 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 bind- |
| ings. Characters 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 mentioned are bound to sseellff--iinnsseerrtt. Charac- |
| ters assigned to signal generation by _s_t_t_y(1) or the ter- |
| minal 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 remain- |
| ing characters are unbound, which causes readline to ring |
| the bell (subject to the setting of the bbeellll--ssttyyllee vari- |
| able). |
| |
| 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 4.3 2002 January 22 READLINE(3) |
