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 */