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

Go to the documentation of this file.

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

   Main Falcon source compiler.
   -------------------------------------------------------------------
   Author: Giancarlo Niccolai
   Begin: dom giu 6 2004

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

   See LICENSE file for licensing details.
*/

#ifndef FALCON_COMPILER_H
#define FALCON_COMPILER_H

#include <falcon/syntree.h>
#include <falcon/error.h>
#include <falcon/common.h>
#include <falcon/string.h>
#include <falcon/module.h>
#include <falcon/genericlist.h>
#include <falcon/basealloc.h>

extern "C" int flc_src_parse( void *param );

namespace Falcon
{

class SrcLexer;
class Stream;
class InteractiveCompiler;
class VMachine;
class ModuleLoader;

class FALCON_DYN_CLASS AliasMap: public Map
{
public:

   AliasMap();
};

class FALCON_DYN_CLASS DeclarationContext: public BaseAlloc
{
   byte m_value;
public:
   DeclarationContext(){ m_value = 0; }
   DeclarationContext( const DeclarationContext &dc ) {
      m_value = dc.m_value;
   }

   DeclarationContext &operator =( const DeclarationContext &other ) {
      m_value = other.m_value; return *this;
   }

   DeclarationContext &setGlobalQuery() { m_value = 0; return *this; }
   DeclarationContext &setQuery() { m_value &= ~0x1; return *this; }
   DeclarationContext &setAssign() { m_value |= 0x1; return *this; }
   DeclarationContext &setGlobalBody() { m_value &= ~(0x2|0x4|0x8); return *this; }
   DeclarationContext &setFunctionBody() { m_value |= 0x2; m_value &= ~(0x4); return *this; }
   DeclarationContext &setClassBody() { m_value |= 0x4; m_value &= ~(0x2); return *this; }
   DeclarationContext &setStatic() { m_value |= 0x8; return *this; }
   DeclarationContext &setNonStatic() { m_value &= ~0x8; return *this; }

};


class FALCON_DYN_CLASS Compiler: public BaseAlloc
{
protected:
   typedef enum {
      e_dc_global,
      e_dc_param,
      e_dc_static_func,
      e_dc_func_body,
      e_dc_static_class,
      e_dc_class_body
   } t_decl_context;

   Map m_constants;

   Map m_namespaces;

   SourceTree *m_root;

   int m_errors;
   int m_optLevel;

   SrcLexer *m_lexer;
   Stream *m_stream;

   Module *m_module;

   int64 m_enumId;

   List m_context;
   List m_func_ctx;

   List m_contextSet;
   List m_loops;

   List m_statementVals;

   List m_functions;

   List m_alias;

   const String *m_staticPrefix;

   int m_lambdaCount;
   int m_closureContexts;
   int m_tempLine;

   bool m_strict;

   String m_language;

   int64 m_modVersion;

   bool m_defContext;

   bool m_bParsingFtd;

   bool m_bInteractive;

   Error *m_rootError;
   InteractiveCompiler *m_metacomp;
   VMachine *m_serviceVM;
   ModuleLoader *m_serviceLoader;

   String m_searchPath;

   void clear();

   void init();

  void addPredefs();

public:
   Compiler();

   Compiler( Module *mod, Stream *input );
   virtual ~Compiler();

   void reset();

   bool compile();

   bool compile( Module *mod, Stream *input );

   void raiseError( int errorNum, int errorLine=0);

   void raiseError( Error *e );

   void raiseContextError( int code, int line, int startLine );
   void raiseError( int errorNum, const String &errorp, int errorLine=0);
   void addError() { m_errors++; }

   Symbol *searchLocalSymbol( const String *symname, bool bRecurse = false );
   Symbol *searchGlobalSymbol( const String *symname );
   Symbol *addLocalSymbol( const String *symname, bool parameter );
   Symbol *addGlobalSymbol( const String *symname );
   Symbol *searchOuterSymbol( const String *symname );

   Symbol *addGlobalVar( const String *symname, VarDef *value );
   bool isLocalContext() { return ! m_functions.empty(); }

   const Value *getConstant( const String &name ) {
      Value **findp = (Value **) m_constants.find( &name );
      if ( findp != 0 )
         return *findp;
      return 0;
   }

   virtual void addLoad( const String &name, bool isFilename ) {
      m_module->addDepend( name, false, isFilename );
   }

   // Inlines
   void addStatement( Statement *stm ) { if ( stm != 0 ) getContextSet()->push_back( stm ); }
   void addFunction( Statement *stm ) { if ( stm != 0 ) m_root->functions().push_back( stm ); }
   void addClass( Statement *stm ) { if ( stm != 0 ) m_root->classes().push_back( stm ); }
   void pushLoop( Statement *stm ) { m_loops.pushBack( stm ); }
   void pushFunction( FuncDef *f );
   void pushContext( Statement *stm ) { m_context.pushBack( stm ); }
   void pushContextSet( StatementList *list ) { m_contextSet.pushBack( list ); }
   Statement *getContext() const { if ( m_context.empty() ) return 0; return (Statement *) m_context.back(); }
   Statement *getLoop() const { if ( m_loops.empty() ) return 0; return (Statement *) m_loops.back(); }
   StatementList *getContextSet() const { if ( m_contextSet.empty() ) return 0; return (StatementList *)m_contextSet.back(); }
   FuncDef * getFunction() const { if ( m_functions.empty() ) return 0; return (FuncDef *) m_functions.back(); }
   void popLoop() { m_loops.popBack(); }
   void popContext() { m_context.popBack(); }
   void popContextSet() { m_contextSet.popBack(); }
   void popFunction();
   void pushFunctionContext( StmtFunction *func ) { m_func_ctx.pushBack( func ); }
   void popFunctionContext() { if ( !m_func_ctx.empty() ) m_func_ctx.popBack(); }
   StmtFunction *getFunctionContext() const { if ( m_func_ctx.empty() ) return 0; return (StmtFunction*) m_func_ctx.back(); }

   String *addString( const String &str ) { return m_module->addString( str ); }

   SrcLexer *lexer() const { return m_lexer; }
   Stream *stream() const { return m_stream; }

   int lambdaCount() const { return m_lambdaCount; }
   void incLambdaCount() { m_lambdaCount++; }

   void addNilConstant( const String &name, uint32 line=0 );
   void addIntConstant( const String &name, int64 value, uint32 line=0 );
   void addNumConstant( const String &name, numeric value, uint32 line=0 );
   void addStringConstant( const String &name, const String &value, uint32 line=0 );
   void addConstant( const String &name, Value *val, uint32 line=0 );

   void addAttribute( const String &name, Value *val, uint32 line=0 );


   SourceTree *sourceTree() const { return m_root; }
   Module *module() const { return m_module; }

   int errors() const { return m_errors; }
   //void include( const char *filename );
   //void includePath( const Hstring &incp );

   void defineVal( Value *val );

   void defineVal( ArrayDecl *val );

   Symbol  *globalize( const String *str );

   bool checkLocalUndefined();
   void addSymdef( Value *val ) { List *l = (List *) m_statementVals.back(); l->pushBack( val ); }

   const String *staticPrefix() const { return m_staticPrefix; }
   void staticPrefix( const String *v ) { m_staticPrefix = v; }

   StmtFunction *buildCtorFor( StmtClass *sym );

   void closeFunction();

   void tempLine( int line ) { m_tempLine = line; }
   int tempLine() const { return m_tempLine; }

   void strictMode( bool breq ) { m_strict = breq; }
   bool strictMode() const { return m_strict; }

   bool parsingFtd() const;
   void parsingFtd( bool b );

   bool setDirective( const String &directive, const String &value, bool bRaise = true );

   bool setDirective( const String &directive, int64 value, bool bRaise = true );

   void defContext( bool ctx ) { m_defContext = ctx; }
   bool defContext() const { return m_defContext; }

   Value *closeClosure();
   void incClosureContext() { m_closureContexts++; }
   void decClosureContext() { m_closureContexts--; }

   void addEnumerator( const String &name, Value *value );

   void addEnumerator( const String &name );

   void resetEnum() { m_enumId = 0; }

   bool isNamespace( const String &symName );

   virtual void addNamespace( const String &nspace, const String &alias, bool full=false, bool filename=false );

   virtual void importSymbols( List *lst, const String *prefix=0, const String *alias=0, bool filename=false );

   virtual Symbol* importAlias( const String *symName, const String *fromMod, const String *alias, bool filename=false );

   void metaCompile( const String &data, int startline );

   VMachine *serviceVM() const { return m_serviceVM; }

   ModuleLoader *serviceLoader() const { return m_serviceLoader; }

   void serviceVM( VMachine *vm ) { m_serviceVM = vm; }

   void serviceLoader(ModuleLoader *l) { m_serviceLoader = l; }

   Error *detachErrors() { Error *e = m_rootError; m_rootError = 0; m_errors = 0; return e; }

   void setInteractive( bool bint ) { m_bInteractive = bint; }

   bool isInteractive() const { return m_bInteractive; }

   const String& searchPath() const { return m_searchPath; }

   void searchPath( const String& path ) { m_searchPath = path; }
};

} // end of namespace

#endif

/* end of compiler.h */

---