xmlspec/XMLScript.cpp

   1 // standard includes
   2 #include <stdio.h>
   3
   4 // our includes
   5 #include "XMLPackage.h"
   6 #include "XMLScript.h"
   7 #include "XMLSpec.h"
   8
   9 // attribute structure for XMLScript
  10 structValidAttrs g_paScriptAttrs[] =
  11 {
  12         {0x0000,    false, false, "dir",         XATTRTYPE_STRING, {"*", NULL}},
  13         {0x0001,    false, false, "interpreter", XATTRTYPE_STRING, {"*", NULL}},
  14         {XATTR_END, false, false, "end",         XATTRTYPE_NONE,   {NULL}}
  15 };
  16
  17 bool XMLScript::parseCreate(XMLAttrs* pAttrs,
  18                                                         const char* szScript,
  19                                                         XMLScripts& rContainer)
  20 {
  21         if (!pAttrs->validate(g_paScriptAttrs, (XMLBase*)pAttrs))
  22                 return false;
  23         XMLScript script(szScript,
  24                                          pAttrs->asString("interpreter"),
  25                                          pAttrs->asString("dir"));
  26         rContainer.add(script);
  27         return true;
  28 }
  29
  30 XMLScript::XMLScript(const char* szScript,
  31                                          const char* szInterpreter,
  32                                          const char* szDir)
  33         : XMLBase()
  34 {
  35         if (szScript)
  36                 m_sValue.assign(szScript);
  37         if (szInterpreter)
  38                 m_sInterpreter.assign(szInterpreter);
  39         if (szDir)
  40                 m_sDir.assign(szDir);
  41 }
  42
  43 XMLScript::XMLScript(const XMLScript& rScript)
  44         : XMLBase()
  45 {
  46         m_sValue.assign(rScript.m_sValue);
  47         m_sInterpreter.assign(rScript.m_sInterpreter);
  48         m_sDir.assign(rScript.m_sDir);
  49 }
  50
  51 XMLScript::~XMLScript()
  52 {
  53 }
  54
  55 XMLScript XMLScript::operator=(XMLScript script)
  56 {
  57         m_sValue.assign(script.m_sValue);
  58         m_sInterpreter.assign(script.m_sInterpreter);
  59         m_sDir.assign(script.m_sDir);
  60 }
  61
  62 void XMLScript::toSpecFile(ostream& rOut)
  63 {
  64         if (hasDirectory())
  65                 rOut << "cd " << getDirectory() << endl;
  66         rOut << getValue() << endl;
  67 }
  68
  69 void XMLScript::toXMLFile(ostream& rOut,
  70                                                   const char* szIndent)
  71 {
  72         rOut << endl << szIndent << "\t\t<script";
  73         if (hasDirectory())
  74                 rOut << " dir=\"" << getDirectory() << "\"";
  75         rOut << ">" << getValue() << "</script>";
  76 }
  77
  78 void XMLScript::toRPMStruct(StringBuf* pSB)
  79 {
  80         if (hasDirectory()) {
  81                 char szBuff[getDirectoryLen()+3+1]; // 3 == strlen("cd ")
  82                 sprintf(szBuff, "cd %s", getDirectory());
  83                 appendStringBuf(*pSB, szBuff);
  84         }
  85         appendStringBuf(*pSB, getValue());
  86 }
  87
  88 bool XMLScripts::addPrepScript(XMLAttrs* pAttrs,
  89                                                            const char* szScript,
  90                                                            XMLSpec* pSpec)
  91 {
  92         // no spec or already set
  93         if (!pSpec)
  94                 return false;
  95         return XMLScript::parseCreate(pAttrs, szScript, pSpec->getPrep());
  96 }
  97
  98 bool XMLScripts::addBuildScript(XMLAttrs* pAttrs,
  99                                                                 const char* szScript,
 100                                                                 XMLSpec* pSpec)
 101 {
 102         // no spec or already set
 103         if (!pSpec)
 104                 return false;
 105         return XMLScript::parseCreate(pAttrs, szScript, pSpec->getBuild());
 106 }
 107
 108 bool XMLScripts::addInstallScript(XMLAttrs* pAttrs,
 109                                                                   const char* szScript,
 110                                                                   XMLSpec* pSpec)
 111 {
 112         // no spec or already set
 113         if (!pSpec)
 114                 return false;
 115         return XMLScript::parseCreate(pAttrs, szScript, pSpec->getInstall());
 116 }
 117
 118 bool XMLScripts::addCleanScript(XMLAttrs* pAttrs,
 119                                                                 const char* szScript,
 120                                                                 XMLSpec* pSpec)
 121 {
 122         // no spec or already set
 123         if (!pSpec)
 124                 return false;
 125         return XMLScript::parseCreate(pAttrs, szScript, pSpec->getClean());
 126 }
 127
 128 XMLScripts::XMLScripts()
 129         : XMLBase()
 130 {
 131 }
 132
 133 XMLScripts::XMLScripts(const XMLScripts& rContainer)
 134         : XMLBase()
 135 {
 136         m_vScripts = rContainer.m_vScripts;
 137 }
 138
 139 XMLScripts::~XMLScripts()
 140 {
 141 }
 142
 143 void XMLScripts::toSpecFile(ostream& rOut,
 144                                                         const char* szTag)
 145 {
 146         if (numScripts()) {
 147                 rOut << endl << "%" << szTag << endl;
 148                 for (unsigned int i = 0; i < numScripts(); i++)
 149                         getScript(i).toSpecFile(rOut);
 150         }
 151 }
 152
 153 void XMLScripts::toXMLFile(ostream& rOut,
 154                                                    const char* szTag)
 155 {
 156         if (numScripts()) {
 157                 rOut << endl << "\t<" << szTag << ">";
 158                 for (unsigned int i = 0; i < numScripts(); i++)
 159                         getScript(i).toXMLFile(rOut, "");
 160                 rOut << endl << "\t</" << szTag << ">";
 161         }
 162 }
 163
 164 bool XMLPackageScripts::addPreScript(XMLAttrs* pAttrs,
 165                                                                          const char* szScript,
 166                                                                          XMLSpec* pSpec)
 167 {
 168         if (!pSpec)
 169                 return false;
 170         return XMLScript::parseCreate(pAttrs, szScript, pSpec->lastPackage().getPre());
 171 }
 172
 173 bool XMLPackageScripts::addPostScript(XMLAttrs* pAttrs,
 174                                                                           const char* szScript,
 175                                                                           XMLSpec* pSpec)
 176 {
 177         if (!pSpec)
 178                 return false;
 179         return XMLScript::parseCreate(pAttrs, szScript, pSpec->lastPackage().getPost());
 180 }
 181
 182 bool XMLPackageScripts::addPreUnScript(XMLAttrs* pAttrs,
 183                                                                            const char* szScript,
 184                                                                            XMLSpec* pSpec)
 185 {
 186         if (!pSpec)
 187                 return false;
 188         return XMLScript::parseCreate(pAttrs, szScript, pSpec->lastPackage().getPreUn());
 189 }
 190
 191 bool XMLPackageScripts::addPostUnScript(XMLAttrs* pAttrs,
 192                                                                                 const char* szScript,
 193                                                                                 XMLSpec* pSpec)
 194 {
 195         if (!pSpec)
 196                 return false;
 197         return XMLScript::parseCreate(pAttrs, szScript, pSpec->lastPackage().getPostUn());
 198 }
 199
 200 bool XMLPackageScripts::addVerifyScript(XMLAttrs* pAttrs,
 201                                                                                 const char* szScript,
 202                                                                                 XMLSpec* pSpec)
 203 {
 204         if (!pSpec)
 205                 return false;
 206         return XMLScript::parseCreate(pAttrs, szScript, pSpec->lastPackage().getVerify());
 207 }
 208
 209 bool XMLPackageScripts::createPreScripts(XMLAttrs* pAttrs,
 210                                                                                  XMLSpec* pSpec)
 211 {
 212         if (!pSpec)
 213                 return false;
 214         pSpec->lastPackage().getPre().setInterpreter(pAttrs->asString("interpreter"));
 215         return true;
 216 }
 217
 218 bool XMLPackageScripts::createPostScripts(XMLAttrs* pAttrs,
 219                                                                                   XMLSpec* pSpec)
 220 {
 221         if (!pSpec)
 222                 return false;
 223         pSpec->lastPackage().getPost().setInterpreter(pAttrs->asString("interpreter"));
 224         return true;
 225 }
 226
 227 bool XMLPackageScripts::createPreUnScripts(XMLAttrs* pAttrs,
 228                                                                                    XMLSpec* pSpec)
 229 {
 230         if (!pSpec)
 231                 return false;
 232         pSpec->lastPackage().getPreUn().setInterpreter(pAttrs->asString("interpreter"));
 233         return true;
 234 }
 235
 236 bool XMLPackageScripts::createPostUnScripts(XMLAttrs* pAttrs,
 237                                                                                         XMLSpec* pSpec)
 238 {
 239         if (!pSpec)
 240                 return false;
 241         pSpec->lastPackage().getPostUn().setInterpreter(pAttrs->asString("interpreter"));
 242         return true;
 243 }
 244
 245 bool XMLPackageScripts::createVerifyScripts(XMLAttrs* pAttrs,
 246                                                                                         XMLSpec* pSpec)
 247 {
 248         if (!pSpec)
 249                 return false;
 250         pSpec->lastPackage().getVerify().setInterpreter(pAttrs->asString("interpreter"));
 251         return true;
 252 }
 253
 254 XMLPackageScripts::XMLPackageScripts()
 255         : XMLScripts()
 256 {
 257 }
 258
 259 XMLPackageScripts::XMLPackageScripts(const XMLPackageScripts& rContainer)
 260         : XMLScripts(rContainer)
 261 {
 262 }
 263
 264 XMLPackageScripts::~XMLPackageScripts()
 265 {
 266 }
 267
 268 void XMLPackageScripts::toSpecFile(ostream& rOut,
 269                                                                    const char* szTag)
 270 {
 271         // NOTE: header not done here, but by "package"
 272         for (unsigned int i = 0; i < numScripts(); i++)
 273                 getScript(i).toSpecFile(rOut);
 274 }
 275
 276 void XMLPackageScripts::toXMLFile(ostream& rOut,
 277                                                                   const char* szTag)
 278 {
 279         if (numScripts()) {
 280                 rOut << endl << "\t\t<" << szTag << ">";
 281                 for (unsigned int i = 0; i < numScripts(); i++)
 282                         getScript(i).toXMLFile(rOut, "\t");
 283                 rOut << endl << "\t\t</" << szTag << ">";
 284         }
 285 }