experiments/clixon
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

renamed .h and libs clicon->clixon

Browse source
This commit is contained in:
Olof Hagsand 2016-02-28 15:27:36 +01:00
parent baa5611616
commit 79b77943f9
132 changed files with 1240 additions and 1268 deletions
Download patch file Download diff file Expand all files Collapse all files

260
lib/src/clicon_yang_parse.l
View file

@ -1,260 +0,0 @@
/*
*
Copyright (C) 2009-2016 Olof Hagsand and Benny Holmgren
This file is part of CLICON.
CLICON is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
CLICON is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with CLICON; see the file LICENSE. If not, see
<http://www.gnu.org/licenses/>.
* Database specification parser cli syntax
* (Cloned from cligen parser)
*/
%{
#include "clicon_config.h"
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include <netinet/in.h>
#include "clicon_yang_parse.tab.h" /* generated */
#include <cligen/cligen.h>
#include "clicon_queue.h"
#include "clicon_hash.h"
#include "clicon_handle.h"
#include "clicon_yang.h"
#include "clicon_yang_parse.h"
/* Redefine main lex function so that you can send arguments to it: _yy is added to arg list */
#define YY_DECL int clicon_yang_parselex(void *_yy)
/* Dont use input function (use user-buffer) */
#define YY_NO_INPUT
/* typecast macro */
#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))
#undef clicon_yang_parsewrap
int
clicon_yang_parsewrap(void)
{
return 1;
}
#ifdef notused
/* like strdup but strip \:s */
static char *
stripdup(char *s0)
{
char *s1;
char *s;
if ((s1 = strdup(s0)) == NULL){
fprintf(stderr, "%s: strdup: %s\n", __FUNCTION__, strerror(errno));
return NULL;
}
while ((s = index(s1, '\\')) != NULL)
memmove(s, s+1, strlen(s));
return s1;
}
#endif /* notused */
/*
statement = keyword [argument] (";" / "{" *statement "}")
The argument is a string
Example: keyword argument ; keyword ; keyword { keyword argument; } keyword
STRING0 corresponds to string rule
ARGUMENT corresponds to identifier-arg-str,unique-arg-str,key-arg-str, etc.
more to do here.
*/
%}
%x KEYWORD
%s ARGUMENT
%s STRING0
%s STRING1
%s STRING2
%s ESCAPE
%s COMMENT1
%s COMMENT2
%%
/* Common tokens */
<KEYWORD,ARGUMENT,STRING0>[ \t]
<KEYWORD,ARGUMENT,STRING0><<EOF>> { return MY_EOF; }
<KEYWORD,ARGUMENT,STRING0,COMMENT1>\n { _YY->yy_linenum++; }
<KEYWORD,ARGUMENT,STRING0>"/*" { _YY->yy_lex_state = YYSTATE; BEGIN(COMMENT1); }
<KEYWORD,ARGUMENT,STRING0>"//" { _YY->yy_lex_state = YYSTATE; BEGIN(COMMENT2); }
<KEYWORD>\} { return *yytext; }
/* RFC 6020 keywords */
<KEYWORD>anyxml { BEGIN(ARGUMENT); return K_ANYXML; }
<KEYWORD>argument { BEGIN(ARGUMENT); return K_ARGUMENT; }
<KEYWORD>augment { BEGIN(ARGUMENT); return K_AUGMENT; }
<KEYWORD>base { BEGIN(ARGUMENT); return K_BASE; }
<KEYWORD>belongs-to { BEGIN(ARGUMENT); return K_BELONGS_TO; }
<KEYWORD>bit { BEGIN(ARGUMENT); return K_BIT; }
<KEYWORD>case { BEGIN(ARGUMENT); return K_CASE; }
<KEYWORD>choice { BEGIN(ARGUMENT); return K_CHOICE; }
<KEYWORD>config { BEGIN(ARGUMENT); return K_CONFIG; }
<KEYWORD>contact { BEGIN(STRING0); return K_CONTACT; }
<KEYWORD>container { BEGIN(ARGUMENT); return K_CONTAINER; }
<KEYWORD>default { BEGIN(STRING0); return K_DEFAULT; }
<KEYWORD>description { BEGIN(STRING0); return K_DESCRIPTION; }
<KEYWORD>deviate { BEGIN(ARGUMENT); return K_DEVIATE; }
<KEYWORD>deviation { BEGIN(ARGUMENT); return K_DEVIATION; }
<KEYWORD>enum { BEGIN(STRING0); return K_ENUM; }
<KEYWORD>error-app-tag { BEGIN(STRING0); return K_ERROR_APP_TAG; }
<KEYWORD>error-message { BEGIN(STRING0); return K_ERROR_MESSAGE; }
<KEYWORD>extension { BEGIN(ARGUMENT); return K_EXTENSION; }
<KEYWORD>feature { BEGIN(ARGUMENT); return K_FEATURE; }
<KEYWORD>fraction-digits { BEGIN(ARGUMENT); return K_FRACTION_DIGITS; }
<KEYWORD>grouping { BEGIN(ARGUMENT); return K_GROUPING; }
<KEYWORD>identity { BEGIN(ARGUMENT); return K_IDENTITY; }
<KEYWORD>if-feature { BEGIN(ARGUMENT); return K_IF_FEATURE; }
<KEYWORD>import { BEGIN(ARGUMENT); return K_IMPORT; }
<KEYWORD>include { BEGIN(ARGUMENT); return K_INCLUDE; }
<KEYWORD>input { BEGIN(ARGUMENT); return K_INPUT; }
<KEYWORD>key { BEGIN(ARGUMENT); return K_KEY; }
<KEYWORD>leaf { BEGIN(ARGUMENT); return K_LEAF; }
<KEYWORD>leaf-list { BEGIN(ARGUMENT); return K_LEAF_LIST; }
<KEYWORD>length { BEGIN(ARGUMENT); return K_LENGTH; }
<KEYWORD>list { BEGIN(ARGUMENT); return K_LIST; }
<KEYWORD>mandatory { BEGIN(ARGUMENT); return K_MANDATORY; }
<KEYWORD>max-elements { BEGIN(ARGUMENT); return K_MAX_ELEMENTS; }
<KEYWORD>min-elements { BEGIN(ARGUMENT); return K_MIN_ELEMENTS; }
<KEYWORD>module { BEGIN(ARGUMENT); return K_MODULE; }
<KEYWORD>must { BEGIN(STRING0); return K_MUST; }
<KEYWORD>namespace { BEGIN(ARGUMENT); return K_NAMESPACE; }
<KEYWORD>notification { BEGIN(ARGUMENT); return K_NOTIFICATION; }
<KEYWORD>ordered-by { BEGIN(ARGUMENT); return K_ORDERED_BY; }
<KEYWORD>organization { BEGIN(STRING0); return K_ORGANIZATION; }
<KEYWORD>output { BEGIN(ARGUMENT); return K_OUTPUT; }
<KEYWORD>path { BEGIN(ARGUMENT); return K_PATH; }
<KEYWORD>pattern { BEGIN(STRING0); return K_PATTERN; }
<KEYWORD>position { BEGIN(ARGUMENT); return K_POSITION; }
<KEYWORD>prefix { BEGIN(ARGUMENT); return K_PREFIX; }
<KEYWORD>presence { BEGIN(STRING0); return K_PRESENCE; }
<KEYWORD>range { BEGIN(ARGUMENT); return K_RANGE; }
<KEYWORD>reference { BEGIN(STRING0); return K_REFERENCE; }
<KEYWORD>refine { BEGIN(ARGUMENT); return K_REFINE; }
<KEYWORD>require-instance { BEGIN(ARGUMENT); return K_REQUIRE_INSTANCE; }
<KEYWORD>revision { BEGIN(ARGUMENT); return K_REVISION; }
<KEYWORD>revision-date { BEGIN(ARGUMENT); return K_REVISION_DATE; }
<KEYWORD>rpc { BEGIN(ARGUMENT); return K_RPC; }
<KEYWORD>status { BEGIN(ARGUMENT); return K_STATUS; }
<KEYWORD>submodule { BEGIN(ARGUMENT); return K_SUBMODULE; }
<KEYWORD>type { BEGIN(ARGUMENT); return K_TYPE; }
<KEYWORD>typedef { BEGIN(ARGUMENT); return K_TYPEDEF; }
<KEYWORD>unique { BEGIN(ARGUMENT); return K_UNIQUE; }
<KEYWORD>units { BEGIN(STRING0); return K_UNITS; }
<KEYWORD>uses { BEGIN(ARGUMENT); return K_USES; }
<KEYWORD>value { BEGIN(ARGUMENT); return K_VALUE; }
<KEYWORD>when { BEGIN(STRING0); return K_WHEN; }
<KEYWORD>yang-version { BEGIN(ARGUMENT); return K_YANG_VERSION; }
<KEYWORD>yin-element { BEGIN(ARGUMENT); return K_YIN_ELEMENT; }
<KEYWORD>. { return K_UNKNOWN; }
<ARGUMENT>; { BEGIN(KEYWORD); return *yytext; }
<ARGUMENT>\{ { BEGIN(KEYWORD); return *yytext; }
<ARGUMENT>\" { _YY->yy_lex_string_state =ARGUMENT; BEGIN(STRING1); return DQ; }
<ARGUMENT>\' { _YY->yy_lex_string_state =ARGUMENT; BEGIN(STRING2); return DQ; }
<ARGUMENT>\+ { return *yytext; /* many arg rules dont like this */ }
<ARGUMENT>: { return *yytext; /* many arg rules dont like this */ }
<ARGUMENT>. { clicon_yang_parselval.string = strdup(yytext);
return CHAR;}
<STRING0>\{ { BEGIN(KEYWORD); return *yytext; }
<STRING0>; { BEGIN(KEYWORD); return *yytext; }
<STRING0>\" { _YY->yy_lex_string_state =STRING0; BEGIN(STRING1); return DQ; }
<STRING0>\' { _YY->yy_lex_string_state =STRING0; BEGIN(STRING2); return DQ; }
<STRING0>\+ { return *yytext; }
<STRING0>. { clicon_yang_parselval.string = strdup(yytext);
return CHAR;}
<STRING1>\\ { _YY->yy_lex_state = STRING1; BEGIN(ESCAPE); }
<STRING1>\" { BEGIN(_YY->yy_lex_string_state); return DQ; }
<STRING1>\n { _YY->yy_linenum++; clicon_yang_parselval.string = strdup(yytext); return CHAR;}
<STRING1>. { clicon_yang_parselval.string = strdup(yytext);
return CHAR;}
<STRING2>\\ { _YY->yy_lex_state = STRING2; BEGIN(ESCAPE); }
<STRING2>\' { BEGIN(_YY->yy_lex_string_state); return DQ; }
<STRING2>\n { _YY->yy_linenum++; clicon_yang_parselval.string = strdup(yytext); return CHAR;}
<STRING2>. { clicon_yang_parselval.string = strdup(yytext);
return CHAR;}
<ESCAPE>. { BEGIN(_YY->yy_lex_state);
clicon_yang_parselval.string = strdup(yytext);
return CHAR; }
<COMMENT1>[^*\n]* /* eat anything that's not a '*' */
<COMMENT1>"*"+[^*/\n]* /* eat up '*'s not followed by '/'s */
<COMMENT1>"*"+"/" BEGIN(_YY->yy_lex_state);
<COMMENT2>[^\n]* /* eat anything that's not a '/' */
<COMMENT2>\n { _YY->yy_linenum++; BEGIN(_YY->yy_lex_state); }
%%
/*
* yang_parse_init
* Initialize scanner.
*/
int
yang_scan_init(struct clicon_yang_yacc_arg *yy)
{
BEGIN(KEYWORD);
yy->yy_lexbuf = yy_scan_string (yy->yy_parse_string);
#if 1 /* XXX: just to use unput to avoid warning */
if (0)
yyunput(0, "");
#endif
return 0;
}
/*
* yang_parse_exit
* free buffers
* Even within Flex version 2.5 (this is assumed), freeing buffers is different.
*/
int
yang_scan_exit(struct clicon_yang_yacc_arg *yy)
{
yy_delete_buffer(yy->yy_lexbuf);
#if defined(YY_FLEX_SUBMINOR_VERSION) && YY_FLEX_SUBMINOR_VERSION >= 9
clicon_yang_parselex_destroy(); /* modern */
#else
yy_init = 1; /* This does not quite free all buffers */
#endif
return 0;
}