VirtualBox

Changeset 14904 in vbox for trunk/src


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/src/VBox/Main
Files:
7 edited
1 moved

Legend:

Unmodified
Added
Removed

  • 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