[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Guile-Lib 0.2.5 released

From: Matt Wette
Subject: Re: Guile-Lib 0.2.5 released
Date: Thu, 19 Jan 2017 05:53:56 -0800

> On Jan 18, 2017, at 12:46 PM, David Pirotte <address@hidden> wrote:
> Hello,
> We are pleased to announce Guile-Lib 0.2.5. This is a maintenance release, 
> the next
> maintenance release for the 0.2 series.
> * Guile-Lib Homepage: 

If you are willing to accept contributions, maybe add logistics for that to the 
home page.  I have a couple I would like to add.  See below. — Matt

Here are a couple I could contribute, if you are interested:

1.1 Struct Module

The '(struct)' module provides procedures for packing and unpacking
scheme data to and from bytevectors based on a format string.

     (use-modules (struct))

     ;; pack two unsigned shorts and a double float in big endian order
     (define data (pack ">2Hd" 3 22 34.0))
     (write data) (newline)
     #vu8(0 3 0 22 64 65 0 0 0 0 0 0)

     ;; verify using unpack
     (write (unpack ">2Hd" data)) (newline)
     (3 22 34.0)

 -- Scheme Procedure: pack format vals ...
     Return a bytevector that contains encoded data from VALS, based on
     the string FORMAT.

 -- Scheme Procedure: unpack format bvec
     Return a list of scheme objects decoded from the bytevector BVEC,
     based on the string FORMAT.

 -- Scheme Procedure: packed-size format
     Return the number of bytes represented by the string FORMAT.

   The _format_ string used for PACK and UNPACK is constructed as a
sequence of digits, representing a repeat count, and codes, representing
the binary content.

The string may optionally begin with a special character that represents
the endianness:
    =        native endianness
    <        little-endian
    >        big-endian
    !        network order -- i.e., big-endian

Type codes used in the format string are interpreted as follows:
    x        blank byte
    c        8-bit character
    ?        boolean
    b        signed 8-bit integer
    B        unsigned 8-bit integer
    h        signed 16-bit integer
    H        unsigned 16-bit integer
    i        signed 32-bit integer
    I        unsigned 32-bit integer
    l        signed 32-bit integer
    L        unsigned 32-bit integer
    q        signed 64-bit integer
    Q        unsigned 64-bit integer
    f        32-bit IEEE floating point
    d        64-bit IEEE floating point
    s        string

   The following issues remain to be addressed:
string padding
     'pack' assumes that the string length in the format is the same as
     in the passed string.  Non-conformance is not trapped as an error.


Regexp Utilities

 -- Scheme Procedure: regexp-case str case ... [else body]
     Match the string STR against each CASE in turn.  Each CASE is of
     the form
          ((pat VAR1 VAR2 ...)
     where pat is a regular expression string literal, VAR1 ... are
     bound to the ordered list of matched subexpressions, and BODY is a
     sequence of expressions.  If no match is found and the optional
     ELSE case exists, the associated body is executed, otherwise an
     error is signaled.

   The following example matches a string aginst either a simple
variable name, or a simple variable name with an array reference, and
returns a list with the variable name and the string index, or '"1"'.
If no match is found, '#f' is returned.

     (define str "foo")
     (regexp-case str
      (("^([a-z]+)\\(([0-9]+)\\)$" var idx)
       (list var idx))
      (("^([a-z]+)$" var)
       (list var "1"))
      (else #f))
     ("foo" "1")

 -- Scheme Procedure: make-string-matcher (str ...) case ... [else body]
     This is similar to 'regexp-case' but generates a procedure '(lambda
     (str ...) ...)' that matches its string argument STR againt each
     CASE in turn.

     (define my-matcher
       (make-string-matcher (str a b c)
        (("^([a-z]+)\\(([0-9]+)\\)$" var idx)
         (list var idx))
        (("^([a-z]+)$" var)
         (list var "1"))
        (else #f))

reply via email to

[Prev in Thread] Current Thread [Next in Thread]