Production rules
================


                       plan ::= "(" [ <docstring> ]
                                    ( ( <competence> | <action-pattern> )*
                                      <drive-collection>
                                      ( <competence> | <action-pattern> )*
                                    )
                                    | <competence>
                                    | <action-pattern>
                                ")"
                  docstring ::= "(" DOCUMENTATION COMMENT COMMENT COMMENT ")"

           drive-collection ::= "(" <drive-collection-id> NAME
                                    ( NIL | <goal> | )
                                    "(" DRIVES <drive-priorities> ")"
                                ")"
        drive-collection-id ::= DC | RDC | SDC | SRDC
           drive_priorities ::= <drive-elements>+
             drive-elements ::= "(" <drive-element>+ ")"
              drive-element ::= "(" NAME ( NIL | <trigger> | ) NAME
                                    ( NIL | <freq> | ) <opt-comment> ")"

# <freq> is the maximum frequency at which the element can be executed

                 competence ::= "(" C NAME ( NIL | <time> | ) ( NIL | <goal> | )
                                    "(" ELEMENTS <competence-priorities> ")"
                                    <opt-comment>
                                ")"
      competence-priorities ::= <competence-elements>+
        competence-elements ::= "(" <competence-element>+ ")"
         competence-element ::= "(" NAME [ <trigger> ] NAME [ INTNUM ]
                                    <opt-comment> ")"

             aption-pattern ::= "(" AP NAME ( NIL | <time> | )
                                    <action-pattern-elements> <opt-comment> ")"
    action-pattern-elements ::= "(" NAME+ ")"

# <time> is the time-out on the scheduler in full/scheduled version of POSH
# (DC|RDC) for SDC|RSDC this will be ignore an can be (but doesn't have to be)
# omitted
# INTNUM is the maximum number of retries

                       goal ::= "(" GOAL <senses> ")"
                    trigger ::= "(" TRIGGER <senses> ")"
                     senses ::= ( NIL | "(" ( NAME | <full-sense> )+ ")" )
                 full-sense ::= "(" NAME [<value> [<predicate>]] ")"
                      value ::= NUMINT | NUMFLOAT | NAME | STRINGVALUE | NIL
                  predicate ::= PREDICATE

# the prediates "=" and "==" mean the same thing
                       
                       freq ::= "(" <freq-unit> <numfloat> ")"
                  freq-unit ::= HOURS | MINUTES | SECONDS | HZ | PM | NONE
                       time ::= "(" <time-unit> <numfloat> ")"
                  time-unit ::= HOURS | MINUTES | SECONDS | NONE
                   numfloat ::= NUMINT | NUMFLOAT

# NONE can only be used in DC or SDC -- there time is in POSH cycles
# in DC or SDC *only* NONE can be used
                   
                opt-comment ::= COMMENT |

Terminal Symbols
================

    RegExp                   Token               Comments
    -----------------------------------------------------------------------------
    AP                       AP
    C                        C
    DC                       DC
    RDC                      RDC
    SDC                      SDC
    SRDC                     SRDC
    nil                      NIL
    (?i)drives               DRIVES              (?i) means case-insensitive
    (?i)elements             ELEMENTS
    (?i)trigger              TRIGGER
    (?i)goal                 GOAL
    (?i)hours                HOURS
    (?i)minutes              MINUTES
    (?i)seconds              SECONDS
    (?i)hz                   HZ
    (?i)pm                   PM
    (?i)none                 NONE
    (?i)documentation        DOCUMENTATION
    (==|=|!=|<|>|<=|>=)      PREDICATE
    \-?(\d*\.\d+|\d+\.)([eE][\+\-]?\d+)?  NUMFLOAT  e.g. -1.34, 1e5, 2., .1
    \-?[0-9]+                NUMINT
    (?i)[a-z][a-z0-9_\-]*    NAME                Need to start with 'a'..'Z'
    (?i)'?[a-z][a-z0-9_\-]*  STRINGVALUE
    \"[^\"]*\"               COMMENT             Anything inbetween two '"'

Comments matching (\#|\;)[^\n]* (i.e. everything that starts with either '#' or
';') are removed in a pre-processing phase