rpm  5.4.10
rpmmc-rb.c
Go to the documentation of this file.
1 
5 #include "system.h"
6 #include "rpm-rb.h"
7 #include "rpmmc-rb.h"
8 
9 #define _MACRO_INTERNAL
10 #include <rpmmacro.h>
11 #include <rpmio/argv.h>
12 
13 #include "../debug.h"
14 
15 
17 
18 VALUE rpmmcClass;
19 
20 /*@unchecked@*/
21 static int _debug = 0;
22 
23 
27 static rpmmc
28 _rpmmc_get_mc(VALUE self)
29 {
30  rpmmc mc;
31  Data_Get_Struct(self, struct MacroContext_s, mc);
32  return mc;
33 }
34 
35 
47 static VALUE
48 rpmmc_add(VALUE self, VALUE macro)
49 {
50  Check_Type(macro, T_STRING);
51 
52  rpmmc mc = _rpmmc_get_mc(self);
53  int lvl = 0;
54 
55  if (_debug)
56  fprintf(stderr, "==> %s(0x%lx, 0x%lx) ptr %p\n",
57  __FUNCTION__, self, macro, mc);
58 
59  int error = rpmDefineMacro(mc, RSTRING_PTR(macro), lvl);
60  if(error)
61  rpm_rb_raise(error, "Macro definition failed");
62  return self;
63 }
64 
65 
76 static VALUE
77 rpmmc_del(VALUE self, VALUE macro)
78 {
79  Check_Type(macro, T_STRING);
80 
81  rpmmc mc = _rpmmc_get_mc(self);
82 
83  if (_debug)
84  fprintf(stderr, "==> %s(0x%lx, 0x%lx) ptr %p\n",
85  __FUNCTION__, self, macro, mc);
86 
87  int error = rpmUndefineMacro(mc, StringValueCStr(macro));
88  if(error)
89  rpm_rb_raise(error, "Macro deletion failed");
90  return self;
91 }
92 
93 
104 static VALUE
105 rpmmc_list(VALUE self)
106 {
107  rpmmc mc = _rpmmc_get_mc(self);
108 
109  void * _mire = NULL;
110  VALUE v = rb_ary_new();
111  int used = -1;
112  const char ** av = NULL;
113  int ac = rpmGetMacroEntries(mc, _mire, used, &av);
114 
115  if (_debug)
116  fprintf(stderr, "==> %s(0x%lx) ptr %p\n", __FUNCTION__, self, mc);
117 
118  if (ac > 0 && av != NULL && av[0] != NULL) {
119  int i;
120  for (i = 0; i < ac; i++) {
121  /* Parse out "%name(opts)\tbody" into n/o/b strings. */
122 
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);
128 
129  if (*name == '%') name++;
130  if (opts != NULL && *opts == '(') {
131  body[-1] = '\0';
132  opts++;
133  opts[-1] = '\0';
134  } else {
135  body[0] = '\0';
136  opts = "";
137  }
138  body++;
139 
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);
143  }
144  }
145 
146  argvFree(av);
147  return v;
148 }
149 
150 
160 static VALUE
161 rpmmc_expand(VALUE self, VALUE macro)
162 {
163  rpmmc mc = _rpmmc_get_mc(self);
164  char *vstr = StringValueCStr(macro);
165 
166  if (_debug)
167  fprintf(stderr, "==> %s(0x%lx, 0x%lx) ptr %p \"%s\"\n",
168  __FUNCTION__, self, macro, mc, vstr);
169  return rb_str_new2(rpmMCExpand(mc, vstr, NULL));
170 }
171 
172 
184 static VALUE
185 rpmmc_load_macro_file(VALUE self, VALUE fn_v, VALUE nesting_v)
186 {
187  rpmmc mc = _rpmmc_get_mc(self);
188 
189  Check_Type(fn_v, T_STRING);
190  Check_Type(nesting_v, T_FIXNUM);
191 
192  int error = rpmLoadMacroFile(mc, RSTRING_PTR(fn_v), FIX2INT(nesting_v));
193  if(error)
194  rpm_rb_raise(error, "Loading macro file failed");
195  return self;
196 }
197 
198 
209 static VALUE
210 rpmmc_init_macros(VALUE self, VALUE macrofiles_v)
211 {
212  Check_Type(macrofiles_v, T_STRING);
213 
214  rpmmc mc = _rpmmc_get_mc(self);
215 
216  rpmInitMacros(mc, RSTRING_PTR(macrofiles_v));
217  return self;
218 }
219 
220 
221 static void
222 initMethods(VALUE klass)
223 {
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);
227  rb_define_method(klass, "expand", &rpmmc_expand, 1);
228  rb_define_method(klass, "load_macro_file", &rpmmc_load_macro_file, 2);
229  rb_define_method(klass, "init_macros", &rpmmc_init_macros, 1);
230 }
231 
232 
233 /* --- Object properties */
234 
243 static VALUE
245 {
246  if (_debug)
247  fprintf(stderr, "==> %s(0x%lx)\n", __FUNCTION__, s);
248  return INT2FIX(_debug);
249 }
250 
251 
260 static VALUE
261 rpmmc_debug_set(VALUE s, VALUE v)
262 {
263  if (_debug)
264  fprintf(stderr, "==> %s(0x%lx, 0x%lx)\n", __FUNCTION__, s, v);
265  return INT2FIX(_debug = FIX2INT(v));
266 }
267 
268 
278 static VALUE
280 {
282 }
283 
284 
293 static VALUE
295 {
297 }
298 
299 
300 static void
301 initProperties(VALUE klass)
302 {
303  rb_define_method(klass, "debug", rpmmc_debug_get, 0);
304  rb_define_method(klass, "debug=", rpmmc_debug_set, 1);
305  rb_define_singleton_method(klass, "global_context",
307  rb_define_singleton_method(klass, "cli_context", rpmmc_get_cli_mc, 0);
308 }
309 
310 
311 /* --- Object ctors/dtors */
312 
313 static void
315 {
316  /* Don't free the global or CLI macro context */
317  if(mc == rpmGlobalMacroContext || mc == rpmCLIMacroContext) return;
318 
319  rpmFreeMacros(mc);
320  mc = _free(mc);
321 }
322 
323 
324 VALUE
326 {
327  if (_debug)
328  fprintf(stderr, "==> %s(%p)\n", __FUNCTION__, mc);
329  return Data_Wrap_Struct(rpmmcClass, 0, &_rpmmc_free, mc);
330 }
331 
332 
333 static VALUE
334 rpmmc_alloc(VALUE klass)
335 {
336  rpmmc mc = xcalloc(1, sizeof(*mc));
337  VALUE obj = rpmmc_wrap(mc);
338  if (_debug)
339  fprintf(stderr, "==> %s(0x%lx) obj 0x%lx mc %p\n",
340  __FUNCTION__, klass, obj, mc);
341  return obj;
342 }
343 
344 
345 /* --- Class initialization */
346 
347 void
349 {
350  rpmmcClass = rb_define_class_under(rpmModule, "Mc", rb_cObject);
351  if (_debug)
352  fprintf(stderr, "==> %s() rpmmcClass 0x%lx\n", __FUNCTION__, rpmmcClass);
353  rb_define_alloc_func(rpmmcClass, rpmmc_alloc);
356 }
void rpmInitMacros(MacroContext mc, const char *macrofiles)
Initialize macro context from set of macrofile(s).
Definition: macro.c:2880
void rpmFreeMacros(MacroContext mc)
Destroy macro context.
Definition: macro.c:2966
static VALUE rpmmc_get_global_mc(void)
Return the global macro context.
Definition: rpmmc-rb.c:279
static VALUE rpmmc_load_macro_file(VALUE self, VALUE fn_v, VALUE nesting_v)
Loads a macro file.
Definition: rpmmc-rb.c:185
static VALUE rpmmc_del(VALUE self, VALUE macro)
Deletes a macro definition.
Definition: rpmmc-rb.c:77
MacroContext rpmCLIMacroContext
Definition: macro.c:127
static VALUE rpmmc_list(VALUE self)
List all macro definitions in the corresponding Macro Context.
Definition: rpmmc-rb.c:105
VALUE rpmmc_wrap(rpmmc mc)
Wraps an already existing MacroContext struct in a Ruby class.
Definition: rpmmc-rb.c:325
void * xcalloc(size_t nmemb, size_t size)
Definition: rpmmalloc.c:301
static VALUE rpmmc_expand(VALUE self, VALUE macro)
Expands a macro.
Definition: rpmmc-rb.c:161
MacroContext rpmGlobalMacroContext
Definition: macro.c:122
int rpmGetMacroEntries(MacroContext mc, void *_mire, int used, const char ***avp)
Return macro entries as string array.
Definition: macro.c:319
static VALUE rpmmc_debug_get(VALUE s)
Get debugging log level.
Definition: rpmmc-rb.c:244
ARGV_t argvFree(ARGV_t argv)
Destroy an argv array.
Definition: argv.c:44
int rpmDefineMacro(MacroContext mc, const char *macro, int level)
Define macro in context.
Definition: macro.c:2739
static rpmmc _rpmmc_get_mc(VALUE self)
Returns the wrapped C structure ::MacroContext_s.
Definition: rpmmc-rb.c:28
MacroContext rpmmc
Definition: rpmmc-rb.c:16
void rpm_rb_raise(rpmRC error, char *message)
Raises a Ruby exception (RPM::Error).
Definition: rpm-rb.c:53
void Init_rpmmc(void)
Definition: rpmmc-rb.c:348
RPM Ruby bindings "RPM" module.
static void initMethods(VALUE klass)
Definition: rpmmc-rb.c:222
static VALUE rpmmc_debug_set(VALUE s, VALUE v)
Set debugging log level.
Definition: rpmmc-rb.c:261
static void initProperties(VALUE klass)
Definition: rpmmc-rb.c:301
struct MacroContext_s * MacroContext
Definition: rpmmacro.h:8
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:647
static int _debug
Definition: rpmmc-rb.c:21
static VALUE rpmmc_init_macros(VALUE self, VALUE macrofiles_v)
Initializes a macro context from a list of files.
Definition: rpmmc-rb.c:210
static VALUE rpmmc_add(VALUE self, VALUE macro)
Adds a new macro definition to the Macro Context.
Definition: rpmmc-rb.c:48
VALUE rpmModule
The "RPM" Ruby module.
Definition: rpm-rb.c:35
static const char * name
static VALUE rpmmc_alloc(VALUE klass)
Definition: rpmmc-rb.c:334
static void _rpmmc_free(rpmmc mc)
Definition: rpmmc-rb.c:314
Ruby bindings to RPM&#39;s macro context facility.
int rpmLoadMacroFile(MacroContext mc, const char *fn, int nesting)
Load macro context from a macro file.
Definition: macro.c:2801
VALUE rpmmcClass
RPM::Mc macro context Ruby class.
Definition: rpmmc-rb.c:18
static VALUE rpmmc_get_cli_mc(void)
Return the CLI macro context.
Definition: rpmmc-rb.c:294
int rpmUndefineMacro(MacroContext mc, const char *macro)
Undefine macro in context.
Definition: macro.c:2753
char * rpmMCExpand(MacroContext mc, const char *arg,...)
Return (malloc&#39;ed) concatenated macro expansion(s) in a context.
Definition: macro.c:3154