9 #define _MACRO_INTERNAL
31 Data_Get_Struct(
self,
struct MacroContext_s, mc);
50 Check_Type(macro, T_STRING);
56 fprintf(stderr,
"==> %s(0x%lx, 0x%lx) ptr %p\n",
57 __FUNCTION__,
self, macro, mc);
79 Check_Type(macro, T_STRING);
84 fprintf(stderr,
"==> %s(0x%lx, 0x%lx) ptr %p\n",
85 __FUNCTION__,
self, macro, mc);
110 VALUE
v = rb_ary_new();
112 const char ** av = NULL;
116 fprintf(stderr,
"==> %s(0x%lx) ptr %p\n", __FUNCTION__,
self, mc);
118 if (ac > 0 && av != NULL && av[0] != NULL) {
120 for (i = 0; i < ac; i++) {
123 char *
name = (
char *)av[i];
124 char *body = strchr(name,
'\t');
125 assert(body != NULL);
126 char *
opts = ((body > name && body[-1] ==
')') ?
127 strchr(name,
'(') : NULL);
129 if (*name ==
'%') name++;
130 if (opts != NULL && *opts ==
'(') {
140 VALUE nob_ary = rb_ary_new3(3, rb_str_new2(name),
141 rb_str_new2(opts), rb_str_new2(body));
142 rb_ary_push(v, nob_ary);
164 char *vstr = StringValueCStr(macro);
167 fprintf(stderr,
"==> %s(0x%lx, 0x%lx) ptr %p \"%s\"\n",
168 __FUNCTION__,
self, macro, mc, vstr);
189 Check_Type(fn_v, T_STRING);
190 Check_Type(nesting_v, T_FIXNUM);
212 Check_Type(macrofiles_v, T_STRING);
224 rb_define_method(klass,
"add", &
rpmmc_add, 1);
225 rb_define_method(klass,
"del", &
rpmmc_del, 1);
226 rb_define_method(klass,
"list", &
rpmmc_list, 0);
247 fprintf(stderr,
"==> %s(0x%lx)\n", __FUNCTION__, s);
264 fprintf(stderr,
"==> %s(0x%lx, 0x%lx)\n", __FUNCTION__, s, v);
265 return INT2FIX(
_debug = FIX2INT(v));
305 rb_define_singleton_method(klass,
"global_context",
328 fprintf(stderr,
"==> %s(%p)\n", __FUNCTION__, mc);
339 fprintf(stderr,
"==> %s(0x%lx) obj 0x%lx mc %p\n",
340 __FUNCTION__, klass, obj, mc);
352 fprintf(stderr,
"==> %s() rpmmcClass 0x%lx\n", __FUNCTION__,
rpmmcClass);
void rpmInitMacros(MacroContext mc, const char *macrofiles)
Initialize macro context from set of macrofile(s).
void rpmFreeMacros(MacroContext mc)
Destroy macro context.
static VALUE rpmmc_get_global_mc(void)
Return the global macro context.
static VALUE rpmmc_load_macro_file(VALUE self, VALUE fn_v, VALUE nesting_v)
Loads a macro file.
static VALUE rpmmc_del(VALUE self, VALUE macro)
Deletes a macro definition.
MacroContext rpmCLIMacroContext
static VALUE rpmmc_list(VALUE self)
List all macro definitions in the corresponding Macro Context.
VALUE rpmmc_wrap(rpmmc mc)
Wraps an already existing MacroContext struct in a Ruby class.
void * xcalloc(size_t nmemb, size_t size)
static VALUE rpmmc_expand(VALUE self, VALUE macro)
Expands a macro.
const char const bson_bool_t v
MacroContext rpmGlobalMacroContext
int rpmGetMacroEntries(MacroContext mc, void *_mire, int used, const char ***avp)
Return macro entries as string array.
static VALUE rpmmc_debug_get(VALUE s)
Get debugging log level.
ARGV_t argvFree(ARGV_t argv)
Destroy an argv array.
int rpmDefineMacro(MacroContext mc, const char *macro, int level)
Define macro in context.
static rpmmc _rpmmc_get_mc(VALUE self)
Returns the wrapped C structure ::MacroContext_s.
void rpm_rb_raise(rpmRC error, char *message)
Raises a Ruby exception (RPM::Error).
RPM Ruby bindings "RPM" module.
const char const char const char * opts
static void initMethods(VALUE klass)
static VALUE rpmmc_debug_set(VALUE s, VALUE v)
Set debugging log level.
static void initProperties(VALUE klass)
struct MacroContext_s * MacroContext
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
static VALUE rpmmc_init_macros(VALUE self, VALUE macrofiles_v)
Initializes a macro context from a list of files.
static VALUE rpmmc_add(VALUE self, VALUE macro)
Adds a new macro definition to the Macro Context.
VALUE rpmModule
The "RPM" Ruby module.
static VALUE rpmmc_alloc(VALUE klass)
static void _rpmmc_free(rpmmc mc)
Ruby bindings to RPM's macro context facility.
int rpmLoadMacroFile(MacroContext mc, const char *fn, int nesting)
Load macro context from a macro file.
VALUE rpmmcClass
RPM::Mc macro context Ruby class.
static VALUE rpmmc_get_cli_mc(void)
Return the CLI macro context.
int rpmUndefineMacro(MacroContext mc, const char *macro)
Undefine macro in context.
char * rpmMCExpand(MacroContext mc, const char *arg,...)
Return (malloc'ed) concatenated macro expansion(s) in a context.