The proc-parse Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The proc-parse Reference Manual

This is the proc-parse Reference Manual, version 0.1, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 04:26:22 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Proc-Parse

Build Status Coverage Status

Question: Are these parser macros for speed or just to make your application look cool?
Answer: Both.

This is a string/octets parser library for Common Lisp with speed and readability in mind. Unlike other libraries, the code is not a pattern-matching-like, but a char-by-char procedural parser.

Although the design is good for speed, the code could look ugly with tagbody and go. Proc-Parse wraps the code with sexy macros.

I believe we don't have to give up speed for the readability while we use Common Lisp.

Usage

(defun parse-url-scheme (data &key (start 0) end)
  "Return a URL scheme of DATA as a string."
  (declare (optimize (speed 3) (safety 0) (debug 0)))
  (block nil
    (with-vector-parsing (data :start start :end end)
      (match-i-case
       ("http:" (return "http"))
       ("https:" (return "https"))
       (otherwise (unless (standard-alpha-char-p (current))
                    (return nil))
                  (bind (scheme (skip* (not #\:)))
                    (return scheme)))))))

API

with-vector-parsing

(with-vector-parsing ("It's Tuesday!" :start 5 :end 12)
  (bind (str (skip-until
              (lambda (c)
                (declare (ignore c))
                (eofp))))
    (print str))) ; "Tuesday"

(with-vector-parsing ((babel:string-to-octets "It's Tuesday!") :start 5 :end 12)
  (bind (str (skip-until
              (lambda (c)
                (declare (ignore c))
                (eofp))))
    (print str))) ; "Tuesday"

with-string-parsing

(with-string-parsing ("It's Tuesday!" :start 5 :end 12)
  (bind (str (skip-until
              (lambda (c)
                (declare (ignore c))
                (eofp))))
    (print str))) ; "Tuesday"

with-octets-parsing

(with-octets-parsing ((babel:string-to-octets "It's Tuesday!") :start 5 :end 12)
  (bind (str (skip-until
              (lambda (c)
                (declare (ignore c))
                (eofp))))
    (print str))) ; "Tuesday"

eofp

(with-vector-parsing ("hello")
  (print (eofp)) ; NIL
  (match "hello")
  (print (eofp))) ; T

current

(with-vector-parsing ("hello")
  (print (current)) ; #\h
  (skip #\h)
  (print (current))) ; #\e

peek

(with-vector-parsing ("hello")
  (print (current)) ; #\h
  (print (peek)) ; #\e
  (print (current))) ; #\h
(with-vector-parsing ("hello")
  (match "hell")
  (print (pos)) ; #\4
  (print (peek :eof-value 'yes))) ; YES

pos

(with-vector-parsing ("hello")
  (print (pos)) ; 0
  (skip #\h)
  (print (pos))) ; 1

advance

(with-vector-parsing ("hello")
  (print (current)) ; #\h
  (advance)
  (print (current)) ; #\e
  (match "ello")
  (print (current)) ; #\o
  (advance)
  (print "Hi")) ; "Hi" won't displayed.

advance*

(with-vector-parsing ("hello")
  (print (current)) ; #\h
  (advance*)
  (print (current)) ; #\e
  (match "ello")
  (print (current)) ; #\o
  (advance*)
  (print (current)) ; #\o
  (print "Hi")) ; "Hi"

skip

(with-vector-parsing ("hello")
  (print (current)) ; #\h
  (skip #\h)
  (print (current)) ; #\e
  (skip (not #\h))
  (print (current)) ; #\l
  (skip #\f))
;; => Condition MATCH-FAILED was signalled.

skip*

(with-vector-parsing ("hello")
  (skip* #\h)
  (print (current)) ; #\e
  (skip* (not #\l))
  (print (current)) ; #\l
  (skip* #\l)
  (print (current)) ; #\o
  (skip* #\f)) ; MATCH-FAILED won't be raised.

skip+

(with-vector-parsing ("hello")
  (skip+ #\h)
  (print (current)) ; #\e
  (skip* (not #\l))
  (print (current)) ; #\l
  (skip+ #\l)
  (print (current)) ; #\o
  (skip+ #\f))
;; => Condition MATCH-FAILED was signalled.

skip?

(with-vector-parsing ("hello")
  (print (current)) ; #\h
  (skip? #\h)
  (print (current)) ; #\e
  (skip? (not #\h))
  (print (current)) ; #\l
  (skip? #\f)) ; MATCH-FAILED won't be raised.

skip-until

(with-vector-parsing ("hello")
  (skip-until (lambda (char) (char= char #\o)))
  (print (current)) ; #\o
  (print (eofp)) ; NIL
  (skip-until (lambda (char) (char= char #\f)))
  (print (eofp))) ; T

skip-while

(with-vector-parsing ("hello")
  (skip-while (lambda (char) (char/= char #\o)))
  (print (current)) ; #\o
  (print (eofp)) ; NIL
  (skip-while (lambda (char) (char/= char #\f)))
  (print (eofp))) ; T

bind

(with-vector-parsing ("hello")
  (bind (str1 (skip-until (lambda (c) (char= c #\l))))
    (print str1)) ; "he"
  (bind (str2 (skip* (not #\f)))
    (print str2))) ; "llo"

match

(with-vector-parsing ("hello")
  (match "he")
  (print (current)) ; #\l
  (match "l" "ll")
  (print (current)) ; #\o
  (match "f"))
;; => Condition MATCH-FAILED was signalled.

match-i

(with-vector-parsing ("hello")
  (match-i "He")
  (print (current)) ; #\l
  (match-i "L" "LL")
  (print (current)) ; #\o
  (match-i "F"))
;; => Condition MATCH-FAILED was signalled.

match?

(with-vector-parsing ("hello")
  (match? "he")
  (print (current)) ; #\l
  (match? "l" "ll")
  (print (current)) ; #\o
  (match? "f")) ; MATCH-FAILED won't be raised.

match-case

(with-vector-parsing ("hello")
  (match-case
   ("he" (print 0))
   ("ll" (print 1))
   (otherwise (print 2))) ; 0
  (print (current)) ; #\l
  (match-case
   ("he" (print 0))
   ("ll" (print 1))
   (otherwise (print 2))) ; 1
  (print (current)) ; #\o
  (match-case
   ("he" (print 0))
   ("ll" (print 1))
   (otherwise (print 2))) ; 2
  (print (current)) ; #\o
  (match-case
   ("he" (print 0))
   ("ll" (print 1))))
;; => Condition MATCH-FAILED was signalled.

(with-vector-parsing ("hello")
  (print
   (match-case
    ("hello" 0))) ;; Nothing will be printed.
  (print "It shold not be printed.")) ;; Nothing will be printed.
;; => NIL

match-i-case

(with-vector-parsing ("hello")
  (match-i-case
   ("He" (print 0))
   ("LL" (print 1))
   (otherwise (print 2))) ; 0
  (print (current)) ; #\l
  (match-i-case
   ("He" (print 0))
   ("LL" (print 1))
   (otherwise (print 2))) ; 1
  (print (current)) ; #\o
  (match-i-case
   ("He" (print 0))
   ("LL" (print 1))
   (otherwise (print 2))) ; 2
  (print (current)) ; #\o
  (match-i-case
   ("He" (print 0))
   ("LL" (print 1))))
;; => Condition MATCH-FAILED was signalled.

(with-vector-parsing ("hello")
  (print
   (match-i-case
    ("Hello" 0))) ;; Nothing will be printed.
  (print "It shold not be printed.")) ;; Nothing will be printed.
;; => NIL

match-failed

(with-vector-parsing ("hello")
  (print (current)) ; #\h
  (skip #\f))
;; => Condition MATCH-FAILED was signalled.

Author

Copyright

Copyright (c) 2015 Eitaro Fukamachi & Rudolph Miller

License

Licensed under the BSD 2-Clause License.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 proc-parse

Author

Eitaro Fukamachi

License

BSD 2-Clause

Description

Procedural vector parser

Long Description

# Proc-Parse

[![Build Status](https://travis-ci.org/fukamachi/proc-parse.svg?branch=master)](https://travis-ci.org/fukamachi/proc-parse)
[![Coverage Status](https://coveralls.io/repos/fukamachi/proc-parse/badge.svg?branch=master)](https://coveralls.io/r/fukamachi/proc-parse)

<blockquote>
Question: Are these parser macros for speed or just to make your application look cool?<br>
Answer: Both.
</blockquote>

This is a string/octets parser library for Common Lisp with speed and readability in mind. Unlike other libraries, the code is not a pattern-matching-like, but a char-by-char procedural parser.

Although the design is good for speed, the code could look ugly with ‘tagbody‘ and ‘go‘. Proc-Parse wraps the code with sexy macros.

I believe we don’t have to give up speed for the readability while we use Common Lisp.

## Usage

“‘common-lisp
(defun parse-url-scheme (data &key (start 0) end)
"Return a URL scheme of DATA as a string."
(declare (optimize (speed 3) (safety 0) (debug 0)))
(block nil
(with-vector-parsing (data :start start :end end)
(match-i-case
("http:" (return "http"))
("https:" (return "https"))
(otherwise (unless (standard-alpha-char-p (current))
(return nil))
(bind (scheme (skip* (not #\:)))
(return scheme)))))))
“‘

## API

### with-vector-parsing

- can parse both string and octets.

“‘Lisp
(with-vector-parsing ("It’s Tuesday!" :start 5 :end 12)
(bind (str (skip-until
(lambda (c)
(declare (ignore c))
(eofp))))
(print str))) ; "Tuesday"

(with-vector-parsing ((babel:string-to-octets "It’s Tuesday!") :start 5 :end 12)
(bind (str (skip-until
(lambda (c)
(declare (ignore c))
(eofp))))
(print str))) ; "Tuesday"
“‘

### with-string-parsing

- can parse string.

“‘Lisp
(with-string-parsing ("It’s Tuesday!" :start 5 :end 12)
(bind (str (skip-until
(lambda (c)
(declare (ignore c))
(eofp))))
(print str))) ; "Tuesday"
“‘

### with-octets-parsing

- can parse octets.

“‘Lisp
(with-octets-parsing ((babel:string-to-octets "It’s Tuesday!") :start 5 :end 12)
(bind (str (skip-until
(lambda (c)
(declare (ignore c))
(eofp))))
(print str))) ; "Tuesday"
“‘

### eofp

- can return EOF or not.

“‘Lisp
(with-vector-parsing ("hello")
(print (eofp)) ; NIL
(match "hello")
(print (eofp))) ; T
“‘

### current

- can return the character of the current position.

“‘Lisp
(with-vector-parsing ("hello")
(print (current)) ; #\h
(skip #\h)
(print (current))) ; #\e
“‘

### peek

- can peek next character from the current position

“‘Lisp
(with-vector-parsing ("hello")
(print (current)) ; #\h
(print (peek)) ; #\e
(print (current))) ; #\h
“‘

- and you can specify the eof-value

“‘Lisp
(with-vector-parsing ("hello")
(match "hell")
(print (pos)) ; #\4
(print (peek :eof-value ’yes))) ; YES
“‘

### pos

- can return the current position.

“‘Lisp
(with-vector-parsing ("hello")
(print (pos)) ; 0
(skip #\h)
(print (pos))) ; 1
“‘

### advance

- can put the current postion forward.
- can cease parsing with EOF.

“‘Lisp
(with-vector-parsing ("hello")
(print (current)) ; #\h
(advance)
(print (current)) ; #\e
(match "ello")
(print (current)) ; #\o
(advance)
(print "Hi")) ; "Hi" won’t displayed.
“‘

### advance*

- can put the current postion forward.
- just returns NIL with EOF.

“‘Lisp
(with-vector-parsing ("hello")
(print (current)) ; #\h
(advance*)
(print (current)) ; #\e
(match "ello")
(print (current)) ; #\o
(advance*)
(print (current)) ; #\o
(print "Hi")) ; "Hi"
“‘

### skip

- can skip the specified character.
- can raise MATCH-FAILED error with unmatched characters.

“‘Lisp
(with-vector-parsing ("hello")
(print (current)) ; #\h
(skip #\h)
(print (current)) ; #\e
(skip (not #\h))
(print (current)) ; #\l
(skip #\f))
;; => Condition MATCH-FAILED was signalled.
“‘

### skip*

- can skip some straignt specified characters.
- just returns NIL with unmatched characters.

“‘Lisp
(with-vector-parsing ("hello")
(skip* #\h)
(print (current)) ; #\e
(skip* (not #\l))
(print (current)) ; #\l
(skip* #\l)
(print (current)) ; #\o
(skip* #\f)) ; MATCH-FAILED won’t be raised.
“‘

### skip+

- can skip some straignt specified characters.
- can raise MATCH-FAILED error with unmatched characters.

“‘Lisp
(with-vector-parsing ("hello")
(skip+ #\h)
(print (current)) ; #\e
(skip* (not #\l))
(print (current)) ; #\l
(skip+ #\l)
(print (current)) ; #\o
(skip+ #\f))
;; => Condition MATCH-FAILED was signalled.
“‘

### skip?

- can skip the specified character.
- just returns NIL with unmatched characters.

“‘Lisp
(with-vector-parsing ("hello")
(print (current)) ; #\h
(skip? #\h)
(print (current)) ; #\e
(skip? (not #\h))
(print (current)) ; #\l
(skip? #\f)) ; MATCH-FAILED won’t be raised.
“‘

### skip-until

- can skip until form returned T or parsing reached EOF.

“‘Lisp
(with-vector-parsing ("hello")
(skip-until (lambda (char) (char= char #\o)))
(print (current)) ; #\o
(print (eofp)) ; NIL
(skip-until (lambda (char) (char= char #\f)))
(print (eofp))) ; T
“‘

### skip-while

- can skip while form returns T and parsing doesn’t reach EOF.

“‘Lisp
(with-vector-parsing ("hello")
(skip-while (lambda (char) (char/= char #\o)))
(print (current)) ; #\o
(print (eofp)) ; NIL
(skip-while (lambda (char) (char/= char #\f)))
(print (eofp))) ; T
“‘

### bind

- can bind subseqed string.

“‘Lisp
(with-vector-parsing ("hello")
(bind (str1 (skip-until (lambda (c) (char= c #\l))))
(print str1)) ; "he"
(bind (str2 (skip* (not #\f)))
(print str2))) ; "llo"
“‘

### match

- can skip matched one of the specified strings.
- can raise MATCH-FAILED error with unmatched characters.

“‘Lisp
(with-vector-parsing ("hello")
(match "he")
(print (current)) ; #\l
(match "l" "ll")
(print (current)) ; #\o
(match "f"))
;; => Condition MATCH-FAILED was signalled.
“‘

### match-i

- can skip case-insensitively matched one of the specified strings.
- can raise MATCH-FAILED error with case-insensitively unmatched characters.

“‘Lisp
(with-vector-parsing ("hello")
(match-i "He")
(print (current)) ; #\l
(match-i "L" "LL")
(print (current)) ; #\o
(match-i "F"))
;; => Condition MATCH-FAILED was signalled.
“‘

### match?

- can skip matched one of the specified strings.
- just returns NIL with unmatched characters.

“‘Lisp
(with-vector-parsing ("hello")
(match? "he")
(print (current)) ; #\l
(match? "l" "ll")
(print (current)) ; #\o
(match? "f")) ; MATCH-FAILED won’t be raised.
“‘

### match-case

- can dispatch to the matched case.
- aborts parsing when reaching EOF.

“‘Lisp
(with-vector-parsing ("hello")
(match-case
("he" (print 0))
("ll" (print 1))
(otherwise (print 2))) ; 0
(print (current)) ; #\l
(match-case
("he" (print 0))
("ll" (print 1))
(otherwise (print 2))) ; 1
(print (current)) ; #\o
(match-case
("he" (print 0))
("ll" (print 1))
(otherwise (print 2))) ; 2
(print (current)) ; #\o
(match-case
("he" (print 0))
("ll" (print 1))))
;; => Condition MATCH-FAILED was signalled.

(with-vector-parsing ("hello")
(print
(match-case
("hello" 0))) ;; Nothing will be printed.
(print "It shold not be printed.")) ;; Nothing will be printed.
;; => NIL
“‘

### match-i-case

- can dispatch to the case-insensitively matched case.
- aborts parsing when reaching EOF.

“‘Lisp
(with-vector-parsing ("hello")
(match-i-case
("He" (print 0))
("LL" (print 1))
(otherwise (print 2))) ; 0
(print (current)) ; #\l
(match-i-case
("He" (print 0))
("LL" (print 1))
(otherwise (print 2))) ; 1
(print (current)) ; #\o
(match-i-case
("He" (print 0))
("LL" (print 1))
(otherwise (print 2))) ; 2
(print (current)) ; #\o
(match-i-case
("He" (print 0))
("LL" (print 1))))
;; => Condition MATCH-FAILED was signalled.

(with-vector-parsing ("hello")
(print
(match-i-case
("Hello" 0))) ;; Nothing will be printed.
(print "It shold not be printed.")) ;; Nothing will be printed.
;; => NIL
“‘

### match-failed

- is the condition representing failure of matching.

“‘Lisp
(with-vector-parsing ("hello")
(print (current)) ; #\h
(skip #\f))
;; => Condition MATCH-FAILED was signalled.
“‘

## Author

* Eitaro Fukamachi
* Rudolph Miller

## Copyright

Copyright (c) 2015 Eitaro Fukamachi & Rudolph Miller

## License

Licensed under the BSD 2-Clause License.

Version

0.1

Dependencies
Source

proc-parse.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 proc-parse/src

Parent

proc-parse (system)

Location

src/

Component

proc-parse.lisp (file)


Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 proc-parse.asd

Location

proc-parse.asd

Systems

proc-parse (system)

Packages

proc-parse-asd


Previous: , Up: Lisp files   [Contents][Index]

4.1.2 proc-parse/src/proc-parse.lisp

Parent

src (module)

Location

src/proc-parse.lisp

Packages

proc-parse

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 proc-parse-asd

Source

proc-parse.asd

Use List

Previous: , Up: Packages   [Contents][Index]

5.2 proc-parse

Source

proc-parse.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Macros

Macro: bind (SYMB &body BIND-FORMS) &body BODY
Package

proc-parse

Source

proc-parse.lisp (file)

Macro: with-octets-parsing (DATA &key START END) &body BODY
Package

proc-parse

Source

proc-parse.lisp (file)

Macro: with-string-parsing (DATA &key START END) &body BODY
Package

proc-parse

Source

proc-parse.lisp (file)

Macro: with-vector-parsing (DATA &key START END) &body BODY
Package

proc-parse

Source

proc-parse.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Conditions

Condition: match-failed ()
Package

proc-parse

Source

proc-parse.lisp (file)

Direct superclasses

error (condition)

Direct slots
Slot: elem
Initargs

:elem

Initform

(quote nil)

Slot: expected
Initargs

:expected

Initform

(quote nil)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Macros

Macro: get-elem FORM
Package

proc-parse

Source

proc-parse.lisp (file)

Macro: parsing-macrolet (ELEM DATA P END) (&rest MACROS) &body BODY
Package

proc-parse

Source

proc-parse.lisp (file)

Macro: subseq* DATA START &optional END
Package

proc-parse

Source

proc-parse.lisp (file)

Macro: tagbody-with-match-failed ELEM &body BODY
Package

proc-parse

Source

proc-parse.lisp (file)

Macro: vector-case ELEM-VAR VEC-AND-OPTIONS &body CASES
Package

proc-parse

Source

proc-parse.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Functions

Function: check-match-cases CASES
Package

proc-parse

Source

proc-parse.lisp (file)

Function: check-skip-elems ELEMS
Package

proc-parse

Source

proc-parse.lisp (file)

Function: convert-case-conditions VAR CHARS
Package

proc-parse

Source

proc-parse.lisp (file)

Function: ensure-char-elem ELEM
Package

proc-parse

Source

proc-parse.lisp (file)

Function: typed-case-tagbodies VAR &rest CASES
Package

proc-parse

Source

proc-parse.lisp (file)

Function: variable-type VAR &optional ENV
Package

proc-parse

Source

proc-parse.lisp (file)

Function: variable-type* VAR &optional ENV
Package

proc-parse

Source

proc-parse.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Types

Type: octets &optional LEN
Package

proc-parse

Source

proc-parse.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   M   P  
Index Entry  Section

F
File, Lisp, proc-parse.asd: The proc-parse<dot>asd file
File, Lisp, proc-parse/src/proc-parse.lisp: The proc-parse/src/proc-parse<dot>lisp file

L
Lisp File, proc-parse.asd: The proc-parse<dot>asd file
Lisp File, proc-parse/src/proc-parse.lisp: The proc-parse/src/proc-parse<dot>lisp file

M
Module, proc-parse/src: The proc-parse/src module

P
proc-parse.asd: The proc-parse<dot>asd file
proc-parse/src: The proc-parse/src module
proc-parse/src/proc-parse.lisp: The proc-parse/src/proc-parse<dot>lisp file

Jump to:   F   L   M   P  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   B   C   E   F   G   M   P   S   T   V   W  
Index Entry  Section

B
bind: Exported macros

C
check-match-cases: Internal functions
check-skip-elems: Internal functions
convert-case-conditions: Internal functions

E
ensure-char-elem: Internal functions

F
Function, check-match-cases: Internal functions
Function, check-skip-elems: Internal functions
Function, convert-case-conditions: Internal functions
Function, ensure-char-elem: Internal functions
Function, typed-case-tagbodies: Internal functions
Function, variable-type: Internal functions
Function, variable-type*: Internal functions

G
get-elem: Internal macros

M
Macro, bind: Exported macros
Macro, get-elem: Internal macros
Macro, parsing-macrolet: Internal macros
Macro, subseq*: Internal macros
Macro, tagbody-with-match-failed: Internal macros
Macro, vector-case: Internal macros
Macro, with-octets-parsing: Exported macros
Macro, with-string-parsing: Exported macros
Macro, with-vector-parsing: Exported macros

P
parsing-macrolet: Internal macros

S
subseq*: Internal macros

T
tagbody-with-match-failed: Internal macros
typed-case-tagbodies: Internal functions

V
variable-type: Internal functions
variable-type*: Internal functions
vector-case: Internal macros

W
with-octets-parsing: Exported macros
with-string-parsing: Exported macros
with-vector-parsing: Exported macros

Jump to:   B   C   E   F   G   M   P   S   T   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   E   S  
Index Entry  Section

E
elem: Exported conditions
expected: Exported conditions

S
Slot, elem: Exported conditions
Slot, expected: Exported conditions

Jump to:   E   S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   M   O   P   S   T  
Index Entry  Section

C
Condition, match-failed: Exported conditions

M
match-failed: Exported conditions

O
octets: Internal types

P
Package, proc-parse: The proc-parse package
Package, proc-parse-asd: The proc-parse-asd package
proc-parse: The proc-parse system
proc-parse: The proc-parse package
proc-parse-asd: The proc-parse-asd package

S
System, proc-parse: The proc-parse system

T
Type, octets: Internal types

Jump to:   C   M   O   P   S   T