Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 10 views

    Compiler 8

    Uploaded by

    Tayyab Fiaz
    The document discusses the flex tool for lexical analysis and creating scanners. It provides examples of flex specification files that define rules for tokenizing input text and returning token codes. The flex tool is used to generate C++ code for a lexical analyzer based on the specification file. The generated scanner can then be used to tokenize input streams and return token codes and lexemes.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    Compiler 8

    Uploaded by

    Tayyab Fiaz
    10 views36 pages
    The document discusses the flex tool for lexical analysis and creating scanners. It provides examples of flex specification files that define rules for tokenizing input text and returning token codes. The flex tool is used to generate C++ code for a lexical analyzer based on the specification file. The generated scanner can then be used to tokenize input streams and return token codes and lexemes.

    Original Description:

    Compiler 8

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document discusses the flex tool for lexical analysis and creating scanners. It provides examples of flex specification files that define rules for tokenizing input text and returning token codes. The flex tool is used to generate C++ code for a lexical analyzer based on the specification file. The generated scanner can then be used to tokenize input streams and return token codes and lexemes.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    10 views36 pages

    Compiler 8

    Uploaded by

    Tayyab Fiaz
    The document discusses the flex tool for lexical analysis and creating scanners. It provides examples of flex specification files that define rules for tokenizing input text and returning token codes. The flex tool is used to generate C++ code for a lexical analyzer based on the specification file. The generated scanner can then be used to tokenize input streams and return token codes and lexemes.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 36

    1

    COMPILER CONSTRUCTION(CS-636)
    (LECTURE 9-10)

    ______________________________________________________
    INSTRUCTOR: Gul Sher Ali
    FLEX 2

     AGENDA
     Installtion of the flex tool
     Basic structure of the flex script
     Execution of the flex script in the flex tool
     Syntax and Examples
     Assignment Discussion
    3
    Specification File lex.l 4
    %{
    #include “tokdefs.h”
    %}
    D [0-9]
    L [a-zA-Z_]
    id {L}({L}|{D})*
    %%
    "void" {return(TOK_VOID);}
    "int" {return(TOK_INT);}
    "if" {return(TOK_IF);}
    Specification File lex.l 5

    "else" {return(TOK_ELSE);}
    "while"{return(TOK_WHILE)};
    "<=" {return(TOK_LE);}
    ">=" {return(TOK_GE);}
    "==" {return(TOK_EQ);}
    "!=" {return(TOK_NE);}
    {D}+ {return(TOK_INT);}
    {id} {return(TOK_ID);}
    [\n]|[\t]|[ ] ;
    %%
    File tokdefs.h 6
    #define TOK_VOID 1
    #define TOK_INT 2
    #define TOK_IF 3
    #define TOK_ELSE 4
    #define TOK_WHILE 5
    #define TOK_LE 6
    #define TOK_GE 7
    #define TOK_EQ 8
    #define TOK_NE 9
    #define TOK_INT 10
    #define TOK_ID 111
    Invoking Flex 7

    lex.l flex lex.cpp


    Using Generated Scanner 8
    void main()
    {
    FlexLexer lex;
    int tc = lex.yylex();
    while(tc != 0)
    cout << tc << “,”
    <<lex.YYText() << endl;
    tc = lex.yylex();
    }
    Creating Scanner EXE 9

    flex lex.l
    g++ –c lex.cpp
    g++ –c main.cpp
    g++ –o lex.exe lex.o main.o

    lex <main.cpp
    Using Generated Scanner 10
    void main()
    {
    FlexLexer lex;
    int tc = lex.yylex();
    while(tc != 0)
    cout << tc << “,”
    <<lex.YYText() << endl;
    tc = lex.yylex();
    }
    Input Tokenized 11

    dos> .\lex < main.cpp


    259,void
    258,main
    283,(
    284,)
    285,{
    258,FlexLexer
    258,lex
    290,;
    260,int
    Input Tokenized 12

    258,tc
    266,=
    258,lex
    291,.
    258,yylex
    283,(
    284,)
    290,;
    263,while
    Input Tokenized 13

    283,(
    258,tc
    276,!=
    257,0
    284,)
    258,cout
    279,<<
    258,tc
    Input Tokenized 14

    279,<<
    292,","
    279,<<
    258,lex
    291,.
    258,YYText
    283,(
    284,)
    279,<<
    Input Tokenized 15
    258,endl
    290,;
    258,tc
    266,=
    258,lex
    291,.
    258,yylex
    283,(
    284,)
    290,;
    286,}
    16

    Flex Examples
    %{ } 17
    #include<stdio.h> main()
    int Upper=0; {
    int Lower=0; extern FILE *yyin;
    %} printf("Enter a string\n");
    yyin();
    %% yylex();
    [A-Z] {printf("%s Uppercase\t", printf("abc: %s" , Upper);
    yytext);Upper++;} }
    [a-z] {printf("%s Lowercase\t",
    yytext);Lower++;}

    %%

    int yywrap()
    {
    return 1;
    %{ {ID} printf( "An identifier: %s\n",
    #include <math.h> yytext );
    #include <stdio.h> 18
    "+"|"-"|"*"|"/" printf( "An operator:
    %} %s\n", yytext );
    DIGIT [0-9] "//"[^}\n]* /* eat up one-line
    ID [a-z][a-z0-9]* comments */
    %option noyywrap [ \t\n]+ /* eat up whitespace */
    %% . printf( "Unrecognized character:
    {DIGIT}+ { %s\n", yytext );
    printf( "An integer: %s (%d)\n", %%
    yytext, main( )
    atoi( yytext ) ); {
    } yylex();
    {DIGIT}+"."{DIGIT}* { }
    printf( "A float: %s (%g)\n", yytext,
    atof( yytext ) );
    }
    if|then|begin|end|procedure|function
    {
    printf( "A keyword: %s\n", yytext
    );
    }
    %{
    #include<stdio.h>
    int no; { 19
    %} printf("No of digits=%d",no);
    %%
    [a-z] {printf("%s Is a Small Letter\n", }
    yytext);}
    [A-Z] {printf("%s Is a capital Letter\n",
    yytext);} }
    [0-9] {printf("%s Is a numeric data \n",
    yytext);}
    %%
    int yywrap()
    {
    return 1;
    }

    main()
    {
    printf("Enter a Character");
    int tc= yylex();
    while (tc!=0)
    %{
    #include<stdio.h>
    %} 20
    %%
    "int"|"if"|"else"|"while"|"do"|"switch"|
    "case" {printf("Keyword");}
    [a-zA-Z][a-z|0-9]* {printf("Identifier");}
    [0-9]* {printf("Number");}
    "!"|"@"|"*"|"&"|"^"|"%"|"$"|"#"
    {printf("Special Character");}
    . {printf("invalid data");}
    %%
    int yywrap()
    {
    return 1;
    }
    main()
    {
    printf("Enter a string of data\n");
    yylex();
    }
    %{
    #include<stdio.h>
    int vowel=0; 21
    int cons=0;
    %}
    %%
    "a"|"e"|"i"|"o"|"u"|"A"|"E"|"I"|"O"|"U
    " {printf("is a VOWEL");vowel++;}
    [a-zA-z] {printf("Is a
    Consonant");cons++;}
    %%
    int yywrap()
    {
    return 1;
    }
    main()
    {
    printf("Enter String\n");
    yylex();
    }
    Flex Input for C++ 22
    /*
    * ISO C++ lexical analyzer.
    * Based on the ISO C++ draft standard of December
    '96.
    */

    %{
    #include <ctype.h>
    #include <stdio.h>
    #include “tokdefs.h"

    int lineno;

    static int yywrap(void);


    static void skip_until_eol(void);
    static void skip_comment(void);
    static int check_identifier(const char *);
    %}
    intsuffix ([uU][lL]?)|([lL][uU]?) 23
    fracconst ([0-9]*\.[0-9]+)|([0-9]+\.)
    exppart [eE][-+]?[0-9]+
    floatsuffix [fFlL]
    chartext ([^'])|(\\.)
    stringtext([^"])|(\\.)
    %%
    %% 24
    "\n" { ++lineno; }
    [\t\f\v\r ]+ { /* Ignore whitespace. */ }

    "/*" { skip_comment(); }
    "//" { skip_until_eol(); }

    "{" { return '{'; }


    "<%" { return '{'; }
    "}" { return '}'; }
    "%>" { return '}'; }
    "[" { return '['; }
    "<:" { return '['; }
    "]" { return ']'; } 25
    ":>" { return ']'; }
    "(" { return '('; }
    ")" { return ')'; }
    ";" { return ';'; }
    ":" { return ':'; }
    "..." { return ELLIPSIS; }
    "?" { return '?'; }
    "::" { return COLONCOLON; }
    "." { return '.'; }
    ".*" { return DOTSTAR; }
    "+" { return '+'; }
    "-" { return '-'; }
    "*" { return '*'; }
    "/" { return '/'; }
    "%" { return '%'; }
    "^" { return '^'; }
    "xor" { return '^'; }
    "&" { return '&'; }
    "bitand" { return '&'; }
    "|" { return '|'; }
    "bitor" { return '|'; } 26
    "~" { return '~'; }
    "compl" { return '~'; }
    "!" { return '!'; }
    "not" { return '!'; }
    "=" { return '='; }
    "<" { return '<'; }
    ">" { return '>'; }
    "+=" { return ADDEQ; }
    "-=" { return SUBEQ; }
    "*=" { return MULEQ; }
    "/=" { return DIVEQ; }
    "%=" { return MODEQ; }
    "^=" { return XOREQ; }
    "xor_eq" { return XOREQ; }
    "&=" { return ANDEQ; }
    "and_eq" { return ANDEQ; }
    "|=" { return OREQ; }
    "or_eq" { return OREQ; }
    27
    "<<" { return SL; }
    ">>" { return SR; }
    "<<=" { return SLEQ; }
    ">>=" { return SREQ; }
    "==" { return EQ; }
    "!=" { return NOTEQ; }
    "not_eq" { return NOTEQ; }
    "<=" { return LTEQ; }
    ">=" { return GTEQ; }
    "&&" { return ANDAND; }
    "and" { return ANDAND; }
    "||" { return OROR; }
    "or" { return OROR; }
    "++" { return PLUSPLUS; }
    "--" { return MINUSMINUS; }
    "," { return ','; }
    "->*" { return ARROWSTAR; }
    "->" { return ARROW; }
    "asm" { return ASM; } 28
    "auto" { return AUTO; }
    "bool" { return BOOL; }
    "break" { return BREAK; }
    "case" { return CASE; }
    "catch" { return CATCH; }
    "char" { return CHAR; }
    "class" { return CLASS; }
    "const" { return CONST; }
    "const_cast" { return CONST_CAST; }
    "continue" { return CONTINUE; }
    "default" { return DEFAULT; }
    "delete" { return DELETE; }
    "do" { return DO; }
    "double" { return DOUBLE; }
    "dynamic_cast" { return DYNAMIC_CAST; }
    "else" { return ELSE; }
    "enum" { return ENUM; }
    "explicit" { return EXPLICIT; }
    "export" { return EXPORT; }
    "extern" { return EXTERN; } 29
    "false" { return FALSE; }
    "float" { return FLOAT; }
    "for" { return FOR; }
    "friend" { return FRIEND; }
    "goto" { return GOTO; }
    "if" { return IF; }
    "inline" { return INLINE; }
    "int" { return INT; }
    "long" { return LONG; }
    "mutable" { return MUTABLE; }
    "namespace" { return NAMESPACE; }
    "new" { return NEW; }
    "operator" { return OPERATOR; }
    "private" { return PRIVATE; }
    "protected" { return PROTECTED; }
    "public" { return PUBLIC; }
    "register" { return REGISTER; }
    "reinterpret_cast" { return REINTERPRET_CAST; }
    "return" { return RETURN; }
    "short" { return SHORT; } 30
    "signed" { return SIGNED; }
    "sizeof" { return SIZEOF; }
    "static" { return STATIC; }
    "static_cast" { return STATIC_CAST; }
    "struct" { return STRUCT; }
    "switch" { return SWITCH; }
    "template" { return TEMPLATE; }
    "this" { return THIS; }
    "throw" { return THROW; }
    "true" { return TRUE; }
    "try" { return TRY; }
    "typedef" { return TYPEDEF; }
    "typeid" { return TYPEID; }
    "typename" { return TYPENAME; }
    "union" { return UNION; }
    "unsigned" { return UNSIGNED; }
    "using" { return USING; }
    "virtual" { return VIRTUAL; }
    "void" { return VOID; }
    "volatile" { return VOLATILE; }
    31
    "wchar_t" { return WCHAR_T; }
    "while" { return WHILE; }

    [a-zA-Z_][a-zA-Z_0-9]*
    { return check_identifier(yytext); }

    "0"[xX][0-9a-fA-F]+{intsuffix}? { return INTEGER; }


    "0"[0-7]+{intsuffix}? { return INTEGER; }
    [0-9]+{intsuffix}? { return INTEGER; }
    {fracconst}{exppart}?{floatsuffix}? { return
    FLOATING; }
    32
    [0-9]+{exppart}{floatsuffix}? { return FLOATING; }

    "'"{chartext}*"'" { return CHARACTER; }


    "L'"{chartext}*"'" { return CHARACTER; }

    "\""{stringtext}*"\"" { return STRING; }


    "L\""{stringtext}*"\"" { return STRING; }
    . { fprintf(stderr,
    33
    "%d: unexpected character `%c'\n", lineno,
    yytext[0]); }

    %%

    static int
    yywrap(void)
    {
    return 1;
    }
    static void
    34
    skip_comment(void)
    {
    int c1, c2;

    c1 = input();
    c2 = input();

    while(c2 != EOF && !(c1 == '*' && c2 == '/'))


    {
    if (c1 == '\n')
    ++lineno;
    c1 = c2;
    c2 = input();
    }
    }
    35
    static void
    skip_until_eol(void)
    {
    int c;

    while ((c = input()) != EOF && c != '\n')


    ;
    ++lineno;
    }
    static int 36
    check_identifier(const char *s)
    {
    /*
    * This function should check if `s' is a
    * typedef name or a class
    * name, or a enum name, ... etc. or
    * an identifier.
    */
    switch (s[0]) {
    case 'D': return TYPEDEF_NAME;
    case 'N': return NAMESPACE_NAME;
    case 'C': return CLASS_NAME;
    case 'E': return ENUM_NAME;
    case 'T': return TEMPLATE_NAME;
    }
    return IDENTIFIER;
    }

    You might also like