DOC HOME SITE MAP MAN PAGES GNU INFO SEARCH PRINT BOOK
 

(guile.info.gz) Expect

Info Catalog (guile.info.gz) Rx Regexps (guile.info.gz) Top (guile.info.gz) The Scheme shell (scsh)
 
 45 Expect
 *********
 
 The macros in this section are made available with:
 
      (use-modules (ice-9 expect))
 
    `expect' is a macro for selecting actions based on the output from a
 port.  The name comes from a tool of similar functionality by Don Libes.
 Actions can be taken when a particular string is matched, when a timeout
 occurs, or when end-of-file is seen on the port.  The `expect' macro is
 described below; `expect-strings' is a front-end to `expect' based on
 regexec (see the regular expression documentation).
 
  -- Macro: expect-strings clause ...
      By default, `expect-strings' will read from the current input port.
      The first term in each clause consists of an expression evaluating
      to a string pattern (regular expression).  As characters are read
      one-by-one from the port, they are accumulated in a buffer string
      which is matched against each of the patterns.  When a pattern
      matches, the remaining expression(s) in the clause are evaluated
      and the value of the last is returned.  For example:
 
           (with-input-from-file "/etc/passwd"
             (lambda ()
               (expect-strings
                 ("^nobody" (display "Got a nobody user.\n")
                            (display "That's no problem.\n"))
                 ("^daemon" (display "Got a daemon user.\n")))))
 
      The regular expression is compiled with the `REG_NEWLINE' flag, so
      that the ^ and $ anchors will match at any newline, not just at
      the start and end of the string.
 
      There are two other ways to write a clause:
 
      The expression(s) to evaluate can be omitted, in which case the
      result of the regular expression match (converted to strings, as
      obtained from regexec with match-pick set to "") will be returned
      if the pattern matches.
 
      The symbol `=>' can be used to indicate that the expression is a
      procedure which will accept the result of a successful regular
      expression match.  E.g.,
 
           ("^daemon" => write)
           ("^d\\(aemon\\)" => (lambda args (for-each write args)))
           ("^da\\(em\\)on" => (lambda (all sub)
                                    (write all) (newline)
                                    (write sub) (newline)))
 
      The order of the substrings corresponds to the order in which the
      opening brackets occur.
 
      A number of variables can be used to control the behaviour of
      `expect' (and `expect-strings').  Most have default top-level
      bindings to the value `#f', which produces the default behaviour.
      They can be redefined at the top level or locally bound in a form
      enclosing the expect expression.
 
     `expect-port'
           A port to read characters from, instead of the current input
           port.
 
     `expect-timeout'
           `expect' will terminate after this number of seconds,
           returning `#f' or the value returned by expect-timeout-proc.
 
     `expect-timeout-proc'
           A procedure called if timeout occurs.  The procedure takes a
           single argument: the accumulated string.
 
     `expect-eof-proc'
           A procedure called if end-of-file is detected on the input
           port.  The procedure takes a single argument: the accumulated
           string.
 
     `expect-char-proc'
           A procedure to be called every time a character is read from
           the port.  The procedure takes a single argument: the
           character which was read.
 
     `expect-strings-compile-flags'
           Flags to be used when compiling a regular expression, which
           are passed to `make-regexp'  Regexp Functions.  The
           default value is `regexp/newline'.
 
     `expect-strings-exec-flags'
           Flags to be used when executing a regular expression, which
           are passed to regexp-exec  Regexp Functions.  The
           default value is `regexp/noteol', which prevents `$' from
           matching the end of the string while it is still accumulating,
           but still allows it to match after a line break or at the end
           of file.
 
      Here's an example using all of the variables:
 
           (let ((expect-port (open-input-file "/etc/passwd"))
                 (expect-timeout 1)
                 (expect-timeout-proc
                   (lambda (s) (display "Times up!\n")))
                 (expect-eof-proc
                   (lambda (s) (display "Reached the end of the file!\n")))
                 (expect-char-proc display)
                 (expect-strings-compile-flags (logior regexp/newline regexp/icase))
                 (expect-strings-exec-flags 0))
              (expect-strings
                ("^nobody"  (display "Got a nobody user\n"))))
 
  -- Macro: expect clause ...
      `expect' is used in the same way as `expect-strings', but tests
      are specified not as patterns, but as procedures.  The procedures
      are called in turn after each character is read from the port,
      with two arguments: the value of the accumulated string and a flag
      to indicate whether end-of-file has been reached.  The flag will
      usually be `#f', but if end-of-file is reached, the procedures are
      called an additional time with the final accumulated string and
      `#t'.
 
      The test is successful if the procedure returns a non-false value.
 
      If the `=>' syntax is used, then if the test succeeds it must
      return a list containing the arguments to be provided to the
      corresponding expression.
 
      In the following example, a string will only be matched at the
      beginning of the file:
 
           (let ((expect-port (open-input-file "/etc/passwd")))
             (expect
                ((lambda (s eof?) (string=? s "fnord!"))
                   (display "Got a nobody user!\n"))))
 
      The control variables described for `expect-strings' also
      influence the behaviour of `expect', with the exception of
      variables whose names begin with `expect-strings-'.
 
Info Catalog (guile.info.gz) Rx Regexps (guile.info.gz) Top (guile.info.gz) The Scheme shell (scsh)
automatically generated byinfo2html