00001
00002
00003
00004
00005
00006
00007
00008
00013 #include <zypp/parser/yum/YUMPatchParser.h>
00014 #include <zypp/parser/yum/YUMPrimaryParser.h>
00015 #include <istream>
00016 #include <string>
00017 #include "zypp/parser/xml_parser_assert.h"
00018 #include <libxml/xmlreader.h>
00019 #include <libxml/tree.h>
00020 #include <zypp/parser/LibXMLHelper.h>
00021 #include <zypp/base/Logger.h>
00022 #include <zypp/parser/yum/schemanames.h>
00023 #include <zypp/ZYppFactory.h>
00024
00025 using namespace std;
00026 namespace zypp {
00027 namespace parser {
00028 namespace yum {
00029
00030 YUMPatchParser::~YUMPatchParser()
00031 { }
00032
00033 YUMPatchParser::YUMPatchParser(istream &is, const string& baseUrl)
00034 : XMLNodeIterator<YUMPatchData_Ptr>(is, baseUrl,PATCHSCHEMA)
00035 , _zypp_architecture( getZYpp()->architecture() )
00036 {
00037 fetchNext();
00038 }
00039
00040 YUMPatchParser::YUMPatchParser()
00041 : _zypp_architecture( getZYpp()->architecture() )
00042 { }
00043
00044 YUMPatchParser::YUMPatchParser(YUMPatchData_Ptr& entry)
00045 : XMLNodeIterator<YUMPatchData_Ptr>(entry)
00046 , _zypp_architecture( getZYpp()->architecture() )
00047 { }
00048
00049
00050
00051 bool
00052 YUMPatchParser::isInterested(const xmlNodePtr nodePtr)
00053 {
00054 return _helper.isElement(nodePtr) && _helper.name(nodePtr) == "patch";
00055 }
00056
00057
00058 YUMPatchData_Ptr
00059 YUMPatchParser::process(const xmlTextReaderPtr reader)
00060 {
00061 xml_assert(reader);
00062 YUMPatchData_Ptr patchPtr = new YUMPatchData;
00063 xmlNodePtr dataNode = xmlTextReaderExpand(reader);
00064 xml_assert(dataNode);
00065 patchPtr->timestamp = _helper.attribute(dataNode,"timestamp");
00066 patchPtr->patchId = _helper.attribute(dataNode,"patchid");
00067 patchPtr->engine = _helper.attribute(dataNode,"engine");
00068
00069
00070 patchPtr->rebootNeeded = false;
00071 patchPtr->packageManager = false;
00072
00073
00074 YUMPrimaryParser prim;
00075
00076 for (xmlNodePtr child = dataNode->children;
00077 child && child != dataNode;
00078 child = child->next) {
00079 if (_helper.isElement(child)) {
00080 string name = _helper.name(child);
00081 if (name == "name") {
00082 patchPtr->name = _helper.content(child);
00083 }
00084 else if (name == "arch") {
00085 patchPtr->arch = _helper.content(child);
00086 try {
00087 if (!Arch(patchPtr->arch).compatibleWith( _zypp_architecture )) {
00088 patchPtr = NULL;
00089 break;
00090 }
00091 }
00092 catch( const Exception & excpt_r ) {
00093 ZYPP_CAUGHT( excpt_r );
00094 DBG << "Skipping malformed " << patchPtr->arch << endl;
00095 patchPtr = NULL;
00096 break;
00097 }
00098 }
00099 else if (name == "summary") {
00100 patchPtr->summary.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00101 }
00102 else if (name == "description") {
00103 patchPtr->description.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00104 }
00105 else if (name == "license-to-confirm")
00106 {
00107 patchPtr->license_to_confirm.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00108 }
00109 else if (name == "version") {
00110 patchPtr->epoch = _helper.attribute(child,"epoch");
00111 patchPtr->ver = _helper.attribute(child,"ver");
00112 patchPtr->rel = _helper.attribute(child,"rel");
00113 }
00114 else if (name == "provides") {
00115 prim.parseDependencyEntries(& patchPtr->provides, child);
00116 }
00117 else if (name == "conflicts") {
00118 prim.parseDependencyEntries(& patchPtr->conflicts, child);
00119 }
00120 else if (name == "obsoletes") {
00121 prim.parseDependencyEntries(& patchPtr->obsoletes, child);
00122 }
00123 else if (name == "prerequires") {
00124 prim.parseDependencyEntries(& patchPtr->prerequires, child);
00125 }
00126 else if (name == "requires") {
00127 prim.parseDependencyEntries(& patchPtr->requires, child);
00128 }
00129 else if (name == "recommends") {
00130 prim.parseDependencyEntries(& patchPtr->recommends, child);
00131 }
00132 else if (name == "suggests") {
00133 prim.parseDependencyEntries(& patchPtr->suggests, child);
00134 }
00135 else if (name == "supplements") {
00136 prim.parseDependencyEntries(& patchPtr->supplements, child);
00137 }
00138 else if (name == "enhances") {
00139 prim.parseDependencyEntries(& patchPtr->enhances, child);
00140 }
00141 else if (name == "freshens") {
00142 prim.parseDependencyEntries(& patchPtr->freshens, child);
00143 }
00144 else if (name == "category") {
00145 patchPtr->category = _helper.content(child);
00146 }
00147 else if (name == "reboot-needed") {
00148 patchPtr->rebootNeeded = true;
00149 }
00150 else if (name == "package-manager") {
00151 patchPtr->packageManager = true;
00152 }
00153 else if (name == "update-script") {
00154 patchPtr->updateScript = _helper.content(child);
00155 }
00156 else if (name == "atoms") {
00157 parseAtomsNode(patchPtr, child);
00158 }
00159 else {
00160 WAR << "YUM <data> contains the unknown element <" << name << "> "
00161 << _helper.positionInfo(child) << ", skipping" << endl;
00162 }
00163 }
00164 }
00165 return patchPtr;
00166 }
00167
00168
00169 void
00170 YUMPatchParser::parseAtomsNode(YUMPatchData_Ptr dataPtr,
00171 xmlNodePtr formatNode)
00172 {
00173 xml_assert(formatNode);
00174 for (xmlNodePtr child = formatNode->children;
00175 child != 0;
00176 child = child ->next) {
00177 if (_helper.isElement(child)) {
00178 string name = _helper.name(child);
00179 XXX << "parseAtomsNode(" << name << ")" << endl;
00180 if (name == "package")
00181 {
00182 parsePackageNode( dataPtr, child );
00183 }
00184 else if (name == "script")
00185 {
00186 parseScriptNode( dataPtr, child );
00187 }
00188 else if (name == "message")
00189 {
00190 parseMessageNode( dataPtr, child );
00191 }
00192 else {
00193 WAR << "YUM <atoms> contains the unknown element <" << name << "> "
00194 << _helper.positionInfo(child) << ", skipping" << endl;
00195 }
00196 }
00197 }
00198 }
00199
00200 void
00201 YUMPatchParser::parseFormatNode(YUMPatchPackage *dataPtr,
00202 xmlNodePtr formatNode)
00203 {
00204 xml_assert(formatNode);
00205 dataPtr->installOnly = false;
00206 dataPtr->media = "1";
00207
00208
00209 YUMPrimaryParser prim;
00210
00211 for (xmlNodePtr child = formatNode->children;
00212 child != 0;
00213 child = child ->next) {
00214 if (_helper.isElement(child)) {
00215 string name = _helper.name(child);
00216 if (name == "license") {
00217 dataPtr->license = _helper.content(child);
00218 }
00219 else if (name == "vendor") {
00220 dataPtr->vendor = _helper.content(child);
00221 }
00222 else if (name == "group") {
00223 dataPtr->group = _helper.content(child);
00224 }
00225 else if (name == "buildhost") {
00226 dataPtr->buildhost = _helper.content(child);
00227 }
00228 else if (name == "sourcerpm") {
00229 dataPtr->sourcerpm = _helper.content(child);
00230 }
00231 else if (name == "header-range") {
00232 dataPtr->headerStart = _helper.attribute(child,"start");
00233 dataPtr->headerEnd = _helper.attribute(child,"end");
00234 }
00235 else if (name == "provides") {
00236 prim.parseDependencyEntries(& dataPtr->provides, child);
00237 }
00238 else if (name == "conflicts") {
00239 prim.parseDependencyEntries(& dataPtr->conflicts, child);
00240 }
00241 else if (name == "obsoletes") {
00242 prim.parseDependencyEntries(& dataPtr->obsoletes, child);
00243 }
00244 else if (name == "prerequires") {
00245 prim.parseDependencyEntries(& dataPtr->prerequires, child);
00246 }
00247 else if (name == "requires") {
00248 prim.parseDependencyEntries(& dataPtr->requires, child);
00249 }
00250 else if (name == "recommends") {
00251 prim.parseDependencyEntries(& dataPtr->recommends, child);
00252 }
00253 else if (name == "suggests") {
00254 prim.parseDependencyEntries(& dataPtr->suggests, child);
00255 }
00256 else if (name == "supplements") {
00257 prim.parseDependencyEntries(& dataPtr->supplements, child);
00258 }
00259 else if (name == "enhances") {
00260 prim.parseDependencyEntries(& dataPtr->enhances, child);
00261 }
00262 else if (name == "file") {
00263 dataPtr->files.push_back
00264 (FileData(_helper.content(child),
00265 _helper.attribute(child,"type")));
00266 }
00267
00268 else if (name == "authors") {
00269 prim.parseAuthorEntries(& dataPtr->authors, child);
00270 }
00271 else if (name == "keywords") {
00272 prim.parseKeywordEntries(& dataPtr->keywords, child);
00273 }
00274 else if (name == "media") {
00275 dataPtr->media = _helper.attribute(child,"mediaid");
00276 }
00277 else if (name == "dirsizes") {
00278 prim.parseDirsizeEntries(& dataPtr->dirSizes, child);
00279 }
00280 else if (name == "freshens") {
00281 prim.parseDependencyEntries(& dataPtr->freshens, child);
00282 }
00283 else if (name == "install-only") {
00284 dataPtr->installOnly = true;
00285 }
00286 else {
00287 WAR << "YUM <atom/package/format> contains the unknown element <"
00288 << name << "> "
00289 << _helper.positionInfo(child) << ", skipping" << endl;
00290 }
00291 }
00292 }
00293 }
00294
00295 void
00296 YUMPatchParser::parsePkgPlainRpmNode(YUMPatchPackage *dataPtr,
00297 xmlNodePtr formatNode)
00298 {
00299 YUMPlainRpm plainRpm;
00300 plainRpm.arch = _helper.attribute( formatNode, "arch" );
00301 plainRpm.filename = _helper.attribute( formatNode, "filename" );
00302 plainRpm.downloadsize = _helper.attribute( formatNode, "downloadsize" );
00303 plainRpm.md5sum = _helper.attribute( formatNode, "md5sum" );
00304 plainRpm.buildtime = _helper.attribute( formatNode, "buildtime" );
00305 for (xmlNodePtr child = formatNode->children;
00306 child != 0;
00307 child = child ->next) {
00308 if (_helper.isElement(child)) {
00309 string name = _helper.name(child);
00310 WAR << "YUM <atom/package/pkgfiles/plain> contains the unknown element <"
00311 << name << "> "
00312 << _helper.positionInfo(child) << ", skipping" << endl;
00313 }
00314 }
00315 dataPtr->plainRpms.push_back(plainRpm);
00316 }
00317
00318 void
00319 YUMPatchParser::parsePkgPatchRpmNode(YUMPatchPackage *dataPtr,
00320 xmlNodePtr formatNode)
00321 {
00322 YUMPatchRpm patchRpm;
00323 patchRpm.arch = _helper.attribute( formatNode, "arch" );
00324 patchRpm.filename = _helper.attribute( formatNode, "filename" );
00325 patchRpm.downloadsize = _helper.attribute( formatNode, "downloadsize" );
00326 patchRpm.md5sum = _helper.attribute( formatNode, "md5sum" );
00327 patchRpm.buildtime = _helper.attribute( formatNode, "buildtime" );
00328 patchRpm.media = "1";
00329 for (xmlNodePtr child = formatNode->children;
00330 child != 0;
00331 child = child ->next) {
00332 if (_helper.isElement(child)) {
00333 string name = _helper.name(child);
00334 if (name == "base-version") {
00335 YUMBaseVersion base_version;
00336 parsePkgBaseVersionNode( &base_version, child);
00337 patchRpm.baseVersions.push_back( base_version );
00338 }
00339 else if (name == "location") {
00340 patchRpm.location = _helper.attribute(child,"href");
00341 }
00342 else if (name == "media") {
00343 patchRpm.media = _helper.content(child);
00344 }
00345 else if (name == "checksum") {
00346 patchRpm.checksumType = _helper.attribute(child,"type");
00347 patchRpm.checksum = _helper.content(child);
00348 }
00349 else if (name == "time") {
00350
00351 patchRpm.buildtime = _helper.attribute(child,"build");
00352 }
00353 else if (name == "size") {
00354
00355
00356 patchRpm.downloadsize = _helper.attribute(child,"archive");
00357 }
00358 else {
00359 WAR << "YUM <atom/package/pkgfiles/patch> contains the unknown element <"
00360 << name << "> "
00361 << _helper.positionInfo(child) << ", skipping" << endl;
00362 }
00363 }
00364 }
00365 dataPtr->patchRpms.push_back(patchRpm);
00366 }
00367
00368 void
00369 YUMPatchParser::parsePkgDeltaRpmNode(YUMPatchPackage *dataPtr,
00370 xmlNodePtr formatNode)
00371 {
00372 YUMDeltaRpm deltaRpm;
00373 deltaRpm.arch = _helper.attribute( formatNode, "arch" );
00374 deltaRpm.filename = _helper.attribute( formatNode, "filename" );
00375 deltaRpm.downloadsize = _helper.attribute( formatNode, "downloadsize" );
00376 deltaRpm.md5sum = _helper.attribute( formatNode, "md5sum" );
00377 deltaRpm.buildtime = _helper.attribute( formatNode, "buildtime" );
00378 deltaRpm.media = "1";
00379 for (xmlNodePtr child = formatNode->children;
00380 child != 0;
00381 child = child ->next) {
00382 if (_helper.isElement(child)) {
00383 string name = _helper.name(child);
00384 if (name == "base-version") {
00385 parsePkgBaseVersionNode( &(deltaRpm.baseVersion), child);
00386 }
00387 else if (name == "location") {
00388 deltaRpm.location = _helper.attribute(child,"href");
00389 }
00390 else if (name == "media") {
00391 deltaRpm.media = _helper.content(child);
00392 }
00393 else if (name == "checksum") {
00394 deltaRpm.checksumType = _helper.attribute(child,"type");
00395 deltaRpm.checksum = _helper.content(child);
00396 }
00397 else if (name == "time") {
00398
00399 deltaRpm.buildtime = _helper.attribute(child,"build");
00400 }
00401 else if (name == "size") {
00402
00403
00404 deltaRpm.downloadsize = _helper.attribute(child,"archive");
00405 }
00406 else {
00407 WAR << "YUM <atom/package/pkgfiles/delta> contains the unknown element <"
00408 << name << "> "
00409 << _helper.positionInfo(child) << ", skipping" << endl;
00410 }
00411 }
00412 }
00413 dataPtr->deltaRpms.push_back(deltaRpm);
00414 }
00415
00416
00417 void
00418 YUMPatchParser::parsePkgBaseVersionNode(YUMBaseVersion *dataPtr,
00419 xmlNodePtr formatNode)
00420 {
00421 dataPtr->epoch = _helper.attribute( formatNode, "epoch" );
00422 dataPtr->ver = _helper.attribute( formatNode, "ver" );
00423 dataPtr->rel = _helper.attribute( formatNode, "rel" );
00424 dataPtr->md5sum = _helper.attribute( formatNode, "md5sum" );
00425 dataPtr->buildtime = _helper.attribute( formatNode, "buildtime" );
00426 dataPtr->source_info = _helper.attribute( formatNode, "source-info" );
00427 }
00428
00429 void
00430 YUMPatchParser::parsePkgFilesNode(YUMPatchPackage *dataPtr,
00431 xmlNodePtr formatNode)
00432 {
00433 for (xmlNodePtr child = formatNode->children;
00434 child != 0;
00435 child = child ->next) {
00436 if (_helper.isElement(child)) {
00437 string name = _helper.name(child);
00438 if (name == "plainrpm") {
00439 parsePkgPlainRpmNode( dataPtr, child );
00440 }
00441 else if (name == "patchrpm") {
00442 parsePkgPatchRpmNode( dataPtr, child );
00443 }
00444 else if (name == "deltarpm") {
00445 parsePkgDeltaRpmNode( dataPtr, child );
00446 }
00447 else {
00448 WAR << "YUM <atom/package/pkgfiles> contains the unknown element <"
00449 << name << "> "
00450 << _helper.positionInfo(child) << ", skipping" << endl;
00451 }
00452 }
00453 }
00454 }
00455
00456
00457
00458
00459
00460
00461 void
00462 YUMPatchParser::parsePackageNode(YUMPatchData_Ptr dataPtr,
00463 xmlNodePtr formatNode)
00464 {
00465 shared_ptr<YUMPatchPackage> package(new YUMPatchPackage);
00466 package->type = _helper.attribute(formatNode,"type");
00467 package->installOnly = false;
00468 package->media = "1";
00469
00470
00471 YUMPrimaryParser prim;
00472
00473 for (xmlNodePtr child = formatNode->children;
00474 child != 0;
00475 child = child ->next) {
00476 if (_helper.isElement(child)) {
00477 string name = _helper.name(child);
00478 XXX << "parsePackageNode(" << name << ")" << endl;
00479 if (name == "name") {
00480 package->name = _helper.content(child);
00481 }
00482 else if (name == "arch") {
00483 package->arch = _helper.content(child);
00484 }
00485 else if (name == "version") {
00486 package->epoch = _helper.attribute(child,"epoch");
00487 package->ver = _helper.attribute(child,"ver");
00488 package->rel = _helper.attribute(child,"rel");
00489 }
00490 else if (name == "checksum") {
00491 package->checksumType = _helper.attribute(child,"type");
00492 package->checksumPkgid = _helper.attribute(child,"pkgid");
00493 package->checksum = _helper.content(child);
00494 }
00495 else if (name == "summary") {
00496 package->summary = _helper.content(child);
00497 }
00498 else if (name == "description") {
00499 package->description = _helper.content(child);
00500 }
00501 else if (name == "packager") {
00502 package->packager = _helper.content(child);
00503 }
00504 else if (name == "url") {
00505 package->url = _helper.content(child);
00506 }
00507 else if (name == "time") {
00508 package->timeFile = _helper.attribute(child,"file");
00509 package->timeBuild = _helper.attribute(child,"build");
00510 }
00511 else if (name == "size") {
00512 package->sizePackage = _helper.attribute(child,"package");
00513 package->sizeInstalled = _helper.attribute(child,"installed");
00514 package->sizeArchive = _helper.attribute(child,"archive");
00515 }
00516 else if (name == "location") {
00517 package->location = _helper.attribute(child,"href");
00518 }
00519 else if (name == "format") {
00520 parseFormatNode (&*package, child);
00521 }
00522 else if (name == "pkgfiles")
00523 {
00524 parsePkgFilesNode (&*package, child);
00525 }
00526 else if (name == "license-to-confirm")
00527 {
00528 package->license_to_confirm.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00529 }
00530 else {
00531 WAR << "YUM <atoms/package> contains the unknown element <"
00532 << name << "> "
00533 << _helper.positionInfo(child) << ", skipping" << endl;
00534 }
00535 }
00536 }
00537 dataPtr->atoms.push_back(package);
00538 }
00539
00540 void
00541 YUMPatchParser::parseScriptNode(YUMPatchData_Ptr dataPtr,
00542 xmlNodePtr formatNode)
00543 {
00544 shared_ptr<YUMPatchScript> script(new YUMPatchScript);
00545 script->do_media = "1";
00546 script->undo_media = "1";
00547
00548
00549 YUMPrimaryParser prim;
00550
00551 for (xmlNodePtr child = formatNode->children;
00552 child != 0;
00553 child = child ->next) {
00554 if (_helper.isElement(child)) {
00555 string name = _helper.name(child);
00556 if (name == "name") {
00557 script->name = _helper.content(child);
00558 }
00559 else if (name == "version") {
00560 script->epoch = _helper.attribute(child,"epoch");
00561 script->ver = _helper.attribute(child,"ver");
00562 script->rel = _helper.attribute(child,"rel");
00563 }
00564 else if (name == "do") {
00565 script->do_script = _helper.content(child);
00566 }
00567 else if (name == "undo") {
00568 script->undo_script = _helper.content(child);
00569 }
00570 else if (name == "do-location") {
00571 script->do_location = _helper.attribute(child,"href");
00572 }
00573 else if (name == "undo-location") {
00574 script->undo_location = _helper.attribute(child,"href");
00575 }
00576 else if (name == "do-media") {
00577 script->do_media = _helper.attribute(child,"mediaid");
00578 }
00579 else if (name == "undo-media") {
00580 script->undo_media = _helper.attribute(child,"mediaid");
00581 }
00582 else if (name == "do-checksum") {
00583 script->do_checksum_type = _helper.attribute(child,"type");
00584 script->do_checksum = _helper.content(child);
00585 }
00586 else if (name == "undo-checksum") {
00587 script->undo_checksum_type = _helper.attribute(child,"type");
00588 script->undo_checksum = _helper.content(child);
00589 }
00590 else if (name == "provides") {
00591 prim.parseDependencyEntries(& script->provides, child);
00592 }
00593 else if (name == "conflicts") {
00594 prim.parseDependencyEntries(& script->conflicts, child);
00595 }
00596 else if (name == "obsoletes") {
00597 prim.parseDependencyEntries(& script->obsoletes, child);
00598 }
00599 else if (name == "requires") {
00600 prim.parseDependencyEntries(& script->requires, child);
00601 }
00602 else if (name == "prerequires") {
00603 prim.parseDependencyEntries(& script->prerequires, child);
00604 }
00605 else if (name == "recommends") {
00606 prim.parseDependencyEntries(& script->recommends, child);
00607 }
00608 else if (name == "suggests") {
00609 prim.parseDependencyEntries(& script->suggests, child);
00610 }
00611 else if (name == "supplements") {
00612 prim.parseDependencyEntries(& script->supplements, child);
00613 }
00614 else if (name == "enhances") {
00615 prim.parseDependencyEntries(& script->enhances, child);
00616 }
00617 else if (name == "freshens") {
00618 prim.parseDependencyEntries(& script->freshens, child);
00619 }
00620 else {
00621 WAR << "YUM <atoms/script> contains the unknown element <"
00622 << name << "> "
00623 << _helper.positionInfo(child) << ", skipping" << endl;
00624 }
00625 }
00626 }
00627 dataPtr->atoms.push_back(script);
00628 }
00629
00630 void
00631 YUMPatchParser::parseMessageNode(YUMPatchData_Ptr dataPtr,
00632 xmlNodePtr formatNode)
00633 {
00634 shared_ptr<YUMPatchMessage> message(new YUMPatchMessage);
00635
00636
00637 YUMPrimaryParser prim;
00638
00639 for (xmlNodePtr child = formatNode->children;
00640 child != 0;
00641 child = child ->next) {
00642 if (_helper.isElement(child)) {
00643 string name = _helper.name(child);
00644 if (name == "name") {
00645 message->name = _helper.content(child);
00646 }
00647 else if (name == "version") {
00648 message->epoch = _helper.attribute(child,"epoch");
00649 message->ver = _helper.attribute(child,"ver");
00650 message->rel = _helper.attribute(child,"rel");
00651 }
00652 else if (name == "text") {
00653 message->text.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
00654 }
00655 else if (name == "provides") {
00656 prim.parseDependencyEntries(& message->provides, child);
00657 }
00658 else if (name == "conflicts") {
00659 prim.parseDependencyEntries(& message->conflicts, child);
00660 }
00661 else if (name == "obsoletes") {
00662 prim.parseDependencyEntries(& message->obsoletes, child);
00663 }
00664 else if (name == "prerequires") {
00665 prim.parseDependencyEntries(& message->prerequires, child);
00666 }
00667 else if (name == "requires") {
00668 prim.parseDependencyEntries(& message->requires, child);
00669 }
00670 else if (name == "recommends") {
00671 prim.parseDependencyEntries(& message->recommends, child);
00672 }
00673 else if (name == "suggests") {
00674 prim.parseDependencyEntries(& message->suggests, child);
00675 }
00676 else if (name == "supplements") {
00677 prim.parseDependencyEntries(& message->supplements, child);
00678 }
00679 else if (name == "enhances") {
00680 prim.parseDependencyEntries(& message->enhances, child);
00681 }
00682 else if (name == "freshens") {
00683 prim.parseDependencyEntries(& message->freshens, child);
00684 }
00685 else {
00686 WAR << "YUM <atoms/message> contains the unknown element <"
00687 << name << "> "
00688 << _helper.positionInfo(child) << ", skipping" << endl;
00689 }
00690 }
00691 }
00692 dataPtr->atoms.push_back(message);
00693 }
00694
00695 }
00696 }
00697 }