149 lines
3.8 KiB
C
149 lines
3.8 KiB
C
/**
|
|
* Display the list of re-exported libraries from a TAPI v2 .tbd file, one per
|
|
* line on stdout.
|
|
*
|
|
* TAPI files are the equivalent of library files for the purposes of linking.
|
|
* Like dylib files, they may re-export other libraries. In upstream usage
|
|
* these refer to the absolute paths of dylibs, and are resolved to .tbd files
|
|
* in combination with the syslibroot option. In nixpkgs, the .tbd files refer
|
|
* directly to other .tbd files without a syslibroot. Note that each .tbd file
|
|
* contains an install name, so the re-exported path does not affect the final
|
|
* result.
|
|
*
|
|
* In nixpkgs each framework is a distinct store path and some frameworks
|
|
* re-export other frameworks. The re-exported names are rewritten to refer to
|
|
* the store paths of dependencies via textual substitution. This utility is
|
|
* used to emit every file that is listed as a re-exported library, which
|
|
* allows the framework builder to verify their existence.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <sys/errno.h>
|
|
#include <yaml.h>
|
|
|
|
static yaml_node_t *get_mapping_entry(yaml_document_t *document, yaml_node_t *mapping, const char *name) {
|
|
if (!mapping) {
|
|
fprintf(stderr, "get_mapping_entry: mapping is null\n");
|
|
return NULL;
|
|
}
|
|
|
|
for (
|
|
yaml_node_pair_t *pair = mapping->data.mapping.pairs.start;
|
|
pair < mapping->data.mapping.pairs.top;
|
|
++pair
|
|
) {
|
|
yaml_node_t *key = yaml_document_get_node(document, pair->key);
|
|
|
|
if (!key) {
|
|
fprintf(stderr, "get_mapping_entry: key (%i) is null\n", pair->key);
|
|
return NULL;
|
|
}
|
|
|
|
if (key->type != YAML_SCALAR_NODE) {
|
|
fprintf(stderr, "get_mapping_entry: key is not a scalar\n");
|
|
return NULL;
|
|
}
|
|
|
|
if (strncmp((const char *)key->data.scalar.value, name, key->data.scalar.length) != 0) {
|
|
continue;
|
|
}
|
|
|
|
return yaml_document_get_node(document, pair->value);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int emit_reexports(yaml_document_t *document) {
|
|
yaml_node_t *root = yaml_document_get_root_node(document);
|
|
|
|
yaml_node_t *exports = get_mapping_entry(document, root, "exports");
|
|
|
|
if (!exports) {
|
|
fprintf(stderr, "emit_reexports: no exports found\n");
|
|
return 0;
|
|
}
|
|
|
|
if (exports->type != YAML_SEQUENCE_NODE) {
|
|
fprintf(stderr, "emit_reexports, value is not a sequence\n");
|
|
return 0;
|
|
}
|
|
|
|
for (
|
|
yaml_node_item_t *export = exports->data.sequence.items.start;
|
|
export < exports->data.sequence.items.top;
|
|
++export
|
|
) {
|
|
yaml_node_t *export_node = yaml_document_get_node(document, *export);
|
|
|
|
yaml_node_t *reexports = get_mapping_entry(document, export_node, "re-exports");
|
|
|
|
if (!reexports) {
|
|
continue;
|
|
}
|
|
|
|
for (
|
|
yaml_node_item_t *reexport = reexports->data.sequence.items.start;
|
|
reexport < reexports->data.sequence.items.top;
|
|
++reexport
|
|
) {
|
|
yaml_node_t *val = yaml_document_get_node(document, *reexport);
|
|
|
|
if (val->type != YAML_SCALAR_NODE) {
|
|
fprintf(stderr, "item is not a scalar\n");
|
|
return 0;
|
|
}
|
|
|
|
fwrite(val->data.scalar.value, val->data.scalar.length, 1, stdout);
|
|
putchar('\n');
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
int result = 0;
|
|
|
|
if (argc != 2) {
|
|
fprintf(stderr, "Invalid usage\n");
|
|
result = 2;
|
|
goto done;
|
|
}
|
|
|
|
FILE *f = fopen(argv[1], "r");
|
|
if (!f) {
|
|
perror("opening input file");
|
|
result = errno;
|
|
goto done;
|
|
}
|
|
|
|
yaml_parser_t yaml_parser;
|
|
if (!yaml_parser_initialize(&yaml_parser)) {
|
|
fprintf(stderr, "Failed to initialize yaml parser\n");
|
|
result = 1;
|
|
goto err_file;
|
|
}
|
|
|
|
yaml_parser_set_input_file(&yaml_parser, f);
|
|
|
|
yaml_document_t yaml_document;
|
|
|
|
if(!yaml_parser_load(&yaml_parser, &yaml_document)) {
|
|
fprintf(stderr, "Failed to load yaml file\n");
|
|
result = 1;
|
|
goto err_yaml;
|
|
}
|
|
|
|
emit_reexports(&yaml_document);
|
|
|
|
err_yaml:
|
|
yaml_parser_delete(&yaml_parser);
|
|
|
|
err_file:
|
|
fclose(f);
|
|
|
|
done:
|
|
return result;
|
|
}
|