FGFS-4.1/flightgear
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
0382bacdb4
flightgear/utils/xmlgrep/metadata.c

1075 lines
28 KiB
C
Raw Normal View History

first commit
2022-10-20 20:29:11 +08:00
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <xml.h>
#define TS (4*1024*1024)
#define PRINT(a) \
tag = (a); if (tag) { strncat(s, " <tag>", TS-strlen(s)); strncat(s, tag, TS-strlen(s)); strncat(s, "</tag>\n", TS-strlen(s)); }
static unsigned int tags_level = 0;
static unsigned int print_tags = 0;
char *
getCommandLineOption(int argc, char **argv, char const *option)
{
int slen = strlen(option);
char *rv = 0;
int i;
for (i=0; i<argc; i++)
{
if (strncmp(argv[i], option, slen) == 0)
{
rv = "";
i++;
if (i<argc) rv = argv[i];
}
}
return rv;
}
void
show_help()
{
printf("Usage: metdata [options]\n");
printf("Updates the metadata of a FlightGear aircraft configuration.\n");
printf("\nOptions:\n");
printf(" -i, --input <file>\t\taircraft configuration file to update\n");
printf("\n");
exit(-1);
}
char *strlwr(char *str)
{
unsigned char *p = (unsigned char *)str;
while (*p) {
*p = tolower((unsigned char)*p);
p++;
}
return str;
}
void print_xml(FILE *fd, void *id, char *tags)
{
static int level = 1;
void *xid = xmlMarkId(id);
unsigned int num;
num = xmlNodeGetNum(xid, "*");
if (num == 0)
{
char *s;
s = xmlGetString(xid);
if (s)
{
fprintf(fd, "%s", s);
free(s);
}
}
else
{
unsigned int i, q;
for (i=0; i<num; i++)
{
if (xmlNodeGetPos(id, xid, "*", i) != 0)
{
unsigned int anum, a;
char name[256];
xmlNodeCopyName(xid, (char *)&name, 256);
if (tags_level == 1 && !strcmp(name, "sim")) tags_level++;
fprintf(fd, "\n");
for(q=0; q<level; q++) fprintf(fd, " ");
fprintf(fd, "<%s", name);
anum = xmlAttributeGetNum(xid);
for (a=0; a<anum; a++)
{
char name[256], attrib[256];
if (xmlAttributeCopyName(xid, (char *)&name, 256, a) != 0)
{
xmlAttributeCopyString(xid, name, (char *)&attrib, 256);
fprintf(fd, " %s=\"%s\"", name, attrib);
}
}
fprintf(fd, ">");
level++;
print_xml(fd, xid, tags);
level--;
fprintf(fd, "</%s>", name);
if (tags_level == 2 && !strcmp(name, "aero")) {
fprintf(fd, "\n%s\n", tags);
}
}
else printf("error\n");
}
fprintf(fd, "\n");
for(q=1; q<level; q++) fprintf(fd, " ");
}
}
void
updateFile(char *fname, char *tags)
{
char bfname[4096];
FILE *fd = NULL;
void *rid;
snprintf(bfname, 4096, "%s.bak", fname);
rename(fname, bfname);
rid = xmlOpen(bfname);
if (rid)
{
fd = fopen(fname, "w");
if (!fd)
{
xmlClose(rid);
rid = NULL;
rename(bfname, fname);
}
}
if (rid)
{
unsigned int i, num;
void *xid;
fprintf(fd, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\n");
xid = xmlMarkId(rid);
num = xmlNodeGetNum(xid, "*");
for (i=0; i<num; i++)
{
if (xmlNodeGetPos(rid, xid, "*", i) != 0)
{
unsigned int anum, a;
char name[256];
xmlNodeCopyName(xid, (char *)&name, 256);
if (strcmp(name, "PropertyList")) break;
tags_level++;
fprintf(fd, "<%s", name);
anum = xmlAttributeGetNum(xid);
for (a=0; a<anum; a++)
{
char name[256], attrib[256];
if (xmlAttributeCopyName(xid, (char *)&name, 256, a) != 0)
{
xmlAttributeCopyString(xid, name, (char *)&attrib, 256);
fprintf(fd, " %s=\"%s\"", name, attrib);
}
}
fprintf(fd, ">");
print_xml(fd, xid, tags);
fprintf(fd, "\n</%s>\n", name);
}
}
free(xid);
xmlClose(rid);
fclose(fd);
}
}
const char*
vendor_tag(char *desc)
{
char *p = strlwr(desc);
if (strstr(p, "boeing")) return "boeing";
if (strstr(p, "airbus")) return "airbus";
if (strstr(p, "antonov")) return "antonov";
if (strstr(p, "tupolev")) return "tupolev";
if (strstr(p, "ilyoushin")) return "ilyoushin";
if (strstr(p, "bombardier")) return "bombardier";
if (strstr(p, "fokker")) return "fokker";
if (strstr(p, "lockheed")) return "lockheed";
if (strstr(p, "general-dynamics")) return "general-dynamics";
if (strstr(p, "general dynamics")) return "general-dynamics";
if (strstr(p, "mig")) return "mikoyan-gurevich";
if (strstr(p, "mikoyan gurevich")) return "mikoyan-gurevich";
if (strstr(p, "mikoyan-gurevich")) return "mikoyan-gurevich";
if (strstr(p, "sukoi")) return "sukoi";
if (strstr(p, "cessna")) return "cessna";
if (strstr(p, "fairchild")) return "fairchild";
if (strstr(p, "dassult")) return "dassult";
if (strstr(p, "dornier")) return "dornier";
if (strstr(p, "arado")) return "arado";
if (strstr(p, "schleicher")) return "schleicher";
if (strstr(p, "avro")) return "avro";
if (strstr(p, "saab")) return "saab";
if (strstr(p, "dassault")) return "dassault";
if (strstr(p, "aermacchi")) return "aermacchi";
if (strstr(p, "arsenal")) return "arsenal";
if (strstr(p, "rockwell")) return "rockwell";
if (strstr(p, "northrop")) return "northrop";
if (strstr(p, "grumman")) return "grumman";
if (strstr(p, "mc donnell") && strstr(p, "douglas")) return "mc-donnell-douglas";
if (strstr(p, "douglas")) return "douglas";
if (strstr(p, "mc donnell")) return "mc-donnell";
if (strstr(p, "mc-donnell")) return "mc-donnell";
// if (strstr(p, "jaguar")) return "jaguar";
if (strstr(p, "junkers")) return "junkers";
if (strstr(p, "kawasaki")) return "kawasaki";
if (strstr(p, "de havilland")) return "de-havilland";
if (strstr(p, "de-havilland")) return "de-havilland";
if (strstr(p, "diamond")) return "diamond";
if (strstr(p, "bell")) return "bell";
if (strstr(p, "hughes")) return "hughes";
if (strstr(p, "kamov")) return "kamov";
if (strstr(p, "mil")) return "mil";
if (strstr(p, "eurocopter")) return "eurocopter";
if (strstr(p, "alouette")) return "alouette";
if (strstr(p, "aerospatiale")) return "aerospatiale";
if (strstr(p, "sikorsky")) return "sikorsky";
if (strstr(p, "bernard")) return "bernard";
if (strstr(p, "bleriot")) return "bleriot";
if (strstr(p, "bristol")) return "bristol";
if (strstr(p, "breguet")) return "breguet";
if (strstr(p, "wright")) return "wright";
if (strstr(p, "breda")) return "breda";
if (strstr(p, "rutan")) return "rutan";
if (strstr(p, "vought")) return "vought";
if (strstr(p, "fiat")) return "fiat";
if (strstr(p, "focke wulf")) return "focke-wulf";
if (strstr(p, "focke-wulf")) return "focke-wulf";
if (strstr(p, "gloster")) return "gloster";
if (strstr(p, "hawker")) return "hawker";
if (strstr(p, "heinkel")) return "heinkel";
if (strstr(p, "messerschmitt")) return "messerschmitt";
if (strstr(p, "north american")) return "north-american";
if (strstr(p, "north-american")) return "north-american";
if (strstr(p, "piaggio")) return "piaggio";
if (strstr(p, "pilatus")) return "pilatus";
if (strstr(p, "supermarine")) return "supermarine";
if (strstr(p, "beechcraft")) return "beechcraft";
if (strstr(p, "beech")) return "beechcraft";
if (strstr(p, "vickers")) return "vickers";
if (strstr(p, "westland")) return "westland";
if (strstr(p, "yakovlev")) return "yakovlev";
if (strstr(p, "schweizer")) return "schweizer";
/* educated guess */
if (strstr(p, "b7")) return "boeing";
if (strstr(p, "airbus")) return "airbus";
if (strstr(p, "an-")) return "antonov";
if (strstr(p, "tu-")) return "tupolev";
if (strstr(p, "il-")) return "ilyoushin";
if (strstr(p, "su-")) return "sukoi";
if (strstr(p, "dc-")) return "douglas";
if (strstr(p, "md-")) return "mc-donnell-douglas";
if (strstr(p, "ju-")) return "junkers";
if (strstr(p, "ec-")) return "eurocopter";
if (strstr(p, "he-")) return "heinkel";
if (strstr(p, "as-")) return "aerospatiale";
if (strstr(p, "me-")) return "messerschmitt";
if (strstr(p, "fw-")) return "focke-wulf";
if (strstr(p, "yak-")) return "yakovlev";
if (strstr(p, "sgs-")) return "schweizer";
if (strstr(p, "ask-")) return "schleicher";
if (strstr(p, "mirage")) return "dassault";
return NULL;
}
/* -- JSBSim ---------------------------------------------------------------- */
const char*
jsb_wing_tag(void *xid, void *path)
{
void *xlid, *xmid, *xeid;
double aero_z = 0.0;
double eye_z = 0.0;
int i, num;
xeid = xmlNodeGet(xid, "/fdm_config/propulsion/engine/thruster");
if (xeid)
{
char *rv = NULL;
char *file = xmlAttributeGetString(xeid, "file");
char *fname = calloc(1, strlen(path)+strlen("Engines/")+
strlen(file)+strlen(".xml")+1);
if (fname)
{
void *xfid;
memcpy(fname, path, strlen(path));
memcpy(fname+strlen(path), "Engines/", strlen("Engines/"));
memcpy(fname+strlen(path)+strlen("Engines/"), file, strlen(file));
memcpy(fname+strlen(path)+strlen("Engines/")+strlen(file), ".xml", strlen(".xml"));
xfid = xmlOpen(fname);
if (xfid)
{
if (xmlNodeTest(xfid, "rotor")) rv = "helicopter";
xmlClose(xfid);
}
free(fname);
}
xmlFree(file);
xmlFree(xeid);
if (rv) return rv;
}
xmid = xmlNodeGet(xid, "/fdm_config/metrics");
if (!xmid) return NULL;
xlid = xmlMarkId(xmid);
num = xmlNodeGetNum(xmid, "location");
for (i=0; i<num; ++i)
{
if (xmlNodeGetPos(xmid, xlid, "location", i) != 0)
{
if (!xmlAttributeCompareString(xlid, "name", "AERORP")) {
aero_z = xmlNodeGetDouble(xlid, "z");
} else if (!xmlAttributeCompareString(xlid, "name", "EYEPOINT")) {
eye_z = xmlNodeGetDouble(xlid, "z");
}
}
}
xmlFree(xlid);
xmlFree(xmid);
if (aero_z > eye_z) return "high-wing";
else return "low-wing";
}
const char*
jsb_gear_tag(void *xid)
{
void *xcid, *xgid = xmlNodeGet(xid, "/fdm_config/ground_reactions");
double nose_x = 0.0;
double main_x = 0.0;
int bogeys = 0;
int i, num;
if (!xgid) return NULL;
xcid = xmlMarkId(xgid);
num = xmlNodeGetNum(xgid, "contact");
for (i=0; i<num; ++i)
{
if (xmlNodeGetPos(xgid, xcid, "contact", i) != 0)
{
if (!xmlAttributeCompareString(xcid, "type", "BOGEY"))
{
if (xmlNodeGetDouble(xcid, "location/y") == 0.0) {
nose_x = xmlNodeGetDouble(xcid, "location/x");
} else {
main_x = xmlNodeGetDouble(xcid, "location/x");
}
bogeys++;
}
}
}
xmlFree(xcid);
xmlFree(xgid);
if (bogeys == 0) return "skids";
else if (bogeys < 3 || main_x < nose_x) return "tail-dragger";
return "tricycle";
}
const char*
jsb_gear_retract_tag(void *xid)
{
int r = xmlNodeGetInt(xid, "/fdm_config/ground_reactions/contact/retractable");
if (r) return "retractable-gear";
else return "fixed-gear";
}
const char*
jsb_gear_steering_tag(void *xid)
{
void *xcid, *xgid = xmlNodeGet(xid, "/fdm_config/ground_reactions");
char *rv = NULL;
int found = 0;
int i, num;
if (!xgid) return NULL;
xcid = xmlMarkId(xgid);
num = xmlNodeGetNum(xgid, "contact");
for (i=0; i<num; ++i)
{
if (xmlNodeGetPos(xgid, xcid, "contact", i) != 0)
{
if (!xmlAttributeCompareString(xcid, "type", "BOGEY"))
{
if (xmlNodeGetDouble(xcid, "location/y") == 0.0)
{
double m = xmlNodeGetDouble(xcid, "max_steer");
int c = xmlNodeGetInt(xcid, "castered");
if (c || (m == 360.0 && !c)) {
rv = "castering";
break;
} else if (m > 0.0) {
// rv = "normal-steering";
break;
}
else {
// rv = "no-steering";
}
}
}
}
}
xmlFree(xcid);
xmlFree(xgid);
return rv;
}
const char*
jsb_engines_tag(void *xid)
{
void *xeid, *xpid = xmlNodeGet(xid, "/fdm_config/propulsion");
const char* rv = NULL;
int engines = 0;
int i, num;
char *main;
if (!xpid) return rv;
xeid = xmlMarkId(xpid);
num = xmlNodeGetNum(xpid, "engine");
for (i=0; i<num; ++i)
{
if (xmlNodeGetPos(xpid, xeid, "engine", i) != 0)
{
if (i == 0)
{
main = xmlAttributeGetString(xeid, "file");
engines++;
}
else if (!xmlAttributeCompareString(xeid, "file", main)) {
engines++;
}
}
}
xmlFree(main);
xmlFree(xeid);
xmlFree(xpid);
switch (engines)
{
case 0:
rv = "glider";
break;
case 1:
rv = "single-engine";
break;
case 2:
rv = "twin-engine";
break;
case 3:
rv = "three-engine";
break;
case 4:
rv = "four-engine";
break;
default:
break;
}
return rv;
}
const char*
jsb_engine_tag(void *xid, char *path)
{
void *xeid = xmlNodeGet(xid, "/fdm_config/propulsion/engine");
char *engine, *fname;
const char *rv = NULL;
if (!xeid) return rv;
engine = xmlAttributeGetString(xeid, "file");
fname = calloc(1, strlen(path)+strlen("Engines/")+
strlen(engine)+strlen(".xml")+1);
if (fname)
{
void *xfid;
memcpy(fname, path, strlen(path));
memcpy(fname+strlen(path), "Engines/", strlen("Engines/"));
memcpy(fname+strlen(path)+strlen("Engines/"), engine, strlen(engine));
memcpy(fname+strlen(path)+strlen("Engines/")+strlen(engine), ".xml", strlen(".xml"));
xfid = xmlOpen(fname);
if (xfid)
{
if (xmlNodeTest(xfid, "turbine_engine")) rv = "jet";
else if (xmlNodeTest(xfid, "turboprop_engine")) rv = "turboprop";
else if (xmlNodeTest(xfid, "piston_engine")) rv = "piston";
else if (xmlNodeTest(xfid, "electric_engine")) rv = "electric";
else if (xmlNodeTest(xfid, "rocket_engine")) rv = "rocket";
xmlClose(xfid);
}
else {
printf("JSBSim engine file not found: %s\n", fname);
}
free(fname);
}
else {
printf("Unable to allocate memory\n");
}
xmlFree(engine);
xmlFree(xeid);
return rv;
}
const char*
jsb_propulsion_tag(void *xid, char *path)
{
void *xeid = xmlNodeGet(xid, "fdm_config/propulsion/engine");
char *file, *fname;
const char *rv = NULL;
if (!xeid) return rv;
file = xmlAttributeGetString(xeid, "file");
fname = calloc(1, strlen(path)+strlen("Engines/")+
strlen(file)+strlen(".xml")+1);
if (fname)
{
void *xfid;
memcpy(fname, path, strlen(path));
memcpy(fname+strlen(path), "Engines/", strlen("Engines/"));
memcpy(fname+strlen(path)+strlen("Engines/"), file, strlen(file));
memcpy(fname+strlen(path)+strlen("Engines/")+strlen(file), ".xml", strlen(".xml"));
xfid = xmlOpen(fname);
if (xfid)
{
if (xmlNodeGetInt(xfid, "turbine_engine/augmented")) {
rv = "afterburner";
}
else if (xmlNodeGetInt(xfid, "piston_engine/numboostspeeds")) {
rv = "supercharged";
}
xmlClose(xfid);
}
else {
printf("JSBSim engine file not found: %s\n", fname);
}
free(fname);
}
xmlFree(xeid);
xmlFree(file);
return rv;
}
const char*
jsb_thruster_tag(void *xid, char *path)
{
void *xeid = xmlNodeGet(xid, "/fdm_config/propulsion/engine/thruster");
char *file, *fname;
const char *rv = NULL;
if (!xeid) return rv;
file = xmlAttributeGetString(xeid, "file");
fname = calloc(1, strlen(path)+strlen("Engines/")+
strlen(file)+strlen(".xml")+1);
if (fname)
{
void *xfid;
memcpy(fname, path, strlen(path));
memcpy(fname+strlen(path), "Engines/", strlen("Engines/"));
memcpy(fname+strlen(path)+strlen("Engines/"), file, strlen(file));
memcpy(fname+strlen(path)+strlen("Engines/")+strlen(file), ".xml", strlen(".xml"));
xfid = xmlOpen(fname);
if (xfid)
{
if (xmlNodeTest(xfid, "propeller"))
{
double min = xmlNodeGetDouble(xfid, "propeller/minpitch");
double max = xmlNodeGetDouble(xfid, "propeller/maxpitch");
if (min == max) rv = "fixed-pitch";
else rv = "variable-pitch";
}
xmlClose(xfid);
}
else {
printf("JSBSim thruster file not found: %s\n", fname);
}
free(fname);
}
else {
printf("Unable to allocate memory\n");
}
xmlFree(file);
xmlFree(xeid);
return rv;
}
void
update_metadata_jsb(char *sfname, char *path, char *aero, char *desc)
{
const char *tag;
char *s, *fname;
void *xid;
fname = calloc(1, strlen(path)+strlen(aero)+strlen(".xml")+1);
if (!fname)
{
printf("Unable to allocate memory\n");
return;
}
memcpy(fname, path, strlen(path));
memcpy(fname+strlen(path), aero, strlen(aero));
memcpy(fname+strlen(path)+strlen(aero), ".xml", strlen(".xml"));
xid = xmlOpen(fname);
if (!xid)
{
printf("JSBSim aero file not found: '%s'\n", fname);
return;
}
s = malloc(65*1024);
if (s)
{
sprintf(s, " <tags>\n");
PRINT("auto-generated");
PRINT(vendor_tag(desc ? desc : aero));
PRINT(strlwr(desc ? desc : aero));
PRINT(jsb_wing_tag(xid, path));
PRINT(jsb_gear_tag(xid));
PRINT(jsb_gear_retract_tag(xid));
PRINT(jsb_gear_steering_tag(xid));
PRINT(jsb_engines_tag(xid));
PRINT(jsb_engine_tag(xid, path));
PRINT(jsb_propulsion_tag(xid, path));
PRINT(jsb_thruster_tag(xid, path));
s = strncat(s, " </tags>", TS-strlen(s));
if (print_tags) {
printf( "%s\n", s);
} else {
updateFile(sfname, s);
}
free(s);
}
xmlClose(xid);
free(fname);
}
/* -- Yasim ----------------------------------------------------------------- */
const char*
yasim_wing_tag(void *xid)
{
void *xaid = xmlNodeGet(xid, "/airplane");
void *xwid, *xcid;
int n_wings;
double wing_z = 0.0;
double eye_z = 0.0;
if (xmlNodeTest(xaid, "rotor")) {
return "helicopter";
}
xwid = xmlNodeGet(xaid, "wing");
if (xwid)
{
wing_z = xmlAttributeGetDouble(xwid, "z");
xmlFree(xwid);
}
xcid = xmlNodeGet(xaid, "cockpit");
if (xcid)
{
eye_z = xmlAttributeGetDouble(xcid, "z");
xmlFree(xcid);
}
n_wings = xmlNodeGetNum(xaid, "mstab");
xmlFree(xaid);
// if (n_wings == 2) return "triplane";
// if (n_wings == 1) return "biplane";
if (wing_z > eye_z) return "high-wing";
return "low-wing";
}
const char*
yasim_gear_tag(void *xid)
{
void *xaid = xmlNodeGet(xid, "/airplane");
void *xgid = xmlMarkId(xaid);
double nose_x = 0.0;
double main_x = 0.0;
int gears = 0;
int i, num;
num = xmlNodeGetNum(xaid, "gear");
for (i=0; i<num; ++i)
{
if (xmlNodeGetPos(xaid, xgid, "gear", i) != 0)
{
if (xmlAttributeGetDouble(xgid, "y") == 0.0) {
nose_x = xmlAttributeGetDouble(xgid, "x");
} else {
main_x = xmlAttributeGetDouble(xgid, "x");
}
gears++;
}
}
xmlFree(xgid);
xmlFree(xaid);
if (gears == 0) return "skids";
else if (gears < 3 || main_x > nose_x) return "tail-dragger";
return "tricycle";
}
const char*
yasim_gear_retract_tag(void *xid)
{
void *xaid = xmlNodeGet(xid, "/airplane");
void *xgid = xmlMarkId(xaid);
char *rv = "fixed-gear";
int found = 0;
int i, num;
num = xmlNodeGetNum(xaid, "gear");
for (i=0; i<num; ++i)
{
if (xmlNodeGetPos(xaid, xgid, "gear", i) != 0)
{
void *xgcid = xmlMarkId(xgid);
int j, cnum = xmlNodeGetNum(xgid, "control-input");
for (j=0; j<cnum; ++j)
{
if (xmlNodeGetPos(xgid, xgcid, "control-input", j))
{
if (!xmlAttributeCompareString(xgcid, "control", "EXTEND")) {
rv = "retractable-gear";
found = 1;
break;
}
}
}
xmlFree(xgcid);
}
}
xmlFree(xgid);
xmlFree(xaid);
return rv;
}
const char*
yasim_gear_steering_tag(void *xid)
{
void *xaid = xmlNodeGet(xid, "/airplane");
void *xgid = xmlMarkId(xaid);
char *rv = NULL;
int found = 0;
int i, num;
num = xmlNodeGetNum(xaid, "gear");
for (i=0; i<num; ++i)
{
if (xmlNodeGetPos(xaid, xgid, "gear", i) != 0)
{
void *xgcid = xmlMarkId(xgid);
int j, cnum = xmlNodeGetNum(xgid, "control-input");
for (j=0; j<cnum; ++j)
{
if (xmlNodeGetPos(xgid, xgcid, "control-input", j))
{
if (!xmlAttributeCompareString(xgcid, "control", "STEER")) {
// rv = "normal-steering";
found = 1;
break;
}
else if (!xmlAttributeCompareString(xgcid, "control", "CASTERING")) {
rv = "castering";
found = 1;
break;
}
}
}
xmlFree(xgcid);
}
}
xmlFree(xgid);
xmlFree(xaid);
return rv;
}
const char*
yasim_engines_tag(void *xid)
{
void *xeid = xmlNodeGet(xid, "/airplane");
const char* rv = "multi-engine";
int engines = 0;
if (xmlNodeTest(xeid, "propeller")) {
engines = xmlNodeGetNum(xeid, "propeller");
}
else if (xmlNodeTest(xeid, "jet")) {
engines = xmlNodeGetNum(xeid, "jet");
}
else if (xmlNodeTest(xeid, "rotor")) {
engines = 1;
}
switch (engines)
{
case 0:
rv = "glider";
break;
case 1:
rv = "single-engine";
break;
case 2:
rv = "twin-engine";
break;
case 3:
rv = "three-engine";
break;
case 4:
rv = "four-engine";
break;
default:
break;
}
xmlFree(xeid);
return rv;
}
const char*
yasim_engine_tag(void *xid, char *path)
{
const char* rv = NULL;
if (xmlNodeTest(xid, "/airplane/propeller/piston-engine")) {
rv = "piston";
}
else if (xmlNodeTest(xid, "/airplane/propeller/turbine-engine")) {
rv = "turboprop";
}
else if (xmlNodeTest(xid, "/airplane/jet")) {
rv = "jet";
}
return rv;
}
const char*
yasim_propulsion_tag(void *xid, char *path)
{
const char* rv = NULL;
void *xpid;
if ((xpid = xmlNodeGet(xid, "/airplane/jet")) != NULL)
{
if (xmlAttributeGetDouble(xpid, "afterburner") > 0.0) {
rv = "afterburner";
}
xmlFree(xpid);
}
else if ((xpid = xmlNodeGet(xid, "/airplane/propeller/piston-engine")) != NULL)
{
if (xmlAttributeGetInt(xpid, "supercharger") > 0) {
rv = "supercharger";
}
xmlFree(xpid);
}
return rv;
}
const char*
yasim_thruster_tag(void *xid, char *path)
{
const char* rv = NULL;
void *xtid;
xtid = xmlNodeGet(xid, "/airplane/propeller/control-input");
if (xtid)
{
if (!xmlAttributeCompareString(xtid, "control", "ADVANCE")) {
rv = "variable-pitch";
} else rv = "fixed-pitch";
xmlFree(xtid);
}
return rv;
}
void
update_metadata_yasim(char *sfname, char *path, char *aero, char *desc)
{
const char *tag;
char *s, *fname;
void *xid;
fname = calloc(1, strlen(path)+strlen(aero)+strlen(".xml")+1);
if (!fname)
{
printf("Unable to allocate memory\n");
return;
}
memcpy(fname, path, strlen(path));
memcpy(fname+strlen(path), aero, strlen(aero));
memcpy(fname+strlen(path)+strlen(aero), ".xml", strlen(".xml"));
xid = xmlOpen(fname);
if (!xid)
{
printf("Yasim aero file not found: '%s'\n", fname);
return;
}
s = malloc(65*1024);
if (s)
{
sprintf(s, " <tags>\n");
PRINT("auto-generated");
PRINT(vendor_tag(desc ? desc : aero));
PRINT(strlwr(desc ? desc : aero));
PRINT(yasim_wing_tag(xid));
PRINT(yasim_gear_tag(xid));
PRINT(yasim_gear_retract_tag(xid));
PRINT(yasim_gear_steering_tag(xid));
PRINT(yasim_engines_tag(xid));
PRINT(yasim_engine_tag(xid, path));
PRINT(yasim_propulsion_tag(xid, path));
PRINT(yasim_thruster_tag(xid, path));
s = strncat(s, " </tags>", TS-strlen(s));
if (print_tags) {
printf( "%s\n", s);
} else {
updateFile(sfname, s);
}
free(s);
}
xmlClose(xid);
free(fname);
}
/* -------------------------------------------------------------------------- */
void
update_metadata(const char *fname)
{
void *xsid, *xid = xmlOpen(fname);
if (!xid)
{
printf("File not found: '%s'\n", fname);
return;
}
xsid = xmlNodeGet(xid, "/PropertyList/sim");
if (!xsid)
{
printf("path '/PropertyList/sim' not found in '%s'\n", fname);
xmlClose(xid);
return;
}
if (xmlNodeTest(xsid, "tags") == 0)
{
char *desc = NULL, *str = NULL;
char *path, *pend;
pend = strrchr(fname, '/');
if (!pend) pend = strrchr(fname, '\\');
if (!pend) path = strdup("./");
else
{
pend++;
path = calloc(1, pend-fname+1);
memcpy(path, fname, pend-fname);
}
desc = xmlNodeGetString(xsid, "description");
str = xmlNodeGetString(xsid, "aero");
if (!xmlNodeCompareString(xsid, "flight-model", "jsb")) {
update_metadata_jsb(fname, path, str, desc);
}
else if (!xmlNodeCompareString(xsid, "flight-model", "yasim")) {
update_metadata_yasim(fname, path, str, desc);
}
else
{
str = xmlNodeGetString(xsid, "flight-model");
printf("The '%s' flightmodel is unsupported at this time\n", str);
}
xmlFree(xsid);
xmlFree(desc);
xmlFree(str);
free(path);
}
else {
printf("'%s' already contains metadata tags\n", fname);
}
xmlClose(xid);
}
int
main(int argc, char **argv)
{
const char *setFile;
if (argc == 1 || getCommandLineOption(argc, argv, "-h") ||
getCommandLineOption(argc, argv, "--help")) {
show_help();
}
if (getCommandLineOption(argc, argv, "-p") ||
getCommandLineOption(argc, argv, "--print")) {
print_tags = 1;
}
setFile = getCommandLineOption(argc, argv, "-i");
if (!setFile) {
setFile = getCommandLineOption(argc, argv, "-input");
}
if (!setFile) {
show_help();
}
printf("%s\n", setFile);
update_metadata(setFile);
printf("\n");
return 0;
}
Reference in New Issue Copy Permalink