Subversion Repositories programming

/*******************************************************************************
 * File: jminus.y
 * 
 * Copyright (c) 2006, Ira W. Snyder (devel@irasnyder.com)
 * License: GNU General Public License v2
 *
 * This file contains a definition of the J-Minus language, and will
 * create a parser for the language when compiled using BYACC/J, which
 * is available from http://byaccj.sourceforge.net.
 ******************************************************************************/

%{
    import java.lang.*;
    import java.io.*;
    import java.util.StringTokenizer;
    import java.util.Vector;
%}

/* Token Declarations */
%token CLASS
%token ID
%token PUBLIC
%token PRIVATE
%token INT
%token FLOAT
%token VOID
%token IF
%token ELSE
%token WHILE
%token RETURN
%token ADDOP
%token MULOP
%token NUM
%token LPAREN
%token RPAREN
%token LBRACE
%token RBRACE
%token SEMI
%token ASSIGNOP

/* J-Minus Grammar */
%%

program : program_good
    | program_bad { badpath=true; };

program_good : modifier CLASS ID LBRACE method_declaration RBRACE
        { System.out.println ("program -> modifier class id { method_declaration }"); };

program_bad : modifier CLASS ID LBRACE method_declaration { v.add("Missing RBRACE in program"); }
    | modifier CLASS ID method_declaration RBRACE { v.add("Missing LBRACE in program"); }
    | modifier ID LBRACE method_declaration RBRACE { v.add("Missing CLASS in program"); }
    | modifier ID ID LBRACE method_declaration RBRACE { v.add("Mis-spelled? CLASS in program"); };

modifier : PUBLIC   { System.out.println ("modifier -> public"); }
    | PRIVATE       { System.out.println ("modifier -> private"); }
    | ID            { badpath=true; v.add("Mis-spelled? PUBLIC or PRIVATE modifier"); }
    |               { badpath=true; v.add("Missing PUBLIC or PRIVATE modifier"); };

method_declaration : method_declaration_good
    | method_declaration_bad { badpath=true; }
    
method_declaration_good : modifier type_specifier ID LPAREN param RPAREN
    LBRACE local_declaration stmt_sequence RBRACE
        { System.out.println ("method_declaration -> modifier type_specifier id (param) "
                             +"{ local_declaration stmt_sequence }"); };

method_declaration_bad : modifier type_specifier ID param RPAREN LBRACE local_declaration stmt_sequence RBRACE
        { v.add("Missing LPAREN in method_declaration"); }
    | modifier type_specifier ID LPAREN param LBRACE local_declaration stmt_sequence RBRACE
        { v.add("Missing RPAREN in method_declaration"); }
    | modifier type_specifier ID LPAREN param RPAREN local_declaration stmt_sequence RBRACE
        { v.add("Missing LBRACE in method_declaration"); }
    | modifier type_specifier ID LPAREN param RPAREN LBRACE local_declaration stmt_sequence
        { v.add("Missing RBRACE in method_declaration"); };

type_specifier : INT { System.out.println ("type_specifier -> int"); }
    | FLOAT { System.out.println ("type_specifier -> float"); }
    | VOID  { System.out.println ("type_specifier -> void"); }
    |       { badpath=true; v.add("Missing type_specifier"); }
    | ID    { badpath=true; v.add("Mis-spelled? type_specifier"); };

param : type_specifier ID { System.out.println ("param -> type_specifier id"); }
    | VOID  { System.out.println ("param -> void"); };

local_declaration : local_declaration_good
    | local_declaration_bad { badpath=true; }
    
local_declaration_good : type_specifier ID SEMI
            { System.out.println ("local_declaration -> id;"); }
    |       { System.out.println ("local_declaration -> epsilon"); };

local_declaration_bad : type_specifier ID { v.add("Missing SEMI in local_declaration"); };

stmt_sequence : stmt_sequence statement
                { System.out.println ("stmt_sequence -> stmt_sequence statement"); }
    | statement { System.out.println ("stmt_sequence -> statement"); };

statement : if_stmt { System.out.println ("statement -> if_stmt"); }
    | while_stmt    { System.out.println ("statement -> while_stmt"); }
    | assign_stmt   { System.out.println ("statement -> assign_stmt"); }
    | return_stmt   { System.out.println ("statement -> return_stmt"); }
    | expr_stmt     { System.out.println ("statement -> expr_stmt"); };

if_stmt : if_stmt_good
    | if_stmt_bad { badpath=true; };

if_stmt_good : IF LPAREN exp RPAREN statement ELSE statement
        { System.out.println ("if_stmt -> if (exp) statement else statement"); };

if_stmt_bad : IF exp RPAREN statement ELSE statement { v.add("Missing LPAREN in if_stmt"); }
    | IF LPAREN exp statment ELSE statement { v.add("Missing RPAREN in if_stmt"); }
    | IF LPAREN exp RPAREN statement { v.add("Missing ELSE part in if_stmt"); };

while_stmt : while_stmt_good
    | while_stmt_bad { badpath=true; };

while_stmt_good : WHILE LPAREN exp RPAREN statement
        { System.out.println ("while_stmt -> (exp) statement"); };

while_stmt_bad : WHILE exp RPAREN statement { v.add("Missing LPAREN in while_stmt"); }
    | WHILE LPAREN exp statement { v.add("Missing RPAREN in while_stmt"); };

assign_stmt : assign_stmt_good
    | assign_stmt_bad { badpath=true; };

assign_stmt_good : ID ASSIGNOP exp SEMI
        { System.out.println ("assign_stmt -> id = exp;"); };

assign_stmt_bad : ID ASSIGNOP exp { v.add("Missing SEMI in assign_stmt"); };

return_stmt : return_stmt_good
    | return_stmt_bad { badpath=true; };

return_stmt_good : RETURN exp SEMI   { System.out.println ("return_stmt -> return exp;"); }
    | RETURN SEMI               { System.out.println ("return_stmt -> return;"); };

return_stmt_bad : RETURN exp { v.add("Missing SEMI in return_stmt"); }
    | RETURN { v.add("Missing SEMI in return_stmt"); };

expr_stmt : expr_stmt_good
    | expr_stmt_bad { badpath=true; };

expr_stmt_good : exp SEMI            { System.out.println ("expr_stmt -> exp;"); };

expr_stmt_bad : exp { v.add("Missing SEMI in expr_stmt"); }

exp : exp ADDOP term            { System.out.println ("exp -> exp + term"); }
    | term                      { System.out.println ("exp -> term"); };

term : term MULOP factor        { System.out.println ("term -> term * factor"); }
    | factor                    { System.out.println ("term -> factor"); };

factor : LPAREN exp RPAREN      { System.out.println ("factor -> (exp)"); }
    | ADDOP factor              { System.out.println ("factor -> + factor"); }
    | NUM                       { System.out.println ("factor -> NUM"); }
    | ID                        { System.out.println ("factor -> ID"); }
    | exp RPAREN                { badpath=true; v.add("Missing LPAREN in factor"); }
    | LPAREN exp                { badpath=true; v.add("Missing RPAREN in factor"); };

%%

/**
 * Special Stuff
 */

static boolean badpath = false;
static Vector v = new Vector();

/**
 * END
 */

private Yylex lexer;

public void yyerror (String error)
{
    System.out.println ("Parse Error: " + error);
}

int yylex ()
{
    int lex_return = -1;

    try
    {
        lex_return = lexer.yylex();
    }
    catch (IOException e)
    {
        System.out.println ("IO Error: " + e);
    }

    return lex_return;
}

public Parser (Reader r)
{
    lexer = new Yylex (r, this);
}

public static void main (String[] args) throws Exception
{
    System.out.println ("Grammar Productions - Rightmost Derivation in Reverse Order");
    System.out.println ("===============================================================");
    
    try
    {
        Parser yyparser = new Parser (new FileReader (args[0]));
        yyparser.yyparse();
    }
    catch (Exception e)
    {
        badpath=true;
    }

    if (badpath)
    {
        int i;
        String s;
        
        System.out.println ("\n\nError Report:");
        System.out.println ("============================================");
        
        for (i=0; i<v.size(); i++)
        {
            s = (String)v.get(i);
            System.out.println (s);
        }
        
        System.out.println ("\nPARSING FAILED");
        
    }
    else
    {
        System.out.println ("\nPARSING SUCCESSFUL");
    }
}