source: trunk/yao/src/analyzers/WORKwELLgrammar.g @ 1

// \file    grammar.g
// \brief   ANTLR based YAO lexer and parser.
// \remarks This file somehow breaks the "one class declaration per file" rule.
// \version 2007/10/01 (yyyy/mm/dd)
// \author  Luigi Nardi <luiginardi(at)gmail.com>  
//
// This file is part of YAO, a framework for variational assimilation in
// numerical models.
// Copyright (c) 2001-onwards LOCEAN. All rights reserved.
//
// This program may be redistributed and/or modified under the terms of the GNU
// General Public License as published by the Free Software Foundation, either
// version 2 of the license, or (at your option) any later version.
//
// This program is provided AS IS and WITHOUT ANY WARRANTY, including any
// implied warranty of DESIGN, MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE.


header "pre_include_hpp"{
  #include <iostream>
  #include <cstdlib>
  #include "../YAOObjects/Constant.hpp"
  #include "../YAOObjects/Context.hpp"
  #include "../YAOObjects/Function.hpp"
  #include "../YAOObjects/Identifier.hpp"
  #include "../YAOObjects/Neuron.hpp"
  #include "../YAOObjects/Operator.hpp"
  #include "../YAOObjects/Table.hpp"
  #include "../help/FilePath.hpp"
  #include "../YAOObjects/Modul.hpp"
  #include "../YAOObjects/Connection.hpp"
  #include "../YAOObjects/Order.hpp"
  #include "../help/Display.hpp"
}

header "post_include_cpp"{
  #include <iomanip>

  //! \namespace antlr
  //! \brief ANTLR namespace.
  using namespace antlr;
  using namespace std;
}

options{
  language = "Cpp";           // Generates C++ code.
  namespace = "yao";          // Encapsulates parser in namespace yao.
  namespaceStd = "std::";     // Makes generated code more readable.
  namespaceAntlr = "antlr::"; // Makes generated code more readable.
  //genHashLines = false;     // Makes generated code more readable.
}

/**
 * \class yao::BaseParser
 * \brief BaseParser class, handles project description analysis. Building
 * the AST is worthless here as all constructs can be generated from previously parsed information.
 */
class BaseParser extends Parser;
  options{
    exportVocab = Yao;          // Sets YAO vocabulary name.
    defaultErrorHandler = false;        // Turns off default exception handling.
    buildAST = false;           // Turns off AST construction.
  }

  {
   public:

      virtual ~BaseParser() {} //!< Destructor.

    private:

      /**
       * Searches given token in table (throws exception when not found).
       * @param aTable the Table where we want to search the information.
       * @param aName the name that we want to search.
       */
      template <typename T>
        std::string search(const Table<T>& aTable,const antlr::RefToken& aName){
          YAO_ENFORCE(aTable.find(aName->getText()))(aName->getLine())("unknown ")
            (T::getPropertyName(0))(": ")(aName->getText());
          return aName->getText();
        }

      void exit(){ //!< Exits parser.
        std::cout << "> exit" << std::endl;
        std::exit(EXIT_SUCCESS);
      }

      /**
      * The display_flagop of the YAO version 8 is obsolete in this current version. 
      * This is why the display of the modules, exec disp_modul, already shows this information.
      * We leave this display here for compability with others version but we do not implement it.
      **/
      void displayFlagop() const{
        cout << "displayFlagop" << ": Obsolete in current YAO version." << endl
             << "The information linking each module with the operator (if it has one) is already available in the display of the modules:"
             << "\"exec disp_modul\"." << endl << endl;
      }

    protected:

      Table<Identifier> theIdentifierTable;     //!< Table of identifiers.
      Table<Constant> theConstantTable;         //!< Table of constants.
      std::vector<std::string> theHeaderList;   //!< List of header (hat) files.
      Context theContext;                       //!< Code generation context (options).
      Table<Trajectory> theTrajectoryTable;     //!< Table of trajectories.
      Table<Space> theSpaceTable;               //!< Table of so-called spaces (model operators).
      Table<Operator> theOperatorTable;         //!< Table of operators.
      Table<Neuron> theNeuronTable;             //!< Table of neurons.
      Table<Function> theFunctionTable;         //!< Table of user-defined functions.
      Table<yao::Modul> theModulTable;          //!< Table of user-defined modules.  
      Table<Connection> theConnectionTable;     //!< Table of user-defined connections.  
      Table<Order> theOrderTable;               //!< Table of user-defined orders.  
      Display theDisplay;                       //!< Record that contains all the display requested.
  }

  /*
     incompleted----NOT YET IMPLEMENTED:
     Yao9 has a new conception of the YAO grammar. Firstly we have to define obligatorialy a "Model declaration block"
     and then we define others pieces of blocks later. The important thing is that every new stuff introducted must
     exist, so it has been defined before. So space and trajectory block can be reversed in the description block but
     when we declare the space it must refer to a trajectory that already exist.
   */
  description : 
  ( defvalBlock )?
  hat_nameBlock
  ( optionBlock )?
  ( // Model declaration block.
    trajBlock
    spaceBlock
    ( operaBlock )?
    ( netwardBlock )?
    modulBlock
    ctBlock
    orderBlock 
  )+ 
  ( insert_fctBlock )?
  EOF!
  ;

  defvalBlock
  : ( execStatement | defvalDeclaration )+
  ;

  hat_nameBlock
  : hat_nameDefinition ( hat_nameDefinition | execStatement )*
  ;

  optionBlock
  : optionDeclaration ( optionDeclaration | execStatement )*
  ;

  trajBlock
  : trajDeclaration ( trajDeclaration | execStatement )*
  ;

  spaceBlock
  : spaceDeclaration ( spaceDeclaration | execStatement )*
  ;

  operaBlock
  : operaDeclaration ( operaDeclaration | execStatement )*
  ;

  netwardBlock
  : netwardDeclaration ( netwardDeclaration | execStatement )*
  ;

  modulBlock
  : modulDeclaration ( modulDeclaration | execStatement )*
  ;

  ctBlock
  : ctDefinition ( ctDefinition | execStatement )*
  ;

  orderBlock
  : orderDefinition ( orderDefinition | execStatement )*
  ;

  insert_fctBlock
  : insert_fctDeclaration ( insert_fctDeclaration | execStatement )*
  ;

  execStatement // Command execution statement.
  : EXEC^ ( EXIT { this->exit(); }
      | HELP { theDisplay.setHelp(true); }
      | DISP_DEFVAL { theDisplay.setDefval(true); }
      | DISP_TRAJ { theDisplay.setTrajectory(true); }
      | DISP_SPACE { theDisplay.setSpace(true); }
      | DISP_OPERA { theDisplay.setOpera(true); }
      | DISP_NETWARD { theDisplay.setNeuron(true); }
      | DISP_MODUL { theDisplay.setModule(true); }
      | DISP_CT_IN { theDisplay.setConnection(true); }
      | DISP_CT_OUT { cout << std::endl << "warning DISP_CT_OUT" << ": this exec belong to olds versions of YAO." << endl; }
      | DISP_FLAGOP { cout << "warning DISP_FLAGOP" << ": this exec belong to olds versions of YAO." << endl
                           << "The information linking each module with the operator (if it has one) is already available in the display of modules:"
                           << "\"exec disp_modul\"" << endl; }
      | DISP_OPTION { theDisplay.setContext(true); } 
      )
  ;

  defvalDeclaration // Constant declaration.
  { 
    string name;
    string value;
  }
  : DEFVAL^ name=identifier
  ( // Unassigned constant.
    | value=integerLiteral
    | value=floatLiteral
    | value=stringLiteral
    | value=constantName { value = theConstantTable.find(value)->getText(); }
  )
  { int line = LT(1)->getLine(); 
    //exception case of Y3_M
    YAO_ENFORCE(!(name=="Y3_M" && atoi(value.c_str()) <= 0))(line)("Y3_M must be positive ");
    theConstantTable.push_back(Constant(name, value)); 
  }
  ;

  hat_nameDefinition // Header (hat) file definition.
  { vector<string> fileList; 
    string str;
  }
  : HAT_NAME^ 
    (  
         name:IDENTIFIER {
      // Firstly we control if it is a constant defined with defval.
      Constant * con = theConstantTable.find(name->getText()); 
      if(con==NULL){
        // If it is not a constant warning for DEPRECATED notation.
        str = name->getText();
        str.append(".h");
        theHeaderList.push_back(str);
        cout  << endl << "Warning in hat directive: "
              << "the syntax for inserting the hat file should be:" << endl
              << "> hat_name \"name.h\"" << endl << "instead of deprecated" << endl
              << "> hat_name name." << endl << "Please add quotation marks and extension. " << endl 
              << "YAO has corrected the problem, the hat file is: " << endl; 
        for(vector<string>::iterator it=theHeaderList.begin(); it!=theHeaderList.end(); it++)
          cout << *it << endl;
      }else {
        // If it is a constant is something like "hatName.h" or "hatName", so we manipulate.
        FilePath fp = (static_cast<FilePath>(con->getText()).removeDoubleQuote());
        if(!(fp.getExtension() == ".h")){
          fp.append(".h");
          cout  << endl << "Warning in hat directive: "
                << "the syntax for inserting the hat file should be:" << endl
                << "> hat_name \"name.h\"" << endl << "instead of deprecated" << endl
                << "> hat_name name." << endl << "Please add quotation marks and extension. " << endl 
                << "YAO has corrected the problem, the hat file is: " << endl; 
          //for(vector<string>::iterator it=theHeaderList.begin(); it!=theHeaderList.end(); it++)
          //cout << *it << endl;
          cout << fp << endl;
}
        theHeaderList.push_back(fp);
              }
    }
    | 
    fileList=stringConstantList
  {
    vector<string>::iterator it;
    for(it=fileList.begin(); it!=fileList.end(); it++)
      *it = (static_cast<FilePath>(*it).removeDoubleQuote()).isFileHeader();
    theHeaderList.insert(theHeaderList.end(), fileList.begin(), fileList.end());
  }
    )
  ;

  optionDeclaration
  : OPTION^ ( optionAttribute )+
  ;

  optionAttribute
  {
    vector<string> fileList;
    int writeMode, size;
  }
  : O_TOOL^ { theContext.setTool(); }  
  | O_REAL^ ( 
    FLOAT { theContext.setDouble(false); }
    | DOUBLE  { 
      if(!theContext.isDouble())
        cout << "Warning: multiple definition of O_REAL option, ambiguities are possible\n";
      theContext.setDouble(); 
      }
    )
  | O_EXTOBJ^ fileList=stringConstantList 
    { 
      vector<string>::iterator it;
      for(it=fileList.begin(); it!=fileList.end(); it++)
        *it = (static_cast<FilePath>(*it).removeDoubleQuote()).isFileObject();
      theContext.addExternal(fileList); 
    }
  | O_NETWARD^ size=positiveConstant 
    { 
      if(theContext.getNeuronSize())
        cout << "Warning: multiple definition of O_NETWARD option, ambiguities are possible\n";
      theContext.setNeuron(size); 
    }
  | O_M1QN3^ 
    { 
      if(theContext.isM2qn1())
        cout << "Warning: multiple definition of O_M1QN3 option, ambiguities are possible\n";
      theContext.setM1qn3(); 
    }
    ( M2QN1 { theContext.setM2qn1(); } )?
  | O_VARINCR^ { theContext.setIncremental(); }
  | O_AUTODF^ 
    {
      if(theContext.getAutoDiff())
        cout << "Warning: multiple definition of O_AUTODF option, ambiguities are possible\n";
      theContext.setAutoDiff();
    } 
    ( ALL {theContext.setAutoDiff(2);} | ONLY {theContext.setAutoDiff(1);} )?  
    ( writeMode=integerConstant 
      {
        int line = LT(1)->getLine();
        YAO_ENFORCE(writeMode == 0 || writeMode == 1)(line)("AUTODF option: write mode must be 0 or 1");
        theContext.setAutoDiffWriteMode(writeMode);
      } 
    )? 
  | O_GRADTEST^ { theContext.setGradTest(); } 
  | O_DBG_NANF^ { theContext.setDebugNan(); }
  | O_DBG_TING^ { theContext.setDebugInput(); }
  | O_DBG_BETA^ { theContext.setDebugBeta(); }
  | O_DBG_TRC_FWARD^ { theContext.setDebugForward(); }
  | O_DBG_TRC_BWARD^ { theContext.setDebugBackward(); }
  | O_DBG_TRC_LWARD^ { theContext.setDebugLinward(); }
  | O_DBG_TRC_AWARD^
  {
    theContext.setDebugForward();
    theContext.setDebugBackward();
    theContext.setDebugLinward();
  }
  ;

  trajDeclaration // Trajectory declaration.
  {
    string name;
    Trajectory::Type type;
    int line;
    int boot; // (uptime)
    int size; // (nbsteptime)
    double step = 1; // (dtime)
    double offset = 0; // (offtime)
  }
  : TRAJ^ name=identifier type=trajectoryType
      boot=integerConstant // (uptime)
      ( ( floatConstant floatConstant )=>
            offset=floatConstant // (offtime)
            { line = LT(1)->getLine(); } step=floatConstant // (dtime)
            { YAO_ENFORCE(step > 0)(line)("invalid step in trajectory: ")(name); }
        | // Optional predicate, avoids non-determinism.
      ) { line = LT(1)->getLine(); } 
      size=positiveConstant // (nbsteptime)
      {
        YAO_ENFORCE(boot < size)(line)("invalid size in trajectory: ")(name);
        theTrajectoryTable.push_back(Trajectory(name, boot, size, step, offset, type));
      }
  ;

  
  spaceDeclaration // So-called space (model operator) declaration.
  {
    string name;
    vector<int> shape;
    string parent;
  }
  : SPACE^ name=identifier M! shape=extent parent=trajectoryName
    {
      theSpaceTable.push_back(Space(name, theTrajectoryTable.find(parent), shape));
    }
  ;

  operaDeclaration // Operator declaration.
  {
    string name;
    Operator::Type type;
    vector<int> shape;
    string parent;
  }
  : OPERA^ name=identifier type=operatorType shape=extent parent=trajectoryName
    {
      theOperatorTable.push_back(Operator(name, theTrajectoryTable.find(parent), shape, type));
    }
  ;

  netwardDeclaration // Neuron declaration.
  {
    string name;
    int indegree;
    int outdegree;
  }
  : NETWARD^ name=identifier indegree=integerConstant outdegree=integerConstant
    { theNeuronTable.push_back(Neuron(name, indegree, outdegree)); }
  ;

  modulDeclaration // Module declaration.
  {
    int type;
    string parent, name;
  }
  : MODUL^ name=identifier { type = LT(1)->getType(); } 
    parent=modulParent {
      if(type == SPACE)
        theModulTable.push_back(Modul(name, theSpaceTable.find(parent), true));    
      else theModulTable.push_back(Modul(name, theOperatorTable.find(parent), false));    
    } 
    ( modulAttribute )*
  ;

  modulAttribute
  {
    Table<Modul>::iterator it = (theModulTable.end() - 1);
    int size, axe;
    string name;
  }
  : NOWARD { it->setNoward(true); }
  | INTER^ { if(it->isInter()) cout << "Warning: multiple definition of inter module option, ambiguities are possible\n";}
      axe=axis {it->setInter(axe);} 
      ( axe=axis {
        if(it->isInterYA(axe))
          cout << "Warning: multiple definition of inter YA" << axe << " option, ambiguities are possible\n";
        it->setInter(axe);
      }
        ( axe=axis {
        if(it->isInterYA(axe))
          cout << "Warning: multiple definition of inter YA" << axe << " option, ambiguities are possible\n"
               << "Warning <inter option>: define 3 axes for a subspace of a maximum 3 dimensions space has no sense\n";
          it->setInter(axe);
          if(it->isInterYA(1) && it->isInterYA(2) && it->isInterYA(3)){
            cout << "Warning: you define for inter Module option the YA1 YA2 and YA3 parameters that mean the entire space.\n"
                 << "In this case the definition of the subspace inter option has no sense\n";
          it->setInter(0);
          }
        })? 
      )?
  | INPUT^ { if(it->getInput()) cout << "Warning: multiple definition of input module option, ambiguities are possible\n"; }
    ( ARRAY { it->setArray(true); })? 
    size=integerConstant { it->setInput(size); }
  | OUTPUT^ { if(it->getOutput()) cout << "Warning: multiple definition of output module option, ambiguities are possible\n"; }
    size=integerConstant { it->setOutput(size); }
  | TARGET {it->setTarget(1); /*it->setTempo(true);*/} //default maybe?!: if target then is also tempo.
    // syntaxe: target [{uptime, UPTIME, steptime, STEPTIME, alltime, ALLTIME}] the default is uptime.
    ( (UPTIME { it->setTarget(2);} | STEPTIME {it->setTarget(3);} | ALLTIME {it->setTarget(4);} ) 
      { if(it->getTarget() > 1) cout << "Warning: multiple definition of target module option, ambiguities are possible\n"; }
    )?
  | TEMPO { it->setTempo(true); }
  | COUT { it->setCout(true); }
  | LOPERA { if(it->isLopera()) cout << "Warning: multiple definition of lopera module option, ambiguities are possible\n"; }
    ( name=operatorName {
      if(it->alreadyLopera(name)) 
        cout << "Warning: multiple definition of Operator " << name << " in lopera module option\n";
      else it->addLopera(name);
      }
    )+ 
  | COVT^ name=moduleName 
    {
      int line = LT(1)->getLine();
      if(it->isCovt()) 
        cout << "Warning: multiple definition of covt module option, ambiguities are possible\n";
      YAO_ENFORCE(theModulTable.find(name)->isCout() || theModulTable.find(name)->isTarget())
        (line)("directive modul: token covt must refer a cout or target modul\n");
      YAO_ENFORCE(theModulTable.find(name)->getCovt().empty() || theModulTable.find(name)->getCovt() == name)
        (line)("directive modul: token covt already referred cost or target modul\n");
      // If the module is Space and not Operator we exit.
      YAO_ENFORCE(!it->isSpaceOrOperator())(line)("the covt option can be applied only to modules defined like Operators.\n");
      YAO_ENFORCE(it->getParent()->getType() == 'B' || it->getParent()->getType() == 'R' || it->getParent()->getType() == 'K')
        (line)("directive modul: token covt must be associated with a covariance operator 'B', 'R' or 'K'\n");
      theModulTable.find(name)->setCovt(it->getName());
    }
  | SPEC { it->setSpec(true); }
  | NETWARD { it->setNetward(true); }
  | AUTONET^ name=neuronName
    {
      if(it->isAutonet()) 
        cout << "Warning: multiple definition of autonet module option, ambiguities are possible\n";
      it->setAutonet(name);}
  | CLONOL^ name=moduleName
    {
      if(it->isClonol()) 
        cout << "Warning: multiple definition of clonol module option, ambiguities are possible\n";
      it->setClonol(name);
    }
  | CLONOF^ name=moduleName
    {
      if(it->isClonof()) 
        cout << "Warning: multiple definition of clonof module option, ambiguities are possible\n";
      it->setClonof(name);}
  | HIDJAC { it->setHidjac(true); } // Hidden jackobien : adjoint direct like tapenade ...
  | NOADF 
    {
      if(it->isOnAdf()) 
        cout << "Warning: multiple definition of ONADF/NOADF module option, ambiguities are possible\n";
      it->setOnAdf(false); 
    }
  | ONADF { it->setOnAdf(true); }
  ;

  ctDefinition // Connection definition. CT*M constructs should be deprecated.
  { 
    Connection connection;
    string name; 
    bool ctinType=true; // True if CTIN, false if CTINM.
  }
  :
  ( CTIN^ | CTINM^ { ctinType=false; }
  ) 
  name=moduleName { connection.setInModule(name); connection.setCtinType(ctinType); theConnectionTable.push_back(connection); } 
  range[0] FROM!
  name=moduleName { Table<Connection>::iterator con = (theConnectionTable.end() - 1); con->setOutModule(name); } 
  range[1] range_i ( range_jkt )?
  ;

  orderDefinition
  { 
    Order ord(&theModulTable); 
    string commonName, spaceNames;
    //string objectName("Soce");
    vector<string> orderTokens;
  }
  : ORDER^ ( 
      MODINSPACE 
        objectName1:IDENTIFIER
        //commonName=spaceName 
        { 
        //objectName=commonName;
          int line = LT(1)->getLine();
          commonName = objectName1->getText();
          if(theSpaceTable.find(commonName)){
            YAO_ENFORCE(theSpaceTable.find(commonName)->isCounterOrderHeader()==false)
              (line)("order error: that space or opera name (")(commonName)(") has already been met\n");
            theSpaceTable.find(commonName)->setCounterOrderHeader(true);
          }else{
            YAO_ENFORCE(theOperatorTable.find(commonName)->isCounterOrderHeader()==false)
              (line)("order error: that space or opera name (")(commonName)(") has already been met\n");
            theOperatorTable.find(commonName)->setCounterOrderHeader(true);
          }
          ord.setOrderPhase(1);
        }
        
/*      objectName1:IDENTIFIER{
        //objectName="Soce";
        //objectName1->getText();
          //if(theSpaceTable.find(objectName->getText()))
         // if(theSpaceTable.find(objectName))
          {
            // Here the object reed is a space.
            YAO_ENFORCE(theSpaceTable.find(objectName)->isCounterOrderHeader()==false)
              (line)("order error: that space or opera name (")(objectName)(") has already been met\n");
            theSpaceTable.find(objectName)->setCounterOrderHeader(true);
cout << " space------------------------------------------ " << endl;
          ord.setOrderPhase(1);
          }
          }*//*else{
            this->search(theOperatorTable, objectName);
            // Here the object reed is an operator.
            YAO_ENFORCE(theOperatorTable.find(objectName->getText())->isCounterOrderHeader()==false)
              (line)("order error: that space or opera name (")(objectName->getText())(") has already been met\n");
            theOperatorTable.find(objectName->getText())->setCounterOrderHeader(true);
cout << " operator " << endl;

          }
          ord.setOrderPhase(1);
}
*/


// devo finire qui: aggiungere la possibilitC  di avere un opera anche e non solo uno space

//controllare l'esecuzione dello script sull'altra shell e quindi verificare bene che anche in rete pisces funziona

        ( modulOrder[orderTokens] { 
          ord.orderTokens.insert(ord.orderTokens.end(), orderTokens.begin(), orderTokens.end()); 
          orderTokens.clear(); 
        }
      )+

      | SPACEINTRAJ commonName=trajectoryName { 
          int line = LT(1)->getLine();
          YAO_ENFORCE(theTrajectoryTable.find(commonName)->isCounterOrder()==false)
            (line)("order error: that trajectory name (")(commonName)(") has already been met\n");
          theTrajectoryTable.find(commonName)->setCounterOrder(true);
          ord.setOrderPhase(2); 
        }
      ( spaceNames=spaceName  { ord.orderTokens.push_back(spaceNames); } )+
    ) FORDER! 
      { 
      ord.setName(commonName);
      theOrderTable.push_back(ord);
      }
  ;

  modulOrder[vector<string>& orderTokens]
  { 
    int axe;
    string token;
  }
  : tok1:ORDER^ { orderTokens.push_back(tok1->getText()); }
  ( axe=axis { orderTokens.push_back(Order::translateAxe(axe)); } )+ 
  ( token=moduleName 
    { 
      orderTokens.push_back(token); 
      // Generate a warning if the module is already present in a directive order modinspace
      /*if(theModulTable.find(token)->isCounterOrder()){
        cout << "WARNING: the module " << token << " appears more than once in order directive\n"
             << "         you should rather use clone key word !?\n";
      }else theModulTable.find(token)->setCounterOrder(true);
      */
    }
  | modulOrder[orderTokens] )+ 
  tok3:FORDER! { orderTokens.push_back(tok3->getText()); }
  ;

  insert_fctDeclaration
  {
    bool parameterized = false;
    string name;
  }
  : INSERT_FCT^ ( ARG { parameterized = true; } )? name=identifier
    { theFunctionTable.push_back(Function(name, parameterized)); }
  ;

  // Common syntax rules: identifier.
  identifier returns [std::string result]
  : name:IDENTIFIER
  {
    int line = LT(1)->getLine();
    result = name->getText();
    Table<Identifier>::const_pointer found = theIdentifierTable.find(result);
    YAO_ENFORCE(!found)(name->getLine())(line)(result)(" already declared line ")(found->getLine());
    theIdentifierTable.push_back(Identifier(result, name->getLine()));
  }
  ;

  // Common syntax rules: literals.
  integerLiteral returns [std::string result]
  : value:INTEGER_LITERAL { result = value->getText(); }
  ;

  floatLiteral returns [std::string result]
  : value:FLOAT_LITERAL { result = value->getText(); }
  ;

  stringLiteral returns [std::string result]
  : value:STRING_LITERAL { result = value->getText(); }
  ;

  // Common syntax rules: constants.
  integerConstant returns [int result]
  {
    int line = LT(1)->getLine();
    string value;
  }
  : ( value=integerLiteral
      | value=constantName { value = theConstantTable.find(value)->getText(); }
    ){ result = stream_cast<int>(value); }  // Be carefull value cannot be greater then a 16 bit number (is a signed so 15 bit for positive number).  
  exception catch [bad_cast]
    { YAO_REPORT(line)("can't convert ")(value)(" to integer"); }
  ;

  floatConstant returns [double result]
  {
    int line = LT(1)->getLine();
    string value;
  }
  : ( value=integerLiteral
      | value=floatLiteral
      | value=constantName { value = theConstantTable.find(value)->getText(); }
    )
    { result = stream_cast<double>(value); } 
  exception catch [bad_cast]
    { YAO_REPORT(line)("can't convert ")(value)(" to floating point value"); }
  ;

  stringConstant returns [std::string result]
    { int line = LT(1)->getLine(); }
  : ( result=stringLiteral
      | result=constantName
      {
        result = theConstantTable.find(result)->getText();
        YAO_ENFORCE(*result.begin() == '\"')(line)("can't convert ")(result)(" to quoted string");
      }
    )
  ;

  stringConstantList returns [std::vector<std::string> result]
  { string filename; }
  : ( filename=stringConstant { result.push_back(filename); } )+
  ;

  positiveConstant returns [int result]
  { int line = LT(1)->getLine(); }
  : result=integerConstant { YAO_ENFORCE(result > 0)(line)("invalid size"); }
  ;

  // Common syntax rules: object names.
  constantName returns [std::string result]
  : name:IDENTIFIER { result = this->search(theConstantTable, name); }
  ;

  trajectoryName returns [std::string result]
  : name:IDENTIFIER { result = this->search(theTrajectoryTable, name); }
  ;

  spaceName returns [std::string result]
  : name:IDENTIFIER { result = this->search(theSpaceTable, name); }
  ;

  operatorName returns [std::string result]
  : name:IDENTIFIER { result = this->search(theOperatorTable, name); }
  ;

  neuronName returns [std::string result]
  : name:IDENTIFIER { result = this->search(theNeuronTable, name);  }
  ;

  moduleName returns [std::string result]
  : name:IDENTIFIER { result = this->search(theModulTable, name); }
  ;

  // Common syntax rules: object attributes.
  trajectoryType returns [Trajectory::Type result]
  {
    int line = LT(1)->getLine();
    string type = LT(1)->getText();
  }
  : ( M | B | H | R | K | I | J | T | IDENTIFIER ) 
    //We have included also the operators and the axes because these are keywords 
    //(they are recognized like keywords from the lexer) and so
    //they are not normal IDENTIFIERs (the LA(1) value is different).
  {
    // Produces same error message as operatorType.
    YAO_ENFORCE(type.length() == 1)(line)("unexpected token: ")(type);
    result = type[0];
    YAO_ENFORCE(result != '_')(line)("unexpected token: ")(type);
  }
  ;

  extent returns [std::vector<int> result]
  {
    int x;
    int y;
    int z;
  }
  : ( positiveConstant positiveConstant positiveConstant trajectoryName )=>
      x=positiveConstant y=positiveConstant z=positiveConstant
        { result.push_back(x); result.push_back(y); result.push_back(z); }
  | ( positiveConstant positiveConstant trajectoryName )=>
      x=positiveConstant y=positiveConstant
        { result.push_back(x); result.push_back(y); }
  | ( positiveConstant trajectoryName )=>
      x=positiveConstant { result.push_back(x); }
  ;

  operatorType returns [Operator::Type result]
  : H { result = Operator::H; } // Observation operator.
  | B { result = Operator::B; } // Background error covariance operator.
  | R { result = Operator::R; } // Observation error covariance operator.
  | K { result = Operator::K; } // Balance operator.
  ;

  modulParent returns [string name]
  : ( SPACE^ name=spaceName | OPERA^ name=operatorName )
  ;

  axis returns [int axe] // Ascending or descending axis.
  : YA1 {axe=1;} | YB1 {axe=-1;} 
  | YA2 {axe=2;} | YB2 {axe=-2;}
  | YA3 {axe=3;} | YB3{axe=-3;}
  ;

  // "parameterNumber" is a number that identifies the actual position we are parsing in the directive. This is in order to understand
  // which type of range we are managing: 0 is for the input range, 1 is for the output range, 2/3/4/5 are for the i/j/k/t respectively.
  range[short parameterNumber] 
  {
    Table<Connection>::iterator con = (theConnectionTable.end() - 1);
    int begin=0, end=0;
  }
  : begin=integerConstant ( DOT_DOT^ end=integerConstant )?
      {con->setAbsoluteInterval(begin, end, parameterNumber);}
  ;

  range_i
  {
    Table<Connection>::iterator con = (theConnectionTable.end() - 1);
    int value=0;
  }
  : range[2]
  | I ( rangeOperator:MODULO^ value=integerConstant )?
  { 
    if(value)
      con->setRelativeInterval(rangeOperator->getText(), value, 2);
    else con->setRelativeInterval("", 0, 2);
  }
  ;

  range_jkt
  : ( range_j range_k range_t )=> range_j range_k range_t
  | ( range_j range_k )=> range_j range_k
  | ( range_j range_t )=> range_j range_t
  | ( range_j )=> range_j
  | range_t
  ;

  range_j
  {
    Table<Connection>::iterator con = (theConnectionTable.end() - 1);
    int value=0;
  }
  : range[3]
  | J ( rangeOperator:MODULO^ value=integerConstant )?
  { 
    if(value)
      con->setRelativeInterval(rangeOperator->getText(), value, 3);
    else con->setRelativeInterval("", 0, 3);
  }
  ;

  range_k
  { 
    Table<Connection>::iterator con = (theConnectionTable.end() - 1);
    int value=0;
  }
  : range[4]
  | K ( rangeOperator:MODULO^ value=integerConstant )?
      { if(value)
         con->setRelativeInterval(rangeOperator->getText(), value, 4);
        else con->setRelativeInterval("", 0, 4);
      }
  ;

  range_t
  { 
    Table<Connection>::iterator con = (theConnectionTable.end() - 1);
    int value=0;
  }
  : range[5]
  | (tT:T ( rangeOperator:MODULO^ value=integerConstant )?
      { if(tT->getText() == "t"){ // 't' case.
          if(value)
            con->setRelativeInterval(rangeOperator->getText(), value, 5);
          else con->setRelativeInterval("", 0, 5);
        }else{ // 'T' case.
          int line = LT(1)->getLine();
          YAO_ENFORCE( theModulTable.find(con->getOutModule())->getTrajectory() !=  theModulTable.find(con->getInModule())->getTrajectory() )
            (line)("ctin directive: capital T index should be used only when different trajectories\n");
          if(value)
            con->setRelativeInterval(rangeOperator->getText(), value, 6);
          else con->setRelativeInterval("", 0, 6);
        }
      }
    )
  ;


{bool warning = false;} // For the warning message of deprecated comment. We want print just one time.
/**
 * \class yao::BaseLexer
 * \brief BaseLexer class, handles whitespaces, comments, identifiers, literals (integer, float, string) and ranges.
 * The lexing recognizes all the token of the description file. 
 * All the tokens are given to the parser in a second stage.
 */
class BaseLexer extends Lexer;
  options
  {
    k = 2;                        // Fixed look-ahead.
    charVocabulary = '\0'..'\377';  // Sets allowed lexer characters.
    defaultErrorHandler = false;          // Turns off default exception handling.
    testLiterals = false;                 // Turns off tokens testing against reserved keywords.
    caseSensitiveLiterals = false;  // Ignores case for reserved keywords.
  }

  tokens // Reserved keywords (identifiers).
  {
    // Old syntax keywords.
    EXEC = "exec";
    EXIT = "exit";
    DISP_DEFVAL = "disp_defval";
    DISP_TRAJ = "disp_traj";
    DISP_SPACE = "disp_space";
    DISP_OPERA = "disp_opera";
    DISP_NETWARD = "disp_netward";
    DISP_MODUL = "disp_modul";
    DISP_CT_IN = "disp_ct_in";
    DISP_CT_OUT = "disp_ct_out";
    DISP_FLAGOP = "disp_flagop";
    DISP_OPTION = "disp_option";
    DEFVAL = "defval";
    HAT_NAME = "hat_name";
    O_TOOL = "O_TOOL";
    O_REAL = "O_REAL";
    FLOAT = "float";
    DOUBLE = "double";
    O_EXTOBJ = "O_EXTOBJ";
    O_NETWARD = "O_NETWARD";
    O_M1QN3 = "O_M1QN3";
    O_VARINCR = "O_VARINCR";
    O_AUTODF = "O_AUTODF";
    ALL = "all";   // option of O_AUTODF : all the modules 
    ONLY = "only"; // option of O_AUTODF : only some modules  
    O_GRADTEST = "O_GRADTEST";
    O_DBG_NANF = "O_DBG_NANF";
    O_DBG_TING = "O_DBG_TING";
    O_DBG_BETA = "O_DBG_BETA";
    O_DBG_TRC_FWARD = "O_DBG_TRC_FWARD";
    O_DBG_TRC_BWARD = "O_DBG_TRC_BWARD";
    O_DBG_TRC_LWARD = "O_DBG_TRC_LWARD";
    O_DBG_TRC_AWARD = "O_DBG_TRC_AWARD";
    TRAJ = "traj";
    M = "M";
    SPACE = "space";
    OPERA = "opera";
    NETWARD = "netward";
    MODUL = "modul";
    NOWARD = "noward";
    INTER = "inter";
    YA1 = "YA1";
    YA2 = "YA2";
    YA3 = "YA3";
    YB1 = "YB1";
    YB2 = "YB2";
    YB3 = "YB3";
    ARRAY = "array";
    TARGET = "target";
    UPTIME = "uptime";
    STEPTIME = "steptime";
    ALLTIME = "alltime";
    TEMPO = "tempo";
    COUT = "cout";
    LOPERA = "lopera";
    COVT = "covt";
    SPEC = "spec";
    AUTONET = "autonet";
    CLONOL = "clonol";
    CLONOF = "clonof";
    HIDJAC = "hidjac";
    NOADF = "noadf";
    ONADF = "onadf";
    CTIN = "ctin";
    CTINM = "ctinm";
    INSERT_FCT = "insert_fct";
    ARG = "arg";
    MODINSPACE = "modinspace";
    SPACEINTRAJ = "spaceintraj";
    FORDER = "forder";

    // Common keywords.
    HELP = "help";
    INPUT = "input";
    OUTPUT = "output";
    OPTION = "option";
    M2QN1 = "M2QN1";
    H = "H";
    B = "B";
    R = "R";
    K = "K";
    FROM = "from";
    TO = "to";
    I = "i";
    J = "j";
    T = "t";
    ORDER = "order";
  }

  {

    public:

      virtual ~BaseLexer() {} //!< Destructor.
  }

  WHITESPACE // Space or newline (increments line count).
  : ( ' ' | '\t' | '\f' | ( "\r\n" | '\r' | '\n' ) { newline(); } )
    { $setType(Token::SKIP); 
      setColumn(1); // This is added for the condition getColumn() == 1 in the DEPRECATEDCOMMENT rule ;
    }
  ;

  // Single line comment '//' ('#' and '|' are deprecated but
  // for compatibility with precedents Yao applications we consider also these cases).
  DEPRECATEDCOMMENT // Deprecated comment '#'.
  : {getColumn() == 1}? '#'  ( ~( '\n' | '\r' ) )* ( '\n' | '\r' )
    {if(!warning) 
      cout << " Warning: use of '#' for comments is deprecated, use C notation '//'" << endl;
    warning = true;
    newline();
    $setType(Token::SKIP);
    };

  COMMENT
  : ("//"
      | '|' //deprecated comment |
      {
        if(!warning) 
          cout << " Warning: use of '|' for comments is deprecated, use C notation '//'" << endl;
        warning = true;
      }
    )
  ( ~( '\n' | '\r' ) )* ( '\n' | '\r' )  { newline(); $setType(Token::SKIP); };

  IDENTIFIER // Identifier or reserved keyword.
  options {
    paraphrase = "an identifier  "; // Makes error messages more readable.
    testLiterals = true; // Tests identifiers against reserved keywords.
  }
  : ( 'a'..'z' | 'A'..'Z' | '_' ) ( 'a'..'z' | 'A'..'Z' | '_' | '0'..'9' )* ;

  INTEGER_LITERAL // Base 10 integer.
  options {  paraphrase = "an integer value"; } // Makes error messages more readable.
  : ( '0'..'9' )+
  ( { (LA(2) != '.') }? '.' ( '0'..'9' )* ( EXPONENT )?
    { $setType(FLOAT_LITERAL); } // Left factoring.
    | ( EXPONENT { $setType(FLOAT_LITERAL); } )? // Left factoring.
  );

  protected
  EXPONENT
  : ( 'e' | 'E' ) ( '+' | '-' )? ( '0'..'9' )+
  ;

  FLOAT_LITERAL // Floating point value.
  options {  paraphrase = "a floating point value";} // Makes error messages more readable.
  : '.' ( '0'..'9' )+ ( EXPONENT )?
  ;

  STRING_LITERAL // Single line quoted string.
  options {  paraphrase = "a quoted string"; } // Makes error messages more readable.
  : '"' (' ' | '\t')* ( 'a'..'z' | 'A'..'Z' | '_' | '-' | '.'| '0'..'9' )+ (' ' | '\t')* '"' 
  ;

  /*STRING_LITERAL // Single line quoted string.
    options {  paraphrase = "a quoted string"; } // Makes error messages more readable.
    : '"' ( '\\' ( 'b' | 't' | 'n' | 'f' | 'r' | "\"" | '\'' | '\\' )
    | ~( '\\' | '\"' | '\n' | '\r' ) )* '"'
    ;
   */
  DOT_DOT // Absolute range operator.
  : ".."
  ;

  MODULO // Relative range operator.
  : '+'  
  | '-'  
  | '~' 
  | "%+"   
  | "%-"  
  | "%~"  
  | "#+"   
  | "#-"   
  | "#~"    
  ;