src/moonshot-webp-parser.c

   1 /* moonshot-webp-parser.c generated by valac 0.10.4, the Vala compiler
   2  * generated from moonshot-webp-parser.vala, do not modify */
   3
   4
   5 #include <glib.h>
   6 #include <glib-object.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <gio/gio.h>
  10 #include <glib/gstdio.h>
  11 #include <libmoonshot.h>
  12 #include <stdio.h>
  13 #include <gobject/gvaluecollector.h>
  14
  15
  16 #define TYPE_ID_CARD (id_card_get_type ())
  17 #define ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ID_CARD, IdCard))
  18 #define ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ID_CARD, IdCardClass))
  19 #define IS_ID_CARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ID_CARD))
  20 #define IS_ID_CARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ID_CARD))
  21 #define ID_CARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ID_CARD, IdCardClass))
  22
  23 typedef struct _IdCard IdCard;
  24 typedef struct _IdCardClass IdCardClass;
  25 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
  26
  27 #define TYPE_RULE (rule_get_type ())
  28 typedef struct _Rule Rule;
  29 #define _g_free0(var) (var = (g_free (var), NULL))
  30
  31 #define TYPE_TRUST_ANCHOR (trust_anchor_get_type ())
  32 #define TRUST_ANCHOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TRUST_ANCHOR, TrustAnchor))
  33 #define TRUST_ANCHOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TRUST_ANCHOR, TrustAnchorClass))
  34 #define IS_TRUST_ANCHOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TRUST_ANCHOR))
  35 #define IS_TRUST_ANCHOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TRUST_ANCHOR))
  36 #define TRUST_ANCHOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TRUST_ANCHOR, TrustAnchorClass))
  37
  38 typedef struct _TrustAnchor TrustAnchor;
  39 typedef struct _TrustAnchorClass TrustAnchorClass;
  40
  41 #define WEB_PROVISIONING_TYPE_PARSER (web_provisioning_parser_get_type ())
  42 #define WEB_PROVISIONING_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParser))
  43 #define WEB_PROVISIONING_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParserClass))
  44 #define WEB_PROVISIONING_IS_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WEB_PROVISIONING_TYPE_PARSER))
  45 #define WEB_PROVISIONING_IS_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), WEB_PROVISIONING_TYPE_PARSER))
  46 #define WEB_PROVISIONING_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParserClass))
  47
  48 typedef struct _WebProvisioningParser WebProvisioningParser;
  49 typedef struct _WebProvisioningParserClass WebProvisioningParserClass;
  50 typedef struct _WebProvisioningParserPrivate WebProvisioningParserPrivate;
  51 #define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
  52 #define _g_markup_parse_context_free0(var) ((var == NULL) ? NULL : (var = (g_markup_parse_context_free (var), NULL)))
  53 typedef struct _WebProvisioningParamSpecParser WebProvisioningParamSpecParser;
  54 #define _moonshot_error_free0(var) ((var == NULL) ? NULL : (var = (moonshot_error_free (var), NULL)))
  55 #define _web_provisioning_parser_unref0(var) ((var == NULL) ? NULL : (var = (web_provisioning_parser_unref (var), NULL)))
  56
  57 struct _Rule {
  58         char* pattern;
  59         char* always_confirm;
  60 };
  61
  62 struct _WebProvisioningParser {
  63         GTypeInstance parent_instance;
  64         volatile int ref_count;
  65         WebProvisioningParserPrivate * priv;
  66 };
  67
  68 struct _WebProvisioningParserClass {
  69         GTypeClass parent_class;
  70         void (*finalize) (WebProvisioningParser *self);
  71 };
  72
  73 struct _WebProvisioningParserPrivate {
  74         GMarkupParser parser;
  75         char* text;
  76         char* path;
  77 };
  78
  79 struct _WebProvisioningParamSpecParser {
  80         GParamSpec parent_instance;
  81 };
  82
  83
  84 extern IdCard* web_provisioning_card;
  85 IdCard* web_provisioning_card = NULL;
  86 extern IdCard** web_provisioning_cards;
  87 extern gint web_provisioning_cards_length1;
  88 IdCard** web_provisioning_cards = NULL;
  89 gint web_provisioning_cards_length1 = 0;
  90 static gint _web_provisioning_cards_size_ = 0;
  91 static gpointer web_provisioning_parser_parent_class = NULL;
  92
  93 GType id_card_get_type (void) G_GNUC_CONST;
  94 gboolean web_provisioning_check_stack (GSList* stack, char** reference, int reference_length1);
  95 gboolean web_provisioning_always_confirm_handler (GSList* stack);
  96 gboolean web_provisioning_pattern_handler (GSList* stack);
  97 gboolean web_provisioning_server_cert_handler (GSList* stack);
  98 gboolean web_provisioning_subject_alt_handler (GSList* stack);
  99 gboolean web_provisioning_subject_handler (GSList* stack);
 100 gboolean web_provisioning_ca_cert_handler (GSList* stack);
 101 gboolean web_provisioning_realm_handler (GSList* stack);
 102 gboolean web_provisioning_password_handler (GSList* stack);
 103 gboolean web_provisioning_user_handler (GSList* stack);
 104 gboolean web_provisioning_display_name_handler (GSList* stack);
 105 void web_provisioning_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, GError** error);
 106 static IdCard** _vala_array_dup1 (IdCard** self, int length);
 107 IdCard* id_card_new (void);
 108 IdCard* id_card_construct (GType object_type);
 109 GType rule_get_type (void) G_GNUC_CONST;
 110 Rule* rule_dup (const Rule* self);
 111 void rule_free (Rule* self);
 112 void rule_copy (const Rule* self, Rule* dest);
 113 void rule_destroy (Rule* self);
 114 Rule* id_card_get_rules (IdCard* self, int* result_length1);
 115 static Rule* _vala_array_dup2 (Rule* self, int length);
 116 void id_card_set_rules (IdCard* self, Rule* value, int value_length1);
 117 static void _vala_Rule_array_free (Rule* array, gint array_length);
 118 void web_provisioning_text_element_func (GMarkupParseContext* context, const char* text, gsize text_len, GError** error);
 119 void id_card_set_display_name (IdCard* self, const char* value);
 120 void id_card_set_username (IdCard* self, const char* value);
 121 void id_card_set_password (IdCard* self, const char* value);
 122 void id_card_set_issuer (IdCard* self, const char* value);
 123 char** id_card_get_services (IdCard* self, int* result_length1);
 124 static char** _vala_array_dup3 (char** self, int length);
 125 void id_card_set_services (IdCard* self, char** value, int value_length1);
 126 GType trust_anchor_get_type (void) G_GNUC_CONST;
 127 TrustAnchor* id_card_get_trust_anchor (IdCard* self);
 128 void trust_anchor_set_ca_cert (TrustAnchor* self, const char* value);
 129 void trust_anchor_set_subject (TrustAnchor* self, const char* value);
 130 void trust_anchor_set_subject_alt (TrustAnchor* self, const char* value);
 131 void trust_anchor_set_server_cert (TrustAnchor* self, const char* value);
 132 gpointer web_provisioning_parser_ref (gpointer instance);
 133 void web_provisioning_parser_unref (gpointer instance);
 134 GParamSpec* web_provisioning_param_spec_parser (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 135 void web_provisioning_value_set_parser (GValue* value, gpointer v_object);
 136 void web_provisioning_value_take_parser (GValue* value, gpointer v_object);
 137 gpointer web_provisioning_value_get_parser (const GValue* value);
 138 GType web_provisioning_parser_get_type (void) G_GNUC_CONST;
 139 #define WEB_PROVISIONING_PARSER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), WEB_PROVISIONING_TYPE_PARSER, WebProvisioningParserPrivate))
 140 enum  {
 141         WEB_PROVISIONING_PARSER_DUMMY_PROPERTY
 142 };
 143 WebProvisioningParser* web_provisioning_parser_new (const char* path);
 144 WebProvisioningParser* web_provisioning_parser_construct (GType object_type, const char* path);
 145 static void _web_provisioning_start_element_func_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self, GError** error);
 146 static void _web_provisioning_text_element_func_gmarkup_parser_text_func (GMarkupParseContext* context, const char* text, gsize text_len, gpointer self, GError** error);
 147 void web_provisioning_parser_parse (WebProvisioningParser* self);
 148 static void web_provisioning_parser_finalize (WebProvisioningParser* obj);
 149 gint web_provisioning_main (char** args, int args_length1);
 150 const char* id_card_get_display_name (IdCard* self);
 151 const char* id_card_get_username (IdCard* self);
 152 const char* id_card_get_password (IdCard* self);
 153 const char* id_card_get_issuer (IdCard* self);
 154 const char* trust_anchor_get_ca_cert (TrustAnchor* self);
 155 const char* trust_anchor_get_subject (TrustAnchor* self);
 156 const char* trust_anchor_get_subject_alt (TrustAnchor* self);
 157 const char* trust_anchor_get_server_cert (TrustAnchor* self);
 158 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 159 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 160 static gint _vala_array_length (gpointer array);
 161 static int _vala_strcmp0 (const char * str1, const char * str2);
 162
 163
 164
 165 gboolean web_provisioning_check_stack (GSList* stack, char** reference, int reference_length1) {
 166         gboolean result = FALSE;
 167         if (g_slist_length (stack) < reference_length1) {
 168                 result = FALSE;
 169                 return result;
 170         }
 171         {
 172                 gint i;
 173                 i = 0;
 174                 {
 175                         gboolean _tmp0_;
 176                         _tmp0_ = TRUE;
 177                         while (TRUE) {
 178                                 if (!_tmp0_) {
 179                                         i++;
 180                                 }
 181                                 _tmp0_ = FALSE;
 182                                 if (!(i < reference_length1)) {
 183                                         break;
 184                                 }
 185                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) i), reference[i]) != 0) {
 186                                         result = FALSE;
 187                                         return result;
 188                                 }
 189                         }
 190                 }
 191         }
 192         result = TRUE;
 193         return result;
 194 }
 195
 196
 197 gboolean web_provisioning_always_confirm_handler (GSList* stack) {
 198         gboolean result = FALSE;
 199         gint always_confirm_path_length1;
 200         gint _always_confirm_path_size_;
 201         char** _tmp1_;
 202         char** _tmp0_ = NULL;
 203         char** always_confirm_path;
 204         always_confirm_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 5 + 1), _tmp0_[0] = g_strdup ("always-confirm"), _tmp0_[1] = g_strdup ("rule"), _tmp0_[2] = g_strdup ("selection-rules"), _tmp0_[3] = g_strdup ("identity"), _tmp0_[4] = g_strdup ("identities"), _tmp0_), always_confirm_path_length1 = 5, _always_confirm_path_size_ = always_confirm_path_length1, _tmp1_);
 205         result = web_provisioning_check_stack (stack, always_confirm_path, always_confirm_path_length1);
 206         always_confirm_path = (_vala_array_free (always_confirm_path, always_confirm_path_length1, (GDestroyNotify) g_free), NULL);
 207         return result;
 208 }
 209
 210
 211 gboolean web_provisioning_pattern_handler (GSList* stack) {
 212         gboolean result = FALSE;
 213         gint pattern_path_length1;
 214         gint _pattern_path_size_;
 215         char** _tmp1_;
 216         char** _tmp0_ = NULL;
 217         char** pattern_path;
 218         pattern_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 5 + 1), _tmp0_[0] = g_strdup ("pattern"), _tmp0_[1] = g_strdup ("rule"), _tmp0_[2] = g_strdup ("selection-rules"), _tmp0_[3] = g_strdup ("identity"), _tmp0_[4] = g_strdup ("identities"), _tmp0_), pattern_path_length1 = 5, _pattern_path_size_ = pattern_path_length1, _tmp1_);
 219         result = web_provisioning_check_stack (stack, pattern_path, pattern_path_length1);
 220         pattern_path = (_vala_array_free (pattern_path, pattern_path_length1, (GDestroyNotify) g_free), NULL);
 221         return result;
 222 }
 223
 224
 225 gboolean web_provisioning_server_cert_handler (GSList* stack) {
 226         gboolean result = FALSE;
 227         gint server_cert_path_length1;
 228         gint _server_cert_path_size_;
 229         char** _tmp1_;
 230         char** _tmp0_ = NULL;
 231         char** server_cert_path;
 232         server_cert_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("server-cert"), _tmp0_[1] = g_strdup ("trust-anchor"), _tmp0_[2] = g_strdup ("identity"), _tmp0_[3] = g_strdup ("identities"), _tmp0_), server_cert_path_length1 = 4, _server_cert_path_size_ = server_cert_path_length1, _tmp1_);
 233         result = web_provisioning_check_stack (stack, server_cert_path, server_cert_path_length1);
 234         server_cert_path = (_vala_array_free (server_cert_path, server_cert_path_length1, (GDestroyNotify) g_free), NULL);
 235         return result;
 236 }
 237
 238
 239 gboolean web_provisioning_subject_alt_handler (GSList* stack) {
 240         gboolean result = FALSE;
 241         gint subject_alt_path_length1;
 242         gint _subject_alt_path_size_;
 243         char** _tmp1_;
 244         char** _tmp0_ = NULL;
 245         char** subject_alt_path;
 246         subject_alt_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("subject-alt"), _tmp0_[1] = g_strdup ("trust-anchor"), _tmp0_[2] = g_strdup ("identity"), _tmp0_[3] = g_strdup ("identities"), _tmp0_), subject_alt_path_length1 = 4, _subject_alt_path_size_ = subject_alt_path_length1, _tmp1_);
 247         result = web_provisioning_check_stack (stack, subject_alt_path, subject_alt_path_length1);
 248         subject_alt_path = (_vala_array_free (subject_alt_path, subject_alt_path_length1, (GDestroyNotify) g_free), NULL);
 249         return result;
 250 }
 251
 252
 253 gboolean web_provisioning_subject_handler (GSList* stack) {
 254         gboolean result = FALSE;
 255         gint subject_path_length1;
 256         gint _subject_path_size_;
 257         char** _tmp1_;
 258         char** _tmp0_ = NULL;
 259         char** subject_path;
 260         subject_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("subject"), _tmp0_[1] = g_strdup ("trust-anchor"), _tmp0_[2] = g_strdup ("identity"), _tmp0_[3] = g_strdup ("identities"), _tmp0_), subject_path_length1 = 4, _subject_path_size_ = subject_path_length1, _tmp1_);
 261         result = web_provisioning_check_stack (stack, subject_path, subject_path_length1);
 262         subject_path = (_vala_array_free (subject_path, subject_path_length1, (GDestroyNotify) g_free), NULL);
 263         return result;
 264 }
 265
 266
 267 gboolean web_provisioning_ca_cert_handler (GSList* stack) {
 268         gboolean result = FALSE;
 269         gint ca_path_length1;
 270         gint _ca_path_size_;
 271         char** _tmp1_;
 272         char** _tmp0_ = NULL;
 273         char** ca_path;
 274         ca_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 4 + 1), _tmp0_[0] = g_strdup ("ca-cert"), _tmp0_[1] = g_strdup ("trust-anchor"), _tmp0_[2] = g_strdup ("identity"), _tmp0_[3] = g_strdup ("identities"), _tmp0_), ca_path_length1 = 4, _ca_path_size_ = ca_path_length1, _tmp1_);
 275         result = web_provisioning_check_stack (stack, ca_path, ca_path_length1);
 276         ca_path = (_vala_array_free (ca_path, ca_path_length1, (GDestroyNotify) g_free), NULL);
 277         return result;
 278 }
 279
 280
 281 gboolean web_provisioning_realm_handler (GSList* stack) {
 282         gboolean result = FALSE;
 283         gint realm_path_length1;
 284         gint _realm_path_size_;
 285         char** _tmp1_;
 286         char** _tmp0_ = NULL;
 287         char** realm_path;
 288         realm_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 3 + 1), _tmp0_[0] = g_strdup ("realm"), _tmp0_[1] = g_strdup ("identity"), _tmp0_[2] = g_strdup ("identities"), _tmp0_), realm_path_length1 = 3, _realm_path_size_ = realm_path_length1, _tmp1_);
 289         result = web_provisioning_check_stack (stack, realm_path, realm_path_length1);
 290         realm_path = (_vala_array_free (realm_path, realm_path_length1, (GDestroyNotify) g_free), NULL);
 291         return result;
 292 }
 293
 294
 295 gboolean web_provisioning_password_handler (GSList* stack) {
 296         gboolean result = FALSE;
 297         gint password_path_length1;
 298         gint _password_path_size_;
 299         char** _tmp1_;
 300         char** _tmp0_ = NULL;
 301         char** password_path;
 302         password_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 3 + 1), _tmp0_[0] = g_strdup ("password"), _tmp0_[1] = g_strdup ("identity"), _tmp0_[2] = g_strdup ("identities"), _tmp0_), password_path_length1 = 3, _password_path_size_ = password_path_length1, _tmp1_);
 303         result = web_provisioning_check_stack (stack, password_path, password_path_length1);
 304         password_path = (_vala_array_free (password_path, password_path_length1, (GDestroyNotify) g_free), NULL);
 305         return result;
 306 }
 307
 308
 309 gboolean web_provisioning_user_handler (GSList* stack) {
 310         gboolean result = FALSE;
 311         gint user_path_length1;
 312         gint _user_path_size_;
 313         char** _tmp1_;
 314         char** _tmp0_ = NULL;
 315         char** user_path;
 316         user_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 3 + 1), _tmp0_[0] = g_strdup ("user"), _tmp0_[1] = g_strdup ("identity"), _tmp0_[2] = g_strdup ("identities"), _tmp0_), user_path_length1 = 3, _user_path_size_ = user_path_length1, _tmp1_);
 317         result = web_provisioning_check_stack (stack, user_path, user_path_length1);
 318         user_path = (_vala_array_free (user_path, user_path_length1, (GDestroyNotify) g_free), NULL);
 319         return result;
 320 }
 321
 322
 323 gboolean web_provisioning_display_name_handler (GSList* stack) {
 324         gboolean result = FALSE;
 325         gint display_name_path_length1;
 326         gint _display_name_path_size_;
 327         char** _tmp1_;
 328         char** _tmp0_ = NULL;
 329         char** display_name_path;
 330         display_name_path = (_tmp1_ = (_tmp0_ = g_new0 (char*, 3 + 1), _tmp0_[0] = g_strdup ("display-name"), _tmp0_[1] = g_strdup ("identity"), _tmp0_[2] = g_strdup ("identities"), _tmp0_), display_name_path_length1 = 3, _display_name_path_size_ = display_name_path_length1, _tmp1_);
 331         result = web_provisioning_check_stack (stack, display_name_path, display_name_path_length1);
 332         display_name_path = (_vala_array_free (display_name_path, display_name_path_length1, (GDestroyNotify) g_free), NULL);
 333         return result;
 334 }
 335
 336
 337 static gpointer _g_object_ref0 (gpointer self) {
 338         return self ? g_object_ref (self) : NULL;
 339 }
 340
 341
 342 static IdCard** _vala_array_dup1 (IdCard** self, int length) {
 343         IdCard** result;
 344         int i;
 345         result = g_new0 (IdCard*, length + 1);
 346         for (i = 0; i < length; i++) {
 347                 result[i] = _g_object_ref0 (self[i]);
 348         }
 349         return result;
 350 }
 351
 352
 353 static Rule* _vala_array_dup2 (Rule* self, int length) {
 354         Rule* result;
 355         int i;
 356         Rule _tmp0_ = {0};
 357         result = g_new0 (Rule, length);
 358         for (i = 0; i < length; i++) {
 359                 result[i] = (rule_copy (&self[i], &_tmp0_), _tmp0_);
 360         }
 361         return result;
 362 }
 363
 364
 365 static void _vala_Rule_array_free (Rule* array, gint array_length) {
 366         if (array != NULL) {
 367                 int i;
 368                 for (i = 0; i < array_length; i = i + 1) {
 369                         rule_destroy (&array[i]);
 370                 }
 371         }
 372         g_free (array);
 373 }
 374
 375
 376 void web_provisioning_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, int attribute_names_length1, char** attribute_values, int attribute_values_length1, GError** error) {
 377         g_return_if_fail (context != NULL);
 378         g_return_if_fail (element_name != NULL);
 379         if (_vala_strcmp0 (element_name, "identity") == 0) {
 380                 gint tmp_cards_length1;
 381                 gint _tmp_cards_size_;
 382                 IdCard** _tmp1_;
 383                 IdCard** _tmp0_;
 384                 IdCard** tmp_cards;
 385                 IdCard** _tmp2_;
 386                 IdCard* _tmp5_;
 387                 IdCard* _tmp6_;
 388                 tmp_cards = (_tmp1_ = (_tmp0_ = web_provisioning_cards, (_tmp0_ == NULL) ? ((gpointer) _tmp0_) : _vala_array_dup1 (_tmp0_, web_provisioning_cards_length1)), tmp_cards_length1 = web_provisioning_cards_length1, _tmp_cards_size_ = tmp_cards_length1, _tmp1_);
 389                 web_provisioning_cards = (_tmp2_ = g_new0 (IdCard*, (tmp_cards_length1 + 1) + 1), web_provisioning_cards = (_vala_array_free (web_provisioning_cards, web_provisioning_cards_length1, (GDestroyNotify) g_object_unref), NULL), web_provisioning_cards_length1 = tmp_cards_length1 + 1, _web_provisioning_cards_size_ = web_provisioning_cards_length1, _tmp2_);
 390                 {
 391                         gint i;
 392                         i = 0;
 393                         {
 394                                 gboolean _tmp3_;
 395                                 _tmp3_ = TRUE;
 396                                 while (TRUE) {
 397                                         IdCard* _tmp4_;
 398                                         if (!_tmp3_) {
 399                                                 i++;
 400                                         }
 401                                         _tmp3_ = FALSE;
 402                                         if (!(i < tmp_cards_length1)) {
 403                                                 break;
 404                                         }
 405                                         web_provisioning_cards[i] = (_tmp4_ = _g_object_ref0 (tmp_cards[i]), _g_object_unref0 (web_provisioning_cards[i]), _tmp4_);
 406                                 }
 407                         }
 408                 }
 409                 web_provisioning_card = (_tmp5_ = id_card_new (), _g_object_unref0 (web_provisioning_card), _tmp5_);
 410                 web_provisioning_cards[tmp_cards_length1] = (_tmp6_ = _g_object_ref0 (web_provisioning_card), _g_object_unref0 (web_provisioning_cards[tmp_cards_length1]), _tmp6_);
 411                 tmp_cards = (_vala_array_free (tmp_cards, tmp_cards_length1, (GDestroyNotify) g_object_unref), NULL);
 412         } else {
 413                 if (_vala_strcmp0 (element_name, "rule") == 0) {
 414                         gint tmp_rules_length1;
 415                         gint _tmp_rules_size_;
 416                         Rule* _tmp9_;
 417                         gint _tmp7_;
 418                         Rule* _tmp8_;
 419                         Rule* tmp_rules;
 420                         Rule* _tmp10_;
 421                         gint _tmp10__length1;
 422                         Rule* _tmp11_;
 423                         gint _tmp18_;
 424                         Rule _tmp19_ = {0};
 425                         gint _tmp20_;
 426                         Rule *_tmp21_;
 427                         Rule _tmp22_;
 428                         tmp_rules = (_tmp9_ = (_tmp8_ = id_card_get_rules (web_provisioning_card, &_tmp7_), (_tmp8_ == NULL) ? ((gpointer) _tmp8_) : _vala_array_dup2 (_tmp8_, _tmp7_)), tmp_rules_length1 = _tmp7_, _tmp_rules_size_ = tmp_rules_length1, _tmp9_);
 429                         _tmp11_ = (_tmp10_ = g_new0 (Rule, tmp_rules_length1 + 1), _tmp10__length1 = tmp_rules_length1 + 1, _tmp10_);
 430                         id_card_set_rules (web_provisioning_card, _tmp11_, tmp_rules_length1 + 1);
 431                         _tmp10_ = (_vala_Rule_array_free (_tmp10_, _tmp10__length1), NULL);
 432                         {
 433                                 gint i;
 434                                 i = 0;
 435                                 {
 436                                         gboolean _tmp12_;
 437                                         _tmp12_ = TRUE;
 438                                         while (TRUE) {
 439                                                 gint _tmp13_;
 440                                                 Rule _tmp14_ = {0};
 441                                                 gint _tmp15_;
 442                                                 Rule *_tmp16_;
 443                                                 Rule _tmp17_;
 444                                                 if (!_tmp12_) {
 445                                                         i++;
 446                                                 }
 447                                                 _tmp12_ = FALSE;
 448                                                 if (!(i < tmp_rules_length1)) {
 449                                                         break;
 450                                                 }
 451                                                 _tmp16_ = &id_card_get_rules (web_provisioning_card, &_tmp15_)[i];
 452                                                 (*_tmp16_) = (_tmp17_ = (rule_copy (&tmp_rules[i], &_tmp14_), _tmp14_), rule_destroy (&(*_tmp16_)), _tmp17_);
 453                                         }
 454                                 }
 455                         }
 456                         _tmp21_ = &id_card_get_rules (web_provisioning_card, &_tmp20_)[tmp_rules_length1];
 457                         (*_tmp21_) = (_tmp22_ = (memset (&_tmp19_, 0, sizeof (Rule)), _tmp19_), rule_destroy (&(*_tmp21_)), _tmp22_);
 458                         tmp_rules = (_vala_Rule_array_free (tmp_rules, tmp_rules_length1), NULL);
 459                 }
 460         }
 461 }
 462
 463
 464 static char** _vala_array_dup3 (char** self, int length) {
 465         char** result;
 466         int i;
 467         result = g_new0 (char*, length + 1);
 468         for (i = 0; i < length; i++) {
 469                 result[i] = g_strdup (self[i]);
 470         }
 471         return result;
 472 }
 473
 474
 475 void web_provisioning_text_element_func (GMarkupParseContext* context, const char* text, gsize text_len, GError** error) {
 476         GSList* stack;
 477         gboolean _tmp0_ = FALSE;
 478         g_return_if_fail (context != NULL);
 479         g_return_if_fail (text != NULL);
 480         stack = g_markup_parse_context_get_element_stack (context);
 481         if (text_len < 1) {
 482                 return;
 483         }
 484         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "display-name") == 0) {
 485                 _tmp0_ = web_provisioning_display_name_handler (stack);
 486         } else {
 487                 _tmp0_ = FALSE;
 488         }
 489         if (_tmp0_) {
 490                 id_card_set_display_name (web_provisioning_card, text);
 491         } else {
 492                 gboolean _tmp1_ = FALSE;
 493                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "user") == 0) {
 494                         _tmp1_ = web_provisioning_user_handler (stack);
 495                 } else {
 496                         _tmp1_ = FALSE;
 497                 }
 498                 if (_tmp1_) {
 499                         id_card_set_username (web_provisioning_card, text);
 500                 } else {
 501                         gboolean _tmp2_ = FALSE;
 502                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "password") == 0) {
 503                                 _tmp2_ = web_provisioning_password_handler (stack);
 504                         } else {
 505                                 _tmp2_ = FALSE;
 506                         }
 507                         if (_tmp2_) {
 508                                 id_card_set_password (web_provisioning_card, text);
 509                         } else {
 510                                 gboolean _tmp3_ = FALSE;
 511                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "realm") == 0) {
 512                                         _tmp3_ = web_provisioning_realm_handler (stack);
 513                                 } else {
 514                                         _tmp3_ = FALSE;
 515                                 }
 516                                 if (_tmp3_) {
 517                                         id_card_set_issuer (web_provisioning_card, text);
 518                                 } else {
 519                                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "service") == 0) {
 520                                                 gint services_length1;
 521                                                 gint _services_size_;
 522                                                 char** _tmp6_;
 523                                                 gint _tmp4_;
 524                                                 char** _tmp5_;
 525                                                 char** services;
 526                                                 char** _tmp7_;
 527                                                 gint _tmp7__length1;
 528                                                 char** _tmp8_;
 529                                                 gint _tmp14_;
 530                                                 gint _tmp15_;
 531                                                 char* *_tmp16_;
 532                                                 char* _tmp17_;
 533                                                 services = (_tmp6_ = (_tmp5_ = id_card_get_services (web_provisioning_card, &_tmp4_), (_tmp5_ == NULL) ? ((gpointer) _tmp5_) : _vala_array_dup3 (_tmp5_, _tmp4_)), services_length1 = _tmp4_, _services_size_ = services_length1, _tmp6_);
 534                                                 _tmp8_ = (_tmp7_ = g_new0 (char*, (services_length1 + 1) + 1), _tmp7__length1 = services_length1 + 1, _tmp7_);
 535                                                 id_card_set_services (web_provisioning_card, _tmp8_, services_length1 + 1);
 536                                                 _tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
 537                                                 {
 538                                                         gint i;
 539                                                         i = 0;
 540                                                         {
 541                                                                 gboolean _tmp9_;
 542                                                                 _tmp9_ = TRUE;
 543                                                                 while (TRUE) {
 544                                                                         gint _tmp10_;
 545                                                                         gint _tmp11_;
 546                                                                         char* *_tmp12_;
 547                                                                         char* _tmp13_;
 548                                                                         if (!_tmp9_) {
 549                                                                                 i++;
 550                                                                         }
 551                                                                         _tmp9_ = FALSE;
 552                                                                         if (!(i < services_length1)) {
 553                                                                                 break;
 554                                                                         }
 555                                                                         _tmp12_ = &id_card_get_services (web_provisioning_card, &_tmp11_)[i];
 556                                                                         (*_tmp12_) = (_tmp13_ = g_strdup (services[i]), _g_free0 ((*_tmp12_)), _tmp13_);
 557                                                                 }
 558                                                         }
 559                                                 }
 560                                                 _tmp16_ = &id_card_get_services (web_provisioning_card, &_tmp15_)[services_length1];
 561                                                 (*_tmp16_) = (_tmp17_ = g_strdup (text), _g_free0 ((*_tmp16_)), _tmp17_);
 562                                                 services = (_vala_array_free (services, services_length1, (GDestroyNotify) g_free), NULL);
 563                                         } else {
 564                                                 gboolean _tmp18_ = FALSE;
 565                                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "pattern") == 0) {
 566                                                         _tmp18_ = web_provisioning_pattern_handler (stack);
 567                                                 } else {
 568                                                         _tmp18_ = FALSE;
 569                                                 }
 570                                                 if (_tmp18_) {
 571                                                         gint _tmp19_;
 572                                                         gint _tmp20_;
 573                                                         char* *_tmp21_;
 574                                                         char* _tmp22_;
 575                                                         _tmp21_ = &id_card_get_rules (web_provisioning_card, &_tmp19_)[_tmp20_ - 1].pattern;
 576                                                         (*_tmp21_) = (_tmp22_ = g_strdup (text), _g_free0 ((*_tmp21_)), _tmp22_);
 577                                                 } else {
 578                                                         gboolean _tmp23_ = FALSE;
 579                                                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "always-confirm") == 0) {
 580                                                                 _tmp23_ = web_provisioning_always_confirm_handler (stack);
 581                                                         } else {
 582                                                                 _tmp23_ = FALSE;
 583                                                         }
 584                                                         if (_tmp23_) {
 585                                                                 gboolean _tmp24_ = FALSE;
 586                                                                 if (_vala_strcmp0 (text, "true") == 0) {
 587                                                                         _tmp24_ = TRUE;
 588                                                                 } else {
 589                                                                         _tmp24_ = _vala_strcmp0 (text, "false") == 0;
 590                                                                 }
 591                                                                 if (_tmp24_) {
 592                                                                         gint _tmp25_;
 593                                                                         gint _tmp26_;
 594                                                                         char* *_tmp27_;
 595                                                                         char* _tmp28_;
 596                                                                         _tmp27_ = &id_card_get_rules (web_provisioning_card, &_tmp25_)[_tmp26_ - 1].always_confirm;
 597                                                                         (*_tmp27_) = (_tmp28_ = g_strdup (text), _g_free0 ((*_tmp27_)), _tmp28_);
 598                                                                 }
 599                                                         } else {
 600                                                                 gboolean _tmp29_ = FALSE;
 601                                                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "ca-cert") == 0) {
 602                                                                         _tmp29_ = web_provisioning_ca_cert_handler (stack);
 603                                                                 } else {
 604                                                                         _tmp29_ = FALSE;
 605                                                                 }
 606                                                                 if (_tmp29_) {
 607                                                                         trust_anchor_set_ca_cert (id_card_get_trust_anchor (web_provisioning_card), text);
 608                                                                 } else {
 609                                                                         gboolean _tmp30_ = FALSE;
 610                                                                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "subject") == 0) {
 611                                                                                 _tmp30_ = web_provisioning_subject_handler (stack);
 612                                                                         } else {
 613                                                                                 _tmp30_ = FALSE;
 614                                                                         }
 615                                                                         if (_tmp30_) {
 616                                                                                 trust_anchor_set_subject (id_card_get_trust_anchor (web_provisioning_card), text);
 617                                                                         } else {
 618                                                                                 gboolean _tmp31_ = FALSE;
 619                                                                                 if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "subject-alt") == 0) {
 620                                                                                         _tmp31_ = web_provisioning_subject_alt_handler (stack);
 621                                                                                 } else {
 622                                                                                         _tmp31_ = FALSE;
 623                                                                                 }
 624                                                                                 if (_tmp31_) {
 625                                                                                         trust_anchor_set_subject_alt (id_card_get_trust_anchor (web_provisioning_card), text);
 626                                                                                 } else {
 627                                                                                         gboolean _tmp32_ = FALSE;
 628                                                                                         if (_vala_strcmp0 ((const char*) g_slist_nth_data (stack, (guint) 0), "server-cert") == 0) {
 629                                                                                                 _tmp32_ = web_provisioning_server_cert_handler (stack);
 630                                                                                         } else {
 631                                                                                                 _tmp32_ = FALSE;
 632                                                                                         }
 633                                                                                         if (_tmp32_) {
 634                                                                                                 trust_anchor_set_server_cert (id_card_get_trust_anchor (web_provisioning_card), text);
 635                                                                                         }
 636                                                                                 }
 637                                                                         }
 638                                                                 }
 639                                                         }
 640                                                 }
 641                                         }
 642                                 }
 643                         }
 644                 }
 645         }
 646 }
 647
 648
 649 static void _web_provisioning_start_element_func_gmarkup_parser_start_element_func (GMarkupParseContext* context, const char* element_name, char** attribute_names, char** attribute_values, gpointer self, GError** error) {
 650         web_provisioning_start_element_func (context, element_name, attribute_names, _vala_array_length (attribute_names), attribute_values, _vala_array_length (attribute_values), error);
 651 }
 652
 653
 654 static void _web_provisioning_text_element_func_gmarkup_parser_text_func (GMarkupParseContext* context, const char* text, gsize text_len, gpointer self, GError** error) {
 655         web_provisioning_text_element_func (context, text, text_len, error);
 656 }
 657
 658
 659 WebProvisioningParser* web_provisioning_parser_construct (GType object_type, const char* path) {
 660         WebProvisioningParser* self = (WebProvisioningParser*) g_type_create_instance (object_type);
 661         char* _tmp0_;
 662         char* _tmp1_;
 663         GFile* file;
 664         GMarkupParser _tmp8_ = {0};
 665         GError * _inner_error_ = NULL;
 666         g_return_val_if_fail (path != NULL, NULL);
 667         self->priv->text = (_tmp0_ = g_strdup (""), _g_free0 (self->priv->text), _tmp0_);
 668         self->priv->path = (_tmp1_ = g_strdup (path), _g_free0 (self->priv->path), _tmp1_);
 669         file = g_file_new_for_path (path);
 670         {
 671                 GFileInputStream* _tmp2_;
 672                 GFileInputStream* _tmp3_;
 673                 GDataInputStream* _tmp4_;
 674                 GDataInputStream* dis;
 675                 char* line;
 676                 _tmp2_ = g_file_read (file, NULL, &_inner_error_);
 677                 if (_inner_error_ != NULL) {
 678                         goto __catch0_g_error;
 679                 }
 680                 dis = (_tmp4_ = g_data_input_stream_new ((GInputStream*) (_tmp3_ = _tmp2_)), _g_object_unref0 (_tmp3_), _tmp4_);
 681                 line = NULL;
 682                 while (TRUE) {
 683                         char* _tmp5_;
 684                         char* _tmp6_;
 685                         char* _tmp7_;
 686                         _tmp5_ = g_data_input_stream_read_line (dis, NULL, NULL, &_inner_error_);
 687                         if (_inner_error_ != NULL) {
 688                                 _g_free0 (line);
 689                                 _g_object_unref0 (dis);
 690                                 goto __catch0_g_error;
 691                         }
 692                         if (!((line = (_tmp6_ = _tmp5_, _g_free0 (line), _tmp6_)) != NULL)) {
 693                                 break;
 694                         }
 695                         self->priv->text = (_tmp7_ = g_strconcat (self->priv->text, line, NULL), _g_free0 (self->priv->text), _tmp7_);
 696                 }
 697                 _g_free0 (line);
 698                 _g_object_unref0 (dis);
 699         }
 700         goto __finally0;
 701         __catch0_g_error:
 702         {
 703                 GError * e;
 704                 e = _inner_error_;
 705                 _inner_error_ = NULL;
 706                 {
 707                         g_error ("moonshot-webp-parser.vala:220: Could not retreive file size");
 708                         _g_error_free0 (e);
 709                 }
 710         }
 711         __finally0:
 712         if (_inner_error_ != NULL) {
 713                 _g_object_unref0 (file);
 714                 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 715                 g_clear_error (&_inner_error_);
 716                 return NULL;
 717         }
 718         self->priv->parser = (_tmp8_.start_element = _web_provisioning_start_element_func_gmarkup_parser_start_element_func, _tmp8_.end_element = NULL, _tmp8_.text = _web_provisioning_text_element_func_gmarkup_parser_text_func, _tmp8_.passthrough = NULL, _tmp8_.error = NULL, _tmp8_);
 719         _g_object_unref0 (file);
 720         return self;
 721 }
 722
 723
 724 WebProvisioningParser* web_provisioning_parser_new (const char* path) {
 725         return web_provisioning_parser_construct (WEB_PROVISIONING_TYPE_PARSER, path);
 726 }
 727
 728
 729 static glong string_get_length (const char* self) {
 730         glong result;
 731         g_return_val_if_fail (self != NULL, 0L);
 732         result = g_utf8_strlen (self, (gssize) (-1));
 733         return result;
 734 }
 735
 736
 737 void web_provisioning_parser_parse (WebProvisioningParser* self) {
 738         GMarkupParseContext* ctx;
 739         GError * _inner_error_ = NULL;
 740         g_return_if_fail (self != NULL);
 741         ctx = g_markup_parse_context_new (&self->priv->parser, 0, NULL, NULL);
 742         {
 743                 g_markup_parse_context_parse (ctx, self->priv->text, (gssize) string_get_length (self->priv->text), &_inner_error_);
 744                 if (_inner_error_ != NULL) {
 745                         goto __catch1_g_error;
 746                 }
 747         }
 748         goto __finally1;
 749         __catch1_g_error:
 750         {
 751                 GError * e;
 752                 e = _inner_error_;
 753                 _inner_error_ = NULL;
 754                 {
 755                         g_error ("moonshot-webp-parser.vala:237: Could not parse %s, invalid content", self->priv->path);
 756                         _g_error_free0 (e);
 757                 }
 758         }
 759         __finally1:
 760         if (_inner_error_ != NULL) {
 761                 _g_markup_parse_context_free0 (ctx);
 762                 g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 763                 g_clear_error (&_inner_error_);
 764                 return;
 765         }
 766         _g_markup_parse_context_free0 (ctx);
 767 }
 768
 769
 770 static void web_provisioning_value_parser_init (GValue* value) {
 771         value->data[0].v_pointer = NULL;
 772 }
 773
 774
 775 static void web_provisioning_value_parser_free_value (GValue* value) {
 776         if (value->data[0].v_pointer) {
 777                 web_provisioning_parser_unref (value->data[0].v_pointer);
 778         }
 779 }
 780
 781
 782 static void web_provisioning_value_parser_copy_value (const GValue* src_value, GValue* dest_value) {
 783         if (src_value->data[0].v_pointer) {
 784                 dest_value->data[0].v_pointer = web_provisioning_parser_ref (src_value->data[0].v_pointer);
 785         } else {
 786                 dest_value->data[0].v_pointer = NULL;
 787         }
 788 }
 789
 790
 791 static gpointer web_provisioning_value_parser_peek_pointer (const GValue* value) {
 792         return value->data[0].v_pointer;
 793 }
 794
 795
 796 static gchar* web_provisioning_value_parser_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 797         if (collect_values[0].v_pointer) {
 798                 WebProvisioningParser* object;
 799                 object = collect_values[0].v_pointer;
 800                 if (object->parent_instance.g_class == NULL) {
 801                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 802                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 803                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 804                 }
 805                 value->data[0].v_pointer = web_provisioning_parser_ref (object);
 806         } else {
 807                 value->data[0].v_pointer = NULL;
 808         }
 809         return NULL;
 810 }
 811
 812
 813 static gchar* web_provisioning_value_parser_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 814         WebProvisioningParser** object_p;
 815         object_p = collect_values[0].v_pointer;
 816         if (!object_p) {
 817                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 818         }
 819         if (!value->data[0].v_pointer) {
 820                 *object_p = NULL;
 821         } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
 822                 *object_p = value->data[0].v_pointer;
 823         } else {
 824                 *object_p = web_provisioning_parser_ref (value->data[0].v_pointer);
 825         }
 826         return NULL;
 827 }
 828
 829
 830 GParamSpec* web_provisioning_param_spec_parser (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 831         WebProvisioningParamSpecParser* spec;
 832         g_return_val_if_fail (g_type_is_a (object_type, WEB_PROVISIONING_TYPE_PARSER), NULL);
 833         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 834         G_PARAM_SPEC (spec)->value_type = object_type;
 835         return G_PARAM_SPEC (spec);
 836 }
 837
 838
 839 gpointer web_provisioning_value_get_parser (const GValue* value) {
 840         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, WEB_PROVISIONING_TYPE_PARSER), NULL);
 841         return value->data[0].v_pointer;
 842 }
 843
 844
 845 void web_provisioning_value_set_parser (GValue* value, gpointer v_object) {
 846         WebProvisioningParser* old;
 847         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, WEB_PROVISIONING_TYPE_PARSER));
 848         old = value->data[0].v_pointer;
 849         if (v_object) {
 850                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, WEB_PROVISIONING_TYPE_PARSER));
 851                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 852                 value->data[0].v_pointer = v_object;
 853                 web_provisioning_parser_ref (value->data[0].v_pointer);
 854         } else {
 855                 value->data[0].v_pointer = NULL;
 856         }
 857         if (old) {
 858                 web_provisioning_parser_unref (old);
 859         }
 860 }
 861
 862
 863 void web_provisioning_value_take_parser (GValue* value, gpointer v_object) {
 864         WebProvisioningParser* old;
 865         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, WEB_PROVISIONING_TYPE_PARSER));
 866         old = value->data[0].v_pointer;
 867         if (v_object) {
 868                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, WEB_PROVISIONING_TYPE_PARSER));
 869                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 870                 value->data[0].v_pointer = v_object;
 871         } else {
 872                 value->data[0].v_pointer = NULL;
 873         }
 874         if (old) {
 875                 web_provisioning_parser_unref (old);
 876         }
 877 }
 878
 879
 880 static void web_provisioning_parser_class_init (WebProvisioningParserClass * klass) {
 881         web_provisioning_parser_parent_class = g_type_class_peek_parent (klass);
 882         WEB_PROVISIONING_PARSER_CLASS (klass)->finalize = web_provisioning_parser_finalize;
 883         g_type_class_add_private (klass, sizeof (WebProvisioningParserPrivate));
 884 }
 885
 886
 887 static void web_provisioning_parser_instance_init (WebProvisioningParser * self) {
 888         self->priv = WEB_PROVISIONING_PARSER_GET_PRIVATE (self);
 889         self->ref_count = 1;
 890 }
 891
 892
 893 static void web_provisioning_parser_finalize (WebProvisioningParser* obj) {
 894         WebProvisioningParser * self;
 895         self = WEB_PROVISIONING_PARSER (obj);
 896         _g_free0 (self->priv->text);
 897         _g_free0 (self->priv->path);
 898 }
 899
 900
 901 GType web_provisioning_parser_get_type (void) {
 902         static volatile gsize web_provisioning_parser_type_id__volatile = 0;
 903         if (g_once_init_enter (&web_provisioning_parser_type_id__volatile)) {
 904                 static const GTypeValueTable g_define_type_value_table = { web_provisioning_value_parser_init, web_provisioning_value_parser_free_value, web_provisioning_value_parser_copy_value, web_provisioning_value_parser_peek_pointer, "p", web_provisioning_value_parser_collect_value, "p", web_provisioning_value_parser_lcopy_value };
 905                 static const GTypeInfo g_define_type_info = { sizeof (WebProvisioningParserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) web_provisioning_parser_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (WebProvisioningParser), 0, (GInstanceInitFunc) web_provisioning_parser_instance_init, &g_define_type_value_table };
 906                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 907                 GType web_provisioning_parser_type_id;
 908                 web_provisioning_parser_type_id = g_type_register_fundamental (g_type_fundamental_next (), "WebProvisioningParser", &g_define_type_info, &g_define_type_fundamental_info, 0);
 909                 g_once_init_leave (&web_provisioning_parser_type_id__volatile, web_provisioning_parser_type_id);
 910         }
 911         return web_provisioning_parser_type_id__volatile;
 912 }
 913
 914
 915 gpointer web_provisioning_parser_ref (gpointer instance) {
 916         WebProvisioningParser* self;
 917         self = instance;
 918         g_atomic_int_inc (&self->ref_count);
 919         return instance;
 920 }
 921
 922
 923 void web_provisioning_parser_unref (gpointer instance) {
 924         WebProvisioningParser* self;
 925         self = instance;
 926         if (g_atomic_int_dec_and_test (&self->ref_count)) {
 927                 WEB_PROVISIONING_PARSER_GET_CLASS (self)->finalize (self);
 928                 g_type_free_instance ((GTypeInstance *) self);
 929         }
 930 }
 931
 932
 933 gint web_provisioning_main (char** args, int args_length1) {
 934         gint result = 0;
 935         WebProvisioningParser* webp;
 936         if (args_length1 < 2) {
 937                 g_error ("moonshot-webp-parser.vala:246: Usage %s [-a] WEB_PROVISIONING_FILE", args[0]);
 938         }
 939         if (!g_file_test (args[1], G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
 940                 g_error ("moonshot-webp-parser.vala:251: %s does not exist", args[1]);
 941         }
 942         webp = web_provisioning_parser_new (args[1]);
 943         web_provisioning_parser_parse (webp);
 944         {
 945                 IdCard** card_collection;
 946                 int card_collection_length1;
 947                 int card_it;
 948                 card_collection = web_provisioning_cards;
 949                 card_collection_length1 = web_provisioning_cards_length1;
 950                 for (card_it = 0; card_it < web_provisioning_cards_length1; card_it = card_it + 1) {
 951                         IdCard* card;
 952                         card = _g_object_ref0 (card_collection[card_it]);
 953                         {
 954                                 MoonshotError* _error_;
 955                                 gint rules_patterns_length1;
 956                                 gint _rules_patterns_size_;
 957                                 char** _tmp1_;
 958                                 char** _tmp0_ = NULL;
 959                                 char** rules_patterns;
 960                                 gint rules_always_confirm_length1;
 961                                 gint _rules_always_confirm_size_;
 962                                 char** _tmp3_;
 963                                 char** _tmp2_ = NULL;
 964                                 char** rules_always_confirm;
 965                                 gint _tmp4_;
 966                                 gint _tmp13_;
 967                                 MoonshotError* _tmp14_ = NULL;
 968                                 MoonshotError* _tmp15_;
 969                                 _error_ = NULL;
 970                                 rules_patterns = (_tmp1_ = (_tmp0_ = g_new0 (char*, 0 + 1), _tmp0_), rules_patterns_length1 = 0, _rules_patterns_size_ = rules_patterns_length1, _tmp1_);
 971                                 rules_always_confirm = (_tmp3_ = (_tmp2_ = g_new0 (char*, 0 + 1), _tmp2_), rules_always_confirm_length1 = 0, _rules_always_confirm_size_ = rules_always_confirm_length1, _tmp3_);
 972                                 if (_tmp4_ > 0) {
 973                                         gint i;
 974                                         gint _tmp5_;
 975                                         char** _tmp6_;
 976                                         gint _tmp7_;
 977                                         char** _tmp8_;
 978                                         i = 0;
 979                                         rules_patterns = (_tmp6_ = g_new0 (char*, _tmp5_ + 1), rules_patterns = (_vala_array_free (rules_patterns, rules_patterns_length1, (GDestroyNotify) g_free), NULL), rules_patterns_length1 = _tmp5_, _rules_patterns_size_ = rules_patterns_length1, _tmp6_);
 980                                         rules_always_confirm = (_tmp8_ = g_new0 (char*, _tmp7_ + 1), rules_always_confirm = (_vala_array_free (rules_always_confirm, rules_always_confirm_length1, (GDestroyNotify) g_free), NULL), rules_always_confirm_length1 = _tmp7_, _rules_always_confirm_size_ = rules_always_confirm_length1, _tmp8_);
 981                                         {
 982                                                 gint _tmp9_;
 983                                                 Rule* r_collection;
 984                                                 int r_collection_length1;
 985                                                 int r_it;
 986                                                 r_collection = id_card_get_rules (card, &_tmp9_);
 987                                                 r_collection_length1 = _tmp9_;
 988                                                 for (r_it = 0; r_it < _tmp9_; r_it = r_it + 1) {
 989                                                         Rule _tmp12_ = {0};
 990                                                         Rule r;
 991                                                         r = (rule_copy (&r_collection[r_it], &_tmp12_), _tmp12_);
 992                                                         {
 993                                                                 char* _tmp10_;
 994                                                                 char* _tmp11_;
 995                                                                 rules_patterns[i] = (_tmp10_ = g_strdup (r.pattern), _g_free0 (rules_patterns[i]), _tmp10_);
 996                                                                 rules_always_confirm[i] = (_tmp11_ = g_strdup (r.always_confirm), _g_free0 (rules_always_confirm[i]), _tmp11_);
 997                                                                 i++;
 998                                                                 rule_destroy (&r);
 999                                                         }
1000                                                 }
1001                                         }
1002                                 }
1003                                 moonshot_install_id_card (id_card_get_display_name (card), id_card_get_username (card), id_card_get_password (card), id_card_get_issuer (card), rules_patterns, rules_patterns_length1, rules_always_confirm, rules_always_confirm_length1, id_card_get_services (card, &_tmp13_), _tmp13_, trust_anchor_get_ca_cert (id_card_get_trust_anchor (card)), trust_anchor_get_subject (id_card_get_trust_anchor (card)), trust_anchor_get_subject_alt (id_card_get_trust_anchor (card)), trust_anchor_get_server_cert (id_card_get_trust_anchor (card)), &_tmp14_);
1004                                 _error_ = (_tmp15_ = _tmp14_, _moonshot_error_free0 (_error_), _tmp15_);
1005                                 if (_error_ != NULL) {
1006                                         fprintf (stderr, "Error: %s", _error_->message);
1007                                         rules_always_confirm = (_vala_array_free (rules_always_confirm, rules_always_confirm_length1, (GDestroyNotify) g_free), NULL);
1008                                         rules_patterns = (_vala_array_free (rules_patterns, rules_patterns_length1, (GDestroyNotify) g_free), NULL);
1009                                         _moonshot_error_free0 (_error_);
1010                                         _g_object_unref0 (card);
1011                                         continue;
1012                                 }
1013                                 rules_always_confirm = (_vala_array_free (rules_always_confirm, rules_always_confirm_length1, (GDestroyNotify) g_free), NULL);
1014                                 rules_patterns = (_vala_array_free (rules_patterns, rules_patterns_length1, (GDestroyNotify) g_free), NULL);
1015                                 _moonshot_error_free0 (_error_);
1016                                 _g_object_unref0 (card);
1017                         }
1018                 }
1019         }
1020         result = 0;
1021         _web_provisioning_parser_unref0 (webp);
1022         return result;
1023 }
1024
1025
1026 int main (int argc, char ** argv) {
1027         g_type_init ();
1028         return web_provisioning_main (argv, argc);
1029 }
1030
1031
1032 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1033         if ((array != NULL) && (destroy_func != NULL)) {
1034                 int i;
1035                 for (i = 0; i < array_length; i = i + 1) {
1036                         if (((gpointer*) array)[i] != NULL) {
1037                                 destroy_func (((gpointer*) array)[i]);
1038                         }
1039                 }
1040         }
1041 }
1042
1043
1044 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
1045         _vala_array_destroy (array, array_length, destroy_func);
1046         g_free (array);
1047 }
1048
1049
1050 static gint _vala_array_length (gpointer array) {
1051         int length;
1052         length = 0;
1053         if (array) {
1054                 while (((gpointer*) array)[length]) {
1055                         length++;
1056                 }
1057         }
1058         return length;
1059 }
1060
1061
1062 static int _vala_strcmp0 (const char * str1, const char * str2) {
1063         if (str1 == NULL) {
1064                 return -(str1 != str2);
1065         }
1066         if (str2 == NULL) {
1067                 return str1 != str2;
1068         }
1069         return strcmp (str1, str2);
1070 }
1071
1072
1073
1074