int rpmPkgSign(const char *path, const struct rpmSignArgs * args) { int rc; if (args) { if (args->hashalgo) { char *algo = NULL; rasprintf(&algo, "%d", args->hashalgo); addMacro(NULL, "_gpg_digest_algo", NULL, algo, RMIL_GLOBAL); free(algo); } if (args->keyid) { addMacro(NULL, "_gpg_name", NULL, args->keyid, RMIL_GLOBAL); } } rc = rpmSign(path, 0, args->signfiles); if (args) { if (args->hashalgo) { delMacro(NULL, "_gpg_digest_algo"); } if (args->keyid) { delMacro(NULL, "_gpg_name"); } } return rc; }
int main(int argc, char *argv[]) { poptContext con = rpmioInit(argc, argv, optionsTable); ARGV_t av = poptGetArgs(con); int ac = argvCount(av);; const char ** keyids = NULL; int ec = 0; int xx; _rpmhkp_lvl = RPMLOG_INFO; /* XXX default is RPMLOG_DEBUG */ if (_hkp_keyserver == NULL) _hkp_keyserver = xstrdup("keys.rpm5.org"); if (_rpmhkp_spew) _rpmhkp_debug = -1; /* XXX no macros are loaded if using poptIO. */ addMacro(NULL, "_hkp_keyserver", NULL, _hkp_keyserver, -1); addMacro(NULL, "_hkp_keyserver_query", NULL, _hkp_keyserver_query, -1); if (ac == 0) { xx = argvAppend(&keyids, _keyids); } else { int gotstdin = 0; int i; for (i = 0; i < ac; i++) { if (strcmp(av[i], "-")) { xx = argvAdd(&keyids, (ARGstr_t)av[i]); continue; } if (gotstdin) continue; gotstdin++; if (argvFgets(&keyids, NULL)) goto exit; } } ec = rpmhkpReadKeys(keyids); if (_rpmhkp_stats) _rpmhkpPrintStats(NULL); exit: keyids = argvFree(keyids); _hkp_keyserver = _free(_hkp_keyserver); /*@i@*/ urlFreeCache(); con = rpmioFini(con); return ec; }
/* TODO: permit overriding macro setup on the command line */ static int doSign(poptContext optCon) { int rc = EXIT_FAILURE; char * passPhrase = NULL; char * name = rpmExpand("%{?_gpg_name}", NULL); struct rpmSignArgs sig = {NULL, 0, 0}; char *key = NULL; if (rstreq(name, "")) { fprintf(stderr, _("You must set \"%%_gpg_name\" in your macro file\n")); goto exit; } if (fileSigningKey) { addMacro(NULL, "_file_signing_key", NULL, fileSigningKey, RMIL_GLOBAL); } if (signfiles) { key = rpmExpand("%{?_file_signing_key}", NULL); if (rstreq(key, "")) { fprintf(stderr, _("You must set \"$$_file_signing_key\" in your macro file or on the command line with --fskpath\n")); goto exit; } if (fskpass) { #ifndef WITH_IMAEVM argerror(_("--fskpass may only be specified when signing files")); #else fileSigningKeyPassword = get_fskpass(); #endif } addMacro(NULL, "_file_signing_key_password", NULL, fileSigningKeyPassword, RMIL_CMDLINE); if (fileSigningKeyPassword) { memset(fileSigningKeyPassword, 0, strlen(fileSigningKeyPassword)); free(fileSigningKeyPassword); } sig.signfiles = 1; } const char *arg; rc = 0; while ((arg = poptGetArg(optCon)) != NULL) { rc += rpmPkgSign(arg, &sig); } exit: free(key); free(passPhrase); free(name); return rc; }
/** * Define or undefine per-header macros. * @param h header * @param define define/undefine? * @return 0 always */ static void rpmInstallLoadMacros(Header h, int define) { const struct tagMacro * tagm; for (tagm = tagMacros; tagm->macroname != NULL; tagm++) { struct rpmtd_s td; char *body; if (!headerGet(h, tagm->tag, &td, HEADERGET_DEFAULT)) continue; /* * Undefine doesn't need the actual data for anything, but * this way ensures we only undefine what was defined earlier. */ switch (rpmtdType(&td)) { default: if (define) { body = rpmtdFormat(&td, RPMTD_FORMAT_STRING, NULL); addMacro(NULL, tagm->macroname, NULL, body, -1); free(body); } else { delMacro(NULL, tagm->macroname); } break; case RPM_NULL_TYPE: break; } rpmtdFreeData(&td); } }
// // SourceTokenizerC::doCommand_define // void SourceTokenizerC::doCommand_define(SourceTokenC *) { SourceTokenC::Reference name = getRaw(); doAssert(name, SourceTokenC::TT_NAM); if (inStack.back()->peek() == '(') { MacroData data; doAssert(getRaw(), SourceTokenC::TT_PAREN_O); SourceTokenC::Reference arg = getRaw(); if (arg->type != SourceTokenC::TT_PAREN_C) for (;;) { if (arg->type == SourceTokenC::TT_DOT3) { data.first.push_back(std::string()); doAssert((arg = getRaw()), SourceTokenC::TT_PAREN_C); break; } doAssert(arg, SourceTokenC::TT_NAM); data.first.push_back(arg->data); if ((arg = getRaw())->type == SourceTokenC::TT_PAREN_C) break; doAssert(arg, SourceTokenC::TT_COMMA); arg = getRaw(); } inStack.back()->disableQuote(); for (char c; (c = inStack.back()->get()) != '\n';) data.second += c; inStack.back()->enableQuote(); inStack.back()->unget('\n'); if (isSkip()) return; addMacro(name->data, data); } else { std::string data; inStack.back()->disableQuote(); for (char c; (c = inStack.back()->get()) != '\n';) data += c; inStack.back()->enableQuote(); inStack.back()->unget('\n'); if (isSkip()) return; addDefine(name->data, data); } }
PyObject * rpmmacro_AddMacro(PyObject * self, PyObject * args, PyObject * kwds) { char * name, * val; char * kwlist[] = {"name", "value", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ss:AddMacro", kwlist, &name, &val)) return NULL; addMacro(NULL, name, NULL, val, -1); Py_RETURN_NONE; }
void Preprocessor::addMacros() { auto it = lines.begin(); while(it != lines.end()) { if(it->length() > 0 && it->at(0) == '#') { trim(*it); mergeLines(it); size_t size = lines.size(); size_t pos = std::distance(lines.begin(), it); addMacro(it); it = lines.erase(lines.begin() + pos + lines.size() - size); } else ++it; } }
PyObject * rpmmacro_AddMacro(/*@unused@*/ PyObject * s, PyObject * args, PyObject * kwds) { char * name, * val; char * kwlist[] = {"name", "value", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "ss:AddMacro", kwlist, &name, &val)) return NULL; addMacro(NULL, name, NULL, val, -1); Py_INCREF(Py_None); return Py_None; }
static rpmRC replaceSigDigests(FD_t fd, const char *rpm, Header *sigp, off_t sigStart, off_t sigTargetSize, char *SHA1, uint8_t *MD5) { off_t archiveSize; rpmRC rc = RPMRC_OK; if (Fseek(fd, sigStart, SEEK_SET) < 0) { rc = RPMRC_FAIL; rpmlog(RPMLOG_ERR, _("Could not seek in file %s: %s\n"), rpm, Fstrerror(fd)); goto exit; } /* Get payload size from signature tag */ archiveSize = headerGetNumber(*sigp, RPMSIGTAG_PAYLOADSIZE); if (!archiveSize) { archiveSize = headerGetNumber(*sigp, RPMSIGTAG_LONGARCHIVESIZE); } /* Set reserved space to 0 */ addMacro(NULL, "__gpg_reserved_space", NULL, 0, RMIL_GLOBAL); /* Replace old digests in sigh */ rc = rpmGenerateSignature(SHA1, MD5, sigTargetSize, archiveSize, fd); if (rc != RPMRC_OK) { rpmlog(RPMLOG_ERR, _("generateSignature failed\n")); goto exit; } if (Fseek(fd, sigStart, SEEK_SET) < 0) { rc = RPMRC_FAIL; rpmlog(RPMLOG_ERR, _("Could not seek in file %s: %s\n"), rpm, Fstrerror(fd)); goto exit; } headerFree(*sigp); rc = rpmReadSignature(fd, sigp, RPMSIGTYPE_HEADERSIG, NULL); if (rc != RPMRC_OK) { rpmlog(RPMLOG_ERR, _("rpmReadSignature failed\n")); goto exit; } exit: return rc; }
/** * Dispatch an inbound operation to this service manager. * * @param message The message to process. */ void ServerMacroSpaceManager::dispatch(ServiceMessage &message) { switch (message.operation) { case ADD_MACRO: addMacro(message); break; case ITERATE_MACRO_DESCRIPTORS: iterateMacros(message); break; case NEXT_MACRO_DESCRIPTOR: nextDescriptor(message); break; case GET_MACRO_IMAGE: getImage(message); break; case GET_MACRO_DESCRIPTOR: getDescriptor(message); break; case CLEAR_MACRO_SPACE: clear(message); break; case REMOVE_MACRO: deleteMacro(message); break; case QUERY_MACRO: queryMacro(message); break; case REORDER_MACRO: reorderMacro(message); break; case ITERATE_MACROS: iterateMacros(message); break; case NEXT_MACRO_IMAGE: nextImage(message); break; default: message.setExceptionInfo(INVALID_OPERATION, "Invalid macro space manager operation"); break; } }
void rpmLoadMacros(rpmMacroContext mc, int level) { if (mc == NULL || mc == rpmGlobalMacroContext) return; if (mc->macroTable != NULL) { int i; for (i = 0; i < mc->firstFree; i++) { rpmMacroEntry *mep, me; mep = &mc->macroTable[i]; me = *mep; if (me == NULL) /* XXX this should never happen */ continue; addMacro(NULL, me->name, me->opts, me->body, (level - 1)); } } }
/** * Define per-header macros. * @param h header * @return 0 always */ static void rpmInstallLoadMacros(Header h) { const struct tagMacro * tagm; for (tagm = tagMacros; tagm->macroname != NULL; tagm++) { struct rpmtd_s td; char *body; if (!headerGet(h, tagm->tag, &td, HEADERGET_DEFAULT)) continue; switch (rpmtdType(&td)) { default: body = rpmtdFormat(&td, RPMTD_FORMAT_STRING, NULL); addMacro(NULL, tagm->macroname, NULL, body, -1); free(body); break; case RPM_NULL_TYPE: break; } rpmtdFreeData(&td); } }
/** * The main macro recursion loop. * @todo Dynamically reallocate target buffer. * @param mb macro expansion state * @return 0 on success, 1 on failure */ static int expandMacro(MacroBuf mb) { rpmMacroEntry *mep; rpmMacroEntry me; const char *s = mb->s, *se; const char *f, *fe; const char *g, *ge; size_t fn, gn; char *t = mb->t; /* save expansion pointer for printExpand */ int c; int rc = 0; int negate; const char * lastc; int chkexist; if (++mb->depth > max_macro_depth) { rpmlog(RPMLOG_ERR, _("Recursion depth(%d) greater than max(%d)\n"), mb->depth, max_macro_depth); mb->depth--; mb->expand_trace = 1; return 1; } while (rc == 0 && mb->nb > 0 && (c = *s) != '\0') { s++; /* Copy text until next macro */ switch(c) { case '%': if (*s) { /* Ensure not end-of-string. */ if (*s != '%') break; s++; /* skip first % in %% */ } default: SAVECHAR(mb, c); continue; break; } /* Expand next macro */ f = fe = NULL; g = ge = NULL; if (mb->depth > 1) /* XXX full expansion for outermost level */ t = mb->t; /* save expansion pointer for printExpand */ negate = 0; lastc = NULL; chkexist = 0; switch ((c = *s)) { default: /* %name substitution */ while (strchr("!?", *s) != NULL) { switch(*s++) { case '!': negate = ((negate + 1) % 2); break; case '?': chkexist++; break; } } f = se = s; if (*se == '-') se++; while((c = *se) && (risalnum(c) || c == '_')) se++; /* Recognize non-alnum macros too */ switch (*se) { case '*': se++; if (*se == '*') se++; break; case '#': se++; break; default: break; } fe = se; /* For "%name " macros ... */ if ((c = *fe) && isblank(c)) if ((lastc = strchr(fe,'\n')) == NULL) lastc = strchr(fe, '\0'); break; case '(': /* %(...) shell escape */ if ((se = matchchar(s, c, ')')) == NULL) { rpmlog(RPMLOG_ERR, _("Unterminated %c: %s\n"), (char)c, s); rc = 1; continue; } if (mb->macro_trace) printMacro(mb, s, se+1); s++; /* skip ( */ rc = doShellEscape(mb, s, (se - s)); se++; /* skip ) */ s = se; continue; break; case '{': /* %{...}/%{...:...} substitution */ if ((se = matchchar(s, c, '}')) == NULL) { rpmlog(RPMLOG_ERR, _("Unterminated %c: %s\n"), (char)c, s); rc = 1; continue; } f = s+1;/* skip { */ se++; /* skip } */ while (strchr("!?", *f) != NULL) { switch(*f++) { case '!': negate = ((negate + 1) % 2); break; case '?': chkexist++; break; } } for (fe = f; (c = *fe) && !strchr(" :}", c);) fe++; switch (c) { case ':': g = fe + 1; ge = se - 1; break; case ' ': lastc = se-1; break; default: break; } break; } /* XXX Everything below expects fe > f */ fn = (fe - f); gn = (ge - g); if ((fe - f) <= 0) { /* XXX Process % in unknown context */ c = '%'; /* XXX only need to save % */ SAVECHAR(mb, c); #if 0 rpmlog(RPMLOG_ERR, _("A %% is followed by an unparseable macro\n")); #endif s = se; continue; } if (mb->macro_trace) printMacro(mb, s, se); /* Expand builtin macros */ if (STREQ("global", f, fn)) { s = doDefine(mb, se, RMIL_GLOBAL, 1); continue; } if (STREQ("define", f, fn)) { s = doDefine(mb, se, mb->depth, 0); continue; } if (STREQ("undefine", f, fn)) { s = doUndefine(mb->mc, se); continue; } if (STREQ("echo", f, fn) || STREQ("warn", f, fn) || STREQ("error", f, fn)) { int waserror = 0; if (STREQ("error", f, fn)) waserror = 1; if (g != NULL && g < ge) doOutput(mb, waserror, g, gn); else doOutput(mb, waserror, f, fn); s = se; continue; } if (STREQ("trace", f, fn)) { /* XXX TODO restore expand_trace/macro_trace to 0 on return */ mb->expand_trace = mb->macro_trace = (negate ? 0 : mb->depth); if (mb->depth == 1) { print_macro_trace = mb->macro_trace; print_expand_trace = mb->expand_trace; } s = se; continue; } if (STREQ("dump", f, fn)) { rpmDumpMacroTable(mb->mc, NULL); while (iseol(*se)) se++; s = se; continue; } #ifdef WITH_LUA if (STREQ("lua", f, fn)) { rpmlua lua = NULL; /* Global state. */ const char *ls = s+sizeof("{lua:")-1; const char *lse = se-sizeof("}")+1; char *scriptbuf = (char *)xmalloc((lse-ls)+1); const char *printbuf; memcpy(scriptbuf, ls, lse-ls); scriptbuf[lse-ls] = '\0'; rpmluaSetPrintBuffer(lua, 1); if (rpmluaRunScript(lua, scriptbuf, NULL) == -1) rc = 1; printbuf = rpmluaGetPrintBuffer(lua); if (printbuf) { size_t len = strlen(printbuf); if (len > mb->nb) len = mb->nb; memcpy(mb->t, printbuf, len); mb->t += len; mb->nb -= len; } rpmluaSetPrintBuffer(lua, 0); free(scriptbuf); s = se; continue; } #endif /* XXX necessary but clunky */ if (STREQ("basename", f, fn) || STREQ("suffix", f, fn) || STREQ("expand", f, fn) || STREQ("verbose", f, fn) || STREQ("uncompress", f, fn) || STREQ("url2path", f, fn) || STREQ("u2p", f, fn) || STREQ("getenv", f, fn) || STREQ("S", f, fn) || STREQ("P", f, fn) || STREQ("F", f, fn)) { /* FIX: verbose may be set */ doFoo(mb, negate, f, fn, g, gn); s = se; continue; } /* Expand defined macros */ mep = findEntry(mb->mc, f, fn); me = (mep ? *mep : NULL); /* XXX Special processing for flags */ if (*f == '-') { if (me) me->used++; /* Mark macro as used */ if ((me == NULL && !negate) || /* Without -f, skip %{-f...} */ (me != NULL && negate)) { /* With -f, skip %{!-f...} */ s = se; continue; } if (g && g < ge) { /* Expand X in %{-f:X} */ rc = expandT(mb, g, gn); } else if (me && me->body && *me->body) {/* Expand %{-f}/%{-f*} */ rc = expandT(mb, me->body, strlen(me->body)); } s = se; continue; } /* XXX Special processing for macro existence */ if (chkexist) { if ((me == NULL && !negate) || /* Without -f, skip %{?f...} */ (me != NULL && negate)) { /* With -f, skip %{!?f...} */ s = se; continue; } if (g && g < ge) { /* Expand X in %{?f:X} */ rc = expandT(mb, g, gn); } else if (me && me->body && *me->body) { /* Expand %{?f}/%{?f*} */ rc = expandT(mb, me->body, strlen(me->body)); } s = se; continue; } if (me == NULL) { /* leave unknown %... as is */ #ifndef HACK #if DEAD /* XXX hack to skip over empty arg list */ if (fn == 1 && *f == '*') { s = se; continue; } #endif /* XXX hack to permit non-overloaded %foo to be passed */ c = '%'; /* XXX only need to save % */ SAVECHAR(mb, c); #else rpmlog(RPMLOG_ERR, _("Macro %%%.*s not found, skipping\n"), fn, f); s = se; #endif continue; } /* Setup args for "%name " macros with opts */ if (me && me->opts != NULL) { if (lastc != NULL) { se = grabArgs(mb, me, fe, lastc); } else { addMacro(mb->mc, "**", NULL, "", mb->depth); addMacro(mb->mc, "*", NULL, "", mb->depth); addMacro(mb->mc, "#", NULL, "0", mb->depth); addMacro(mb->mc, "0", NULL, me->name, mb->depth); } } /* Recursively expand body of macro */ if (me->body && *me->body) { mb->s = me->body; rc = expandMacro(mb); if (rc == 0) me->used++; /* Mark macro as used */ } /* Free args for "%name " macros with opts */ if (me->opts != NULL) freeArgs(mb); s = se; } *mb->t = '\0'; mb->s = s; mb->depth--; if (rc != 0 || mb->expand_trace) printExpansion(mb, t, mb->t); return rc; }
void Driver::setupLexer( Lexer * lexer ) { // stl lexer->addSkipWord( "__STL_BEGIN_NAMESPACE" ); lexer->addSkipWord( "__STL_END_NAMESPACE" ); lexer->addSkipWord( "__STL_BEGIN_RELOPS_NAMESPACE" ); lexer->addSkipWord( "__STL_END_RELOPS_NAMESPACE" ); lexer->addSkipWord( "__STL_TEMPLATE_NULL" ); lexer->addSkipWord( "__STL_TRY" ); lexer->addSkipWord( "__STL_UNWIND" ); lexer->addSkipWord( "__STL_NOTHROW" ); lexer->addSkipWord( "__STL_NULL_TMPL_ARGS" ); lexer->addSkipWord( "__STL_UNWIND", SkipWordAndArguments ); lexer->addSkipWord( "__GC_CONST" ); lexer->addSkipWord( "__HASH_ALLOC_INIT", SkipWordAndArguments ); lexer->addSkipWord( "__STL_DEFAULT_ALLOCATOR", SkipWordAndArguments, "T" ); lexer->addSkipWord( "__STL_MUTEX_INITIALIZER" ); lexer->addSkipWord( "__STL_NULL_TMPL_ARGS" ); // antlr lexer->addSkipWord( "ANTLR_BEGIN_NAMESPACE", SkipWordAndArguments ); lexer->addSkipWord( "ANTLR_USE_NAMESPACE", SkipWordAndArguments ); lexer->addSkipWord( "ANTLR_USING_NAMESPACE", SkipWordAndArguments ); lexer->addSkipWord( "ANTLR_END_NAMESPACE" ); lexer->addSkipWord( "ANTLR_C_USING", SkipWordAndArguments ); lexer->addSkipWord( "ANTLR_API" ); // gnu lexer->addSkipWord( "__extension__", SkipWordAndArguments ); lexer->addSkipWord( "__attribute__", SkipWordAndArguments ); lexer->addSkipWord( "__BEGIN_DECLS" ); lexer->addSkipWord( "__END_DECLS" ); lexer->addSkipWord( "__THROW" ); lexer->addSkipWord( "__restrict" ); lexer->addSkipWord( "__restrict__" ); lexer->addSkipWord( "__attribute_pure__" ); lexer->addSkipWord( "__attribute_malloc__" ); lexer->addSkipWord( "__attribute_format_strfmon__" ); lexer->addSkipWord( "__asm__", SkipWordAndArguments ); lexer->addSkipWord( "__devinit" ); lexer->addSkipWord( "__devinit__" ); lexer->addSkipWord( "__init" ); lexer->addSkipWord( "__init__" ); lexer->addSkipWord( "__signed" ); lexer->addSkipWord( "__signed__" ); lexer->addSkipWord( "__unsigned" ); lexer->addSkipWord( "__unsigned__" ); lexer->addSkipWord( "asmlinkage" ); lexer->addSkipWord( "____cacheline_aligned" ); lexer->addSkipWord( "__glibcpp_class_requires", SkipWordAndArguments ); lexer->addSkipWord( "__glibcpp_class2_requires", SkipWordAndArguments ); lexer->addSkipWord( "__glibcpp_class4_requires", SkipWordAndArguments ); lexer->addSkipWord( "__glibcpp_function_requires", SkipWordAndArguments ); lexer->addSkipWord( "restrict" ); lexer->addSkipWord( "__BEGIN_NAMESPACE_STD" ); lexer->addSkipWord( "__END_NAMESPACE_STD" ); lexer->addSkipWord( "__BEGIN_NAMESPACE_C99" ); lexer->addSkipWord( "__END_NAMESPACE_C99" ); lexer->addSkipWord( "__USING_NAMESPACE_STD", SkipWordAndArguments ); // kde lexer->addSkipWord( "K_SYCOCATYPE", SkipWordAndArguments ); lexer->addSkipWord( "EXPORT_DOCKCLASS" ); lexer->addSkipWord( "K_EXPORT_COMPONENT_FACTORY", SkipWordAndArguments ); lexer->addSkipWord( "K_SYCOCAFACTORY", SkipWordAndArguments ); lexer->addSkipWord( "KDE_DEPRECATED" ); // qt lexer->addSkipWord( "Q_OVERRIDE", SkipWordAndArguments ); lexer->addSkipWord( "Q_ENUMS", SkipWordAndArguments ); lexer->addSkipWord( "Q_PROPERTY", SkipWordAndArguments ); lexer->addSkipWord( "Q_CLASSINFO", SkipWordAndArguments ); lexer->addSkipWord( "Q_SETS", SkipWordAndArguments ); lexer->addSkipWord( "Q_UNUSED", SkipWordAndArguments ); lexer->addSkipWord( "Q_CREATE_INSTANCE", SkipWordAndArguments ); lexer->addSkipWord( "Q_DUMMY_COMPARISON_OPERATOR", SkipWordAndArguments ); lexer->addSkipWord( "ACTIVATE_SIGNAL_WITH_PARAM", SkipWordAndArguments ); lexer->addSkipWord( "Q_INLINE_TEMPLATES" ); lexer->addSkipWord( "Q_TEMPLATE_EXTERN" ); lexer->addSkipWord( "Q_TYPENAME" ); lexer->addSkipWord( "Q_REFCOUNT" ); lexer->addSkipWord( "Q_EXPLICIT" ); lexer->addSkipWord( "QMAC_PASCAL" ); lexer->addSkipWord( "QT_STATIC_CONST" ); lexer->addSkipWord( "QT_STATIC_CONST_IMPL" ); lexer->addSkipWord( "QT_WIN_PAINTER_MEMBERS" ); lexer->addSkipWord( "QT_NC_MSGBOX" ); lexer->addSkipWord( "Q_VARIANT_AS", SkipWordAndArguments ); lexer->addSkipWord( "CALLBACK_CALL_TYPE" ); // flex lexer->addSkipWord( "yyconst" ); lexer->addSkipWord( "YY_RULE_SETUP" ); lexer->addSkipWord( "YY_BREAK" ); lexer->addSkipWord( "YY_RESTORE_YY_MORE_OFFSET" ); // gtk lexer->addSkipWord( "G_BEGIN_DECLS" ); lexer->addSkipWord( "G_END_DECLS" ); lexer->addSkipWord( "G_GNUC_CONST" ); lexer->addSkipWord( "G_CONST_RETURN" ); lexer->addSkipWord( "GTKMAIN_C_VAR" ); lexer->addSkipWord( "GTKVAR" ); lexer->addSkipWord( "GDKVAR" ); lexer->addSkipWord( "G_GNUC_PRINTF", SkipWordAndArguments ); // windows lexer->addSkipWord( "WINAPI" ); lexer->addSkipWord( "__stdcall" ); lexer->addSkipWord( "__cdecl" ); lexer->addSkipWord( "_cdecl" ); lexer->addSkipWord( "CALLBACK" ); // gcc extensions addMacro( Macro("__asm__", "asm") ); addMacro( Macro("__inline", "inline") ); addMacro( Macro("__inline__", "inline") ); addMacro( Macro("__const", "const") ); addMacro( Macro("__const__", "const") ); addMacro( Macro("__volatile__", "volatile") ); addMacro( Macro("__complex__", "") ); }
/** * Parse %setup macro. * @todo FIXME: Option -q broken when not immediately after %setup. * @param spec build info * @param line current line from spec file * @return 0 on success */ static int doSetupMacro(Spec spec, const char * line) /*@globals rpmGlobalMacroContext, h_errno, fileSystem, internalState @*/ /*@modifies spec->buildSubdir, spec->macros, spec->prep, spec->packages->header, rpmGlobalMacroContext, fileSystem, internalState @*/ { char buf[BUFSIZ]; rpmiob before = NULL; rpmiob after = NULL; poptContext optCon; int argc; const char ** argv; int arg; const char * optArg; int rc; rpmuint32_t num; rpmRC ec = RPMRC_FAIL; /* XXX assume failure */ /*@-mods@*/ leaveDirs = skipDefaultAction = 0; createDir = quietly = 0; dirName = NULL; /*@=mods@*/ if ((rc = poptParseArgvString(line, &argc, &argv))) { rpmlog(RPMLOG_ERR, _("Error parsing %%setup: %s\n"), poptStrerror(rc)); goto exit; } before = rpmiobNew(0); after = rpmiobNew(0); optCon = poptGetContext(NULL, argc, argv, optionsTable, 0); while ((arg = poptGetNextOpt(optCon)) > 0) { optArg = poptGetOptArg(optCon); /* We only parse -a and -b here */ if (parseNum(optArg, &num)) { rpmlog(RPMLOG_ERR, _("line %d: Bad arg to %%setup: %s\n"), spec->lineNum, (optArg ? optArg : "???")); optCon = poptFreeContext(optCon); argv = _free(argv); goto exit; } { const char *chptr = doUntar(spec, num, quietly); if (chptr == NULL) goto exit; (void) rpmiobAppend((arg == 'a' ? after : before), chptr, 1); } } if (arg < -1) { rpmlog(RPMLOG_ERR, _("line %d: Bad %%setup option %s: %s\n"), spec->lineNum, poptBadOption(optCon, POPT_BADOPTION_NOALIAS), poptStrerror(arg)); optCon = poptFreeContext(optCon); argv = _free(argv); goto exit; } if (dirName) { spec->buildSubdir = xstrdup(dirName); } else { const char *N, *V; (void) headerNEVRA(spec->packages->header, &N, NULL, &V, NULL, NULL); (void) snprintf(buf, sizeof(buf), "%s-%s", N, V); buf[sizeof(buf)-1] = '\0'; N = _free(N); V = _free(V); spec->buildSubdir = xstrdup(buf); } addMacro(spec->macros, "buildsubdir", NULL, spec->buildSubdir, RMIL_SPEC); optCon = poptFreeContext(optCon); argv = _free(argv); /* cd to the build dir */ { const char * buildDirURL = rpmGenPath(spec->rootURL, "%{_builddir}", ""); const char *buildDir; (void) urlPath(buildDirURL, &buildDir); rc = rpmioMkpath(buildDir, 0755, -1, -1); sprintf(buf, "cd '%s'", buildDir); spec->prep = rpmiobAppend(spec->prep, buf, 1); buildDirURL = _free(buildDirURL); } /* delete any old sources */ if (!leaveDirs) { sprintf(buf, "rm -rf '%s'", spec->buildSubdir); spec->prep = rpmiobAppend(spec->prep, buf, 1); } /* check if source is a ruby gem */ { struct Source *sp; for (sp = spec->sources; sp != NULL; sp = sp->next) { if ((sp->flags & RPMFILE_SOURCE) && (sp->num == 0)) { break; } } if (sp != NULL) { char *t = strrchr(sp->source, '.'); if(t && !strcasecmp(t, ".gem")) createDir = 1; } } /* if necessary, create and cd into the proper dir */ if (createDir) { char *mkdir_p; mkdir_p = rpmExpand("%{?__mkdir_p}%{!?__mkdir_p:mkdir -p}", NULL); if (!mkdir_p) mkdir_p = xstrdup("mkdir -p"); sprintf(buf, "%s '%s'\ncd '%s'", mkdir_p, spec->buildSubdir, spec->buildSubdir); mkdir_p = _free(mkdir_p); spec->prep = rpmiobAppend(spec->prep, buf, 1); } /* do the default action */ if (!createDir && !skipDefaultAction) { const char *chptr = doUntar(spec, 0, quietly); if (chptr == NULL) goto exit; spec->prep = rpmiobAppend(spec->prep, chptr, 1); } spec->prep = rpmiobAppend(spec->prep, rpmiobStr(before), 0); if (!createDir) { sprintf(buf, "cd '%s'", spec->buildSubdir); spec->prep = rpmiobAppend(spec->prep, buf, 1); } if (createDir && !skipDefaultAction) { const char * chptr = doUntar(spec, 0, quietly); if (chptr == NULL) goto exit; spec->prep = rpmiobAppend(spec->prep, chptr, 1); } spec->prep = rpmiobAppend(spec->prep, rpmiobStr(after), 0); /* XXX FIXME: owner & group fixes were conditioned on !geteuid() */ /* Fix the owner, group, and permissions of the setup build tree */ { /*@observer@*/ static const char *fixmacs[] = { "%{_fixowner}", "%{_fixgroup}", "%{_fixperms}", NULL }; const char ** fm; for (fm = fixmacs; *fm; fm++) { const char *fix; fix = rpmExpand(*fm, " .", NULL); if (fix && *fix != '%') spec->prep = rpmiobAppend(spec->prep, fix, 1); fix = _free(fix); } } ec = RPMRC_OK; exit: before = rpmiobFree(before); after = rpmiobFree(after); return ec; }
void FixupSelfReferentialMacrosInAST::visit ( SgNode* node ) { // DQ (3/11/2006): Set NULL pointers where we would like to have none. // printf ("In FixupSelfReferentialMacrosInAST::visit(): node = %s \n",node->class_name().c_str()); ROSE_ASSERT(node != NULL); switch (node->variantT()) { case V_SgInitializedName: { SgInitializedName* initializedName = isSgInitializedName(node); ROSE_ASSERT(initializedName != NULL); SgType* type = initializedName->get_type()->stripType(); SgClassType* classType = isSgClassType(type); if (classType != NULL) { SgClassDeclaration* targetClassDeclaration = isSgClassDeclaration(classType->get_declaration()); SgName className = targetClassDeclaration->get_name(); // printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a class declaration name = %s \n",className.str()); // For sudo_exec_pty.c also look for siginfo if (className == "sigaction" || className == "siginfo") { // printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a sigaction type \n"); // Note we could also check that the declaration came from a known header file. SgStatement* associatedStatement = isSgStatement(initializedName->get_parent()); if (associatedStatement != NULL) { // Add a macro to undefine the "#define sa_handler __sigaction_handler.sa_handler" macro. // printf ("In FixupSelfReferentialMacrosInAST::visit(): Add a macro to undefine the macro #define sa_handler __sigaction_handler.sa_handler \n"); // PreprocessingInfo* macro = new PreprocessingInfo(DirectiveType, const std::string & inputString,const std::string & filenameString, int line_no , int col_no,int nol, RelativePositionType relPos ); PreprocessingInfo::DirectiveType directiveType = PreprocessingInfo::CpreprocessorUndefDeclaration; // We are puting out all macros anytime we see either type. This might be too much... // From the sigaction.h file (included by signal.h): addMacro(associatedStatement,"#undef sa_handler\n",directiveType); addMacro(associatedStatement,"#undef sa_sigaction\n",directiveType); // From the siginfo.h file (included by signal.h): addMacro(associatedStatement,"#undef si_pid\n", directiveType); addMacro(associatedStatement,"#undef si_uid\n", directiveType); addMacro(associatedStatement,"#undef si_timerid\n",directiveType); addMacro(associatedStatement,"#undef si_overrun\n",directiveType); addMacro(associatedStatement,"#undef si_status\n", directiveType); addMacro(associatedStatement,"#undef si_utime\n", directiveType); addMacro(associatedStatement,"#undef si_stime\n", directiveType); addMacro(associatedStatement,"#undef si_value\n", directiveType); addMacro(associatedStatement,"#undef si_int\n", directiveType); addMacro(associatedStatement,"#undef si_ptr\n", directiveType); addMacro(associatedStatement,"#undef si_addr\n", directiveType); addMacro(associatedStatement,"#undef si_band\n", directiveType); addMacro(associatedStatement,"#undef si_fd\n", directiveType); } } } } default: { // printf ("Not handled in FixupSelfReferentialMacrosInAST::visit(%s) \n",node->class_name().c_str()); } } }
static int runGPG(sigTarget sigt, const char *sigfile) { int pid = 0, status; FD_t fnamedPipe = NULL; char *namedPipeName = NULL; unsigned char buf[BUFSIZ]; ssize_t count; ssize_t wantCount; rpm_loff_t size; int rc = 1; /* assume failure */ namedPipeName = mkTempFifo(); addMacro(NULL, "__plaintext_filename", NULL, namedPipeName, -1); addMacro(NULL, "__signature_filename", NULL, sigfile, -1); if (!(pid = fork())) { char *const *av; char *cmd = NULL; const char *gpg_path = rpmExpand("%{?_gpg_path}", NULL); if (gpg_path && *gpg_path != '\0') (void) setenv("GNUPGHOME", gpg_path, 1); unsetenv("MALLOC_CHECK_"); cmd = rpmExpand("%{?__gpg_sign_cmd}", NULL); rc = poptParseArgvString(cmd, NULL, (const char ***)&av); if (!rc) rc = execve(av[0], av+1, environ); rpmlog(RPMLOG_ERR, _("Could not exec %s: %s\n"), "gpg", strerror(errno)); _exit(EXIT_FAILURE); } delMacro(NULL, "__plaintext_filename"); delMacro(NULL, "__signature_filename"); fnamedPipe = Fopen(namedPipeName, "w"); if (!fnamedPipe) { rpmlog(RPMLOG_ERR, _("Fopen failed\n")); goto exit; } if (Fseek(sigt->fd, sigt->start, SEEK_SET) < 0) { rpmlog(RPMLOG_ERR, _("Could not seek in file %s: %s\n"), sigt->fileName, Fstrerror(sigt->fd)); goto exit; } size = sigt->size; wantCount = size < sizeof(buf) ? size : sizeof(buf); while ((count = Fread(buf, sizeof(buf[0]), wantCount, sigt->fd)) > 0) { Fwrite(buf, sizeof(buf[0]), count, fnamedPipe); if (Ferror(fnamedPipe)) { rpmlog(RPMLOG_ERR, _("Could not write to pipe\n")); goto exit; } size -= count; wantCount = size < sizeof(buf) ? size : sizeof(buf); } if (count < 0) { rpmlog(RPMLOG_ERR, _("Could not read from file %s: %s\n"), sigt->fileName, Fstrerror(sigt->fd)); goto exit; } Fclose(fnamedPipe); fnamedPipe = NULL; (void) waitpid(pid, &status, 0); pid = 0; if (!WIFEXITED(status) || WEXITSTATUS(status)) { rpmlog(RPMLOG_ERR, _("gpg exec failed (%d)\n"), WEXITSTATUS(status)); } else { rc = 0; } exit: if (fnamedPipe) Fclose(fnamedPipe); if (pid) waitpid(pid, &status, 0); if (namedPipeName) { rpmRmTempFifo(namedPipeName); free(namedPipeName); } return rc; }
/* * @todo Single use by %%doc in files.c prevents static. */ rpmRC doScript(Spec spec, int what, const char *name, rpmiob iob, int test) { const char * rootURL = spec->rootURL; const char * rootDir; const char * scriptName = NULL; const char * buildDirURL = rpmGenPath(rootURL, "%{_builddir}", ""); const char * buildScript; const char * buildCmd = NULL; const char * buildTemplate = NULL; const char * buildPost = NULL; const char * mTemplate = NULL; const char * mCmd = NULL; const char * mPost = NULL; int argc = 0; const char **argv = NULL; FILE * fp = NULL; urlinfo u = NULL; rpmop op = NULL; int ix = -1; FD_t fd; FD_t xfd; int status; rpmRC rc; size_t i; switch (what) { case RPMBUILD_PREP: name = "%prep"; iob = spec->prep; op = memset(alloca(sizeof(*op)), 0, sizeof(*op)); ix = RPMSCRIPT_PREP; mTemplate = "%{__spec_prep_template}"; mPost = "%{__spec_prep_post}"; mCmd = "%{__spec_prep_cmd}"; break; case RPMBUILD_BUILD: name = "%build"; iob = spec->build; op = memset(alloca(sizeof(*op)), 0, sizeof(*op)); ix = RPMSCRIPT_BUILD; mTemplate = "%{__spec_build_template}"; mPost = "%{__spec_build_post}"; mCmd = "%{__spec_build_cmd}"; break; case RPMBUILD_INSTALL: name = "%install"; iob = spec->install; op = memset(alloca(sizeof(*op)), 0, sizeof(*op)); ix = RPMSCRIPT_INSTALL; mTemplate = "%{__spec_install_template}"; mPost = "%{__spec_install_post}"; mCmd = "%{__spec_install_cmd}"; break; case RPMBUILD_CHECK: name = "%check"; iob = spec->check; op = memset(alloca(sizeof(*op)), 0, sizeof(*op)); ix = RPMSCRIPT_CHECK; mTemplate = "%{__spec_check_template}"; mPost = "%{__spec_check_post}"; mCmd = "%{__spec_check_cmd}"; break; case RPMBUILD_CLEAN: name = "%clean"; iob = spec->clean; mTemplate = "%{__spec_clean_template}"; mPost = "%{__spec_clean_post}"; mCmd = "%{__spec_clean_cmd}"; break; case RPMBUILD_RMBUILD: name = "--clean"; mTemplate = "%{__spec_clean_template}"; mPost = "%{__spec_clean_post}"; mCmd = "%{__spec_clean_cmd}"; break; /* support "%track" script/section */ case RPMBUILD_TRACK: name = "%track"; iob = NULL; if (spec->foo) for (i = 0; i < spec->nfoo; i++) { if (spec->foo[i].str == NULL || spec->foo[i].iob == NULL) continue; if (xstrcasecmp(spec->foo[i].str, "track")) continue; iob = spec->foo[i].iob; /*@loopbreak@*/ break; } mTemplate = "%{__spec_track_template}"; mPost = "%{__spec_track_post}"; mCmd = "%{__spec_track_cmd}"; break; case RPMBUILD_STRINGBUF: default: mTemplate = "%{___build_template}"; mPost = "%{___build_post}"; mCmd = "%{___build_cmd}"; break; } assert(name != NULL); if ((what != RPMBUILD_RMBUILD) && iob == NULL) { rc = RPMRC_OK; goto exit; } if (rpmTempFile(rootURL, &scriptName, &fd) || fd == NULL || Ferror(fd)) { rpmlog(RPMLOG_ERR, _("Unable to open temp file.\n")); rc = RPMRC_FAIL; goto exit; } if (fdGetFp(fd) == NULL) xfd = Fdopen(fd, "w.fpio"); else xfd = fd; /*@-type@*/ /* FIX: cast? */ if ((fp = fdGetFp(xfd)) == NULL) { rc = RPMRC_FAIL; goto exit; } /*@=type@*/ (void) urlPath(rootURL, &rootDir); if (*rootDir == '\0') rootDir = "/"; (void) urlPath(scriptName, &buildScript); buildTemplate = rpmExpand(mTemplate, NULL); buildPost = rpmExpand(mPost, NULL); (void) fputs(buildTemplate, fp); /* support "%track" script/section */ if (what != RPMBUILD_PREP && what != RPMBUILD_RMBUILD && spec->buildSubdir && what != RPMBUILD_TRACK) fprintf(fp, "cd '%s'\n", spec->buildSubdir); if (what == RPMBUILD_RMBUILD) { if (spec->buildSubdir) fprintf(fp, "rm -rf '%s'\n", spec->buildSubdir); } else if (iob != NULL) fprintf(fp, "%s", rpmiobStr(iob)); (void) fputs(buildPost, fp); (void) Fclose(xfd); if (test) { rc = RPMRC_OK; goto exit; } if (buildDirURL && buildDirURL[0] != '/' && (urlSplit(buildDirURL, &u) != 0)) { rc = RPMRC_FAIL; goto exit; } switch (urlType(u)) { case URL_IS_HTTPS: case URL_IS_HTTP: case URL_IS_FTP: addMacro(spec->macros, "_remsh", NULL, "%{__remsh}", RMIL_SPEC); addMacro(spec->macros, "_remhost", NULL, u->host, RMIL_SPEC); if (strcmp(rootDir, "/")) addMacro(spec->macros, "_remroot", NULL, rootDir, RMIL_SPEC); break; case URL_IS_UNKNOWN: case URL_IS_DASH: case URL_IS_PATH: case URL_IS_HKP: default: break; } buildCmd = rpmExpand(mCmd, " ", buildScript, NULL); (void) poptParseArgvString(buildCmd, &argc, &argv); if (what != RPMBUILD_TRACK) /* support "%track" script/section */ rpmlog(RPMLOG_NOTICE, _("Executing(%s): %s\n"), name, buildCmd); /* Run the script with a stopwatch. */ if (op != NULL) (void) rpmswEnter(op, 0); status = rpmsqExecve(argv); if (ix >= 0 && ix < RPMSCRIPT_MAX) spec->sstates[ix] = (RPMSCRIPT_STATE_EXEC | RPMSCRIPT_STATE_REAPED) | (status & 0xffff); if (!WIFEXITED(status) || WEXITSTATUS(status)) { rpmlog(RPMLOG_ERR, _("Bad exit status from %s (%s)\n"), scriptName, name); rc = RPMRC_FAIL; } else rc = RPMRC_OK; if (op != NULL) { static unsigned int scale = 1000; (void) rpmswExit(op, 0); if (ix >= 0 && ix < RPMSCRIPT_MAX) spec->smetrics[ix] += op->usecs / scale; } exit: if (scriptName) { #if defined(RPM_VENDOR_OPENPKG) /* always-remove-tempfiles */ /* Unconditionally remove temporary files ("rpm-tmp.XXXXX") which were generated for the executed scripts. In OpenPKG we run the scripts in debug mode ("set -x") anyway, so we never need to see the whole generated script -- not even if it breaks. Instead we would just have temporary files staying around forever. */ #else if (rc == RPMRC_OK) #endif (void) Unlink(scriptName); scriptName = _free(scriptName); } switch (urlType(u)) { case URL_IS_HTTPS: case URL_IS_HTTP: case URL_IS_FTP: delMacro(spec->macros, "_remsh"); delMacro(spec->macros, "_remhost"); if (strcmp(rootDir, "/")) delMacro(spec->macros, "_remroot"); break; case URL_IS_UNKNOWN: case URL_IS_DASH: case URL_IS_PATH: case URL_IS_HKP: default: break; } argv = _free(argv); buildCmd = _free(buildCmd); buildTemplate = _free(buildTemplate); buildPost = _free(buildPost); buildDirURL = _free(buildDirURL); return rc; }
void FixupSelfReferentialMacrosInAST::visit ( SgNode* node ) { // DQ (3/11/2006): Set NULL pointers where we would like to have none. // printf ("In FixupSelfReferentialMacrosInAST::visit(): node = %s \n",node->class_name().c_str()); ROSE_ASSERT(node != NULL); switch (node->variantT()) { case V_SgInitializedName: { SgInitializedName* initializedName = isSgInitializedName(node); ROSE_ASSERT(initializedName != NULL); SgType* type = initializedName->get_type()->stripType(); SgClassType* classType = isSgClassType(type); if (classType != NULL) { SgClassDeclaration* targetClassDeclaration = isSgClassDeclaration(classType->get_declaration()); SgName className = targetClassDeclaration->get_name(); // printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a class declaration name = %s \n",className.str()); // For sudo_exec_pty.c also look for siginfo if (className == "sigaction" || className == "siginfo") { // printf ("In FixupSelfReferentialMacrosInAST::visit(): Found a sigaction type \n"); // Note we could also check that the declaration came from a known header file. SgStatement* associatedStatement = isSgStatement(initializedName->get_parent()); if (associatedStatement != NULL) { // Add a macro to undefine the "#define sa_handler __sigaction_handler.sa_handler" macro. // printf ("In FixupSelfReferentialMacrosInAST::visit(): Add a macro to undefine the macro #define sa_handler __sigaction_handler.sa_handler \n"); // PreprocessingInfo* macro = new PreprocessingInfo(DirectiveType, const std::string & inputString,const std::string & filenameString, int line_no , int col_no,int nol, RelativePositionType relPos ); PreprocessingInfo::DirectiveType directiveType = PreprocessingInfo::CpreprocessorUndefDeclaration; // We are puting out all macros anytime we see either type. This might be too much... // From the sigaction.h file (included by signal.h): addMacro(associatedStatement,"#undef sa_handler\n",directiveType); addMacro(associatedStatement,"#undef sa_sigaction\n",directiveType); // From the siginfo.h file (included by signal.h): addMacro(associatedStatement,"#undef si_pid\n", directiveType); addMacro(associatedStatement,"#undef si_uid\n", directiveType); addMacro(associatedStatement,"#undef si_timerid\n",directiveType); addMacro(associatedStatement,"#undef si_overrun\n",directiveType); addMacro(associatedStatement,"#undef si_status\n", directiveType); addMacro(associatedStatement,"#undef si_utime\n", directiveType); addMacro(associatedStatement,"#undef si_stime\n", directiveType); addMacro(associatedStatement,"#undef si_value\n", directiveType); addMacro(associatedStatement,"#undef si_int\n", directiveType); addMacro(associatedStatement,"#undef si_ptr\n", directiveType); addMacro(associatedStatement,"#undef si_addr\n", directiveType); addMacro(associatedStatement,"#undef si_band\n", directiveType); addMacro(associatedStatement,"#undef si_fd\n", directiveType); } } } } default: { // printf ("Not handled in FixupSelfReferentialMacrosInAST::visit(%s) \n",node->class_name().c_str()); } } #if 0 // DQ (12/30/2013): Comments and CPP directives have not yet been attached to the AST, so we can't process them here. // SgLocatedNode* locatedNode = isSgLocatedNode(node); // if (locatedNode != NULL) SgStatement* stmt = isSgStatement(node); if (stmt != NULL) { // Find all #define statements and look for self referencing macros int numberOfComments = -1; if (stmt->getAttachedPreprocessingInfo() != NULL) numberOfComments = stmt->getAttachedPreprocessingInfo()->size(); std::string s = std::string(" --- startOfConstruct: file = " ) + stmt->get_startOfConstruct()->get_filenameString() + " raw filename = " + stmt->get_startOfConstruct()->get_raw_filename() + " raw line = " + StringUtility::numberToString(stmt->get_startOfConstruct()->get_raw_line()) + " raw column = " + StringUtility::numberToString(stmt->get_startOfConstruct()->get_raw_col()) + " #comments = " + StringUtility::numberToString(numberOfComments) + " \n "; AttachedPreprocessingInfoType* comments = stmt->getAttachedPreprocessingInfo(); if (comments != NULL) { printf ("Found attached comments (at %p of type: %s): \n",stmt,stmt->class_name().c_str()); AttachedPreprocessingInfoType::iterator i; for (i = comments->begin(); i != comments->end(); i++) { ROSE_ASSERT ( (*i) != NULL ); printf (" Attached Comment (relativePosition=%s): %s\n", ((*i)->getRelativePosition() == PreprocessingInfo::before) ? "before" : "after", (*i)->getString().c_str()); printf ("Comment/Directive getNumberOfLines = %d getColumnNumberOfEndOfString = %d \n",(*i)->getNumberOfLines(),(*i)->getColumnNumberOfEndOfString()); (*i)->get_file_info()->display("comment/directive location"); } } else { printf ("No attached comments (at %p of type: %s): \n",stmt,stmt->class_name().c_str()); } } #endif }
void AbstractDecorator::decorate(const QString &text, int state) { if (text.contains("\n")) { qDebug() << "Wrong block found"; return; } prepare(text); QmlJS::Scanner scanner; QList<QmlJS::Token> tokens = scanner(text, state); for (int i = 0; i < tokens.count(); i++) { const QmlJS::Token token = tokens.at(i); switch (token.kind) { case QmlJS::Token::Keyword: addKeyword(token.offset, token.length); break; case QmlJS::Token::Identifier: { QString entry = text.mid(token.offset, token.length); if (maybeQmlKeyword(entry)) { // check the previous token if (i == 0 || tokens.at(i - 1).isNot(QmlJS::Token::Dot)) { if (i + 1 == tokens.count() || tokens.at(i + 1).isNot(QmlJS::Token::Colon)) { addKeyword(token.offset, token.length); break; } } } else if (i > 0 && maybeQmlBuiltinType(entry)) { const QmlJS::Token &previousToken = tokens.at(i - 1); if (previousToken.is(QmlJS::Token::Identifier) && text.mid(previousToken.offset, previousToken.length) == QLatin1String("property")) { addKeyword(token.offset, token.length); break; } } if (maybeMacro(entry)) { addMacro(token.offset, token.length); break; } if (entry.at(0).isUpper()) { // Check if we are importing a module if (i > 0) { const QmlJS::Token &previousToken = tokens.first(); if (previousToken.is(QmlJS::Token::Identifier) && text.mid(previousToken.offset, previousToken.length) == QLatin1String("import")) { addKeyword(token.offset, token.length); break; } } addComponent(token.offset, token.length); break; } // Try to find if it is a property // The easy ones are followed by a { or a : if (i + 1 < tokens.count()) { const QmlJS::Token &nextToken = tokens.at(i + 1); if (nextToken.is(QmlJS::Token::Colon) || nextToken.is(QmlJS::Token::LeftBrace)) { addIdentifier(token.offset, token.length); break; } } // A harder one is anchors.fill: if (i + 3 < tokens.count()) { const QmlJS::Token &next1Token = tokens.at(i + 1); const QmlJS::Token &next2Token = tokens.at(i + 2); const QmlJS::Token &next3Token = tokens.at(i + 3); if (next1Token.is(QmlJS::Token::Dot) && next2Token.is(QmlJS::Token::Identifier) && (next3Token.is(QmlJS::Token::Colon) || next3Token.is(QmlJS::Token::LeftBrace))) { addIdentifier(token.offset, token.length); break; } } } break; case QmlJS::Token::String: addString(token.offset, token.length); break; case QmlJS::Token::Comment: addComment(token.offset, token.length); break; case QmlJS::Token::Number: addNumber(token.offset, token.length); break; default: break; } } setState(scanner.state()); finalize(); }
static void rpmcliAllArgCallback( poptContext con, enum poptCallbackReason reason, const struct poptOption * opt, const char * arg, const void * data) { /* XXX avoid accidental collisions with POPT_BIT_SET for flags */ if (opt->arg == NULL) switch (opt->val) { case 'q': rpmSetVerbosity(RPMLOG_WARNING); break; case 'v': rpmIncreaseVerbosity(); break; case POPT_PREDEFINE: (void) rpmDefineMacro(NULL, arg, RMIL_CMDLINE); break; case 'D': { char *s, *t; /* XXX Convert '-' in macro name to underscore, skip leading %. */ s = t = xstrdup(arg); while (*t && !risspace(*t)) { if (*t == '-') *t = '_'; t++; } t = s; if (*t == '%') t++; /* XXX Predefine macro if not initialized yet. */ if (rpmcliInitialized < 0) (void) rpmDefineMacro(NULL, t, RMIL_CMDLINE); rpmcliConfigured(); (void) rpmDefineMacro(NULL, t, RMIL_CMDLINE); (void) rpmDefineMacro(rpmCLIMacroContext, t, RMIL_CMDLINE); free(s); break; } case 'E': rpmcliConfigured(); { char *val = rpmExpand(arg, NULL); fprintf(stdout, "%s\n", val); free(val); } break; case POPT_DBPATH: rpmcliConfigured(); addMacro(NULL, "_dbpath", NULL, arg, RMIL_CMDLINE); break; case POPT_SHOWVERSION: printVersion(stdout); exit(EXIT_SUCCESS); break; case POPT_SHOWRC: rpmcliConfigured(); (void) rpmShowRC(stdout); exit(EXIT_SUCCESS); break; case POPT_QUERYTAGS: rpmDisplayQueryTags(stdout); exit(EXIT_SUCCESS); break; case RPMCLI_POPT_NODIGEST: rpmcliQueryFlags |= VERIFY_DIGEST; break; case RPMCLI_POPT_NOSIGNATURE: rpmcliQueryFlags |= VERIFY_SIGNATURE; break; case RPMCLI_POPT_NOHDRCHK: rpmcliQueryFlags |= VERIFY_HDRCHK; break; } }
void MacrosWindow::on_addBtn_clicked() { addMacro("New",""); }
/** * Parse (and execute) new macro definition. * @param mb macro expansion state * @param se macro definition to parse * @param level macro recursion level * @param expandbody should body be expanded? * @return address to continue parsing */ static const char * doDefine(MacroBuf mb, const char * se, int level, int expandbody) { const char *s = se; size_t blen = MACROBUFSIZ; char *buf = xmalloc(blen); char *n = buf, *ne = n; char *o = NULL, *oe; char *b, *be; int c; int oc = ')'; /* Copy name */ COPYNAME(ne, s, c); /* Copy opts (if present) */ oe = ne + 1; if (*s == '(') { s++; /* skip ( */ o = oe; COPYOPTS(oe, s, oc); s++; /* skip ) */ } /* Copy body, skipping over escaped newlines */ b = be = oe + 1; SKIPBLANK(s, c); if (c == '{') { /* XXX permit silent {...} grouping */ if ((se = matchchar(s, c, '}')) == NULL) { rpmlog(RPMLOG_ERR, _("Macro %%%s has unterminated body\n"), n); se = s; /* XXX W2DO? */ return se; } s++; /* XXX skip { */ strncpy(b, s, (se - s)); b[se - s] = '\0'; be += strlen(b); se++; /* XXX skip } */ s = se; /* move scan forward */ } else { /* otherwise free-field */ int bc = 0, pc = 0; while (*s && (bc || pc || !iseol(*s))) { switch (*s) { case '\\': switch (*(s+1)) { case '\0': break; default: s++; break; } break; case '%': switch (*(s+1)) { case '{': *be++ = *s++; bc++; break; case '(': *be++ = *s++; pc++; break; case '%': *be++ = *s++; break; } break; case '{': if (bc > 0) bc++; break; case '}': if (bc > 0) bc--; break; case '(': if (pc > 0) pc++; break; case ')': if (pc > 0) pc--; break; } *be++ = *s++; } *be = '\0'; if (bc || pc) { rpmlog(RPMLOG_ERR, _("Macro %%%s has unterminated body\n"), n); se = s; /* XXX W2DO? */ return se; } /* Trim trailing blanks/newlines */ while (--be >= b && (c = *be) && (isblank(c) || iseol(c))) {}; *(++be) = '\0'; /* one too far */ } /* Move scan over body */ while (iseol(*s)) s++; se = s; /* Names must start with alphabetic or _ and be at least 3 chars */ if (!((c = *n) && (risalpha(c) || c == '_') && (ne - n) > 2)) { rpmlog(RPMLOG_ERR, _("Macro %%%s has illegal name (%%define)\n"), n); return se; } /* Options must be terminated with ')' */ if (o && oc != ')') { rpmlog(RPMLOG_ERR, _("Macro %%%s has unterminated opts\n"), n); goto exit; } if ((be - b) < 1) { rpmlog(RPMLOG_ERR, _("Macro %%%s has empty body\n"), n); goto exit; } if (expandbody && expandU(mb, b, (&buf[blen] - b))) { rpmlog(RPMLOG_ERR, _("Macro %%%s failed to expand\n"), n); goto exit; } addMacro(mb->mc, n, o, b, (level - 1)); exit: _free(buf); return se; }
int Configuration::parseOption(char const* opt, char const* opt2) { int ret = Status::STAT_OK; std::string val, val2; char const* marker; char const* token = opt; int option, int_v; bool good; #line 121 "<stdout>" { char yych; yych = *opt; switch (yych) { case '\n': goto yy2; case '-': goto yy3; case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': goto yy5; default: goto yy6; } yy2: opt = marker; goto yy4; yy3: yych = *(marker = ++opt); switch (yych) { case '-': goto yy12; case '?': case 'h': goto yy15; case 's': goto yy17; case 'v': goto yy13; default: goto yy4; } yy4: #line 156 "bcplus/Configuration.r2c" { val = token; option = Option::BAD; goto re2c_finish; } #line 203 "<stdout>" yy5: yych = *(marker = ++opt); switch (yych) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': goto yy7; case '=': goto yy9; default: goto yy4; } yy6: yych = *++opt; goto yy4; yy7: ++opt; yych = *opt; switch (yych) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case '_': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': goto yy7; case '=': goto yy9; default: goto yy2; } yy9: ++opt; yych = *opt; if (yych >= 0x01) goto yy9; #line 150 "bcplus/Configuration.r2c" { char const* c = strchr(token, '='); val.assign(token, (size_t)(c - token)); val2.assign(c+1,opt-c-1); option = Option::MACRO_DEF; goto re2c_finish; } #line 357 "<stdout>" yy12: yych = *++opt; switch (yych) { case 'h': goto yy23; case 'p': goto yy22; case 's': goto yy20; case 'v': goto yy21; default: goto yy2; } yy13: ++opt; #line 146 "bcplus/Configuration.r2c" { EXTRACT_NAME; option = Option::VERSION; goto re2c_finish; } #line 374 "<stdout>" yy15: ++opt; #line 142 "bcplus/Configuration.r2c" { EXTRACT_NAME; option = Option::HELP; goto re2c_finish; } #line 382 "<stdout>" yy17: ++opt; switch ((yych = *opt)) { case '=': goto yy19; default: goto yy18; } yy18: #line 126 "bcplus/Configuration.r2c" { EXTRACT_NAME_VAL; option = Option::SYMTAB_INPUT; goto re2c_finish; } #line 395 "<stdout>" yy19: yych = *++opt; goto yy18; yy20: yych = *++opt; switch (yych) { case 'y': goto yy45; default: goto yy2; } yy21: yych = *++opt; switch (yych) { case 'e': goto yy37; default: goto yy2; } yy22: yych = *++opt; switch (yych) { case 'a': goto yy26; default: goto yy2; } yy23: yych = *++opt; switch (yych) { case 'e': goto yy24; default: goto yy2; } yy24: yych = *++opt; switch (yych) { case 'l': goto yy25; default: goto yy2; } yy25: yych = *++opt; switch (yych) { case 'p': goto yy15; default: goto yy2; } yy26: yych = *++opt; switch (yych) { case 'r': goto yy27; default: goto yy2; } yy27: yych = *++opt; switch (yych) { case 's': goto yy28; default: goto yy2; } yy28: yych = *++opt; switch (yych) { case 'e': goto yy29; default: goto yy2; } yy29: yych = *++opt; switch (yych) { case '-': goto yy30; default: goto yy2; } yy30: yych = *++opt; switch (yych) { case 't': goto yy31; default: goto yy2; } yy31: yych = *++opt; switch (yych) { case 'r': goto yy32; default: goto yy2; } yy32: yych = *++opt; switch (yych) { case 'a': goto yy33; default: goto yy2; } yy33: yych = *++opt; switch (yych) { case 'c': goto yy34; default: goto yy2; } yy34: yych = *++opt; switch (yych) { case 'e': goto yy35; default: goto yy2; } yy35: ++opt; #line 138 "bcplus/Configuration.r2c" { EXTRACT_NAME; option = Option::PARSE_TRACE; goto re2c_finish; } #line 496 "<stdout>" yy37: yych = *++opt; switch (yych) { case 'r': goto yy38; default: goto yy2; } yy38: yych = *++opt; switch (yych) { case 'b': goto yy40; case 's': goto yy39; default: goto yy2; } yy39: yych = *++opt; switch (yych) { case 'i': goto yy43; default: goto yy2; } yy40: ++opt; switch ((yych = *opt)) { case '=': goto yy42; default: goto yy41; } yy41: #line 134 "bcplus/Configuration.r2c" { EXTRACT_NAME_VAL; option = Option::VERBOSITY; goto re2c_finish; } #line 528 "<stdout>" yy42: yych = *++opt; goto yy41; yy43: yych = *++opt; switch (yych) { case 'o': goto yy44; default: goto yy2; } yy44: yych = *++opt; switch (yych) { case 'n': goto yy13; default: goto yy2; } yy45: yych = *++opt; switch (yych) { case 'm': goto yy46; default: goto yy2; } yy46: yych = *++opt; switch (yych) { case 't': goto yy47; default: goto yy2; } yy47: yych = *++opt; switch (yych) { case 'a': goto yy48; default: goto yy2; } yy48: yych = *++opt; switch (yych) { case 'b': goto yy49; default: goto yy2; } yy49: yych = *++opt; switch (yych) { case '-': goto yy50; default: goto yy2; } yy50: yych = *++opt; switch (yych) { case 'i': goto yy52; case 'o': goto yy51; default: goto yy2; } yy51: yych = *++opt; switch (yych) { case 'u': goto yy53; default: goto yy2; } yy52: yych = *++opt; switch (yych) { case 'n': goto yy17; default: goto yy2; } yy53: yych = *++opt; switch (yych) { case 't': goto yy54; default: goto yy2; } yy54: ++opt; switch ((yych = *opt)) { case '=': goto yy56; default: goto yy55; } yy55: #line 130 "bcplus/Configuration.r2c" { EXTRACT_NAME_VAL; option = Option::SYMTAB_OUTPUT; goto re2c_finish; } #line 611 "<stdout>" yy56: ++opt; yych = *opt; goto yy55; } #line 160 "bcplus/Configuration.r2c" re2c_finish: switch (option) { case Option::SYMTAB_INPUT: // if (fs::native(val2)) { _symtab_in = new ReferencedPath(val2); // } else { // ret = Status::STAT_BAD_ARG; // std::cerr << "ERROR: \"" << val2 << "\" is not a valid file path." << std::endl; // } break; case Option::SYMTAB_OUTPUT: // if (fs::native(val2)) { _symtab_out = new ReferencedPath(val2); // } else { // ret = Status::STAT_BAD_ARG; // std::cerr << "ERROR: \"" << val2 << "\" is not a valid file path." << std::endl; // // } break; case Option::VERBOSITY: good = babb::utils::fromString(val2.c_str(), int_v); if (!good || int_v < 0) { ret = Status::STAT_BAD_ARG; std::cerr << "ERROR: Bad value provided for command line option. Expected a non-negative integer for argument \"" << val << "\"." << std::endl; } else { verbosity(int_v); } break; case Option::PARSE_TRACE: _parse_trace = true; break; case Option::MACRO_DEF: addMacro(new ReferencedString(val), new ReferencedString(val2)); break; case Option::HELP: ret = Status::STAT_HELP; break; case Option::VERSION: ret = Status::STAT_VERSION; break; case Option::BAD: default: ret = Status::STAT_BAD_ARG; break; } return ret; }
/** * Parse arguments (to next new line) for parameterized macro. * @todo Use popt rather than getopt to parse args. * @param mb macro expansion state * @param me macro entry slot * @param se arguments to parse * @param lastc stop parsing at lastc * @return address to continue parsing */ static const char * grabArgs(MacroBuf mb, const rpmMacroEntry me, const char * se, const char * lastc) { const char *opts, *o; char *args = NULL; ARGV_t argv = NULL; int argc = 0; int c; /* Copy macro name as argv[0] */ argvAdd(&argv, me->name); addMacro(mb->mc, "0", NULL, me->name, mb->depth); /* * Make a copy of se up to lastc string that we can pass to argvSplit(). * Append the results to main argv. */ { ARGV_t av = NULL; char *s = xcalloc((lastc-se)+1, sizeof(*s)); memcpy(s, se, (lastc-se)); argvSplit(&av, s, " \t"); argvAppend(&argv, av); argvFree(av); free(s); } /* * The macro %* analoguous to the shell's $* means "Pass all non-macro * parameters." Consequently, there needs to be a macro that means "Pass all * (including macro parameters) options". This is useful for verifying * parameters during expansion and yet transparently passing all parameters * through for higher level processing (e.g. %description and/or %setup). * This is the (potential) justification for %{**} ... */ args = argvJoin(argv + 1, " "); addMacro(mb->mc, "**", NULL, args, mb->depth); free(args); /* * POSIX states optind must be 1 before any call but glibc uses 0 * to (re)initialize getopt structures, eww. */ #ifdef __GLIBC__ optind = 0; #else optind = 1; #endif opts = me->opts; argc = argvCount(argv); /* Define option macros. */ while((c = getopt(argc, argv, opts)) != -1) { char *name = NULL, *body = NULL; if (c == '?' || (o = strchr(opts, c)) == NULL) { rpmlog(RPMLOG_ERR, _("Unknown option %c in %s(%s)\n"), (char)c, me->name, opts); goto exit; } rasprintf(&name, "-%c", c); if (optarg) { rasprintf(&body, "-%c %s", c, optarg); } else { rasprintf(&body, "-%c", c); } addMacro(mb->mc, name, NULL, body, mb->depth); free(name); free(body); if (optarg) { rasprintf(&name, "-%c*", c); addMacro(mb->mc, name, NULL, optarg, mb->depth); free(name); } } /* Add argument count (remaining non-option items) as macro. */ { char *ac = NULL; rasprintf(&ac, "%d", (argc - optind)); addMacro(mb->mc, "#", NULL, ac, mb->depth); free(ac); } /* Add macro for each argument */ if (argc - optind) { for (c = optind; c < argc; c++) { char *name = NULL; rasprintf(&name, "%d", (c - optind + 1)); addMacro(mb->mc, name, NULL, argv[c], mb->depth); free(name); } } /* Add concatenated unexpanded arguments as yet another macro. */ args = argvJoin(argv + optind, " "); addMacro(mb->mc, "*", NULL, args ? args : "", mb->depth); free(args); exit: argvFree(argv); return *lastc ? lastc + 1 : lastc; }
// setup the preprocessor // code provided by Reginald Stadlbauer <*****@*****.**> void setup() { QString kdedir = getenv( "KDEDIR" ); if ( !kdedir.isNull() ) addIncludePath( kdedir + "/include" ); QString qtdir = getenv( "QTDIR" ); if ( !qtdir.isNull() ) addIncludePath( qtdir + "/include" ); QString qmakespec = getenv( "QMAKESPEC" ); if ( qmakespec.isNull() ) qmakespec = "linux-g++"; // #### implement other mkspecs and find a better way to find the // #### proper mkspec (althoigh this will be no fun :-) addIncludePath( qtdir + "/mkspecs/" + qmakespec ); if ( qmakespec == "linux-g++" ) { addIncludePath( "/include" ); addIncludePath( "/usr/include" ); addIncludePath( "/ust/local/include" ); bool ok; QString gccLibPath = SetupHelper::getGccIncludePath(&ok); if (!ok) return; gccLibPath = gccLibPath.replace( QRegExp( "[\r\n]" ), "" ); addIncludePath( gccLibPath ); addIncludePath( "/usr/include/g++-3" ); addIncludePath( "/usr/include/g++" ); QStringList lines = SetupHelper::getGccMacros(&ok); if (!ok) return; for (QStringList::ConstIterator it = lines.constBegin(); it != lines.constEnd(); ++it) { QStringList lst = QStringList::split( ' ', *it ); if ( lst.count() != 3 ) continue; addMacro( Macro( lst[1], lst[2] ) ); } addMacro( Macro( "__cplusplus", "1" ) ); QString incl = getenv( "INCLUDE" ); QStringList includePaths = QStringList::split( ':', incl ); QStringList::Iterator it = includePaths.begin(); while ( it != includePaths.end() ) { addIncludePath( ( *it ).stripWhiteSpace() ); ++it; } } else if ( qmakespec == "win32-borland" ) { QString incl = getenv( "INCLUDE" ); QStringList includePaths = QStringList::split( ';', incl ); QStringList::Iterator it = includePaths.begin(); while ( it != includePaths.end() ) { addIncludePath( ( *it ).stripWhiteSpace() ); ++it; } // ### I am sure there are more standard include paths on // ### windows. I will fix that soon // ### Also do the compiler specific defines on windows } }
static rpmSpec parseSpec(const char *specFile, rpmSpecFlags flags, const char *buildRoot, int recursing) { int parsePart = PART_PREAMBLE; int initialPackage = 1; rpmSpec spec; /* Set up a new Spec structure with no packages. */ spec = newSpec(); spec->specFile = rpmGetPath(specFile, NULL); pushOFI(spec, spec->specFile); /* If buildRoot not specified, use default %{buildroot} */ if (buildRoot) { spec->buildRoot = xstrdup(buildRoot); } else { spec->buildRoot = rpmGetPath("%{?buildroot:%{buildroot}}", NULL); } addMacro(NULL, "_docdir", NULL, "%{_defaultdocdir}", RMIL_SPEC); addMacro(NULL, "_licensedir", NULL, "%{_defaultlicensedir}", RMIL_SPEC); spec->recursing = recursing; spec->flags = flags; /* All the parse*() functions expect to have a line pre-read */ /* in the spec's line buffer. Except for parsePreamble(), */ /* which handles the initial entry into a spec file. */ while (parsePart != PART_NONE) { int goterror = 0; switch (parsePart) { case PART_ERROR: /* fallthrough */ default: goterror = 1; break; case PART_PREAMBLE: parsePart = parsePreamble(spec, initialPackage); initialPackage = 0; break; case PART_PREP: parsePart = parsePrep(spec); break; case PART_BUILD: case PART_INSTALL: case PART_CHECK: case PART_CLEAN: parsePart = parseBuildInstallClean(spec, parsePart); break; case PART_CHANGELOG: parsePart = parseChangelog(spec); break; case PART_DESCRIPTION: parsePart = parseDescription(spec); break; case PART_PRE: case PART_POST: case PART_PREUN: case PART_POSTUN: case PART_PRETRANS: case PART_POSTTRANS: case PART_VERIFYSCRIPT: case PART_TRIGGERPREIN: case PART_TRIGGERIN: case PART_TRIGGERUN: case PART_TRIGGERPOSTUN: case PART_FILETRIGGERIN: case PART_FILETRIGGERUN: case PART_FILETRIGGERPOSTUN: case PART_TRANSFILETRIGGERIN: case PART_TRANSFILETRIGGERUN: case PART_TRANSFILETRIGGERPOSTUN: parsePart = parseScript(spec, parsePart); break; case PART_FILES: parsePart = parseFiles(spec); break; case PART_POLICIES: parsePart = parsePolicies(spec); break; case PART_NONE: /* XXX avoid gcc whining */ case PART_LAST: case PART_BUILDARCHITECTURES: break; } if (goterror || parsePart >= PART_LAST) { goto errxit; } if (parsePart == PART_BUILDARCHITECTURES) { int index; int x; closeSpec(spec); spec->BASpecs = xcalloc(spec->BACount, sizeof(*spec->BASpecs)); index = 0; if (spec->BANames != NULL) for (x = 0; x < spec->BACount; x++) { /* Skip if not arch is not compatible. */ if (!rpmMachineScore(RPM_MACHTABLE_BUILDARCH, spec->BANames[x])) continue; addMacro(NULL, "_target_cpu", NULL, spec->BANames[x], RMIL_RPMRC); spec->BASpecs[index] = parseSpec(specFile, flags, buildRoot, 1); if (spec->BASpecs[index] == NULL) { spec->BACount = index; goto errxit; } delMacro(NULL, "_target_cpu"); index++; } spec->BACount = index; if (! index) { rpmlog(RPMLOG_ERR, _("No compatible architectures found for build\n")); goto errxit; } /* * Return the 1st child's fully parsed Spec structure. * The restart of the parse when encountering BuildArch * causes problems for "rpm -q --specfile". This is * still a hack because there may be more than 1 arch * specified (unlikely but possible.) There's also the * further problem that the macro context, particularly * %{_target_cpu}, disagrees with the info in the header. */ if (spec->BACount >= 1) { rpmSpec nspec = spec->BASpecs[0]; spec->BASpecs = _free(spec->BASpecs); rpmSpecFree(spec); spec = nspec; } goto exit; } } if (spec->clean == NULL) { char *body = rpmExpand("%{?buildroot: %{__rm} -rf %{buildroot}}", NULL); spec->clean = newStringBuf(); appendLineStringBuf(spec->clean, body); free(body); } /* Check for description in each package */ for (Package pkg = spec->packages; pkg != NULL; pkg = pkg->next) { if (!headerIsEntry(pkg->header, RPMTAG_DESCRIPTION)) { rpmlog(RPMLOG_ERR, _("Package has no %%description: %s\n"), headerGetString(pkg->header, RPMTAG_NAME)); goto errxit; } } /* Add arch, os and platform, self-provides etc for each package */ addTargets(spec->packages); /* Check for encoding in each package unless disabled */ if (!(spec->flags & RPMSPEC_NOUTF8)) { int badenc = 0; for (Package pkg = spec->packages; pkg != NULL; pkg = pkg->next) { if (checkForEncoding(pkg->header, 0) != RPMRC_OK) { badenc = 1; } } if (badenc) goto errxit; } closeSpec(spec); exit: /* Assemble source header from parsed components */ initSourceHeader(spec); return spec; errxit: rpmSpecFree(spec); return NULL; }
void Driver::insertMacros( const MacroSet& macros ) { for( MacroSet::Macros::const_iterator it = macros.m_usedMacros.begin(); it != macros.m_usedMacros.end(); ++it ) { addMacro( *it ); } }
void Driver::addDependence( const QString & fileName, const Dependence & dep ) { // this can happen if the parser was invoked on a snippet of text and not a file if ( fileName.isEmpty() || !m_currentParsedFile ) return; //@todo prevent cyclic dependency-loops QFileInfo fileInfo( dep.first ); QString fn = fileInfo.absFilePath(); if ( !depresolv ) { findOrInsertDependenceList( fileName ).insert( fn, dep ); m_currentParsedFile->addIncludeFile( dep.first, 0, dep.second == Dep_Local ); return ; } QString file = findIncludeFile( dep ); findOrInsertDependenceList( fileName ).insert( file, dep ); m_currentParsedFile->addIncludeFile( file, 0, dep.second == Dep_Local ); if ( !QFile::exists( file ) ) { Problem p( i18n( "Could not find include file %1" ).arg( dep.first ), lexer ? lexer->currentLine() : -1, lexer ? lexer->currentColumn() : -1, Problem::Level_Warning ); addProblem( fileName, p ); return ; } if( m_currentLexerCache ) m_currentLexerCache->addIncludeFile( file, QDateTime() ); ///The time will be overwritten in CachedLexedFile::merge(...) /**What should be done: * 1. Lex the file to get all the macros etc. * 2. TODO: Check what previously set macros the file was affected by, and compare those macros to any previously parsed instances of this file. * 2.1 If there is a parse-instance of the file where all macros that played a role had the same values, we do not need to reparse this file. * 2.2 If there is no such fitting instance, the file needs to be parsed and put to the code-model. * * It'll be necessary to have multiple versions of one file in the code-model. */ IntIncreaser i( m_dependenceDepth ); if( m_dependenceDepth > m_maxDependenceDepth ) { //kdDebug( 9007 ) << "maximum dependence-depth of " << m_maxDependenceDepth << " was reached, " << fileName << " will not be processed" << endl; return; } CachedLexedFilePointer lexedFileP = m_lexerCache.lexedFile( HashedString( file ) ); if( lexedFileP ) { CachedLexedFile& lexedFile( *lexedFileP ); m_currentLexerCache->merge( lexedFile ); //The ParseHelper will will copy the include-files into the result later for( MacroSet::Macros::const_iterator it = lexedFile.definedMacros().macros().begin(); it != lexedFile.definedMacros().macros().end(); ++it ) { addMacro( (*it) ); } ///@todo fill usingMacro(...) return; } ParseHelper h( file, true, this, false, m_currentMasterFileName ); /*if ( m_parsedUnits.find(file) != m_parsedUnits.end() ) return;*/ if( shouldParseIncludedFile( m_currentParsedFile ) ) ///Until the ParseHelper is destroyed, m_currentParsedFile will stay the included file h.parse(); }
int parseSpec(rpmts ts, const char *specFile, const char *rootDir, const char *buildRoot, int recursing, const char *passPhrase, const char *cookie, int anyarch, int force) { rpmParseState parsePart = PART_PREAMBLE; int initialPackage = 1; Package pkg; rpmSpec spec; /* Set up a new Spec structure with no packages. */ spec = newSpec(); spec->specFile = rpmGetPath(specFile, NULL); spec->fileStack = newOpenFileInfo(); spec->fileStack->fileName = xstrdup(spec->specFile); /* If buildRoot not specified, use default %{buildroot} */ if (buildRoot) { spec->buildRoot = xstrdup(buildRoot); } else { spec->buildRoot = rpmGetPath("%{?buildroot:%{buildroot}}", NULL); } addMacro(NULL, "_docdir", NULL, "%{_defaultdocdir}", RMIL_SPEC); spec->recursing = recursing; spec->anyarch = anyarch; spec->force = force; if (rootDir) spec->rootDir = xstrdup(rootDir); if (passPhrase) spec->passPhrase = xstrdup(passPhrase); if (cookie) spec->cookie = xstrdup(cookie); spec->timeCheck = rpmExpandNumeric("%{_timecheck}"); /* All the parse*() functions expect to have a line pre-read */ /* in the spec's line buffer. Except for parsePreamble(), */ /* which handles the initial entry into a spec file. */ while (parsePart != PART_NONE) { int goterror = 0; switch (parsePart) { /* XXX Trap unexpected RPMRC_FAIL returns for now */ case RPMRC_FAIL: rpmlog(RPMLOG_ERR, "FIXME: got RPMRC_FAIL from spec parse\n"); abort(); case PART_ERROR: /* fallthrough */ default: goterror = 1; break; case PART_PREAMBLE: parsePart = parsePreamble(spec, initialPackage); initialPackage = 0; break; case PART_PREP: parsePart = parsePrep(spec); break; case PART_BUILD: case PART_INSTALL: case PART_CHECK: case PART_CLEAN: parsePart = parseBuildInstallClean(spec, parsePart); break; case PART_CHANGELOG: parsePart = parseChangelog(spec); break; case PART_DESCRIPTION: parsePart = parseDescription(spec); break; case PART_PRE: case PART_POST: case PART_PREUN: case PART_POSTUN: case PART_PRETRANS: case PART_POSTTRANS: case PART_VERIFYSCRIPT: case PART_TRIGGERPREIN: case PART_TRIGGERIN: case PART_TRIGGERUN: case PART_TRIGGERPOSTUN: parsePart = parseScript(spec, parsePart); break; case PART_FILES: parsePart = parseFiles(spec); break; case PART_NONE: /* XXX avoid gcc whining */ case PART_LAST: case PART_BUILDARCHITECTURES: break; } if (goterror || parsePart >= PART_LAST) { goto errxit; } if (parsePart == PART_BUILDARCHITECTURES) { int index; int x; closeSpec(spec); spec->BASpecs = xcalloc(spec->BACount, sizeof(*spec->BASpecs)); index = 0; if (spec->BANames != NULL) for (x = 0; x < spec->BACount; x++) { /* Skip if not arch is not compatible. */ if (!rpmMachineScore(RPM_MACHTABLE_BUILDARCH, spec->BANames[x])) continue; addMacro(NULL, "_target_cpu", NULL, spec->BANames[x], RMIL_RPMRC); spec->BASpecs[index] = NULL; if (parseSpec(ts, specFile, spec->rootDir, buildRoot, 1, passPhrase, cookie, anyarch, force) || (spec->BASpecs[index] = rpmtsSetSpec(ts, NULL)) == NULL) { spec->BACount = index; goto errxit; } delMacro(NULL, "_target_cpu"); index++; } spec->BACount = index; if (! index) { rpmlog(RPMLOG_ERR, _("No compatible architectures found for build\n")); goto errxit; } /* * Return the 1st child's fully parsed Spec structure. * The restart of the parse when encountering BuildArch * causes problems for "rpm -q --specfile". This is * still a hack because there may be more than 1 arch * specified (unlikely but possible.) There's also the * further problem that the macro context, particularly * %{_target_cpu}, disagrees with the info in the header. */ if (spec->BACount >= 1) { rpmSpec nspec = spec->BASpecs[0]; spec->BASpecs = _free(spec->BASpecs); spec = freeSpec(spec); spec = nspec; } (void) rpmtsSetSpec(ts, spec); return 0; } } if (spec->clean == NULL) { char *body = rpmExpand("%{?buildroot: %{__rm} -rf %{buildroot}}", NULL); spec->clean = newStringBuf(); appendLineStringBuf(spec->clean, body); free(body); } /* Check for description in each package and add arch and os */ { char *platform = rpmExpand("%{_target_platform}", NULL); char *arch = rpmExpand("%{_target_cpu}", NULL); char *os = rpmExpand("%{_target_os}", NULL); for (pkg = spec->packages; pkg != NULL; pkg = pkg->next) { if (!headerIsEntry(pkg->header, RPMTAG_DESCRIPTION)) { rpmlog(RPMLOG_ERR, _("Package has no %%description: %s\n"), headerGetString(pkg->header, RPMTAG_NAME)); goto errxit; } headerPutString(pkg->header, RPMTAG_OS, os); /* noarch subpackages already have arch set here, leave it alone */ if (!headerIsEntry(pkg->header, RPMTAG_ARCH)) { headerPutString(pkg->header, RPMTAG_ARCH, arch); } headerPutString(pkg->header, RPMTAG_PLATFORM, platform); pkg->ds = rpmdsThis(pkg->header, RPMTAG_REQUIRENAME, RPMSENSE_EQUAL); } platform = _free(platform); arch = _free(arch); os = _free(os); } closeSpec(spec); (void) rpmtsSetSpec(ts, spec); return 0; errxit: spec = freeSpec(spec); return PART_ERROR; }