rpmds.h

Go to the documentation of this file.

#ifndef H_RPMDS
#define H_RPMDS
 
#include <time.h>
 
#include <rpm/rpmtypes.h>
#include <rpm/rpmutil.h>
#include <rpm/rpmps.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
extern int _rpmds_nopromote;
 
enum rpmsenseFlags_e {
    RPMSENSE_ANY        = 0,
    RPMSENSE_LESS       = (1 << 1),
    RPMSENSE_GREATER    = (1 << 2),
    RPMSENSE_EQUAL      = (1 << 3),
    /* bit 4 unused */
    RPMSENSE_POSTTRANS  = (1 << 5),     
    RPMSENSE_PREREQ     = (1 << 6),     /* legacy prereq dependency */
    RPMSENSE_PRETRANS   = (1 << 7),     
    RPMSENSE_INTERP     = (1 << 8),     
    RPMSENSE_SCRIPT_PRE = (1 << 9),     
    RPMSENSE_SCRIPT_POST = (1 << 10),   
    RPMSENSE_SCRIPT_PREUN = (1 << 11),  
    RPMSENSE_SCRIPT_POSTUN = (1 << 12), 
    RPMSENSE_SCRIPT_VERIFY = (1 << 13), 
    RPMSENSE_FIND_REQUIRES = (1 << 14), 
    RPMSENSE_FIND_PROVIDES = (1 << 15), 
    RPMSENSE_TRIGGERIN  = (1 << 16),    
    RPMSENSE_TRIGGERUN  = (1 << 17),    
    RPMSENSE_TRIGGERPOSTUN = (1 << 18), 
    RPMSENSE_MISSINGOK  = (1 << 19),    
    /* bits 20-23 unused */
    RPMSENSE_RPMLIB = (1 << 24),        
    RPMSENSE_TRIGGERPREIN = (1 << 25),  
    RPMSENSE_KEYRING    = (1 << 26),
    /* bit 27 unused */
    RPMSENSE_CONFIG     = (1 << 28),
    RPMSENSE_META       = (1 << 29),    
};
 
typedef rpmFlags rpmsenseFlags;
 
#define RPMSENSE_SENSEMASK      15       /* Mask to get senses, ie serial, */
                                         /* less, greater, equal.          */
 
#define RPMSENSE_TRIGGER        \
        (RPMSENSE_TRIGGERPREIN | RPMSENSE_TRIGGERIN | RPMSENSE_TRIGGERUN | RPMSENSE_TRIGGERPOSTUN)
 
#define _ALL_REQUIRES_MASK      (\
    RPMSENSE_INTERP | \
    RPMSENSE_SCRIPT_PRE | \
    RPMSENSE_SCRIPT_POST | \
    RPMSENSE_SCRIPT_PREUN | \
    RPMSENSE_SCRIPT_POSTUN | \
    RPMSENSE_SCRIPT_VERIFY | \
    RPMSENSE_FIND_REQUIRES | \
    RPMSENSE_RPMLIB | \
    RPMSENSE_KEYRING | \
    RPMSENSE_PRETRANS | \
    RPMSENSE_POSTTRANS | \
    RPMSENSE_PREREQ | \
    RPMSENSE_META | \
    RPMSENSE_MISSINGOK)
 
#define _notpre(_x)             ((_x) & ~RPMSENSE_PREREQ)
#define _INSTALL_ONLY_MASK \
    _notpre(RPMSENSE_SCRIPT_PRE|RPMSENSE_SCRIPT_POST|RPMSENSE_RPMLIB|RPMSENSE_KEYRING|RPMSENSE_PRETRANS|RPMSENSE_POSTTRANS)
#define _ERASE_ONLY_MASK  \
    _notpre(RPMSENSE_SCRIPT_PREUN|RPMSENSE_SCRIPT_POSTUN)
#define _UNORDERED_ONLY_MASK \
    _notpre(RPMSENSE_RPMLIB|RPMSENSE_CONFIG|RPMSENSE_PRETRANS|RPMSENSE_POSTTRANS|RPMSENSE_SCRIPT_VERIFY|RPMSENSE_META)
#define _FORCE_ORDER_ONLY_MASK \
    _notpre(RPMSENSE_SCRIPT_PRE|RPMSENSE_SCRIPT_POST|RPMSENSE_SCRIPT_PREUN|RPMSENSE_SCRIPT_POSTUN)
 
#define isLegacyPreReq(_x)  (((_x) & _ALL_REQUIRES_MASK) == RPMSENSE_PREREQ)
#define isInstallPreReq(_x)     ((_x) & _INSTALL_ONLY_MASK)
#define isErasePreReq(_x)       ((_x) & _ERASE_ONLY_MASK)
#define isUnorderedReq(_x)      ((_x) & _UNORDERED_ONLY_MASK && \
                                 !((_x) & _FORCE_ORDER_ONLY_MASK))
#define isTransientReq(_x)      (isInstallPreReq(_x) && \
                                 !isErasePreReq(_x) &&  \
                                 !((_x) & RPMSENSE_META))
 
rpmsenseFlags rpmSanitizeDSFlags(rpmTagVal tagN, rpmsenseFlags Flags);
 
rpmsenseFlags rpmParseDSFlags(const char *str, size_t len);
 
rpmds rpmdsLink(rpmds ds);
 
rpmds rpmdsFree(rpmds ds);
 
rpmds rpmdsNew(Header h, rpmTagVal tagN, int flags);
 
char * rpmdsNewDNEVR(const char * dspfx, const rpmds ds);
 
rpmds rpmdsThis(Header h, rpmTagVal tagN, rpmsenseFlags Flags);
 
rpmds rpmdsSingle(rpmTagVal tagN, const char * N, const char * EVR, rpmsenseFlags Flags);
 
rpmds rpmdsCurrent(rpmds ds);
 
int rpmdsPutToHeader(rpmds ds, Header h);
 
int rpmdsCount(const rpmds ds);
 
int rpmdsIx(const rpmds ds);
 
int rpmdsSetIx(rpmds ds, int ix);
 
const char * rpmdsDNEVR(const rpmds ds);
 
char rpmdsD(const rpmds ds);
 
rpmTagVal rpmdsDToTagN(char deptype);
 
const char * rpmdsN(const rpmds ds);
 
const char * rpmdsEVR(const rpmds ds);
 
int rpmdsTi(const rpmds ds);
 
rpmsenseFlags rpmdsFlags(const rpmds ds);
 
rpmTagVal rpmdsTagN(const rpmds ds);
 
rpmTagVal rpmdsTagEVR(const rpmds ds);
 
rpmTagVal rpmdsTagF(const rpmds ds);
 
rpmTagVal rpmdsTagTi(const rpmds ds);
 
unsigned int rpmdsInstance(rpmds ds);
 
int rpmdsIsWeak(rpmds ds);
 
int rpmdsIsReverse(rpmds ds);
 
RPM_GNUC_DEPRECATED
int rpmdsNoPromote(const rpmds ds);
 
RPM_GNUC_DEPRECATED
int rpmdsSetNoPromote(rpmds ds, int nopromote);
 
rpm_color_t rpmdsColor(const rpmds ds);
 
rpm_color_t rpmdsSetColor(const rpmds ds, rpm_color_t color);
 
int rpmdsNext(rpmds ds);
 
rpmds rpmdsInit(rpmds ds);
 
int rpmdsFind(rpmds ds, const rpmds ods);
 
int rpmdsMerge(rpmds * dsp, rpmds ods);
 
int rpmdsSearch(rpmds ds, rpmds ods);
 
int rpmdsCompare(const rpmds A, const rpmds B);
 
int rpmdsAnyMatchesDep (const Header h, const rpmds req, int nopromote);
 
int rpmdsMatchesDep (const Header h, int ix, const rpmds req, int nopromote);
 
int rpmdsNVRMatchesDep(const Header h, const rpmds req, int nopromote);
 
int rpmdsRpmlib(rpmds * dsp, const void * tblp);
 
rpmds rpmdsNewPool(rpmstrPool pool, Header h, rpmTagVal tagN, int flags);
 
rpmds rpmdsThisPool(rpmstrPool pool,
                    Header h, rpmTagVal tagN, rpmsenseFlags Flags);
 
rpmds rpmdsSinglePool(rpmstrPool pool, rpmTagVal tagN,
                      const char * N, const char * EVR, rpmsenseFlags Flags);
 
rpmds rpmdsSinglePoolTix(rpmstrPool pool, rpmTagVal tagN,
                            const char * N, const char * EVR, 
                            rpmsenseFlags Flags, int triggerIndex);
 
int rpmdsRpmlibPool(rpmstrPool pool, rpmds * dsp, const void * tblp);
 
 
typedef enum rpmrichOp_e {
    RPMRICHOP_SINGLE  = 1,
    RPMRICHOP_AND     = 2,
    RPMRICHOP_OR      = 3,
    RPMRICHOP_IF      = 4,
    RPMRICHOP_ELSE    = 5,
    RPMRICHOP_WITH    = 6,
    RPMRICHOP_WITHOUT = 7,
    RPMRICHOP_UNLESS  = 8
} rpmrichOp;
 
typedef enum rpmrichParseType_e {
    RPMRICH_PARSE_SIMPLE = 1,   /* standard N <=> EVR dep */
    RPMRICH_PARSE_ENTER  = 2,   /* entering sub-dependency */
    RPMRICH_PARSE_LEAVE  = 3,   /* leaving sub-dependency */
    RPMRICH_PARSE_OP     = 4    /* parsed a rich dependency op */
} rpmrichParseType;
 
typedef rpmRC (*rpmrichParseFunction) (void *cbdata, rpmrichParseType type,
                         const char *n, int nl, const char *e, int el, rpmsenseFlags sense,
                         rpmrichOp op, char **emsg);
 
rpmRC rpmrichParse(const char **dstrp, char **emsg, rpmrichParseFunction cb, void *cbdata);
 
rpmRC rpmrichParseForTag(const char **dstrp, char **emsg, rpmrichParseFunction cb, void *cbdata, rpmTagVal tagN);
 
 
int rpmdsIsRich(rpmds dep);
 
const char *rpmrichOpStr(rpmrichOp op);
 
rpmRC rpmdsParseRichDep(rpmds dep, rpmds *leftds, rpmds *rightds, rpmrichOp *op, char **emsg);
 
#ifdef __cplusplus
}
#endif
 
#endif  /* H_RPMDS */