/home/gian/Progetti/falcon/core/include/falcon/genhasm.h

Go to the documentation of this file.

/*
   FALCON - The Falcon Programming Language.
   FILE: genhasm.h

   Short description
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: sab giu 5 2004

   -------------------------------------------------------------------
   (C) Copyright 2004: the FALCON developers (see list in AUTHORS file)

   See LICENSE file for licensing details.
*/

#ifndef FALCON_GENHSAM_H
#define FALCON_GENHSAM_H

#include <falcon/generator.h>
#include <falcon/compiler.h>
#include <falcon/genericlist.h>

namespace Falcon
{


class FALCON_DYN_CLASS GenHAsm: public Generator
{
   void gen_depTable( const Module *mod );
   void gen_stringTable( const Module *mod );
   void gen_symbolTable( const Module *mod );
   void gen_function( const StmtFunction *func );
   void gen_class( const StmtClass *cls );
   void gen_propdef( const VarDef &def );
   void gen_block( const StatementList *slist );
   void gen_statement( const Statement *stmt );
   void gen_condition( const Value *stmt, int mode=0 );
   void gen_value( const Value *stmt, const char *prefix = 0, const char *cpl_post = 0 );
   void gen_operand( const Value *stmt );

   typedef enum {
      l_value,
      p_value,
      v_value
   } t_valType;

   void gen_complex_value( const Value *value, t_valType &x_value );

   void gen_complex_value( const Value *value ) { t_valType dummy; gen_complex_value( value, dummy ); }

   void gen_expression( const Expression *expr, t_valType &x_value );

   void gen_expression( const Expression *expr ) { t_valType dummy; gen_expression( expr, dummy ); }

   void gen_dict_decl( const DictDecl *stmt );
   void gen_array_decl( const ArrayDecl *stmt );
   void gen_range_decl( const RangeDecl *stmt );

   void gen_push( const Value *val );

   void gen_load( const Value *target, const Value *source );
   //void gen_load( const Value *target, const char *source );
   void gen_store_to_deep( const char *type, const Value *source, const Value *first, const Value *second );

   void gen_inc_prefix( const Value *target );
   void gen_dec_prefix( const Value *target );
   void gen_inc_postfix( const Value *target );
   void gen_dec_postfix( const Value *target );
   void gen_autoassign( const char *op, const Value *target, const Value *source );
   void gen_store_to_deep_A( const char *type, const Value *first, const Value *second );
   void gen_store_to_deep_reg( const char *type, const Value *first, const Value *second, const char *reg );
   void gen_load_from_deep( const char *type, const Value *first, const Value *second );
   void gen_load_from_A( const Value *target );
   void gen_load_from_reg( const Value *target, const char *reg );
   int gen_refArray( const ArrayDecl *tarr, bool bGenArray );

   void dump_cases( int branch, const MapIterator &begin );

   void gen_funcall( const Expression *call, bool fork=false );

   int m_branch_id;
   int m_loop_id;
   int m_try_id;

   List m_branches;
   List m_loops;
   List m_trys;

   class LoopInfo
   {
   public:
      LoopInfo( int id, const Statement* l ):
         m_loop( l ),
         m_id( id ),
         m_isForLast( false )
         {}

      const Statement* m_loop;
      int m_id;
      bool m_isForLast;
   };

   List m_functions;

public:
   GenHAsm( Stream *out );
   virtual void generate( const SourceTree *st );
   void generatePrologue( const Module *module );
};

}
#endif
/* end of genhasm.h */

---