240 lines
9.6 KiB
C
240 lines
9.6 KiB
C
/** @license 2023 Neil Edelman, distributed under the terms of the
|
|
[MIT License](https://opensource.org/licenses/MIT).
|
|
@std C11 */
|
|
#include "../src/flights.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
|
|
|
|
static void flight_to_string(const union line64 line, const struct flight *u,
|
|
char (*const a)[12]) { (void)u; date32_to_string(line.date, a); }
|
|
static int flight_compare(const union line64 a, const union line64 b)
|
|
{ return a.u64 > b.u64; }
|
|
#define TREE_NAME flight
|
|
#define TREE_KEY union line64
|
|
#define TREE_VALUE struct flight
|
|
#define TREE_COMPARE
|
|
#define TREE_TO_STRING
|
|
#define TREE_BODY
|
|
#include "../src/tree.h"
|
|
|
|
|
|
/*!conditions:re2c*/
|
|
|
|
static int scan(struct flight_tree *const f,
|
|
union date32 date, const char *const text) {
|
|
const char *YYCURSOR, *YYMARKER, *yyt1, *yyt2, *s0, *s1, *t0, *t1;
|
|
enum YYCONDTYPE condition = yycline;
|
|
size_t line = 1;
|
|
char datestr[12] = {0};
|
|
const char *why = "unexpected";
|
|
struct flight *flight = 0;
|
|
assert(f && text);
|
|
YYCURSOR = YYMARKER = yyt1 = text;
|
|
/*!re2c /**/
|
|
re2c:define:YYCTYPE = char;
|
|
re2c:yyfill:enable = 0;
|
|
re2c:define:YYGETCONDITION = "condition";
|
|
re2c:define:YYSETCONDITION = "condition = @@;";
|
|
re2c:define:YYGETCONDITION:naked = 1;
|
|
re2c:define:YYSETCONDITION:naked = 1;
|
|
|
|
ws = [ \t];
|
|
glyph = [^\x00-\x20\x7f]; // [^\x00\n\t ] + all weird
|
|
semitext = glyph \ ";";
|
|
natural = [1-9][0-9]*;
|
|
minutes = [0-5][0-9];
|
|
zero_natural = natural | "0";
|
|
airport = [A-Z0-9]{4,4};
|
|
*/
|
|
for( ; ; ) { /*!re2c /**/
|
|
/* Default ignore. */
|
|
<skip> [^\n\x00] { continue; }
|
|
<skip> "\x00" { why = "no newline at end of file"; goto catch; }
|
|
<line> "\x00" { return 1; }
|
|
<line, skip> "\n" => line { line++; continue; }
|
|
<line> * :=> skip
|
|
|
|
/* Except this . . . */
|
|
<line> "[glider]" :=> glider_type
|
|
/* type, reg, launch, how, height, landing, pilot, dual, instr, remarks
|
|
eg, [glider] 2-33A; C-GCLK; CYQQ; A; 2000'; CYQQ; ;:13;; Peters D1 */
|
|
<glider_type> * { why = "type unrecognized"; goto catch; }
|
|
<glider_reg> * { why = "reg unrecognized"; goto catch; }
|
|
<glider_launch> * { why = "launch unrecognized"; goto catch; }
|
|
<glider_how> * { why = "how unrecognized"; goto catch; }
|
|
<glider_height> * { why = "height unrecognized"; goto catch; }
|
|
<glider_landing> * { why = "landing unrecognized"; goto catch; }
|
|
<glider_pilot> * { why = "pilot unrecognized"; goto catch; }
|
|
<glider_dual> * { why = "dual unrecognized"; goto catch; }
|
|
<glider_instr> * { why = "instr unrecognized"; goto catch; }
|
|
<glider_remarks> * { why = "remarks unrecognized"; goto catch; }
|
|
<glider_type> ws* @s0 semitext+ @s1 ws* ";" => glider_reg {
|
|
const union line64 key
|
|
= {{ (uint32_t)line, {{ date.day, date.month, date.year }} }};
|
|
assert(!flight);
|
|
if(line > UINT32_MAX) { why = "line overflow"; goto catch; }
|
|
switch(flight_tree_assign(f, key, &flight)) { /* fixme */
|
|
case TREE_PRESENT: why = "duplicate key";
|
|
case TREE_ERROR: goto catch;
|
|
case TREE_ABSENT: flight->type = GLIDER; break;
|
|
}
|
|
flight->glider.type.a = s0, flight->glider.type.b = s1;
|
|
continue;
|
|
}
|
|
<glider_reg> ws* @s0 semitext+ @s1 ws* ";" => glider_launch
|
|
{ flight->glider.reg.a = s0, flight->glider.reg.b = s1; continue; }
|
|
<glider_launch> ws* @s0 airport @s1 ws* ";" => glider_how
|
|
{ flight->glider.launch.a = s0, flight->glider.launch.b = s1;
|
|
continue; }
|
|
<glider_how> ws* @s0 [MWA] ws* ";" => glider_height {
|
|
switch(*s0) {
|
|
case 'M': flight->glider.how = MotorCarTow; break;
|
|
case 'W': flight->glider.how = Winch; break;
|
|
case 'A': flight->glider.how = AeroTow; break;
|
|
default: assert(0); break;
|
|
}
|
|
continue;
|
|
}
|
|
<glider_height> ws* @s0 natural @s1 "'" ws* ";" => glider_landing
|
|
{ if(!pair_to_natural(s0, s1, &flight->glider.height_ft));
|
|
continue; }
|
|
<glider_landing> ws* @s0 airport @s1 ws* ";" => glider_pilot
|
|
{ flight->glider.landing.a = s0, flight->glider.landing.b = s1;
|
|
continue; }
|
|
<glider_pilot> ws* ";" => glider_dual /* not PIC */
|
|
{ flight->glider.pilot_min = 0; continue; }
|
|
<glider_pilot> ws* @s0 natural? @s1 ":" @t0 minutes @t1 ws* ";"
|
|
=> glider_dual { if(!pair_colon_to_minutes(s0, s1, t0, t1,
|
|
&flight->glider.pilot_min)) { why = "pilot time"; goto catch; }
|
|
continue; }
|
|
<glider_dual> ws* ";" => glider_instr
|
|
{ flight->glider.dual_min = 0; continue; }
|
|
<glider_dual> ws* @s0 natural? @s1 ":" @t0 minutes @t1 ws* ";"
|
|
=> glider_instr { if(!pair_colon_to_minutes(s0, s1, t0, t1,
|
|
&flight->glider.dual_min)) { why = "dual time"; goto catch; }
|
|
continue; }
|
|
<glider_instr> ws* ";" => glider_remarks
|
|
{ flight->glider.instr_min = 0; continue; }
|
|
<glider_instr> ws* @s0 natural? @s1 ":" @t0 minutes @t1 ws* ";"
|
|
=> glider_remarks { if(!pair_hours_to_minutes(s0, s1, t0, t1,
|
|
&flight->glider.instr_min)) { why = "instr time"; goto catch; }
|
|
continue; }
|
|
<glider_remarks> ws* "\n" => line
|
|
{ flight->glider.remarks.a = flight->glider.remarks.b = 0;
|
|
flight = 0; line++; continue; }
|
|
<glider_remarks> ws* @s0 glyph+ (ws+ glyph+)* @s1 "\n" => line
|
|
{ flight->glider.remarks.a = s0, flight->glider.remarks.b = s1;
|
|
flight = 0; line++; continue; }
|
|
|
|
/* And this . . . */
|
|
<line> "[flight]" :=> flight_type
|
|
/* type; registration; launch -- landing; pic; sic;
|
|
single engine day dual; pilot; instrument simulated; actual; remarks */
|
|
<flight_type> * { why = "type unrecognized"; goto catch; }
|
|
<flight_reg> * { why = "reg unrecognized"; goto catch; }
|
|
<flight_airports> * { why = "airports unrecognized"; goto catch; }
|
|
<flight_pic> * { why = "pic unrecognized"; goto catch; }
|
|
<flight_sic> * { why = "sic unrecognized"; goto catch; }
|
|
<flight_dual> * { why = "dual time unrecognized"; goto catch; }
|
|
<flight_pilot> * { why = "pilot time unrecognized"; goto catch; }
|
|
<flight_ifrsim> * { why = "simulated ifr time unrecognized";
|
|
goto catch; }
|
|
<flight_ifr> * { why = "ifr time unrecognized"; goto catch; }
|
|
<flight_remarks> * { why = "remarks unrecognized"; goto catch; }
|
|
<flight_type> ws* @s0 semitext+ @s1 ws* ";" => flight_reg {
|
|
const union line64 key
|
|
= {{ (uint32_t)line, {{ date.day, date.month, date.year }} }};
|
|
assert(!flight);
|
|
if(line > UINT32_MAX) { why = "line overflow"; goto catch; }
|
|
switch(flight_tree_assign(f, key, &flight)) {
|
|
case TREE_PRESENT: why = "duplicate key";
|
|
case TREE_ERROR: goto catch;
|
|
case TREE_ABSENT: flight->type = POWER; break;
|
|
}
|
|
flight->power.type.a = s0, flight->power.type.b = s1;
|
|
continue;
|
|
}
|
|
<flight_reg> ws* @s0 semitext+ @s1 ws* ";" => flight_airports
|
|
{ flight->power.reg.a = s0, flight->power.reg.b = s1; continue; }
|
|
<flight_airports> ws* @s0 airport @s1 ws* "--"
|
|
ws* @t0 airport @t1 ws* ";" => flight_pic {
|
|
flight->power.launch.a = s0, flight->power.launch.b = s1;
|
|
flight->power.landing.a = t0, flight->power.landing.b = t1;
|
|
continue;
|
|
}
|
|
<flight_pic> ws* @s0 semitext+ (ws+ semitext+)* @s1 /* ws*? */";"
|
|
=> flight_sic { flight->power.pilot.a = s0,
|
|
flight->power.pilot.b = s1; continue; }
|
|
<flight_sic> ws* ";" => flight_dual
|
|
{ flight->power.copilot.a = flight->power.copilot.b = 0; continue; }
|
|
<flight_sic> ws* @s0 semitext+ (ws+ semitext+)* @s1 ";"
|
|
=> flight_dual { flight->power.copilot.a = s0,
|
|
flight->power.copilot.b = s1; continue; }
|
|
<flight_dual> ws* ";" => flight_pilot
|
|
{ flight->power.dual_min = 0; continue; }
|
|
<flight_dual> ws* @s0 zero_natural? @s1 "." @t0 [0-9] @t1 "h" ws* ";"
|
|
=> flight_pilot { if(!pair_hours_to_minutes(s0, s1, t0, t1,
|
|
&flight->power.dual_min)) { why = "dual time"; goto catch; }
|
|
continue; }
|
|
<flight_pilot> ws* ";" => flight_ifrsim
|
|
{ flight->power.pilot_min = 0; continue; }
|
|
<flight_pilot> ws* @s0 zero_natural? @s1 "." @t0 [0-9] @t1 "h" ws* ";"
|
|
=> flight_ifrsim { if(!pair_hours_to_minutes(s0, s1, t0, t1,
|
|
&flight->power.pilot_min)) { why = "pilot time"; goto catch; }
|
|
continue; }
|
|
<flight_ifrsim> ws* ";" => flight_ifr
|
|
{ flight->power.ifrsim_min = 0; continue; }
|
|
<flight_ifrsim> ws* @s0 zero_natural? @s1 "." @t0 [0-9] @t1 "h" ws* ";"
|
|
=> flight_ifr { if(!pair_hours_to_minutes(s0, s1, t0, t1,
|
|
&flight->power.ifrsim_min)) { why = "simulated ifr time";
|
|
goto catch; } continue; }
|
|
<flight_ifr> ws* ";" => flight_remarks
|
|
{ flight->power.ifr_min = 0; continue; }
|
|
<flight_ifr> ws* @s0 zero_natural? @s1 "." @t0 [0-9] @t1 "h" ws* ";"
|
|
=> flight_remarks { if(!pair_hours_to_minutes(s0, s1, t0, t1,
|
|
&flight->power.ifr_min)) { why = "pilot time"; goto catch; }
|
|
continue; }
|
|
<flight_remarks> ws* "\n" => line
|
|
{ flight->power.remarks.a = flight->power.remarks.b = 0;
|
|
flight = 0; line++; continue; }
|
|
<flight_remarks> ws* @s0 glyph+ (ws+ glyph+)* @s1 "\n" => line
|
|
{ flight->power.remarks.a = s0, flight->power.remarks.b = s1;
|
|
flight = 0; line++; continue; }
|
|
*/ }
|
|
assert(0); /* Never gets here. */
|
|
catch:
|
|
if(!errno) errno = EILSEQ;
|
|
date32_to_string(date, &datestr);
|
|
fprintf(stderr, "%s line %zu: %s.\n", datestr, line, why);
|
|
return 0;
|
|
}
|
|
void flights_(struct flight_tree *const f) { flight_tree_(f); }
|
|
struct flight_tree flights(struct journal *const j) {
|
|
struct flight_tree f = flight_tree();
|
|
struct journal_iterator it;
|
|
union date32 date;
|
|
const char *text;
|
|
assert(j);
|
|
it = journal_iterator(j);
|
|
while(journal_next(&it, &date, &text)) if(!scan(&f, date, text)) goto catch;
|
|
goto finally;
|
|
catch:
|
|
flights_(&f);
|
|
finally:
|
|
return f;
|
|
}
|
|
const char *flights_to_string(const struct flight_tree *const f)
|
|
{ return flight_tree_to_string(f); }
|
|
struct flight_tree_iterator flights_iterator(struct flight_tree *const f)
|
|
{ return flight_tree_iterator(f); }
|
|
int flights_next(struct flight_tree_iterator *const it, union line64 *const k,
|
|
const struct flight **const v) {
|
|
assert(it && k && v);
|
|
if(!flight_tree_next(it)) return 0;
|
|
*k = flight_tree_key(it);
|
|
*v = flight_tree_value(it);
|
|
return 1;
|
|
}
|