YCPCode.h

Go to the documentation of this file.

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

   File:       YCPCode.h

   Author:      Klaus Kaempf <kkaempf@suse.de>
   Maintainer:  Klaus Kaempf <kkaempf@suse.de>

   Wrappers for YCode data as YCPValue

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

#ifndef YCPCode_h
#define YCPCode_h


#include "ycp/YCPValue.h"
#include "ycp/YCode.h"
#include "y2/SymbolEntry.h"

//---------------------------------------------------------------------------
// YCPCode

class YCPBreak;
class YCPReturn;

class YCPCodeRep : public YCPValueRep
{
    YCodePtr m_code;

protected:
    friend class YCPCode;

    YCPCodeRep();
    YCPCodeRep (YCodePtr c);

    ~YCPCodeRep();

public:
    YCodePtr code() const;

    YCPOrder compare (const YCPCode &v) const;

    string toString() const;

    std::ostream & toStream (std::ostream & str) const;
    std::ostream & toXml (std::ostream & str, int indent ) const;

    YCPValueType valuetype() const;

    YCPValue evaluate (bool cse = false) const;
};


class YCPCode : public YCPValue
{
    DEF_COMMON(Code, Value);
public:
    YCPCode() : YCPValue (new YCPCodeRep ()) {}
    YCPCode (YCodePtr code) : YCPValue (new YCPCodeRep (code)) {}
    YCPCode (bytecodeistream & str);
};


//---------------------------------------------------------------------------
// YCPBreak


class YCPBreakRep : public YCPValueRep
{
protected:
    friend class YCPBreak;

    YCPBreakRep () {};

    ~YCPBreakRep() {}

public:
    YCPOrder compare (const YCPBreak &) const { return YO_EQUAL; }

    string toString() const { return "nil"; }

    std::ostream & toStream (std::ostream & str) const { return str; };
    std::ostream & toXml (std::ostream & str, int indent ) const;

    YCPValueType valuetype() const { return YT_BREAK; }

};

class YCPBreak : public YCPValue
{
    DEF_COMMON(Break, Value);
public:
    YCPBreak() : YCPValue (new YCPBreakRep ()) {}
    YCPBreak (bytecodeistream &) : YCPValue (new YCPBreakRep ()) {}
};


//---------------------------------------------------------------------------
// YCPReturn

class YCPReturnRep : public YCPValueRep
{
protected:
    friend class YCPReturn;

    YCPReturnRep() {}

    ~YCPReturnRep() {}

public:
    YCPOrder compare (const YCPReturn &) const { return YO_EQUAL; }

    string toString() const { return "nil"; }

    std::ostream & toStream (std::ostream & str) const { return str; };
    std::ostream & toXml (std::ostream & str, int indent ) const;

    YCPValueType valuetype() const { return YT_RETURN; }

};

class YCPReturn : public YCPValue
{
    DEF_COMMON(Return, Value);
public:
    YCPReturn() : YCPValue (new YCPReturnRep ()) {}
    YCPReturn(bytecodeistream &) : YCPValue (new YCPReturnRep ()) {}
};


//---------------------------------------------------------------------------
// YCPEntry


class YCPEntryRep : public YCPValueRep
{
    SymbolEntryPtr m_entry;

protected:
    friend class YCPEntry;

    YCPEntryRep ();
    YCPEntryRep (SymbolEntryPtr entry);

    ~YCPEntryRep() {}

public:
    SymbolEntryPtr entry() const;

    YCPOrder compare (const YCPEntry &v) const;

    string toString() const;

    std::ostream & toStream (std::ostream & str) const;
    std::ostream & toXml (std::ostream & str, int indent ) const;

    YCPValueType valuetype() const;

    YCPValue evaluate (bool cse = false) const;
};


class YCPEntry : public YCPValue
{
    DEF_COMMON(Entry, Value);
public:
    YCPEntry (SymbolEntryPtr entry) : YCPValue (new YCPEntryRep (entry)) {}
    YCPEntry (bytecodeistream & str);
};


//---------------------------------------------------------------------------
// YCPReference


class YCPReferenceRep : public YCPValueRep
{
    SymbolEntryPtr m_entry;

protected:
    friend class YCPReference;

    YCPReferenceRep ();
    YCPReferenceRep (SymbolEntryPtr entry);

    ~YCPReferenceRep() {}

public:
    SymbolEntryPtr entry() const;

    YCPOrder compare (const YCPReference &v) const;

    string toString() const;

    std::ostream & toStream (std::ostream & str) const;
    std::ostream & toXml (std::ostream & str, int indent ) const;

    YCPValueType valuetype() const;

    YCPValue evaluate (bool cse = false) const;
};


class YCPReference : public YCPValue
{
    DEF_COMMON(Reference, Value);
public:
    YCPReference (SymbolEntryPtr entry) : YCPValue (new YCPReferenceRep (entry)) {}
};

#endif   // YCPCode_h