parse.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef included_vlib_parse_h
#define included_vlib_parse_h
 
#include <vlib/vlib.h>
#include <vlib/lex.h>
#include <vppinfra/mhash.h>
 
typedef struct
{
  /* Word aligned value. */
  union
  {
    u8 as_u8[32 - 1 * sizeof (u16)];
    void *as_pointer;
    uword as_uword;
    word as_word;
    u64 as_u64;
  } value;
 
  /* 16 bit type at end so that 30 bytes of value are aligned. */
  u16 type;
} __attribute ((packed))
  vlib_parse_value_t;
 
/* Instance of a type. */
     typedef struct
     {
       u32
         type;
 
       u32
         origin;
 
       u32
         help_index;
 
       union
       {
         void *
           as_pointer;
         uword
           as_uword;
       } value;
     } vlib_parse_item_t;
 
     typedef struct
     {
       /* Index of item for this node. */
       u32
         item;
 
       /* Graph index of peer (sibling) node (linked list of peers). */
       u32
         peer;
 
       /* Graph index of deeper (child) node (linked list of children). */
       u32
         deeper;
     } vlib_parse_graph_t;
 
#define foreach_parse_match_type                \
  _(MATCH_DONE)                                 \
  _(MATCH_RULE)                                 \
  _(MATCH_FAIL)                                 \
  _(MATCH_FULL)                                 \
  _(MATCH_VALUE)                                \
  _(MATCH_PARTIAL)                              \
  _(MATCH_AMBIGUOUS)                            \
  _(MATCH_EVAL_FAIL)
 
     typedef enum
     {
#define _(a) VLIB_PARSE_##a,
       foreach_parse_match_type
#undef _
     } vlib_parse_match_t;
 
     struct vlib_parse_type;
     struct vlib_parse_main;
 
     typedef
     vlib_parse_match_t (vlib_parse_match_function_t)
  (struct vlib_parse_main *,
   struct vlib_parse_type *, vlib_lex_token_t *, vlib_parse_value_t *);
     typedef void (vlib_parse_value_cleanup_function_t) (vlib_parse_value_t
                                                         *);
 
     typedef struct vlib_parse_type
     {
       /* Type name. */
       char *
         name;
 
       vlib_parse_match_function_t *
         match_function;
 
       vlib_parse_value_cleanup_function_t *
         value_cleanup_function;
 
       format_function_t *
         format_value;
 
       u32
         rule_index;
     } vlib_parse_type_t;
 
     typedef struct
     {
       char *
         initializer;
       void *
         eof_match;
       int
         rule_length;
     } parse_registration_t;
 
     typedef struct vlib_parse_main
     {
       /* (type, origin, help, value) tuples */
       vlib_parse_item_t *
         parse_items;
       mhash_t
         parse_item_hash;
 
       /* (item, peer, deeper) tuples */
       vlib_parse_graph_t *
         parse_graph;
       u32
         root_index;
 
       u8 *
         register_input;
 
       /* parser types */
       vlib_parse_type_t *
         parse_types;
       uword *
         parse_type_by_name_hash;
 
       /* Vector of MATCH_VALUEs */
       vlib_parse_value_t *
         parse_value;
       u32 *
         match_items;
 
       /* Parse registrations */
       parse_registration_t **
         parse_registrations;
 
       /* Token vector */
       vlib_lex_token_t *
         tokens;
       u32
         current_token_index;
 
       vlib_lex_main_t *
         lex_main;
       vlib_main_t *
         vlib_main;
     } vlib_parse_main_t;
 
     vlib_parse_main_t
       vlib_parse_main;
 
     typedef
     vlib_parse_match_t (vlib_parse_eval_function_t)
  (vlib_parse_main_t *, vlib_parse_item_t *, vlib_parse_value_t *);
 
vlib_parse_match_t
vlib_parse_eval (u8 * input);
 
     format_function_t format_vlib_parse_value;
 
/* FIXME need these to be global? */
     vlib_parse_match_function_t rule_match, eof_match, word_match,
       number_match;
 
#define _PARSE_REGISTRATION_DATA(x) \
VLIB_ELF_SECTION_DATA(x##_registration,parse_registration_t,parse_registrations)
 
#define PARSE_INIT(x, s, e)                     \
static _PARSE_REGISTRATION_DATA(x) = {          \
    .initializer = s,                           \
    .eof_match = e,                             \
};
 
#define _PARSE_TYPE_REGISTRATION_DATA(x) \
VLIB_ELF_SECTION_DATA(x##_type_registration,vlib_parse_type_t, \
parse_type_registrations)
 
#define PARSE_TYPE_INIT(n, m, c, f)             \
static _PARSE_TYPE_REGISTRATION_DATA(n) = {     \
    .name = #n,                                 \
    .match_function = m,                        \
    .value_cleanup_function = c,                \
    .format_value = f,                          \
};
 
#endif /* included_vlib_parse_h */
 
/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */