static void
enum_waypt_cb(const waypoint *wpt)
{
garmin_fs_p gmsd;
int wpt_class;
gmsd = GMSD_FIND(wpt);
wpt_class = GMSD_GET(wpt_class, 0);
if (wpt_class < 0x80)
{
int i;
if (gtxt_flags.enum_waypoints) /* enumerate only */
{
waypoints++;
return;
}
for (i = 0; i < wpt_a_ct; i++) { /* check for duplicates */
waypoint *tmp = wpt_a[i];
if (case_ignore_strcmp(tmp->shortname, wpt->shortname) == 0)
{
wpt_a[i] = (waypoint *)wpt;
waypoints--;
return;
}
}
wpt_a[wpt_a_ct++] = (waypoint *)wpt;
}
}
void
garmin_fs_xml_fprint(gbfile *ofd, const waypoint *waypt)
{
char *phone, *addr;
garmin_fs_t *gmsd = GMSD_FIND(waypt);
if (gmsd == NULL) return;
/* Find out if there is at least one field set */
addr = GMSD_GET(addr, "");
if (! *addr) addr = GMSD_GET(city, "");
if (! *addr) addr = GMSD_GET(country, "");
if (! *addr) addr = GMSD_GET(postal_code, "");
if (! *addr) addr = GMSD_GET(state, "");
phone = GMSD_GET(phone_nr, "");
if (*addr || *phone ||
(gmsd->flags.category && gmsd->category) ||
WAYPT_HAS(waypt, depth) ||
WAYPT_HAS(waypt, proximity) ||
WAYPT_HAS(waypt, temperature) ||
gmsd->flags.display)
{
int space = 1;
gbfprintf(ofd, "%*s<extensions>\n", space++ * 2, "");
gbfprintf(ofd, "%*s<gpxx:WaypointExtension %s\">\n", space++ * 2, "", GARMIN_GPX_EXT_REFERENCE);
if WAYPT_HAS(waypt, proximity)
gbfprintf(ofd, "%*s<gpxx:Proximity>%.6f</gpxx:Proximity>\n", space * 2, "", waypt->proximity);
if WAYPT_HAS(waypt, temperature)
gbfprintf(ofd, "%*s<gpxx:Temperature>%.6f</gpxx:Temperature>\n", space * 2, "", waypt->temperature);
if WAYPT_HAS(waypt, depth)
gbfprintf(ofd, "%*s<gpxx:Depth>%.6f</gpxx:Depth>\n", space * 2, "", waypt->depth);
if (gmsd->flags.display)
{
char *cx;
switch(gmsd->display)
{
case gt_display_mode_symbol:
cx = "SymbolOnly";
break;
case gt_display_mode_symbol_and_comment:
cx = "SymbolAndDescription";
break;
default:
cx = "SymbolAndName";
break;
}
gbfprintf(ofd, "%*s<gpxx:DisplayMode>%s</gpxx:DisplayMode>\n", space * 2, "", cx);
}
if (gmsd->flags.category && gmsd->category)
{
int i;
gbuint16 cx = gmsd->category;
gbfprintf(ofd, "%*s<gpxx:Categories>\n", space++ * 2, "");
for (i = 0; i < 16; i++)
{
if (cx & 1)
gbfprintf(ofd, "%*s<gpxx:Category>Category %d</gpxx:Category>\n", space*2, "", i+1);
cx = cx >> 1;
}
gbfprintf(ofd, "%*s</gpxx:Categories>\n", --space * 2, "");
}
static void
write_waypt(const waypoint *wpt)
{
unsigned char wpt_class;
garmin_fs_p gmsd;
char *wpt_type;
char *dspl_mode;
const char *country;
double x;
int i, icon, dynamic;
char *icon_descr;
gmsd = GMSD_FIND(wpt);
i = GMSD_GET(display, 0);
if (i > GT_DISPLAY_MODE_MAX) i = 0;
dspl_mode = gt_display_mode_names[i];
wpt_class = GMSD_GET(wpt_class, 0);
if (wpt_class <= gt_waypt_class_map_line)
wpt_type = gt_waypt_class_names[wpt_class];
else
wpt_type = gt_waypt_class_names[0];
gbfprintf(fout, "Waypoint\t%s\t", (wpt->shortname) ? wpt->shortname : "");
if (wpt_class <= gt_waypt_class_airport_ndb) {
char *temp = wpt->notes;
if (temp == NULL) {
if (wpt->description && (strcmp(wpt->description, wpt->shortname) != 0))
temp = wpt->description;
else
temp = "";
}
print_string("%s\t", temp);
}
else
gbfprintf(fout, "\t");
gbfprintf(fout, "%s\t", wpt_type);
print_position(wpt);
if IS_VALID_ALT(wpt->altitude)
print_distance(wpt->altitude, 1, 0, 0);
gbfprintf(fout, "\t");
x = WAYPT_GET(wpt, depth, unknown_alt);
if (x != unknown_alt)
print_distance(x, 1, 0, 1);
gbfprintf(fout, "\t");
x = WAYPT_GET(wpt, proximity, unknown_alt);
if (x != unknown_alt)
print_distance(x, 0, 0, 0);
gbfprintf(fout, "\t");
x = WAYPT_GET(wpt, temperature, -999);
if (x != -999)
print_temperature(x);
gbfprintf(fout, "\t%s\t", dspl_mode);
gbfprintf(fout, "Unknown\t"); /* Color is fixed: Unknown */
icon = GMSD_GET(icon, -1);
if (icon == -1) {
icon = gt_find_icon_number_from_desc(wpt->icon_descr, GDB);
}
icon_descr = gt_find_desc_from_icon_number(icon, GDB, &dynamic);
print_string("%s\t", icon_descr);
if (dynamic) xfree(icon_descr);
print_string("%s\t", GMSD_GET(facility, ""));
print_string("%s\t", GMSD_GET(city, ""));
print_string("%s\t", GMSD_GET(state, ""));
country = gt_get_icao_country(GMSD_GET(cc, ""));
print_string("%s\t", (country != NULL) ? country : "");
print_date_and_time(wpt->creation_time, 0);
print_string("%s\t", wpt->url ? wpt->url : "");
print_categories(GMSD_GET(category, 0));
gbfprintf(fout, "\r\n");
}
static void
unicsv_parse_one_line(char *ibuf)
{
char *s;
waypoint *wpt = NULL;
int column;
int utm_zone = -9999;
double utm_easting = 0;
double utm_northing = 0;
char utm_zc = 'N';
char bng_zone[3] = "";
double bng_easting = 0;
double bng_northing = 0;
double swiss_easting = unicsv_unknown;
double swiss_northing = unicsv_unknown;
int checked = 0;
time_t date = -1, time = -1;
int msec = -1;
char is_localtime = 0;
garmin_fs_t *gmsd;
double d;
struct tm ymd;
int src_datum = unicsv_datum_idx;
int ns = 1;
int ew = 1;
#ifdef UNICSV_GC_READY
geocache_data *gc_data = NULL;
#endif
wpt = waypt_new();
wpt->latitude = unicsv_unknown;
wpt->longitude = unicsv_unknown;
memset(&ymd, 0, sizeof(ymd));
column = -1;
while ((s = csv_lineparse(ibuf, unicsv_fieldsep, "\"", 0))) {
if (column > unicsv_fields_tab_ct) break; /* ignore extra fields on line */
ibuf = NULL;
column++;
checked++;
s = lrtrim(s);
if (! *s) continue; /* skip empty columns */
switch(unicsv_fields_tab[column]) {
case fld_time:
case fld_date:
case fld_datetime:
/* switch column type if it looks like an iso time string */
if (strchr(s, 'T'))
unicsv_fields_tab[column] = fld_iso_time;
break;
default: ;
}
switch(unicsv_fields_tab[column]) {
case fld_latitude:
human_to_dec( s, &wpt->latitude, &wpt->longitude, 1 );
wpt->latitude = wpt->latitude * ns;
break;
case fld_longitude:
human_to_dec( s, &wpt->latitude, &wpt->longitude, 2 );
wpt->longitude = wpt->longitude * ew;
break;
case fld_shortname:
wpt->shortname = xstrdup(s);
break;
case fld_description:
wpt->description = xstrdup(s);
break;
case fld_notes:
wpt->notes = xstrdup(s);
break;
case fld_url:
wpt->url = xstrdup(s);
break;
case fld_altitude:
if (parse_distance(s, &d, unicsv_altscale, MYNAME)) {
if (fabs(d) < fabs(unknown_alt))
wpt->altitude = d;
}
break;
case fld_utm_zone:
utm_zone = atoi(s);
break;
case fld_utm_easting:
utm_easting = atof(s);
break;
case fld_utm_northing:
utm_northing = atof(s);
break;
case fld_utm_zone_char:
utm_zc = toupper(s[0]);
break;
case fld_utm:
parse_coordinates(s, unicsv_datum_idx, grid_utm,
&wpt->latitude, &wpt->longitude, MYNAME);
/* coordinates from parse_coordinates are in WGS84
don't convert a second time */
src_datum = DATUM_WGS84;
break;
case fld_bng:
parse_coordinates(s, DATUM_OSGB36, grid_bng,
&wpt->latitude, &wpt->longitude, MYNAME);
/* coordinates from parse_coordinates are in WGS84
don't convert a second time */
src_datum = DATUM_WGS84;
break;
case fld_bng_zone:
strncpy(bng_zone, s, sizeof(bng_zone));
strupper(bng_zone);
break;
case fld_bng_northing:
bng_northing = atof(s);
break;
case fld_bng_easting:
bng_easting = atof(s);
break;
case fld_swiss:
parse_coordinates(s, DATUM_WGS84, grid_swiss,
&wpt->latitude, &wpt->longitude, MYNAME);
/* coordinates from parse_coordinates are in WGS84
don't convert a second time */
src_datum = DATUM_WGS84;
break;
case fld_swiss_easting:
swiss_easting = atof(s);
break;
case fld_swiss_northing:
swiss_northing = atof(s);
break;
case fld_hdop:
wpt->hdop = atof(s);
if (unicsv_detect) unicsv_data_type = trkdata;
break;
case fld_pdop:
wpt->pdop = atof(s);
if (unicsv_detect) unicsv_data_type = trkdata;
break;
case fld_vdop:
wpt->vdop = atof(s);
if (unicsv_detect) unicsv_data_type = trkdata;
break;
case fld_sat:
wpt->sat = atoi(s);
if (unicsv_detect) unicsv_data_type = trkdata;
break;
case fld_fix:
if (unicsv_detect) unicsv_data_type = trkdata;
if (case_ignore_strcmp(s, "none") == 0)
wpt->fix = fix_none;
else if (case_ignore_strcmp(s, "2d") == 0)
wpt->fix = fix_2d;
else if (case_ignore_strcmp(s, "3d") == 0)
wpt->fix = fix_3d;
else if (case_ignore_strcmp(s, "dgps") == 0)
wpt->fix = fix_dgps;
else if (case_ignore_strcmp(s, "pps") == 0)
wpt->fix = fix_pps;
else wpt->fix = fix_unknown;
break;
case fld_utc_date:
if ((is_localtime < 2) && (date < 0)) {
date = unicsv_parse_date(s, NULL);
is_localtime = 0;
}
break;
case fld_utc_time:
if ((is_localtime < 2) && (time < 0)) {
time = unicsv_parse_time(s, &msec, &date);
is_localtime = 0;
}
break;
case fld_speed:
if (parse_speed(s, &d, 1.0, MYNAME)) {
WAYPT_SET(wpt, speed, d);
if (unicsv_detect)
unicsv_data_type = trkdata;
}
break;
case fld_course:
WAYPT_SET(wpt, course, atof(s));
if (unicsv_detect) unicsv_data_type = trkdata;
break;
case fld_temperature:
d = atof(s);
if (fabs(d) < 999999) WAYPT_SET(wpt, temperature, d);
break;
case fld_temperature_f:
d = atof(s);
if (fabs(d) < 999999) WAYPT_SET(wpt, temperature, FAHRENHEIT_TO_CELSIUS(d));
break;
case fld_heartrate:
wpt->heartrate = atoi(s);
if (unicsv_detect) unicsv_data_type = trkdata;
break;
case fld_cadence:
wpt->cadence = atoi(s);
if (unicsv_detect) unicsv_data_type = trkdata;
break;
case fld_proximity:
if (parse_distance(s, &d, unicsv_proximityscale, MYNAME))
WAYPT_SET(wpt, proximity, d);
break;
case fld_depth:
if (parse_distance(s, &d, unicsv_depthscale, MYNAME))
WAYPT_SET(wpt, depth, d);
break;
case fld_symbol:
wpt->icon_descr = xstrdup(s);
wpt->wpt_flags.icon_descr_is_dynamic = 1;
break;
case fld_iso_time:
is_localtime = 2; /* fix result */
wpt->creation_time = xml_parse_time(s, &wpt->microseconds);
break;
case fld_time:
if ((is_localtime < 2) && (time < 0)) {
time = unicsv_parse_time(s, &msec, &date);
is_localtime = 1;
}
break;
case fld_date:
if ((is_localtime < 2) && (date < 0)) {
date = unicsv_parse_date(s, NULL);
is_localtime = 1;
}
break;
case fld_year:
ymd.tm_year = atoi(s);
break;
case fld_month:
ymd.tm_mon = atoi(s);
break;
case fld_day:
ymd.tm_mday = atoi(s);
break;
case fld_hour:
ymd.tm_hour = atoi(s);
break;
case fld_min:
ymd.tm_min = atoi(s);
break;
case fld_sec:
ymd.tm_sec = atoi(s);
break;
case fld_datetime:
if ((is_localtime < 2) && (date < 0) && (time < 0)) {
time = unicsv_parse_time(s, &msec, &date);
is_localtime = 1;
}
break;
case fld_ns:
ns = tolower(s[0]) == 'n' ? 1 : -1;
wpt->latitude *= ns;
break;
case fld_ew:
ew = tolower(s[0]) == 'e' ? 1 : -1;
wpt->longitude *= ew;
break;
case fld_garmin_city:
case fld_garmin_postal_code:
case fld_garmin_state:
case fld_garmin_country:
case fld_garmin_addr:
case fld_garmin_phone_nr:
case fld_garmin_phone_nr2:
case fld_garmin_fax_nr:
case fld_garmin_email:
case fld_garmin_facility:
gmsd = GMSD_FIND(wpt);
if (! gmsd) {
gmsd = garmin_fs_alloc(-1);
fs_chain_add(&wpt->fs, (format_specific_data *) gmsd);
}
switch(unicsv_fields_tab[column]) {
case fld_garmin_city: GMSD_SETSTR(city, s); break;
case fld_garmin_postal_code: GMSD_SETSTR(postal_code, s); break;
case fld_garmin_state: GMSD_SETSTR(state, s); break;
case fld_garmin_country: GMSD_SETSTR(country, s); break;
case fld_garmin_addr: GMSD_SETSTR(addr, s); break;
case fld_garmin_phone_nr: GMSD_SETSTR(phone_nr, s); break;
case fld_garmin_phone_nr2: GMSD_SETSTR(phone_nr2, s); break;
case fld_garmin_fax_nr: GMSD_SETSTR(fax_nr, s); break;
case fld_garmin_email: GMSD_SETSTR(email, s); break;
case fld_garmin_facility: GMSD_SETSTR(facility, s); break;
default: break;
}
break;
#ifdef UNICSV_GC_READY
case fld_gc_id:
case fld_gc_type:
case fld_gc_container:
case fld_gc_terr:
case fld_gc_diff:
case fld_gc_is_archived:
case fld_gc_is_available:
case fld_gc_exported:
case fld_gc_last_found:
case fld_gc_placer:
case fld_gc_placer_id:
case fld_gc_hint:
gc_data = waypt_alloc_gc_data(wpt);
switch(unicsv_fields_tab[column]) {
case fld_gc_id:
gc_data->id = atoi(s);
if (gc_data->id == 0) gc_data->id = unicsv_parse_gc_id(s);
break;
case fld_gc_type: gc_data->type = gs_mktype(s); break;
case fld_gc_container: gc_data->container = gs_mkcont(s); break;
case fld_gc_terr: gc_data->terr = atof(s) * 10; break;
case fld_gc_diff: gc_data->diff = atof(s) * 10; break;
case fld_gc_is_archived: gc_data->is_archived = unicsv_parse_status(s); break;
case fld_gc_is_available: gc_data->is_available = unicsv_parse_status(s); break;
case fld_gc_exported: {
time_t time, date; int msec;
time = unicsv_parse_time(s, &msec, &date);
if (date || time) gc_data->exported = unicsv_adjust_time(time, &date);
}
break;
case fld_gc_last_found: {
time_t time, date;
int msec;
time = unicsv_parse_time(s, &msec, &date);
if (date || time) gc_data->last_found = unicsv_adjust_time(time, &date);
}
break;
case fld_gc_placer: gc_data->placer = xstrdup(s); break;
case fld_gc_placer_id: gc_data->placer_id = atoi(s); break;
case fld_gc_hint: gc_data->hint = xstrdup(s); break;
default: break;
}
break;
#endif
case fld_terminator: /* dummy */
checked--;
break;
}
}
if (checked == 0) {
waypt_free(wpt);
return;
}
if (is_localtime < 2) { /* not fixed */
if ((time >= 0) && (date >= 0)) {
time_t t = date + time;
if (is_localtime) {
struct tm tm;
tm = *gmtime(&t);
if (opt_utc)
wpt->creation_time = mkgmtime(&tm);
else
wpt->creation_time = mklocaltime(&tm);
}
else
wpt->creation_time = t;
}
else if (time >= 0)
wpt->creation_time = time;
else if (date >= 0)
wpt->creation_time = date;
else if (ymd.tm_year || ymd.tm_mon || ymd.tm_mday) {
if (ymd.tm_year < 100) {
if (ymd.tm_year <= 70) ymd.tm_year += 2000;
else ymd.tm_year += 1900;
}
ymd.tm_year -= 1900;
if (ymd.tm_mon == 0) ymd.tm_mon = 1;
if (ymd.tm_mday == 0) ymd.tm_mday = 1;
ymd.tm_mon--;
if (opt_utc)
wpt->creation_time = mkgmtime(&ymd);
else
wpt->creation_time = mklocaltime(&ymd);
}
else if (ymd.tm_hour || ymd.tm_min || ymd.tm_sec) {
if (opt_utc)
wpt->creation_time = mkgmtime(&ymd);
else
wpt->creation_time = mklocaltime(&ymd);
}
if (msec >= 0)
wpt->microseconds = msec;
if (opt_utc)
wpt->creation_time += atoi(opt_utc) * SECONDS_PER_HOUR;
}
/* utm/bng/swiss can be optional */
if ((wpt->latitude == unicsv_unknown) && (wpt->longitude == unicsv_unknown)) {
if (utm_zone != -9999) {
GPS_Math_UTM_EN_To_Known_Datum(&wpt->latitude, &wpt->longitude,
utm_easting, utm_northing, utm_zone, utm_zc, unicsv_datum_idx);
}
else if (bng_zone[0]) {
if (! GPS_Math_UKOSMap_To_WGS84_M(
bng_zone, bng_easting, bng_northing,
&wpt->latitude, &wpt->longitude))
fatal(MYNAME ": Unable to convert BNG coordinates (%s %.f %.f)!\n",
bng_zone, bng_easting, bng_northing);
src_datum = DATUM_WGS84; /* don't convert afterwards */
}
else if ((swiss_easting != unicsv_unknown) && (swiss_northing != unicsv_unknown)) {
GPS_Math_Swiss_EN_To_WGS84(swiss_easting, swiss_northing,
&wpt->latitude, &wpt->longitude);
src_datum = DATUM_WGS84; /* don't convert afterwards */
}
}
if ((src_datum != DATUM_WGS84) &&
(wpt->latitude != unicsv_unknown) && (wpt->longitude != unicsv_unknown)) {
double alt;
GPS_Math_Known_Datum_To_WGS84_M(wpt->latitude, wpt->longitude, (double) 0.0,
&wpt->latitude, &wpt->longitude, &alt, src_datum);
}
switch(unicsv_data_type) {
case rtedata:
if (! unicsv_route) {
unicsv_route = route_head_alloc();
route_add_head(unicsv_route);
}
route_add_wpt(unicsv_route, wpt);
break;
case trkdata:
if (! unicsv_track) {
unicsv_track = route_head_alloc();
track_add_head(unicsv_track);
}
track_add_wpt(unicsv_track, wpt);
break;
default:
waypt_add(wpt);
}
}
static void
unicsv_waypt_disp_cb(const waypoint *wpt)
{
double lat, lon, alt;
char *cout = NULL;
const char *shortname;
garmin_fs_t *gmsd;
#ifdef UNICSV_GC_READY
const geocache_data *gc_data = NULL;
#endif
unicsv_waypt_ct++;
shortname = (wpt->shortname) ? wpt->shortname : "";
gmsd = GMSD_FIND(wpt);
if (unicsv_datum_idx == DATUM_WGS84) {
lat = wpt->latitude;
lon = wpt->longitude;
alt = wpt->altitude;
}
else {
GPS_Math_WGS84_To_Known_Datum_M(wpt->latitude, wpt->longitude, 0.0,
&lat, &lon, &alt, unicsv_datum_idx);
}
gbfprintf(fout, "%d%s", unicsv_waypt_ct, unicsv_fieldsep);
switch(unicsv_grid_idx) {
case grid_lat_lon_ddd:
cout = pretty_deg_format(lat, lon, 'd', unicsv_fieldsep, 0);
gbfputs(cout, fout);
break;
case grid_lat_lon_dmm:
cout = pretty_deg_format(lat, lon, 'm', unicsv_fieldsep, 0);
gbfputs(cout, fout);
break;
case grid_lat_lon_dms: {
char *sep, *tmp;
cout = pretty_deg_format(lat, lon, 's', unicsv_fieldsep, 0);
sep = strchr(cout, ',');
*sep = '\0';
tmp = strenquote(cout, UNICSV_QUOT_CHAR);
gbfprintf(fout, "%s%s", tmp, unicsv_fieldsep);
xfree(tmp);
tmp = strenquote(sep+1, UNICSV_QUOT_CHAR);
gbfputs(tmp, fout);
xfree(tmp);
}
break;
case grid_bng: {
char map[3];
double north, east;
if (! GPS_Math_WGS84_To_UKOSMap_M(wpt->latitude, wpt->longitude, &east, &north, map))
unicsv_fatal_outside(wpt);
gbfprintf(fout, "%s%s%5.0f%s%5.0f",
map, unicsv_fieldsep,
east, unicsv_fieldsep,
north);
break;
}
case grid_utm: {
int zone;
char zonec;
double north, east;
if (! GPS_Math_Known_Datum_To_UTM_EN(lat, lon,
&east, &north, &zone, &zonec, unicsv_datum_idx))
unicsv_fatal_outside(wpt);
gbfprintf(fout, "%02d%s%c%s%.0f%s%.0f",
zone, unicsv_fieldsep,
zonec, unicsv_fieldsep,
east, unicsv_fieldsep,
north);
break;
}
case grid_swiss: {
double north, east;
if (! GPS_Math_WGS84_To_Swiss_EN(wpt->latitude, wpt->longitude, &east, &north))
unicsv_fatal_outside(wpt);
gbfprintf(fout, "%.f%s%.f",
east, unicsv_fieldsep, north);
break;
}
default:
gbfprintf(fout, "%.*f%s%.*f", llprec, lat, unicsv_fieldsep, llprec, lon);
break;
}
if (cout) xfree(cout);
if FIELD_USED(fld_shortname) unicsv_print_str(shortname);
if FIELD_USED(fld_altitude) {
if (wpt->altitude != unknown_alt)
gbfprintf(fout, "%s%.1f", unicsv_fieldsep, wpt->altitude);
else
gbfputs(unicsv_fieldsep, fout);
}
if FIELD_USED(fld_description) unicsv_print_str(wpt->description);
if FIELD_USED(fld_notes) unicsv_print_str(wpt->notes);
if FIELD_USED(fld_symbol)
unicsv_print_str((wpt->icon_descr != NULL) ? wpt->icon_descr : "Waypoint");
if FIELD_USED(fld_depth) {
if WAYPT_HAS(wpt, depth)
gbfprintf(fout, "%s%.3f", unicsv_fieldsep, wpt->depth);
else
gbfputs(unicsv_fieldsep, fout);
}
static void
unicsv_waypt_enum_cb(const waypoint *wpt)
{
const char *shortname;
garmin_fs_t *gmsd;
shortname = (wpt->shortname) ? wpt->shortname : "";
gmsd = GMSD_FIND(wpt);
if (*shortname) gb_setbit(&unicsv_outp_flags, fld_shortname);
if (wpt->altitude != unknown_alt) gb_setbit(&unicsv_outp_flags, fld_altitude);
if (wpt->icon_descr && *wpt->icon_descr) gb_setbit(&unicsv_outp_flags, fld_symbol);
if (wpt->description && *wpt->description && (strcmp(shortname, wpt->description) != 0))
gb_setbit(&unicsv_outp_flags, fld_description);
if (wpt->notes && *wpt->notes && (strcmp(shortname, wpt->notes) != 0)) {
if ((! wpt->description) || (strcmp(wpt->description, wpt->notes) != 0))
gb_setbit(&unicsv_outp_flags, fld_notes);
}
if (wpt->url && *wpt->url) gb_setbit(&unicsv_outp_flags, fld_url);
if (wpt->creation_time != 0) {
gb_setbit(&unicsv_outp_flags, fld_time);
if (wpt->creation_time >= SECONDS_PER_DAY)
gb_setbit(&unicsv_outp_flags, fld_date);
}
if (wpt->fix != fix_unknown) gb_setbit(&unicsv_outp_flags, fld_fix);
if (wpt->vdop > 0) gb_setbit(&unicsv_outp_flags, fld_vdop);
if (wpt->hdop > 0) gb_setbit(&unicsv_outp_flags, fld_hdop);
if (wpt->pdop > 0) gb_setbit(&unicsv_outp_flags, fld_pdop);
if (wpt->sat > 0) gb_setbit(&unicsv_outp_flags, fld_sat);
if (wpt->heartrate != 0) gb_setbit(&unicsv_outp_flags, fld_heartrate);
if (wpt->cadence != 0) gb_setbit(&unicsv_outp_flags, fld_cadence);
/* "flagged" waypoint members */
if WAYPT_HAS(wpt, course) gb_setbit(&unicsv_outp_flags, fld_course);
if WAYPT_HAS(wpt, depth) gb_setbit(&unicsv_outp_flags, fld_depth);
if WAYPT_HAS(wpt, speed) gb_setbit(&unicsv_outp_flags, fld_speed);
if WAYPT_HAS(wpt, proximity) gb_setbit(&unicsv_outp_flags, fld_proximity);
if WAYPT_HAS(wpt, temperature) gb_setbit(&unicsv_outp_flags, fld_temperature);
if (gmsd) {
if GMSD_HAS(addr) gb_setbit(&unicsv_outp_flags, fld_garmin_addr);
if GMSD_HAS(city) gb_setbit(&unicsv_outp_flags, fld_garmin_city);
if GMSD_HAS(country) gb_setbit(&unicsv_outp_flags, fld_garmin_country);
if GMSD_HAS(phone_nr) gb_setbit(&unicsv_outp_flags, fld_garmin_phone_nr);
if GMSD_HAS(phone_nr2) gb_setbit(&unicsv_outp_flags, fld_garmin_phone_nr2);
if GMSD_HAS(fax_nr) gb_setbit(&unicsv_outp_flags, fld_garmin_fax_nr);
if GMSD_HAS(email) gb_setbit(&unicsv_outp_flags, fld_garmin_email);
if GMSD_HAS(postal_code) gb_setbit(&unicsv_outp_flags, fld_garmin_postal_code);
if GMSD_HAS(state) gb_setbit(&unicsv_outp_flags, fld_garmin_state);
if GMSD_HAS(facility) gb_setbit(&unicsv_outp_flags, fld_garmin_facility);
}
#ifdef UNICSV_GC_READY
if (! waypt_empty_gc_data(wpt)) {
const geocache_data *gc_data = wpt->gc_data;
if (gc_data->id) gb_setbit(&unicsv_outp_flags, fld_gc_id);
if (gc_data->type) gb_setbit(&unicsv_outp_flags, fld_gc_type);
if (gc_data->container) gb_setbit(&unicsv_outp_flags, fld_gc_container);
if (gc_data->terr) gb_setbit(&unicsv_outp_flags, fld_gc_terr);
if (gc_data->diff) gb_setbit(&unicsv_outp_flags, fld_gc_diff);
if (gc_data->is_archived) gb_setbit(&unicsv_outp_flags, fld_gc_is_archived);
if (gc_data->is_available) gb_setbit(&unicsv_outp_flags, fld_gc_is_available);
if (gc_data->exported) gb_setbit(&unicsv_outp_flags, fld_gc_exported);
if (gc_data->last_found) gb_setbit(&unicsv_outp_flags, fld_gc_last_found);
if (gc_data->placer && *gc_data->placer) gb_setbit(&unicsv_outp_flags, fld_gc_placer);
if (gc_data->placer_id) gb_setbit(&unicsv_outp_flags, fld_gc_placer_id);
if (gc_data->hint && *gc_data->hint) gb_setbit(&unicsv_outp_flags, fld_gc_hint);
}
#endif
}
