OpenSRF/src/utils/fieldmapper-c.pl

   1 #!/usr/bin/perl
   2 use strict; use warnings;
   3 use Data::Dumper;
   4 use OpenILS::Utils::Fieldmapper;
   5
   6
   7 if(!$ARGV[1]) {
   8         print "usage: $0 <header_file> <source_file>\n";
   9         exit;
  10 }
  11
  12 warn "Generating fieldmapper-c code...\n";
  13
  14 #open(HEADER, ">fieldmapper.h");
  15 #open(SOURCE, ">fieldmapper.c");
  16
  17 print $ARGV[0] . "\n";
  18 print $ARGV[1] . "\n";
  19
  20 open(HEADER, ">$ARGV[0]");
  21 open(SOURCE, ">$ARGV[1]");
  22
  23 my $map = $Fieldmapper::fieldmap;
  24
  25 print HEADER <<C;
  26
  27 #include "objson/object.h"
  28 #include "objson/json_parser.h"
  29 #include "utils.h"
  30
  31 /* Fieldmapper-C.  Autogenerated from fieldmapper-c.pl.\n\nNote that object*'s passed in as
  32 constructor parameters are copied in so the originals will need to be freed*/
  33
  34 /* fm_obj is the generic placeholder object */
  35 struct fm_obj_struct {
  36         char* classname;
  37         object* array;
  38 };
  39 typedef struct fm_obj_struct fm_obj;
  40
  41 /* takes a json object and builds a fieldmapper object.  the object
  42         is then cast into an fm_obj and returned.  To verify an object is
  43         what is expected, check fm_obj_thing->classname. */
  44 fm_obj* fm_factory(object*);
  45
  46 /* builds a new fieldmapper object by class name */
  47 fm_obj* fm_factory_string(char*);
  48
  49 void fm_free(fm_obj* fm);
  50 C
  51
  52 print SOURCE <<C;
  53 #include "fieldmapper.h"
  54
  55 void fm_free(fm_obj* fm) {
  56         if(!fm) return;
  57         free_object(fm->array);
  58         free(fm);
  59 }
  60 C
  61
  62 my $factory_string = <<C;
  63 fm_obj* fm_factory(object* obj) {
  64
  65         if(!obj) return NULL;
  66         if(!obj->classname) return NULL;
  67         fm_obj* fm = NULL;
  68
  69 C
  70
  71 my $fstring_string = <<C;
  72 fm_obj* fm_factory_string(char* string) {
  73         if(!string) return NULL;
  74         object* obj = new_object(NULL);
  75         object* tmp = NULL;
  76 C
  77
  78 for my $object (keys %$map) {
  79
  80         my $short_name                          = $map->{$object}->{hint};
  81         my $func_header_string  = "";
  82         my $func_code_string            = "";
  83         my $constructor_string  = "";
  84
  85         $factory_string .= <<CODE;
  86         if(!strcmp(obj->classname,"$short_name"))
  87                 fm = (fm_obj*) fm_new_$short_name(obj);
  88 CODE
  89
  90         $fstring_string .= <<CODE;
  91         if(!strcmp(string, "$short_name")) {
  92                 obj->set_class(obj, "$short_name");
  93 CODE
  94
  95         my $header_string = <<CODE;
  96 struct fm_${short_name}_struct {
  97         char* classname;
  98         object* array;
  99         char*\t\t(*to_string) (struct fm_${short_name}_struct*);
 100 CODE
 101
 102         $func_header_string .= <<CODE;
 103 char* fm_${short_name}_to_string(fm_$short_name*);
 104 CODE
 105
 106         my $to_string   = <<CODE;
 107 char* fm_${short_name}_to_string(fm_$short_name* fm) {
 108         if(!fm || !fm->array) return NULL;
 109         growing_buffer* buf = buffer_init(256);
 110         buffer_fadd(buf, "%s => {\\n", fm->classname);
 111         object* o;
 112 CODE
 113
 114         $constructor_string .= <<CODE;
 115 fm_$short_name* fm_new_$short_name(object* obj_array) {
 116
 117         fm_$short_name* fm = (fm_$short_name*) safe_malloc(sizeof(fm_$short_name));
 118
 119         /* build an empty array object */
 120         if(!obj_array) {
 121                 fm->array = new_object(NULL);
 122                 fm->array->is_array = 1;
 123                 fm->array->set_class(fm->array, "$short_name");
 124
 125         } else {
 126
 127                 /* we don't want invalid objects */
 128                 if (!obj_array->classname) return NULL;
 129                 if(strcmp(obj_array->classname, "$short_name")) return NULL;
 130
 131                 char* s = obj_array->to_json(obj_array);
 132                 fm->array = json_parse_string(s);
 133                 free(s);
 134         }
 135
 136         fm->classname = fm->array->classname;
 137         fm->to_string = &fm_${short_name}_to_string;
 138 CODE
 139
 140         for my $field (keys %{$map->{$object}->{fields}}) {
 141                 my $position = $map->{$object}->{fields}->{$field}->{position};
 142
 143                 $to_string .= <<CODE;
 144         o = fm->array->get_index(fm->array, $position);
 145         if(o) {
 146                 char* str = o->to_json(o);
 147                 buffer_fadd(buf, "  $field\\t: %s\\n", str);
 148                 free(str);
 149         };
 150 CODE
 151
 152                 $fstring_string .= <<CODE;
 153                 tmp = new_object(NULL);
 154                 tmp->is_null = 1;
 155                 obj->set_index(obj, $position, tmp);
 156 CODE
 157
 158                 $header_string .= <<CODE;
 159         object*\t(*get_$field) (struct fm_${short_name}_struct*);
 160         void\t\t(*set_$field) (struct fm_${short_name}_struct*, object*);
 161 CODE
 162
 163                 $constructor_string .= <<CODE;
 164         fm->set_$field = &fm_${short_name}_set_$field;
 165         fm->get_$field = &fm_${short_name}_get_$field;
 166 CODE
 167
 168                 $func_header_string .= <<CODE;
 169 object* fm_${short_name}_get_$field(fm_$short_name*);
 170 void fm_${short_name}_set_$field(fm_$short_name*, object*);
 171 CODE
 172
 173                 $func_code_string .= <<CODE
 174         object* fm_${short_name}_get_$field(fm_$short_name* fm) {
 175                 if(!fm || !fm->array) return NULL;
 176                 return fm->array->get_index(fm->array, $position);
 177         }
 178
 179         void fm_${short_name}_set_$field(fm_$short_name* fm, object* obj) {
 180                 if(!fm || !fm->array || !obj) return;
 181                 fm->array->set_index(fm->array, $position, obj);
 182         }
 183 CODE
 184
 185         }
 186
 187         $fstring_string .= <<CODE;
 188                 return (fm_obj*) fm_new_$short_name(obj);
 189         }
 190 CODE
 191
 192         $to_string .= <<CODE;
 193         buffer_add(buf,"}\\n");
 194         char* b = buffer_data(buf);
 195         buffer_free(buf);
 196         return b;
 197 }
 198 CODE
 199
 200         $constructor_string .= "\treturn fm;\n}\n";
 201         $header_string .= "};\n";
 202         $func_code_string = $constructor_string . $to_string . $func_code_string;
 203
 204         $header_string .= "typedef struct fm_$short_name"."_struct fm_$short_name;\n\n";
 205         $header_string .= "fm_$short_name* fm_new_$short_name(object*);\n";
 206         $header_string .= "$func_header_string\n";
 207
 208         print HEADER "\n$header_string\n";
 209         print SOURCE "\n$func_code_string\n";
 210
 211
 212 }
 213
 214 $factory_string .= "\treturn fm;\n}\n";
 215 #$fstring_string .= "\treturn NULL;\n}\n";
 216 $fstring_string .= <<CODE;
 217         free_object(obj);
 218         return NULL;
 219 }
 220 CODE
 221
 222 print SOURCE "\n$factory_string\n";
 223 print SOURCE "\n$fstring_string\n";
 224
 225 close HEADER;
 226 close SOURCE;
 227
 228 warn  "done\n";
 229