tnf/prex/prexlex.l

%{
/*
 * 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 (c) 1994, by Sun Microsytems, Inc.
 */

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

%a 10000
%o 10000

%{
#include "spec.h"
#include "expr.h"
#include "y.tab.h"
#include <stdlib.h>
#include <string.h>

char *  qtstr       (char *     instr);
char *  rgstr       (char *     instr);

/*
** we substitute i/o routines defined in main.c for the
** standard fare.  This allows us to support the "source"
** function by redirecting the input stream from different
** places
*/
#include "source.h"
#undef input
#undef unput
#undef output
#define input()     source_input()
#define unput(c)    source_unput(c)
#define output(c)   source_output(c)
%}

IDFIRST         [a-zA-Z_\.%]
IDCHAR          ({IDFIRST}|[0-9])
ID          {IDFIRST}{IDCHAR}*

%%

#.*         ;       /* eat comments */
[ \t]+          ;       /* eats whitespace */

\n          { source_nl(); return NL; }
\\\n            { source_nl(); } /* escaped newline */
=           return (EQ);
\,          return (COMMA);

add         { yylval.intval = ADD; return (ADD); }
alloc           { yylval.intval = ALLOC; return (ALLOC); }
buffer          { yylval.intval = BUFFER; return (BUFFER); }
clear           { yylval.intval = CLEAR; return (CLEAR); }
connect         { yylval.intval = CONNECT; return (CONNECT); }
continue        { yylval.intval = CONTINUE; return (CONTINUE); }
create          { yylval.intval = CREATE; return (CREATE); }
dealloc         { yylval.intval = DEALLOC; return (DEALLOC); }
delete          { yylval.intval = DELETE; return (DELETE); }
disable         { yylval.intval = DISABLE; return (DISABLE); }
enable          { yylval.intval = ENABLE; return (ENABLE); }
fcns            { yylval.intval = FCNS; return (FCNS); }
filter          { yylval.intval = FILTER; return (FILTER); }
help            { yylval.intval = HELP; return (HELP); }
history         { yylval.intval = HISTORY; return (HISTORY); }
tracefile       { yylval.intval = TRACEFILE; return (TRACEFILE); }
kill            { yylval.intval = KILL; return (KILL); }
ktrace          { yylval.intval = KTRACE; return (KTRACE); }
list            { yylval.intval = LIST; return (LIST); }
off         { yylval.intval = OFF; return (OFF); }
on          { yylval.intval = ON; return (ON); }
pfilter         { yylval.intval = PFILTER; return (PFILTER); }
probes          { yylval.intval = PROBES; return (PROBES); }
quit            { yylval.intval = QUIT; return (QUIT); }
resume          { yylval.intval = RESUME; return (RESUME); }
sets            { yylval.intval = SETS; return (SETS); }
source          { yylval.intval = SOURCE; return (SOURCE); }
suspend         { yylval.intval = SUSPEND; return (SUSPEND); }
trace           { yylval.intval = TRACE; return (TRACE); }
untrace         { yylval.intval = UNTRACE; return (UNTRACE); }
values          { yylval.intval = VALUES; return (VALUES); }

${ID}           { yylval.strval = strdup(&yytext[1]); return SETNAME; }
&{ID}           { yylval.strval = strdup(&yytext[1]); return FCNNAME; }
{ID}            { yylval.strval = strdup(yytext); return IDENT; }
\'[^'\n]*\'     { yylval.strval = qtstr(yytext); return VALSTR; }

\/([^/\\\n]|\\.)*\/ { yylval.strval = rgstr(yytext); return REGEXP; }

[0-9]+[KkMm]?       {
                char scale = yytext[yyleng - 1];
                yylval.intval = atoi(yytext);
                if (scale == 'k' || scale == 'K')
                    yylval.intval *= 1024;
                else if (scale == 'm' || scale == 'M')
                    yylval.intval *= 1024 * 1024;
                return (SCALED_INT);
            }

.           return (INVAL); /* barf on anything else */

%%

/****************************************************************
qtstr() - shucks a quoted str, and copies it into new memory
****************************************************************/

char *
qtstr       (char *     instr)
{
    char    *ptr;
    int indx;

    /* skip the leading quote in the copy */
    ptr = strdup(&instr[1]);

    /* null out the trailing quote */
    indx = strlen(ptr) - 1;
    indx = (indx < 0) ? 0 : indx;
    ptr[indx] = '\0';

    return ptr;
}   /* end qtstr */


/****************************************************************
rgstr() - shucks a decorated regular expression, and copies it
into new memory
****************************************************************/

char *
rgstr       (char *     instr)
{
    char    *ptr;
    int indx;

    /* skip the leading slash in the copy */
    ptr = strdup(&instr[1]);

    /* null out the trailing slash */
    indx = strlen(ptr) - 1;
    indx = (indx < 0) ? 0 : indx;
    ptr[indx] = '\0';

    return (ptr);

}   /* end rgstr */