2014-02-13 06:21:25 -08:00
|
|
|
#include <getopt.h>
|
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
#include <Eina.h>
|
|
|
|
|
|
|
|
#include "Eolian.h"
|
|
|
|
#include "legacy_generator.h"
|
|
|
|
#include "eo1_generator.h"
|
2014-05-01 05:07:26 -07:00
|
|
|
#include "impl_generator.h"
|
2014-02-20 01:53:01 -08:00
|
|
|
#include "common_funcs.h"
|
2014-02-11 05:42:59 -08:00
|
|
|
|
2014-02-25 07:27:38 -08:00
|
|
|
static char*
|
|
|
|
_include_guard_enclose(const char *fname, const char *fbody)
|
|
|
|
{
|
2014-03-07 00:43:56 -08:00
|
|
|
char incname[255];
|
|
|
|
memset(incname, 0, sizeof(incname));
|
|
|
|
strncpy (incname, fname, sizeof(incname) - 1);
|
2014-02-25 07:27:38 -08:00
|
|
|
char *p = incname;
|
|
|
|
eina_str_toupper(&p);
|
|
|
|
|
|
|
|
Eina_Strbuf *incguard = eina_strbuf_new();
|
|
|
|
eina_strbuf_append_printf(incguard,
|
|
|
|
"#ifndef _%s_\n#define _%s_\n\n_code_\n#endif",
|
|
|
|
incname,
|
|
|
|
incname);
|
|
|
|
eina_strbuf_replace_all(incguard, ".", "_");
|
|
|
|
eina_strbuf_replace_all(incguard, "_code_", fbody);
|
2014-03-03 08:01:53 -08:00
|
|
|
char *ret = eina_strbuf_string_steal(incguard);
|
|
|
|
eina_strbuf_free(incguard);
|
|
|
|
return ret;
|
2014-02-25 07:27:38 -08:00
|
|
|
}
|
|
|
|
|
2014-03-03 08:00:45 -08:00
|
|
|
static const char *
|
|
|
|
_filename_get(const char *path)
|
|
|
|
{
|
|
|
|
char *result = NULL;
|
|
|
|
|
|
|
|
if (!path) return NULL;
|
|
|
|
if ((result = strrchr(path, '/'))) result++;
|
|
|
|
else result = (char *)path;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
static Eina_Bool
|
2014-05-22 07:24:50 -07:00
|
|
|
_generate_eo_h_file(char *filename, const Eolian_Class class)
|
2014-02-11 05:42:59 -08:00
|
|
|
{
|
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
Eina_Strbuf *hfile = eina_strbuf_new();
|
2014-05-22 07:24:50 -07:00
|
|
|
if (!eo_header_generate(class, hfile))
|
2014-02-11 05:42:59 -08:00
|
|
|
{
|
2014-05-22 07:24:50 -07:00
|
|
|
ERR("Failed to generate header for %s", eolian_class_name_get(class));
|
2014-03-20 08:33:25 -07:00
|
|
|
goto end;
|
2014-02-11 05:42:59 -08:00
|
|
|
}
|
2014-02-25 07:27:38 -08:00
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
const char *htext = eina_strbuf_string_get(hfile);
|
|
|
|
|
2014-03-28 13:39:52 -07:00
|
|
|
FILE* fd = fopen(filename, "wb");
|
2014-02-11 05:42:59 -08:00
|
|
|
if (!fd)
|
|
|
|
{
|
2014-03-07 04:01:52 -08:00
|
|
|
const char *err = strerror(errno);
|
|
|
|
ERR ("Couldn't open file %s for writing. Reason: '%s'", filename, err);
|
2014-02-11 05:42:59 -08:00
|
|
|
goto end;
|
|
|
|
}
|
2014-02-25 07:27:38 -08:00
|
|
|
|
|
|
|
if (htext)
|
|
|
|
{
|
2014-03-03 08:00:45 -08:00
|
|
|
char *fcontent = _include_guard_enclose(_filename_get(filename), htext);
|
2014-02-25 07:27:38 -08:00
|
|
|
fputs(fcontent, fd);
|
|
|
|
free(fcontent);
|
|
|
|
}
|
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
fclose(fd);
|
|
|
|
|
|
|
|
ret = EINA_TRUE;
|
|
|
|
end:
|
|
|
|
eina_strbuf_free(hfile);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
2014-05-22 07:24:50 -07:00
|
|
|
_generate_c_file(char *filename, const Eolian_Class class, Eina_Bool legacy_support)
|
2014-02-11 05:42:59 -08:00
|
|
|
{
|
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
|
2014-03-20 08:33:25 -07:00
|
|
|
Eina_Strbuf *eo_buf = eina_strbuf_new();
|
|
|
|
Eina_Strbuf *legacy_buf = eina_strbuf_new();
|
|
|
|
|
2014-05-22 07:24:50 -07:00
|
|
|
if (!eo_source_generate(class, eo_buf))
|
2014-02-20 03:54:12 -08:00
|
|
|
{
|
2014-05-22 07:24:50 -07:00
|
|
|
ERR("Failed to generate source for %s", eolian_class_name_get(class));
|
2014-02-20 03:54:12 -08:00
|
|
|
goto end;
|
|
|
|
}
|
2014-02-11 05:42:59 -08:00
|
|
|
|
2014-03-20 08:33:25 -07:00
|
|
|
if (legacy_support)
|
2014-05-22 07:24:50 -07:00
|
|
|
if (!legacy_source_generate(class, legacy_buf))
|
2014-03-20 08:33:25 -07:00
|
|
|
{
|
2014-05-22 07:24:50 -07:00
|
|
|
ERR("Failed to generate source for %s", eolian_class_name_get(class));
|
2014-03-20 08:33:25 -07:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2014-03-28 13:39:52 -07:00
|
|
|
FILE* fd = fopen(filename, "wb");
|
2014-02-11 05:42:59 -08:00
|
|
|
if (!fd)
|
|
|
|
{
|
2014-02-20 03:54:12 -08:00
|
|
|
ERR("Couldnt open file %s for writing", filename);
|
2014-02-11 05:42:59 -08:00
|
|
|
goto end;
|
|
|
|
}
|
2014-03-20 08:33:25 -07:00
|
|
|
|
|
|
|
const char *text = eina_strbuf_string_get(eo_buf);
|
|
|
|
if (text) fputs(text, fd);
|
|
|
|
text = eina_strbuf_string_get(legacy_buf);
|
|
|
|
if (text) fputs(text, fd);
|
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
fclose(fd);
|
|
|
|
|
|
|
|
ret = EINA_TRUE;
|
|
|
|
end:
|
2014-03-20 08:33:25 -07:00
|
|
|
eina_strbuf_free(legacy_buf);
|
|
|
|
eina_strbuf_free(eo_buf);
|
2014-02-11 05:42:59 -08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-05-01 05:07:26 -07:00
|
|
|
static Eina_Bool
|
2014-05-22 07:24:50 -07:00
|
|
|
_generate_impl_c_file(char *filename, const Eolian_Class class)
|
2014-05-01 05:07:26 -07:00
|
|
|
{
|
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
long file_size = 0;
|
2014-05-02 09:20:10 -07:00
|
|
|
Eina_Strbuf *buffer = NULL;
|
2014-05-01 05:07:26 -07:00
|
|
|
|
|
|
|
FILE* fd = fopen(filename, "rb");
|
2014-05-02 09:20:10 -07:00
|
|
|
if (fd)
|
2014-05-01 05:07:26 -07:00
|
|
|
{
|
2014-05-02 09:20:10 -07:00
|
|
|
fseek(fd, 0, SEEK_END);
|
|
|
|
file_size = ftell(fd);
|
|
|
|
fseek(fd, 0, SEEK_SET);
|
|
|
|
char *content = malloc(file_size + 1);
|
|
|
|
fread(content, file_size, 1, fd);
|
|
|
|
content[file_size] = '\0';
|
|
|
|
fclose(fd);
|
|
|
|
|
|
|
|
if (!content)
|
|
|
|
{
|
|
|
|
ERR("Couldnt read file %s", filename);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
buffer = eina_strbuf_manage_new(content);
|
2014-05-01 05:07:26 -07:00
|
|
|
}
|
2014-05-02 09:20:10 -07:00
|
|
|
else
|
|
|
|
buffer = eina_strbuf_new();
|
2014-05-01 05:07:26 -07:00
|
|
|
|
2014-05-22 07:24:50 -07:00
|
|
|
if (!impl_source_generate(class, buffer))
|
2014-05-01 05:07:26 -07:00
|
|
|
{
|
2014-05-22 07:24:50 -07:00
|
|
|
ERR("Failed to generate source for %s", eolian_class_name_get(class));
|
2014-05-01 05:07:26 -07:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
fd = fopen(filename, "wb");
|
|
|
|
if (!fd)
|
|
|
|
{
|
|
|
|
ERR("Couldnt open file %s for writing", filename);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *text = eina_strbuf_string_get(buffer);
|
|
|
|
if (text) fputs(text, fd);
|
|
|
|
|
|
|
|
fclose(fd);
|
|
|
|
|
|
|
|
ret = EINA_TRUE;
|
|
|
|
end:
|
|
|
|
eina_strbuf_free(buffer);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
// TODO join with header gen.
|
|
|
|
static Eina_Bool
|
2014-05-22 07:24:50 -07:00
|
|
|
_generate_legacy_header_file(char *filename, const Eolian_Class class)
|
2014-02-11 05:42:59 -08:00
|
|
|
{
|
|
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
|
|
|
|
Eina_Strbuf *lfile = eina_strbuf_new();
|
|
|
|
|
2014-05-22 07:24:50 -07:00
|
|
|
if (!legacy_header_generate(class, lfile))
|
2014-02-11 05:42:59 -08:00
|
|
|
{
|
2014-05-22 07:24:50 -07:00
|
|
|
ERR("Failed to generate header for %s", eolian_class_name_get(class));
|
2014-03-20 08:33:25 -07:00
|
|
|
goto end;
|
2014-02-11 05:42:59 -08:00
|
|
|
}
|
|
|
|
|
2014-03-28 13:39:52 -07:00
|
|
|
FILE* fd = fopen(filename, "wb");
|
2014-02-11 05:42:59 -08:00
|
|
|
if (!fd)
|
|
|
|
{
|
2014-02-20 03:54:12 -08:00
|
|
|
ERR ("Couldnt open file %s for writing", filename);
|
2014-02-11 05:42:59 -08:00
|
|
|
goto end;
|
|
|
|
}
|
2014-02-25 07:27:38 -08:00
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
const char *ltext = eina_strbuf_string_get(lfile);
|
2014-02-25 07:27:38 -08:00
|
|
|
|
|
|
|
if (ltext)
|
|
|
|
{
|
2014-03-03 08:00:45 -08:00
|
|
|
char *fcontent = _include_guard_enclose(_filename_get(filename), ltext);
|
2014-02-25 07:27:38 -08:00
|
|
|
fputs(fcontent, fd);
|
|
|
|
free(fcontent);
|
|
|
|
}
|
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
fclose(fd);
|
|
|
|
|
|
|
|
ret = EINA_TRUE;
|
|
|
|
end:
|
|
|
|
eina_strbuf_free(lfile);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-02-20 01:53:01 -08:00
|
|
|
enum
|
|
|
|
{
|
|
|
|
NO_WAY_GEN,
|
|
|
|
H_GEN,
|
2014-05-01 05:07:26 -07:00
|
|
|
C_GEN,
|
|
|
|
C_IMPL_GEN
|
2014-02-20 01:53:01 -08:00
|
|
|
};
|
2014-04-22 22:55:15 -07:00
|
|
|
static int gen_opt = NO_WAY_GEN;
|
|
|
|
static int eo_needed = 0;
|
|
|
|
static Eina_Bool legacy_support = EINA_FALSE;
|
2014-02-20 01:53:01 -08:00
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2014-02-18 07:01:17 -08:00
|
|
|
int ret = 1;
|
2014-02-11 05:42:59 -08:00
|
|
|
Eina_Bool help = EINA_FALSE, show = EINA_FALSE;
|
2014-05-03 21:41:46 -07:00
|
|
|
Eina_List *itr;
|
2014-02-16 06:09:06 -08:00
|
|
|
Eina_List *files4gen = NULL;
|
2014-05-22 07:24:50 -07:00
|
|
|
Eolian_Class class;
|
2014-02-20 01:53:01 -08:00
|
|
|
char *output_filename = NULL; /* if NULL, have to generate, otherwise use the name stored there */
|
2014-02-11 05:42:59 -08:00
|
|
|
|
2014-02-18 07:01:17 -08:00
|
|
|
eina_init();
|
|
|
|
eolian_init();
|
|
|
|
|
2014-02-20 01:53:01 -08:00
|
|
|
const char *log_dom = "eolian_gen";
|
|
|
|
_eolian_gen_log_dom = eina_log_domain_register(log_dom, EINA_COLOR_GREEN);
|
|
|
|
if (_eolian_gen_log_dom < 0)
|
|
|
|
{
|
|
|
|
EINA_LOG_ERR("Could not register log domain: %s", log_dom);
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
eina_log_timing(_eolian_gen_log_dom,
|
|
|
|
EINA_LOG_STATE_STOP,
|
|
|
|
EINA_LOG_STATE_INIT);
|
|
|
|
|
2014-02-13 06:21:25 -08:00
|
|
|
static struct option long_options[] =
|
2014-02-11 05:42:59 -08:00
|
|
|
{
|
2014-02-13 06:21:25 -08:00
|
|
|
/* These options set a flag. */
|
2014-04-22 22:55:15 -07:00
|
|
|
{"eo", no_argument, &eo_needed, 1},
|
2014-02-18 07:01:17 -08:00
|
|
|
{"verbose", no_argument, 0, 'v'},
|
2014-02-13 06:21:25 -08:00
|
|
|
{"help", no_argument, 0, 'h'},
|
2014-02-20 01:53:01 -08:00
|
|
|
{"gh", no_argument, &gen_opt, H_GEN},
|
|
|
|
{"gc", no_argument, &gen_opt, C_GEN},
|
2014-05-01 05:07:26 -07:00
|
|
|
{"gi", no_argument, &gen_opt, C_IMPL_GEN},
|
2014-02-20 01:53:01 -08:00
|
|
|
{"output", required_argument, 0, 'o'},
|
|
|
|
{"legacy", no_argument, (int *)&legacy_support, EINA_TRUE},
|
2014-02-13 06:21:25 -08:00
|
|
|
{"include", required_argument, 0, 'I'},
|
|
|
|
{0, 0, 0, 0}
|
|
|
|
};
|
|
|
|
int long_index =0, opt;
|
2014-02-18 07:01:17 -08:00
|
|
|
while ((opt = getopt_long(argc, argv,"vho:I:", long_options, &long_index )) != -1)
|
2014-02-13 06:21:25 -08:00
|
|
|
{
|
|
|
|
switch (opt) {
|
|
|
|
case 0: break;
|
2014-02-20 01:53:01 -08:00
|
|
|
case 'o':
|
|
|
|
{
|
|
|
|
output_filename = strdup(optarg);
|
|
|
|
break;
|
|
|
|
}
|
2014-02-18 07:01:17 -08:00
|
|
|
case 'v': show = EINA_TRUE; break;
|
2014-02-13 06:21:25 -08:00
|
|
|
case 'h': help = EINA_TRUE; break;
|
|
|
|
case 'I':
|
|
|
|
{
|
2014-02-17 23:01:23 -08:00
|
|
|
const char *dir = optarg;
|
2014-04-27 00:03:39 -07:00
|
|
|
if (!eolian_directory_scan(dir))
|
2014-02-13 06:21:25 -08:00
|
|
|
{
|
2014-04-27 00:03:39 -07:00
|
|
|
ERR("Failed to scan %s", dir);
|
|
|
|
goto end;
|
2014-02-13 06:21:25 -08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: help = EINA_TRUE;
|
|
|
|
}
|
2014-02-11 05:42:59 -08:00
|
|
|
}
|
2014-02-16 06:09:06 -08:00
|
|
|
while (optind < argc)
|
2014-02-17 23:01:23 -08:00
|
|
|
files4gen = eina_list_append(files4gen, argv[optind++]);
|
2014-02-11 05:42:59 -08:00
|
|
|
|
2014-02-18 07:01:17 -08:00
|
|
|
if (help)
|
2014-02-11 05:42:59 -08:00
|
|
|
{
|
2014-05-01 05:07:26 -07:00
|
|
|
printf("Usage: %s [-h/--help] [-v/--verbose] [-I/--include input_dir] [--legacy] [--gh|--gc|--gi] [--output/-o outfile] file.eo ... \n", argv[0]);
|
2014-02-20 01:53:01 -08:00
|
|
|
printf(" --help/-h Print that help\n");
|
|
|
|
printf(" --include/-I Include 'input_dir' as directory to search .eo files into\n");
|
|
|
|
printf(" --output/-o Force output filename to 'outfile'\n");
|
2014-04-17 05:50:22 -07:00
|
|
|
printf(" --eo Set generator to eo mode. Must be specified\n");
|
2014-05-01 05:07:26 -07:00
|
|
|
printf(" --gh Generate C header file [.h]\n");
|
|
|
|
printf(" --gc Generate C source file [.c]\n");
|
|
|
|
printf(" --gi Generate C implementation source file [.c]. The output will be a series of functions that have to be filled.\n");
|
2014-02-13 07:12:19 -08:00
|
|
|
printf(" --legacy Generate legacy\n");
|
2014-02-18 07:01:17 -08:00
|
|
|
ret = 0;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!files4gen)
|
|
|
|
{
|
2014-02-20 03:54:12 -08:00
|
|
|
ERR("No input files specified.\nTerminating.\n");
|
2014-02-18 07:01:17 -08:00
|
|
|
goto end;
|
2014-02-11 05:42:59 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
const char *filename;
|
2014-02-17 23:01:23 -08:00
|
|
|
EINA_LIST_FOREACH(files4gen, itr, filename)
|
|
|
|
{
|
|
|
|
if (!eolian_eo_file_parse(filename))
|
|
|
|
{
|
2014-02-20 03:54:12 -08:00
|
|
|
ERR("Error during parsing file %s\n", filename);
|
2014-02-17 23:01:23 -08:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-16 06:09:06 -08:00
|
|
|
if (show)
|
|
|
|
{
|
2014-02-17 23:01:23 -08:00
|
|
|
EINA_LIST_FOREACH(files4gen, itr, filename)
|
2014-02-16 06:09:06 -08:00
|
|
|
{
|
2014-05-22 07:24:50 -07:00
|
|
|
class = eolian_class_find_by_file(filename);
|
|
|
|
if (class) eolian_show(class);
|
2014-02-16 06:09:06 -08:00
|
|
|
}
|
|
|
|
}
|
2014-02-11 05:42:59 -08:00
|
|
|
|
2014-04-22 22:55:15 -07:00
|
|
|
if (!eo_needed && !(gen_opt == H_GEN && legacy_support))
|
2014-02-11 05:42:59 -08:00
|
|
|
{
|
2014-04-22 22:55:15 -07:00
|
|
|
ERR("Eo flag is not specified (use --eo). Aborting eo generation.\n");
|
2014-02-11 05:42:59 -08:00
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
2014-05-22 07:24:50 -07:00
|
|
|
class = eolian_class_find_by_file(eina_list_data_get(files4gen));
|
2014-02-16 06:09:06 -08:00
|
|
|
|
2014-02-20 01:53:01 -08:00
|
|
|
if (gen_opt)
|
2014-02-11 05:42:59 -08:00
|
|
|
{
|
2014-02-20 01:53:01 -08:00
|
|
|
if (!output_filename)
|
2014-02-16 06:09:06 -08:00
|
|
|
{
|
2014-05-01 05:07:26 -07:00
|
|
|
ERR("You must use -o argument for files generation.");
|
|
|
|
goto end;
|
2014-02-16 06:09:06 -08:00
|
|
|
}
|
2014-02-20 01:53:01 -08:00
|
|
|
switch (gen_opt)
|
|
|
|
{
|
2014-03-20 08:33:25 -07:00
|
|
|
case H_GEN:
|
2014-02-20 01:53:01 -08:00
|
|
|
{
|
2014-03-20 08:33:25 -07:00
|
|
|
INF("Generating header file %s\n", output_filename);
|
2014-02-25 07:27:38 -08:00
|
|
|
if (legacy_support)
|
2014-05-22 07:24:50 -07:00
|
|
|
ret = ( _generate_legacy_header_file(output_filename, class) ? 0 : 1 );
|
2014-02-25 07:27:38 -08:00
|
|
|
else
|
2014-05-22 07:24:50 -07:00
|
|
|
ret = ( _generate_eo_h_file(output_filename, class) ? 0 : 1 );
|
2014-02-20 01:53:01 -08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case C_GEN:
|
|
|
|
{
|
|
|
|
INF("Generating source file %s\n", output_filename);
|
2014-05-22 07:24:50 -07:00
|
|
|
ret = _generate_c_file(output_filename, class, legacy_support)?0:1;
|
2014-02-20 01:53:01 -08:00
|
|
|
break;
|
|
|
|
}
|
2014-05-01 05:07:26 -07:00
|
|
|
case C_IMPL_GEN:
|
|
|
|
{
|
|
|
|
INF("Generating user source file %s\n", output_filename);
|
2014-05-22 07:24:50 -07:00
|
|
|
ret = _generate_impl_c_file(output_filename, class) ? 0 : 1;
|
2014-05-01 05:07:26 -07:00
|
|
|
break;
|
|
|
|
}
|
2014-02-20 01:53:01 -08:00
|
|
|
default:
|
2014-02-20 03:54:12 -08:00
|
|
|
ERR("Bad generation option\n");
|
|
|
|
break;
|
2014-02-20 01:53:01 -08:00
|
|
|
}
|
|
|
|
free(output_filename);
|
2014-02-11 05:42:59 -08:00
|
|
|
}
|
2014-02-20 03:54:12 -08:00
|
|
|
else ret = 0;
|
2014-02-11 05:42:59 -08:00
|
|
|
|
|
|
|
end:
|
2014-02-16 06:09:06 -08:00
|
|
|
eina_list_free(files4gen);
|
2014-02-20 01:53:01 -08:00
|
|
|
|
|
|
|
eina_log_timing(_eolian_gen_log_dom,
|
|
|
|
EINA_LOG_STATE_START,
|
|
|
|
EINA_LOG_STATE_SHUTDOWN);
|
|
|
|
eina_log_domain_unregister(_eolian_gen_log_dom);
|
|
|
|
_eolian_gen_log_dom = -1;
|
|
|
|
|
2014-02-11 05:42:59 -08:00
|
|
|
eolian_shutdown();
|
|
|
|
eina_shutdown();
|
|
|
|
return ret;
|
|
|
|
}
|