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

Go to the documentation of this file.

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

   Short description
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: mar ago 3 2004

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

   See LICENSE file for licensing details.
*/

#ifndef FLC_MODLOADER_H
#define FLC_MODLOADER_H

#include <falcon/common.h>
#include <falcon/error.h>
#include <falcon/string.h>
#include <falcon/basealloc.h>
#include <falcon/compiler.h>

namespace Falcon {

class Module;
class Stream;
class URI;
class FileStat;
class VFSProvider;

class FALCON_DYN_CLASS ModuleLoader: public BaseAlloc
{
public:
   typedef enum
   {
      t_none,
      t_source,
      t_ftd,
      t_vmmod,
      t_binmod,
      t_defaultSource
   } t_filetype;


protected:
   Module *loadModule_ver_1_0( Stream *in );

   bool m_alwaysRecomp;
   bool m_compMemory;
   bool m_saveModule;
   bool m_saveMandatory;
   bool m_detectTemplate;
   bool m_forceTemplate;
   bool m_delayRaise;
   bool m_ignoreSources;
   bool m_saveRemote;
   uint32 m_compileErrors;

   Compiler m_compiler;
   String m_srcEncoding;
   bool m_bSaveIntTemplate;

   Module *compile( const String &path );
   t_filetype searchForModule( String &final_name );
   t_filetype checkForModuleAlreadyThere( String &final_name );


   String m_language;

   Module *loadModule_select_ver( Stream *in );

   static void getModuleName( const String &path, String &modName );

   List m_path;

   virtual Stream *openResource( const String &path, t_filetype type = t_none );

   bool scanForFile( URI &origUri, VFSProvider*, t_filetype &type, FileStat &fs );

   virtual t_filetype fileType( const String &path );

   bool applyLangTable( Module *mod, const String &file_path );

public:

   ModuleLoader();
   ModuleLoader( const ModuleLoader &other );

   ModuleLoader( const String &path );

   virtual ~ModuleLoader();

   virtual ModuleLoader *clone() const;


   void setSearchPath( const String &path );

   void addFalconPath();

   void addSearchPath( const String &path );

   void addDirectoryFront( const String &directory )
   {
      if ( directory != "" )
         m_path.pushFront( new String( directory ) );
   }

   void addDirectoryBack( const String &directory )
   {
      if ( directory != "" )
         m_path.pushBack( new String( directory ) );
   }

   virtual Module *loadName( const String &module_name, const String &parent_module = "" );

   virtual Module *loadFile( const String &module_path, t_filetype type=t_none, bool scan=false );

   virtual Module *loadFile( const URI &module_URI, t_filetype type=t_none, bool scan=false );

   virtual Module *loadModule( Stream *input );

   Module *loadModule( const String &file );

   virtual Module *loadSource( const String &file );

   virtual Module *loadSource( Stream *in, const String &uri, const String &modname );

   virtual Module *loadBinaryModule( const String &module_path );

   void raiseError( int code, const String &expl, int fsError=0 );

   void getSearchPath( String &target ) const;

   String getSearchPath() const
   {
      String temp;
      getSearchPath( temp );
      return temp;
   }

   void saveIntTemplates( bool mode /*, bool force=false */ )
   {
      m_bSaveIntTemplate = mode;
   }

   void setLanguage( const String &langname ) { m_language = langname; }

   const String &getLanguage() const { return m_language; }

   bool loadLanguageTable( Module *module, const String &language );

   bool ignoreSources() const { return m_ignoreSources; }

   bool alwaysRecomp() const { return m_alwaysRecomp;}

   void ignoreSources( bool mode ) { m_ignoreSources = mode; }
   void alwaysRecomp( bool mode ) { m_alwaysRecomp = mode; }

   void compileInMemory( bool ci ) { m_compMemory = ci; }
   bool compileInMemory() const { return m_compMemory; }

   void saveModules( bool t ) { m_saveModule = t; }
   bool saveModules() const { return m_saveModule; }

   void sourceEncoding( const String &name ) { m_srcEncoding = name; }
   const String &sourceEncoding() const { return m_srcEncoding; }

   void delayRaise( bool setting ) { m_delayRaise = setting; }
   bool delayRaise() const { return m_delayRaise; }

   void saveMandatory( bool setting ) { m_saveMandatory = setting; }
   bool saveMandatory() const { return m_saveMandatory; }

   void detectTemplate( bool bDetect ) { m_detectTemplate = bDetect; }
   bool detectTemplate() const { return m_detectTemplate; }

   void compileTemplate( bool bCompTemplate ) { m_forceTemplate = bCompTemplate; }
   bool compileTemplate() const { return m_forceTemplate; }

   void saveRemote( bool brem ) { m_saveRemote = brem; }

   bool saveRemote() const { return m_saveRemote; }

   uint32 compileErrors() const { return m_compileErrors; }

   const Compiler &compiler() const { return m_compiler; }

   Compiler &compiler() { return m_compiler; }
};

}

#endif
/* end of modloader.h */

---