/******************************************************************************
 * Date:     Thu Oct 25 11:43:04 CDT 2007
 * Author:   John Quigley <jquigley@jquigley.com>
 * Revision: $Id$
 *
 * The White Programming Language
 * Copyright (C) 2007 John Quigley <jquigley@jquigley.com> 
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *****************************************************************************/

%{

#include <stdlib.h>
#include <stdio.h>

#include "core/util.h"
#include "frontend/scan.h"

#define YYPARSE_PARAM scanner
#define YYLEX_PARAM   scanner

void
yyerror (char const *s)
{
    fprintf (stderr, "%s\n", s);
}

%}

%pure-parser
%locations


%union {
    char *      strval; /* string value */
    long        lval;   /* rational value */
    long long   llval;  /* integer value */
    long double ldval;  /* rational value */
}

%token <llval>  INTEGER
%token <ldval>  RATIONAL
%token <ldval>  SCIENTIFIC
%token <lval>   HEX
%token <lval>   OCTAL
%token <lval>   COMPLEX
%token <strval> STRING
%token <strval> SYMBOL
%token <strval> KEYWORD
%token <strval> IDENTIFIER

%%

program:            /* empty */
                    {
                        LOGGER_DEBUG("parser found program");
                    }

                |   clause
                    {
                        LOGGER_DEBUG("parser found program");
                    }

;

/* ************************************************************************* */

clause:             expr ';'
                    {
                        LOGGER_DEBUG("parser found clause: expr");
                        return 0;
                    }
                |   clause expr ';'
                    {
                        LOGGER_DEBUG(
                            "parser found clause: <clause expr>");
                        return 0;
                    }

;

expr:               atomic_expr
                    {
                        LOGGER_DEBUG("parser found expr: atomic_expr");
                    }

                |   grouped_expr
                    {
                        LOGGER_DEBUG("parser found expr: grouped_expr");
                    }

                |   expr atomic_expr
                    {
                        LOGGER_DEBUG("parser found expr: <expr atomic_expr>");
                    }
 
                |   expr grouped_expr
                    {
                        LOGGER_DEBUG(
                            "parser found expr: <expr grouped_expr>");
                    }
                    
                    
;

/* ************************************************************************* */

grouped_expr:       '(' expr ')'
                    {
                        LOGGER_DEBUG("parser found grouped_expr: expr");
                    }

                |   '[' clause ']'
                    {
                        LOGGER_DEBUG("parser found grouped_expr: complete_expr");
                    }

;

atomic_expr:        INTEGER
                    {
                        LOGGER_DEBUG("atomic_expr: INTEGER '%lld'", $<llval>1);
                    }

                |   RATIONAL
                    {
                        LOGGER_DEBUG("atomic_expr: RATIONAL '%Lf'", $<ldval>1);
                    }

                |   SCIENTIFIC
                    {
                        LOGGER_DEBUG("atomic_expr: SCIENTIFIC '%Le'", $<ldval>1);
                    }

                |   HEX
                    {
                        LOGGER_DEBUG("atomic_expr: HEX '%lx'", $<lval>1);
                    }

                |   OCTAL
                    {
                        LOGGER_DEBUG("atomic_expr: OCTAL '%lo'", $<lval>1);
                    }

                |   COMPLEX
                    {
                        LOGGER_DEBUG("atomic_expr: COMPLEX '%ld * i'", $<lval>1);
                    }

                |   STRING
                    {
                        LOGGER_DEBUG("atomic_expr: STRING '%s'", $<strval>1);
                    }

                |   SYMBOL
                    {
                        LOGGER_DEBUG("atomic_expr: SYMBOL '%s'", $<strval>1);
                    }

                |   IDENTIFIER
                    {
                        LOGGER_DEBUG("atomic_expr: IDENTIFIER '%s'", $<strval>1);
                    }

                |   KEYWORD
                    {
                        LOGGER_DEBUG("atomic_expr: KEYWORD '%s'", $<strval>1);

                    }

;

%%

/* EOF */