readcuiksystem.y

Go to the documentation of this file.

%{ 
#include "cuiksystem.h"
#include "readcuiksystemtypes.h"

#include "boolean.h"
#include "error.h"
#include "interval.h"
#include "monomial.h"
#include "equations.h"
#include "equation.h"
#include "variable.h"
#include "variable_set.h"
#include "constants.h"
#include "defines.h"
#include "parameters.h"

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

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

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

  /*Our own variables*/
  extern unsigned int RCSline; /*line number currently processed (incremented by the LEX processor)*/
  
  Tparameters *rcs_parameters=NULL;

  /*Global pointer to allow the different parts of the parser to acces the equations being initialized*/
  TCuikSystem *rcs_cuiksystem=NULL;

  Tequation rcs_equation;
  Tmonomial rcs_monomial;

  unsigned int rcs_eq_type=SYSTEM_EQ;
  unsigned int rcs_var_type=SYSTEM_VAR;

  Tconstants rcs_constants;

%}

%union 
{ 
  char *id; 
  int int_number;
  double real_number;
  Texpr expr;
} 
 
%start problem

%token _CONSTANTS _SYSTEM_VARS _SECONDARY_VARS _DUMMY_VARS _CARTESIAN_VARS _SYSTEM_EQS _COORD_EQS _DUMMY_EQS _SEARCH _DEPTH _BREADTH _FIRST _MIN _EQU _LEQ _GEQ _ASSIGN _INF _PI _SIN _COS _SQRT 

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

%type <expr> expr
%type <int_number> cmp 
%type <int_number> power

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

problem: ct_defs var_defs system_eqs coord_eqs dummy_eqs search
       ;

ct_defs : _CONSTANTS ct_list  
        |
        ;
         
ct_list : ct_definition ct_list
        |
        ;

ct_definition: _IDENTIFIER _ASSIGN expr
               {
                 if (GetConstantWithName($1,&rcs_constants)!=NO_UINT)
                   {
                     char s[200];
                     
                     sprintf(s,"Duplicated constant %s",$1);
                     ReadcuiksystemSemanticError(s);
                   }

                 AddConstant($1,$3.value,&rcs_constants);
                 free($1);
               }
             ;


expr : '+' expr    %prec _MAX_PRECEDENCE
         {
           if ($2.id!=NULL)
             ReadcuiksystemSemanticError("No operation is allowed with variables");

           $$.id=NULL;
           $$.value=$2.value;
         }
        | '-' expr    %prec _MAX_PRECEDENCE
         {
           if ($2.id!=NULL)
             ReadcuiksystemSemanticError("No operation is allowed with variables");

           $$.id=NULL;
           $$.value=-$2.value;
         }
        | expr '+' expr 
         {
           if (($1.id!=NULL)||($3.id!=NULL))
             ReadcuiksystemSemanticError("No operation is allowed with variables");

           $$.id=NULL;
           $$.value=$1.value+$3.value;
         }
        | expr '-' expr 
         {
           if (($1.id!=NULL)||($3.id!=NULL))
             ReadcuiksystemSemanticError("No operation is allowed with variables");

           $$.id=NULL;
           $$.value=$1.value-$3.value;
         }
        | expr '*' expr 
         {
           if (($1.id!=NULL)||($3.id!=NULL))
             ReadcuiksystemSemanticError("No operation is allowed with variables");

           $$.id=NULL;
           $$.value=$1.value*$3.value;
         }
        | expr '^' expr 
         {
           if (($1.id!=NULL)||($3.id!=NULL))
             ReadcuiksystemSemanticError("No operation is allowed with variables");

           $$.id=NULL;
           $$.value=pow($1.value,$3.value);
         }
        | expr '/' expr 
         {
           if (($1.id!=NULL)||($3.id!=NULL))
             ReadcuiksystemSemanticError("No operation is allowed with variables");

           if ($3.value==0.0)
             ReadcuiksystemSemanticError("Division by zero");
           
           $$.id=NULL;
           $$.value=$1.value/$3.value;
         }
        | '(' expr ')'
         {
           $$.id=$2.id;
           $$.value=$2.value;
         }
        | _PI 
         {
           $$.id=NULL;
           $$.value=M_PI;
         }
        | _INF
         {
           $$.id=NULL;
           $$.value=INF;
         }
        | _SIN '(' expr ')'
         {
           if ($3.id!=NULL)
             ReadcuiksystemSemanticError("No operation is allowed with variables");
           
           $$.id=NULL;
           $$.value=sin($3.value);
         }
        | _COS '(' expr ')'
         {
           if ($3.id!=NULL)
             ReadcuiksystemSemanticError("No operation is allowed with variables");
           
           $$.id=NULL;
           $$.value=cos($3.value);
         }
        | _SQRT '(' expr ')'
         {
           if ($3.id!=NULL)
             ReadcuiksystemSemanticError("No operation is allowed with variables");
           
           $$.id=NULL;
           $$.value=sqrt($3.value);
         }
        | _IDENTIFIER
         {
           unsigned int nc;

           nc=GetConstantWithName($1,&rcs_constants);

           if (nc!=NO_UINT)
             {
               $$.id=NULL;
               $$.value=GetConstantValue(nc,&rcs_constants);
             }
           else
             {
               char ms[200];
               sprintf(ms,"Undefined constant: %s",$1);
               ReadcuiksystemSemanticError(ms);
             }
           free($1);
         }
        | _INTEGER
         {
           $$.id=NULL;
           $$.value=(double)$1;
         } 
        | _REAL
         {
           $$.id=NULL;
           $$.value=$1;
         }
        ; 

var_defs : var_block var_defs
         | 
         ;

var_block : system_vars
          | secondary_vars
          | dummy_vars
          | cartesian_vars
          ;

system_vars: _SYSTEM_VARS 
             { 
               rcs_var_type=SYSTEM_VAR;
             }
             range_list
           ;

secondary_vars: _SECONDARY_VARS 
                { 
                  rcs_var_type=SECONDARY_VAR;
                }
                range_list
              ;

dummy_vars: _DUMMY_VARS
            { 
              rcs_var_type=DUMMY_VAR;
            }
            range_list
          ;

cartesian_vars: _CARTESIAN_VARS 
                {
                  rcs_var_type=CARTESIAN_VAR;   
                }
                range_list
              ;

range_list: range_definition range_list
          |
          ;

range_definition : _IDENTIFIER ':' '[' expr ',' expr ']'
                  {
                    Tinterval i_user; 
                    Tvariable v;
                    
                    if (GetCSVariableID($1,rcs_cuiksystem)!=NO_UINT) 
                      {
                        char s[300];
                        
                        sprintf(s,"Repeated range declaration for variable %s",$1);
                        ReadcuiksystemSemanticError(s);
                      }

                    NewInterval($4.value,$6.value,&i_user);

                    if (EmptyInterval(&i_user))
                      ReadcuiksystemSemanticError("Empty Interval");

                    NewVariable(rcs_var_type,$1,&v);
                    SetVariableInterval(&i_user,&v);

                    AddVariable2CS(&v,rcs_cuiksystem);

                    DeleteVariable(&v);
                    free($1);
                  }
                ;

system_eqs : _SYSTEM_EQS
             {
               rcs_eq_type=SYSTEM_EQ;
             } 
             eq_list
           |
           ;

coord_eqs : _COORD_EQS 
            {
              rcs_eq_type=COORD_EQ;
            }
            eq_list
          |
          ;

dummy_eqs : _DUMMY_EQS 
            {
              rcs_eq_type=DUMMY_EQ;
            }
            eq_list
          |
          ;

search: _SEARCH
        search_type
      |
        { 
          SetCSSearchMode(DEPTH_FIRST_SEARCH,NULL,rcs_cuiksystem);
        }
      ;

search_type: _DEPTH _FIRST
             {
               SetCSSearchMode(DEPTH_FIRST_SEARCH,NULL,rcs_cuiksystem);
             }
           | _BREADTH _FIRST
             {
               SetCSSearchMode(BREADTH_FIRST_SEARCH,NULL,rcs_cuiksystem);
             }
           | _MIN monomials
             {
               SetEquationType(SYSTEM_EQ,&rcs_equation);
               SetEquationCmp(EQU,&rcs_equation);
               SetCSSearchMode(MINIMIZATION_SEARCH,&(rcs_equation),rcs_cuiksystem);
               ResetEquation(&rcs_equation);
             }
           ;

eq_list: equation 
         {
           AddEquation2CS(rcs_parameters,&rcs_equation,rcs_cuiksystem);
             
           /*Get ready for next equation definition*/
           ResetEquation(&rcs_equation);
         }
         eq_list
         |
         ;

equation : monomials cmp expr ';'
           {
             SetEquationType(rcs_eq_type,&rcs_equation);
             SetEquationCmp($2,&rcs_equation);
             SetEquationValue($3.value+GetEquationValue(&rcs_equation),&rcs_equation);

             ResetMonomial(&rcs_monomial);
           }
           ;

monomials : opt_sign monomial
          {
            AddMonomial(&rcs_monomial,&rcs_equation);
            ResetMonomial(&rcs_monomial);
          }
          more_monomials
        ;

more_monomials: sign monomial 
              {
                AddMonomial(&rcs_monomial,&rcs_equation);
                ResetMonomial(&rcs_monomial);
              }
              more_monomials 
            |
            ;

opt_sign : sign
         |
         ;

sign : '+'
     | '-'
       {
         AddCt2Monomial(-1.0,&rcs_monomial);
       }
     ;

monomial : item '*' monomial
       | item
       ;

item : _REAL
       {
         AddCt2Monomial($1,&rcs_monomial);
       } 
     | _INTEGER
       {
         AddCt2Monomial((double)$1,&rcs_monomial);
       } 
     | _SIN '(' expr ')'
       {
         if ($3.id!=NULL)
           ReadcuiksystemSemanticError("sin() only works on constant expressions");
         
         AddCt2Monomial(sin($3.value),&rcs_monomial);  
       }
     | _COS '(' expr ')'
       {
         if ($3.id!=NULL)
           ReadcuiksystemSemanticError("cos() only works on constant expressions");
         
         AddCt2Monomial(cos($3.value),&rcs_monomial);  
       }
     | _IDENTIFIER power
       {
         unsigned int id;
         unsigned int nc;


         nc=GetConstantWithName($1,&rcs_constants);

         if (nc!=NO_UINT)
           AddCt2Monomial(pow(GetConstantValue(nc,&rcs_constants),(double)($2)),&rcs_monomial);
         else
           {
             id=GetCSVariableID($1,rcs_cuiksystem);
             if (id!=NO_UINT) /*a known variable*/
               AddVariable2Monomial(id,$2,&rcs_monomial);
             else
               {
                 char s[300];
                 
                 sprintf(s,"Unknown variable or constant %s",$1);
                 ReadcuiksystemSemanticError(s);
               }
           }
         free($1);
       }
     ;

power : '^' _INTEGER
        {
          $$=$2;
        }
      |
        {
          $$=1;
        }
      ;

cmp : _EQU
      {
        $$=EQU;
      }
    | _LEQ
      {
        $$=LEQ;
      }
    | _GEQ
      {
        $$=GEQ;
      }
    ;

%%
/*
 * Reads a file containing the constants definitions, kinematic equations to be solved, 
 * and the range constrains for the variables.
 */
void InitCuikSystemFromFile(Tparameters *p,char *filename,TCuikSystem *cs)
{
  rcs_parameters=p;

  Readcuiksystemin=fopen(filename,"r");
  if (!Readcuiksystemin) 
    {
      char ErrorText[500];

      sprintf(ErrorText,"File %s does not exists",filename);
      Error(ErrorText);
    }

  /*Start the data structures*/
  InitCuikSystem(cs);

  InitConstants(&rcs_constants);

  /*Reset the lines numbering*/
  RCSline=1;

  /*we initalize the global pointer to make the parameters accesibles to any one inside the YACC module*/
  rcs_cuiksystem=cs;

  /*Get ready for first equation*/
  InitEquation(&rcs_equation);
  InitMonomial(&rcs_monomial);

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

  DeleteConstants(&rcs_constants);   
  DeleteEquation(&rcs_equation);
  DeleteMonomial(&rcs_monomial);;

  cs->updated=FALSE;
  fclose(Readcuiksystemin);
}