715 lines
24 KiB
C
715 lines
24 KiB
C
#include "mrklib_priv.h"
|
|
|
|
typedef enum
|
|
{
|
|
TMODE_EOL,
|
|
TMODE_PATH,
|
|
TMODE_TEXT,
|
|
TMODE_PATH_CP,
|
|
TMODE_PATH_CP_LIST,
|
|
TMODE_PATH_LIST,
|
|
} Tag_Mode;
|
|
|
|
typedef struct
|
|
{
|
|
const char *tag;
|
|
Tag_Mode mode;
|
|
} Tag_Type;
|
|
|
|
static const Tag_Type tags[] =
|
|
{
|
|
{"PROJ:", TMODE_EOL},
|
|
{"PROJICON:", TMODE_PATH},
|
|
{"BRIEF:", TMODE_TEXT},
|
|
{"VERSION:", TMODE_EOL},
|
|
{"LICENSE:", TMODE_EOL},
|
|
{"COPYING:", TMODE_PATH_LIST},
|
|
{"NEEDS:", TMODE_EOL},
|
|
{"DOMAIN:", TMODE_PATH},
|
|
{"REPO:", TMODE_EOL},
|
|
{"DEVREPO:", TMODE_EOL},
|
|
{"CONTACT:", TMODE_TEXT},
|
|
{"CATEGORY:", TMODE_PATH_LIST},
|
|
{"TAGS:", TMODE_PATH_LIST},
|
|
{"BIN:", TMODE_PATH},
|
|
{"SRC:", TMODE_PATH_LIST},
|
|
{"DEPS:", TMODE_PATH_LIST},
|
|
{"INC:", TMODE_PATH_LIST},
|
|
{"DATA:", TMODE_PATH_CP_LIST},
|
|
{"DESKTOP:", TMODE_PATH_LIST},
|
|
{"ICON:", TMODE_PATH_LIST},
|
|
{"PODOMAIN:", TMODE_PATH},
|
|
{"PO:", TMODE_PATH_LIST},
|
|
{NULL, 0} // END OF LIST
|
|
};
|
|
|
|
static char *
|
|
parse_token(char **p, char *end)
|
|
{
|
|
char *tok, *seg;
|
|
|
|
while ((*p < end) && (isspace(**p))) (*p)++;
|
|
if (*p >= end) return NULL;
|
|
tok = *p;
|
|
|
|
while (*p < end)
|
|
{
|
|
if (isspace(**p)) goto token;
|
|
(*p)++;
|
|
}
|
|
token:
|
|
seg = malloc(*p - tok + 1);
|
|
if (!seg) return NULL;
|
|
memcpy(seg, tok, *p - tok);
|
|
seg[*p - tok] = 0;
|
|
return seg;
|
|
}
|
|
|
|
static char *
|
|
parse_eol(char **p, char *end)
|
|
{
|
|
char *tok, *seg;
|
|
|
|
while ((*p < end) && (isspace(**p))) (*p)++;
|
|
if (*p >= end) return NULL;
|
|
tok = *p;
|
|
|
|
while (*p < end)
|
|
{
|
|
if (**p == '\n') goto token;
|
|
(*p)++;
|
|
}
|
|
token:
|
|
seg = malloc(*p - tok + 1);
|
|
if (!seg) return NULL;
|
|
memcpy(seg, tok, *p - tok);
|
|
seg[*p - tok] = 0;
|
|
return seg;
|
|
}
|
|
|
|
static char *
|
|
path_check(char *tok)
|
|
{
|
|
// XXX: check me
|
|
return strdup(tok);
|
|
}
|
|
|
|
static Mrk_Build *
|
|
parse_content(char *mem, size_t size)
|
|
{
|
|
Mrk_Build *bld = NULL;
|
|
char prevc = '\n';
|
|
char *end = mem + size;
|
|
char *p = mem;
|
|
int skipline = 0;
|
|
int startline = 0;
|
|
int line = 1;
|
|
char *seg = NULL, *s;
|
|
char *data1 = NULL, *data2 = NULL;
|
|
int i;
|
|
Tag_Mode mode = TMODE_TEXT;
|
|
#define err(reason...) do { fprintf(stderr, ##reason); goto error; } while (0)
|
|
|
|
bld = calloc(1, sizeof(Mrk_Build));
|
|
if (!bld) return NULL;
|
|
|
|
while (p < end)
|
|
{
|
|
if (prevc == '\n')
|
|
{
|
|
line++;
|
|
if (*p == '#') skipline = 1;
|
|
else skipline = 0;
|
|
startline = 1;
|
|
}
|
|
if (!skipline)
|
|
{
|
|
char *tok;
|
|
char *prevp;
|
|
|
|
prevp = p;
|
|
tok = parse_token(&p, end);
|
|
if (!tok) err("%i: token parse error\n", line);
|
|
if (startline)
|
|
{
|
|
for (i = 0; tags[i].tag; i++)
|
|
{
|
|
if (!strcmp(tok, tags[i].tag))
|
|
{
|
|
free(seg);
|
|
seg = strdup(tok);
|
|
mode = tags[i].mode;
|
|
break;
|
|
}
|
|
}
|
|
if (!tags[i].tag) goto not_tag;
|
|
}
|
|
else
|
|
{
|
|
not_tag:
|
|
switch (mode)
|
|
{
|
|
case TMODE_EOL:
|
|
case TMODE_TEXT:
|
|
p = prevp;
|
|
data1 = parse_eol(&p, end);
|
|
if (!data1) err("%i: no content\n", line);
|
|
break;
|
|
case TMODE_PATH:
|
|
case TMODE_PATH_LIST:
|
|
data1 = path_check(tok);
|
|
if (!data1) err("%i: path invalid\n", line);
|
|
break;
|
|
case TMODE_PATH_CP:
|
|
case TMODE_PATH_CP_LIST:
|
|
data1 = path_check(tok);
|
|
if (!data1) err("%i: path invalid\n", line);
|
|
s = parse_token(&p, end);
|
|
if (!s) err("%i: missing > in path copy\n", line);
|
|
if (!(!strcmp(s, ">"))) err("%i: copy token is not >\n", line);
|
|
free(s);
|
|
s = parse_token(&p, end);
|
|
if (!s) err("%i: missing destination path in path copy\n", line);
|
|
data2 = path_check(s);
|
|
if (!data2) err("%i: destination path not valid\n", line);
|
|
free(s);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (seg)
|
|
{
|
|
if (!strcmp(seg, "PROJ:"))
|
|
{
|
|
if (!_mrk_util_plain_file_check(data1))
|
|
err("%i: name failed sanity check\n", line);
|
|
eina_stringshare_del(bld->name);
|
|
bld->name = eina_stringshare_add(data1);
|
|
}
|
|
else if (!strcmp(seg, "PROJICON:"))
|
|
{
|
|
eina_stringshare_del(bld->icon);
|
|
bld->icon = eina_stringshare_add(data1);
|
|
}
|
|
else if (!strcmp(seg, "BRIEF:"))
|
|
{
|
|
if (!bld->brief) bld->brief = eina_stringshare_add(data1);
|
|
else
|
|
{
|
|
s = malloc(strlen(bld->brief) + 1 + strlen(data1) + 1);
|
|
if (s)
|
|
{
|
|
strcpy(s, bld->brief);
|
|
strcat(s, " ");
|
|
strcat(s, data1);
|
|
eina_stringshare_del(bld->brief);
|
|
bld->brief = s;
|
|
}
|
|
}
|
|
}
|
|
else if (!strcmp(seg, "VERSION:"))
|
|
{
|
|
eina_stringshare_del(bld->version);
|
|
bld->version = eina_stringshare_add(data1);
|
|
}
|
|
else if (!strcmp(seg, "LICENSE:"))
|
|
{
|
|
eina_stringshare_del(bld->license);
|
|
bld->license = eina_stringshare_add(data1);
|
|
}
|
|
else if (!strcmp(seg, "COPYING:"))
|
|
{
|
|
bld->copying = eina_list_append(bld->copying,
|
|
eina_stringshare_add(data1));
|
|
}
|
|
else if (!strcmp(seg, "NEEDS:"))
|
|
{
|
|
eina_stringshare_del(bld->needs);
|
|
bld->license = eina_stringshare_add(data1);
|
|
}
|
|
else if (!strcmp(seg, "DOMAIN:"))
|
|
{
|
|
eina_stringshare_del(bld->domain);
|
|
bld->domain = eina_stringshare_add(data1);
|
|
}
|
|
else if (!strcmp(seg, "REPO:"))
|
|
{
|
|
eina_stringshare_del(bld->repo);
|
|
bld->repo = eina_stringshare_add(data1);
|
|
}
|
|
else if (!strcmp(seg, "DEVREPO:"))
|
|
{
|
|
eina_stringshare_del(bld->devrepo);
|
|
bld->devrepo = eina_stringshare_add(data1);
|
|
}
|
|
else if (!strcmp(seg, "CATEGORY:"))
|
|
{
|
|
bld->categories = eina_list_append(bld->categories,
|
|
eina_stringshare_add(data1));
|
|
}
|
|
else if (!strcmp(seg, "TAGS:"))
|
|
{
|
|
bld->tags = eina_list_append(bld->tags,
|
|
eina_stringshare_add(data1));
|
|
}
|
|
else if (!strcmp(seg, "CONTACT:"))
|
|
{
|
|
if (!bld->contact) bld->contact = eina_stringshare_add(data1);
|
|
else
|
|
{
|
|
s = malloc(strlen(bld->contact) + 1 + strlen(data1) + 1);
|
|
if (s)
|
|
{
|
|
strcpy(s, bld->contact);
|
|
strcat(s, " ");
|
|
strcat(s, data1);
|
|
eina_stringshare_del(bld->contact);
|
|
bld->contact = s;
|
|
}
|
|
}
|
|
}
|
|
else if (!strcmp(seg, "BIN:"))
|
|
{
|
|
Mrk_Build_Bin *build_bin = calloc(1, sizeof(Mrk_Build_Bin));
|
|
if (build_bin)
|
|
{
|
|
build_bin->bin = eina_stringshare_add(data1);
|
|
bld->bins = eina_list_append(bld->bins,
|
|
build_bin);
|
|
}
|
|
}
|
|
else if (!strcmp(seg, "SRC:"))
|
|
{
|
|
Mrk_Build_Bin *build_bin = eina_list_data_get(eina_list_last(bld->bins));
|
|
if (build_bin)
|
|
{
|
|
build_bin->srcs = eina_list_append(build_bin->srcs,
|
|
eina_stringshare_add(data1));
|
|
}
|
|
}
|
|
else if (!strcmp(seg, "DEPS:"))
|
|
{
|
|
Mrk_Build_Bin *build_bin = eina_list_data_get(eina_list_last(bld->bins));
|
|
if (build_bin)
|
|
{
|
|
build_bin->deps = eina_list_append(build_bin->deps,
|
|
eina_stringshare_add(data1));
|
|
}
|
|
}
|
|
else if (!strcmp(seg, "INC:"))
|
|
{
|
|
Mrk_Build_Bin *build_bin = eina_list_data_get(eina_list_last(bld->bins));
|
|
if (build_bin)
|
|
{
|
|
build_bin->incs = eina_list_append(build_bin->incs,
|
|
eina_stringshare_add(data1));
|
|
}
|
|
}
|
|
else if (!strcmp(seg, "DATA:"))
|
|
{
|
|
Mrk_Build_Data *build_data = calloc(1, sizeof(Mrk_Build_Data));
|
|
if (build_data)
|
|
{
|
|
build_data->src = eina_stringshare_add(data1);
|
|
build_data->dest = eina_stringshare_add(data2);
|
|
bld->data = eina_list_append(bld->data,
|
|
build_data);
|
|
}
|
|
}
|
|
else if (!strcmp(seg, "DESKTOP:"))
|
|
{
|
|
bld->desktops = eina_list_append(bld->desktops,
|
|
eina_stringshare_add(data1));
|
|
}
|
|
else if (!strcmp(seg, "ICON:"))
|
|
{
|
|
bld->icons = eina_list_append(bld->icons,
|
|
eina_stringshare_add(data1));
|
|
}
|
|
else if (!strcmp(seg, "PO:"))
|
|
{
|
|
bld->po = eina_list_append(bld->po,
|
|
eina_stringshare_add(data1));
|
|
}
|
|
}
|
|
free(data1);
|
|
free(data2);
|
|
data1 = NULL;
|
|
data2 = NULL;
|
|
}
|
|
free(tok);
|
|
prevc = *p;
|
|
p++;
|
|
}
|
|
else
|
|
{
|
|
prevc = *p;
|
|
p++;
|
|
}
|
|
startline = 0;
|
|
}
|
|
return bld;
|
|
error:
|
|
mrk_build_free(bld);
|
|
return NULL;
|
|
#undef err
|
|
}
|
|
|
|
EAPI Mrk_Build *
|
|
mrk_build_load(const char *file)
|
|
{
|
|
Mrk_Build *bld;
|
|
Eina_File *ef;
|
|
char *mem;
|
|
size_t size;
|
|
int ret;
|
|
|
|
ef = eina_file_open(file, EINA_FALSE);
|
|
if (!ef) return NULL;
|
|
|
|
size = eina_file_size_get(ef);
|
|
mem = eina_file_map_all(ef, EINA_FILE_SEQUENTIAL);
|
|
if ((size == 0) || (!mem)) return NULL;
|
|
|
|
bld = parse_content(mem, size);
|
|
|
|
eina_file_close(ef);
|
|
return bld;
|
|
}
|
|
|
|
EAPI void
|
|
mrk_build_free(Mrk_Build *bld)
|
|
{
|
|
const char *s;
|
|
Mrk_Build_Bin *build_bin;
|
|
Mrk_Build_Data *build_data;
|
|
|
|
if (!bld) return;
|
|
eina_stringshare_del(bld->name);
|
|
eina_stringshare_del(bld->icon);
|
|
eina_stringshare_del(bld->brief);
|
|
eina_stringshare_del(bld->version);
|
|
eina_stringshare_del(bld->license);
|
|
eina_stringshare_del(bld->domain);
|
|
eina_stringshare_del(bld->repo);
|
|
eina_stringshare_del(bld->devrepo);
|
|
eina_stringshare_del(bld->contact);
|
|
EINA_LIST_FREE(bld->tags, s) eina_stringshare_del(s);
|
|
EINA_LIST_FREE(bld->categories, s) eina_stringshare_del(s);
|
|
EINA_LIST_FREE(bld->copying, s) eina_stringshare_del(s);
|
|
eina_stringshare_del(bld->needs);
|
|
EINA_LIST_FREE(bld->desktops, s) eina_stringshare_del(s);
|
|
EINA_LIST_FREE(bld->bins, build_bin)
|
|
{
|
|
eina_stringshare_del(build_bin->bin);
|
|
EINA_LIST_FREE(build_bin->srcs, s) eina_stringshare_del(s);
|
|
EINA_LIST_FREE(build_bin->deps, s) eina_stringshare_del(s);
|
|
EINA_LIST_FREE(build_bin->incs, s) eina_stringshare_del(s);
|
|
free(build_bin);
|
|
}
|
|
EINA_LIST_FREE(bld->data, build_data)
|
|
{
|
|
eina_stringshare_del(build_data->src);
|
|
eina_stringshare_del(build_data->dest);
|
|
free(build_data);
|
|
}
|
|
EINA_LIST_FREE(bld->icons, s) eina_stringshare_del(s);
|
|
EINA_LIST_FREE(bld->po, s) eina_stringshare_del(s);
|
|
free(bld);
|
|
}
|
|
|
|
EAPI Eina_Bool
|
|
mrk_build_do(Mrk_Build *bld, const char *tmpd)
|
|
{
|
|
Eina_List *l, *ll;
|
|
Mrk_Build_Bin *bin;
|
|
Mrk_Build_Data *data;
|
|
Eina_Strbuf *buf;
|
|
char *s, *extn, *s2;
|
|
char tmp[4096];
|
|
char tmp2[4096];
|
|
const char *ss, *cc;
|
|
#define err(reason) do { fprintf(stderr, "%s\n", reason); goto error; } while (0)
|
|
|
|
EINA_LIST_FOREACH(bld->po, l, s)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "%s/share/locale/%s/LC_MESSAGES/", tmpd, s);
|
|
ecore_file_mkpath(tmp);
|
|
snprintf(tmp2, sizeof(tmp2), "po/%s.gmo", s);
|
|
snprintf(tmp, sizeof(tmp), "%s/share/locale/%s/LC_MESSAGES/%s.mo", tmpd, s, bld->domain);
|
|
ecore_file_cp(tmp2, tmp);
|
|
}
|
|
EINA_LIST_FOREACH(bld->data, l, data)
|
|
{
|
|
s = ecore_file_dir_get(data->dest);
|
|
if (s)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "%s/%s", tmpd, s);
|
|
ecore_file_mkpath(tmp);
|
|
free(s);
|
|
}
|
|
snprintf(tmp, sizeof(tmp), "%s/%s", tmpd, data->dest);
|
|
ecore_file_cp(data->src, tmp);
|
|
}
|
|
snprintf(tmp, sizeof(tmp), "%s/%s", tmpd, "share/applications");
|
|
ecore_file_mkpath(tmp);
|
|
EINA_LIST_FOREACH(bld->desktops, l, s)
|
|
{
|
|
ss = ecore_file_file_get(s);
|
|
if (!(!strncmp(ss, bld->domain, strlen(bld->domain))))
|
|
err("destkop file wrong domain");
|
|
snprintf(tmp, sizeof(tmp), "%s/share/applications/%s", tmpd, ss);
|
|
ecore_file_cp(s, tmp);
|
|
}
|
|
snprintf(tmp, sizeof(tmp), "%s/%s", tmpd, "share/icons");
|
|
ecore_file_mkpath(tmp);
|
|
EINA_LIST_FOREACH(bld->icons, l, s)
|
|
{
|
|
ss = ecore_file_file_get(s);
|
|
if (!(!strncmp(ss, bld->domain, strlen(bld->domain))))
|
|
err("icon file wrong domain");
|
|
snprintf(tmp, sizeof(tmp), "%s/share/icons/%s", tmpd, ss);
|
|
ecore_file_cp(s, tmp);
|
|
}
|
|
EINA_LIST_FOREACH(bld->copying, l, s)
|
|
{
|
|
if (strchr(s, '/'))
|
|
{
|
|
s2 = ecore_file_dir_get(s);
|
|
snprintf(tmp, sizeof(tmp), "%s/share/licenses/%s", tmpd, s2);
|
|
free(s2);
|
|
}
|
|
else
|
|
snprintf(tmp, sizeof(tmp), "%s/share/licenses", tmpd);
|
|
ecore_file_mkpath(tmp);
|
|
snprintf(tmp, sizeof(tmp), "%s/share/licenses/%s", tmpd, s);
|
|
ecore_file_cp(s, tmp);
|
|
}
|
|
EINA_LIST_FOREACH(bld->bins, l, bin)
|
|
{
|
|
if ((buf = eina_strbuf_new()))
|
|
{
|
|
s = ecore_file_dir_get(bin->bin);
|
|
if (s)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "%s/%s", tmpd, s);
|
|
ecore_file_mkpath(tmp);
|
|
free(s);
|
|
}
|
|
cc = getenv("CC");
|
|
if (!cc) cc = "gcc";
|
|
eina_strbuf_append(buf, cc);
|
|
eina_strbuf_append(buf, " -I. -lm -o ");
|
|
eina_strbuf_append(buf, tmpd);
|
|
eina_strbuf_append(buf, "/");
|
|
eina_strbuf_append(buf, bin->bin);
|
|
|
|
eina_strbuf_append(buf, " -DLOCALEDIR=\\\"/tmp/X/share/locale\\\"");
|
|
eina_strbuf_append(buf, " -DPACKAGE_BIN_DIR=\\\"/tmp/X/bin\\\"");
|
|
eina_strbuf_append(buf, " -DPACKAGE_LIB_DIR=\\\"/tmp/X/lib\\\"");
|
|
eina_strbuf_append(buf, " -DPACKAGE_DATA_DIR=\\\"/tmp/X/share/");
|
|
eina_strbuf_append(buf, bld->domain);
|
|
eina_strbuf_append(buf, "\\\"");
|
|
|
|
eina_strbuf_append(buf, " -DPACKAGE_NAME=\\\"");
|
|
eina_strbuf_append(buf, bld->domain);
|
|
eina_strbuf_append(buf, "\\\"");
|
|
|
|
eina_strbuf_append(buf, " -DPACKAGE_VERSION=\\\"");
|
|
eina_strbuf_append(buf, bld->version);
|
|
eina_strbuf_append(buf, "\\\"");
|
|
|
|
eina_strbuf_append(buf, " -D_REENTRANT -DHAVE_CONFIG_H -pthread ");
|
|
eina_strbuf_append(buf, " $CFLAGS ");
|
|
|
|
EINA_LIST_FOREACH(bin->srcs, ll, s)
|
|
{
|
|
extn = strrchr(s, '.');
|
|
if ((extn) && (!strcasecmp(extn, ".c")))
|
|
{
|
|
eina_strbuf_append(buf, s);
|
|
eina_strbuf_append(buf, " ");
|
|
}
|
|
}
|
|
EINA_LIST_FOREACH(bin->deps, ll, s)
|
|
{
|
|
eina_strbuf_append(buf, " `pkg-config --cflags --libs ");
|
|
eina_strbuf_append(buf, s);
|
|
eina_strbuf_append(buf, "`");
|
|
}
|
|
EINA_LIST_FOREACH(bin->incs, ll, s)
|
|
{
|
|
eina_strbuf_append(buf, " -I");
|
|
eina_strbuf_append(buf, s);
|
|
eina_strbuf_append(buf, " ");
|
|
}
|
|
s = (char *)eina_strbuf_string_get(buf);
|
|
if (s) system(s);
|
|
eina_strbuf_free(buf);
|
|
}
|
|
}
|
|
return EINA_TRUE;
|
|
error:
|
|
return EINA_FALSE;
|
|
#undef err
|
|
}
|
|
|
|
static void
|
|
package_file(Eet_File *ef, const char *file, const char *key)
|
|
{
|
|
Eina_File *enf = eina_file_open(file, EINA_FALSE);
|
|
if (enf)
|
|
{
|
|
void *mem = eina_file_map_all(enf, EINA_FILE_SEQUENTIAL);
|
|
if (mem)
|
|
{
|
|
size_t size = eina_file_size_get(enf);
|
|
eet_write(ef, key, mem, size, EET_COMPRESSION_VERYFAST);
|
|
}
|
|
eina_file_close(enf);
|
|
}
|
|
}
|
|
|
|
static void
|
|
package_bin_iter(Eet_File *ef, const char *dir, const char *key)
|
|
{
|
|
Eina_List *files;
|
|
Eina_File *enf;
|
|
char *s;
|
|
char tmp[4096];
|
|
char tmp2[4096];
|
|
|
|
files = ecore_file_ls(dir);
|
|
EINA_LIST_FREE(files, s)
|
|
{
|
|
if (!strcmp(s, ".")) continue;
|
|
else if (!strcmp(s, "..")) continue;
|
|
snprintf(tmp, sizeof(tmp), "%s/%s", dir, s);
|
|
snprintf(tmp2, sizeof(tmp2), "%s/%s", key, s);
|
|
if (ecore_file_is_dir(tmp))
|
|
{
|
|
if (ecore_file_can_exec(tmp)) tmp2[4] = 'D';
|
|
package_bin_iter(ef, tmp, tmp2);
|
|
}
|
|
else
|
|
{
|
|
if (ecore_file_can_exec(tmp)) tmp2[4] = 'X';
|
|
else tmp2[4] = 'f';
|
|
package_file(ef, tmp, tmp2);
|
|
}
|
|
free(s);
|
|
}
|
|
}
|
|
|
|
EAPI Eina_Bool
|
|
mrk_build_package_bin(Mrk_Build *bld, const char *file, const char *tmpd, const char *os, const char *arch)
|
|
{
|
|
Eet_File *ef;
|
|
char tmp[4096];
|
|
Eina_List *l;
|
|
char *s;
|
|
int i;
|
|
|
|
// snprintf(tmp, sizeof(tmp), "%s-%s.mkb", bld->name, bld->version);
|
|
ef = eet_open(file, EET_FILE_MODE_WRITE);
|
|
if (ef)
|
|
{
|
|
#define WRTS(key, var) \
|
|
if (var) eet_write(ef, key, var, strlen(var), EET_COMPRESSION_VERYFAST)
|
|
WRTS("name", bld->name);
|
|
if (bld->icon) package_file(ef, bld->icon, "icon");
|
|
WRTS("brief", bld->brief);
|
|
WRTS("version", bld->version);
|
|
WRTS("license", bld->license);
|
|
WRTS("repo", bld->repo);
|
|
WRTS("devrepo", bld->devrepo);
|
|
WRTS("contact", bld->contact);
|
|
WRTS("needs", bld->needs);
|
|
snprintf(tmp, sizeof(tmp), "%s-%s", os, arch);
|
|
WRTS("arch", tmp);
|
|
i = 0;
|
|
EINA_LIST_FOREACH(bld->tags, l, s)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "tag/%i", i++);
|
|
WRTS(tmp, s);
|
|
}
|
|
i = 0;
|
|
EINA_LIST_FOREACH(bld->categories, l, s)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "category/%i", i++);
|
|
WRTS(tmp, s);
|
|
}
|
|
package_bin_iter(ef, tmpd, "bin/f");
|
|
eet_close(ef);
|
|
return EINA_TRUE;
|
|
}
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
EAPI Eina_Bool
|
|
mrk_build_package_src(Mrk_Build *bld, const char *buildfile, const char *file)
|
|
{
|
|
Eet_File *ef;
|
|
char tmp[4096];
|
|
char tmp2[4096];
|
|
|
|
// snprintf(tmp, sizeof(tmp), "%s-%s.mks", bld->name, bld->version);
|
|
ef = eet_open(file, EET_FILE_MODE_WRITE);
|
|
if (ef)
|
|
{
|
|
Eina_File *enf;
|
|
Eina_List *l, *ll;
|
|
void *mem;
|
|
size_t size;
|
|
char *s;
|
|
Mrk_Build_Bin *bin;
|
|
Mrk_Build_Data *data;
|
|
|
|
enf = eina_file_open(buildfile, EINA_FALSE);
|
|
if (!enf) err("can't open build file");
|
|
mem = eina_file_map_all(enf, EINA_FILE_SEQUENTIAL);
|
|
if (!mem) err("can't map build file");
|
|
size = eina_file_size_get(enf);
|
|
eet_write(ef, "buildinfo", mem, size, EET_COMPRESSION_VERYFAST);
|
|
eina_file_close(enf);
|
|
|
|
EINA_LIST_FOREACH(bld->copying, l, s)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "src/%s", s);
|
|
package_file(ef, s, tmp);
|
|
}
|
|
EINA_LIST_FOREACH(bld->desktops, l, s)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "src/%s", s);
|
|
package_file(ef, s, tmp);
|
|
}
|
|
EINA_LIST_FOREACH(bld->icons, l, s)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "src/%s", s);
|
|
package_file(ef, s, tmp);
|
|
}
|
|
EINA_LIST_FOREACH(bld->po, l, s)
|
|
{
|
|
snprintf(tmp2, sizeof(tmp2), "po/%s.gmo", s);
|
|
snprintf(tmp, sizeof(tmp), "src/po/%s.gmo", s);
|
|
package_file(ef, tmp2, tmp);
|
|
}
|
|
EINA_LIST_FOREACH(bld->bins, l, bin)
|
|
{
|
|
EINA_LIST_FOREACH(bin->srcs, ll, s)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "src/%s", s);
|
|
package_file(ef, s, tmp);
|
|
}
|
|
}
|
|
EINA_LIST_FOREACH(bld->data, l, data)
|
|
{
|
|
snprintf(tmp, sizeof(tmp), "src/%s", data->src);
|
|
package_file(ef, data->src, tmp);
|
|
}
|
|
eet_close(ef);
|
|
return EINA_TRUE;
|
|
}
|
|
return EINA_FALSE;
|
|
}
|