git.m6w6.name Git - m6w6/ext-psi/blob - src/data.c

   1 /*******************************************************************************
   2  Copyright (c) 2016, Michael Wallner <mike@php.net>.
   3  All rights reserved.
   4
   5  Redistribution and use in source and binary forms, with or without
   6  modification, are permitted provided that the following conditions are met:
   7
   8  * Redistributions of source code must retain the above copyright notice,
   9  this list of conditions and the following disclaimer.
  10  * Redistributions in binary form must reproduce the above copyright
  11  notice, this list of conditions and the following disclaimer in the
  12  documentation and/or other materials provided with the distribution.
  13
  14  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  18  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  21  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  *******************************************************************************/
  25
  26 #include "php_psi_stdinc.h"
  27 #include "data.h"
  28
  29 #include "php_globals.h"
  30
  31 #include <dlfcn.h>
  32 #include <ctype.h>
  33
  34 struct psi_data *psi_data_ctor_with_dtors(struct psi_data *data,
  35                 psi_error_cb error, unsigned flags)
  36 {
  37         if (!data) {
  38                 data = calloc(1, sizeof(*data));
  39         }
  40
  41         data->error = error;
  42         data->flags = flags;
  43         if (!data->file.libnames) {
  44                 data->file.libnames = psi_plist_init((psi_plist_dtor) psi_names_free);
  45         }
  46         if (!data->file.dlopened) {
  47                 data->file.dlopened = psi_plist_init((psi_plist_dtor) psi_libs_free);
  48         }
  49
  50         if (!data->consts) {
  51                 data->consts = psi_plist_init((psi_plist_dtor) psi_const_free);
  52         }
  53         if (!data->types) {
  54                 data->types = psi_plist_init((psi_plist_dtor) psi_decl_arg_free);
  55         }
  56         if (!data->structs) {
  57                 data->structs = psi_plist_init((psi_plist_dtor) psi_decl_struct_free);
  58         }
  59         if (!data->unions) {
  60                 data->unions = psi_plist_init((psi_plist_dtor) psi_decl_union_free);
  61         }
  62         if (!data->enums) {
  63                 data->enums = psi_plist_init((psi_plist_dtor) psi_decl_enum_free);
  64         }
  65         if (!data->decls) {
  66                 data->decls = psi_plist_init((psi_plist_dtor) psi_decl_free);
  67         }
  68         if (!data->vars) {
  69                 data->vars = psi_plist_init((psi_plist_dtor) psi_decl_extvar_free);
  70         }
  71         if (!data->impls) {
  72                 data->impls = psi_plist_init((psi_plist_dtor) psi_impl_free);
  73         }
  74         return data;
  75 }
  76
  77 struct psi_data *psi_data_ctor(struct psi_data *data, psi_error_cb error,
  78                 unsigned flags)
  79 {
  80         if (!data) {
  81                 data = calloc(1, sizeof(*data));
  82         }
  83
  84         data->error = error;
  85         data->flags = flags;
  86
  87         if (!data->file.libnames) {
  88                 data->file.libnames = psi_plist_init(NULL);
  89         }
  90         if (!data->file.dlopened) {
  91                 data->file.dlopened = psi_plist_init(NULL);
  92         }
  93
  94         if (!data->consts) {
  95                 data->consts = psi_plist_init(NULL);
  96         }
  97         if (!data->types) {
  98                 data->types = psi_plist_init(NULL);
  99         }
 100         if (!data->structs) {
 101                 data->structs = psi_plist_init(NULL);
 102         }
 103         if (!data->unions) {
 104                 data->unions = psi_plist_init(NULL);
 105         }
 106         if (!data->enums) {
 107                 data->enums = psi_plist_init(NULL);
 108         }
 109         if (!data->decls) {
 110                 data->decls = psi_plist_init(NULL);
 111         }
 112         if (!data->vars) {
 113                 data->vars = psi_plist_init(NULL);
 114         }
 115         if (!data->impls) {
 116                 data->impls = psi_plist_init(NULL);
 117         }
 118         return data;
 119 }
 120
 121 struct psi_data *psi_data_exchange(struct psi_data *dest, struct psi_data *src)
 122 {
 123         if (!dest) {
 124                 dest = malloc(sizeof(*dest));
 125         }
 126         *dest = *src;
 127         memset(src, 0, sizeof(*src));
 128         return dest;
 129 }
 130
 131 void psi_data_dtor(struct psi_data *data)
 132 {
 133         if (data->consts) {
 134                 psi_plist_free(data->consts);
 135         }
 136         if (data->types) {
 137                 psi_plist_free(data->types);
 138         }
 139         if (data->structs) {
 140                 psi_plist_free(data->structs);
 141         }
 142         if (data->unions) {
 143                 psi_plist_free(data->unions);
 144         }
 145         if (data->enums) {
 146                 psi_plist_free(data->enums);
 147         }
 148         if (data->decls) {
 149                 psi_plist_free(data->decls);
 150         }
 151         if (data->vars) {
 152                 psi_plist_free(data->vars);
 153         }
 154         if (data->impls) {
 155                 psi_plist_free(data->impls);
 156         }
 157
 158         psi_decl_file_dtor(&data->file);
 159 }
 160
 161 void psi_data_dump(int fd, struct psi_data *D)
 162 {
 163         if (D->file.filename) {
 164                 size_t i = 0;
 165                 char *libname;
 166
 167                 dprintf(fd, "// filename=%s (%u errors)\n", D->file.filename, D->errors);
 168                 while (psi_plist_get(D->file.libnames, i++, &libname)) {
 169                         dprintf(fd, "lib \"%s\";\n", libname);
 170                 }
 171         } else {
 172                 dprintf(fd, "// builtin predef\n");
 173         }
 174         if (psi_plist_count(D->types)) {
 175                 size_t i = 0;
 176                 struct psi_decl_arg *def;
 177
 178                 while (psi_plist_get(D->types, i++, &def)) {
 179                         dprintf(fd, "typedef ");
 180                         psi_decl_arg_dump(fd, def, 0);
 181                         dprintf(fd, ";\n");
 182                 }
 183                 dprintf(fd, "\n");
 184         }
 185         if (psi_plist_count(D->unions)) {
 186                 size_t i = 0;
 187                 struct psi_decl_union *unn;
 188
 189                 while (psi_plist_get(D->unions, i++, &unn)) {
 190                         if (!psi_decl_type_is_anon(unn->name, "union")) {
 191                                 psi_decl_union_dump(fd, unn);
 192                                 dprintf(fd, "\n");
 193                         }
 194                 }
 195                 dprintf(fd, "\n");
 196         }
 197         if (psi_plist_count(D->structs)) {
 198                 size_t i = 0;
 199                 struct psi_decl_struct *strct;
 200
 201                 while (psi_plist_get(D->structs, i++, &strct)) {
 202                         if (!psi_decl_type_is_anon(strct->name, "struct")) {
 203                                 psi_decl_struct_dump(fd, strct);
 204                                 dprintf(fd, "\n");
 205                         }
 206                 }
 207                 dprintf(fd, "\n");
 208         }
 209         if (psi_plist_count(D->enums)) {
 210                 size_t i = 0;
 211                 struct psi_decl_enum *enm;
 212
 213                 while (psi_plist_get(D->enums, i++, &enm)) {
 214                         if (!psi_decl_type_is_anon(enm->name, "enum")) {
 215                                 psi_decl_enum_dump(fd, enm, 0);
 216                                 dprintf(fd, "\n");
 217                         }
 218                 }
 219                 dprintf(fd, "\n");
 220         }
 221         if (psi_plist_count(D->consts)) {
 222                 size_t i = 0;
 223                 struct psi_const *c;
 224
 225                 while (psi_plist_get(D->consts, i++, &c)) {
 226                         psi_const_dump(fd, c);
 227                         dprintf(fd, "\n");
 228                 }
 229                 dprintf(fd, "\n");
 230         }
 231         if (psi_plist_count(D->decls)) {
 232                 size_t i = 0;
 233                 struct psi_decl *decl;
 234
 235                 while (psi_plist_get(D->decls, i++, &decl)) {
 236                         psi_decl_dump(fd, decl);
 237                         dprintf(fd, "\n");
 238                 }
 239                 dprintf(fd, "\n");
 240         }
 241         if (psi_plist_count(D->vars)) {
 242                 size_t i = 0;
 243                 struct psi_decl_extvar *evar;
 244
 245                 while (psi_plist_get(D->vars, i++, &evar)) {
 246                         psi_decl_extvar_dump(fd, evar);
 247                 }
 248                 dprintf(fd, "\n");
 249         }
 250         if (psi_plist_count(D->impls)) {
 251                 size_t i = 0;
 252                 struct psi_impl *impl;
 253
 254                 while (psi_plist_get(D->impls, i++, &impl)) {
 255                         psi_impl_dump(fd, impl);
 256                         dprintf(fd, "\n");
 257                 }
 258                 dprintf(fd, "\n");
 259         }
 260 }