readparameters.y

Go to the documentation of this file.

%{ 
#include "parameters.h"
#include "error.h"
#include "boolean.h"
#include "defines.h"

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

  Tparameters *rp_ps; /*global pointer used from inside the parser to refer to the current set of
                       parameter being read*/

  /*Lex and Yacc variables*/
  extern FILE *ReadParametersin; 

  /*Lex and Yacc functions*/
  int ReadParameterslex(void); 

  /*Our own variables*/
  extern unsigned int RPNline; /*line number currently processed (incremented by the LEX processor)*/

%}

%union 
{ 
  int int_number;
  double real_number;
} 
 
%start parameters

%token _TRUE _FALSE _INF _EPSILON _SIGMA _SMALL_SIGMA _RHO _STATE_PERIOD _DUMMIFY _ERROR_SPLIT _SAFE_SIMPLEX _SIMPLIFICATION_LEVEL _LR2TM_Q _LR2TM_S

%token <int_number> _INTEGER
%token <real_number> _REAL

%type <real_number> ct_expr
%type <real_number> boolean_value

%left _MIN_PRECEDENCE
%left '+' '-' 
%left '*' '/'
%right _MAX_PRECEDENCE 

%% 

parameters : parameter parameters
           |
           ;

parameter : _EPSILON '=' ct_expr
            {
              if ($3<0.0)
                Error("Parameter EPSILON must be greater than (or equal to) 0.0");
              SetParameter(CT_EPSILON,"Epsilon",$3,rp_ps);
            }
          | _RHO '=' ct_expr
            {
              if (($3>0.0)&&($3<1.0))
                SetParameter(CT_RHO,"Rho",$3,rp_ps);
              else
                Error("Parameter RHO must in the interval (0,1)");
            }
          | _SIGMA '=' ct_expr
            {
              if ($3<0.0)
                Error("Parameter SIGMA  must be greater than (or equal to) 0.0");
              SetParameter(CT_SIGMA,"Sigma",$3,rp_ps);
            }
          | _SMALL_SIGMA '=' ct_expr
            {
              if ($3<0.0)
                Error("Parameter SMALL SIGMA  must be greater than (or equal to) 0.0");
              SetParameter(CT_SMALL_SIGMA,"Small Sigma",$3,rp_ps);
            }
          | _STATE_PERIOD '=' ct_expr
            {
              if ($3<0)
                Error("Parameter STATE_PERIOD  must be greater than (or equal to) 0");
              SetParameter(CT_STATE_PERIOD,"Period between state files",$3,rp_ps);
            }
          | _DUMMIFY '=' ct_expr
            {
              SetParameter(CT_DUMMIFY,"Dummification Level",$3,rp_ps);
            } 
          | _ERROR_SPLIT '=' boolean_value
            {
              SetParameter(CT_SPLIT_TYPE,"Error Split ",$3,rp_ps);
            } 
          | _SAFE_SIMPLEX '=' ct_expr
            {
              SetParameter(CT_SAFE_SIMPLEX,"Save Simplex",$3,rp_ps);
            }  
          | _SIMPLIFICATION_LEVEL '=' ct_expr
            {
              SetParameter(CT_SIMPLIFICATION_LEVEL,"Simplification Level",$3,rp_ps);
            } 
          | _LR2TM_Q '=' ct_expr
            {
              SetParameter(CT_LR2TM_Q,"LR2TM_Q",$3,rp_ps);
            }  
          | _LR2TM_S '=' ct_expr
            {
              SetParameter(CT_LR2TM_S,"LR2TM_S",$3,rp_ps);
            }  
          ;

boolean_value : _TRUE
                {
                  $$=1.0;
                }
              | _FALSE
                {
                  $$=0.0;
                }
              ;

ct_expr : '+' ct_expr                 %prec _MAX_PRECEDENCE
         {
           $$=$2;
         }
        | '-' ct_expr                 %prec _MAX_PRECEDENCE
         {
           $$=-$2;
         }
        | ct_expr '+' ct_expr 
         {
           $$=$1+$3;
         }
        | ct_expr '-' ct_expr 
         {
           $$=$1-$3;
         }
        | ct_expr '*' ct_expr 
         {
           $$=$1*$3;
         } 
        | ct_expr '/' ct_expr 
         {
           $$=$1/$3;
         } 
        | '(' ct_expr ')'
         {
           $$=$2;
         } 
        | _INF
         {
           $$=(double)INF;
         } 

        | _INTEGER 
         {
           $$=(double)$1;
         } 
        | _REAL
         {
           $$=$1;
         }
        ; 

%%
boolean ReadParameters(char *file,Tparameters *p)
{
  unsigned int i;
  boolean fileExists;

  ReadParametersin=fopen(file,"r");
  if (!ReadParametersin) 
    fileExists=FALSE;
  else
    {
      fileExists=TRUE;
    
      /*Set up the global pointer to make the parameter structure under initialization
        to be accesible form everywhere in the parser*/
      rp_ps=p;
  
      /*Reset the lines numbering*/
      RPNline=1;

      /*and process the file*/
      ReadParametersparse();

      for(i=0;i<NPARAMETERS;i++)
        {
          if ((*p)[i].name==NULL)
            {
              char ErrorText[200];
              
              sprintf(ErrorText,"Parameter number %u is undefined (see sources/parameters.h to see parameter numbering)",i);
              Error(ErrorText);
            }
        }

      if (GetParameter(CT_SMALL_SIGMA,p)>GetParameter(CT_SIGMA,p))
        Error("SMALL_SIGMA can not be larger than SIGMA!!!");

      if (GetParameter(CT_EPSILON,p)>GetParameter(CT_SIGMA,p))
        Error("EPSILON can not be larger than SIGMA!!!");

      fclose(ReadParametersin);
    }

  return(fileExists);
}