static void
gopal_rd_init(const char *fname)
{char buff[32];
char *ck;
char *filename;
CHECK_BOOL(optclean);
if (optminspeed)
{
minspeed=atof(optminspeed);
if (global_opts.debug_level > 1) fprintf(stderr,"options from command line : gopal minspeed = %s\n",optminspeed);
}
else
minspeed=0;
if (optmaxspeed)
{
maxspeed=atof(optmaxspeed);
if (global_opts.debug_level > 1) fprintf(stderr,"options from command line : gopal maxspeed = %s\n",optmaxspeed);
}
else
maxspeed=200;
if (global_opts.debug_level > 1) fprintf(stderr,"setting minspeed to %5.1lf km/h and maxspeed to %5.1lf km/h\n",minspeed,maxspeed);
fin = gbfopen(fname, "r", MYNAME);
memset(buff,0,sizeof(buff));
if (optdate)
{
memset(&opt_tm, 0, sizeof(opt_tm));
ck = (char *)strptime(optdate, "%Y%m%d", &opt_tm);
if ((ck == NULL) || (*ck != '\0') || (strlen(optdate) != 8))
fatal(MYNAME ": Invalid date \"%s\"!\n", optdate);
else if (opt_tm.tm_year < 70)
fatal(MYNAME ": Date \"%s\" is out of range (have to be 19700101 or later)!\n", optdate);
tx = mkgmtime(&opt_tm);
}
else
{
/* remove path */
filename = get_filename(fname);
if ((strncmp(filename,"track",5)==0)&&(strlen(filename)>13)) // we need at least 13 letters: trackYYYYMMDD...
{
strncpy(&buff[0],&filename[5],8);
}
else
if ((strncmp(filename,"A_",2)==0)&&(strlen(filename)>10))// here we expect at least 10 letters: A_YYYYMMDD...
{
strncpy(&buff[0],&filename[2],8);
}
// in buff we should now have something wich looks like a valid date starting with YYYYMMDD
ck = (char *)strptime(buff, "%Y%m%d", &filenamedate);
if (((ck == NULL) || (*ck != '\0') )&&!(optdate))
fatal(MYNAME ": Invalid date in filename \"%s\", try to set manually using \"optdate\" switch!\n", buff);
else if (filenamedate.tm_year < 70)
fatal(MYNAME ": Date \"%s\" is out of range (have to be 19700101 or later)!\n", buff);
tx= mkgmtime(&filenamedate);
}
}
static void
osm_wr_init(const char *fname)
{
fout = gbfopen(fname, "w", MYNAME);
osm_init_icons();
waypoints = avltree_init(0, MYNAME);
node_id = 0;
}
static void
wr_init(const char *fname)
{
waypoint_count = 0;
output_name = xstrdup(fname);
if (!split_output) {
file_out = gbfopen(fname, "w", MYNAME);
}
mkshort_handle = mkshort_new_handle();
}
static void
garmin_txt_wr_init(const char *fname)
{
char *grid_str;
memset(>xt_flags, 0, sizeof(gtxt_flags));
fout = gbfopen(fname, "wb", MYNAME);
gtxt_flags.metric = (toupper(*get_option_val(opt_dist, "m")) == 'M');
gtxt_flags.celsius = (toupper(*get_option_val(opt_temp, "c")) == 'C');
init_date_and_time_format();
if (opt_precision) {
precision = atoi(opt_precision);
is_fatal(precision < 0, MYNAME ": Invalid precision (%s)!", opt_precision);
}
datum_str = get_option_val(opt_datum, NULL);
grid_str = get_option_val(opt_grid, NULL);
grid_index = grid_lat_lon_dmm;
if (grid_str != NULL) {
int i;
if (sscanf(grid_str, "%d", &i)) {
grid_index = (grid_type) i;
if ((grid_index < GRID_INDEX_MIN) || (grid_index > GRID_INDEX_MAX))
fatal(MYNAME ": Grid index out of range (%d..%d)!",
(int)GRID_INDEX_MIN, (int)GRID_INDEX_MAX);
}
else grid_index = gt_lookup_grid_type(grid_str, MYNAME);
}
switch(grid_index) {
case grid_bng: /* force datum to "Ord Srvy Grt Britn" */
datum_index = DATUM_OSGB36;
break;
case grid_swiss: /* force datum to "Ord Srvy Grt Britn" */
datum_index = DATUM_WGS84;
break;
default:
datum_index = gt_lookup_datum_index(datum_str, MYNAME);
}
if (opt_utc != NULL) {
if (case_ignore_strcmp(opt_utc, "utc") == 0)
utc_offs = 0;
else
utc_offs = atoi(opt_utc);
utc_offs *= (60 * 60);
gtxt_flags.utc = 1;
}
}
static void
garmin_txt_rd_init(const char *fname)
{
memset(>xt_flags, 0, sizeof(gtxt_flags));
fin = gbfopen(fname, "rb", MYNAME);
memset(&header_ct, 0, sizeof(header_ct));
datum_index = -1;
grid_index = -1;
init_date_and_time_format();
}
static void
nav_rd_init(const char *fname)
{
fin = gbfopen(fname, "r", MYNAME);
psr = XML_ParserCreate(NULL);
if (!psr) {
fatal(MYNAME ":Cannot create XML parser\n");
}
XML_SetUnknownEncodingHandler(psr, cet_lib_expat_UnknownEncodingHandler, NULL);
XML_SetElementHandler(psr, nav_start, nav_end);
}
static void
xol_wr_init(const char *fname)
{
fout = gbfopen(fname, "w", MYNAME);
space = 1;
waypt_init_bounds(&all_bounds);
short_h = mkshort_new_handle();
setshort_length(short_h, 1024); /* ??? */
setshort_badchars(short_h, "\r\n\t");
setshort_mustupper(short_h, 0);
setshort_mustuniq(short_h, 1);
setshort_whitespace_ok(short_h, 1);
setshort_repeating_whitespace_ok(short_h, 1);
setshort_defname(short_h, "Waypoint");
}
static void
gtc_wr_init(const char *fname)
{
int i;
ofd = gbfopen(fname, "w", MYNAME);
if(opt_sport) {
for(i = 0; i < MAX_SPORTS; i++) {
if(0 == case_ignore_strncmp(opt_sport, gtc_sportlist[i], 2)) {
gtc_sport = i;
break;
}
}
}
gtc_course_flag = atoi(opt_course);
}
static void
mmo_read(void)
{
#ifdef MMO_DBG
const char *sobj = "main";
#endif
gbfile *fx;
int i;
/* copy file to memory stream (needed for seek-ops and piped commands) */
DBG(("main", "loading file \"%s\".\n", fin->name));
fx = gbfopen(NULL, "wb", MYNAME);
gbfcopyfrom(fx, fin, 0x7FFFFFFF);
gbfrewind(fx);
gbfclose(fin);
fin = fx;
mmo_obj_ct = gbfgetuint16(fin);
DBG((sobj, "number of objects = %d\n", mmo_obj_ct));
i = gbfgetuint16(fin);
if (i != 0xFFFF) fatal(MYNAME ": Marker not equel to 0xFFFF!\n");
mmo_version = gbfgetuint16(fin);
DBG((sobj, "version = 0x%02X\n", mmo_version));
mmo_filemark = 0xFFFF0000UL | be_read16(&mmo_version);
DBG((sobj, "filemark = 0x%08X\n", mmo_filemark));
gbfseek(fin, -4, SEEK_CUR);
while (! gbfeof(fin)) { /* main read loop */
(void) mmo_read_object(NULL);
}
#ifdef MMO_DBG
printf("\n" MYNAME ":---------------------------------------\n");
printf(MYNAME ": EOF reached, nice!!!\n");
printf(MYNAME ": =======================================\n\n");
#endif
}
static void
kml_wr_init(const char *fname)
{
char u = 's';
if (opt_units) {
u = tolower(opt_units[0]);
}
switch(u) {
case 's': fmt_setunits(units_statute); break;
case 'm': fmt_setunits(units_metric); break;
default: fatal("Units argument '%s' should be 's' for statute units or 'm' for metric.", opt_units); break;
}
/*
* Reduce race conditions with network read link.
*/
ofd = gbfopen(fname, "w", MYNAME);
}
static void
unicsv_rd_init(const char *fname)
{
char *c;
unicsv_altscale = 1.0;
unicsv_depthscale = 1.0;
unicsv_proximityscale = 1.0;
unicsv_fields_tab = NULL;
unicsv_fields_tab_ct = 0;
unicsv_data_type = global_opts.objective;
unicsv_detect = (! (global_opts.masked_objective & (WPTDATAMASK | TRKDATAMASK | RTEDATAMASK | POSNDATAMASK)));
unicsv_track = unicsv_route = NULL;
unicsv_datum_idx = gt_lookup_datum_index(opt_datum, MYNAME);
fin = gbfopen(fname, "rb", MYNAME);
if ((c = gbfgetstr(fin)))
unicsv_fondle_header(c);
else
unicsv_fieldsep = NULL;
if (fin->unicode) cet_convert_init(CET_CHARSET_UTF8, 1);
}
static void
sbp_rd_init(const char *fname)
{
file_handle = gbfopen(fname, "r", MYNAME);
}
static void
compegps_wr_init(const char *fname)
{
fout = gbfopen(fname, "w", MYNAME);
sh = mkshort_new_handle();
}
static void
compegps_rd_init(const char *fname)
{
fin = gbfopen(fname, "rb", MYNAME);
input_datum = DATUM_WGS84;
}
static void
text_disp(const waypoint *wpt)
{
int latint, lonint;
char tbuf[1024];
time_t tm = wpt->creation_time;
gbint32 utmz;
double utme, utmn;
char utmzc;
char *tmpout1, *tmpout2;
char *altout;
fs_xml *fs_gpx;
waypoint_count++;
if (split_output) {
char *thisfname;
xasprintf(&thisfname, "%s%d", output_name, waypoint_count);
file_out = gbfopen(thisfname, "w", MYNAME);
}
lonint = abs((int) wpt->longitude);
latint = abs((int) wpt->latitude);
GPS_Math_WGS84_To_UTM_EN(wpt->latitude, wpt->longitude,
&utme, &utmn, &utmz, &utmzc);
if (tm == 0)
tm = time(NULL);
strftime(tbuf, sizeof(tbuf), "%d-%b-%Y", localtime(&tm));
tmpout1 = pretty_deg_format(wpt->latitude, wpt->longitude, degformat[2], " ", 0);
if (wpt->altitude != unknown_alt) {
xasprintf(&altout, " alt:%d", (int) ( (altunits[0]=='f')?METERS_TO_FEET(wpt->altitude):wpt->altitude) );
}
else {
altout = "";
}
xasprintf (&tmpout2, "%s (%d%c %6.0f %7.0f)%s", tmpout1, utmz, utmzc, utme, utmn, altout );
gbfprintf(file_out, "%-16s %59s\n",
(global_opts.synthesize_shortnames) ? mkshort_from_wpt(mkshort_handle, wpt) : wpt->shortname,
tmpout2);
xfree(tmpout2);
xfree(tmpout1);
if (altout[0])
xfree(altout);
if (strcmp(wpt->description, wpt->shortname)) {
gbfprintf(file_out, "%s", wpt->description);
if (wpt->gc_data->placer)
gbfprintf(file_out, " by %s", wpt->gc_data->placer);
}
if (wpt->gc_data->terr) {
gbfprintf(file_out, " - %s / %s - (%d%s / %d%s)\n",
gs_get_cachetype(wpt->gc_data->type), gs_get_container(wpt->gc_data->container),
(int)(wpt->gc_data->diff / 10), (wpt->gc_data->diff%10)?".5":"",
(int)(wpt->gc_data->terr / 10), (wpt->gc_data->terr%10)?".5":"" );
if (wpt->gc_data->desc_short.utfstring) {
char *stripped_html = strip_html(&wpt->gc_data->desc_short);
gbfprintf (file_out, "\n%s\n", stripped_html);
xfree(stripped_html);
}
if (wpt->gc_data->desc_long.utfstring) {
char *stripped_html = strip_html(&wpt->gc_data->desc_long);
gbfprintf (file_out, "\n%s\n", stripped_html);
xfree(stripped_html);
}
if (wpt->gc_data->hint) {
char *hint = NULL;
if ( txt_encrypt )
hint = rot13( wpt->gc_data->hint );
else
hint = xstrdup( wpt->gc_data->hint );
gbfprintf (file_out, "\nHint: %s\n", hint);
xfree( hint );
}
}
else if (wpt->notes && (!wpt->description || strcmp(wpt->notes,wpt->description))) {
gbfprintf (file_out, "\n%s\n", wpt->notes);
}
fs_gpx = NULL;
if ( includelogs ) {
fs_gpx = (fs_xml *)fs_chain_find( wpt->fs, FS_GPX);
}
if ( fs_gpx && fs_gpx->tag ) {
xml_tag *root = fs_gpx->tag;
xml_tag *curlog = NULL;
xml_tag *logpart = NULL;
curlog = xml_findfirst( root, "groundspeak:log" );
while ( curlog ) {
time_t logtime = 0;
struct tm *logtm = NULL;
gbfprintf( file_out, "\n" );
logpart = xml_findfirst( curlog, "groundspeak:type" );
if ( logpart ) {
gbfprintf( file_out, "%s by ", logpart->cdata );
}
logpart = xml_findfirst( curlog, "groundspeak:finder" );
if ( logpart ) {
gbfprintf( file_out, "%s on ", logpart->cdata );
}
logpart = xml_findfirst( curlog, "groundspeak:date" );
if ( logpart ) {
logtime = xml_parse_time( logpart->cdata, NULL);
logtm = localtime( &logtime );
if ( logtm ) {
gbfprintf( file_out,
"%4.4d-%2.2d-%2.2d\n",
logtm->tm_year+1900,
logtm->tm_mon+1,
logtm->tm_mday );
}
}
logpart = xml_findfirst( curlog, "groundspeak:log_wpt" );
if ( logpart ) {
char *coordstr = NULL;
float lat = 0;
float lon = 0;
coordstr = xml_attribute( logpart, "lat" );
if ( coordstr ) {
lat = atof( coordstr );
}
coordstr = xml_attribute( logpart, "lon" );
if ( coordstr ) {
lon = atof( coordstr );
}
coordstr = pretty_deg_format(lat, lon, degformat[2], " ", 0);
gbfprintf( file_out, "%s\n", coordstr);
xfree(coordstr);
}
logpart = xml_findfirst( curlog, "groundspeak:text" );
if ( logpart ) {
char *encstr = NULL;
char *s = NULL;
int encoded = 0;
encstr = xml_attribute( logpart, "encoded" );
encoded = (encstr[0] != 'F');
if ( txt_encrypt && encoded ) {
s = rot13( logpart->cdata );
}
else {
s = xstrdup( logpart->cdata );
}
gbfprintf( file_out, "%s", s );
xfree( s );
}
gbfprintf( file_out, "\n" );
curlog = xml_findnext( root, curlog, "groundspeak:log" );
}
}
if (! suppresssep)
gbfprintf(file_out, "\n-----------------------------------------------------------------------------\n");
else
gbfprintf(file_out, "\n");
if (split_output) {
gbfclose(file_out);
file_out = NULL;
}
}
static void
gopal_wr_init(const char *fname)
{
fout = gbfopen(fname, "w", MYNAME);
}
static void
wr_init(const char *fname)
{
file_out = gbfopen(fname, "w", MYNAME);
}
static void
nmn4_rd_init(const char *fname)
{
fin = gbfopen(fname, "rb", MYNAME);
}
static void
nmn4_wr_init(const char *fname)
{
fout = gbfopen(fname, "wb", MYNAME);
}
static void
vpl_rd_init(const char *fname)
{
vpl_file_in = gbfopen(fname, "r", MYNAME);
}
static void
nav_wr_init(const char *fname)
{
fatal(MYNAME ": Does not support writing Navicache files.\n");
fout = gbfopen(fname, "w", MYNAME);
}
/*******************************************************************************
* %%% Reader callbacks %%% *
*******************************************************************************/
static void
format_garmin_xt_rd_init(const char *fname)
{
fin = gbfopen(fname, "rb", MYNAME);
}
