fminject/common/inj_grammar.y

	inj_grammar.y revision 7aec1d6e253b21f9e9b7ef68b4d81ab9859b51fe
%{
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * FMA Event Injector language parser
 */

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#include <inj.h>
#include <inj_err.h>
#include <inj_event.h>
#include <inj_hash.h>
#include <inj_lex.h>

%}

%union {
    inj_decl_t *l_decl;
    inj_declmem_t *l_declmem;
    inj_defn_t *l_defn;
    inj_defnmem_t *l_defnmem;
    inj_cmd_t *l_command;
    inj_randelem_t *l_randelem;

    inj_hash_t *l_hash;

    char *l_string;
    uint_t l_number;
    hrtime_t l_hrtime;
}

%type   <l_decl>    decl_memlist
%type   <l_declmem> decl_mem
%type   <l_declmem> decl_baremem
%type   <l_declmem> decl_mem_intr
%type   <l_number>  decl_intr_type
%type   <l_number>  decl_arraydim
%type   <l_declmem> decl_mem_cplx
%type   <l_hash>    decl_enumlist

%type   <l_defn>    defn_memlist
%type   <l_defnmem> defn_memvals
%type   <l_defnmem> defn_val

%type   <l_command> command
%type   <l_command> cmd_repeatable
%type   <l_randelem>    rand_problist
%type   <l_randelem>    rand_element

%type   <l_defn>    defined_event
%type   <l_number>  number
%type   <l_hrtime>  hrtime

%token  INJ_TOK_EVDEF
%token  INJ_TOK_FMRIDEF
%token  INJ_TOK_AUTHDEF
%token  INJ_TOK_LISTDEF

%token  INJ_TOK_INT8
%token  INJ_TOK_INT16
%token  INJ_TOK_INT32
%token  INJ_TOK_INT64
%token  INJ_TOK_UINT8
%token  INJ_TOK_UINT16
%token  INJ_TOK_UINT32
%token  INJ_TOK_UINT64
%token  INJ_TOK_BOOLEAN
%token  INJ_TOK_STRING
%token  INJ_TOK_ENUM

%token  INJ_TOK_EVENT
%token  INJ_TOK_FMRI
%token  INJ_TOK_AUTH
%token  INJ_TOK_LIST

%token  INJ_TOK_ADDHRT
%token  INJ_TOK_ENDHRT
%token  INJ_TOK_SLEEP
%token  INJ_TOK_REPEAT
%token  INJ_TOK_RANDOMIZE

%token  <l_string> INJ_TOK_IDENT
%token  <l_string> INJ_TOK_FMACLASS
%token  <l_string> INJ_TOK_IMM
%token  <l_string> INJ_TOK_QSTRING

%%

statement_list: /* EMPTY */
    |   statement_list statement ';'
    ;

statement:  decl
    |   defn
    |   command {
            if ($1 != NULL)
                inj_cmds_add($1);
        }
    ;

/*
 * Event, FMRI, Authority, and list declarations
 */

decl:       INJ_TOK_EVDEF INJ_TOK_FMACLASS '{' decl_memlist '}' {
            if ($4 != NULL)
                inj_decl_finish($4, $2, ITEMTYPE_EVENT);
        }
    |   INJ_TOK_FMRIDEF INJ_TOK_IDENT '{' decl_memlist '}' {
            if ($4 != NULL)
                inj_decl_finish($4, $2, ITEMTYPE_FMRI);
        }
    |   INJ_TOK_AUTHDEF INJ_TOK_IDENT '{' decl_memlist '}' {
            if ($4 != NULL)
                inj_decl_finish($4, $2, ITEMTYPE_AUTH);
        }
    |   INJ_TOK_LISTDEF INJ_TOK_IDENT '{' decl_memlist '}' {
            if ($4 != NULL)
                inj_decl_finish($4, $2, ITEMTYPE_LIST);
        }
    ;

decl_memlist:   /* EMPTY */ { $$ = NULL; }
    |   decl_memlist decl_mem ';' {
            if ($2 == NULL) {
                $$ = $1;
            } else if ($1 == NULL) {
                $$ = inj_decl_create($2);
            } else {
                inj_decl_addmem($1, $2);
                $$ = $1;
            }
        }
    ;

decl_mem:   decl_baremem
    |   decl_baremem decl_arraydim {
            if ($1 != NULL)
                inj_decl_mem_make_array($1, $2);
            $$ = $1;
        }
    ;

decl_baremem:   decl_mem_intr
    |   decl_mem_cplx
    ;

decl_mem_intr:  decl_intr_type INJ_TOK_IDENT {
            $$ = inj_decl_mem_create($2, $1);
        }
    ;

decl_intr_type: INJ_TOK_INT8        { $$ = MEMTYPE_INT8; }
    |   INJ_TOK_INT16       { $$ = MEMTYPE_INT16; }
    |   INJ_TOK_INT32       { $$ = MEMTYPE_INT32; }
    |   INJ_TOK_INT64       { $$ = MEMTYPE_INT64; }
    |   INJ_TOK_UINT8       { $$ = MEMTYPE_UINT8; }
    |   INJ_TOK_UINT16      { $$ = MEMTYPE_UINT16; }
    |   INJ_TOK_UINT32      { $$ = MEMTYPE_UINT32; }
    |   INJ_TOK_UINT64      { $$ = MEMTYPE_UINT64; }
    |   INJ_TOK_BOOLEAN     { $$ = MEMTYPE_BOOL; }
    |   INJ_TOK_STRING      { $$ = MEMTYPE_STRING; }
    ;

decl_arraydim:  '[' number ']' {
            $$ = $2;
        }
    |   '[' ']' {
            $$ = 0;
        }
    ;

decl_mem_cplx:  INJ_TOK_ENUM INJ_TOK_IDENT '{' decl_enumlist '}' {
            $$ = inj_decl_mem_create_enum($2, $4);
        }
    |   INJ_TOK_EVENT INJ_TOK_FMACLASS INJ_TOK_IDENT {
            $$ = inj_decl_mem_create_defined($3, $2,
                ITEMTYPE_EVENT);
        }
    |   INJ_TOK_FMRI INJ_TOK_IDENT INJ_TOK_IDENT {
            $$ = inj_decl_mem_create_defined($3, $2,
                ITEMTYPE_FMRI);
        }
    |   INJ_TOK_AUTH INJ_TOK_IDENT INJ_TOK_IDENT {
            $$ = inj_decl_mem_create_defined($3, $2,
                ITEMTYPE_AUTH);
        }
    |   INJ_TOK_LIST INJ_TOK_IDENT INJ_TOK_IDENT {
            $$ = inj_decl_mem_create_defined($3, $2,
                ITEMTYPE_LIST);
        }
    ;

decl_enumlist:  INJ_TOK_IDENT {
            $$ = inj_zalloc(sizeof (inj_hash_t));
            inj_strhash_create($$);

            inj_strhash_insert($$, $1, 1);
        }
    |   decl_enumlist ',' INJ_TOK_IDENT {
            if (inj_strhash_lookup($1, $3) != NULL)
                yyerror("duplicate enum value \"%s\"", $3);
            else
                inj_strhash_insert($1, $3, 1);
            $$ = $1;
        }
    ;

/*
 * Event, FMRI, Authority, and list definitions
 */

defn:       INJ_TOK_EVENT INJ_TOK_FMACLASS INJ_TOK_IDENT '='
            '{' defn_memlist '}' {
            inj_defn_finish($6, $2, $3, ITEMTYPE_EVENT);
            inj_strfree($2);
        }
    |   INJ_TOK_FMRI INJ_TOK_IDENT INJ_TOK_IDENT '='
            '{' defn_memlist '}' {
            inj_defn_finish($6, $2, $3, ITEMTYPE_FMRI);
            inj_strfree($2);
        }
    |   INJ_TOK_AUTH INJ_TOK_IDENT INJ_TOK_IDENT '='
            '{' defn_memlist '}' {
            inj_defn_finish($6, $2, $3, ITEMTYPE_AUTH);
            inj_strfree($2);
        }
    ;

defn_memlist:   defn_memvals {
            $$ = inj_defn_create($1);
        }
    |   defn_memlist ',' defn_memvals {
            inj_defn_addmem($1, $3);
            $$ = $1;
        }
    ;

defn_memvals:   defn_val
    |   INJ_TOK_EVENT INJ_TOK_FMACLASS {
            $$ = inj_defn_mem_create($2, DEFNMEM_EVENT);
        }
    |   INJ_TOK_FMRI INJ_TOK_IDENT {
            $$ = inj_defn_mem_create($2, DEFNMEM_FMRI);
        }
    |   INJ_TOK_AUTH INJ_TOK_IDENT {
            $$ = inj_defn_mem_create($2, DEFNMEM_AUTH);
        }
    |   '[' defn_memlist ']' {
            $$ = inj_defn_mem_create_list($2, DEFNMEM_ARRAY);
        }
    |   '{' defn_memlist '}' {
            $$ = inj_defn_mem_create_list($2, DEFNMEM_LIST);
        }
    ;

defn_val:   INJ_TOK_IMM {
            $$ = inj_defn_mem_create($1, DEFNMEM_IMM);
        }
    |   INJ_TOK_IDENT {
            $$ = inj_defn_mem_create($1, DEFNMEM_IDENT);
        }
    |   INJ_TOK_QSTRING {
            $$ = inj_defn_mem_create($1, DEFNMEM_QSTRING);
        }
    ;

/*
 * Commands
 */

command:    cmd_repeatable
    |   INJ_TOK_ADDHRT hrtime { $$ = inj_cmd_addhrt($2); }
    |   INJ_TOK_ENDHRT { $$ = inj_cmd_endhrt(); }
    |   INJ_TOK_SLEEP number { $$ = inj_cmd_sleep($2); }
    |   INJ_TOK_REPEAT number cmd_repeatable {
            $$ = ($3 == NULL ? NULL : inj_cmd_repeat($3, $2));
        }
    ;

cmd_repeatable: defined_event {
            $$ = ($1 == NULL ? NULL : inj_cmd_send($1));
        }
    |   INJ_TOK_RANDOMIZE '{' rand_problist '}' {
            $$ = ($3 == NULL ? NULL : inj_cmd_rand($3));
        }
    ;

rand_problist:  rand_element
    |   rand_problist ',' rand_element {
            $$ = ($1 == NULL || $3 == NULL) ?
                NULL : inj_rand_add($1, $3);
        }
    ;

rand_element:   '{' defined_event ',' number '}' {
            $$ = ($2 == NULL ? NULL : inj_rand_create($2, $4));
        }
    ;

defined_event:  INJ_TOK_IDENT {
            inj_defn_t *ev;

            if ((ev = inj_defn_lookup($1, MEMTYPE_EVENT)) ==
                NULL) {
                yyerror("unknown event \"%s\"\n", $1);
                $$ = NULL;
            } else
                $$ = ev;
        }

number:     INJ_TOK_IMM {
            u_longlong_t val;

            if (inj_strtoull($1, 32, &val) < 0) {
                yyerror("invalid number");
                $$ = 0;
            } else
                $$ = (uint32_t)val;
        }

hrtime:     INJ_TOK_IMM INJ_TOK_IDENT {
            longlong_t val;

            if (inj_strtoll($1, 64, &val) < 0 ||
                inj_strtime(&val, $2) < 0) {
                yyerror("invalid time");
                $$ = 0;
            } else
                $$ = val;
        }

%%

inj_list_t *
inj_program_read(const char *file)
{
    if (strcmp(file, "-") == 0) {
        yyin = stdin;
        yyinname = "stdin";
    } else {
        if ((yyin = fopen(file, "r")) == NULL)
            die("failed to open %s", file);

        yyinname = strrchr(file, '/');
        if (yyinname != NULL)
            yyinname++;
        else
            yyinname = file;
    }

    yyreset();
    (void) yyparse();

    if (yyin != stdin)
        (void) fclose(yyin);

    if (yynerrors != 0) {
        die("parsing failed - %d error%s\n", yynerrors,
            (yynerrors > 1 ? "s" : ""));
    }

    return (inj_cmds_get());
}