stmtNode.h

Ir a la documentación de este archivo.

//stmtNode.h
//-------------------------------------------------------------------------------------------
/*
 * Fco. Javier Bohórquez Ogalla
 * 75766599-E
 * Puerto Real (Cádiz)
 * powersgame@gmail.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 2 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 */
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
#ifndef _RUN_STMTS_STMTNODE_
#define _RUN_STMTS_STMTNODE_

#include "../tree/runTree.h"

#include "condStmtNode.h"
#include "ioStmtNode.h"
#include "loopStmtNode.h"
#include "../../lshParser.h"

extern int yylineno;
extern int yyparse ();
extern void yyrestart(FILE*);
extern FILE* yyin;
extern string infile;
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class noNode :
   public runNode {
 public:
   noNode ();
   void run ();
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class stmtNode :public runNode  {
 public:
   stmtNode (runNode* node1, runNode* node2, YYLTYPE bloq = YYLTYPE(), bool firstlevel = false);
   void run ();
   static void newLine (void);
   static int row_;
   static bool compile_error;
 private:
   runNode *node1_, *node2_;
   int line_;
   bool firstlevel_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class includeNode :
   public runNode {
 public:
   includeNode (runNode* file);
   void run ();
 private:
   runNode* file_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class typeofNode :
   public runNode {
 public:
   typeofNode (idNode* id);
   void run ();
   static string type (runNode *r);
 private:
   idNode *id_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class breakException :
   public std::exception {
 public:
   breakException (int n = 1);
   const char* what() const throw();
   void end ();
 private:
   int n_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class breakNode:
   public runNode {
 public:
   breakNode (int n = 1);
   void run ();
 private:
   int n_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class exitNode:
   public runNode {
 public:
   void run ();
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class labelNode :
   public runNode {
 public:
   labelNode (runNode* id, runNode* stmt);
   void run ();
 private:
   runNode *id_, *stmt_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class gotoException :
   public std::exception {
 public:
   const char* what() const throw();
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class gotoNode :
   public runNode {
 public:
   gotoNode (runNode* node);
   void run ();
 private:
   runNode *node1_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class withNode : public runNode {
   public: 
      withNode (runNode* node, runNode *stmts);
      void run();
      static void push_with (runNode* node);
      static runNode *get_with ();
      static void pop_with ();
      
   private:
      static vector<runNode *> stack_with;
      static int top_with;
      runNode *node_, *stmts_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class sizeOfNode : public arithNode {
   public:
      sizeOfNode (runNode* node);
      void run ();
   private:
      runNode * node_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class datInfoNode : public runNode {
   public:
      datInfoNode (runNode* node);
      void run ();
   private:
      runNode * node_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class throwException :
   public std::exception {
 public:
   throwException (runNode* resp);
   const char* what() const throw();
   runNode* val () const;
 private:
   runNode* resp_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class throwNode : public runNode {
   public:
      throwNode (runNode* obj);
      void run ();
   private:
      runNode *obj_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
class tryNode : public runNode {
   public:
      tryNode (runNode* tryblock, runNode *id, runNode *catchblock);
      void run ();
   private:
      runNode * tryblock_, *id_, *catchblock_;
};
//-------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------
#endif
//-------------------------------------------------------------------------------------------
//Fco. Javier Bohórquez Ogalla