| EDITLINE(3) | Library Functions Manual | EDITLINE(3) | 
editline, el_init,
  el_init_fd, el_end,
  el_reset, el_gets,
  el_wgets, el_getc,
  el_wgetc, el_push,
  el_wpush, el_parse,
  el_wparse, el_set,
  el_wset, el_get,
  el_wget, el_source,
  el_resize, el_cursor,
  el_line, el_wline,
  el_insertstr, el_winsertstr,
  el_deletestr, el_wdeletestr,
  history_init, history_winit,
  history_end, history_wend,
  history, history_w,
  tok_init, tok_winit,
  tok_end, tok_wend,
  tok_reset, tok_wreset,
  tok_line, tok_wline,
  tok_str, tok_wstr —
#include <histedit.h>
EditLine *
  
  el_init(const
    char *prog, FILE
    *fin, FILE *fout,
    FILE *ferr);
EditLine *
  
  el_init_fd(const
    char *prog, FILE
    *fin, FILE *fout,
    FILE *ferr,
    int fdin,
    int fdout,
    int fderr);
void
  
  el_end(EditLine
    *e);
void
  
  el_reset(EditLine
    *e);
const char *
  
  el_gets(EditLine
    *e, int
  *count);
const wchar_t *
  
  el_wgets(EditLine
    *e, int
  *count);
int
  
  el_getc(EditLine
    *e, char *ch);
int
  
  el_wgetc(EditLine
    *e, wchar_t
  *wc);
void
  
  el_push(EditLine
    *e, const char
    *mbs);
void
  
  el_wpush(EditLine
    *e, const wchar_t
    *wcs);
int
  
  el_parse(EditLine
    *e, int argc,
    const char *argv[]);
int
  
  el_wparse(EditLine
    *e, int argc,
    const wchar_t
  *argv[]);
int
  
  el_set(EditLine
    *e, int op,
    ...);
int
  
  el_wset(EditLine
    *e, int op,
    ...);
int
  
  el_get(EditLine
    *e, int op,
    ...);
int
  
  el_wget(EditLine
    *e, int op,
    ...);
int
  
  el_source(EditLine
    *e, const char
    *file);
void
  
  el_resize(EditLine
    *e);
int
  
  el_cursor(EditLine
    *e, int count);
const LineInfo *
  
  el_line(EditLine
    *e);
const LineInfoW *
  
  el_wline(EditLine
    *e);
int
  
  el_insertstr(EditLine
    *e, const char
    *str);
int
  
  el_winsertstr(EditLine
    *e, const wchar_t
    *str);
void
  
  el_deletestr(EditLine
    *e, int count);
void
  
  el_wdeletestr(EditLine
    *e, int count);
History *
  
  history_init(void);
HistoryW *
  
  history_winit(void);
void
  
  history_end(History
    *h);
void
  
  history_wend(HistoryW
    *h);
int
  
  history(History
    *h, HistEvent *ev,
    int op,
    ...);
int
  
  history_w(HistoryW
    *h, HistEventW *ev,
    int op,
    ...);
Tokenizer *
  
  tok_init(const
    char *IFS);
TokenizerW *
  
  tok_winit(const
    wchar_t *IFS);
void
  
  tok_end(Tokenizer
    *t);
void
  
  tok_wend(TokenizerW
    *t);
void
  
  tok_reset(Tokenizer
    *t);
void
  
  tok_wreset(TokenizerW
    *t);
int
  
  tok_line(Tokenizer
    *t, const LineInfo
    *li, int *argc,
    const char **argv[],
    int *cursorc,
    int *cursoro);
int
  
  tok_wline(TokenizerW
    *t, const LineInfoW
    *li, int *argc,
    const wchar_t **argv[],
    int *cursorc,
    int *cursoro);
int
  
  tok_str(Tokenizer
    *t, const char
    *str, int *argc,
    const char **argv[]);
int
  
  tok_wstr(TokenizerW
    *t, const wchar_t
    *str, int *argc,
    const wchar_t
  **argv[]);
editline library provides generic line editing,
  history and tokenization functions, similar to those found in
  sh(1).
These functions are available in the
    libedit library (which needs the
    libtermcap library). Programs should be linked with
    -ledit -ltermcap.
The editline library respects the
    LC_CTYPE locale set by the application program and
    never uses setlocale(3) to
    change the locale.
el_init() or el_init_fd() and
  freed by el_end().
The wide-character functions behave the same way as their narrow counterparts.
The following functions are available:
el_init()NULL on failure.
      prog is the name of the invoking program, used when
      reading the editrc(5) file
      to determine which settings to use. fin,
      fout and ferr are the input,
      output, and error streams (respectively) to use. In this documentation,
      references to “the tty” are actually to this input/output
      stream combination.el_init_fd()el_init() but allows specifying file
      descriptors for the stdio(3)
      corresponding streams, in case those were created with
      funopen(3).el_end()el_init() or
      el_init_fd().el_reset()el_gets()NULL if no characters were read or
      if an error occurred. If an error occurred, count is
      set to -1 and errno contains the error code that
      caused it. The return value may not remain valid across calls to
      el_gets() and must be copied if the data is to be
      retained.el_wgetc()EILSEQ, and
      the next character is read and stored in wc. Returns
      1 if a valid character was read, 0 on end of file, or -1 on
      read(2) failure. In the latter
      case, errno is set to indicate the error.el_getc()el_wgetc()
      and return 0 on end of file or -1 on failure. If the wide character can be
      represented as a single-byte character, convert it with
      wctob(3), store the result in
      ch, and return 1; otherwise, set
      errno to ERANGE and return
      -1. In the C or POSIX locale, this simply reads a byte, but for any other
      locale, including UTF-8, this is rarely useful.el_wpush()NULL or memory allocation fails, the function
      beeps at the user, but does not report the problem to the caller.el_push()el_wpush().el_parse()editline commands. If the command is prefixed with
      “prog”: then el_parse() will only
      execute the command if “prog” matches the
      prog argument supplied to
      el_init(). The return value is -1 if the command
      is unknown, 0 if there was no error or “prog” didn't match,
      or 1 if the command returned an error. Refer to
      editrc(5) for more
      information.el_set()editline parameters. op
      determines which parameter to set, and each operation has its own
      parameter list. Returns 0 on success, -1 on failure.
    The following values for op are supported, along with the required argument list:
EL_PROMPT,
        char *(*f)(EditLine *)EL_PROMPT_ESC,
        char *(*f)(EditLine *), char
        cEL_PROMPT, but the
          c argument indicates the start/stop literal
          prompt character.
        If a start/stop literal character is found in the prompt,
            the character itself is not printed, but characters after it are
            printed directly to the terminal without affecting the state of the
            current line. A subsequent second start/stop literal character ends
            this behavior. This is typically used to embed literal escape
            sequences that change the color/style of the terminal in the prompt.
            Note that the literal escape character cannot be the last character
            in the prompt, as the escape sequence is attached to the next
            character in the prompt. 0 unsets it.
EL_REFRESHEL_RPROMPT,
        char *(*f)(EditLine *)EL_RPROMPT_ESC,
        char *(*f)(EditLine *), char
        cEL_TERMINAL,
        const char *typeTERM if type is
          NULL.EL_EDITOR,
        const char *modeEL_SIGNAL,
        int flageditline will install its own signal handler
          for the following signals when reading command input:
          SIGCONT, SIGHUP,
          SIGINT, SIGQUIT,
          SIGSTOP, SIGTERM,
          SIGTSTP, and SIGWINCH.
          Otherwise, the current signal handlers will be used.EL_BIND,
        const char *, ...,
        NULLbind builtin command. Refer to
          editrc(5) for more
          information.EL_ECHOTC,
        const char *, ...,
        NULLechotc builtin command. Refer to
          editrc(5) for more
          information.EL_SETTC,
        const char *, ...,
        NULLsettc builtin command. Refer to
          editrc(5) for more
          information.EL_SETTY,
        const char *, ...,
        NULLsetty builtin command. Refer to
          editrc(5) for more
          information.EL_TELLTC,
        const char *, ...,
        NULLtelltc builtin command. Refer to
          editrc(5) for more
          information.EL_ADDFN,
        const char *name, const char
        *help, unsigned char (*func)(EditLine *e, int
        ch)func(), referred
          to as name which is invoked when a key which is
          bound to name is entered.
          help is a description of
          name. At invocation time,
          ch is the key which caused the invocation. The
          return value of func() should be one of:
        CC_NORMCC_NEWLINECC_EOFCC_ARGHACKCC_REFRESHCC_REFRESH_BEEPCC_CURSORCC_REFRESH.CC_REDISPLAYCC_ERRORCC_FATALEL_HIST,
        History *(*func)(History *, int op, ...),
        const char *ptrhistory(). ptr should be
          the value returned by history_init().EL_EDITMODE,
        int flageditline. At this time, it is
          the caller's responsibility to check this (using
          el_get()) to determine if editing should be
          enabled or not.EL_UNBUFFERED,
        int flagel_gets()
          will return immediately after processing a single character.EL_GETCFN,
        el_rfunc_t ff(EditLine *e,
          wchar_t *wc);el_wgets(),
          el_wgetc(), el_gets(),
          and el_getc(). Initially, a builtin function
          is installed, and replacing it is discouraged because writing such a
          function is very error prone. The builtin function can be restored at
          any time by passing the special value
          EL_BUILTIN_GETCFN instead of a function
          pointer.EL_CLIENTDATA,
        void *datael_get() call.EL_SETFP,
        int fd, FILE *fpeditline file pointer for
          “input” fd =
          0, “output”
          fd = 1, or
          “error” fd =
          2 from fp.el_get()editline parameters. op
      determines which parameter to retrieve into result.
      Returns 0 if successful, -1 otherwise.
    The following values for op are supported, along with actual type of result:
EL_PROMPT,
        char *(*f)(EditLine *), char
        *cNULL, set it to the start/stop literal prompt
          character.EL_RPROMPT,
        char *(*f)(EditLine *), char
        *cNULL, set it to the start/stop literal prompt
          character.EL_EDITOR,
        const char **nEL_GETTC,
        const char *name, void
        *valueEL_SIGNAL,
        int *seditline has installed private signal handlers
          (see el_get() above).EL_EDITMODE,
        int *cEL_GETCFN,
        el_rfunc_t *fEL_BUILTIN_GETCFN if the
          builtin function is in use.EL_CLIENTDATA,
        void **datael_set() call.EL_UNBUFFERED,
        int *cEL_GETFP,
        int fd, FILE **fpeditline file pointer for
          “input” fd =
          0, “output”
          fd = 1, or
          “error” fd =
          2.el_source()editline by reading the contents of
      file. el_parse() is called
      for each line in file. If file
      is NULL, try $EDITRC and
      if that is not set $HOME/.editrc. Refer to
      editrc(5) for details on the
      format of file. el_source()
      returns 0 on success and -1 on error.el_resize()EL_SIGNAL has been set with
      el_set(), then this is done automatically.
      Otherwise, it's the responsibility of the application to call
      el_resize() on the appropriate occasions.el_cursor()el_line()
typedef struct lineinfo {
    const char *buffer;    /* address of buffer */
    const char *cursor;    /* address of cursor */
    const char *lastchar;  /* address of last character */
} LineInfo;
    
    buffer is not NUL terminated. This
        function may be called after el_gets() to obtain
        the LineInfo structure pertaining to line returned
        by that function, and from within user defined functions added with
        EL_ADDFN.
el_insertstr()el_deletestr()history_init() and freed by
  history_end().
The following functions are available:
history_init()NULL on
    failure.history_end()history_init().history()H_SETSIZE,
        int sizeH_GETSIZEH_ENDhistory_init().H_CLEARH_FUNC,
        void *ptr, history_gfun_t
        first, history_gfun_t next,
        history_gfun_t last,
        history_gfun_t prev,
        history_gfun_t curr,
        history_sfun_t set, history_vfun_t
        clear, history_efun_t enter,
        history_efun_t addH_FIRSTH_LASTH_PREVH_NEXTH_CURRH_SET,
        int positionH_ADD,
        const char *strH_ENTER operation with
          argument str if there is no current
        element.H_APPEND,
        const char *strH_ENTER,
        const char *strH_SETUNIQUE has been called with a
          non-zero argument, the element will not be entered into the history if
          its contents match the ones of the current history element. If the
          element is entered history() returns 1; if it
          is ignored as a duplicate returns 0. Finally
          history() returns -1 if an error
        occurred.H_PREV_STR,
        const char *strH_NEXT_STR,
        const char *strH_PREV_EVENT,
        int eH_NEXT_EVENT,
        int eH_LOAD,
        const char *fileH_SAVE,
        const char *fileH_SAVE_FP,
        FILE *fpH_NSAVE_FP,
        size_t n, FILE *fpH_SETUNIQUE,
        int uniqueH_GETUNIQUEH_DEL,
        int ereadline compatibility. The
          caller is responsible for free'ing the string in the returned
          HistEvent.history() returns >= 0 if the
        operation op succeeds. Otherwise, -1 is returned
        and ev is updated to contain more details about
        the error.
tok_init() and freed by
  tok_end().
The following functions are available:
tok_init()NULL.tok_end()tok_init().tok_reset()tok_line() or
      tok_str() and before a new line is to be
      tokenized.tok_line()NULL) to
      contain the index of the word containing the cursor, and
      cursoro (if not NULL) to
      contain the offset within argv[cursorc] of the
      cursor.
    Returns 0 if successful, -1 for an internal error, 1 for an unmatched single quote, 2 for an unmatched double quote, and 3 for a backslash quoted ⟨newline⟩. A positive exit code indicates that another line should be read and tokenization attempted again.
tok_str()tok_line();
      str is a NUL terminated string to tokenize.editline library first appeared in
  4.4BSD. CC_REDISPLAY appeared
  in NetBSD 1.3.
  CC_REFRESH_BEEP, EL_EDITMODE
  and the readline emulation appeared in NetBSD 1.4.
  EL_RPROMPT appeared in NetBSD
  1.5.
editline library was written by
  Christos Zoulas. Luke Mewburn
  wrote this manual and implemented CC_REDISPLAY,
  CC_REFRESH_BEEP, EL_EDITMODE,
  and EL_RPROMPT. Jaromir
  Dolecek implemented the readline emulation. Johny
  Mattsson implemented wide-character support.
EL_EDITMODE operation of
  el_get() (after an el_source()
  or el_parse()) to determine if
  editline should be used for further input. I.e.,
  EL_EDITMODE is purely an indication of the result of
  the most recent editrc(5)
  edit command.
| November 9, 2018 | NetBSD 9.4 |