static void usage(FILE *fp)
{
fprintf(fp, "BabelTrace Trace Viewer and Converter %s\n\n", VERSION);
fprintf(fp, "usage : babeltrace [OPTIONS] FILE...\n");
fprintf(fp, "\n");
fprintf(fp, " FILE Input trace file(s) and/or directory(ies)\n");
fprintf(fp, " (space-separated)\n");
fprintf(fp, " -w, --output OUTPUT Output trace path (default: stdout)\n");
fprintf(fp, "\n");
fprintf(fp, " -i, --input-format FORMAT Input trace format (default: ctf)\n");
fprintf(fp, " -o, --output-format FORMAT Output trace format (default: text)\n");
fprintf(fp, "\n");
fprintf(fp, " -h, --help This help message\n");
fprintf(fp, " -l, --list List available formats\n");
fprintf(fp, " -v, --verbose Verbose mode\n");
fprintf(fp, " (or set BABELTRACE_VERBOSE environment variable)\n");
fprintf(fp, " -d, --debug Debug mode\n");
fprintf(fp, " (or set BABELTRACE_DEBUG environment variable)\n");
fprintf(fp, " --no-delta Do not print time delta between consecutive events\n");
fprintf(fp, " -n, --names name1<,name2,...> Print field names:\n");
fprintf(fp, " (payload OR args OR arg)\n");
fprintf(fp, " none, all, scope, header, (context OR ctx)\n");
fprintf(fp, " (default: payload,context)\n");
fprintf(fp, " -f, --fields name1<,name2,...> Print additional fields:\n");
fprintf(fp, " all, trace, trace:hostname, trace:domain,\n");
fprintf(fp, " trace:procname, trace:vpid, loglevel, emf, callsite.\n");
fprintf(fp, " (default: trace:hostname,trace:procname,trace:vpid)\n");
fprintf(fp, " --clock-cycles Timestamp in cycles\n");
fprintf(fp, " --clock-offset seconds Clock offset in seconds\n");
fprintf(fp, " --clock-offset-ns ns Clock offset in nanoseconds\n");
fprintf(fp, " --clock-seconds Print the timestamps as [sec.ns]\n");
fprintf(fp, " (default is: [hh:mm:ss.ns])\n");
fprintf(fp, " --clock-date Print clock date\n");
fprintf(fp, " --clock-gmt Print clock in GMT time zone (default: local time zone)\n");
fprintf(fp, " --clock-force-correlate Assume that clocks are inherently correlated\n");
fprintf(fp, " across traces.\n");
fprintf(fp, " --stream-intersection Only print events when all streams are active.\n");
#ifdef ENABLE_DEBUG_INFO
fprintf(fp, " --debug-info-dir Directory in which to look for debugging information\n");
fprintf(fp, " files. (default: /usr/lib/debug/)\n");
fprintf(fp, " --debug-info-target-prefix Directory to use as a prefix for executable lookup\n");
fprintf(fp, " --debug-info-full-path Show full debug info source and binary paths (if available)\n");
#endif
list_formats(fp);
fprintf(fp, "\n");
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct _options options;
struct _flags flags;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
G_add_keyword(_("output"));
G_add_keyword(_("external"));
module->description =
_("Defines vector output format utilizing OGR library.");
OGRRegisterAll();
parse_args(argc, argv, &options, &flags);
if (flags.f->answer) {
list_formats();
exit(EXIT_SUCCESS);
}
if (flags.r->answer) {
G_remove("", "OGR");
exit(EXIT_SUCCESS);
}
if (options.format->answer)
check_format(options.format->answer);
if (options.dsn->answer)
make_link(options.dsn->answer,
options.format->answer, options.opts->answers);
if (flags.p->answer || flags.g->answer) {
print_status(flags.g->answer ? 1 : 0);
}
exit(EXIT_SUCCESS);
}
static int lavf_check_file(demuxer_t *demuxer){
AVProbeData avpd;
uint8_t buf[PROBE_BUF_SIZE];
lavf_priv_t *priv;
if(!demuxer->priv)
demuxer->priv=calloc(sizeof(lavf_priv_t),1);
priv= demuxer->priv;
av_register_all();
if(stream_read(demuxer->stream, buf, PROBE_BUF_SIZE)!=PROBE_BUF_SIZE)
return 0;
avpd.filename= demuxer->stream->url;
avpd.buf= buf;
avpd.buf_size= PROBE_BUF_SIZE;
if (opt_format) {
if (strcmp(opt_format, "help") == 0) {
list_formats();
return 0;
}
priv->avif= av_find_input_format(opt_format);
if (!priv->avif) {
mp_msg(MSGT_DEMUX,MSGL_FATAL,"Unknown lavf format %s\n", opt_format);
return 0;
}
mp_msg(MSGT_DEMUX,MSGL_INFO,"Forced lavf %s demuxer\n", priv->avif->long_name);
return DEMUXER_TYPE_LAVF;
}
priv->avif= av_probe_input_format(&avpd, 1);
if(!priv->avif){
mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: no clue about this gibberish!\n");
return 0;
}else
mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: %s\n", priv->avif->long_name);
return DEMUXER_TYPE_LAVF;
}
int main(int argc, char *argv[])
{
const char *input, *source, *output;
char *title;
struct Cell_head cellhd;
GDALDatasetH hDS;
GDALRasterBandH hBand;
struct GModule *module;
struct {
struct Option *input, *source, *output, *band, *title;
} parm;
struct {
struct Flag *o, *f, *e, *r, *h, *v;
} flag;
int min_band, max_band, band;
struct band_info info;
int flip;
struct Ref reference;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("import"));
G_add_keyword(_("input"));
G_add_keyword(_("external"));
module->description =
_("Links GDAL supported raster data as a pseudo GRASS raster map.");
parm.input = G_define_standard_option(G_OPT_F_INPUT);
parm.input->description = _("Name of raster file to be linked");
parm.input->required = NO;
parm.input->guisection = _("Input");
parm.source = G_define_option();
parm.source->key = "source";
parm.source->description = _("Name of non-file GDAL data source");
parm.source->required = NO;
parm.source->type = TYPE_STRING;
parm.source->key_desc = "name";
parm.source->guisection = _("Input");
parm.output = G_define_standard_option(G_OPT_R_OUTPUT);
parm.band = G_define_option();
parm.band->key = "band";
parm.band->type = TYPE_INTEGER;
parm.band->required = NO;
parm.band->description = _("Band to select (default: all)");
parm.band->guisection = _("Input");
parm.title = G_define_option();
parm.title->key = "title";
parm.title->key_desc = "phrase";
parm.title->type = TYPE_STRING;
parm.title->required = NO;
parm.title->description = _("Title for resultant raster map");
parm.title->guisection = _("Metadata");
flag.f = G_define_flag();
flag.f->key = 'f';
flag.f->description = _("List supported formats and exit");
flag.f->guisection = _("Print");
flag.f->suppress_required = YES;
flag.o = G_define_flag();
flag.o->key = 'o';
flag.o->description =
_("Override projection (use location's projection)");
flag.e = G_define_flag();
flag.e->key = 'e';
flag.e->description = _("Extend location extents based on new dataset");
flag.r = G_define_flag();
flag.r->key = 'r';
flag.r->description = _("Require exact range");
flag.h = G_define_flag();
flag.h->key = 'h';
flag.h->description = _("Flip horizontally");
flag.v = G_define_flag();
flag.v->key = 'v';
flag.v->description = _("Flip vertically");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
GDALAllRegister();
if (flag.f->answer) {
list_formats();
exit(EXIT_SUCCESS);
}
input = parm.input->answer;
source = parm.source->answer;
output = parm.output->answer;
flip = 0;
if (flag.h->answer)
flip |= FLIP_H;
if (flag.v->answer)
flip |= FLIP_V;
if (parm.title->answer) {
title = G_store(parm.title->answer);
G_strip(title);
}
else
title = NULL;
if (!input && !source)
G_fatal_error(_("One of options <%s> or <%s> must be given"),
parm.input->key, parm.source->key);
if (input && source)
G_fatal_error(_("Option <%s> and <%s> are mutually exclusive"),
parm.input->key, parm.source->key);
if (input && !G_is_absolute_path(input)) {
char path[GPATH_MAX];
getcwd(path, sizeof(path));
strcat(path, "/");
strcat(path, input);
input = G_store(path);
}
if (!input)
input = source;
hDS = GDALOpen(input, GA_ReadOnly);
if (hDS == NULL)
return 1;
setup_window(&cellhd, hDS, &flip);
check_projection(&cellhd, hDS, flag.o->answer);
Rast_set_window(&cellhd);
if (parm.band->answer)
min_band = max_band = atoi(parm.band->answer);
else
min_band = 1, max_band = GDALGetRasterCount(hDS);
G_verbose_message(_("Proceeding with import..."));
if (max_band > min_band) {
if (I_find_group(output) == 1)
G_warning(_("Imagery group <%s> already exists and will be overwritten."), output);
I_init_group_ref(&reference);
}
for (band = min_band; band <= max_band; band++) {
char *output2, *title2 = NULL;
G_message(_("Reading band %d of %d..."),
band, GDALGetRasterCount( hDS ));
hBand = GDALGetRasterBand(hDS, band);
if (!hBand)
G_fatal_error(_("Selected band (%d) does not exist"), band);
if (max_band > min_band) {
G_asprintf(&output2, "%s.%d", output, band);
if (title)
G_asprintf(&title2, "%s (band %d)", title, band);
G_debug(1, "Adding raster map <%s> to group <%s>", output2, output);
I_add_file_to_group_ref(output2, G_mapset(), &reference);
}
else {
output2 = G_store(output);
if (title)
title2 = G_store(title);
}
query_band(hBand, output2, flag.r->answer, &cellhd, &info);
create_map(input, band, output2, &cellhd, &info, title, flip);
G_free(output2);
G_free(title2);
}
if (flag.e->answer)
update_default_window(&cellhd);
/* Create the imagery group if multiple bands are imported */
if (max_band > min_band) {
I_put_group_ref(output, &reference);
I_put_group(output);
G_message(_("Imagery group <%s> created"), output);
}
exit(EXIT_SUCCESS);
}
static int lavf_check_file(demuxer_t *demuxer){
AVProbeData avpd;
lavf_priv_t *priv;
int probe_data_size = 0;
int read_size = INITIAL_PROBE_SIZE;
int score;
if(!demuxer->priv)
demuxer->priv=calloc(sizeof(lavf_priv_t),1);
priv= demuxer->priv;
init_avformat();
if (opt_format) {
if (strcmp(opt_format, "help") == 0) {
list_formats();
return 0;
}
priv->avif= av_find_input_format(opt_format);
if (!priv->avif) {
mp_msg(MSGT_DEMUX,MSGL_FATAL,"Unknown lavf format %s\n", opt_format);
return 0;
}
mp_msg(MSGT_DEMUX,MSGL_INFO,"Forced lavf %s demuxer\n", priv->avif->long_name);
return DEMUXER_TYPE_LAVF;
}
avpd.buf = av_mallocz(FFMAX(BIO_BUFFER_SIZE, PROBE_BUF_SIZE) +
FF_INPUT_BUFFER_PADDING_SIZE);
do {
read_size = stream_read(demuxer->stream, avpd.buf + probe_data_size, read_size);
if(read_size < 0) {
av_free(avpd.buf);
return 0;
}
probe_data_size += read_size;
avpd.filename= demuxer->stream->url;
if (!avpd.filename) {
mp_msg(MSGT_DEMUX, MSGL_WARN, "Stream url is not set!\n");
avpd.filename = "";
}
if (!strncmp(avpd.filename, "ffmpeg://", 9))
avpd.filename += 9;
avpd.buf_size= probe_data_size;
score = 0;
priv->avif= av_probe_input_format2(&avpd, probe_data_size > 0, &score);
read_size = FFMIN(2*read_size, PROBE_BUF_SIZE - probe_data_size);
} while ((demuxer->desc->type != DEMUXER_TYPE_LAVF_PREFERRED ||
probe_data_size < SMALL_MAX_PROBE_SIZE) &&
score <= AVPROBE_SCORE_MAX / 4 &&
read_size > 0 && probe_data_size < PROBE_BUF_SIZE);
av_free(avpd.buf);
if(!priv->avif){
mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: no clue about this gibberish!\n");
return 0;
}else
mp_msg(MSGT_HEADER,MSGL_V,"LAVF_check: %s\n", priv->avif->long_name);
return DEMUXER_TYPE_LAVF;
}
int muxer_init_muxer_lavf(muxer_t *muxer)
{
muxer_priv_t *priv;
AVOutputFormat *fmt = NULL;
init_avformat();
if (conf_format && strcmp(conf_format, "help") == 0) {
list_formats();
return 0;
}
mp_msg(MSGT_MUXER, MSGL_WARN, "** MUXER_LAVF *****************************************************************\n");
mp_msg(MSGT_MUXER, MSGL_WARN,
"REMEMBER: MEncoder's libavformat muxing is presently broken and can generate\n"
"INCORRECT files in the presence of B-frames. Moreover, due to bugs MPlayer\n"
"will play these INCORRECT files as if nothing were wrong!\n"
"*******************************************************************************\n");
priv = calloc(1, sizeof(muxer_priv_t));
if(priv == NULL)
return 0;
priv->oc = avformat_alloc_context();
if(!priv->oc)
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "Could not get format context.\n");
goto fail;
}
if(conf_format)
fmt = av_guess_format(conf_format, NULL, NULL);
if(! fmt)
fmt = av_guess_format(NULL, out_filename, NULL);
if(! fmt)
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "Cannot get specified format.\n");
goto fail;
}
priv->oc->oformat = fmt;
priv->oc->packet_size= mux_packet_size;
priv->oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
if (info_name)
av_dict_set(&priv->oc->metadata, "title", info_name, 0);
if (info_artist)
av_dict_set(&priv->oc->metadata, "author", info_artist, 0);
if (info_genre)
av_dict_set(&priv->oc->metadata, "genre", info_genre, 0);
if (info_copyright)
av_dict_set(&priv->oc->metadata, "copyright", info_copyright, 0);
if (info_comment)
av_dict_set(&priv->oc->metadata, "comment", info_comment, 0);
if(mux_avopt){
if(parse_avopts(priv->oc, mux_avopt) < 0){
mp_msg(MSGT_MUXER,MSGL_ERR, "Your options /%s/ look like gibberish to me pal.\n", mux_avopt);
goto fail;
}
}
priv->oc->pb = avio_alloc_context(priv->buffer, BIO_BUFFER_SIZE, 1, muxer, NULL, mp_write, mp_seek);
if ((muxer->stream->flags & MP_STREAM_SEEK) != MP_STREAM_SEEK)
priv->oc->pb->seekable = 0;
muxer->priv = priv;
muxer->cont_new_stream = &lavf_new_stream;
muxer->cont_write_chunk = &write_chunk;
muxer->cont_write_header = &write_header;
muxer->cont_write_index = &write_trailer;
muxer->fix_stream_parameters = &fix_parameters;
mp_msg(MSGT_MUXER, MSGL_INFO, "OK, exit.\n");
return 1;
fail:
free(priv);
return 0;
}
int muxer_init_muxer_lavf(muxer_t *muxer)
{
muxer_priv_t *priv;
AVOutputFormat *fmt = NULL;
char mp_filename[256] = "menc://stream.dummy";
av_register_all();
if (conf_format && strcmp(conf_format, "help") == 0) {
list_formats();
return 0;
}
mp_msg(MSGT_MUXER, MSGL_WARN, "** MUXER_LAVF *****************************************************************\n");
if (!conf_allow_lavf) {
mp_msg(MSGT_MUXER, MSGL_FATAL,
"If you wish to use libavformat muxing, you must ensure that your video stream\n"
"does not contain B frames (out of order decoding) and specify:\n"
" -lavfopts i_certify_that_my_video_stream_does_not_use_b_frames\n"
"on the command line.\n");
} else {
mp_msg(MSGT_MUXER, MSGL_WARN,
"You have certified that your video stream does not contain B frames.\n");
}
mp_msg(MSGT_MUXER, MSGL_WARN,
"REMEMBER: MEncoder's libavformat muxing is presently broken and will generate\n"
"INCORRECT files in the presence of B frames. Moreover, due to bugs MPlayer\n"
"will play these INCORRECT files as if nothing were wrong!\n"
"*******************************************************************************\n");
if (!conf_allow_lavf) return 0;
priv = (muxer_priv_t *) calloc(1, sizeof(muxer_priv_t));
if(priv == NULL)
return 0;
priv->oc = av_alloc_format_context();
if(!priv->oc)
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "Couldn't get format context\n");
goto fail;
}
if(conf_format)
fmt = guess_format(conf_format, NULL, NULL);
if(! fmt)
fmt = guess_format(NULL, out_filename, NULL);
if(! fmt)
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "CAN'T GET SPECIFIED FORMAT\n");
goto fail;
}
priv->oc->oformat = fmt;
if(av_set_parameters(priv->oc, NULL) < 0)
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "Invalid output format parameters\n");
goto fail;
}
priv->oc->packet_size= mux_packet_size;
priv->oc->mux_rate= mux_rate;
priv->oc->preload= (int)(mux_preload*AV_TIME_BASE);
priv->oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
if (info_name)
pstrcpy(priv->oc->title , sizeof(priv->oc->title ), info_name );
if (info_artist)
pstrcpy(priv->oc->author , sizeof(priv->oc->author ), info_artist );
if (info_genre)
pstrcpy(priv->oc->genre , sizeof(priv->oc->genre ), info_genre );
if (info_copyright)
pstrcpy(priv->oc->copyright, sizeof(priv->oc->copyright), info_copyright);
if (info_comment)
pstrcpy(priv->oc->comment , sizeof(priv->oc->comment ), info_comment );
register_protocol(&mp_protocol);
if(url_fopen(&priv->oc->pb, mp_filename, URL_WRONLY))
{
mp_msg(MSGT_MUXER, MSGL_FATAL, "Coulnd't open outfile\n");
goto fail;
}
((URLContext*)(priv->oc->pb.opaque))->priv_data= muxer;
muxer->priv = (void *) priv;
muxer->cont_new_stream = &lavf_new_stream;
muxer->cont_write_chunk = &write_chunk;
muxer->cont_write_header = &write_header;
muxer->cont_write_index = &write_trailer;
muxer->fix_stream_parameters = &fix_parameters;
mp_msg(MSGT_MUXER, MSGL_INFO, "OK, exit\n");
return 1;
fail:
free(priv);
return 0;
}
/**
* Check the commandline arguments
* @param argc number of commandline args+1
* @param argv array of arguments, first is program name
* @param s the stripper object containing local vars
* @return 1 if they were OK, 0 otherwise
*/
static int check_args( int argc, char **argv, stripper *s )
{
char *dot_pos;
int sane = 1;
if ( argc < 2 )
sane = 0;
else
{
int i,rlen;
const char *rdata = NULL;
for ( i=1;i<argc;i++ )
{
if ( strlen(argv[i])==2 && argv[i][0]=='-' )
{
switch ( argv[i][1] )
{
case 'v':
printf( "stripper version 1.1 (c) "
"Desmond Schmidt 2011\n");
s->doing_help = 1;
break;
case 'h':
print_help();
s->doing_help = 1;
break;
case 'f':
if ( i < argc-2 )
{
s->selected_format = lookup_format( argv[i+1] );
if ( s->selected_format == -1 )
error("stripper: format %s not supported.\n",
argv[i+1]);
}
else
sane = 0;
break;
case 'l':
list_formats();
s->doing_help = 1;
break;
case 'r':
s->recipe_file = argv[i+1];
break;
case 's':
s->style = argv[i+1];
break;
case 'e':
s->hh_except_string = strdup(argv[i+1]);
break;
}
}
if ( !sane )
break;
}
if ( !s->doing_help )
{
strncpy( s->src, argv[argc-1], FILE_NAME_LEN );
sane = file_exists( s->src );
if ( !sane )
fprintf(stderr,"stripper: can't find file %s\n",s->src );
else
{
strncpy(s->barefile, s->src, FILE_NAME_LEN );
dot_pos = strrchr( s->barefile, '.' );
if ( dot_pos != NULL )
dot_pos[0] = 0;
}
}
}
return sane;
}
/*
* Return 0 if caller should continue, < 0 if caller should return
* error, > 0 if caller should exit without reporting error.
*/
static int parse_options(int argc, char **argv)
{
poptContext pc;
int opt, ret = 0;
const char *ipath;
if (argc == 1) {
usage(stdout);
return 1; /* exit cleanly */
}
pc = poptGetContext(NULL, argc, (const char **) argv, long_options, 0);
poptReadDefaultConfig(pc, 0);
/* set default */
opt_context_field_names = 1;
opt_payload_field_names = 1;
while ((opt = poptGetNextOpt(pc)) != -1) {
switch (opt) {
case OPT_OUTPUT_PATH:
opt_output_path = (char *) poptGetOptArg(pc);
if (!opt_output_path) {
ret = -EINVAL;
goto end;
}
break;
case OPT_INPUT_FORMAT:
opt_input_format = (char *) poptGetOptArg(pc);
if (!opt_input_format) {
ret = -EINVAL;
goto end;
}
break;
case OPT_OUTPUT_FORMAT:
opt_output_format = (char *) poptGetOptArg(pc);
if (!opt_output_format) {
ret = -EINVAL;
goto end;
}
break;
case OPT_HELP:
usage(stdout);
ret = 1; /* exit cleanly */
goto end;
case OPT_LIST:
list_formats(stdout);
ret = 1;
goto end;
case OPT_VERBOSE:
babeltrace_verbose = 1;
break;
case OPT_NAMES:
if (get_names_args(&pc)) {
ret = -EINVAL;
goto end;
}
break;
case OPT_FIELDS:
if (get_fields_args(&pc)) {
ret = -EINVAL;
goto end;
}
break;
case OPT_DEBUG:
babeltrace_debug = 1;
break;
case OPT_NO_DELTA:
opt_delta_field = 0;
break;
case OPT_CLOCK_CYCLES:
opt_clock_cycles = 1;
break;
case OPT_CLOCK_OFFSET:
{
char *str;
char *endptr;
str = (char *) poptGetOptArg(pc);
if (!str) {
fprintf(stderr, "[error] Missing --clock-offset argument\n");
ret = -EINVAL;
goto end;
}
errno = 0;
opt_clock_offset = strtoull(str, &endptr, 0);
if (*endptr != '\0' || str == endptr || errno != 0) {
fprintf(stderr, "[error] Incorrect --clock-offset argument: %s\n", str);
ret = -EINVAL;
free(str);
goto end;
}
free(str);
break;
}
case OPT_CLOCK_SECONDS:
opt_clock_seconds = 1;
break;
case OPT_CLOCK_OFFSET_NS:
{
char *str;
char *endptr;
str = (char *) poptGetOptArg(pc);
if (!str) {
fprintf(stderr, "[error] Missing --clock-offset-ns argument\n");
ret = -EINVAL;
goto end;
}
errno = 0;
opt_clock_offset_ns = strtoull(str, &endptr, 0);
if (*endptr != '\0' || str == endptr || errno != 0) {
fprintf(stderr, "[error] Incorrect --clock-offset-ns argument: %s\n", str);
ret = -EINVAL;
free(str);
goto end;
}
free(str);
break;
}
case OPT_CLOCK_DATE:
opt_clock_date = 1;
break;
case OPT_CLOCK_GMT:
opt_clock_gmt = 1;
break;
case OPT_CLOCK_FORCE_CORRELATE:
opt_clock_force_correlate = 1;
break;
case OPT_STREAM_INTERSECTION:
opt_stream_intersection = 1;
break;
case OPT_DEBUG_INFO_DIR:
opt_debug_info_dir = (char *) poptGetOptArg(pc);
if (!opt_debug_info_dir) {
ret = -EINVAL;
goto end;
}
break;
case OPT_DEBUG_INFO_FULL_PATH:
opt_debug_info_full_path = 1;
break;
case OPT_DEBUG_INFO_TARGET_PREFIX:
opt_debug_info_target_prefix = (char *) poptGetOptArg(pc);
if (!opt_debug_info_target_prefix) {
ret = -EINVAL;
goto end;
}
break;
default:
ret = -EINVAL;
goto end;
}
}
do {
ipath = poptGetArg(pc);
if (ipath)
g_ptr_array_add(opt_input_paths, (gpointer) ipath);
} while (ipath);
if (opt_input_paths->len == 0) {
ret = -EINVAL;
goto end;
}
end:
if (pc) {
poptFreeContext(pc);
}
return ret;
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct _options options;
struct _flags flags;
char * format;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
G_add_keyword(_("output"));
G_add_keyword(_("external"));
G_add_keyword("OGR");
G_add_keyword("PostGIS");
module->description = _("Defines vector output format.");
#ifdef HAVE_OGR
OGRRegisterAll();
#endif
parse_args(argc, argv, &options, &flags);
if (flags.f->answer) {
list_formats();
exit(EXIT_SUCCESS);
}
if (flags.r->answer) {
if (G_remove("", "OGR") == 1) {
G_verbose_message(_("Switched from OGR to native format"));
}
else {
if (G_remove("", "PG") == 1)
G_verbose_message(_("Switched from PostGIS to native format"));
}
G_message(_("Current output format for vectors: %s"), "GRASS");
exit(EXIT_SUCCESS);
}
format = NULL;
if (options.format->answer) {
format = G_store(options.format->answer);
check_format(format);
}
if (options.dsn->answer) {
make_link(options.dsn->answer, format,
options.opts->answer, options.opts->answers);
}
else if (options.input->answer) {
read_status_file(options.input);
}
if (flags.p->answer || flags.g->answer) {
print_status(flags.g->answer ? TRUE : FALSE);
}
if (options.output->answer) {
save_status_file(options.output);
}
if (options.dsn->answer || options.input->answer)
G_message(_("Current output format for vectors: %s"), format);
exit(EXIT_SUCCESS);
}
