configure

Browse Download file Permalink

/* $Id$ */

/* This file is part of DeforaOS Devel configure */

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are

* met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED

* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

#include <sys/param.h>

#include <stdarg.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include <errno.h>

#include "../config.h"

#ifndef __unused

# define __unused

#endif

#ifndef MAXPATHLEN

# define MAXPATHLEN 1024 /* XXX */

#endif

#ifndef PREFIX

# define PREFIX "/usr/local"

#endif

#ifndef PROGNAME

# define PROGNAME "pkg-config"

#endif

#define PKG_CFLAGS (1 << 0)

#define PKG_CFLAGS_ONLY_I (1 << 1)

#define PKG_CFLAGS_ONLY_OTHERS (1 << 2)

#define PKG_LIBS (1 << 3)

#define PKG_LIBS_ONLY_L (1 << 4)

#define PKG_LIBS_ONLY_l (1 << 5)

#define PKG_LIBS_ONLY_OTHERS (1 << 6)

#define PKG_DESCRIPTION (1 << 7)

#define PKG_URL (1 << 8)

#define PKG_STATIC (1 << 9)

#define PKG_VERSION (1 << 10)

#define PKG_EXISTS (1 << 11)

#define PKG_MODVERSION (1 << 12)

#define PKG_PRINT_REQUIRES (1 << 13)

#define PKG_PRINT_REQUIRES_PRIV (1 << 14)

/* pkg-config without glib without pkg-config without glib without pkg-config */

/* private */

/* types */

typedef struct _ListData {

void *data;

void (*freefn)(void *free);

} ListData;

typedef struct _PkgList {

size_t cap;

size_t len;

ListData **data;

} PkgList;

typedef struct _PkgConfigVariable

{

char * name;

char * value;

} PkgConfigVariable;

typedef enum {

GT,

LT,

GE,

LE,

} operator;

typedef struct _Pkg

{

char *pkgname;

char *name;

char *version;

char *description;

char *url;

PkgList *cflags;

PkgList *cflags_private;

PkgList *libs;

PkgList *libs_private;

PkgList *requires;

PkgList *requires_private;

PkgList *variables;

} Pkg;

typedef struct _PkgRequires

{

char *name;

char *version;

operator op;

Pkg *pkg;

} PkgRequires;

typedef struct _PkgConfig

{

/* variables */

unsigned int flags;

PkgList *pc_dirs;

PkgList *pkgs;

} PkgConfig;

/* prototypes */

static int _pkgconfig(PkgConfig * pc, int pkgc, char * pkgv[]);

static int _pkgconfig_error(int ret, char const * format, ...);

/* lists */

static PkgList * _pkglist_new(PkgList **list);

static void _pkglist_delete(PkgList *list);

static void * _pkglist_get(PkgList *list, size_t i);

static void _pkglist_append(PkgList *list, void *data, void (*freefn)(void *));

/* string */

static int _string_append(char ** string, char const * append);

static int _string_append_length(char ** string, char const * append,

size_t length);

static int _usage(int brief);

/* functions */

/* pkgconfig */

static Pkg * _pkg_new(Pkg **pkg, char const * pkgname);

static void _pkgconfig_variable_delete(PkgConfigVariable *p);

static FILE * _pkgconfig_open(PkgConfig * pc, char const * pkg);

static int _pkgconfig_parse(PkgConfig * p, FILE * fp);

static int _pkgconfig_parse_directive(PkgConfig * pc, Pkg * p, char const * directive,

char const * value);

static char * _pkgconfig_parse_substitute(PkgList * v, char const * value);

static int _pkgconfig_parse_variable(PkgConfig * pc, Pkg * p, char const * name,

char const * value);

static int _pkgconfig_parse_name(PkgConfig *pc, Pkg *p, char *data);

static int _pkgconfig_parse_description(PkgConfig *pc, Pkg *p, char *data);

static int _pkgconfig_parse_version(PkgConfig *pc, Pkg *p, char *data);

static int _pkgconfig_parse_cflags(PkgConfig *pc, Pkg *p, char *data);

static int _pkgconfig_parse_cflags_private(PkgConfig *pc, Pkg *p, char *data);

static int _pkgconfig_parse_libs(PkgConfig *pc, Pkg *p, char *data);

static int _pkgconfig_parse_libs_private(PkgConfig *pc, Pkg *p, char *data);

static int _pkgconfig_parse_requires(PkgConfig *pc, Pkg *p, char *data);

static int _pkgconfig_parse_requires_private(PkgConfig *pc, Pkg *p, char *data);

static int _pkgconfig_parse_requires_generic(PkgConfig *pc, Pkg *p, char *data, PkgList *lst);

struct keys {

const char *key;

int (*parse)(PkgConfig *, Pkg *, char *);

} keys [] = {

{ "Name", _pkgconfig_parse_name },

{ "Description", _pkgconfig_parse_description },

{ "Version", _pkgconfig_parse_version },

{ "Cflags", _pkgconfig_parse_cflags },

{ "Cflags.private", _pkgconfig_parse_cflags_private },

{ "Libs", _pkgconfig_parse_libs },

{ "Libs.private", _pkgconfig_parse_libs_private },

{ "Requires", _pkgconfig_parse_requires },

{ "Requires.private", _pkgconfig_parse_requires_private },

{ NULL, NULL },

};

static PkgRequires * _pkgrequires_new(PkgRequires **p, char *name)

{

if (*p != NULL)

return *p;

if ((*p = malloc(sizeof(PkgRequires))) == NULL) {

_pkgconfig_error(1, "%s", strerror(errno));

return NULL;

}

(*p)->name = strdup(name);

(*p)->op = EQ;

(*p)->version = NULL;

(*p)->pkg = NULL;

return *p;

}

static void _pkgrequires_delete(void *p1)

{

PkgRequires *p = (PkgRequires *)p1;

if (p == NULL)

return;

if (p->name != NULL)

free(p->name);

if (p->version != NULL)

free(p->version);

}

static Pkg * _pkg_new(Pkg **pkg, char const * pkgname)

{

if (*pkg != NULL)

return *pkg;

if ((*pkg = malloc(sizeof(Pkg))) == NULL) {

_pkgconfig_error(1, "%s", strerror(errno));

return NULL;

}

(*pkg)->name = NULL;

(*pkg)->version = NULL;

(*pkg)->description = NULL;

(*pkg)->url = NULL;

(*pkg)->pkgname = strdup(pkgname);

(*pkg)->cflags = NULL;

(*pkg)->cflags_private = NULL;

(*pkg)->libs = NULL;

(*pkg)->libs_private = NULL;

(*pkg)->variables = NULL;

(*pkg)->requires = NULL;

(*pkg)->requires_private = NULL;

return *pkg;

}

static void _pkg_delete(void *pkg)

{

Pkg *p = (Pkg *)pkg;

if (p->pkgname != NULL)

free(p->pkgname);

if (p->name != NULL)

free(p->name);

if (p->version != NULL)

free(p->version);

if (p->description != NULL)

free(p->description);

if (p->url != NULL)

free(p->url);

_pkglist_delete(p->cflags);

_pkglist_delete(p->cflags_private);

_pkglist_delete(p->libs);

_pkglist_delete(p->libs_private);

_pkglist_delete(p->variables);

_pkglist_delete(p->requires);

_pkglist_delete(p->requires_private);

}

static PkgConfigVariable *_pkgconfig_variable_new(PkgConfigVariable **p)

{

if (*p != NULL)

return *p;

if ((*p = malloc(sizeof(PkgConfigVariable))) == NULL)

{

_pkgconfig_error(1, "%s", strerror(errno));

return NULL;

}

(*p)->name = NULL;

(*p)->value = NULL;

return *p;

}

static void _pkgconfig_variable_delete(PkgConfigVariable *p)

{

free(p->name);

free(p->value);

free(p);

}

static int _pkgconfig_parse_name(__unused PkgConfig *pc, Pkg *p, char *data)

{

int ret = 0;

if (p->name != NULL)

free(p->name);

p->name = strdup(data);

return ret;

}

static int _pkgconfig_parse_description(PkgConfig *pc, Pkg *p, char *data)

{

int ret = 0;

if ((pc->flags & PKG_DESCRIPTION) == 0)

return ret;

if (p->description != NULL)

free(p->description);

p->description = strdup(data);

return ret;

}

static int _pkgconfig_parse_version(PkgConfig *pc, Pkg *p, char *data)

{

int ret = 0;

if ((pc->flags & PKG_MODVERSION) == 0)

return ret;

if (p->version != NULL)

free(p->version);

p->version = strdup(data);

return ret;

}

static int split_chr(char *str, char sep)

{

char *next;

char *buf = str;

int nbel = 0;

while ((next = strchr(buf, sep)) != NULL) {

nbel++;

buf = next;

buf[0] = '\0';

buf++;

}

return nbel;

}

static void _pkgconfig_add_to_list(PkgList *lst, char *data)

{

size_t k;

/* do not append something already appended */

for (k = 0; k < lst->len; k++)

if (strcmp((char *)_pkglist_get(lst, k), data) == 0)

break;

if (k == lst->len)

_pkglist_append(lst, strdup(data), free);

}

static int _pkgconfig_parse_generic(PkgList *lst, char *data, unsigned int flags, unsigned int type)

{

int ret = 0;

int i;

int nbel = 0;

size_t next;

char *walk;

nbel = split_chr(data, ' ');

next = strlen(data);

walk = data;

for (i = 0; i <= nbel; i++) {

if (next != 0) {

if (type == PKG_CFLAGS) {

if (flags & PKG_CFLAGS_ONLY_I) {

if (strncmp(walk, "-I", 2) == 0)