YBlock.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

   File:        YBlock.h

   Author:      Klaus Kaempf <kkaempf@suse.de>
                Stanislav Visnovsky <visnov@suse.cz>
   Maintainer:  Stanislav Visnovsky <visnov@suse.cz>

/-*/
// -*- c++ -*-

#ifndef YBlock_h
#define YBlock_h

#include <string>
#include <list>
using std::string;
#include <y2util/Ustring.h>

#include <y2/Y2Namespace.h>
#include "ycp/YStatement.h"

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

class YSImport;

class YBlock : public YCode, public Y2Namespace
{
    REP_BODY (YBlock);

public:
    // block kinds
    typedef enum {
        b_unknown = 0,          // 0: unspecified
        b_module,               // 1: toplevel module (-> m_table != 0)
        b_file,                 // 2: toplevel file block
        b_statement,            // 3: used as statement (local block which might contain return)
        b_definition,           // 4: used as function definition
        b_value,                // 5: used as value (intermediate block)
        b_namespace,            // 6: block defines a namespace
        b_using                 // 7: block is evaluated in different namespace
    } blockkind_t;

private:
    // --------------------------------
    // general block data

    // Block kind
    // b_statement == implict return YCPNull() (block is statement, default)
    // else YCPVoid () (treat block as expression)
    blockkind_t m_kind;

    // Pointer to name of block.
    //   normaly empty, non-empty for b_module and b_namespace
    string m_name;

    // --------------------------------
    // Environment
    // keep track of symbols entered into SymbolTable (declared
    // in this block), we must remove then at finishBlock()
    // so they go out of scope

    struct yTElist {
        struct yTElist *next;
        TableEntry *tentry;
        unsigned int position;
    };
    typedef struct yTElist yTElist_t;

    // block environment (linked list of local declarations)
    //  as TableEntry used during parse time
    yTElist_t *m_tenvironment;

    // pointer to last declaration for easier append
    // points to 0 after detachEnvironment()
    yTElist_t *m_last_tparm;

    // --------------------------------
    // source file, needs environment

    // Point (Filename) of source file (global SymbolEntry:c_filename)
    // always points to the current file. During include, it points to
    // a chain <include file> -> <toplevel file>. See Point.h
    const Point *m_point;

    // --------------------------------
    // Block content

    struct stmtlist {
        YStatementPtr stmt;
        struct stmtlist *next;
    };
    typedef struct stmtlist stmtlist_t;

    // linked list of statements
    stmtlist_t *m_statements;

    // pointer to last statement for easier append
    stmtlist_t *m_last_statement;

    typedef std::list<std::string> stringlist_t;
    stringlist_t* m_includes;
    
    constTypePtr m_type;
    
    bool m_running;
    
public:
    //---------------------------------------------------------------
    // Constructor / Destructor
   
    // toplevel block
    YBlock (const std::string & filename, blockkind_t kind = b_unknown);
    // midlevel block
    YBlock (const Point *point);
    YBlock (bytecodeistream & str);
    ~YBlock ();

    //---------------------------------------------------------------
    // YCode

    virtual bool isBlock () const { return true; }
    virtual ykind kind () const { return yeBlock; }

    // warning: it is return type in fact!
    constTypePtr type () const { return m_type; }
    
    // set the return type of this block
    void setType (constTypePtr type);

    // the whole block is parsed, do final changes
    void finishBlock ();

    // evaluate the complete block
    virtual YCPValue evaluate (bool cse = false);
    
    // evaluate the block from the given statement (switch)
    YCPValue evaluateFrom (int statement_index);

    // evaluate a single statement
    // this is a special purpose interface for macro player
    // does not handle break, return
    //   and also skips initial 'import' statements (e.g. autogenerated
    //    import "UI")  by default
    YCPValue evaluate (int statement_index, bool skip_initial_imports = true);
    
    //---------------------------------------------------------------
    // member access

    // return name of source file
    virtual const std::string filename () const;

    // SymbolTable for global module environment (m_kind == b_module)
    //   non-const return since we must be able to find() which tracks references
    virtual SymbolTable *table () const;

    virtual Y2Function* createFunctionCall (const string name, constFunctionTypePtr type);

    // returns the current parse file as Point
    const Point *point () const;

    // returns the name of the block
    const string name () const;
    void setName (const string & name);

    const Y2Namespace *nameSpace () const { return (const Y2Namespace *)this; }
    Y2Namespace *nameSpace () { return (Y2Namespace *)this; }

    //---------------------------------------------------------------
    // block kind

    // set block kind
    void setKind (blockkind_t kind);

    // get block kind
    blockkind_t bkind () const;

    // block is toplevel block of a module
    bool isModule () const      { return (m_kind == b_module); }                // toplevel module block
    bool isFile () const        { return (m_kind == b_file); }                  // toplevel file block
    bool isStatement () const   { return (m_kind == b_statement); }             // used as statement (local block)
    bool isDefinition () const  { return (m_kind == b_definition); }            // used as function definition
    bool isValue () const       { return (m_kind == b_value); }                 // used as value (intermediate block)
    bool isNamespace () const   { return (m_kind == b_namespace); }             // block defines a namespace

    //---------------------------------------------------------------
    // Value / Entry

    // add new value code to this block
    //   (used for functions which accept either symbolic variables or values, e.g. foreach())
    // returns position
    unsigned int newValue (constTypePtr type, YCodePtr code);

    // add a new table entry to this block
    //  and attach it to m_tenvironment
    //   return NULL if symbol of same name already declared in this block
    TableEntry *newEntry (const char *name, SymbolEntry::category_t cat, constTypePtr type, unsigned int line);

    //---------------------------------------------------------------
    // Namespace

    // add a new namespace entry to this block
    //  and attach it to m_tenvironment
    //   return NULL if symbol of same name already declared in this block
    TableEntry *newNamespace (const string & name, Y2Namespace *name_space, int line);

    //---------------------------------------------------------------
    // symbol handling

    // Attach entry (variable, typedef, ...) to local environment
    void attachEntry (TableEntry *entry);

    // Detach local environment from symbol table
    void detachEnvironment (SymbolTable *table);

    //---------------------------------------------------------------
    // statement handling

    // Attach statement to end of block
    void attachStatement (YStatementPtr statement);

    // Pretach statement to beginning block
    void pretachStatement (YStatementPtr statement);

    // count the statements in this block
    int statementCount () const;

    //---------------------------------------------------------------
    // return

    // returns the return statement if the block just consists of a single return
    YSReturnPtr justReturn () const;

    //---------------------------------------------------------------
    // include

    // end of include block, 'pop' head of m_point chain
    void endInclude ();

    bool isIncluded (string includename) const;
    void addIncluded (string includename);

    //---------------------------------------------------------------
    // string output

    string toString () const;
    string environmentToString () const;
    string toStringSwitch (map<YCPValue, int, ycp_less> cases, int defaultcase) const;

    //---------------------------------------------------------------
    // stream output

    // write block to stream
    std::ostream & toStream (std::ostream & str) const;
    std::ostream & toXml( std::ostream & str, int indent ) const;
    std::ostream & toXmlSwitch( map<YCPValue, int, ycp_less> cases, int defaultcase, std::ostream & str, int indent ) const;

};


#endif // YBlock_h