efl

1
#ifdef HAVE_CONFIG_H
2
# include "config.h"
3
#endif
4

5
#include <Eina.h>
6
#include "eolian_database.h"
7

8
EOLIAN_API Eolian_Object_Scope
9
eolian_function_scope_get(const Eolian_Function *fid, Eolian_Function_Type ftype)
10
{
11
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EOLIAN_SCOPE_UNKNOWN);
12
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, EOLIAN_SCOPE_UNKNOWN);
13
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, EOLIAN_SCOPE_UNKNOWN);
14
   switch (ftype)
15
     {
16
      case EOLIAN_METHOD:
17
        if (fid->type != EOLIAN_METHOD)
18
          return EOLIAN_SCOPE_UNKNOWN;
19
        return fid->get_scope;
20
      case EOLIAN_PROP_GET:
21
        if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
22
          return EOLIAN_SCOPE_UNKNOWN;
23
        return fid->get_scope;
24
      case EOLIAN_PROP_SET:
25
        if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
26
          return EOLIAN_SCOPE_UNKNOWN;
27
        return fid->set_scope;
28
      default:
29
        return EOLIAN_SCOPE_UNKNOWN;
30
     }
31
}
32

33
EOLIAN_API Eolian_Function_Type
34
eolian_function_type_get(const Eolian_Function *fid)
35
{
36
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EOLIAN_UNRESOLVED);
37
   return fid->type;
38
}
39

40
static const char *
41
_get_c_prefix(const Eolian_Function *foo_id, char *buf)
42
{
43
    if (foo_id->klass->c_prefix)
44
      return foo_id->klass->c_prefix;
45
    strcpy(buf, foo_id->klass->base.c_name);
46
    eina_str_tolower(&buf);
47
    return buf;
48
}
49

50
static char *
51
_get_abbreviated_name(const char *prefix, const char *fname)
52
{
53
   Eina_Strbuf *buf = eina_strbuf_new();
54

55
   const char *last_p = strrchr(prefix, '_');
56
   last_p = (last_p) ? (last_p + 1) : prefix;
57

58
   const char *tmp = strstr(fname, last_p);
59
   int len = strlen(last_p);
60

61
   if ((tmp) &&
62
       ((tmp == fname) || (*(tmp - 1) == '_')) &&
63
       ((*(tmp + len) == '\0') || (*(tmp + len) == '_')))
64
     {
65
        int plen = strlen(prefix);
66
        len += (tmp - fname);
67

68
        if ((plen >= len) && !strncmp(prefix + plen - len, fname, len))
69
          {
70
             eina_strbuf_append_n(buf, prefix, plen - len);
71
          }
72
     }
73

74
   if (eina_strbuf_length_get(buf) == 0)
75
     eina_strbuf_append_printf(buf, "%s_", prefix);
76
   eina_strbuf_append(buf, fname);
77

78
   char *ret = eina_strbuf_string_steal(buf);
79
   eina_strbuf_free(buf);
80
   return ret;
81
}
82

83
EOLIAN_API Eina_Stringshare *
84
eolian_function_full_c_name_get(const Eolian_Function *foo_id,
85
                                Eolian_Function_Type ftype)
86
{
87
   char tbuf[512];
88
   tbuf[0] = '\0';
89
   const char *prefix = (ftype != EOLIAN_FUNCTION_POINTER) ? _get_c_prefix(foo_id, tbuf): tbuf;
90

91
   if (!prefix)
92
     return NULL;
93

94
   const char  *funcn = eolian_function_name_get(foo_id);
95
   Eina_Strbuf *buf = eina_strbuf_new();
96
   Eina_Stringshare *ret;
97

98
   char *abbr = _get_abbreviated_name(prefix, funcn);
99
   eina_strbuf_append(buf, abbr);
100
   free(abbr);
101

102
   if ((ftype == EOLIAN_PROP_GET) || (ftype == EOLIAN_PROPERTY))
103
     eina_strbuf_append(buf, "_get");
104
   else if (ftype == EOLIAN_PROP_SET)
105
     eina_strbuf_append(buf, "_set");
106

107
   ret = eina_stringshare_add(eina_strbuf_string_get(buf));
108
   eina_strbuf_free(buf);
109
   return ret;
110
}
111

112
EOLIAN_API const Eolian_Implement *
113
eolian_function_implement_get(const Eolian_Function *fid)
114
{
115
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
116
   return fid->impl;
117
}
118

119
EOLIAN_API Eina_Bool
120
eolian_function_is_static(const Eolian_Function *fid)
121
{
122
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_FALSE);
123
   return fid->is_static;
124
}
125

126
EOLIAN_API Eina_Bool
127
eolian_function_is_constructor(const Eolian_Function *fid, const Eolian_Class *klass)
128
{
129
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_FALSE);
130
   Eina_Stringshare *s = eina_stringshare_ref(klass->base.name);
131
   Eina_Bool r = !!eina_list_search_sorted_list
132
     (fid->ctor_of, EINA_COMPARE_CB(strcmp), s);
133
   eina_stringshare_del(s);
134
   return r;
135
}
136

137
static Eina_List *
138
_get_prop_keys(const Eolian_Function *fid, Eolian_Function_Type ftype)
139
{
140
   Eina_List *l = fid->prop_keys_get;
141
   if (ftype == EOLIAN_PROP_SET) l = fid->prop_keys_set;
142
   if (!l) return fid->prop_keys;
143
   return l;
144
}
145

146
static Eina_List *
147
_get_prop_values(const Eolian_Function *fid, Eolian_Function_Type ftype)
148
{
149
   Eina_List *l = fid->prop_values_get;
150
   if (ftype == EOLIAN_PROP_SET) l = fid->prop_values_set;
151
   if (!l) return fid->prop_values;
152
   return l;
153
}
154

155
EOLIAN_API Eina_Iterator *
156
eolian_property_keys_get(const Eolian_Function *fid, Eolian_Function_Type ftype)
157
{
158
   Eina_List *l = NULL;
159
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
160
   if (ftype != EOLIAN_PROP_GET && ftype != EOLIAN_PROP_SET)
161
     return NULL;
162
   l = _get_prop_keys(fid, ftype);
163
   return (l ? eina_list_iterator_new(l) : NULL);
164
}
165

166
EOLIAN_API Eina_Iterator *
167
eolian_property_values_get(const Eolian_Function *fid, Eolian_Function_Type ftype)
168
{
169
   Eina_List *l = NULL;
170
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
171
   if (ftype != EOLIAN_PROP_GET && ftype != EOLIAN_PROP_SET)
172
     return NULL;
173
   l = _get_prop_values(fid, ftype);
174
   return (l ? eina_list_iterator_new(l) : NULL);
175
}
176

177
EOLIAN_API Eina_Iterator *
178
eolian_function_parameters_get(const Eolian_Function *fid)
179
{
180
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
181
   if (fid->type != EOLIAN_METHOD && fid->type != EOLIAN_FUNCTION_POINTER)
182
     return NULL;
183
   return (fid->params ? eina_list_iterator_new(fid->params) : NULL);
184
}
185

186
EOLIAN_API const Eolian_Type *
187
eolian_function_return_type_get(const Eolian_Function *fid, Eolian_Function_Type ftype)
188
{
189
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
190
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, NULL);
191
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, NULL);
192
   switch (ftype)
193
     {
194
      case EOLIAN_METHOD:
195
      case EOLIAN_FUNCTION_POINTER:
196
        if (fid->type != ftype)
197
          return NULL;
198
        return fid->get_ret_type;
199
      case EOLIAN_PROP_GET:
200
        if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
201
          return NULL;
202
        return fid->get_ret_type;
203
      case EOLIAN_PROP_SET:
204
        if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
205
          return NULL;
206
        return fid->set_ret_type;
207
      default:
208
        return NULL;
209
     }
210
}
211

212
EOLIAN_API const Eolian_Expression *
213
eolian_function_return_default_value_get(const Eolian_Function *fid, Eolian_Function_Type ftype)
214
{
215
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
216
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, NULL);
217
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, NULL);
218
   switch (ftype)
219
     {
220
      case EOLIAN_METHOD:
221
      case EOLIAN_FUNCTION_POINTER:
222
        if (fid->type != ftype)
223
          return NULL;
224
        return fid->get_ret_val;
225
      case EOLIAN_PROP_GET:
226
        if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
227
          return NULL;
228
        return fid->get_ret_val;
229
      case EOLIAN_PROP_SET:
230
        if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
231
          return NULL;
232
        return fid->set_ret_val;
233
      default:
234
        return NULL;
235
     }
236
}
237

238
EOLIAN_API const Eolian_Documentation *
239
eolian_function_return_documentation_get(const Eolian_Function *fid, Eolian_Function_Type ftype)
240
{
241
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
242
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, NULL);
243
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, NULL);
244
   switch (ftype)
245
     {
246
      case EOLIAN_METHOD:
247
      case EOLIAN_FUNCTION_POINTER:
248
        if (fid->type != ftype)
249
          return NULL;
250
        return fid->get_return_doc;
251
      case EOLIAN_PROP_GET:
252
        if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
253
          return NULL;
254
        return fid->get_return_doc;
255
      case EOLIAN_PROP_SET:
256
        if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
257
          return NULL;
258
        return fid->set_return_doc;
259
      default:
260
        return NULL;
261
     }
262
}
263

264
EOLIAN_API Eina_Bool
265
eolian_function_return_allow_unused(const Eolian_Function *fid,
266
      Eolian_Function_Type ftype)
267
{
268
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_TRUE);
269
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, EINA_TRUE);
270
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, EINA_TRUE);
271
   switch (ftype)
272
     {
273
      case EOLIAN_METHOD:
274
      case EOLIAN_FUNCTION_POINTER:
275
        if (fid->type != ftype)
276
          return EINA_TRUE;
277
        return !fid->get_return_no_unused;
278
      case EOLIAN_PROP_GET:
279
        if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
280
          return EINA_TRUE;
281
        return !fid->get_return_no_unused;
282
      case EOLIAN_PROP_SET:
283
        if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
284
          return EINA_TRUE;
285
        return !fid->set_return_no_unused;
286
      default:
287
        return EINA_TRUE;
288
     }
289
}
290

291
EOLIAN_API Eina_Bool
292
eolian_function_return_is_by_ref(const Eolian_Function *fid,
293
      Eolian_Function_Type ftype)
294
{
295
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_FALSE);
296
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, EINA_FALSE);
297
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, EINA_FALSE);
298
   switch (ftype)
299
     {
300
      case EOLIAN_METHOD:
301
      case EOLIAN_FUNCTION_POINTER:
302
        if (fid->type != ftype)
303
          return EINA_FALSE;
304
        return fid->get_return_by_ref;
305
      case EOLIAN_PROP_GET:
306
        if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
307
          return EINA_FALSE;
308
        return fid->get_return_by_ref;
309
      case EOLIAN_PROP_SET:
310
        if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
311
          return EINA_FALSE;
312
        return fid->set_return_by_ref;
313
      default:
314
        return EINA_FALSE;
315
     }
316
}
317

318
EOLIAN_API Eina_Bool
319
eolian_function_return_is_move(const Eolian_Function *fid,
320
      Eolian_Function_Type ftype)
321
{
322
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_FALSE);
323
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, EINA_FALSE);
324
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, EINA_FALSE);
325
   switch (ftype)
326
     {
327
      case EOLIAN_METHOD:
328
      case EOLIAN_FUNCTION_POINTER:
329
        if (fid->type != ftype)
330
          return EINA_FALSE;
331
        return fid->get_return_move;
332
      case EOLIAN_PROP_GET:
333
        if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
334
          return EINA_FALSE;
335
        return fid->get_return_move;
336
      case EOLIAN_PROP_SET:
337
        if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
338
          return EINA_FALSE;
339
        return fid->set_return_move;
340
      default:
341
        return EINA_FALSE;
342
     }
343
}
344

345
EOLIAN_API Eina_Stringshare *
346
eolian_function_return_c_type_get(const Eolian_Function *fid,
347
                                  Eolian_Function_Type ftype)
348
{
349
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
350
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_UNRESOLVED, NULL);
351
   EINA_SAFETY_ON_FALSE_RETURN_VAL(ftype != EOLIAN_PROPERTY, NULL);
352
   const Eolian_Type *tp = NULL;
353
   Eina_Bool by_ref = EINA_FALSE;
354
   switch (ftype)
355
     {
356
      case EOLIAN_METHOD:
357
      case EOLIAN_FUNCTION_POINTER:
358
        if (fid->type != ftype)
359
          return NULL;
360
        tp = fid->get_ret_type;
361
        by_ref = fid->get_return_by_ref;
362
        break;
363
      case EOLIAN_PROP_GET:
364
        if ((fid->type != EOLIAN_PROP_GET) && (fid->type != EOLIAN_PROPERTY))
365
          return NULL;
366
        tp = fid->get_ret_type;
367
        by_ref = fid->get_return_by_ref;
368
        break;
369
      case EOLIAN_PROP_SET:
370
        if ((fid->type != EOLIAN_PROP_SET) && (fid->type != EOLIAN_PROPERTY))
371
          return NULL;
372
        tp = fid->set_ret_type;
373
        by_ref = fid->set_return_by_ref;
374
        break;
375
      default:
376
        return NULL;
377
     }
378
   Eina_Strbuf *buf = eina_strbuf_new();
379
   database_type_to_str(tp, buf, NULL, EOLIAN_C_TYPE_RETURN, by_ref);
380
   Eina_Stringshare *ret = eina_stringshare_add(eina_strbuf_string_get(buf));
381
   eina_strbuf_free(buf);
382
   return ret;
383
}
384

385
EOLIAN_API Eina_Bool
386
eolian_function_object_is_const(const Eolian_Function *fid)
387
{
388
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, EINA_FALSE);
389
   return fid->obj_is_const;
390
}
391

392
EOLIAN_API const Eolian_Class *
393
eolian_function_class_get(const Eolian_Function *fid)
394
{
395
   EINA_SAFETY_ON_NULL_RETURN_VAL(fid, NULL);
396
   return fid->klass;
397
}
398