int parse_command(string, object/object*, string, destargs...)

                        Returns 1 if pattern matches

        string          Given command

        object*         if arr
        object                  array holding the accessible objects
                        if ob
                                object from which to recurse and create
                                the list of accessible objects, normally
                                ob = environment(this_player())
        string          Parsepattern as list of words and formats:
                        Example string = " 'get' / 'take' %i "
                        Syntax:
                                'word'          obligatory text
                                [word]          optional text
                                /               Alternative marker
                                %o              Single item, object
                                %l              Living objects
                                %s              Any text
                                %w              Any word
                                %p              One of a list (prepositions)
                                %i              Any items
                                %d              Number 0- or tx(0-99)

        destargs        This is the list of result variables as in sscanf
                        One variable is needed for each %_
                        The return types of different %_ is:
                        %o      Returns an object
                        %s      Returns a string of words
                        %w      Returns a string of one word
                        %p      Can on entry hold a list of word in array
                                or an empty variable
                                Returns:
                                   if empty variable: a string
                                   if array: array[0]=matched word
                        %i      Returns a special array on the form:
                                [0] = (int) +(wanted) -(order) 0(all)
                                [1..n] (object) Objectpointers
                        %l      Returns a special array on the form:
                                [0] = (int) +(wanted) -(order) 0(all)
                                [1..n] (object) Objectpointers
                                                These are only living objects.
                        %d      Returns a number

  The only types of % that uses all the loaded information from the objects
  are %i and %l. These are in fact identical except that %l filters out
  all nonliving objects from the list of objects before trying to parse.

  The return values of %i and %l is also the most complex. They return an
  array consisting of first a number and then all possible objects matching.
  As the typical string matched by %i/%l looks like: 'three red roses',
  'all nasty bugs' or 'second blue sword' the number indicates which
  of these numerical constructs was matched:

         if numeral >0 then three, four, five etc were matched
         if numeral <0 then second, twentyfirst etc were matched
         if numeral==0 then 'all' or a generic plural form such as 'apples'
                            were matched.

  NOTE!
       The efun makes no semantic implication on the given numeral. It does
       not matter if 'all apples' or 'second apple' is given. A %i will
       return ALL possible objects matching in the array. It is up to the
       caller to decide what 'second' means in a given context.

       Also when given an object and not an explicit array of objects the
       entire recursive inventory of the given object is searched. It is up
       to the caller to decide which of the objects are actually visible
       meaning that 'second' might not at all mean the second object in
       the returned array of objects.

Example:

 if (parse_command("spray car",environment(this_player()),
                      " 'spray' / 'paint' [paint] %i ",items))
 {
      If the pattern matched then items holds a return array as described
        under 'destargs' %i above.

 }

 BUGS / Features
:

 Patterns of type: "%s %w %i"
   Might not work as one would expect. %w will always succeed so the arg
   corresponding to %s will always be empty.

 Patterns of the type: 'word' and [word]
   The 'word' can not contain spaces. It must be a single word. This is so
   because the pattern is exploded on " " (space) and a pattern element can
   therefore not contain spaces.

