Return to token.lm CVS log

Up to [NeXTSTEP 3.3 examples] / Examples / AppKit / Graph

Annotation of Examples/AppKit/Graph/token.lm, revision 1.1.1.1

1.1       root        1: 
                      2: %{
                      3: /*
                      4:     token.lm
                      5: 
                      6:     This file defines the tokens that the Expression grammar is built on.  To
                      7:     fully understand this file, you will need to understand lex.  The basic
                      8:     idea is that lex scans a text stream and breaks that stream up into tokens
                      9:     which are then fed to the grammar (defined in yacc).  Whitespace is ignored
                     10:     so the grammar is just fed a steady stream of significant tokens.
                     11: */
                     12: 
                     13: /*
                     14:  * These are the routines lex calls to get another character as it parses.
                     15:  * By default they are macros which read from stdin. We toss the default
                     16:  * macro definitions and supply our own versions of these, which will feed
                     17:  * lex characters from the expression string we are parsing.
                     18:  */
                     19: #undef input
                     20: #undef unput
                     21: #undef output
                     22: static int input();
                     23: static void unput(char c);
                     24: static void output(char c);
                     25: 
                     26: #import <stdlib.h>
                     27: #import <string.h>
                     28: #import <math.h>
                     29: #import "exprDefs.h"
                     30: #import "y.tab.h"
                     31: 
                     32: /* global which holds the string we are parsing */
                     33: static const char *CurrText;
                     34: 
                     35: /* glue to get rid of compiler warnings */
                     36: extern yylook(), yyback();
                     37: static int yywrap();
                     38: %}
                     39: 
                     40: DIGIT    ([0-9])
                     41: EXP      ([Ee][+-]?[0-9]+)
                     42: 
                     43: %%
                     44: 
                     45: 
                     46: [ \t\n]+ {             /* whitespace - we ignore it */
                     47:        ;
                     48: }
                     49: 
                     50: {DIGIT}+ {             /* an integer */
                     51:        yylval.integer = atoi(yytext);
                     52:        return INTEGER;
                     53: }
                     54: 
                     55: (({DIGIT}+"."{DIGIT}*{EXP}?)|([+-]?{DIGIT}*"."{DIGIT}+{EXP}?)|({DIGIT}+{EXP})) {                   /* a float */
                     56:        yylval.real = atof(yytext);
                     57:        return NUMBER;
                     58: }
                     59: 
                     60: {DIGIT}+"#"[a-zA-Z0-9]+ {      /* a radix number */
                     61:        int radix;
                     62:        register int mult = 1;
                     63:        register char *c, *stop;
                     64:        register unsigned int accum = 0;
                     65:        register int charVal;
                     66: 
                     67:        sscanf( yytext, "%d#", &radix );
                     68:        for( stop = yytext; *stop++ != '#'; ); /* skip the pound sign */
                     69:        for( c = yytext+yyleng-1; c >= stop; c--, mult *= radix ) {
                     70:            if( *c >= '0' && *c <= '9' )
                     71:                charVal = *c - '0';
                     72:            else if( *c >= 'A' && *c <= 'Z' )
                     73:                charVal = *c - 'A' + 10;
                     74:            else
                     75:                charVal = *c - 'a' + 10;
                     76:            accum += mult * charVal;
                     77:        }
                     78:        yylval.real = accum;
                     79:        return NUMBER;
                     80: }
                     81: 
                     82: pi {                   /* the constant pi */
                     83:        yylval.real = M_PI;
                     84:        return NUMBER;
                     85: }
                     86: 
                     87: e {                    /* the constant e */
                     88:        yylval.real = M_E;
                     89:        return NUMBER;
                     90: }
                     91: 
                     92: [-+*/%^(),]  {                 /* a single char that must be recognized */
                     93:        return yytext[0];
                     94: }
                     95: 
                     96: [A-Za-z_][A-Za-z_0-9]* {       /* an identifier */
                     97:        yylval.string = NXZoneMalloc(NXDefaultMallocZone(), yyleng+1); 
                     98:        bcopy(yytext, yylval.string, yyleng);
                     99:        yylval.string[yyleng] = '\0';
                    100:        return IDENTIFIER;
                    101: }
                    102: 
                    103: . {            /* other garbage chars (last rule is the default) */
                    104:        yylval.character = yytext[0];
                    105:        return BADCHAR;
                    106: }
                    107: 
                    108: 
                    109: %%
                    110: 
                    111: /* inits the global string to the one we will parse */
                    112: void _EXPPrepareToScan(const char *text) {
                    113:     CurrText = text;
                    114: }
                    115: 
                    116: /* tells lex there's really no more input when we're done */
                    117: static int yywrap() {
                    118:     return 1;
                    119: }
                    120: 
                    121: /* returns the next char of the string we're parsing */
                    122: static int input() {
                    123:     return *CurrText++;
                    124: }
                    125: 
                    126: /* lets lex back up one char in the string we're parsing */
                    127: static void unput(char c) {
                    128:     --CurrText;
                    129: }
                    130: 
                    131: /* called by lex when it wants to output a char.  This should never happen. */
                    132: static void output(char c) {
                    133:     fprintf(stderr, "lex output function called with char '%c'\n", c);
                    134: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.