[Top][All Lists]

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

grep and sed in guile

From: Stefan Israelsson Tampe
Subject: grep and sed in guile
Date: Sun, 25 Aug 2013 23:32:19 +0200
User-agent: KMail/4.9.5 (Linux/3.5.0-30-generic; KDE/4.9.5; x86_64; ; )

Hi all,

This small discussion refers to the current head of the guile-log
branch. When the parser framework is rich enough I will issue a new 
release of it.

As you know I'm currently working with guile-log to attach decent
parser tools in for anyone wanting to do parsing in a logic
programming environment. My next task have been to develop grep and
sed like tools using the parser framework. This is now successful and
I would ask for what features will be needed for it to be good enough.
This will be a kind of testbed to develop the parser further.

So, the background is that we designed a regular expressions like 
functionality via e.g. 

    (s-and m1 ... mn)  m1 ... and mn must both match mn is used for 
                       the stream
    s-and!             the same as s-and but only successes one time
    (s-seq m1 m2 ...)  m1 match then m2 match ...
    (s-or  m1 m2 ...)  m1 match else m2 match else
    s-or!              the same as s-or but successes only one time

    (s-not m)          if m does not match then consume one character
     s-not!            the same as s-not but will store the character
     pr-not            the same as s-not but prints the character to

    (s-tag tag)        (s-tag a)  matches a, (s-tag "a") matches a
     s-tag!            the same as s-tag, but stores the character
    pr-tag             the sa,e as s-tag, but prints the character to

    (s-reg pat)        (s-ref ".") matches any character the pattern
                        should be a regular expression matching one
     s-reg! pr-reg     as above
With this basic regular expressions can be built.

Currently the grep and sed facilities comes in

1) (grep m expr #:key (a 0) (b 0) (c 0))

the standard output of the expr is captured by grep and if the matcher
m matches starting at line i, then lines:

   (- i (max a c)) -> (+ i (max b c))

will be printed

2) (par-grep m expr #:key (a 0) (b 0) (c 0) (d 0))

This grepper knows about scheme code and will work basically the same
but print the lines containing the form including the matched sentence
and d enclosing forms above. a b c is as before but now defines the
extra lines printed appart from the target form.


scheme@(guile-user)> (par-grep (s-tag x) (f1) #:d 0)
(a (b c "x  

scheme@(guile-user)> (par-grep (s-tag x) (f1) #:d 1)
(a (b c "x  
   (d e)
   (b (f g h)))

3) (sed m expr)

This will print out on std output all lines not matched by m, if m is
matched then that expr will make sure to print the correct way

An example matcher is 
  m := (s-tr a b) 

which will replace a by b

4) (par-sed m expr)
This is the same as sed but knows about scheme. There is nothing 
with this right know.

Have fun!

reply via email to

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