usr/src/cmd/tnf/prex/prexlex.l

   1 %{
   2 /*
   3  * CDDL HEADER START
   4  *
   5  * The contents of this file are subject to the terms of the
   6  * Common Development and Distribution License, Version 1.0 only
   7  * (the "License").  You may not use this file except in compliance
   8  * with the License.
   9  *
  10  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  11  * or http://www.opensolaris.org/os/licensing.
  12  * See the License for the specific language governing permissions
  13  * and limitations under the License.
  14  *
  15  * When distributing Covered Code, include this CDDL HEADER in each
  16  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  17  * If applicable, add the following below this CDDL HEADER, with the
  18  * fields enclosed by brackets "[]" replaced with your own identifying
  19  * information: Portions Copyright [yyyy] [name of copyright owner]
  20  *
  21  * CDDL HEADER END
  22  *
  23  *      Copyright (c) 1994, by Sun Microsytems, Inc.
  24  */
  25
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27 %}
  28
  29 %a 10000
  30 %o 10000
  31
  32 %{
  33 #include "spec.h"
  34 #include "expr.h"
  35 #include "y.tab.h"
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 char *  qtstr           (char *         instr);
  40 char *  rgstr           (char *         instr);
  41
  42 /*
  43 ** we substitute i/o routines defined in main.c for the
  44 ** standard fare.  This allows us to support the "source"
  45 ** function by redirecting the input stream from different
  46 ** places
  47 */
  48 #include "source.h"
  49 #undef input
  50 #undef unput
  51 #undef output
  52 #define input()         source_input()
  53 #define unput(c)        source_unput(c)
  54 #define output(c)       source_output(c)
  55 %}
  56
  57 IDFIRST                 [a-zA-Z_\.%]
  58 IDCHAR                  ({IDFIRST}|[0-9])
  59 ID                      {IDFIRST}{IDCHAR}*
  60
  61 %%
  62
  63 #.*                     ;               /* eat comments */
  64 [ \t]+                  ;               /* eats whitespace */
  65
  66 \n                      { source_nl(); return NL; }
  67 \\\n                    { source_nl(); } /* escaped newline */
  68 =                       return (EQ);
  69 \,                      return (COMMA);
  70
  71 add                     { yylval.intval = ADD; return (ADD); }
  72 alloc                   { yylval.intval = ALLOC; return (ALLOC); }
  73 buffer                  { yylval.intval = BUFFER; return (BUFFER); }
  74 clear                   { yylval.intval = CLEAR; return (CLEAR); }
  75 connect                 { yylval.intval = CONNECT; return (CONNECT); }
  76 continue                { yylval.intval = CONTINUE; return (CONTINUE); }
  77 create                  { yylval.intval = CREATE; return (CREATE); }
  78 dealloc                 { yylval.intval = DEALLOC; return (DEALLOC); }
  79 delete                  { yylval.intval = DELETE; return (DELETE); }
  80 disable                 { yylval.intval = DISABLE; return (DISABLE); }
  81 enable                  { yylval.intval = ENABLE; return (ENABLE); }
  82 fcns                    { yylval.intval = FCNS; return (FCNS); }
  83 filter                  { yylval.intval = FILTER; return (FILTER); }
  84 help                    { yylval.intval = HELP; return (HELP); }
  85 history                 { yylval.intval = HISTORY; return (HISTORY); }
  86 tracefile               { yylval.intval = TRACEFILE; return (TRACEFILE); }
  87 kill                    { yylval.intval = KILL; return (KILL); }
  88 ktrace                  { yylval.intval = KTRACE; return (KTRACE); }
  89 list                    { yylval.intval = LIST; return (LIST); }
  90 off                     { yylval.intval = OFF; return (OFF); }
  91 on                      { yylval.intval = ON; return (ON); }
  92 pfilter                 { yylval.intval = PFILTER; return (PFILTER); }
  93 probes                  { yylval.intval = PROBES; return (PROBES); }
  94 quit                    { yylval.intval = QUIT; return (QUIT); }
  95 resume                  { yylval.intval = RESUME; return (RESUME); }
  96 sets                    { yylval.intval = SETS; return (SETS); }
  97 source                  { yylval.intval = SOURCE; return (SOURCE); }
  98 suspend                 { yylval.intval = SUSPEND; return (SUSPEND); }
  99 trace                   { yylval.intval = TRACE; return (TRACE); }
 100 untrace                 { yylval.intval = UNTRACE; return (UNTRACE); }
 101 values                  { yylval.intval = VALUES; return (VALUES); }
 102
 103 ${ID}                   { yylval.strval = strdup(&yytext[1]); return SETNAME; }
 104 &{ID}                   { yylval.strval = strdup(&yytext[1]); return FCNNAME; }
 105 {ID}                    { yylval.strval = strdup(yytext); return IDENT; }
 106 \'[^'\n]*\'             { yylval.strval = qtstr(yytext); return VALSTR; }
 107
 108 \/([^/\\\n]|\\.)*\/     { yylval.strval = rgstr(yytext); return REGEXP; }
 109
 110 [0-9]+[KkMm]?           {
 111                                 char scale = yytext[yyleng - 1];
 112                                 yylval.intval = atoi(yytext);
 113                                 if (scale == 'k' || scale == 'K')
 114                                         yylval.intval *= 1024;
 115                                 else if (scale == 'm' || scale == 'M')
 116                                         yylval.intval *= 1024 * 1024;
 117                                 return (SCALED_INT);
 118                         }
 119
 120 .                       return (INVAL); /* barf on anything else */
 121
 122 %%
 123
 124 /****************************************************************
 125 qtstr() - shucks a quoted str, and copies it into new memory
 126 ****************************************************************/
 127
 128 char *
 129 qtstr           (char *         instr)
 130 {
 131         char    *ptr;
 132         int     indx;
 133
 134         /* skip the leading quote in the copy */
 135         ptr = strdup(&instr[1]);
 136
 137         /* null out the trailing quote */
 138         indx = strlen(ptr) - 1;
 139         indx = (indx < 0) ? 0 : indx;
 140         ptr[indx] = '\0';
 141
 142         return ptr;
 143 }   /* end qtstr */
 144
 145
 146 /****************************************************************
 147 rgstr() - shucks a decorated regular expression, and copies it
 148 into new memory
 149 ****************************************************************/
 150
 151 char *
 152 rgstr           (char *         instr)
 153 {
 154         char    *ptr;
 155         int     indx;
 156
 157         /* skip the leading slash in the copy */
 158         ptr = strdup(&instr[1]);
 159
 160         /* null out the trailing slash */
 161         indx = strlen(ptr) - 1;
 162         indx = (indx < 0) ? 0 : indx;
 163         ptr[indx] = '\0';
 164
 165         return (ptr);
 166
 167 }   /* end rgstr */
 168
 169