eversholt/common/escparse.y

%{
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * escparse.y -- parser for esc
 *
 * this is the yacc-based parser for Eversholt.  the syntax is simple
 * and is defined by the LALR(1) grammar described by this file.  there
 * should be no shift/reduce or reduce/reduce messages when building this
 * file.
 *
 * as the input is parsed, a parse tree is built by calling the
 * tree_X() functions defined in tree.c.  any syntax errors cause
 * us to skip to the next semicolon, achieved via the "error" clause
 * in the stmt rule below.  the yacc state machine code will call
 * yyerror() in esclex.c and that will keep count of the errors and
 * display the filename, line number, and current input stream of tokens
 * to help the user figure out the problem.  the -Y flag to this program
 * turns on the yacc debugging output which is quite large.  you probably
 * only need to do that if you're debugging the grammar below.
 *
 */

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include "out.h"
#include "stable.h"
#include "literals.h"
#include "lut.h"
#include "esclex.h"
#include "tree.h"

%}
%union {
    struct tokstr tok;
    struct node *np;
}

%right '='

/*
 * make sure ':' comes immediately after '?' in precedence declarations
 */
%right '?'
%nonassoc ':'

%left OR
%left AND
%left '|'
%left '^'
%left '&'
%left EQ NE
%left LE GE '<' '>'
%left LSHIFT RSHIFT
%left '-' '+'
%left '*' '%' DIV '/'
%right '!' '~'
%left '.'

%token <tok> PROP MASK ARROW EVENT ENGINE ASRU FRU COUNT CONFIG
%token <tok> ID QUOTE NUMBER IF PATHFUNC
%type <tok> enameid
%type <np> root stmtlist stmt nvpairlist nvpair nvname nvexpr
%type <np> exprlist expr iterid ename pname epname eexprlist ipname iname
%type <np> numexpr cexpr func pfunc parglist parg
%type <np> eventlist event nork norkexpr globid propbody

%%

root    : stmtlist
        { (void)tree_root($1); }
    ;

stmtlist   : /*empty*/
        { $$ = NULL; }
        | stmtlist stmt
        { $$ = tree_expr(T_LIST, $1, $2); }
    ;

stmt    : error ';'
            { $$ = tree_nothing(); }
    | IF '(' expr ')' stmt
        { $$ = $5; }
    | IF '(' expr ')' '{' stmtlist '}'
        { $$ = $6; }
    | EVENT event nvpairlist ';'
        { $$ = tree_decl(T_EVENT, $2, $3, $1.file, $1.line); }
    | ENGINE event nvpairlist ';'
        { $$ = tree_decl(T_ENGINE, $2, $3, $1.file, $1.line); }
    | PROP propbody ';'
        {
            $$ = tree_stmt(T_PROP, $2, $1.file, $1.line);
        }
    | MASK propbody ';'
        {
            $$ = tree_stmt(T_MASK, $2, $1.file, $1.line);
        }
    | ASRU pname nvpairlist ';'
        {
            $$ = tree_decl(T_ASRU, $2, $3, $1.file, $1.line);
        }
    | FRU pname nvpairlist ';'
        {
            $$ = tree_decl(T_FRU, $2, $3, $1.file, $1.line);
        }
    | CONFIG ipname nvpairlist ';'
        {
            $$ = tree_decl(T_CONFIG, $2, $3, $1.file, $1.line);
        }
    | /*superfluous semicolons are ignored*/ ';'
            { $$ = tree_nothing(); }
    ;

propbody: eventlist nork ARROW nork eventlist
        {
            $$ = tree_arrow($1, $2, $4, $5);
        }
    | propbody nork ARROW nork eventlist
        {
            $$ = tree_arrow($1, $2, $4, $5);
        }
    ;

nork    : /* empty */
        { $$ = NULL; }
    | '(' norkexpr ')'
        { $$ = $2; }
    ;

norkexpr: NUMBER
        { $$ = tree_num($1.s, $1.file, $1.line); }
    | ID
        /* really can only be 'A', enforced by check_arrow() later */
            { $$ = tree_name($1.s, IT_NONE, $1.file, $1.line); }
    | '(' norkexpr ')'
        { $$ = $2; }
    | norkexpr '-' norkexpr
        { $$ = tree_expr(T_SUB, $1, $3); }
    | norkexpr '+' norkexpr
        { $$ = tree_expr(T_ADD, $1, $3); }
    | norkexpr '*' norkexpr
        { $$ = tree_expr(T_MUL, $1, $3); }
    | norkexpr DIV norkexpr
        { $$ = tree_expr(T_DIV, $1, $3); }
    | norkexpr '%' norkexpr
        { $$ = tree_expr(T_MOD, $1, $3); }
    ;

nvpairlist: /* empty */
        { $$ = NULL; }
    | nvpair
    | nvpairlist ',' nvpair
        { $$ = tree_expr(T_LIST, $1, $3); }
    ;

nvpair  : nvname '=' nvexpr
        { $$ = tree_expr(T_NVPAIR, $1, $3); }
    | ENGINE '=' nvexpr
        /* "engine" is a reserved word, but a valid property name */
        {
            $$ = tree_expr(T_NVPAIR,
                tree_name($1.s, IT_NONE, $1.file, $1.line), $3);
        }
    | COUNT '=' nvexpr
        /* "count" is a reserved word, but a valid property name */
        {
            $$ = tree_expr(T_NVPAIR,
                tree_name($1.s, IT_NONE, $1.file, $1.line), $3);
        }
    ;

nvname  : ID
        { $$ = tree_name($1.s, IT_NONE, $1.file, $1.line); }
    | nvname '-' ID
        {
            /* hack to allow dashes in property names */
            $$ = tree_name_repairdash($1, $3.s);
        }
    ;

/* the RHS of an nvpair can be a value, or an ename, or an ename@pname */
nvexpr  : numexpr
    | ename epname
        { $$ = tree_event($1, $2, NULL); }
    | pname
    | globid
    | func
    | NUMBER ID
        /*
         * ID must be timevals only ("ms", "us", etc.).
         * enforced by tree_timeval().
         */
        { $$ = tree_timeval($1.s, $2.s, $1.file, $1.line); }
    | QUOTE
        { $$ = tree_quote($1.s, $1.file, $1.line); }
    ;

/* arithmetic operations, no variables or symbols */
numexpr : numexpr '-' numexpr
        { $$ = tree_expr(T_SUB, $1, $3); }
    | numexpr '+' numexpr
        { $$ = tree_expr(T_ADD, $1, $3); }
    | numexpr '*' numexpr
        { $$ = tree_expr(T_MUL, $1, $3); }
    | numexpr DIV numexpr
        { $$ = tree_expr(T_DIV, $1, $3); }
    | numexpr '/' numexpr
        { $$ = tree_expr(T_DIV, $1, $3); }
    | numexpr '%' numexpr
        { $$ = tree_expr(T_MOD, $1, $3); }
    | '(' numexpr ')'
        { $$ = $2; }
    | NUMBER
        { $$ = tree_num($1.s, $1.file, $1.line); }
    ;

eventlist: event
    | eventlist ',' event
        { $$ = tree_expr(T_LIST, $1, $3); }
    ;

event   : ename epname eexprlist
        { $$ = tree_event($1, $2, $3); }
    ;

epname  : /* empty */
        { $$ = NULL; }
    | '@' pname
        { $$ = $2; }
    ;

eexprlist: /* empty */
        { $$ = NULL; }
    | '{' exprlist '}'
        { $$ = $2; }
    ;

exprlist: expr
    | exprlist ',' expr
        { $$ = tree_expr(T_LIST, $1, $3); }
    ;

/*
 * note that expr does not include pname, to avoid reduce/reduce
 * conflicts between cexpr and iterid involving the use of ID
 */
expr    : cexpr
    | NUMBER ID
        /*
         * ID must be timevals only ("ms", "us", etc.).
         * enforced by tree_timeval().
         */
        { $$ = tree_timeval($1.s, $2.s, $1.file, $1.line); }
    ;

cexpr   : cexpr '=' cexpr
        { $$ = tree_expr(T_ASSIGN, $1, $3); }
    | cexpr '?' cexpr
        { $$ = tree_expr(T_CONDIF, $1, $3); }
    | cexpr ':' cexpr
        { $$ = tree_expr(T_CONDELSE, $1, $3); }
    | cexpr OR cexpr
        { $$ = tree_expr(T_OR, $1, $3); }
    | cexpr AND cexpr
        { $$ = tree_expr(T_AND, $1, $3); }
    | cexpr '|' cexpr
        { $$ = tree_expr(T_BITOR, $1, $3); }
    | cexpr '^' cexpr
        { $$ = tree_expr(T_BITXOR, $1, $3); }
    | cexpr '&' cexpr
        { $$ = tree_expr(T_BITAND, $1, $3); }
    | cexpr EQ cexpr
        { $$ = tree_expr(T_EQ, $1, $3); }
    | cexpr NE cexpr
        { $$ = tree_expr(T_NE, $1, $3); }
    | cexpr '<' cexpr
        { $$ = tree_expr(T_LT, $1, $3); }
    | cexpr LE cexpr
        { $$ = tree_expr(T_LE, $1, $3); }
    | cexpr '>' cexpr
        { $$ = tree_expr(T_GT, $1, $3); }
    | cexpr GE cexpr
        { $$ = tree_expr(T_GE, $1, $3); }
    | cexpr LSHIFT cexpr
        { $$ = tree_expr(T_LSHIFT, $1, $3); }
    | cexpr RSHIFT cexpr
        { $$ = tree_expr(T_RSHIFT, $1, $3); }
    | cexpr '-' cexpr
        { $$ = tree_expr(T_SUB, $1, $3); }
    | cexpr '+' cexpr
        { $$ = tree_expr(T_ADD, $1, $3); }
    | cexpr '*' cexpr
        { $$ = tree_expr(T_MUL, $1, $3); }
    | cexpr DIV cexpr
        { $$ = tree_expr(T_DIV, $1, $3); }
    | cexpr '/' cexpr
        { $$ = tree_expr(T_DIV, $1, $3); }
    | cexpr '%' cexpr
        { $$ = tree_expr(T_MOD, $1, $3); }
    |  '!' cexpr
        { $$ = tree_expr(T_NOT, $2, NULL); }
    |  '~' cexpr
        { $$ = tree_expr(T_BITNOT, $2, NULL); }
    | '(' cexpr ')'
        { $$ = $2; }
    | func
    | NUMBER
        { $$ = tree_num($1.s, $1.file, $1.line); }
    | ID
            {
            /* iteration variable */
            $$ = tree_name($1.s, IT_NONE, $1.file, $1.line);
        }
    | globid
    | QUOTE
        { $$ = tree_quote($1.s, $1.file, $1.line); }
    ;

func    : ID '(' ')'
        { $$ = tree_func($1.s, NULL, $1.file, $1.line); }
    | ID '(' exprlist ')'
        { $$ = tree_func($1.s, $3, $1.file, $1.line); }
    | PATHFUNC '(' parglist ')'
        { $$ = tree_func($1.s, $3, $1.file, $1.line); }
    | pfunc
    ;

parglist: parg
    | parglist ',' parg
        { $$ = tree_expr(T_LIST, $1, $3); }
    ;

parg    : pfunc
    | pname
        { $$ = tree_pname($1); }
    | QUOTE
        { $$ = tree_quote($1.s, $1.file, $1.line); }
    | ID '(' exprlist ')'
        { $$ = tree_func($1.s, $3, $1.file, $1.line); }
    ;

/*
 * these functions are in the grammar so we can force the arg to be
 * a path or an event.  they show up as functions in the parse tree.
 */
pfunc   : ASRU '(' pname ')'
        { $$ = tree_func($1.s, tree_pname($3), $1.file, $1.line); }
    | FRU '(' pname ')'
        { $$ = tree_func($1.s, tree_pname($3), $1.file, $1.line); }
    | COUNT '(' event ')'
        { $$ = tree_func($1.s, $3, $1.file, $1.line); }
    ;

globid  : '$' ID
            { $$ = tree_globid($2.s, $2.file, $2.line); }
    ;

iterid  : ID
            { $$ = tree_name($1.s, IT_VERTICAL, $1.file, $1.line); }
    | ID '[' ']'
            { $$ = tree_name($1.s, IT_VERTICAL, $1.file, $1.line); }
    | ID '[' cexpr ']'
            {
            $$ = tree_name_iterator(
               tree_name($1.s, IT_VERTICAL, $1.file, $1.line), $3);
        }
    | ID '<' '>'
            { $$ = tree_name($1.s, IT_HORIZONTAL, $1.file, $1.line); }
    | ID '<' ID '>'
            {
            $$ = tree_name_iterator(
                tree_name($1.s, IT_HORIZONTAL, $1.file, $1.line),
                tree_name($3.s, IT_NONE, $3.file, $3.line));
        }
    | ID '-' iterid
        {
            /* hack to allow dashes in path name components */
            $$ = tree_name_repairdash2($1.s, $3);
        }
    ;

/* iname is an ID where we can peel numbers off the end */
iname   : ID
            { $$ = tree_iname($1.s, $1.file, $1.line); }
    ;

/* base case of ID.ID instead of just ID requires ename to contain one dot */
ename   : ID '.' enameid
            {
            $$ = tree_name_append(
                tree_name($1.s, IT_ENAME, $1.file, $1.line),
                tree_name($3.s, IT_NONE, $3.file, $3.line));
        }
    | ename '.' enameid
        {
            $$ = tree_name_append($1,
                tree_name($3.s, IT_NONE, $3.file, $3.line));
        }
    | ename '-' enameid
        {
            /*
             * hack to allow dashes in class names.  when we
             * detect the dash here, we know we're in a class
             * name because the left recursion of this rule
             * means we've already matched at least:
             *  ID '.' ID
             * so the ename here has an incomplete final
             * component (because the lexer stopped at the
             * dash).  so we repair that final component here.
             */
            $$ = tree_name_repairdash($1, $3.s);
        }
    ;

/* like an ID, but we let reserved words act unreserved in enames */
enameid : ID
    | PROP
    | MASK
    | EVENT
    | ENGINE
    | ASRU
    | FRU
    | CONFIG
    | IF
    ;

/* pname is a pathname, like x/y, x<i>/y[0], etc */
pname   : iterid
    | pname '/' iterid
        { $$ = tree_name_append($1, $3); }
    ;

/* ipname is an "instanced" pathname, like x0/y1 */
ipname  : iname
    | ipname '/' iname
        { $$ = tree_name_append($1, $3); }
    ;

%%