/*

 *=============================================================================

 *  flex based parser for DATCOM input cards.

 *

 *  Copyright (C) 2009  Anders Gidenstam (anders(at)gidenstam.org)

 *  Copyright (C) 2009  Ronald Jensen    (ron(at)jentronics.com)

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 3 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *=============================================================================

 */

%{

    #include <stdio.h>

    #include <string.h>

    #include <math.h>

    #include "datcom-parser.h"

    extern int verbose;

    /* Internal global variables. */

    static AIRCRAFT* current_aircraft;

    static int current_namelist;

    #define NL_NONE    0

    #define NL_UNKNOWN 1

    #define NL_SYNTHS  2

    #define NL_BODY    3

    #define NL_WGPLNF  4

    #define NL_HTPLNF  5

    #define NL_VTPLNF  6

    #define NL_VFPLNF  7

    #define NL_WGSCHR  8

    #define NL_HTSCHR  9

    #define NL_VTSCHR  10

    #define NL_VFSCHR  11

    #define NL_PROPWR  12

    #define NL_SYMFLP  13

    #define NL_ASYFLP  14

    #define NL_OPTINS  15

    #define NL_MAX     16 /* Keep this entry last! */

    static int line_number;

    /* For variables and array variables. */

    static double* next_double;

    static int     num_doubles;

    static int*    next_int;

    static int*    next_bool;

    static const char* NL_NAME[] = {

                                       "",

                                       "",

                                       "$SYNTHS",

                                       "$BODY",

                                       "$WGPLNF",

                                       "$HTPLNF",

                                       "$VTPLNF",

                                       "$VFPLNF",

                                       "$WGSCHR",

                                       "$HTSCHR",

                                       "$VTSCHR",

                                       "$VFSCHR",

                                       "$PROPWR",

                                       "$SYMFLP",

                                       "$ASYFLP",

                                       "$OPTINS",

                                   };

    /* Internal functions. */

    static void InitializeParser(AIRCRAFT* aircraft);

    static void Fail();

    static void BeginNameList(char* name);

    static void EndNameList();

    static void ReadVariable(char* var);

    static void ReadNumber(char* str); /* Reads a double or an int */ 

    static void OPTINSReadVariable(char* var);

    static void SYNTHSReadVariable(char* var);

    static void BODYReadVariable(char* var);

    static void PLNFReadVariable(char* var, struct WGPLNF* surface);

    static void SCHRReadVariable(char* var, DATCOM_AIRFOIL* airfoil);

    static void PROPWRReadVariable(char* var);

    static void NACARead(char* str);

    /* Added by Bill Galbraith 10-13-10 */

    static void ClearLineRead();

    static void AppendToLineRead(char* str);

    char LineRead[300];

%}

/* This tells flex to read only one input file */

%option noyywrap

/* Parser conditions/"states" */

%s namelist

DIGIT           [0-9]

ALPHA           [a-zA-Z]

ALPHANUM        [A-Za-z0-9]

ID              [A-Z][A-Z0-9]*

WS              [ \t]

EOL             "\n"|"\n\r"|"\r\n"

NEOL            [^\n\r]

/* Bill Galbraith  10-12-10

   Redefined what a DOUBLE was, to :

      digit(s), a decimal point, and digit(s)

      digit(s) and a decimal point

      a decimal point and digit(s)

   and of which may or may not have a leading minus sign and

   trailing exponent, which is made up of an optional minus sign

   and digit(s)

   * IMPORTANT NOTE * The DOUBLE is also defined as ending with a comma.

   Old definition

DOUBLE          "-"?{DIGIT}*"."{DIGIT}*("E""-"?{DIGIT}+)?   */

/* This works, except it doesn't account for not having

   the numbers separated by commas. If you fix this, also have BOOLEAN

   separated by commas.

*/

DOUBLE          ("-"?{DIGIT}+"."{DIGIT}+("E""-"?{DIGIT}+)?|"-"?{DIGIT}+"."("E""-"?{DIGIT}+)?|"-"?"."{DIGIT}+("E""-"?{DIGIT}+)?)

BOOL            \.TRUE\.|\.FALSE\.

COMMAND         ^(PART|DERIV|DUMP|DAMP|SAVE|NEXT|CASEID|BUILD|PLOT|TRIM)

DIMENSION       ^(DIM)

NAMELIST        "$"{ID}

VAR             {ID}({WS}*"=")

ARRVAR          {ID}"(1)"{WS}*"="

NACAAIRFOIL     ^"NACA"({WS}|"-"){NEOL}*{LENDCOMMENT}?

LINECOMMENT     ^("*"|"#"){NEOL}*

LENDCOMMENT     "!"{NEOL}*

/*******************************************************************************

 * Rules

 */

%%

<namelist>{DOUBLE} {

    if (verbose > 2) fprintf(stderr,"datcom-parser:    DOUBLE: %s = %g\n", yytext, atof(yytext));

    /* Bill Galbraith 10-13-10  This is a more accurate output */

    /* Ron Jensen 10-13-10 The conversion is done with atof() so perhaps both are interesting */

    //fprintf(stderr,"    DOUBLE: %s\n", yytext);

    ReadNumber(yytext);

    AppendToLineRead(yytext);

}

<namelist>{BOOL} {

    if (verbose > 2) fprintf(stderr,"datcom-parser:    BOOL: %s\n", yytext);

    ReadNumber(yytext);

    AppendToLineRead(yytext);

}

<INITIAL>{NAMELIST} {

    if (verbose > 2) fprintf(stderr,"datcom-parser:NAMELIST: %s\n", yytext);

    BEGIN(namelist);

    BeginNameList(yytext);

    AppendToLineRead(yytext);

}

<namelist>"$" {

    if (verbose > 2) fprintf(stderr,"datcom-parser:END OF NAMELIST\n");

    BEGIN(INITIAL);

    EndNameList();

    AppendToLineRead(yytext);

}

<namelist>{ARRVAR} {

    char* e;

    AppendToLineRead(yytext);

    /* Strip trailing garbage. I hope this is safe.. */

    e = strchr(yytext, '(');

    if (e != NULL) {

        *e = '\0';

    }

    if (verbose > 2) fprintf(stderr,"datcom-parser:  ARRAYVARIABLE: %s\n", yytext);

    ReadVariable(yytext);

}

<namelist>{VAR} {

    char* s;

    char* e;

    /* Strip trailing garbage. I hope this is safe.. */

    s = strchr(yytext, ' ');

    e = strchr(yytext, '=');

    e = (e != NULL) ? e : s;

    s = (s != NULL) ? s : e;

    e = (e < s) ? e : s;

    if (e != NULL) {

        *e = '\0';

    }

    AppendToLineRead(yytext);

    if (verbose > 2) fprintf(stderr,"datcom-parser:  VARIABLE: %s\n", yytext);

    ReadVariable(yytext);

}

{NACAAIRFOIL} {

    if (verbose > 2) fprintf(stderr,"datcom-parser:AIRFOIL: %s\n", yytext);

    NACARead(yytext);

    ClearLineRead();

}

{COMMAND}{NEOL}* {

	if (verbose > 2) fprintf(stderr,"datcom-parser:Command: %s\n", yytext);

    /* Drop uninteresting commands */

    ClearLineRead();

}

{DIMENSION}{NEOL}* {

	if (verbose) fprintf(stderr,"datcom-parser:Dimension: %s\n", yytext);

    /* Drop uninteresting commands */

    ClearLineRead();

}

{LINECOMMENT} {

    /* Drop comment lines */

   ClearLineRead();

}

{LENDCOMMENT} {

    /* Drop comment lines */

    ClearLineRead();

}

{EOL} {

    line_number++;

   ClearLineRead();

}

"," {

    /* Eat ',' */

    AppendToLineRead(yytext);

}

{WS} {

    /* Eat up whitespace */

}

. {

    Fail();

}

%%

/*******************************************************************************

 * Verbatim code section

 */

/* Main entry point. */

void ReadDatcom(char* filename, AIRCRAFT* aircraft)

{

    yyin = fopen(filename, "r");

    if(!yyin){

      fprintf(stderr,"Failed to open input file %s\n", filename);

      exit(EXIT_FAILURE);

    }

    InitializeParser(aircraft);

    yylex();

    fclose(yyin);

}

static void InitializeParser(AIRCRAFT* aircraft)

{

    /* Bill Galbraith  10-12-10

       Changed the initial value from 0 to 1, so that the line numbers

       output actually matches that in the file. */

    line_number = 1;

    current_aircraft = aircraft;

    current_namelist = NL_NONE;

    next_double      = NULL;

    num_doubles      = 0;

    next_int         = NULL;

    memset(current_aircraft, 0, sizeof(AIRCRAFT));

    current_aircraft->optins.ROUGFC=-1; // using this as the unset value in modeler.c GetShiny()

}

static void Fail()

{

    if (verbose > 0) fprintf(stderr, "datcom-parser: Error: Unrecognized or misplaced character '%s' in line %d\n",

            yytext, line_number);

    fprintf(stderr, "Errant line up to the error is:\n%s\n", LineRead );

    exit(-1);

}

static void BeginNameList(char* name)

{

    int i;

    if (current_namelist != NL_NONE) {

        if (verbose > 0) fprintf(stderr,

               "datcom-parser: Unterminated NAMELIST in line %d\n",

                line_number);

        exit(-1);

    }

    current_namelist = NL_UNKNOWN;

    for (i = 0; i < NL_MAX; i++) {

        if (strcmp(name, NL_NAME[i]) == 0) {

            current_namelist = i;

        }

    }

    if (current_namelist == NL_UNKNOWN) {

        if (verbose > 1) fprintf(stderr,

               "datcom-parser: Unknown NAMELIST %s in line %d\n",

                name,

                line_number);

    }

 }

static void EndNameList()

{

    if (current_namelist == NL_NONE) {

        if (verbose > 0) fprintf(stderr,

                "datcom-parser: Unbegun NAMELIST terminated in line %d\n",

                line_number);

        exit(-1);

    }

    current_namelist = NL_NONE;

}

static void ReadVariable(char* var)

{

    if(verbose > 3)  

    {

        switch (current_namelist) {

        case NL_NONE:

            fprintf(stderr,"datcom-parser: NL_NONE\n");

            break;

        case NL_UNKNOWN: // This case will print elsewhere

//            fprintf(stderr,"datcom-parser: NL_UNKNOWN\n");

            break;

        default:

            if(current_namelist < NL_MAX) fprintf(stderr,"datcom-parser: %s\n", NL_NAME[current_namelist]);

        }

    }

    switch (current_namelist) {

    case NL_NONE:

        if (verbose > 0) fputs("datcom-parser: Variable outside of NAMELIST", stderr);

        exit(-1);

        break;

    case NL_SYNTHS:

        SYNTHSReadVariable(var);

        break;

    case NL_BODY:

        BODYReadVariable(var);

        break;

    case NL_WGPLNF:

        PLNFReadVariable(var, &current_aircraft->wing);

        break;

    case NL_HTPLNF:

        PLNFReadVariable(var, &current_aircraft->htail);

        break;

    case NL_VTPLNF:

        PLNFReadVariable(var, &current_aircraft->vtail);

        break;

    case NL_VFPLNF:

        PLNFReadVariable(var, &current_aircraft->vfin);

        break;

    case NL_WGSCHR:

        SCHRReadVariable(var, &current_aircraft->wingfoil);

        break;

    case NL_HTSCHR:

        SCHRReadVariable(var, &current_aircraft->htailfoil);

        break;

    case NL_VTSCHR:

        SCHRReadVariable(var, &current_aircraft->vtailfoil);

        break;

    case NL_VFSCHR:

        SCHRReadVariable(var, &current_aircraft->vfinfoil);

        break;

    case NL_PROPWR:

        PROPWRReadVariable(var);

        break;

    case NL_SYMFLP:

// FIXME: Do Something!

        break;

    case NL_ASYFLP:

// FIXME: Do Something!

        break;

    case NL_OPTINS:

        OPTINSReadVariable(var);

        break;

    default:

        break;

    }

}

static void ReadNumber(char* str)

{

    if (num_doubles-- && next_double != NULL) {

        *next_double = atof(yytext); /* Add error detection here! */

        next_double = (num_doubles > 0) ? next_double + 1 : NULL;

    } else if (next_int) {

        *next_int = (int)atof(yytext); /* Add error detection here! */

        next_int = NULL;

    } else if (next_bool) {

        if (strcmp(yytext, ".TRUE.") == 0) {

            *next_bool = 1;

        } else {

            *next_bool = 0;

        }

        next_bool=NULL;

    }

}

static void PROPWRReadVariable(char* var)

{

    num_doubles = 1;

    if (strcmp(var, "AIETLP") == 0) {

        next_double = &current_aircraft->propwr.AIETLP;

    } else if (strcmp(var, "NENGSP") == 0) {

        next_double = &current_aircraft->propwr.NENGSP;

    } else if (strcmp(var, "THSTCP") == 0) {

        next_double = &current_aircraft->propwr.THSTCP;

    } else if (strcmp(var, "PHALOC") == 0) {

        next_double = &current_aircraft->propwr.PHALOC;

    } else if (strcmp(var, "PHVLOC") == 0) {

        next_double = &current_aircraft->propwr.PHVLOC;

    } else if (strcmp(var, "PRPRAD") == 0) {

        next_double = &current_aircraft->propwr.PRPRAD;

    } else if (strcmp(var, "BWAPR3") == 0) {

        next_double = &current_aircraft->propwr.BWAPR3;

    } else if (strcmp(var, "BWAPR6") == 0) {

        next_double = &current_aircraft->propwr.BWAPR6;

    } else if (strcmp(var, "BWAPR9") == 0) {

        next_double = &current_aircraft->propwr.BWAPR9;

    } else if (strcmp(var, "NOPBPE") == 0) {

        next_double = &current_aircraft->propwr.NOPBPE;

    } else if (strcmp(var, "BAPR75") == 0) {

        next_double = &current_aircraft->propwr.BAPR75;

    } else if (strcmp(var, "YP") == 0) {

        next_double = &current_aircraft->propwr.YP;

    } else if (strcmp(var, "CROT") == 0) {

        num_doubles = 0;

        next_int = &current_aircraft->propwr.CROT;

    } else {

       if (verbose > 1) fprintf(stderr,

                "datcom-parser: Unknown variable %s in PROPWR NAMELIST close to line %d\n",

                var, line_number);

    }

}

static void OPTINSReadVariable(char* var)

{

    num_doubles = 1;

    if (strcmp(var, "ROUGFC") == 0) {

        next_double = &current_aircraft->optins.ROUGFC;

    } else if (strcmp(var, "SREF") == 0) {

        next_double = &current_aircraft->optins.SREF;

    } else if (strcmp(var, "CBARR") == 0) {

        next_double = &current_aircraft->optins.CBARR;

    } else if (strcmp(var, "BLREF") == 0) {

        next_double = &current_aircraft->optins.BLREF;

    } else {

       if (verbose > 1) fprintf(stderr,

                "datcom-parser: Unknown variable %s in OPTIN NAMELIST close to line %d\n",

                var, line_number);

    }

} 

static void SYNTHSReadVariable(char* var)

{

    /*printf("SYNTHS: %s\n", var);*/

    num_doubles = 1;

    if (strcmp(var, "XCG") == 0) {

        next_double = &current_aircraft->synths.XCG;

    } else if (strcmp(var, "ZCG") == 0) {

        next_double = &current_aircraft->synths.ZCG;

    } else if (strcmp(var, "XW") == 0) {

        next_double = &current_aircraft->synths.XW;

    } else if (strcmp(var, "ZW") == 0) {

        next_double = &current_aircraft->synths.ZW;

    } else if (strcmp(var, "ALIW") == 0) {

        next_double = &current_aircraft->synths.ALIW;

    } else if (strcmp(var, "XH") == 0) {

        next_double = &current_aircraft->synths.XH;

    } else if (strcmp(var, "ZH") == 0) {

        next_double = &current_aircraft->synths.ZH;

    } else if (strcmp(var, "ALIH") == 0) {

        next_double = &current_aircraft->synths.ALIH;

    } else if (strcmp(var, "XV") == 0) {

        next_double = &current_aircraft->synths.XV;

    } else if (strcmp(var, "ZV") == 0) {

        next_double = &current_aircraft->synths.ZV;

    } else if (strcmp(var, "XVF") == 0) {

        next_double = &current_aircraft->synths.XVF;

    } else if (strcmp(var, "ZVF") == 0) {

        next_double = &current_aircraft->synths.ZVF;

    } else if (strcmp(var, "SCALE") == 0) {

        next_double = &current_aircraft->synths.SCALE;

    } else if (strcmp(var, "HINAX") == 0) {

        next_double = &current_aircraft->synths.HINAX;

    } else if (strcmp(var, "VERTUP") == 0) {

        num_doubles = 0;

        next_int = NULL;

        next_bool = &current_aircraft->synths.VERTUP;

    } else {

       if (verbose > 1) fprintf(stderr,

                "datcom-parser: Unknown variable %s in SYNTHS NAMELIST in line %d\n",

                var, line_number);

    }

}

static void BODYReadVariable(char* var)

{

    if (strcmp(var, "NX") == 0) {

        next_int = &current_aircraft->body.NX;

    } else if (strcmp(var, "X") == 0) {

        num_doubles = current_aircraft->body.NX;

        next_double = &current_aircraft->body.X[0];

    } else if (strcmp(var, "S") == 0) {

        num_doubles = current_aircraft->body.NX;

        next_double = &current_aircraft->body.S[0];

    } else if (strcmp(var, "P") == 0) {

        num_doubles = current_aircraft->body.NX;

        next_double = &current_aircraft->body.P[0];

    } else if (strcmp(var, "R") == 0) {

        num_doubles = current_aircraft->body.NX;

        next_double = &current_aircraft->body.R[0];

    } else if (strcmp(var, "ZU") == 0) {

        num_doubles = current_aircraft->body.NX;

        next_double = &current_aircraft->body.ZU[0];

    } else if (strcmp(var, "ZL") == 0) {

        num_doubles = current_aircraft->body.NX;

        next_double = &current_aircraft->body.ZL[0];

    } else if (strcmp(var, "BNOSE") == 0) {

        num_doubles = 1;

        next_double = &current_aircraft->body.BNOSE;

    } else if (strcmp(var, "BTAIL") == 0) {

        num_doubles = 1;

        next_double = &current_aircraft->body.BTAIL;

    } else if (strcmp(var, "BLN") == 0) {

        num_doubles = 1;

        next_double = &current_aircraft->body.BLN;

    } else if (strcmp(var, "BLA") == 0) {

        num_doubles = 1;

        next_double = &current_aircraft->body.BLA;

    } else if (strcmp(var, "DS") == 0) {

        num_doubles = 1;

        next_double = &current_aircraft->body.DS;

    } else if (strcmp(var, "ITYPE") == 0) {

        num_doubles = 0;

        next_int = &current_aircraft->body.ITYPE;

    } else if (strcmp(var, "METHOD") == 0) {

        num_doubles = 0;

        next_int = &current_aircraft->body.METHOD;

    } else {

        if (verbose > 1) fprintf(stderr,

                "datcom-parser: Unknown variable %s in BODY NAMELIST in line %d\n",

                var, line_number);

    }

}

static void PLNFReadVariable(char* var, struct WGPLNF* surface)

{

    num_doubles = 1;

    if (strcmp(var, "CHRDR") == 0) {

        next_double = &surface->CHRDR;

    } else if (strcmp(var, "CHRDBP") == 0) {

        next_double = &surface->CHRDBP;

    } else if (strcmp(var, "CHRDTP") == 0) {

        next_double = &surface->CHRDTP;

    } else if (strcmp(var, "SSPN") == 0) {

        next_double = &surface->SSPN;

    } else if (strcmp(var, "SSPNE") == 0) {

        next_double = &surface->SSPNE;

    } else if (strcmp(var, "SSPNOP") == 0) {

        next_double = &surface->SSPNOP;

    } else if (strcmp(var, "SAVSI") == 0) {

        next_double = &surface->SAVSI;

    } else if (strcmp(var, "SAVSO") == 0) {

        next_double = &surface->SAVSO;

    } else if (strcmp(var, "CHSTAT") == 0) {

        next_double = &surface->CHSTAT;

    } else if (strcmp(var, "TWISTA") == 0) {

        next_double = &surface->TWISTA;

    } else if (strcmp(var, "SSPNDD") == 0) {

        next_double = &surface->SSPNDD;

    } else if (strcmp(var, "DHDADI") == 0) {

        next_double = &surface->DHDADI;

    } else if (strcmp(var, "DHDADO") == 0) {

        next_double = &surface->DHDADO;

    } else if (strcmp(var, "TYPE") == 0) {

        num_doubles = 0;

        next_int    = &surface->TYPE;

    } else {

       if (verbose > 1) fprintf(stderr,

                "datcom-parser: Unknown variable %s in PLNF NAMELIST around line %d\n",

                var, line_number);

    }

}

static void SCHRReadVariable(char* var, DATCOM_AIRFOIL *airfoil)

{

    if (strcmp(var, "TYPEIN") == 0) {

        next_int = &airfoil->TYPEIN;

    } else if (strcmp(var, "NPTS") == 0) {

        next_int = &airfoil->NPTS;

    } else if (strcmp(var, "XCORD") == 0) {

        num_doubles = airfoil->NPTS;

        airfoil->XCORD = calloc(num_doubles, sizeof(double));

        next_double = &airfoil->XCORD[0];

    } else if (strcmp(var, "YUPPER") == 0) {

        num_doubles = airfoil->NPTS;

        airfoil->YUPPER = calloc(num_doubles, sizeof(double));

        next_double = &airfoil->YUPPER[0];

    } else if (strcmp(var, "YLOWER") == 0) {

        num_doubles = airfoil->NPTS;

        airfoil->YLOWER = calloc(num_doubles, sizeof(double));

        next_double = &airfoil->YLOWER[0];

    } else {

       if (verbose > 1) fprintf(stderr,

                "datcom-parser: Unknown variable %s in SCHR NAMELIST in line %d\n",

                var, line_number);

    } 

}

static void NACARead(char* str)

{

    ClearLineRead();

    switch (str[5]) {

    case 'W':

        current_aircraft->wingfoil.NACA_DESCR =

            (char *)malloc(strlen(str) + 1);

        strcpy(current_aircraft->wingfoil.NACA_DESCR, str);

        break;

    case 'H':

        current_aircraft->htailfoil.NACA_DESCR =

            (char *)malloc(strlen(str) + 1);

        strcpy(current_aircraft->htailfoil.NACA_DESCR, str);

        break;

    case 'V':

        current_aircraft->vtailfoil.NACA_DESCR =

            (char *)malloc(strlen(str) + 1);

        strcpy(current_aircraft->vtailfoil.NACA_DESCR, str);

        break;

    case 'F':

        current_aircraft->vfinfoil.NACA_DESCR =

            (char *)malloc(strlen(str) + 1);

        strcpy(current_aircraft->vfinfoil.NACA_DESCR, str);

        break;

    default:

       if (verbose > 1) fprintf(stderr, "datcom-parser: Unknow surface in NACA airfoil %s in line %d\n",

                str, line_number);

        break;

    }

}

static void ClearLineRead()

{

    strcpy( LineRead,"" );

}

static void AppendToLineRead(char* str)

{

    strcat( LineRead, str );

    if ( strlen(LineRead) > 80 )

    {

       fprintf(stderr,"datcom-parser: Line is too long at line %d. Keep it under 80 characters\n%s\n", 

          line_number, LineRead );

//       exit(-1);

    }

}