CliXoN
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros
Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
clixon_yang_parse.l File Reference
#include "clixon_config.h"
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include <netinet/in.h>
#include "clixon_yang_parse.tab.h"
#include <cligen/cligen.h>
#include "clixon_queue.h"
#include "clixon_hash.h"
#include "clixon_handle.h"
#include "clixon_yang.h"
#include "clixon_yang_parse.h"

Data Structures

union  YYSTYPE
 
struct  ys_stack
 
struct  clicon_yang_yacc_arg
 
struct  yang_userdata
 

Macros

#define YY_DECL   int clixon_yang_parselex(void *_yy)
 
#define YY_NO_INPUT
 
#define _YY   ((struct clicon_yang_yacc_arg *)_yy)
 
#define MAXBUF   4*4*64*1024
 
#define MAX(x, y)   ((x)>(y)?(x):(y))
 
#define MIN(x, y)   ((x)<(y)?(x):(y))
 

Typedefs

typedef union YYSTYPE YYSTYPE
 

Enumerations

enum  
 

Functions

int clixon_yang_parseparse (void *_yy)
 
int yang_scan_init (struct clicon_yang_yacc_arg *ya)
 
int yang_scan_exit (struct clicon_yang_yacc_arg *ya)
 
int yang_parse_init (struct clicon_yang_yacc_arg *ya, yang_spec *ysp)
 
int yang_parse_exit (struct clicon_yang_yacc_arg *ya)
 
int clixon_yang_parselex (void *_ya)
 
int clixon_yang_parseparse (void *)
 
void clixon_yang_parseerror (void *_ya, char *)
 
int ystack_pop (struct clicon_yang_yacc_arg *ya)
 
struct ys_stackystack_push (struct clicon_yang_yacc_arg *ya, yang_node *yn)
 
int clixon_yang_parsewrap (void)
 
< KEYWORD > enum { ... }  BEGIN (STRING0)
 

Variables

YYSTYPE clixon_yang_parselval
 
x KEYWORD s ARGUMENT s STRING0
s STRING1 s STRING2 s ESCAPE s
COMMENT1 s COMMENT2< KEYWORD,
ARGUMENT, STRING0 >< KEYWORD,
ARGUMENT, STRING0 ><< EOF >
< KEYWORD, ARGUMENT, STRING0,
COMMENT1
n { _YY->yy_linenum++
 
< KEYWORD, ARGUMENT, STRING0 >
< KEYWORD
anyxml { BEGIN(ARGUMENT)
 
return K_ANYXML
 
< KEYWORDargument { BEGIN(ARGUMENT)
 
return K_ARGUMENT
 
< KEYWORDaugment { BEGIN(ARGUMENT)
 
return K_AUGMENT
 
< KEYWORDbase { BEGIN(ARGUMENT)
 
return K_BASE
 
< KEYWORD > belongs to { BEGIN(ARGUMENT)
 
return K_BELONGS_TO
 
< KEYWORDbit { BEGIN(ARGUMENT)
 
return K_BIT
 
< KEYWORDcase { BEGIN(ARGUMENT)
 
return K_CASE
 
< KEYWORDchoice { BEGIN(ARGUMENT)
 
return K_CHOICE
 
< KEYWORDconfig { BEGIN(ARGUMENT)
 
return K_CONFIG
 
< KEYWORDcontact { BEGIN(STRING0)
 
return K_CONTACT
 
< KEYWORDcontainer { BEGIN(ARGUMENT)
 
return K_CONTAINER
 
< KEYWORDdefault { BEGIN(STRING0)
 
return K_DEFAULT
 
< KEYWORDdescription { BEGIN(STRING0)
 
return K_DESCRIPTION
 
< KEYWORDdeviate { BEGIN(ARGUMENT)
 
return K_DEVIATE
 
< KEYWORDdeviation { BEGIN(ARGUMENT)
 
return K_DEVIATION
 
return K_ENUM =(STRING0)
 
return K_ERROR_APP_TAG
 
< KEYWORD > error message { BEGIN(STRING0)
 
return K_ERROR_MESSAGE
 
< KEYWORDextension { BEGIN(ARGUMENT)
 
return K_EXTENSION
 
< KEYWORDfeature { BEGIN(ARGUMENT)
 
return K_FEATURE
 
< KEYWORD > fraction digits { BEGIN(ARGUMENT)
 
return K_FRACTION_DIGITS
 
< KEYWORDgrouping { BEGIN(ARGUMENT)
 
return K_GROUPING
 
< KEYWORDidentity { BEGIN(ARGUMENT)
 
return K_IDENTITY
 
return K_IF_FEATURE
 
< KEYWORDimport { BEGIN(ARGUMENT)
 
return K_IMPORT
 
< KEYWORDinclude { BEGIN(ARGUMENT)
 
return K_INCLUDE
 
< KEYWORDinput { BEGIN(ARGUMENT)
 
return K_INPUT
 
< KEYWORDkey { BEGIN(ARGUMENT)
 
return K_KEY
 
< KEYWORDleaf { BEGIN(ARGUMENT)
 
return K_LEAF
 
< KEYWORD > leaf list { BEGIN(ARGUMENT)
 
return K_LEAF_LIST
 
< KEYWORDlength { BEGIN(ARGUMENT)
 
return K_LENGTH
 
return K_LIST
 
< KEYWORDmandatory { BEGIN(ARGUMENT)
 
return K_MANDATORY
 
< KEYWORD > max elements { BEGIN(ARGUMENT)
 
return K_MAX_ELEMENTS
 
return K_MIN_ELEMENTS
 
< KEYWORDmodule { BEGIN(ARGUMENT)
 
return K_MODULE
 
< KEYWORDmust { BEGIN(STRING0)
 
return K_MUST
 
< KEYWORDnotification { BEGIN(ARGUMENT)
 
return K_NOTIFICATION
 
< KEYWORD > ordered by { BEGIN(ARGUMENT)
 
return K_ORDERED_BY
 
< KEYWORDorganization { BEGIN(STRING0)
 
return K_ORGANIZATION
 
< KEYWORDoutput { BEGIN(ARGUMENT)
 
return K_OUTPUT
 
< KEYWORDpath { BEGIN(ARGUMENT)
 
return K_PATH
 
< KEYWORDpattern { BEGIN(STRING0)
 
return K_PATTERN
 
< KEYWORDposition { BEGIN(ARGUMENT)
 
return K_POSITION
 
< KEYWORDprefix { BEGIN(ARGUMENT)
 
return K_PREFIX
 
< KEYWORDpresence { BEGIN(STRING0)
 
return K_PRESENCE
 
< KEYWORDrange { BEGIN(ARGUMENT)
 
return K_RANGE
 
< KEYWORDreference { BEGIN(STRING0)
 
return K_REFERENCE
 
< KEYWORDrefine { BEGIN(ARGUMENT)
 
return K_REFINE
 
< KEYWORD > require instance { BEGIN(ARGUMENT)
 
return K_REQUIRE_INSTANCE
 
< KEYWORDrevision { BEGIN(ARGUMENT)
 
return K_REVISION
 
< KEYWORD > revision date { BEGIN(ARGUMENT)
 
return K_REVISION_DATE
 
< KEYWORDrpc { BEGIN(ARGUMENT)
 
return K_RPC
 
< KEYWORDstatus { BEGIN(ARGUMENT)
 
return K_STATUS
 
< KEYWORDsubmodule { BEGIN(ARGUMENT)
 
return K_SUBMODULE
 
< KEYWORDtype { BEGIN(ARGUMENT)
 
return K_TYPE
 
< KEYWORDtypedef { BEGIN(ARGUMENT)
 
return K_TYPEDEF
 
< KEYWORDunique { BEGIN(ARGUMENT)
 
return K_UNIQUE
 
< KEYWORDunits { BEGIN(STRING0)
 
return K_UNITS
 
< KEYWORDuses { BEGIN(ARGUMENT)
 
return K_USES
 
< KEYWORDvalue { BEGIN(ARGUMENT)
 
return K_VALUE
 
< KEYWORDwhen { BEGIN(STRING0)
 
return K_WHEN
 
< KEYWORD > yang version { BEGIN(ARGUMENT)
 
return K_YANG_VERSION
 
< KEYWORD > yin element { BEGIN(ARGUMENT)
 
return K_YIN_ELEMENT
 
< KEYWORD >< ARGUMENT > returnyytext { BEGIN(KEYWORD)
 

Macro Definition Documentation

#define _YY   ((struct clicon_yang_yacc_arg *)_yy)
#define MAX (   x,
 
)    ((x)>(y)?(x):(y))
#define MAXBUF   4*4*64*1024
#define MIN (   x,
 
)    ((x)<(y)?(x):(y))
#define YY_DECL   int clixon_yang_parselex(void *_yy)
#define YY_NO_INPUT

Typedef Documentation

Enumeration Type Documentation

anonymous enum

Function Documentation

<KEYWORD> enum @3 BEGIN ( STRING0  )
void clixon_yang_parseerror ( void *  _ya,
char *   
)
int clixon_yang_parselex ( void *  _ya)
int clixon_yang_parseparse ( void *  )
int clixon_yang_parseparse ( void *  _yy)
int clixon_yang_parsewrap ( void  )
int yang_parse_exit ( struct clicon_yang_yacc_arg ya)
int yang_parse_init ( struct clicon_yang_yacc_arg ya,
yang_spec *  ysp 
)
int yang_scan_exit ( struct clicon_yang_yacc_arg ya)
int yang_scan_init ( struct clicon_yang_yacc_arg ya)
int ystack_pop ( struct clicon_yang_yacc_arg ya)
struct ys_stack * ystack_push ( struct clicon_yang_yacc_arg ya,
yang_node *  yn 
)

Variable Documentation

<KEYWORD> argument { BEGIN(ARGUMENT)
<KEYWORD> augment { BEGIN(ARGUMENT)
<KEYWORD> base { BEGIN(ARGUMENT)
<KEYWORD> ordered by { BEGIN(ARGUMENT)
<KEYWORD> case { BEGIN(ARGUMENT)
<KEYWORD> choice { BEGIN(ARGUMENT)
YYSTYPE clixon_yang_parselval
<KEYWORD> config { BEGIN(ARGUMENT)
<KEYWORD> contact { BEGIN(STRING0)
<KEYWORD> container { BEGIN(ARGUMENT)
<KEYWORD> default { BEGIN(STRING0)
<KEYWORD> description { BEGIN(STRING0)
<KEYWORD> deviate { BEGIN(ARGUMENT)
<KEYWORD> deviation { BEGIN(ARGUMENT)
<KEYWORD> fraction digits { BEGIN(ARGUMENT)
<KEYWORD> yin element { BEGIN(ARGUMENT)
< KEYWORD > min elements { BEGIN(ARGUMENT)
<KEYWORD> extension { BEGIN(ARGUMENT)
< KEYWORD > if feature { BEGIN(ARGUMENT)
<KEYWORD> grouping { BEGIN(ARGUMENT)
<KEYWORD> identity { BEGIN(ARGUMENT)
<KEYWORD> import { BEGIN(ARGUMENT)
<KEYWORD> include { BEGIN(ARGUMENT)
<KEYWORD> input { BEGIN(ARGUMENT)
<KEYWORD> require instance { BEGIN(ARGUMENT)
return K_ANYXML
return K_ARGUMENT
return K_AUGMENT
return K_BASE
return K_BELONGS_TO
return K_BIT
return K_CASE
return K_CHOICE
return K_CONFIG
return K_CONTACT
return K_CONTAINER
return K_DEFAULT
return K_DESCRIPTION
return K_DEVIATE
return K_DEVIATION
@ K_ENUM =(STRING0)
return K_ERROR_APP_TAG
return K_ERROR_MESSAGE
return K_EXTENSION
return K_FEATURE
return K_FRACTION_DIGITS
return K_GROUPING
return K_IDENTITY
return K_IF_FEATURE
return K_IMPORT
return K_INCLUDE
return K_INPUT
return K_KEY
return K_LEAF
return K_LEAF_LIST
return K_LENGTH
return K_LIST
return K_MANDATORY
return K_MAX_ELEMENTS
return K_MIN_ELEMENTS
return K_MODULE
return K_MUST
return K_NOTIFICATION
return K_ORDERED_BY
return K_ORGANIZATION
return K_OUTPUT
return K_PATH
return K_PATTERN
return K_POSITION
return K_PREFIX
return K_PRESENCE
return K_RANGE
return K_REFERENCE
return K_REFINE
return K_REQUIRE_INSTANCE
return K_REVISION
return K_REVISION_DATE
return K_RPC
return K_STATUS
return K_SUBMODULE
return K_TYPE
return K_TYPEDEF
return K_UNIQUE
return K_UNITS
return K_USES
return K_VALUE
return K_WHEN
return K_YANG_VERSION
return K_YIN_ELEMENT
<KEYWORD> leaf { BEGIN(ARGUMENT)
<KEYWORD> length { BEGIN(ARGUMENT)
<KEYWORD> list { BEGIN(ARGUMENT)
<KEYWORD> mandatory { BEGIN(ARGUMENT)
<KEYWORD> error message { BEGIN(STRING0)
<KEYWORD> module { BEGIN(ARGUMENT)
<KEYWORD> must { BEGIN(STRING0)
<KEYWORD> notification { BEGIN(ARGUMENT)
<KEYWORD> organization { BEGIN(STRING0)
<KEYWORD> output { BEGIN(ARGUMENT)
<KEYWORD> path { BEGIN(ARGUMENT)
<KEYWORD> pattern { BEGIN(STRING0)
<KEYWORD> position { BEGIN(ARGUMENT)
<KEYWORD> prefix { BEGIN(ARGUMENT)
<KEYWORD> presence { BEGIN(STRING0)
<KEYWORD> range { BEGIN(ARGUMENT)
<KEYWORD> reference { BEGIN(STRING0)
<KEYWORD> refine { BEGIN(ARGUMENT)
<KEYWORD> revision { BEGIN(ARGUMENT)
<KEYWORD> status { BEGIN(ARGUMENT)
<KEYWORD> submodule { BEGIN(ARGUMENT)
<KEYWORD> belongs to { BEGIN(ARGUMENT)
<KEYWORD> type { BEGIN(ARGUMENT)
<KEYWORD> typedef { BEGIN(ARGUMENT)
<KEYWORD> unique { BEGIN(ARGUMENT)
<KEYWORD> units { BEGIN(STRING0)
<KEYWORD> uses { BEGIN(ARGUMENT)
<KEYWORD> value { BEGIN(ARGUMENT)
<KEYWORD> yang version { BEGIN(ARGUMENT)
<KEYWORD> when { BEGIN(STRING0)