VirtualBox

Changeset 14904 in vbox


Ignore:
Timestamp:
Dec 2, 2008 2:37:52 PM (16 years ago)
Author:
vboxsync
Message:

Main: change vboxxml files and namespace to xml only; more XML code abstractions

Location:
trunk
Files:
8 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/settings.h

    r14854 r14904  
    3636
    3737#include <list>
    38 #include <memory>
    39 #include <limits>
    4038
    4139/* these conflict with numeric_digits<>::min and max */
    … …  
    4341#undef max
    4442
    45 #include <iprt/assert.h>
    46 #include <iprt/string.h>
    47 #include <iprt/mem.h>
    4843#include <iprt/time.h>
    4944
    50 #include <VBox/vboxxml.h>
     45#include <VBox/xml.h>
    5146
    5247#include <stdarg.h>
    … …  
    233228 *
    234229 * The alternative is to instantiate a template before the data member
    235  * declaration with the VBOXSETTINGS_CLASS prefix, but the standard disables
     230 * declaration with the VBOXXML_CLASS prefix, but the standard disables
    236231 * explicit instantiations in a foreign namespace. In other words, a declaration
    237232 * like:
    238233 *
    239  *   template class VBOXSETTINGS_CLASS std::auto_ptr <Data>;
     234 *   template class VBOXXML_CLASS std::auto_ptr <Data>;
    240235 *
    241236 * right before the member declaration makes MSVC happy too, but this is not a
    … …  
    270265//////////////////////////////////////////////////////////////////////////////
    271266
    272 class VBOXSETTINGS_CLASS ENoKey : public vboxxml::LogicError
     267class VBOXXML_CLASS ENoKey : public xml::LogicError
    273268{
    274269public:
    275270
    276     ENoKey (const char *aMsg = NULL) : vboxxml::LogicError (aMsg) {}
     271    ENoKey (const char *aMsg = NULL) : xml::LogicError (aMsg) {}
    277272};
    278273
    279 class VBOXSETTINGS_CLASS ENoValue : public vboxxml::LogicError
     274class VBOXXML_CLASS ENoValue : public xml::LogicError
    280275{
    281276public:
    282277
    283     ENoValue (const char *aMsg = NULL) : vboxxml::LogicError (aMsg) {}
     278    ENoValue (const char *aMsg = NULL) : xml::LogicError (aMsg) {}
    284279};
    285280
    286 class VBOXSETTINGS_CLASS ENoConversion : public vboxxml::RuntimeError
     281class VBOXXML_CLASS ENoConversion : public xml::RuntimeError
    287282{
    288283public:
    … …  
    302297 * <tr>const char *</tr> and makes a copy of the string it points to.
    303298 */
    304 class VBOXSETTINGS_CLASS FmtStr
     299class VBOXXML_CLASS FmtStr
    305300{
    306301public:
    … …  
    372367    }
    373368
    374     throw vboxxml::ENotImplemented (RT_SRC_POS);
     369    throw xml::ENotImplemented (RT_SRC_POS);
    375370}
    376371
    … …  
    444439    }
    445440
    446     throw vboxxml::ENotImplemented (RT_SRC_POS);
     441    throw xml::ENotImplemented (RT_SRC_POS);
    447442}
    448443
    … …  
    496491 * that becomes invalid when this TreeBackend instance is destroyed.
    497492 */
    498 class VBOXSETTINGS_CLASS Key
     493class VBOXXML_CLASS Key
    499494{
    500495public:
    … …  
    508503     * storing settings keys.
    509504     */
    510     class VBOXSETTINGS_CLASS Backend : public stdx::auto_ref
     505    class VBOXXML_CLASS Backend : public stdx::auto_ref
    511506    {
    512507    public:
    … …  
    892887 * and an attempt to access Key data will cause the program crash.
    893888 */
    894 class VBOXSETTINGS_CLASS TreeBackend
     889class VBOXXML_CLASS TreeBackend
    895890{
    896891public:
    … …  
    917912     * @param aFlags        Optional bit flags.
    918913     */
    919     void read (vboxxml::Input &aInput, const char *aSchema = NULL, int aFlags = 0)
     914    void read (xml::Input &aInput, const char *aSchema = NULL, int aFlags = 0)
    920915    {
    921916        aInput.setPos (0);
    … …  
    933928     * @see read()
    934929     */
    935     virtual void rawRead (vboxxml::Input &aInput, const char *aSchema = NULL,
     930    virtual void rawRead (xml::Input &aInput, const char *aSchema = NULL,
    936931                          int aFlags = 0) = 0;
    937932
    … …  
    947942     * @param aOutput       Output stream.
    948943     */
    949     void write (vboxxml::Output &aOutput)
     944    void write (xml::Output &aOutput)
    950945    {
    951946        aOutput.setPos (0);
    … …  
    966961     * @see write()
    967962     */
    968     virtual void rawWrite (vboxxml::Output &aOutput) = 0;
     963    virtual void rawWrite (xml::Output &aOutput) = 0;
    969964
    970965    /**
    … …  
    1002997 * settings namespace) needs to be used by more than one thread.
    1003998 */
    1004 class VBOXSETTINGS_CLASS XmlTreeBackend : public TreeBackend
     999class VBOXXML_CLASS XmlTreeBackend : public TreeBackend
    10051000{
    10061001public:
    … …  
    10211016     * validating the XML document representing the settings tree.
    10221017     */
    1023     class VBOXSETTINGS_CLASS Error : public vboxxml::RuntimeError
     1018    class VBOXXML_CLASS Error : public xml::RuntimeError
    10241019    {
    10251020    public:
    … …  
    10321027     * AutoConverter::needsConversion() implementation.
    10331028     */
    1034     class VBOXSETTINGS_CLASS EConversionCycle : public Error
     1029    class VBOXXML_CLASS EConversionCycle : public Error
    10351030    {
    10361031    public:
    … …  
    10431038     * for external entities given an URL and entity ID.
    10441039     */
    1045     class VBOXSETTINGS_CLASS InputResolver
     1040    class VBOXXML_CLASS InputResolver
    10461041    {
    10471042    public:
    … …  
    10601055         * Input subclasses.
    10611056         */
    1062         virtual vboxxml::Input *resolveEntity (const char *aURI, const char *aID) = 0;
     1057        virtual xml::Input *resolveEntity (const char *aURI, const char *aID) = 0;
    10631058    };
    10641059
    … …  
    10681063     * stream.
    10691064     */
    1070     class VBOXSETTINGS_CLASS AutoConverter
     1065    class VBOXXML_CLASS AutoConverter
    10711066    {
    10721067    public:
    … …  
    11791174    const char *oldVersion() const;
    11801175
    1181     void rawRead (vboxxml::Input &aInput, const char *aSchema = NULL, int aFlags = 0);
    1182     void rawWrite (vboxxml::Output &aOutput);
     1176    void rawRead (xml::Input &aInput, const char *aSchema = NULL, int aFlags = 0);
     1177    void rawWrite (xml::Output &aOutput);
    11831178    void reset();
    11841179    Key &rootKey() const;

  • trunk/include/VBox/xml.h

    r14894 r14904  
    3333#include <iprt/cdefs.h>
    3434#include <iprt/cpputils.h>
    35 #include <iprt/string.h>
    36 
    37 #include <list>
    38 #include <memory>
    39 #include <limits>
    4035
    4136/* these conflict with numeric_digits<>::min and max */
    … …  
    4338#undef max
    4439
    45 #include <iprt/assert.h>
    46 #include <iprt/string.h>
    4740#include <iprt/mem.h>
    48 #include <iprt/time.h>
    4941
    5042#ifndef IN_RING3
    … …  
    5244#else /* IN_RING3 */
    5345
    54 /** @def IN_VBOXSETTINGS_R3
     46/** @def IN_VBOXXML_R3
    5547 * Used to indicate whether we're inside the same link module as the
    5648 * XML Settings File Manipulation API.
    … …  
    6052 */
    6153#ifdef DOXYGEN_RUNNING
    62 # define IN_VBOXSETTINGS_R3
     54# define IN_VBOXXML_R3
    6355#endif
    6456
    65 /** @def VBOXSETTINGS_CLASS
     57/** @def VBOXXML_CLASS
    6658 * Class export/import wrapper. */
    67 #ifdef IN_VBOXSETTINGS_R3
    68 # define VBOXSETTINGS_CLASS DECLEXPORT_CLASS
     59#ifdef IN_VBOXXML_R3
     60# define VBOXXML_CLASS DECLEXPORT_CLASS
    6961#else
    70 # define VBOXSETTINGS_CLASS DECLIMPORT_CLASS
     62# define VBOXXML_CLASS DECLIMPORT_CLASS
    7163#endif
    7264
    … …  
    7870 *
    7971 * The alternative is to instantiate a template before the data member
    80  * declaration with the VBOXSETTINGS_CLASS prefix, but the standard disables
     72 * declaration with the VBOXXML_CLASS prefix, but the standard disables
    8173 * explicit instantiations in a foreign namespace. In other words, a declaration
    8274 * like:
    8375 *
    84  *   template class VBOXSETTINGS_CLASS std::auto_ptr <Data>;
     76 *   template class VBOXXML_CLASS std::auto_ptr <Data>;
    8577 *
    8678 * right before the member declaration makes MSVC happy too, but this is not a
    … …  
    10597typedef xmlError *xmlErrorPtr;
    10698
    107 namespace vboxxml
     99namespace xml
    108100{
    109101
    … …  
    114106 * Base exception class.
    115107 */
    116 class VBOXSETTINGS_CLASS Error : public std::exception
     108class VBOXXML_CLASS Error : public std::exception
    117109{
    118110public:
    … …  
    152144};
    153145
    154 class VBOXSETTINGS_CLASS LogicError : public Error
     146class VBOXXML_CLASS LogicError : public Error
    155147{
    156148public:
    … …  
    158150    LogicError (const char *aMsg = NULL) : Error (aMsg) {}
    159151
    160     LogicError (RT_SRC_POS_DECL)
    161     {
    162         char *msg = NULL;
    163         RTStrAPrintf (&msg, "In '%s', '%s' at #%d",
    164                       pszFunction, pszFile, iLine);
    165         setWhat (msg);
    166         RTStrFree (msg);
    167     }
    168 };
    169 
    170 class VBOXSETTINGS_CLASS RuntimeError : public Error
     152    LogicError (RT_SRC_POS_DECL);
     153};
     154
     155class VBOXXML_CLASS RuntimeError : public Error
    171156{
    172157public:
    … …  
    178163//////////////////////////////////////////////////////////////////////////////
    179164
    180 class VBOXSETTINGS_CLASS ENotImplemented : public LogicError
     165class VBOXXML_CLASS ENotImplemented : public LogicError
    181166{
    182167public:
    … …  
    186171};
    187172
    188 class VBOXSETTINGS_CLASS EInvalidArg : public LogicError
     173class VBOXXML_CLASS EInvalidArg : public LogicError
    189174{
    190175public:
    … …  
    197182//////////////////////////////////////////////////////////////////////////////
    198183
    199 class VBOXSETTINGS_CLASS ENoMemory : public RuntimeError, public std::bad_alloc
     184class VBOXXML_CLASS ENoMemory : public RuntimeError, public std::bad_alloc
    200185{
    201186public:
    … …  
    205190};
    206191
    207 class VBOXSETTINGS_CLASS EIPRTFailure : public RuntimeError
     192class VBOXXML_CLASS EIPRTFailure : public RuntimeError
    208193{
    209194public:
    … …  
    223208 * The Stream class is a base class for I/O streams.
    224209 */
    225 class VBOXSETTINGS_CLASS Stream
     210class VBOXXML_CLASS Stream
    226211{
    227212public:
    … …  
    258243 * useful functionality.
    259244 */
    260 class VBOXSETTINGS_CLASS Input : virtual public Stream
     245class VBOXXML_CLASS Input : virtual public Stream
    261246{
    262247public:
    … …  
    276261 *
    277262 */
    278 class VBOXSETTINGS_CLASS Output : virtual public Stream
     263class VBOXXML_CLASS Output : virtual public Stream
    279264{
    280265public:
    … …  
    313298 * when reading from or writing to such File instances.
    314299 */
    315 class VBOXSETTINGS_CLASS File : public Input, public Output
     300class VBOXXML_CLASS File : public Input, public Output
    316301{
    317302public:
    … …  
    396381 * memory buffer.
    397382 */
    398 class VBOXSETTINGS_CLASS MemoryBuf : public Input
     383class VBOXXML_CLASS MemoryBuf : public Input
    399384{
    400385public:
    … …  
    411396
    412397private:
    413 
    414398    /* Obscure class data */
    415399    struct Data;
    … …  
    422406
    423407/*
    424  * VBoxXml
    425  *
    426  *
    427  */
    428 
    429 
    430 class VBoxXmlBase
     408 * GlobalLock
     409 *
     410 *
     411 */
     412
     413typedef xmlParserInput* FNEXTERNALENTITYLOADER(const char *aURI,
     414                                               const char *aID,
     415                                               xmlParserCtxt *aCtxt);
     416typedef FNEXTERNALENTITYLOADER *PFNEXTERNALENTITYLOADER;
     417
     418class VBOXXML_CLASS GlobalLock
     419{
     420public:
     421    GlobalLock();
     422    ~GlobalLock();
     423
     424    void setExternalEntityLoader(PFNEXTERNALENTITYLOADER pFunc);
     425
     426    static xmlParserInput* callDefaultLoader(const char *aURI,
     427                                             const char *aID,
     428                                             xmlParserCtxt *aCtxt);
     429
     430private:
     431    /* Obscure class data */
     432    struct Data;
     433    std::auto_ptr<Data> m;
     434};
     435
     436/*
     437 * XmlParserBase
     438 *
     439 */
     440
     441class VBOXXML_CLASS XmlParserBase
    431442{
    432443protected:
    433     VBoxXmlBase();
    434 
    435     ~VBoxXmlBase();
     444    XmlParserBase();
     445    ~XmlParserBase();
    436446
    437447    xmlParserCtxtPtr m_ctxt;
    438448};
    439449
    440 class VBoxXmlFile : public VBoxXmlBase
    441 {
    442 public:
    443     VBoxXmlFile();
    444     ~VBoxXmlFile();
     450/*
     451 * XmlFileParser
     452 *
     453 */
     454
     455class VBOXXML_CLASS XmlFileParser : public XmlParserBase
     456{
     457public:
     458    XmlFileParser();
     459    ~XmlFileParser();
     460
     461    void read(const char *pcszFilename);
     462
     463private:
     464    /* Obscure class data */
     465    struct Data;
     466    std::auto_ptr<Data> m;
     467
    445468};
    446469
    … …  
    455478/** @} */
    456479
    457 } // end namespace vboxxml
     480} // end namespace xml
    458481
    459482#endif /* ___VBox_vboxxml_h */

  • trunk/src/VBox/Main/MachineImpl.cpp

    r14858 r14904  
    23902390    {
    23912391        using namespace settings;
    2392         using namespace vboxxml;
     2392        using namespace xml;
    23932393
    23942394        /* load the settings file (we don't reuse the existing handle but
    … …  
    24942494    {
    24952495        using namespace settings;
    2496         using namespace vboxxml;
     2496        using namespace xml;
    24972497
    24982498        /* load the settings file (we don't reuse the existing handle but
    … …  
    25702570    {
    25712571        using namespace settings;
    2572         using namespace vboxxml;
     2572        using namespace xml;
    25732573
    25742574        /* load the settings file */
    … …  
    47124712    {
    47134713        using namespace settings;
    4714         using namespace vboxxml;
     4714        using namespace xml;
    47154715
    47164716        /* no concurrent file access is possible in init() so open by handle */
    … …  
    58705870    {
    58715871        using namespace settings;
    5872         using namespace vboxxml;
     5872        using namespace xml;
    58735873
    58745874        /* this object is locked for writing to prevent concurrent reads and writes */
    … …  
    60666066    {
    60676067        using namespace settings;
    6068         using namespace vboxxml;
     6068        using namespace xml;
    60696069
    60706070        /* load the settings file */
    … …  
    66296629                                               emptyStr);
    66306630    }
    6631     catch (vboxxml::ENoMemory e)
     6631    catch (xml::ENoMemory e)
    66326632    {
    66336633        return E_OUTOFMEMORY;
    … …  
    67116711    {
    67126712        using namespace settings;
    6713         using namespace vboxxml;
     6713        using namespace xml;
    67146714
    67156715        /* load the settings file */

  • trunk/src/VBox/Main/Makefile.kmk

    r14854 r14904  
    555555        include
    556556VBoxSettings_SOURCES    = \
    557         xml/vboxxml.cpp \
     557        xml/xml.cpp \
    558558        xml/Settings.cpp
    559559VBoxSettings_LDFLAGS.darwin = -install_name $(VBOX_DYLD_EXECUTABLE_PATH)/$(notdir $(LIB_SETTINGS)) -Wl,-x # no debug info please.

  • trunk/src/VBox/Main/VirtualBoxBase.cpp

    r14854 r14904  
    12551255
    12561256    if (RT_FAILURE (vrc))
    1257         throw vboxxml::LogicError (RT_SRC_POS);
     1257        throw xml::LogicError (RT_SRC_POS);
    12581258
    12591259    return result;
    … …  
    12931293    int vrc = RTUuidToStr (aValue.raw(), result.get() + 1, RTUUID_STR_LENGTH);
    12941294    if (RT_FAILURE (vrc))
    1295         throw vboxxml::LogicError (RT_SRC_POS);
     1295        throw xml::LogicError (RT_SRC_POS);
    12961296
    12971297    result.get() [0] = '{';

  • trunk/src/VBox/Main/VirtualBoxImpl.cpp

    r14874 r14904  
    221221        {
    222222            using namespace settings;
    223             using namespace vboxxml;
     223            using namespace xml;
    224224
    225225            /* no concurrent file access is possible in init() so open by handle */
    … …  
    14221422    {
    14231423        using namespace settings;
    1424         using namespace vboxxml;
     1424        using namespace xml;
    14251425
    14261426        /* load the settings file (we don't reuse the existing handle but
    … …  
    15211521    {
    15221522        using namespace settings;
    1523         using namespace vboxxml;
     1523        using namespace xml;
    15241524
    15251525        /* load the settings file (we don't reuse the existing handle but
    … …  
    15821582    {
    15831583        using namespace settings;
    1584         using namespace vboxxml;
     1584        using namespace xml;
    15851585
    15861586        /* load the settings file */
    … …  
    31483148    {
    31493149        using namespace settings;
    3150         using namespace vboxxml;
     3150        using namespace xml;
    31513151
    31523152        /* load the settings file */
    … …  
    37683768/* static */
    37693769HRESULT VirtualBox::loadSettingsTree (settings::XmlTreeBackend &aTree,
    3770                                       vboxxml::File &aFile,
     3770                                      xml::File &aFile,
    37713771                                      bool aValidate,
    37723772                                      bool aCatchLoadErrors,
    … …  
    38033803        }
    38043804    }
    3805     catch (const vboxxml::EIPRTFailure &err)
     3805    catch (const xml::EIPRTFailure &err)
    38063806    {
    38073807        if (!aCatchLoadErrors)
    … …  
    38423842/* static */
    38433843HRESULT VirtualBox::saveSettingsTree (settings::TreeBackend &aTree,
    3844                                       vboxxml::File &aFile,
     3844                                      xml::File &aFile,
    38453845                                      Utf8Str &aFormatVersion)
    38463846{
    … …  
    38563856            aFormatVersion = VBOX_XML_VERSION_FULL;
    38573857    }
    3858     catch (const vboxxml::EIPRTFailure &err)
     3858    catch (const xml::EIPRTFailure &err)
    38593859    {
    38603860        /* this is the only expected exception for now */

  • trunk/src/VBox/Main/VirtualBoxImplExtra.cpp

    r14854 r14904  
    6868 *              a wrong URI/ID pair.
    6969 */
    70 vboxxml::Input *
     70xml::Input *
    7171VirtualBox::SettingsTreeHelper::resolveEntity (const char *aURI, const char *aID)
    7272{
    7373    if (strcmp (aURI, VBOX_XML_SCHEMA_COMMON) == 0)
    7474    {
    75         return new vboxxml::
     75        return new xml::
    7676            MemoryBuf ((const char *) g_ab_xml_VirtualBox_settings_common_xsd,
    7777                       g_cb_xml_VirtualBox_settings_common_xsd, aURI);
    … …  
    8080    if (strcmp (aURI, VBOX_XML_SCHEMA_ROOT) == 0)
    8181    {
    82         return new vboxxml::
     82        return new xml::
    8383            MemoryBuf ((const char *) g_ab_xml_VirtualBox_settings_root_xsd,
    8484                       g_cb_xml_VirtualBox_settings_root_xsd, aURI);
    … …  
    8787    if (strcmp (aURI, VBOX_XML_SCHEMA) == 0)
    8888    {
    89         return new vboxxml::
     89        return new xml::
    9090            MemoryBuf ((const char *) g_ab_xml_VirtualBox_settings_xsd,
    9191                       g_cb_xml_VirtualBox_settings_xsd, aURI);
    … …  
    9494    if (strcmp (aURI, VBOX_XML_SETTINGS_CONVERTER) == 0)
    9595    {
    96         return new vboxxml::
     96        return new xml::
    9797            MemoryBuf ((const char *) g_ab_xml_SettingsConverter_xsl,
    9898                       g_cb_xml_SettingsConverter_xsl, aURI);

  • trunk/src/VBox/Main/include/VirtualBoxImpl.h

    r14854 r14904  
    280280
    281281        // InputResolver interface
    282         vboxxml::Input *resolveEntity (const char *aURI, const char *aID);
     282        xml::Input *resolveEntity (const char *aURI, const char *aID);
    283283
    284284        // AutoConverter interface
    … …  
    288288
    289289    static HRESULT loadSettingsTree (settings::XmlTreeBackend &aTree,
    290                                      vboxxml::File &aFile,
     290                                     xml::File &aFile,
    291291                                     bool aValidate,
    292292                                     bool aCatchLoadErrors,
    … …  
    304304     */
    305305    static HRESULT loadSettingsTree_FirstTime (settings::XmlTreeBackend &aTree,
    306                                                vboxxml::File &aFile,
     306                                               xml::File &aFile,
    307307                                               Utf8Str &aFormatVersion)
    308308    {
    … …  
    320320     */
    321321    static HRESULT loadSettingsTree_Again (settings::XmlTreeBackend &aTree,
    322                                            vboxxml::File &aFile)
     322                                           xml::File &aFile)
    323323    {
    324324        return loadSettingsTree (aTree, aFile, true, false, true);
    … …  
    333333     */
    334334    static HRESULT loadSettingsTree_ForUpdate (settings::XmlTreeBackend &aTree,
    335                                                vboxxml::File &aFile)
     335                                               xml::File &aFile)
    336336    {
    337337        return loadSettingsTree (aTree, aFile, true, false, false);
    … …  
    339339
    340340    static HRESULT saveSettingsTree (settings::TreeBackend &aTree,
    341                                      vboxxml::File &aFile,
     341                                     xml::File &aFile,
    342342                                     Utf8Str &aFormatVersion);
    343343

  • trunk/src/VBox/Main/xml/Settings.cpp

    r14854 r14904  
    4343
    4444
    45 /**
    46  * Global module initialization structure.
    47  *
    48  * The constructor and destructor of this structure are used to perform global
    49  * module initiaizaton and cleanup. Thee must be only one global variable of
    50  * this structure.
    51  */
    52 static
    53 class Global
    54 {
    55 public:
    56 
    57     Global()
    58     {
    59         /* Check the parser version. The docs say it will kill the app if
    60          * there is a serious version mismatch, but I couldn't find it in the
    61          * source code (it only prints the error/warning message to the console) so
    62          * let's leave it as is for informational purposes. */
    63         LIBXML_TEST_VERSION
    64 
    65         /* Init libxml */
    66         xmlInitParser();
    67 
    68         /* Save the default entity resolver before someone has replaced it */
    69         xml.defaultEntityLoader = xmlGetExternalEntityLoader();
    70     }
    71 
    72     ~Global()
    73     {
    74         /* Shutdown libxml */
    75         xmlCleanupParser();
    76     }
    77 
    78     struct
    79     {
    80         xmlExternalEntityLoader defaultEntityLoader;
    81 
    82         /** Used to provide some thread safety missing in libxml2 (see e.g.
    83          *  XmlTreeBackend::read()) */
    84         RTLockMtx lock;
    85     }
    86     xml;
    87 }
    88 gGlobal;
    89 
    90 
    9145namespace settings
    9246{
    … …  
    14397            break;
    14498        default:
    145             throw vboxxml::ENotImplemented (RT_SRC_POS);
     99            throw xml::ENotImplemented (RT_SRC_POS);
    146100    }
    147101
    … …  
    287241            break;
    288242        default:
    289             throw vboxxml::ENotImplemented (RT_SRC_POS);
     243            throw xml::ENotImplemented (RT_SRC_POS);
    290244    }
    291245
    … …  
    295249        return result;
    296250
    297     throw vboxxml::EIPRTFailure (vrc);
     251    throw xml::EIPRTFailure (vrc);
    298252}
    299253
    … …  
    401355void XmlKeyBackend::setName (const char *aName)
    402356{
    403     throw vboxxml::ENotImplemented (RT_SRC_POS);
     357    throw xml::ENotImplemented (RT_SRC_POS);
    404358}
    405359
    … …  
    458412            value = xmlEncodeSpecialChars (mNode->doc, value);
    459413            if (value == NULL)
    460                 throw vboxxml::ENoMemory();
     414                throw xml::ENoMemory();
    461415        }
    462416
    … …  
    484438            int rc = xmlRemoveProp (attr);
    485439            if (rc != 0)
    486                 throw vboxxml::EInvalidArg (RT_SRC_POS);
     440                throw xml::EInvalidArg (RT_SRC_POS);
    487441        }
    488442        return;
    … …  
    492446                                  (const xmlChar *) aValue);
    493447    if (attr == NULL)
    494         throw vboxxml::ENoMemory();
     448        throw xml::ENoMemory();
    495449}
    496450
    … …  
    545499    xmlNodePtr node = xmlNewChild (mNode, NULL, (const xmlChar *) aName, NULL);
    546500    if (node == NULL)
    547         throw vboxxml::ENoMemory();
     501        throw xml::ENoMemory();
    548502
    549503    return Key (new XmlKeyBackend (node));
    … …  
    571525    {
    572526        if (!aErr)
    573             throw vboxxml::EInvalidArg (RT_SRC_POS);
     527            throw xml::EInvalidArg (RT_SRC_POS);
    574528
    575529        char *msg = Format (aErr);
    … …  
    623577    struct IOCtxt
    624578    {
    625         IOCtxt (vboxxml::Stream *aStream, std::auto_ptr <stdx::exception_trap_base> &aErr)
     579        IOCtxt (xml::Stream *aStream, std::auto_ptr <stdx::exception_trap_base> &aErr)
    626580            : stream (aStream), deleteStreamOnClose (false)
    627581            , err (aErr) {}
    … …  
    632586        void resetErr() { err.reset(); }
    633587
    634         vboxxml::Stream *stream;
     588        xml::Stream *stream;
    635589        bool deleteStreamOnClose;
    636590
    … …  
    640594    struct InputCtxt : public IOCtxt
    641595    {
    642         InputCtxt (vboxxml::Input *aInput, std::auto_ptr <stdx::exception_trap_base> &aErr)
     596        InputCtxt (xml::Input *aInput, std::auto_ptr <stdx::exception_trap_base> &aErr)
    643597            : IOCtxt (aInput, aErr), input (aInput) {}
    644598
    645         vboxxml::Input *input;
     599        xml::Input *input;
    646600    };
    647601
    648602    struct OutputCtxt : public IOCtxt
    649603    {
    650         OutputCtxt (vboxxml::Output *aOutput, std::auto_ptr <stdx::exception_trap_base> &aErr)
     604        OutputCtxt (xml::Output *aOutput, std::auto_ptr <stdx::exception_trap_base> &aErr)
    651605            : IOCtxt (aOutput, aErr), output (aOutput) {}
    652606
    653         vboxxml::Output *output;
     607        xml::Output *output;
    654608    };
    655609};
    … …  
    661615    m->ctxt = xmlNewParserCtxt();
    662616    if (m->ctxt == NULL)
    663         throw vboxxml::ENoMemory();
     617        throw xml::ENoMemory();
    664618}
    665619
    … …  
    700654extern "C" void *xsltGenericErrorContext;
    701655
    702 void XmlTreeBackend::rawRead (vboxxml::Input &aInput, const char *aSchema /* = NULL */,
     656void XmlTreeBackend::rawRead (xml::Input &aInput, const char *aSchema /* = NULL */,
    703657                              int aFlags /* = 0 */)
    704658{
    … …  
    713667     * unwanted now for several reasons. Search for "thread-safe" to find all
    714668     * unsafe cases. */
    715     RTLock alock (gGlobal.xml.lock);
    716 
    717     xmlExternalEntityLoader oldEntityLoader = xmlGetExternalEntityLoader();
     669    xml::GlobalLock global;
     670    global.setExternalEntityLoader(ExternalEntityLoader);
     671
    718672    sThat = this;
    719     xmlSetExternalEntityLoader (ExternalEntityLoader);
    720 
    721673    xmlDocPtr doc = NULL;
    722674
    … …  
    727679         * otherwise xmlSaveDoc() won't be able to do proper indentation on
    728680         * output. */
    729 
    730681        /* parse the stream */
    731682        /* NOTE: new InputCtxt instance will be deleted when the stream is closed by
    … …  
    764715                /* parse the XSLT template */
    765716                {
    766                     vboxxml::Input *xsltInput =
     717                    xml::Input *xsltInput =
    767718                        m->inputResolver->resolveEntity
    768719                            (m->autoConverter->templateUri(), NULL);
    … …  
    800751                {
    801752                    if (errorStr != NULL)
    802                         throw vboxxml::LogicError (errorStr);
     753                        throw xml::LogicError (errorStr);
    803754                    /* errorStr is freed in catch(...) below */
    804755
    805                     throw vboxxml::LogicError (RT_SRC_POS);
     756                    throw xml::LogicError (RT_SRC_POS);
    806757                }
    807758
    … …  
    811762                    xmlDocPtr newDoc = xsltApplyStylesheet (xslt, doc, NULL);
    812763                    if (newDoc == NULL && errorStr == NULL)
    813                         throw vboxxml::LogicError (RT_SRC_POS);
     764                        throw xml::LogicError (RT_SRC_POS);
    814765
    815766                    if (errorStr != NULL)
    … …  
    873824                schemaCtxt = xmlSchemaNewParserCtxt (aSchema);
    874825                if (schemaCtxt == NULL)
    875                     throw vboxxml::LogicError (RT_SRC_POS);
     826                    throw xml::LogicError (RT_SRC_POS);
    876827
    877828                /* set our error handlers */
    … …  
    887838                    validCtxt = xmlSchemaNewValidCtxt (schema);
    888839                    if (validCtxt == NULL)
    889                         throw vboxxml::LogicError (RT_SRC_POS);
     840                        throw xml::LogicError (RT_SRC_POS);
    890841
    891842                    /* instruct to create default attribute's values in the document */
    … …  
    908859
    909860                    if (errorStr == NULL)
    910                         throw vboxxml::LogicError (RT_SRC_POS);
     861                        throw xml::LogicError (RT_SRC_POS);
    911862
    912863                    throw Error (errorStr);
    … …  
    948899        m->oldVersion = oldVersion;
    949900
    950         /* restore the previous entity resolver */
    951         xmlSetExternalEntityLoader (oldEntityLoader);
    952901        sThat = NULL;
    953902    }
    … …  
    957906            xmlFreeDoc (doc);
    958907
    959         /* restore the previous entity resolver */
    960         xmlSetExternalEntityLoader (oldEntityLoader);
    961908        sThat = NULL;
    962909
    … …  
    965912}
    966913
    967 void XmlTreeBackend::rawWrite (vboxxml::Output &aOutput)
     914void XmlTreeBackend::rawWrite (xml::Output &aOutput)
    968915{
    969916    /* reset error variables used to memorize exceptions while inside the
    … …  
    987934                                           XML_SAVE_FORMAT);
    988935    if (saveCtxt == NULL)
    989         throw vboxxml::LogicError (RT_SRC_POS);
     936        throw xml::LogicError (RT_SRC_POS);
    990937
    991938    long rc = xmlSaveDoc (saveCtxt, m->doc);
    … …  
    998945        /* there must be an exception from the Output implementation,
    999946         * otherwise the save operation must always succeed. */
    1000         throw vboxxml::LogicError (RT_SRC_POS);
     947        throw xml::LogicError (RT_SRC_POS);
    1001948    }
    1002949
    … …  
    1037984        return ctxt->input->read (aBuf, aLen);
    1038985    }
    1039     catch (const vboxxml::EIPRTFailure &err) { ctxt->setErr (err); }
    1040     catch (const vboxxml::Error &err) { ctxt->setErr (err); }
     986    catch (const xml::EIPRTFailure &err) { ctxt->setErr (err); }
     987    catch (const xml::Error &err) { ctxt->setErr (err); }
    1041988    catch (const std::exception &err) { ctxt->setErr (err); }
    1042     catch (...) { ctxt->setErr (vboxxml::LogicError (RT_SRC_POS)); }
     989    catch (...) { ctxt->setErr (xml::LogicError (RT_SRC_POS)); }
    1043990
    1044991    return -1 /* failure */;
    … …  
    10581005        return ctxt->output->write (aBuf, aLen);
    10591006    }
    1060     catch (const vboxxml::EIPRTFailure &err) { ctxt->setErr (err); }
    1061     catch (const vboxxml::Error &err) { ctxt->setErr (err); }
     1007    catch (const xml::EIPRTFailure &err) { ctxt->setErr (err); }
     1008    catch (const xml::Error &err) { ctxt->setErr (err); }
    10621009    catch (const std::exception &err) { ctxt->setErr (err); }
    1063     catch (...) { ctxt->setErr (vboxxml::LogicError (RT_SRC_POS)); }
     1010    catch (...) { ctxt->setErr (xml::LogicError (RT_SRC_POS)); }
    10641011
    10651012    return -1 /* failure */;
    … …  
    10901037        return 0 /* success */;
    10911038    }
    1092     catch (const vboxxml::EIPRTFailure &err) { ctxt->setErr (err); }
    1093     catch (const vboxxml::Error &err) { ctxt->setErr (err); }
     1039    catch (const xml::EIPRTFailure &err) { ctxt->setErr (err); }
     1040    catch (const xml::Error &err) { ctxt->setErr (err); }
    10941041    catch (const std::exception &err) { ctxt->setErr (err); }
    1095     catch (...) { ctxt->setErr (vboxxml::LogicError (RT_SRC_POS)); }
     1042    catch (...) { ctxt->setErr (xml::LogicError (RT_SRC_POS)); }
    10961043
    10971044    return -1 /* failure */;
    … …  
    11911138
    11921139    if (sThat->m->inputResolver == NULL)
    1193         return gGlobal.xml.defaultEntityLoader (aURI, aID, aCtxt);
     1140        return xml::GlobalLock::callDefaultLoader(aURI, aID, aCtxt);
    11941141
    11951142    /* To prevent throwing exceptions while inside libxml2 code, we catch
    … …  
    11971144    try
    11981145    {
    1199         vboxxml::Input *input = sThat->m->inputResolver->resolveEntity (aURI, aID);
     1146        xml::Input *input = sThat->m->inputResolver->resolveEntity (aURI, aID);
    12001147        if (input == NULL)
    12011148            return NULL;
    … …  
    12321179        delete ctxt;
    12331180
    1234         throw vboxxml::ENoMemory();
    1235     }
    1236     catch (const vboxxml::EIPRTFailure &err) { sThat->m->trappedErr.reset (stdx::new_exception_trap (err)); }
    1237     catch (const vboxxml::Error &err) { sThat->m->trappedErr.reset (stdx::new_exception_trap (err)); }
     1181        throw xml::ENoMemory();
     1182    }
     1183    catch (const xml::EIPRTFailure &err) { sThat->m->trappedErr.reset (stdx::new_exception_trap (err)); }
     1184    catch (const xml::Error &err) { sThat->m->trappedErr.reset (stdx::new_exception_trap (err)); }
    12381185    catch (const std::exception &err) { sThat->m->trappedErr.reset (stdx::new_exception_trap (err)); }
    1239     catch (...) { sThat->m->trappedErr.reset (stdx::new_exception_trap (vboxxml::LogicError (RT_SRC_POS))); }
     1186    catch (...) { sThat->m->trappedErr.reset (stdx::new_exception_trap (xml::LogicError (RT_SRC_POS))); }
    12401187
    12411188    return NULL;

  • trunk/src/VBox/Main/xml/xml.cpp

    r14894 r14904  
    2424#include <iprt/file.h>
    2525#include <iprt/lock.h>
     26#include <iprt/string.h>
    2627
    2728#include <libxml/tree.h>
    … …  
    3435#include <libxml/xmlschemas.h>
    3536
    36 #include <libxslt/xsltInternals.h>
    37 #include <libxslt/transform.h>
    38 #include <libxslt/xsltutils.h>
    39 
    40 #include <string.h>
    41 
    42 #include "VBox/vboxxml.h"
    43 
    44 namespace vboxxml
    45 {
     37#include <string>
     38
     39#include "VBox/xml.h"
     40
     41
     42/**
     43 * Global module initialization structure.
     44 *
     45 * The constructor and destructor of this structure are used to perform global
     46 * module initiaizaton and cleanup. Thee must be only one global variable of
     47 * this structure.
     48 */
     49static
     50class Global
     51{
     52public:
     53
     54    Global()
     55    {
     56        /* Check the parser version. The docs say it will kill the app if
     57         * there is a serious version mismatch, but I couldn't find it in the
     58         * source code (it only prints the error/warning message to the console) so
     59         * let's leave it as is for informational purposes. */
     60        LIBXML_TEST_VERSION
     61
     62        /* Init libxml */
     63        xmlInitParser();
     64
     65        /* Save the default entity resolver before someone has replaced it */
     66        xml.defaultEntityLoader = xmlGetExternalEntityLoader();
     67    }
     68
     69    ~Global()
     70    {
     71        /* Shutdown libxml */
     72        xmlCleanupParser();
     73    }
     74
     75    struct
     76    {
     77        xmlExternalEntityLoader defaultEntityLoader;
     78
     79        /** Used to provide some thread safety missing in libxml2 (see e.g.
     80         *  XmlTreeBackend::read()) */
     81        RTLockMtx lock;
     82    }
     83    xml;
     84}
     85gGlobal;
     86
     87
     88
     89namespace xml
     90{
     91
     92//////////////////////////////////////////////////////////////////////////////
     93// Exceptions
     94//////////////////////////////////////////////////////////////////////////////
     95
     96LogicError::LogicError(RT_SRC_POS_DECL)
     97{
     98    char *msg = NULL;
     99    RTStrAPrintf(&msg, "In '%s', '%s' at #%d",
     100                 pszFunction, pszFile, iLine);
     101    setWhat(msg);
     102    RTStrFree(msg);
     103}
     104
    46105
    47106//////////////////////////////////////////////////////////////////////////////
    … …  
    246305}
    247306
    248 
    249307/*
    250  * VBoxXml
    251  *
    252  *
    253  */
    254 
    255 VBoxXmlBase::VBoxXmlBase()
     308 * GlobalLock
     309 *
     310 *
     311 */
     312
     313struct GlobalLock::Data
     314{
     315    PFNEXTERNALENTITYLOADER pOldLoader;
     316    RTLock lock;
     317
     318    Data()
     319        : pOldLoader(NULL),
     320          lock(gGlobal.xml.lock)
     321    {
     322    }
     323};
     324
     325GlobalLock::GlobalLock()
     326    : m(new Data())
     327{
     328}
     329
     330GlobalLock::~GlobalLock()
     331{
     332    if (m->pOldLoader)
     333        xmlSetExternalEntityLoader(m->pOldLoader);
     334}
     335
     336void GlobalLock::setExternalEntityLoader(PFNEXTERNALENTITYLOADER pLoader)
     337{
     338    m->pOldLoader = xmlGetExternalEntityLoader();
     339    xmlSetExternalEntityLoader(pLoader);
     340}
     341
     342// static
     343xmlParserInput* GlobalLock::callDefaultLoader(const char *aURI,
     344                                              const char *aID,
     345                                              xmlParserCtxt *aCtxt)
     346{
     347    return gGlobal.xml.defaultEntityLoader(aURI, aID, aCtxt);
     348}
     349
     350/*
     351 * XmlParserBase
     352 *
     353 *
     354 */
     355
     356XmlParserBase::XmlParserBase()
    256357{
    257358    m_ctxt = xmlNewParserCtxt();
    … …  
    260361}
    261362
    262 VBoxXmlBase::~VBoxXmlBase()
     363XmlParserBase::~XmlParserBase()
    263364{
    264365    xmlFreeParserCtxt (m_ctxt);
    … …  
    266367}
    267368
    268 
    269 int ReadCallback (void *aCtxt, char *aBuf, int aLen)
    270 {
    271     return -1 /* failure */;
    272 }
    273 
    274 
    275 VBoxXmlFile::VBoxXmlFile()
    276     : VBoxXmlBase()
    277 {
    278     xmlDocPtr doc;
    279 
    280 }
    281 
    282 VBoxXmlFile::~VBoxXmlFile()
    283 {
    284 }
    285 
    286 } // namespace vboxxml
    287 
    288 
     369/*
     370 * XmlFileParser
     371 *
     372 *
     373 */
     374
     375struct XmlFileParser::Data
     376{
     377    xmlParserCtxtPtr ctxt;
     378    std::string strXmlFilename;
     379
     380    Data()
     381    {
     382        if (!(ctxt = xmlNewParserCtxt()))
     383            throw xml::ENoMemory();
     384    }
     385
     386    ~Data()
     387    {
     388        xmlFreeParserCtxt(ctxt);
     389        ctxt = NULL;
     390    }
     391};
     392
     393XmlFileParser::XmlFileParser()
     394    : XmlParserBase(),
     395      m(new Data())
     396{
     397}
     398
     399XmlFileParser::~XmlFileParser()
     400{
     401}
     402
     403void XmlFileParser::read(const char *pcszFilename)
     404{
     405    GlobalLock lock();
     406
     407    xmlDocPtr doc = NULL;
     408
     409    m->strXmlFilename = pcszFilename;
     410
     411    /* Note: when parsing we use XML_PARSE_NOBLANKS to instruct libxml2 to
     412        * remove text nodes that contain only blanks. This is important because
     413        * otherwise xmlSaveDoc() won't be able to do proper indentation on
     414        * output. */
     415
     416    /* parse the stream */
     417    /* NOTE: new InputCtxt instance will be deleted when the stream is closed by
     418        * the libxml2 API (e.g. when calling xmlFreeParserCtxt()) */
     419//     doc = xmlCtxtReadIO(m->ctxt,
     420//                         ReadCallback,
     421//                         CloseCallback,
     422//                         new Data::InputCtxt (&aInput, m->trappedErr),
     423//                         aInput.uri(), NULL,
     424//                         XML_PARSE_NOBLANKS);
     425    if (doc == NULL)
     426    {
     427        /* look if there was a forwared exception from the lower level */
     428//         if (m->trappedErr.get() != NULL)
     429//             m->trappedErr->rethrow();
     430
     431//         throw XmlError (xmlCtxtGetLastError (m->ctxt));
     432    }
     433}
     434
     435} // end namespace xml
     436
     437
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette