src/FDM/UIUCModel/uiuc_menu.cpp

   1 /**********************************************************************
   2
   3  FILENAME:     uiuc_menu.cpp
   4
   5 ----------------------------------------------------------------------
   6
   7  DESCRIPTION:  reads input file for specified aircraft and creates
   8                approporiate data storage space
   9
  10 ----------------------------------------------------------------------
  11
  12  STATUS:       alpha version
  13
  14 ----------------------------------------------------------------------
  15
  16  REFERENCES:   based on "menu reader" format of Michael Selig
  17
  18 ----------------------------------------------------------------------
  19
  20  HISTORY:      01/29/2000   initial release
  21                02/18/2000   (JS) added 1D data file capability for
  22                             CL(a) and CD(a) -- calls
  23                             uiuc_1DdataFileReader
  24                02/22/2000   (JS) added ice map functions
  25                02/29/2000   (JS) added 2D data file capability for
  26                             CL(a,de), CD(a,de), Cm(a,de), CY(a,da),
  27                             CY(beta,dr), Cl(a,da), Cl(beta,dr),
  28                             Cn(a,da), Cn(beta,dr) -- calls
  29                             uiuc_2DdataFileReader
  30                02/02/2000   (JS) added record options for 1D and
  31                             2D interpolated variables
  32                03/28/2000   (JS) streamlined conversion factors for
  33                             file readers -- since they are global
  34                             variables, it is not necessary to put
  35                             them in the function calls
  36                03/29/2000   (JS) added Cmfa and Weight flags;
  37                             added misc map; added Dx_cg (etc) to init
  38                             map
  39                04/01/2000   (JS) added throttle, longitudinal, lateral,
  40                             and rudder inputs to record map
  41                04/05/2000   (JS) added Altitude to init and record
  42                             maps; added zero_Long_trim to
  43                             controlSurface map
  44                03/09/2001   (DPM) added support for gear.
  45                06/18/2001   (RD) Added Alpha, Beta, U_body,
  46                             V_body, and W_body to init map.  Added
  47                             aileron_input, rudder_input, pilot_elev_no,
  48                             pilot_ail_no, and pilot_rud_no to
  49                             controlSurface map.  Added Throttle_pct_input
  50                             to engine map.  Added CZfa to CL map.
  51                07/05/2001   (RD) Changed pilot_elev_no = true to pilot_
  52                             elev_no_check=false.  This is to allow pilot
  53                             to fly aircraft after input files have been
  54                             used.
  55                08/27/2001   (RD) Added xxx_init_true and xxx_init for
  56                             P_body, Q_body, R_body, Phi, Theta, Psi,
  57                             U_body, V_body, and W_body to help in
  58                             starting the A/C at an initial condition.
  59                10/25/2001   (RD) Added new variables needed for the non-
  60                             linear Twin Otter model at zero flaps
  61                             (Cxfxxf0)
  62                11/12/2001   (RD) Added new variables needed for the non-
  63                             linear Twin Otter model with flaps
  64                             (Cxfxxf).  Removed zero flap variables.
  65                             Added minmaxfind() which is needed for non-
  66                             linear variables
  67                01/11/2002   (AP) Added keywords for bootTime
  68                02/13/2002   (RD) Added variables so linear aero model
  69                             values can be recorded
  70                02/18/2002   (RD) Added variables necessary to use the
  71                             uiuc_3Dinterp_quick() function.  Takes
  72                             advantage of data in a "nice" form (data
  73                             that are in a rectangular matrix).
  74                03/13/2002   (RD) Added aircraft_directory so full path
  75                             is no longer needed in the aircraft.dat file
  76                04/02/2002   (RD) Removed minmaxfind() since it was no
  77                             longer needed.  Added d_2_to_3(),
  78                             d_1_to_2(), and i_1_to_2() so uiuc_menu()
  79                             will compile with certain compilers.
  80                08/29/2002   (RD) Separated each primary keyword into its
  81                             own function to speed up compile time
  82
  83 ----------------------------------------------------------------------
  84
  85  AUTHOR(S):    Bipin Sehgal       <bsehgal@uiuc.edu>
  86                Jeff Scott         <jscott@mail.com>
  87                Robert Deters      <rdeters@uiuc.edu>
  88                Michael Selig      <m-selig@uiuc.edu>
  89                David Megginson    <david@megginson.com>
  90                Ann Peedikayil     <peedikay@uiuc.edu>
  91 ----------------------------------------------------------------------
  92
  93  VARIABLES:
  94
  95 ----------------------------------------------------------------------
  96
  97  INPUTS:       n/a
  98
  99 ----------------------------------------------------------------------
 100
 101  OUTPUTS:      n/a
 102
 103 ----------------------------------------------------------------------
 104
 105  CALLED BY:    uiuc_wrapper.cpp
 106
 107 ----------------------------------------------------------------------
 108
 109  CALLS TO:     aircraft.dat
 110                tabulated data files (if needed)
 111
 112 ----------------------------------------------------------------------
 113
 114  COPYRIGHT:    (C) 2000 by Michael Selig
 115
 116  This program is free software; you can redistribute it and/or
 117  modify it under the terms of the GNU General Public License
 118  as published by the Free Software Foundation.
 119
 120  This program is distributed in the hope that it will be useful,
 121  but WITHOUT ANY WARRANTY; without even the implied warranty of
 122  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 123  GNU General Public License for more details.
 124
 125  You should have received a copy of the GNU General Public License
 126  along with this program; if not, write to the Free Software
 127  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 128  USA or view http://www.gnu.org/copyleft/gpl.html.
 129
 130 **********************************************************************/
 131
 132 #include <simgear/compiler.h>
 133
 134 #if defined( __MWERKS__ )
 135 // -dw- optimizer chokes (big-time) trying to optimize humongous
 136 // loop/switch statements
 137 #pragma optimization_level 0
 138 #endif
 139
 140 #include <stdlib.h>
 141 #include <string.h>
 142 #include STL_IOSTREAM
 143
 144 #include "uiuc_menu.h"
 145
 146 #if !defined (SG_HAVE_NATIVE_SGI_COMPILERS)
 147 SG_USING_STD(cerr);
 148 SG_USING_STD(cout);
 149 SG_USING_STD(endl);
 150
 151 #  ifndef _MSC_VER
 152 SG_USING_STD(exit);
 153 #  endif
 154 #endif
 155
 156 bool check_float( const string &token)
 157 {
 158   float value;
 159   istrstream stream(token.c_str());
 160   return (stream >> value);
 161 }
 162
 163 void d_2_to_3( double array2D[100][100], double array3D[][100][100], int index3D)
 164 {
 165   for (register int i=0; i<=99; i++)
 166     {
 167       for (register int j=1; j<=99; j++)
 168         {
 169           array3D[index3D][i][j]=array2D[i][j];
 170         }
 171     }
 172 }
 173
 174 void d_1_to_2( double array1D[100], double array2D[][100], int index2D)
 175 {
 176   for (register int i=0; i<=99; i++)
 177     {
 178       array2D[index2D][i]=array1D[i];
 179     }
 180 }
 181
 182 void d_1_to_1( double array1[100], double array2[100] )
 183 {
 184   for (register int i=0; i<=99; i++)
 185     {
 186       array2[i]=array1[i];
 187     }
 188 }
 189
 190 void i_1_to_2( int array1D[100], int array2D[][100], int index2D)
 191 {
 192   for (register int i=0; i<=99; i++)
 193     {
 194       array2D[index2D][i]=array1D[i];
 195     }
 196 }
 197
 198 void parse_init( const string& linetoken2, const string& linetoken3,
 199                  LIST command_line ) {
 200     double token_value;
 201     istrstream token3(linetoken3.c_str());
 202     int token_value_recordRate;
 203
 204     switch(init_map[linetoken2])
 205       {
 206       case Dx_pilot_flag:
 207         {
 208           if (check_float(linetoken3))
 209             token3 >> token_value;
 210           else
 211             uiuc_warnings_errors(1, *command_line);
 212
 213           Dx_pilot = token_value;
 214           initParts -> storeCommands (*command_line);
 215           break;
 216         }
 217       case Dy_pilot_flag:
 218         {
 219           if (check_float(linetoken3))
 220             token3 >> token_value;
 221           else
 222             uiuc_warnings_errors(1, *command_line);
 223
 224           Dy_pilot = token_value;
 225           initParts -> storeCommands (*command_line);
 226           break;
 227         }
 228       case Dz_pilot_flag:
 229         {
 230           if (check_float(linetoken3))
 231             token3 >> token_value;
 232           else
 233             uiuc_warnings_errors(1, *command_line);
 234
 235           Dz_pilot = token_value;
 236           initParts -> storeCommands (*command_line);
 237           break;
 238         }
 239       case Dx_cg_flag:
 240         {
 241           if (check_float(linetoken3))
 242             token3 >> token_value;
 243           else
 244             uiuc_warnings_errors(1, *command_line);
 245
 246           Dx_cg = token_value;
 247           initParts -> storeCommands (*command_line);
 248           break;
 249         }
 250       case Dy_cg_flag:
 251         {
 252           if (check_float(linetoken3))
 253             token3 >> token_value;
 254           else
 255             uiuc_warnings_errors(1, *command_line);
 256
 257           Dy_cg = token_value;
 258           initParts -> storeCommands (*command_line);
 259           break;
 260         }
 261       case Dz_cg_flag:
 262         {
 263           if (check_float(linetoken3))
 264             token3 >> token_value;
 265           else
 266             uiuc_warnings_errors(1, *command_line);
 267
 268           Dz_cg = token_value;
 269           initParts -> storeCommands (*command_line);
 270           break;
 271         }
 272       case Altitude_flag:
 273         {
 274           if (check_float(linetoken3))
 275             token3 >> token_value;
 276           else
 277             uiuc_warnings_errors(1, *command_line);
 278
 279           Altitude = token_value;
 280           initParts -> storeCommands (*command_line);
 281           break;
 282         }
 283       case V_north_flag:
 284         {
 285           if (check_float(linetoken3))
 286             token3 >> token_value;
 287           else
 288             uiuc_warnings_errors(1, *command_line);
 289
 290           V_north = token_value;
 291           initParts -> storeCommands (*command_line);
 292           break;
 293         }
 294       case V_east_flag:
 295         {
 296           initParts -> storeCommands (*command_line);
 297           if (check_float(linetoken3))
 298             token3 >> token_value;
 299           else
 300             uiuc_warnings_errors(1, *command_line);
 301
 302           V_east = token_value;
 303           break;
 304         }
 305       case V_down_flag:
 306         {
 307           if (check_float(linetoken3))
 308             token3 >> token_value;
 309           else
 310             uiuc_warnings_errors(1, *command_line);
 311
 312           V_down = token_value;
 313           initParts -> storeCommands (*command_line);
 314           break;
 315         }
 316       case P_body_flag:
 317         {
 318           if (check_float(linetoken3))
 319             token3 >> token_value;
 320           else
 321             uiuc_warnings_errors(1, *command_line);
 322
 323           P_body_init_true = true;
 324           P_body_init = token_value;
 325           initParts -> storeCommands (*command_line);
 326           break;
 327         }
 328       case Q_body_flag:
 329         {
 330           if (check_float(linetoken3))
 331             token3 >> token_value;
 332           else
 333             uiuc_warnings_errors(1, *command_line);
 334
 335           Q_body_init_true = true;
 336           Q_body_init = token_value;
 337           initParts -> storeCommands (*command_line);
 338           break;
 339         }
 340       case R_body_flag:
 341         {
 342           if (check_float(linetoken3))
 343             token3 >> token_value;
 344           else
 345             uiuc_warnings_errors(1, *command_line);
 346
 347           R_body_init_true = true;
 348           R_body_init = token_value;
 349           initParts -> storeCommands (*command_line);
 350           break;
 351         }
 352       case Phi_flag:
 353         {
 354           if (check_float(linetoken3))
 355             token3 >> token_value;
 356           else
 357             uiuc_warnings_errors(1, *command_line);
 358
 359           Phi_init_true = true;
 360           Phi_init = token_value;
 361           initParts -> storeCommands (*command_line);
 362           break;
 363         }
 364       case Theta_flag:
 365         {
 366           if (check_float(linetoken3))
 367             token3 >> token_value;
 368           else
 369             uiuc_warnings_errors(1, *command_line);
 370
 371           Theta_init_true = true;
 372           Theta_init = token_value;
 373           initParts -> storeCommands (*command_line);
 374           break;
 375         }
 376       case Psi_flag:
 377         {
 378           if (check_float(linetoken3))
 379             token3 >> token_value;
 380           else
 381             uiuc_warnings_errors(1, *command_line);
 382
 383           Psi_init_true = true;
 384           Psi_init = token_value;
 385           initParts -> storeCommands (*command_line);
 386           break;
 387         }
 388       case Long_trim_flag:
 389         {
 390           if (check_float(linetoken3))
 391             token3 >> token_value;
 392           else
 393             uiuc_warnings_errors(1, *command_line);
 394
 395           Long_trim = token_value;
 396           initParts -> storeCommands (*command_line);
 397           break;
 398         }
 399       case recordRate_flag:
 400         {
 401           //can't use check_float since variable is integer
 402           token3 >> token_value_recordRate;
 403           recordRate = 120 / token_value_recordRate;
 404           break;
 405         }
 406       case recordStartTime_flag:
 407         {
 408           if (check_float(linetoken3))
 409             token3 >> token_value;
 410           else
 411             uiuc_warnings_errors(1, *command_line);
 412
 413           recordStartTime = token_value;
 414           break;
 415         }
 416       case use_V_rel_wind_2U_flag:
 417         {
 418           use_V_rel_wind_2U = true;
 419           break;
 420         }
 421       case nondim_rate_V_rel_wind_flag:
 422         {
 423           nondim_rate_V_rel_wind = true;
 424           break;
 425         }
 426       case use_abs_U_body_2U_flag:
 427         {
 428           use_abs_U_body_2U = true;
 429           break;
 430         }
 431       case dyn_on_speed_flag:
 432         {
 433           if (check_float(linetoken3))
 434             token3 >> token_value;
 435           else
 436             uiuc_warnings_errors(1, *command_line);
 437
 438           dyn_on_speed = token_value;
 439           break;
 440         }
 441       case dyn_on_speed_zero_flag:
 442         {
 443           if (check_float(linetoken3))
 444             token3 >> token_value;
 445           else
 446             uiuc_warnings_errors(1, *command_line);
 447
 448           dyn_on_speed_zero = token_value;
 449           break;
 450         }
 451       case use_dyn_on_speed_curve1_flag:
 452         {
 453           use_dyn_on_speed_curve1 = true;
 454           break;
 455         }
 456       case Alpha_flag:
 457         {
 458           if (check_float(linetoken3))
 459             token3 >> token_value;
 460           else
 461             uiuc_warnings_errors(1, *command_line);
 462
 463           Alpha_init_true = true;
 464           Alpha_init = token_value * DEG_TO_RAD;
 465           break;
 466         }
 467       case Beta_flag:
 468         {
 469           if (check_float(linetoken3))
 470             token3 >> token_value;
 471           else
 472             uiuc_warnings_errors(1, *command_line);
 473
 474           Beta_init_true = true;
 475           Beta_init = token_value * DEG_TO_RAD;
 476           break;
 477         }
 478       case U_body_flag:
 479         {
 480           if (check_float(linetoken3))
 481             token3 >> token_value;
 482           else
 483             uiuc_warnings_errors(1, *command_line);
 484
 485           U_body_init_true = true;
 486           U_body_init = token_value;
 487           break;
 488         }
 489       case V_body_flag:
 490         {
 491           if (check_float(linetoken3))
 492             token3 >> token_value;
 493           else
 494             uiuc_warnings_errors(1, *command_line);
 495
 496           V_body_init_true = true;
 497           V_body_init = token_value;
 498           break;
 499         }
 500       case W_body_flag:
 501         {
 502           if (check_float(linetoken3))
 503             token3 >> token_value;
 504           else
 505             uiuc_warnings_errors(1, *command_line);
 506
 507           W_body_init_true = true;
 508           W_body_init = token_value;
 509           break;
 510         }
 511       case ignore_unknown_flag:
 512         {
 513           dont_ignore=false;
 514           break;
 515         }
 516       default:
 517         {
 518           if (dont_ignore)
 519             uiuc_warnings_errors(2, *command_line);
 520           break;
 521         }
 522       };
 523 }
 524
 525 void parse_geometry( const string& linetoken2, const string& linetoken3,
 526                  LIST command_line ) {
 527     double token_value;
 528     istrstream token3(linetoken3.c_str());
 529
 530     switch(geometry_map[linetoken2])
 531       {
 532       case bw_flag:
 533         {
 534           if (check_float(linetoken3))
 535             token3 >> token_value;
 536           else
 537             uiuc_warnings_errors(1, *command_line);
 538
 539           bw = token_value;
 540           geometryParts -> storeCommands (*command_line);
 541           break;
 542         }
 543       case cbar_flag:
 544         {
 545           if (check_float(linetoken3))
 546             token3 >> token_value;
 547           else
 548             uiuc_warnings_errors(1, *command_line);
 549
 550           cbar = token_value;
 551           geometryParts -> storeCommands (*command_line);
 552           break;
 553         }
 554       case Sw_flag:
 555         {
 556           if (check_float(linetoken3))
 557             token3 >> token_value;
 558           else
 559             uiuc_warnings_errors(1, *command_line);
 560
 561           Sw = token_value;
 562           geometryParts -> storeCommands (*command_line);
 563           break;
 564         }
 565       case ih_flag:
 566         {
 567           if (check_float(linetoken3))
 568             token3 >> token_value;
 569           else
 570             uiuc_warnings_errors(1, *command_line);
 571
 572           ih = token_value;
 573           geometryParts -> storeCommands (*command_line);
 574           break;
 575         }
 576       case bh_flag:
 577         {
 578           if (check_float(linetoken3))
 579             token3 >> token_value;
 580           else
 581             uiuc_warnings_errors(1, *command_line);
 582
 583           bh = token_value;
 584           geometryParts -> storeCommands (*command_line);
 585           break;
 586         }
 587       case ch_flag:
 588         {
 589           if (check_float(linetoken3))
 590             token3 >> token_value;
 591           else
 592             uiuc_warnings_errors(1, *command_line);
 593
 594           ch = token_value;
 595           geometryParts -> storeCommands (*command_line);
 596           break;
 597         }
 598       case Sh_flag:
 599         {
 600           if (check_float(linetoken3))
 601             token3 >> token_value;
 602           else
 603             uiuc_warnings_errors(1, *command_line);
 604
 605           Sh = token_value;
 606           geometryParts -> storeCommands (*command_line);
 607           break;
 608         }
 609       default:
 610         {
 611           if (dont_ignore)
 612             uiuc_warnings_errors(2, *command_line);
 613           break;
 614         }
 615       };
 616 }
 617
 618 void parse_controlSurface( const string& linetoken2, const string& linetoken3,
 619                            const string& linetoken4, const string& linetoken5,
 620                            const string& linetoken6,
 621                            const string& aircraft_directory,
 622                            LIST command_line ) {
 623     double token_value;
 624     int token_value_convert1, token_value_convert2;
 625     istrstream token3(linetoken3.c_str());
 626     istrstream token4(linetoken4.c_str());
 627     istrstream token5(linetoken5.c_str());
 628     istrstream token6(linetoken6.c_str());
 629
 630     switch(controlSurface_map[linetoken2])
 631       {
 632       case de_flag:
 633         {
 634           if (check_float(linetoken3))
 635             token3 >> token_value;
 636           else
 637             uiuc_warnings_errors(1, *command_line);
 638
 639           demax = token_value;
 640
 641           if (check_float(linetoken4))
 642             token4 >> token_value;
 643           else
 644             uiuc_warnings_errors(1, *command_line);
 645
 646           demin = token_value;
 647           break;
 648         }
 649       case da_flag:
 650         {
 651           if (check_float(linetoken3))
 652             token3 >> token_value;
 653           else
 654             uiuc_warnings_errors(1, *command_line);
 655
 656           damax = token_value;
 657
 658           if (check_float(linetoken4))
 659             token4 >> token_value;
 660           else
 661             uiuc_warnings_errors(1, *command_line);
 662
 663           damin = token_value;
 664           break;
 665         }
 666       case dr_flag:
 667         {
 668           if (check_float(linetoken3))
 669             token3 >> token_value;
 670           else
 671             uiuc_warnings_errors(1, *command_line);
 672
 673           drmax = token_value;
 674
 675           if (check_float(linetoken4))
 676             token4 >> token_value;
 677           else
 678             uiuc_warnings_errors(1, *command_line);
 679
 680           drmin = token_value;
 681           break;
 682         }
 683       case set_Long_trim_flag:
 684         {
 685           if (check_float(linetoken3))
 686             token3 >> token_value;
 687           else
 688             uiuc_warnings_errors(1, *command_line);
 689
 690           set_Long_trim = true;
 691           elevator_tab = token_value;
 692           break;
 693         }
 694       case set_Long_trim_deg_flag:
 695         {
 696           if (check_float(linetoken3))
 697             token3 >> token_value;
 698           else
 699             uiuc_warnings_errors(1, *command_line);
 700
 701           set_Long_trim = true;
 702           elevator_tab = token_value * DEG_TO_RAD;
 703           break;
 704         }
 705       case zero_Long_trim_flag:
 706         {
 707           zero_Long_trim = true;
 708           break;
 709         }
 710       case elevator_step_flag:
 711         {
 712           // set step input flag
 713           elevator_step = true;
 714
 715           // read in step angle in degrees and convert
 716           if (check_float(linetoken3))
 717             token3 >> token_value;
 718           else
 719             uiuc_warnings_errors(1, *command_line);
 720
 721           elevator_step_angle = token_value * DEG_TO_RAD;
 722
 723           // read in step start time
 724           if (check_float(linetoken4))
 725             token4 >> token_value;
 726           else
 727             uiuc_warnings_errors(1, *command_line);
 728
 729           elevator_step_startTime = token_value;
 730           break;
 731         }
 732       case elevator_singlet_flag:
 733         {
 734           // set singlet input flag
 735           elevator_singlet = true;
 736
 737           // read in singlet angle in degrees and convert
 738           if (check_float(linetoken3))
 739             token3 >> token_value;
 740           else
 741             uiuc_warnings_errors(1, *command_line);
 742
 743           elevator_singlet_angle = token_value * DEG_TO_RAD;
 744
 745           // read in singlet start time
 746           if (check_float(linetoken4))
 747             token4 >> token_value;
 748           else
 749             uiuc_warnings_errors(1, *command_line);
 750
 751           elevator_singlet_startTime = token_value;
 752
 753           // read in singlet duration
 754           if (check_float(linetoken5))
 755             token5 >> token_value;
 756           else
 757             uiuc_warnings_errors(1, *command_line);
 758
 759           elevator_singlet_duration = token_value;
 760           break;
 761         }
 762       case elevator_doublet_flag:
 763         {
 764           // set doublet input flag
 765           elevator_doublet = true;
 766
 767           // read in doublet angle in degrees and convert
 768           if (check_float(linetoken3))
 769             token3 >> token_value;
 770           else
 771             uiuc_warnings_errors(1, *command_line);
 772
 773           elevator_doublet_angle = token_value * DEG_TO_RAD;
 774
 775           // read in doublet start time
 776           if (check_float(linetoken4))
 777             token4 >> token_value;
 778           else
 779             uiuc_warnings_errors(1, *command_line);
 780
 781           elevator_doublet_startTime = token_value;
 782
 783           // read in doublet duration
 784           if (check_float(linetoken5))
 785             token5 >> token_value;
 786           else
 787             uiuc_warnings_errors(1, *command_line);
 788
 789           elevator_doublet_duration = token_value;
 790           break;
 791         }
 792       case elevator_input_flag:
 793         {
 794           elevator_input = true;
 795           elevator_input_file = aircraft_directory + linetoken3;
 796           token4 >> token_value_convert1;
 797           token5 >> token_value_convert2;
 798           convert_y = uiuc_convert(token_value_convert1);
 799           convert_x = uiuc_convert(token_value_convert2);
 800           uiuc_1DdataFileReader(elevator_input_file,
 801                                 elevator_input_timeArray,
 802                                 elevator_input_deArray,
 803                                 elevator_input_ntime);
 804           token6 >> token_value;
 805           elevator_input_startTime = token_value;
 806           break;
 807         }
 808       case aileron_input_flag:
 809         {
 810           aileron_input = true;
 811           aileron_input_file = aircraft_directory + linetoken3;
 812           token4 >> token_value_convert1;
 813           token5 >> token_value_convert2;
 814           convert_y = uiuc_convert(token_value_convert1);
 815           convert_x = uiuc_convert(token_value_convert2);
 816           uiuc_1DdataFileReader(aileron_input_file,
 817                                 aileron_input_timeArray,
 818                                 aileron_input_daArray,
 819                                 aileron_input_ntime);
 820           token6 >> token_value;
 821           aileron_input_startTime = token_value;
 822           break;
 823         }
 824       case rudder_input_flag:
 825         {
 826           rudder_input = true;
 827           rudder_input_file = aircraft_directory + linetoken3;
 828           token4 >> token_value_convert1;
 829           token5 >> token_value_convert2;
 830           convert_y = uiuc_convert(token_value_convert1);
 831           convert_x = uiuc_convert(token_value_convert2);
 832           uiuc_1DdataFileReader(rudder_input_file,
 833                                 rudder_input_timeArray,
 834                                 rudder_input_drArray,
 835                                 rudder_input_ntime);
 836           token6 >> token_value;
 837           rudder_input_startTime = token_value;
 838           break;
 839         }
 840       case pilot_elev_no_flag:
 841         {
 842           pilot_elev_no_check = true;
 843           break;
 844         }
 845       case pilot_ail_no_flag:
 846         {
 847           pilot_ail_no_check = true;
 848           break;
 849         }
 850       case pilot_rud_no_flag:
 851         {
 852           pilot_rud_no_check = true;
 853           break;
 854         }
 855       case flap_max_flag:
 856         {
 857           if (check_float(linetoken3))
 858             token3 >> token_value;
 859           else
 860             uiuc_warnings_errors(1, *command_line);
 861
 862           flap_max = token_value;
 863           break;
 864         }
 865       case flap_rate_flag:
 866         {
 867           if (check_float(linetoken3))
 868             token3 >> token_value;
 869           else
 870             uiuc_warnings_errors(1, *command_line);
 871
 872           flap_rate = token_value;
 873           break;
 874         }
 875       default:
 876         {
 877           if (dont_ignore)
 878             uiuc_warnings_errors(2, *command_line);
 879           break;
 880         }
 881       };
 882 }
 883
 884 void parse_mass( const string& linetoken2, const string& linetoken3,
 885                  LIST command_line ) {
 886     double token_value;
 887     istrstream token3(linetoken3.c_str());
 888
 889     switch(mass_map[linetoken2])
 890       {
 891       case Weight_flag:
 892         {
 893           if (check_float(linetoken3))
 894             token3 >> token_value;
 895           else
 896             uiuc_warnings_errors(1, *command_line);
 897
 898           Weight = token_value;
 899           Mass = Weight * INVG;
 900           massParts -> storeCommands (*command_line);
 901           break;
 902         }
 903       case Mass_flag:
 904         {
 905           if (check_float(linetoken3))
 906             token3 >> token_value;
 907           else
 908             uiuc_warnings_errors(1, *command_line);
 909
 910           Mass = token_value;
 911           massParts -> storeCommands (*command_line);
 912           break;
 913         }
 914       case I_xx_flag:
 915         {
 916           if (check_float(linetoken3))
 917             token3 >> token_value;
 918           else
 919             uiuc_warnings_errors(1, *command_line);
 920
 921           I_xx = token_value;
 922           massParts -> storeCommands (*command_line);
 923           break;
 924         }
 925       case I_yy_flag:
 926         {
 927           if (check_float(linetoken3))
 928             token3 >> token_value;
 929           else
 930             uiuc_warnings_errors(1, *command_line);
 931
 932           I_yy = token_value;
 933           massParts -> storeCommands (*command_line);
 934           break;
 935         }
 936       case I_zz_flag:
 937         {
 938           if (check_float(linetoken3))
 939             token3 >> token_value;
 940           else
 941             uiuc_warnings_errors(1, *command_line);
 942
 943           I_zz = token_value;
 944           massParts -> storeCommands (*command_line);
 945           break;
 946         }
 947       case I_xz_flag:
 948         {
 949           if (check_float(linetoken3))
 950             token3 >> token_value;
 951           else
 952             uiuc_warnings_errors(1, *command_line);
 953
 954           I_xz = token_value;
 955           massParts -> storeCommands (*command_line);
 956           break;
 957         }
 958       case Mass_appMass_ratio_flag:
 959         {
 960           if (check_float(linetoken3))
 961             token3 >> token_value;
 962           else
 963             uiuc_warnings_errors(1, *command_line);
 964
 965           Mass_appMass_ratio = token_value;
 966           massParts -> storeCommands (*command_line);
 967           break;
 968         }
 969       case I_xx_appMass_ratio_flag:
 970         {
 971           if (check_float(linetoken3))
 972             token3 >> token_value;
 973           else
 974             uiuc_warnings_errors(1, *command_line);
 975
 976           I_xx_appMass_ratio = token_value;
 977           massParts -> storeCommands (*command_line);
 978           break;
 979         }
 980       case I_yy_appMass_ratio_flag:
 981         {
 982           if (check_float(linetoken3))
 983             token3 >> token_value;
 984           else
 985             uiuc_warnings_errors(1, *command_line);
 986
 987           I_yy_appMass_ratio = token_value;
 988           massParts -> storeCommands (*command_line);
 989           break;
 990         }
 991       case I_zz_appMass_ratio_flag:
 992         {
 993           if (check_float(linetoken3))
 994             token3 >> token_value;
 995           else
 996             uiuc_warnings_errors(1, *command_line);
 997
 998           I_zz_appMass_ratio = token_value;
 999           massParts -> storeCommands (*command_line);
1000           break;
1001         }
1002       case Mass_appMass_flag:
1003         {
1004           if (check_float(linetoken3))
1005             token3 >> token_value;
1006           else
1007             uiuc_warnings_errors(1, *command_line);
1008
1009           Mass_appMass = token_value;
1010           massParts -> storeCommands (*command_line);
1011           break;
1012         }
1013       case I_xx_appMass_flag:
1014         {
1015           if (check_float(linetoken3))
1016             token3 >> token_value;
1017           else
1018             uiuc_warnings_errors(1, *command_line);
1019
1020           I_xx_appMass = token_value;
1021           massParts -> storeCommands (*command_line);
1022           break;
1023         }
1024       case I_yy_appMass_flag:
1025         {
1026           if (check_float(linetoken3))
1027             token3 >> token_value;
1028           else
1029             uiuc_warnings_errors(1, *command_line);
1030
1031           I_yy_appMass = token_value;
1032           massParts -> storeCommands (*command_line);
1033           break;
1034         }
1035       case I_zz_appMass_flag:
1036         {
1037           if (check_float(linetoken3))
1038             token3 >> token_value;
1039           else
1040             uiuc_warnings_errors(1, *command_line);
1041
1042           I_zz_appMass = token_value;
1043           massParts -> storeCommands (*command_line);
1044           break;
1045         }
1046       default:
1047         {
1048           if (dont_ignore)
1049             uiuc_warnings_errors(2, *command_line);
1050           break;
1051         }
1052       };
1053 }
1054
1055 void parse_engine( const string& linetoken2, const string& linetoken3,
1056                    const string& linetoken4, const string& linetoken5,
1057                    const string& linetoken6, const string& aircraft_directory,
1058                    LIST command_line ) {
1059     double token_value;
1060     int token_value_convert1, token_value_convert2;
1061     istrstream token3(linetoken3.c_str());
1062     istrstream token4(linetoken4.c_str());
1063     istrstream token5(linetoken5.c_str());
1064     istrstream token6(linetoken6.c_str());
1065
1066     switch(engine_map[linetoken2])
1067       {
1068       case simpleSingle_flag:
1069         {
1070           if (check_float(linetoken3))
1071             token3 >> token_value;
1072           else
1073             uiuc_warnings_errors(1, *command_line);
1074
1075           simpleSingleMaxThrust = token_value;
1076           engineParts -> storeCommands (*command_line);
1077           break;
1078         }
1079       case c172_flag:
1080         {
1081           engineParts -> storeCommands (*command_line);
1082           break;
1083         }
1084       case cherokee_flag:
1085         {
1086           engineParts -> storeCommands (*command_line);
1087           break;
1088         }
1089       case Throttle_pct_input_flag:
1090         {
1091           Throttle_pct_input = true;
1092           Throttle_pct_input_file = aircraft_directory + linetoken3;
1093           token4 >> token_value_convert1;
1094           token5 >> token_value_convert2;
1095           convert_y = uiuc_convert(token_value_convert1);
1096           convert_x = uiuc_convert(token_value_convert2);
1097           uiuc_1DdataFileReader(Throttle_pct_input_file,
1098                                 Throttle_pct_input_timeArray,
1099                                 Throttle_pct_input_dTArray,
1100                                 Throttle_pct_input_ntime);
1101           token6 >> token_value;
1102           Throttle_pct_input_startTime = token_value;
1103           break;
1104         }
1105       case forcemom_flag:
1106         {
1107           engineParts -> storeCommands (*command_line);
1108           break;
1109         }
1110       case Xp_input_flag:
1111         {
1112           Xp_input = true;
1113           Xp_input_file = aircraft_directory + linetoken3;
1114           token4 >> token_value_convert1;
1115           token5 >> token_value_convert2;
1116           convert_y = uiuc_convert(token_value_convert1);
1117           convert_x = uiuc_convert(token_value_convert2);
1118           uiuc_1DdataFileReader(Xp_input_file,
1119                                 Xp_input_timeArray,
1120                                 Xp_input_XpArray,
1121                                 Xp_input_ntime);
1122           token6 >> token_value;
1123           Xp_input_startTime = token_value;
1124           break;
1125         }
1126       case Zp_input_flag:
1127         {
1128           Zp_input = true;
1129           Zp_input_file = aircraft_directory + linetoken3;
1130           token4 >> token_value_convert1;
1131           token5 >> token_value_convert2;
1132           convert_y = uiuc_convert(token_value_convert1);
1133           convert_x = uiuc_convert(token_value_convert2);
1134           uiuc_1DdataFileReader(Zp_input_file,
1135                                 Zp_input_timeArray,
1136                                 Zp_input_ZpArray,
1137                                 Zp_input_ntime);
1138           token6 >> token_value;
1139           Zp_input_startTime = token_value;
1140           break;
1141         }
1142       case Mp_input_flag:
1143         {
1144           Mp_input = true;
1145           Mp_input_file = aircraft_directory + linetoken3;
1146           token4 >> token_value_convert1;
1147           token5 >> token_value_convert2;
1148           convert_y = uiuc_convert(token_value_convert1);
1149           convert_x = uiuc_convert(token_value_convert2);
1150           uiuc_1DdataFileReader(Mp_input_file,
1151                                 Mp_input_timeArray,
1152                                 Mp_input_MpArray,
1153                                 Mp_input_ntime);
1154           token6 >> token_value;
1155           Mp_input_startTime = token_value;
1156           break;
1157         }
1158       default:
1159         {
1160           if (dont_ignore)
1161             uiuc_warnings_errors(2, *command_line);
1162           break;
1163         }
1164       };
1165 }
1166
1167 void parse_CD( const string& linetoken2, const string& linetoken3,
1168                const string& linetoken4, const string& linetoken5,
1169                const string& linetoken6, const string& linetoken7,
1170                const string& linetoken8, const string& linetoken9,
1171                const string& aircraft_directory,
1172                bool &CXfabetaf_first, bool &CXfadef_first,
1173                bool &CXfaqf_first, LIST command_line ) {
1174     double token_value;
1175     int token_value_convert1, token_value_convert2, token_value_convert3;
1176     double datafile_xArray[100][100], datafile_yArray[100];
1177     double datafile_zArray[100][100];
1178     int datafile_nxArray[100], datafile_ny;
1179     istrstream token3(linetoken3.c_str());
1180     istrstream token4(linetoken4.c_str());
1181     istrstream token5(linetoken5.c_str());
1182     istrstream token6(linetoken6.c_str());
1183     istrstream token7(linetoken7.c_str());
1184     istrstream token8(linetoken8.c_str());
1185     istrstream token9(linetoken9.c_str());
1186
1187     switch(CD_map[linetoken2])
1188       {
1189       case CDo_flag:
1190         {
1191           if (check_float(linetoken3))
1192             token3 >> token_value;
1193           else
1194             uiuc_warnings_errors(1, *command_line);
1195
1196           CDo = token_value;
1197           CDo_clean = CDo;
1198           aeroDragParts -> storeCommands (*command_line);
1199           break;
1200         }
1201       case CDK_flag:
1202         {
1203           if (check_float(linetoken3))
1204             token3 >> token_value;
1205           else
1206             uiuc_warnings_errors(1, *command_line);
1207
1208           CDK = token_value;
1209           CDK_clean = CDK;
1210           aeroDragParts -> storeCommands (*command_line);
1211           break;
1212         }
1213       case CD_a_flag:
1214         {
1215           if (check_float(linetoken3))
1216             token3 >> token_value;
1217           else
1218             uiuc_warnings_errors(1, *command_line);
1219
1220           CD_a = token_value;
1221           CD_a_clean = CD_a;
1222           aeroDragParts -> storeCommands (*command_line);
1223           break;
1224         }
1225       case CD_adot_flag:
1226         {
1227           if (check_float(linetoken3))
1228             token3 >> token_value;
1229           else
1230             uiuc_warnings_errors(1, *command_line);
1231
1232           CD_adot = token_value;
1233           CD_adot_clean = CD_adot;
1234           aeroDragParts -> storeCommands (*command_line);
1235           break;
1236         }
1237       case CD_q_flag:
1238         {
1239           if (check_float(linetoken3))
1240             token3 >> token_value;
1241           else
1242             uiuc_warnings_errors(1, *command_line);
1243
1244           CD_q = token_value;
1245           CD_q_clean = CD_q;
1246           aeroDragParts -> storeCommands (*command_line);
1247           break;
1248         }
1249       case CD_ih_flag:
1250         {
1251           if (check_float(linetoken3))
1252             token3 >> token_value;
1253           else
1254             uiuc_warnings_errors(1, *command_line);
1255
1256           CD_ih = token_value;
1257           aeroDragParts -> storeCommands (*command_line);
1258           break;
1259         }
1260       case CD_de_flag:
1261         {
1262           if (check_float(linetoken3))
1263             token3 >> token_value;
1264           else
1265             uiuc_warnings_errors(1, *command_line);
1266
1267           CD_de = token_value;
1268           CD_de_clean = CD_de;
1269           aeroDragParts -> storeCommands (*command_line);
1270           break;
1271         }
1272       case CDfa_flag:
1273         {
1274           CDfa = aircraft_directory + linetoken3;
1275           token4 >> token_value_convert1;
1276           token5 >> token_value_convert2;
1277           convert_y = uiuc_convert(token_value_convert1);
1278           convert_x = uiuc_convert(token_value_convert2);
1279           /* call 1D File Reader with file name (CDfa) and conversion
1280              factors; function returns array of alphas (aArray) and
1281              corresponding CD values (CDArray) and max number of
1282              terms in arrays (nAlpha) */
1283           uiuc_1DdataFileReader(CDfa,
1284                                 CDfa_aArray,
1285                                 CDfa_CDArray,
1286                                 CDfa_nAlpha);
1287           aeroDragParts -> storeCommands (*command_line);
1288           break;
1289         }
1290       case CDfCL_flag:
1291         {
1292           CDfCL = aircraft_directory + linetoken3;
1293           token4 >> token_value_convert1;
1294           token5 >> token_value_convert2;
1295           convert_y = uiuc_convert(token_value_convert1);
1296           convert_x = uiuc_convert(token_value_convert2);
1297           /* call 1D File Reader with file name (CDfCL) and conversion
1298              factors; function returns array of CLs (CLArray) and
1299              corresponding CD values (CDArray) and max number of
1300              terms in arrays (nCL) */
1301           uiuc_1DdataFileReader(CDfCL,
1302                                 CDfCL_CLArray,
1303                                 CDfCL_CDArray,
1304                                 CDfCL_nCL);
1305           aeroDragParts -> storeCommands (*command_line);
1306           break;
1307         }
1308       case CDfade_flag:
1309         {
1310           CDfade = aircraft_directory + linetoken3;
1311           token4 >> token_value_convert1;
1312           token5 >> token_value_convert2;
1313           token6 >> token_value_convert3;
1314           convert_z = uiuc_convert(token_value_convert1);
1315           convert_x = uiuc_convert(token_value_convert2);
1316           convert_y = uiuc_convert(token_value_convert3);
1317           /* call 2D File Reader with file name (CDfade) and
1318              conversion factors; function returns array of
1319              elevator deflections (deArray) and corresponding
1320              alpha (aArray) and delta CD (CDArray) values and
1321              max number of terms in alpha arrays (nAlphaArray)
1322              and deflection array (nde) */
1323           uiuc_2DdataFileReader(CDfade,
1324                                 CDfade_aArray,
1325                                 CDfade_deArray,
1326                                 CDfade_CDArray,
1327                                 CDfade_nAlphaArray,
1328                                 CDfade_nde);
1329           aeroDragParts -> storeCommands (*command_line);
1330           break;
1331         }
1332       case CDfdf_flag:
1333         {
1334           CDfdf = aircraft_directory + linetoken3;
1335           token4 >> token_value_convert1;
1336           token5 >> token_value_convert2;
1337           convert_y = uiuc_convert(token_value_convert1);
1338           convert_x = uiuc_convert(token_value_convert2);
1339           /* call 1D File Reader with file name (CDfdf) and conversion
1340              factors; function returns array of dfs (dfArray) and
1341              corresponding CD values (CDArray) and max number of
1342              terms in arrays (ndf) */
1343           uiuc_1DdataFileReader(CDfdf,
1344                                 CDfdf_dfArray,
1345                                 CDfdf_CDArray,
1346                                 CDfdf_ndf);
1347           aeroDragParts -> storeCommands (*command_line);
1348           break;
1349         }
1350       case CDfadf_flag:
1351         {
1352           CDfadf = aircraft_directory + linetoken3;
1353           token4 >> token_value_convert1;
1354           token5 >> token_value_convert2;
1355           token6 >> token_value_convert3;
1356           convert_z = uiuc_convert(token_value_convert1);
1357           convert_x = uiuc_convert(token_value_convert2);
1358           convert_y = uiuc_convert(token_value_convert3);
1359           /* call 2D File Reader with file name (CDfadf) and
1360              conversion factors; function returns array of
1361              flap deflections (dfArray) and corresponding
1362              alpha (aArray) and delta CD (CDArray) values and
1363              max number of terms in alpha arrays (nAlphaArray)
1364              and deflection array (ndf) */
1365           uiuc_2DdataFileReader(CDfadf,
1366                                 CDfadf_aArray,
1367                                 CDfadf_dfArray,
1368                                 CDfadf_CDArray,
1369                                 CDfadf_nAlphaArray,
1370                                 CDfadf_ndf);
1371           aeroDragParts -> storeCommands (*command_line);
1372           break;
1373         }
1374       case CXo_flag:
1375         {
1376           if (check_float(linetoken3))
1377             token3 >> token_value;
1378           else
1379             uiuc_warnings_errors(1, *command_line);
1380
1381           CXo = token_value;
1382           CXo_clean = CXo;
1383           aeroDragParts -> storeCommands (*command_line);
1384           break;
1385         }
1386       case CXK_flag:
1387         {
1388           if (check_float(linetoken3))
1389             token3 >> token_value;
1390           else
1391             uiuc_warnings_errors(1, *command_line);
1392
1393           CXK = token_value;
1394           CXK_clean = CXK;
1395           aeroDragParts -> storeCommands (*command_line);
1396           break;
1397         }
1398       case CX_a_flag:
1399         {
1400           if (check_float(linetoken3))
1401             token3 >> token_value;
1402           else
1403             uiuc_warnings_errors(1, *command_line);
1404
1405           CX_a = token_value;
1406           CX_a_clean = CX_a;
1407           aeroDragParts -> storeCommands (*command_line);
1408           break;
1409         }
1410       case CX_a2_flag:
1411         {
1412           if (check_float(linetoken3))
1413             token3 >> token_value;
1414           else
1415             uiuc_warnings_errors(1, *command_line);
1416
1417           CX_a2 = token_value;
1418           CX_a2_clean = CX_a2;
1419           aeroDragParts -> storeCommands (*command_line);
1420           break;
1421         }
1422       case CX_a3_flag:
1423         {
1424           if (check_float(linetoken3))
1425             token3 >> token_value;
1426           else
1427             uiuc_warnings_errors(1, *command_line);
1428
1429           CX_a3 = token_value;
1430           CX_a3_clean = CX_a3;
1431           aeroDragParts -> storeCommands (*command_line);
1432           break;
1433         }
1434       case CX_adot_flag:
1435         {
1436           if (check_float(linetoken3))
1437             token3 >> token_value;
1438           else
1439             uiuc_warnings_errors(1, *command_line);
1440
1441           CX_adot = token_value;
1442           CX_adot_clean = CX_adot;
1443           aeroDragParts -> storeCommands (*command_line);
1444           break;
1445         }
1446       case CX_q_flag:
1447         {
1448           if (check_float(linetoken3))
1449             token3 >> token_value;
1450           else
1451             uiuc_warnings_errors(1, *command_line);
1452
1453           CX_q = token_value;
1454           CX_q_clean = CX_q;
1455           aeroDragParts -> storeCommands (*command_line);
1456           break;
1457         }
1458       case CX_de_flag:
1459         {
1460           if (check_float(linetoken3))
1461             token3 >> token_value;
1462           else
1463             uiuc_warnings_errors(1, *command_line);
1464
1465           CX_de = token_value;
1466           CX_de_clean = CX_de;
1467           aeroDragParts -> storeCommands (*command_line);
1468           break;
1469         }
1470       case CX_dr_flag:
1471         {
1472           if (check_float(linetoken3))
1473             token3 >> token_value;
1474           else
1475             uiuc_warnings_errors(1, *command_line);
1476
1477           CX_dr = token_value;
1478           CX_dr_clean = CX_dr;
1479           aeroDragParts -> storeCommands (*command_line);
1480           break;
1481         }
1482       case CX_df_flag:
1483         {
1484           if (check_float(linetoken3))
1485             token3 >> token_value;
1486           else
1487             uiuc_warnings_errors(1, *command_line);
1488
1489           CX_df = token_value;
1490           CX_df_clean = CX_df;
1491           aeroDragParts -> storeCommands (*command_line);
1492           break;
1493         }
1494       case CX_adf_flag:
1495         {
1496           if (check_float(linetoken3))
1497             token3 >> token_value;
1498           else
1499             uiuc_warnings_errors(1, *command_line);
1500
1501           CX_adf = token_value;
1502           CX_adf_clean = CX_adf;
1503           aeroDragParts -> storeCommands (*command_line);
1504           break;
1505         }
1506       case CXfabetaf_flag:
1507         {
1508           int CXfabetaf_index, i;
1509           string CXfabetaf_file;
1510           double flap_value;
1511           CXfabetaf_file = aircraft_directory + linetoken3;
1512           token4 >> CXfabetaf_index;
1513           if (CXfabetaf_index < 1 || CXfabetaf_index >= 30)
1514             uiuc_warnings_errors(1, *command_line);
1515           if (CXfabetaf_index > CXfabetaf_nf)
1516             CXfabetaf_nf = CXfabetaf_index;
1517           token5 >> flap_value;
1518           CXfabetaf_fArray[CXfabetaf_index] = flap_value;
1519           token6 >> token_value_convert1;
1520           token7 >> token_value_convert2;
1521           token8 >> token_value_convert3;
1522           token9 >> CXfabetaf_nice;
1523           convert_z = uiuc_convert(token_value_convert1);
1524           convert_x = uiuc_convert(token_value_convert2);
1525           convert_y = uiuc_convert(token_value_convert3);
1526           /* call 2D File Reader with file name (CXfabetaf_file) and
1527              conversion factors; function returns array of
1528              elevator deflections (deArray) and corresponding
1529              alpha (aArray) and delta CZ (CZArray) values and
1530              max number of terms in alpha arrays (nAlphaArray)
1531              and delfection array (nde) */
1532           uiuc_2DdataFileReader(CXfabetaf_file,
1533                                 datafile_xArray,
1534                                 datafile_yArray,
1535                                 datafile_zArray,
1536                                 datafile_nxArray,
1537                                 datafile_ny);
1538           d_2_to_3(datafile_xArray, CXfabetaf_aArray, CXfabetaf_index);
1539           d_1_to_2(datafile_yArray, CXfabetaf_betaArray, CXfabetaf_index);
1540           d_2_to_3(datafile_zArray, CXfabetaf_CXArray, CXfabetaf_index);
1541           i_1_to_2(datafile_nxArray, CXfabetaf_nAlphaArray, CXfabetaf_index);
1542           CXfabetaf_nbeta[CXfabetaf_index] = datafile_ny;
1543           if (CXfabetaf_first==true)
1544             {
1545               if (CXfabetaf_nice == 1)
1546                 {
1547                   CXfabetaf_na_nice = datafile_nxArray[1];
1548                   CXfabetaf_nb_nice = datafile_ny;
1549                   d_1_to_1(datafile_yArray, CXfabetaf_bArray_nice);
1550                   for (i=1; i<=CXfabetaf_na_nice; i++)
1551                     CXfabetaf_aArray_nice[i] = datafile_xArray[1][i];
1552                 }
1553               aeroDragParts -> storeCommands (*command_line);
1554               CXfabetaf_first=false;
1555             }
1556           break;
1557         }
1558       case CXfadef_flag:
1559         {
1560           int CXfadef_index, i;
1561           string CXfadef_file;
1562           double flap_value;
1563           CXfadef_file = aircraft_directory + linetoken3;
1564           token4 >> CXfadef_index;
1565           if (CXfadef_index < 0 || CXfadef_index >= 30)
1566             uiuc_warnings_errors(1, *command_line);
1567           if (CXfadef_index > CXfadef_nf)
1568             CXfadef_nf = CXfadef_index;
1569           token5 >> flap_value;
1570           CXfadef_fArray[CXfadef_index] = flap_value;
1571           token6 >> token_value_convert1;
1572           token7 >> token_value_convert2;
1573           token8 >> token_value_convert3;
1574           token9 >> CXfadef_nice;
1575           convert_z = uiuc_convert(token_value_convert1);
1576           convert_x = uiuc_convert(token_value_convert2);
1577           convert_y = uiuc_convert(token_value_convert3);
1578           /* call 2D File Reader with file name (CXfadef_file) and
1579              conversion factors; function returns array of
1580              elevator deflections (deArray) and corresponding
1581              alpha (aArray) and delta CZ (CZArray) values and
1582              max number of terms in alpha arrays (nAlphaArray)
1583              and delfection array (nde) */
1584           uiuc_2DdataFileReader(CXfadef_file,
1585                                 datafile_xArray,
1586                                 datafile_yArray,
1587                                 datafile_zArray,
1588                                 datafile_nxArray,
1589                                 datafile_ny);
1590           d_2_to_3(datafile_xArray, CXfadef_aArray, CXfadef_index);
1591           d_1_to_2(datafile_yArray, CXfadef_deArray, CXfadef_index);
1592           d_2_to_3(datafile_zArray, CXfadef_CXArray, CXfadef_index);
1593           i_1_to_2(datafile_nxArray, CXfadef_nAlphaArray, CXfadef_index);
1594           CXfadef_nde[CXfadef_index] = datafile_ny;
1595           if (CXfadef_first==true)
1596             {
1597               if (CXfadef_nice == 1)
1598                 {
1599                   CXfadef_na_nice = datafile_nxArray[1];
1600                   CXfadef_nde_nice = datafile_ny;
1601                   d_1_to_1(datafile_yArray, CXfadef_deArray_nice);
1602                   for (i=1; i<=CXfadef_na_nice; i++)
1603                     CXfadef_aArray_nice[i] = datafile_xArray[1][i];
1604                 }
1605               aeroDragParts -> storeCommands (*command_line);
1606               CXfadef_first=false;
1607             }
1608           break;
1609         }
1610       case CXfaqf_flag:
1611         {
1612           int CXfaqf_index, i;
1613           string CXfaqf_file;
1614           double flap_value;
1615           CXfaqf_file = aircraft_directory + linetoken3;
1616           token4 >> CXfaqf_index;
1617           if (CXfaqf_index < 0 || CXfaqf_index >= 30)
1618             uiuc_warnings_errors(1, *command_line);
1619           if (CXfaqf_index > CXfaqf_nf)
1620             CXfaqf_nf = CXfaqf_index;
1621           token5 >> flap_value;
1622           CXfaqf_fArray[CXfaqf_index] = flap_value;
1623           token6 >> token_value_convert1;
1624           token7 >> token_value_convert2;
1625           token8 >> token_value_convert3;
1626           token9 >> CXfaqf_nice;
1627           convert_z = uiuc_convert(token_value_convert1);
1628           convert_x = uiuc_convert(token_value_convert2);
1629           convert_y = uiuc_convert(token_value_convert3);
1630           /* call 2D File Reader with file name (CXfaqf_file) and
1631              conversion factors; function returns array of
1632              elevator deflections (deArray) and corresponding
1633              alpha (aArray) and delta CZ (CZArray) values and
1634              max number of terms in alpha arrays (nAlphaArray)
1635              and delfection array (nde) */
1636           uiuc_2DdataFileReader(CXfaqf_file,
1637                                 datafile_xArray,
1638                                 datafile_yArray,
1639                                 datafile_zArray,
1640                                 datafile_nxArray,
1641                                 datafile_ny);
1642           d_2_to_3(datafile_xArray, CXfaqf_aArray, CXfaqf_index);
1643           d_1_to_2(datafile_yArray, CXfaqf_qArray, CXfaqf_index);
1644           d_2_to_3(datafile_zArray, CXfaqf_CXArray, CXfaqf_index);
1645           i_1_to_2(datafile_nxArray, CXfaqf_nAlphaArray, CXfaqf_index);
1646           CXfaqf_nq[CXfaqf_index] = datafile_ny;
1647           if (CXfaqf_first==true)
1648             {
1649               if (CXfaqf_nice == 1)
1650                 {
1651                   CXfaqf_na_nice = datafile_nxArray[1];
1652                   CXfaqf_nq_nice = datafile_ny;
1653                   d_1_to_1(datafile_yArray, CXfaqf_qArray_nice);
1654                   for (i=1; i<=CXfaqf_na_nice; i++)
1655                     CXfaqf_aArray_nice[i] = datafile_xArray[1][i];
1656                 }
1657               aeroDragParts -> storeCommands (*command_line);
1658               CXfaqf_first=false;
1659             }
1660           break;
1661         }
1662       default:
1663         {
1664           if (dont_ignore)
1665             uiuc_warnings_errors(2, *command_line);
1666           break;
1667         }
1668       };
1669 }
1670
1671
1672 void parse_CL( const string& linetoken2, const string& linetoken3,
1673                const string& linetoken4, const string& linetoken5,
1674                const string& linetoken6, const string& linetoken7,
1675                const string& linetoken8, const string& linetoken9,
1676                const string& aircraft_directory,
1677                bool &CZfabetaf_first, bool &CZfadef_first,
1678                bool &CZfaqf_first, LIST command_line ) {
1679     double token_value;
1680     int token_value_convert1, token_value_convert2, token_value_convert3;
1681     double datafile_xArray[100][100], datafile_yArray[100];
1682     double datafile_zArray[100][100];
1683     int datafile_nxArray[100], datafile_ny;
1684     istrstream token3(linetoken3.c_str());
1685     istrstream token4(linetoken4.c_str());
1686     istrstream token5(linetoken5.c_str());
1687     istrstream token6(linetoken6.c_str());
1688     istrstream token7(linetoken7.c_str());
1689     istrstream token8(linetoken8.c_str());
1690     istrstream token9(linetoken9.c_str());
1691
1692     switch(CL_map[linetoken2])
1693       {
1694       case CLo_flag:
1695         {
1696           if (check_float(linetoken3))
1697             token3 >> token_value;
1698           else
1699             uiuc_warnings_errors(1, *command_line);
1700
1701           CLo = token_value;
1702           CLo_clean = CLo;
1703           aeroLiftParts -> storeCommands (*command_line);
1704           break;
1705         }
1706       case CL_a_flag:
1707         {
1708           if (check_float(linetoken3))
1709             token3 >> token_value;
1710           else
1711             uiuc_warnings_errors(1, *command_line);
1712
1713           CL_a = token_value;
1714           CL_a_clean = CL_a;
1715           aeroLiftParts -> storeCommands (*command_line);
1716           break;
1717         }
1718       case CL_adot_flag:
1719         {
1720           if (check_float(linetoken3))
1721             token3 >> token_value;
1722           else
1723             uiuc_warnings_errors(1, *command_line);
1724
1725           CL_adot = token_value;
1726           CL_adot_clean = CL_adot;
1727           aeroLiftParts -> storeCommands (*command_line);
1728           break;
1729         }
1730       case CL_q_flag:
1731         {
1732           if (check_float(linetoken3))
1733             token3 >> token_value;
1734           else
1735             uiuc_warnings_errors(1, *command_line);
1736
1737           CL_q = token_value;
1738           CL_q_clean = CL_q;
1739           aeroLiftParts -> storeCommands (*command_line);
1740           break;
1741         }
1742       case CL_ih_flag:
1743         {
1744           if (check_float(linetoken3))
1745             token3 >> token_value;
1746           else
1747             uiuc_warnings_errors(1, *command_line);
1748
1749           CL_ih = token_value;
1750           aeroLiftParts -> storeCommands (*command_line);
1751           break;
1752         }
1753       case CL_de_flag:
1754         {
1755           if (check_float(linetoken3))
1756             token3 >> token_value;
1757           else
1758             uiuc_warnings_errors(1, *command_line);
1759
1760           CL_de = token_value;
1761           CL_de_clean = CL_de;
1762           aeroLiftParts -> storeCommands (*command_line);
1763           break;
1764         }
1765       case CLfa_flag:
1766         {
1767           CLfa = aircraft_directory + linetoken3;
1768           token4 >> token_value_convert1;
1769           token5 >> token_value_convert2;
1770           convert_y = uiuc_convert(token_value_convert1);
1771           convert_x = uiuc_convert(token_value_convert2);
1772           /* call 1D File Reader with file name (CLfa) and conversion
1773              factors; function returns array of alphas (aArray) and
1774              corresponding CL values (CLArray) and max number of
1775              terms in arrays (nAlpha) */
1776           uiuc_1DdataFileReader(CLfa,
1777                                 CLfa_aArray,
1778                                 CLfa_CLArray,
1779                                 CLfa_nAlpha);
1780           aeroLiftParts -> storeCommands (*command_line);
1781           break;
1782         }
1783       case CLfade_flag:
1784         {
1785           CLfade = aircraft_directory + linetoken3;
1786           token4 >> token_value_convert1;
1787           token5 >> token_value_convert2;
1788           token6 >> token_value_convert3;
1789           convert_z = uiuc_convert(token_value_convert1);
1790           convert_x = uiuc_convert(token_value_convert2);
1791           convert_y = uiuc_convert(token_value_convert3);
1792           /* call 2D File Reader with file name (CLfade) and
1793              conversion factors; function returns array of
1794              elevator deflections (deArray) and corresponding
1795              alpha (aArray) and delta CL (CLArray) values and
1796              max number of terms in alpha arrays (nAlphaArray)
1797              and deflection array (nde) */
1798           uiuc_2DdataFileReader(CLfade,
1799                                 CLfade_aArray,
1800                                 CLfade_deArray,
1801                                 CLfade_CLArray,
1802                                 CLfade_nAlphaArray,
1803                                 CLfade_nde);
1804           aeroLiftParts -> storeCommands (*command_line);
1805           break;
1806         }
1807       case CLfdf_flag:
1808         {
1809           CLfdf = aircraft_directory + linetoken3;
1810           token4 >> token_value_convert1;
1811           token5 >> token_value_convert2;
1812           convert_y = uiuc_convert(token_value_convert1);
1813           convert_x = uiuc_convert(token_value_convert2);
1814           /* call 1D File Reader with file name (CLfdf) and conversion
1815              factors; function returns array of dfs (dfArray) and
1816              corresponding CL values (CLArray) and max number of
1817              terms in arrays (ndf) */
1818           uiuc_1DdataFileReader(CLfdf,
1819                                 CLfdf_dfArray,
1820                                 CLfdf_CLArray,
1821                                 CLfdf_ndf);
1822           aeroLiftParts -> storeCommands (*command_line);
1823
1824           // additional variables to streamline flap routine in aerodeflections
1825           ndf = CLfdf_ndf;
1826           int temp_counter = 1;
1827           while (temp_counter <= ndf)
1828             {
1829               dfArray[temp_counter] = CLfdf_dfArray[temp_counter];
1830               TimeArray[temp_counter] = dfTimefdf_TimeArray[temp_counter];
1831               temp_counter++;
1832             }
1833           break;
1834         }
1835       case CLfadf_flag:
1836         {
1837           CLfadf = aircraft_directory + linetoken3;
1838           token4 >> token_value_convert1;
1839           token5 >> token_value_convert2;
1840           token6 >> token_value_convert3;
1841           convert_z = uiuc_convert(token_value_convert1);
1842           convert_x = uiuc_convert(token_value_convert2);
1843           convert_y = uiuc_convert(token_value_convert3);
1844           /* call 2D File Reader with file name (CLfadf) and
1845              conversion factors; function returns array of
1846              flap deflections (dfArray) and corresponding
1847              alpha (aArray) and delta CL (CLArray) values and
1848              max number of terms in alpha arrays (nAlphaArray)
1849              and deflection array (ndf) */
1850           uiuc_2DdataFileReader(CLfadf,
1851                                 CLfadf_aArray,
1852                                 CLfadf_dfArray,
1853                                 CLfadf_CLArray,
1854                                 CLfadf_nAlphaArray,
1855                                 CLfadf_ndf);
1856           aeroLiftParts -> storeCommands (*command_line);
1857           break;
1858         }
1859       case CZo_flag:
1860         {
1861           if (check_float(linetoken3))
1862             token3 >> token_value;
1863           else
1864             uiuc_warnings_errors(1, *command_line);
1865
1866           CZo = token_value;
1867           CZo_clean = CZo;
1868           aeroLiftParts -> storeCommands (*command_line);
1869           break;
1870         }
1871       case CZ_a_flag:
1872         {
1873           if (check_float(linetoken3))
1874             token3 >> token_value;
1875           else
1876             uiuc_warnings_errors(1, *command_line);
1877
1878           CZ_a = token_value;
1879           CZ_a_clean = CZ_a;
1880           aeroLiftParts -> storeCommands (*command_line);
1881           break;
1882         }
1883       case CZ_a2_flag:
1884         {
1885           if (check_float(linetoken3))
1886             token3 >> token_value;
1887           else
1888             uiuc_warnings_errors(1, *command_line);
1889
1890           CZ_a2 = token_value;
1891           CZ_a2_clean = CZ_a2;
1892           aeroLiftParts -> storeCommands (*command_line);
1893           break;
1894         }
1895       case CZ_a3_flag:
1896         {
1897           if (check_float(linetoken3))
1898             token3 >> token_value;
1899           else
1900             uiuc_warnings_errors(1, *command_line);
1901
1902           CZ_a3 = token_value;
1903           CZ_a3_clean = CZ_a3;
1904           aeroLiftParts -> storeCommands (*command_line);
1905           break;
1906         }
1907       case CZ_adot_flag:
1908         {
1909           if (check_float(linetoken3))
1910             token3 >> token_value;
1911           else
1912             uiuc_warnings_errors(1, *command_line);
1913
1914           CZ_adot = token_value;
1915           CZ_adot_clean = CZ_adot;
1916           aeroLiftParts -> storeCommands (*command_line);
1917           break;
1918         }
1919       case CZ_q_flag:
1920         {
1921           if (check_float(linetoken3))
1922             token3 >> token_value;
1923           else
1924             uiuc_warnings_errors(1, *command_line);
1925
1926           CZ_q = token_value;
1927           CZ_q_clean = CZ_q;
1928           aeroLiftParts -> storeCommands (*command_line);
1929           break;
1930         }
1931       case CZ_de_flag:
1932         {
1933           if (check_float(linetoken3))
1934             token3 >> token_value;
1935           else
1936             uiuc_warnings_errors(1, *command_line);
1937
1938           CZ_de = token_value;
1939           CZ_de_clean = CZ_de;
1940           aeroLiftParts -> storeCommands (*command_line);
1941           break;
1942         }
1943       case CZ_deb2_flag:
1944         {
1945           if (check_float(linetoken3))
1946             token3 >> token_value;
1947           else
1948             uiuc_warnings_errors(1, *command_line);
1949
1950           CZ_deb2 = token_value;
1951           CZ_deb2_clean = CZ_deb2;
1952           aeroLiftParts -> storeCommands (*command_line);
1953           break;
1954         }
1955       case CZ_df_flag:
1956         {
1957           if (check_float(linetoken3))
1958             token3 >> token_value;
1959           else
1960             uiuc_warnings_errors(1, *command_line);
1961
1962           CZ_df = token_value;
1963           CZ_df_clean = CZ_df;
1964           aeroLiftParts -> storeCommands (*command_line);
1965           break;
1966         }
1967       case CZ_adf_flag:
1968         {
1969           if (check_float(linetoken3))
1970             token3 >> token_value;
1971           else
1972             uiuc_warnings_errors(1, *command_line);
1973
1974           CZ_adf = token_value;
1975           CZ_adf_clean = CZ_adf;
1976           aeroLiftParts -> storeCommands (*command_line);
1977           break;
1978         }
1979       case CZfa_flag:
1980         {
1981           CZfa = aircraft_directory + linetoken3;
1982           token4 >> token_value_convert1;
1983           token5 >> token_value_convert2;
1984           convert_y = uiuc_convert(token_value_convert1);
1985           convert_x = uiuc_convert(token_value_convert2);
1986           /* call 1D File Reader with file name (CZfa) and conversion
1987              factors; function returns array of alphas (aArray) and
1988              corresponding CZ values (CZArray) and max number of
1989              terms in arrays (nAlpha) */
1990           uiuc_1DdataFileReader(CZfa,
1991                                 CZfa_aArray,
1992                                 CZfa_CZArray,
1993                                 CZfa_nAlpha);
1994           aeroLiftParts -> storeCommands (*command_line);
1995           break;
1996         }
1997       case CZfabetaf_flag:
1998         {
1999           int CZfabetaf_index, i;
2000           string CZfabetaf_file;
2001           double flap_value;
2002           CZfabetaf_file = aircraft_directory + linetoken3;
2003           token4 >> CZfabetaf_index;
2004           if (CZfabetaf_index < 0 || CZfabetaf_index >= 30)
2005             uiuc_warnings_errors(1, *command_line);
2006           if (CZfabetaf_index > CZfabetaf_nf)
2007             CZfabetaf_nf = CZfabetaf_index;
2008           token5 >> flap_value;
2009           CZfabetaf_fArray[CZfabetaf_index] = flap_value;
2010           token6 >> token_value_convert1;
2011           token7 >> token_value_convert2;
2012           token8 >> token_value_convert3;
2013           token9 >> CZfabetaf_nice;
2014           convert_z = uiuc_convert(token_value_convert1);
2015           convert_x = uiuc_convert(token_value_convert2);
2016           convert_y = uiuc_convert(token_value_convert3);
2017           /* call 2D File Reader with file name (CZfabetaf_file) and
2018              conversion factors; function returns array of
2019              beta (betaArray) and corresponding
2020              alpha (aArray) and CZ (CZArray) values and
2021              max number of terms in alpha arrays (nAlphaArray)
2022              and beta array (nbeta) */
2023           uiuc_2DdataFileReader(CZfabetaf_file,
2024                                 datafile_xArray,
2025                                 datafile_yArray,
2026                                 datafile_zArray,
2027                                 datafile_nxArray,
2028                                 datafile_ny);
2029           d_2_to_3(datafile_xArray, CZfabetaf_aArray, CZfabetaf_index);
2030           d_1_to_2(datafile_yArray, CZfabetaf_betaArray, CZfabetaf_index);
2031           d_2_to_3(datafile_zArray, CZfabetaf_CZArray, CZfabetaf_index);
2032           i_1_to_2(datafile_nxArray, CZfabetaf_nAlphaArray, CZfabetaf_index);
2033           CZfabetaf_nbeta[CZfabetaf_index] = datafile_ny;
2034           if (CZfabetaf_first==true)
2035             {
2036               if (CZfabetaf_nice == 1)
2037                 {
2038                   CZfabetaf_na_nice = datafile_nxArray[1];
2039                   CZfabetaf_nb_nice = datafile_ny;
2040                   d_1_to_1(datafile_yArray, CZfabetaf_bArray_nice);
2041                   for (i=1; i<=CZfabetaf_na_nice; i++)
2042                     CZfabetaf_aArray_nice[i] = datafile_xArray[1][i];
2043                 }
2044               aeroLiftParts -> storeCommands (*command_line);
2045               CZfabetaf_first=false;
2046             }
2047           break;
2048         }
2049       case CZfadef_flag:
2050         {
2051           int CZfadef_index, i;
2052           string CZfadef_file;
2053           double flap_value;
2054           CZfadef_file = aircraft_directory + linetoken3;
2055           token4 >> CZfadef_index;
2056           if (CZfadef_index < 0 || CZfadef_index >= 30)
2057             uiuc_warnings_errors(1, *command_line);
2058           if (CZfadef_index > CZfadef_nf)
2059             CZfadef_nf = CZfadef_index;
2060           token5 >> flap_value;
2061           CZfadef_fArray[CZfadef_index] = flap_value;
2062           token6 >> token_value_convert1;
2063           token7 >> token_value_convert2;
2064           token8 >> token_value_convert3;
2065           token9 >> CZfadef_nice;
2066           convert_z = uiuc_convert(token_value_convert1);
2067           convert_x = uiuc_convert(token_value_convert2);
2068           convert_y = uiuc_convert(token_value_convert3);
2069           /* call 2D File Reader with file name (CZfadef_file) and
2070              conversion factors; function returns array of
2071              elevator deflections (deArray) and corresponding
2072              alpha (aArray) and delta CZ (CZArray) values and
2073              max number of terms in alpha arrays (nAlphaArray)
2074              and delfection array (nde) */
2075           uiuc_2DdataFileReader(CZfadef_file,
2076                                 datafile_xArray,
2077                                 datafile_yArray,
2078                                 datafile_zArray,
2079                                 datafile_nxArray,
2080                                 datafile_ny);
2081           d_2_to_3(datafile_xArray, CZfadef_aArray, CZfadef_index);
2082           d_1_to_2(datafile_yArray, CZfadef_deArray, CZfadef_index);
2083           d_2_to_3(datafile_zArray, CZfadef_CZArray, CZfadef_index);
2084           i_1_to_2(datafile_nxArray, CZfadef_nAlphaArray, CZfadef_index);
2085           CZfadef_nde[CZfadef_index] = datafile_ny;
2086           if (CZfadef_first==true)
2087             {
2088               if (CZfadef_nice == 1)
2089                 {
2090                   CZfadef_na_nice = datafile_nxArray[1];
2091                   CZfadef_nde_nice = datafile_ny;
2092                   d_1_to_1(datafile_yArray, CZfadef_deArray_nice);
2093                   for (i=1; i<=CZfadef_na_nice; i++)
2094                     CZfadef_aArray_nice[i] = datafile_xArray[1][i];
2095                 }
2096               aeroLiftParts -> storeCommands (*command_line);
2097               CZfadef_first=false;
2098             }
2099           break;
2100         }
2101       case CZfaqf_flag:
2102         {
2103           int CZfaqf_index, i;
2104           string CZfaqf_file;
2105           double flap_value;
2106           CZfaqf_file = aircraft_directory + linetoken3;
2107           token4 >> CZfaqf_index;
2108           if (CZfaqf_index < 0 || CZfaqf_index >= 30)
2109             uiuc_warnings_errors(1, *command_line);
2110           if (CZfaqf_index > CZfaqf_nf)
2111             CZfaqf_nf = CZfaqf_index;
2112           token5 >> flap_value;
2113           CZfaqf_fArray[CZfaqf_index] = flap_value;
2114           token6 >> token_value_convert1;
2115           token7 >> token_value_convert2;
2116           token8 >> token_value_convert3;
2117           token9 >> CZfaqf_nice;
2118           convert_z = uiuc_convert(token_value_convert1);
2119           convert_x = uiuc_convert(token_value_convert2);
2120           convert_y = uiuc_convert(token_value_convert3);
2121           /* call 2D File Reader with file name (CZfaqf_file) and
2122              conversion factors; function returns array of
2123              pitch rate (qArray) and corresponding
2124              alpha (aArray) and delta CZ (CZArray) values and
2125              max number of terms in alpha arrays (nAlphaArray)
2126              and pitch rate array (nq) */
2127           uiuc_2DdataFileReader(CZfaqf_file,
2128                                 datafile_xArray,
2129                                 datafile_yArray,
2130                                 datafile_zArray,
2131                                 datafile_nxArray,
2132                                 datafile_ny);
2133           d_2_to_3(datafile_xArray, CZfaqf_aArray, CZfaqf_index);
2134           d_1_to_2(datafile_yArray, CZfaqf_qArray, CZfaqf_index);
2135           d_2_to_3(datafile_zArray, CZfaqf_CZArray, CZfaqf_index);
2136           i_1_to_2(datafile_nxArray, CZfaqf_nAlphaArray, CZfaqf_index);
2137           CZfaqf_nq[CZfaqf_index] = datafile_ny;
2138           if (CZfaqf_first==true)
2139             {
2140               if (CZfaqf_nice == 1)
2141                 {
2142                   CZfaqf_na_nice = datafile_nxArray[1];
2143                   CZfaqf_nq_nice = datafile_ny;
2144                   d_1_to_1(datafile_yArray, CZfaqf_qArray_nice);
2145                   for (i=1; i<=CZfaqf_na_nice; i++)
2146                     CZfaqf_aArray_nice[i] = datafile_xArray[1][i];
2147                 }
2148               aeroLiftParts -> storeCommands (*command_line);
2149               CZfaqf_first=false;
2150             }
2151           break;
2152         }
2153       default:
2154         {
2155           if (dont_ignore)
2156             uiuc_warnings_errors(2, *command_line);
2157           break;
2158         }
2159       };
2160 }
2161
2162
2163 void parse_Cm( const string& linetoken2, const string& linetoken3,
2164                const string& linetoken4, const string& linetoken5,
2165                const string& linetoken6, const string& linetoken7,
2166                const string& linetoken8, const string& linetoken9,
2167                const string& aircraft_directory,
2168                bool &Cmfabetaf_first, bool &Cmfadef_first,
2169                bool &Cmfaqf_first, LIST command_line ) {
2170     double token_value;
2171     int token_value_convert1, token_value_convert2, token_value_convert3;
2172     double datafile_xArray[100][100], datafile_yArray[100];
2173     double datafile_zArray[100][100];
2174     int datafile_nxArray[100], datafile_ny;
2175     istrstream token3(linetoken3.c_str());
2176     istrstream token4(linetoken4.c_str());
2177     istrstream token5(linetoken5.c_str());
2178     istrstream token6(linetoken6.c_str());
2179     istrstream token7(linetoken7.c_str());
2180     istrstream token8(linetoken8.c_str());
2181     istrstream token9(linetoken9.c_str());
2182
2183     switch(Cm_map[linetoken2])
2184       {
2185       case Cmo_flag:
2186         {
2187           if (check_float(linetoken3))
2188             token3 >> token_value;
2189           else
2190             uiuc_warnings_errors(1, *command_line);
2191
2192           Cmo = token_value;
2193           Cmo_clean = Cmo;
2194           aeroPitchParts -> storeCommands (*command_line);
2195           break;
2196         }
2197       case Cm_a_flag:
2198         {
2199           if (check_float(linetoken3))
2200             token3 >> token_value;
2201           else
2202             uiuc_warnings_errors(1, *command_line);
2203
2204           Cm_a = token_value;
2205           Cm_a_clean = Cm_a;
2206           aeroPitchParts -> storeCommands (*command_line);
2207           break;
2208         }
2209       case Cm_a2_flag:
2210         {
2211           if (check_float(linetoken3))
2212             token3 >> token_value;
2213           else
2214             uiuc_warnings_errors(1, *command_line);
2215
2216           Cm_a2 = token_value;
2217           Cm_a2_clean = Cm_a2;
2218           aeroPitchParts -> storeCommands (*command_line);
2219           break;
2220         }
2221       case Cm_adot_flag:
2222         {
2223           if (check_float(linetoken3))
2224             token3 >> token_value;
2225           else
2226             uiuc_warnings_errors(1, *command_line);
2227
2228           Cm_adot = token_value;
2229           Cm_adot_clean = Cm_adot;
2230           aeroPitchParts -> storeCommands (*command_line);
2231           break;
2232         }
2233       case Cm_q_flag:
2234         {
2235           if (check_float(linetoken3))
2236             token3 >> token_value;
2237           else
2238             uiuc_warnings_errors(1, *command_line);
2239
2240           Cm_q = token_value;
2241           Cm_q_clean = Cm_q;
2242           aeroPitchParts -> storeCommands (*command_line);
2243           break;
2244         }
2245       case Cm_ih_flag:
2246         {
2247           if (check_float(linetoken3))
2248             token3 >> token_value;
2249           else
2250             uiuc_warnings_errors(1, *command_line);
2251
2252           Cm_ih = token_value;
2253           aeroPitchParts -> storeCommands (*command_line);
2254           break;
2255         }
2256       case Cm_de_flag:
2257         {
2258           if (check_float(linetoken3))
2259             token3 >> token_value;
2260           else
2261             uiuc_warnings_errors(1, *command_line);
2262
2263           Cm_de = token_value;
2264           Cm_de_clean = Cm_de;
2265           aeroPitchParts -> storeCommands (*command_line);
2266           break;
2267         }
2268       case Cm_b2_flag:
2269         {
2270           if (check_float(linetoken3))
2271             token3 >> token_value;
2272           else
2273             uiuc_warnings_errors(1, *command_line);
2274
2275           Cm_b2 = token_value;
2276           Cm_b2_clean = Cm_b2;
2277           aeroPitchParts -> storeCommands (*command_line);
2278           break;
2279         }
2280       case Cm_r_flag:
2281         {
2282           if (check_float(linetoken3))
2283             token3 >> token_value;
2284           else
2285             uiuc_warnings_errors(1, *command_line);
2286
2287           Cm_r = token_value;
2288           Cm_r_clean = Cm_r;
2289           aeroPitchParts -> storeCommands (*command_line);
2290           break;
2291         }
2292       case Cm_df_flag:
2293         {
2294           if (check_float(linetoken3))
2295             token3 >> token_value;
2296           else
2297             uiuc_warnings_errors(1, *command_line);
2298
2299           Cm_df = token_value;
2300           Cm_df_clean = Cm_df;
2301           aeroPitchParts -> storeCommands (*command_line);
2302           break;
2303         }
2304       case Cmfa_flag:
2305         {
2306           Cmfa = aircraft_directory + linetoken3;
2307           token4 >> token_value_convert1;
2308           token5 >> token_value_convert2;
2309           convert_y = uiuc_convert(token_value_convert1);
2310           convert_x = uiuc_convert(token_value_convert2);
2311           /* call 1D File Reader with file name (Cmfa) and conversion
2312              factors; function returns array of alphas (aArray) and
2313              corresponding Cm values (CmArray) and max number of
2314              terms in arrays (nAlpha) */
2315           uiuc_1DdataFileReader(Cmfa,
2316                                 Cmfa_aArray,
2317                                 Cmfa_CmArray,
2318                                 Cmfa_nAlpha);
2319           aeroPitchParts -> storeCommands (*command_line);
2320           break;
2321         }
2322       case Cmfade_flag:
2323         {
2324           Cmfade = aircraft_directory + linetoken3;
2325           token4 >> token_value_convert1;
2326           token5 >> token_value_convert2;
2327           token6 >> token_value_convert3;
2328           convert_z = uiuc_convert(token_value_convert1);
2329           convert_x = uiuc_convert(token_value_convert2);
2330           convert_y = uiuc_convert(token_value_convert3);
2331           /* call 2D File Reader with file name (Cmfade) and
2332              conversion factors; function returns array of
2333              elevator deflections (deArray) and corresponding
2334              alpha (aArray) and delta Cm (CmArray) values and
2335              max number of terms in alpha arrays (nAlphaArray)
2336              and deflection array (nde) */
2337           uiuc_2DdataFileReader(Cmfade,
2338                                 Cmfade_aArray,
2339                                 Cmfade_deArray,
2340                                 Cmfade_CmArray,
2341                                 Cmfade_nAlphaArray,
2342                                 Cmfade_nde);
2343           aeroPitchParts -> storeCommands (*command_line);
2344           break;
2345         }
2346       case Cmfdf_flag:
2347         {
2348           Cmfdf = aircraft_directory + linetoken3;
2349           token4 >> token_value_convert1;
2350           token5 >> token_value_convert2;
2351           convert_y = uiuc_convert(token_value_convert1);
2352           convert_x = uiuc_convert(token_value_convert2);
2353           /* call 1D File Reader with file name (Cmfdf) and conversion
2354              factors; function returns array of dfs (dfArray) and
2355              corresponding Cm values (CmArray) and max number of
2356              terms in arrays (ndf) */
2357           uiuc_1DdataFileReader(Cmfdf,
2358                                 Cmfdf_dfArray,
2359                                 Cmfdf_CmArray,
2360                                 Cmfdf_ndf);
2361           aeroPitchParts -> storeCommands (*command_line);
2362           break;
2363         }
2364       case Cmfadf_flag:
2365         {
2366           Cmfadf = aircraft_directory + linetoken3;
2367           token4 >> token_value_convert1;
2368           token5 >> token_value_convert2;
2369           token6 >> token_value_convert3;
2370           convert_z = uiuc_convert(token_value_convert1);
2371           convert_x = uiuc_convert(token_value_convert2);
2372           convert_y = uiuc_convert(token_value_convert3);
2373           /* call 2D File Reader with file name (Cmfadf) and
2374              conversion factors; function returns array of
2375              flap deflections (dfArray) and corresponding
2376              alpha (aArray) and delta Cm (CmArray) values and
2377              max number of terms in alpha arrays (nAlphaArray)
2378              and deflection array (ndf) */
2379           uiuc_2DdataFileReader(Cmfadf,
2380                                 Cmfadf_aArray,
2381                                 Cmfadf_dfArray,
2382                                 Cmfadf_CmArray,
2383                                 Cmfadf_nAlphaArray,
2384                                 Cmfadf_ndf);
2385           aeroPitchParts -> storeCommands (*command_line);
2386           break;
2387         }
2388       case Cmfabetaf_flag:
2389         {
2390           int Cmfabetaf_index, i;
2391           string Cmfabetaf_file;
2392           double flap_value;
2393           Cmfabetaf_file = aircraft_directory + linetoken3;
2394           token4 >> Cmfabetaf_index;
2395           if (Cmfabetaf_index < 0 || Cmfabetaf_index >= 30)
2396             uiuc_warnings_errors(1, *command_line);
2397           if (Cmfabetaf_index > Cmfabetaf_nf)
2398             Cmfabetaf_nf = Cmfabetaf_index;
2399           token5 >> flap_value;
2400           Cmfabetaf_fArray[Cmfabetaf_index] = flap_value;
2401           token6 >> token_value_convert1;
2402           token7 >> token_value_convert2;
2403           token8 >> token_value_convert3;
2404           token9 >> Cmfabetaf_nice;
2405           convert_z = uiuc_convert(token_value_convert1);
2406           convert_x = uiuc_convert(token_value_convert2);
2407           convert_y = uiuc_convert(token_value_convert3);
2408           /* call 2D File Reader with file name (Cmfabetaf_file) and
2409              conversion factors; function returns array of
2410              elevator deflections (deArray) and corresponding
2411              alpha (aArray) and delta CZ (CZArray) values and
2412              max number of terms in alpha arrays (nAlphaArray)
2413              and delfection array (nde) */
2414           uiuc_2DdataFileReader(Cmfabetaf_file,
2415                                 datafile_xArray,
2416                                 datafile_yArray,
2417                                 datafile_zArray,
2418                                 datafile_nxArray,
2419                                 datafile_ny);
2420           d_2_to_3(datafile_xArray, Cmfabetaf_aArray, Cmfabetaf_index);
2421           d_1_to_2(datafile_yArray, Cmfabetaf_betaArray, Cmfabetaf_index);
2422           d_2_to_3(datafile_zArray, Cmfabetaf_CmArray, Cmfabetaf_index);
2423           i_1_to_2(datafile_nxArray, Cmfabetaf_nAlphaArray, Cmfabetaf_index);
2424           Cmfabetaf_nbeta[Cmfabetaf_index] = datafile_ny;
2425           if (Cmfabetaf_first==true)
2426             {
2427               if (Cmfabetaf_nice == 1)
2428                 {
2429                   Cmfabetaf_na_nice = datafile_nxArray[1];
2430                   Cmfabetaf_nb_nice = datafile_ny;
2431                   d_1_to_1(datafile_yArray, Cmfabetaf_bArray_nice);
2432                   for (i=1; i<=Cmfabetaf_na_nice; i++)
2433                     Cmfabetaf_aArray_nice[i] = datafile_xArray[1][i];
2434                 }
2435               aeroPitchParts -> storeCommands (*command_line);
2436               Cmfabetaf_first=false;
2437             }
2438           break;
2439         }
2440       case Cmfadef_flag:
2441         {
2442           int Cmfadef_index, i;
2443           string Cmfadef_file;
2444           double flap_value;
2445           Cmfadef_file = aircraft_directory + linetoken3;
2446           token4 >> Cmfadef_index;
2447           if (Cmfadef_index < 0 || Cmfadef_index >= 30)
2448             uiuc_warnings_errors(1, *command_line);
2449           if (Cmfadef_index > Cmfadef_nf)
2450             Cmfadef_nf = Cmfadef_index;
2451           token5 >> flap_value;
2452           Cmfadef_fArray[Cmfadef_index] = flap_value;
2453           token6 >> token_value_convert1;
2454           token7 >> token_value_convert2;
2455           token8 >> token_value_convert3;
2456           token9 >> Cmfadef_nice;
2457           convert_z = uiuc_convert(token_value_convert1);
2458           convert_x = uiuc_convert(token_value_convert2);
2459           convert_y = uiuc_convert(token_value_convert3);
2460           /* call 2D File Reader with file name (Cmfadef_file) and
2461              conversion factors; function returns array of
2462              elevator deflections (deArray) and corresponding
2463              alpha (aArray) and delta CZ (CZArray) values and
2464              max number of terms in alpha arrays (nAlphaArray)
2465              and delfection array (nde) */
2466           uiuc_2DdataFileReader(Cmfadef_file,
2467                                 datafile_xArray,
2468                                 datafile_yArray,
2469                                 datafile_zArray,
2470                                 datafile_nxArray,
2471                                 datafile_ny);
2472           d_2_to_3(datafile_xArray, Cmfadef_aArray, Cmfadef_index);
2473           d_1_to_2(datafile_yArray, Cmfadef_deArray, Cmfadef_index);
2474           d_2_to_3(datafile_zArray, Cmfadef_CmArray, Cmfadef_index);
2475           i_1_to_2(datafile_nxArray, Cmfadef_nAlphaArray, Cmfadef_index);
2476           Cmfadef_nde[Cmfadef_index] = datafile_ny;
2477           if (Cmfadef_first==true)
2478             {
2479               if (Cmfadef_nice == 1)
2480                 {
2481                   Cmfadef_na_nice = datafile_nxArray[1];
2482                   Cmfadef_nde_nice = datafile_ny;
2483                   d_1_to_1(datafile_yArray, Cmfadef_deArray_nice);
2484                   for (i=1; i<=Cmfadef_na_nice; i++)
2485                     Cmfadef_aArray_nice[i] = datafile_xArray[1][i];
2486                 }
2487               aeroPitchParts -> storeCommands (*command_line);
2488               Cmfadef_first=false;
2489             }
2490           break;
2491         }
2492       case Cmfaqf_flag:
2493         {
2494           int Cmfaqf_index, i;
2495           string Cmfaqf_file;
2496           double flap_value;
2497           Cmfaqf_file = aircraft_directory + linetoken3;
2498           token4 >> Cmfaqf_index;
2499           if (Cmfaqf_index < 0 || Cmfaqf_index >= 30)
2500             uiuc_warnings_errors(1, *command_line);
2501           if (Cmfaqf_index > Cmfaqf_nf)
2502             Cmfaqf_nf = Cmfaqf_index;
2503           token5 >> flap_value;
2504           Cmfaqf_fArray[Cmfaqf_index] = flap_value;
2505           token6 >> token_value_convert1;
2506           token7 >> token_value_convert2;
2507           token8 >> token_value_convert3;
2508           token9 >> Cmfaqf_nice;
2509           convert_z = uiuc_convert(token_value_convert1);
2510           convert_x = uiuc_convert(token_value_convert2);
2511           convert_y = uiuc_convert(token_value_convert3);
2512           /* call 2D File Reader with file name (Cmfaqf_file) and
2513              conversion factors; function returns array of
2514              elevator deflections (deArray) and corresponding
2515              alpha (aArray) and delta CZ (CZArray) values and
2516              max number of terms in alpha arrays (nAlphaArray)
2517              and delfection array (nde) */
2518           uiuc_2DdataFileReader(Cmfaqf_file,
2519                                 datafile_xArray,
2520                                 datafile_yArray,
2521                                 datafile_zArray,
2522                                 datafile_nxArray,
2523                                 datafile_ny);
2524           d_2_to_3(datafile_xArray, Cmfaqf_aArray, Cmfaqf_index);
2525           d_1_to_2(datafile_yArray, Cmfaqf_qArray, Cmfaqf_index);
2526           d_2_to_3(datafile_zArray, Cmfaqf_CmArray, Cmfaqf_index);
2527           i_1_to_2(datafile_nxArray, Cmfaqf_nAlphaArray, Cmfaqf_index);
2528           Cmfaqf_nq[Cmfaqf_index] = datafile_ny;
2529           if (Cmfaqf_first==true)
2530             {
2531               if (Cmfaqf_nice == 1)
2532                 {
2533                   Cmfaqf_na_nice = datafile_nxArray[1];
2534                   Cmfaqf_nq_nice = datafile_ny;
2535                   d_1_to_1(datafile_yArray, Cmfaqf_qArray_nice);
2536                   for (i=1; i<=Cmfaqf_na_nice; i++)
2537                     Cmfaqf_aArray_nice[i] = datafile_xArray[1][i];
2538                 }
2539               aeroPitchParts -> storeCommands (*command_line);
2540               Cmfaqf_first=false;
2541             }
2542           break;
2543         }
2544       default:
2545         {
2546           if (dont_ignore)
2547             uiuc_warnings_errors(2, *command_line);
2548           break;
2549         }
2550       };
2551 }
2552
2553
2554 void parse_CY( const string& linetoken2, const string& linetoken3,
2555                const string& linetoken4, const string& linetoken5,
2556                const string& linetoken6, const string& linetoken7,
2557                const string& linetoken8, const string& linetoken9,
2558                const string& aircraft_directory,
2559                bool &CYfabetaf_first, bool &CYfadaf_first,
2560                bool &CYfadrf_first, bool &CYfapf_first,
2561                bool &CYfarf_first, LIST command_line ) {
2562     double token_value;
2563     int token_value_convert1, token_value_convert2, token_value_convert3;
2564     double datafile_xArray[100][100], datafile_yArray[100];
2565     double datafile_zArray[100][100];
2566     int datafile_nxArray[100], datafile_ny;
2567     istrstream token3(linetoken3.c_str());
2568     istrstream token4(linetoken4.c_str());
2569     istrstream token5(linetoken5.c_str());
2570     istrstream token6(linetoken6.c_str());
2571     istrstream token7(linetoken7.c_str());
2572     istrstream token8(linetoken8.c_str());
2573     istrstream token9(linetoken9.c_str());
2574
2575     switch(CY_map[linetoken2])
2576       {
2577       case CYo_flag:
2578         {
2579           if (check_float(linetoken3))
2580             token3 >> token_value;
2581           else
2582             uiuc_warnings_errors(1, *command_line);
2583
2584           CYo = token_value;
2585           CYo_clean = CYo;
2586           aeroSideforceParts -> storeCommands (*command_line);
2587           break;
2588         }
2589       case CY_beta_flag:
2590         {
2591           if (check_float(linetoken3))
2592             token3 >> token_value;
2593           else
2594             uiuc_warnings_errors(1, *command_line);
2595
2596           CY_beta = token_value;
2597           CY_beta_clean = CY_beta;
2598           aeroSideforceParts -> storeCommands (*command_line);
2599           break;
2600         }
2601       case CY_p_flag:
2602         {
2603           if (check_float(linetoken3))
2604             token3 >> token_value;
2605           else
2606             uiuc_warnings_errors(1, *command_line);
2607
2608           CY_p = token_value;
2609           CY_p_clean = CY_p;
2610           aeroSideforceParts -> storeCommands (*command_line);
2611           break;
2612         }
2613       case CY_r_flag:
2614         {
2615           if (check_float(linetoken3))
2616             token3 >> token_value;
2617           else
2618             uiuc_warnings_errors(1, *command_line);
2619
2620           CY_r = token_value;
2621           CY_r_clean = CY_r;
2622           aeroSideforceParts -> storeCommands (*command_line);
2623           break;
2624         }
2625       case CY_da_flag:
2626         {
2627           if (check_float(linetoken3))
2628             token3 >> token_value;
2629           else
2630             uiuc_warnings_errors(1, *command_line);
2631
2632           CY_da = token_value;
2633           CY_da_clean = CY_da;
2634           aeroSideforceParts -> storeCommands (*command_line);
2635           break;
2636         }
2637       case CY_dr_flag:
2638         {
2639           if (check_float(linetoken3))
2640             token3 >> token_value;
2641           else
2642             uiuc_warnings_errors(2, *command_line);
2643
2644           CY_dr = token_value;
2645           CY_dr_clean = CY_dr;
2646           aeroSideforceParts -> storeCommands (*command_line);
2647           break;
2648         }
2649       case CY_dra_flag:
2650         {
2651           if (check_float(linetoken3))
2652             token3 >> token_value;
2653           else
2654             uiuc_warnings_errors(2, *command_line);
2655
2656           CY_dra = token_value;
2657           CY_dra_clean = CY_dra;
2658           aeroSideforceParts -> storeCommands (*command_line);
2659           break;
2660         }
2661       case CY_bdot_flag:
2662         {
2663           if (check_float(linetoken3))
2664             token3 >> token_value;
2665           else
2666             uiuc_warnings_errors(2, *command_line);
2667
2668           CY_bdot = token_value;
2669           CY_bdot_clean = CY_bdot;
2670           aeroSideforceParts -> storeCommands (*command_line);
2671           break;
2672         }
2673       case CYfada_flag:
2674         {
2675           CYfada = aircraft_directory + linetoken3;
2676           token4 >> token_value_convert1;
2677           token5 >> token_value_convert2;
2678           token6 >> token_value_convert3;
2679           convert_z = uiuc_convert(token_value_convert1);
2680           convert_x = uiuc_convert(token_value_convert2);
2681           convert_y = uiuc_convert(token_value_convert3);
2682           /* call 2D File Reader with file name (CYfada) and
2683              conversion factors; function returns array of
2684              aileron deflections (daArray) and corresponding
2685              alpha (aArray) and delta CY (CYArray) values and
2686              max number of terms in alpha arrays (nAlphaArray)
2687              and deflection array (nda) */
2688           uiuc_2DdataFileReader(CYfada,
2689                                 CYfada_aArray,
2690                                 CYfada_daArray,
2691                                 CYfada_CYArray,
2692                                 CYfada_nAlphaArray,
2693                                 CYfada_nda);
2694           aeroSideforceParts -> storeCommands (*command_line);
2695           break;
2696         }
2697       case CYfbetadr_flag:
2698         {
2699           CYfbetadr = aircraft_directory + linetoken3;
2700           token4 >> token_value_convert1;
2701           token5 >> token_value_convert2;
2702           token6 >> token_value_convert3;
2703           convert_z = uiuc_convert(token_value_convert1);
2704           convert_x = uiuc_convert(token_value_convert2);
2705           convert_y = uiuc_convert(token_value_convert3);
2706           /* call 2D File Reader with file name (CYfbetadr) and
2707              conversion factors; function returns array of
2708              rudder deflections (drArray) and corresponding
2709              beta (betaArray) and delta CY (CYArray) values and
2710              max number of terms in beta arrays (nBetaArray)
2711              and deflection array (ndr) */
2712           uiuc_2DdataFileReader(CYfbetadr,
2713                                 CYfbetadr_betaArray,
2714                                 CYfbetadr_drArray,
2715                                 CYfbetadr_CYArray,
2716                                 CYfbetadr_nBetaArray,
2717                                 CYfbetadr_ndr);
2718           aeroSideforceParts -> storeCommands (*command_line);
2719           break;
2720         }
2721       case CYfabetaf_flag:
2722         {
2723           int CYfabetaf_index, i;
2724           string CYfabetaf_file;
2725           double flap_value;
2726           CYfabetaf_file = aircraft_directory + linetoken3;
2727           token4 >> CYfabetaf_index;
2728           if (CYfabetaf_index < 0 || CYfabetaf_index >= 30)
2729             uiuc_warnings_errors(1, *command_line);
2730           if (CYfabetaf_index > CYfabetaf_nf)
2731             CYfabetaf_nf = CYfabetaf_index;
2732           token5 >> flap_value;
2733           CYfabetaf_fArray[CYfabetaf_index] = flap_value;
2734           token6 >> token_value_convert1;
2735           token7 >> token_value_convert2;
2736           token8 >> token_value_convert3;
2737           token9 >> CYfabetaf_nice;
2738           convert_z = uiuc_convert(token_value_convert1);
2739           convert_x = uiuc_convert(token_value_convert2);
2740           convert_y = uiuc_convert(token_value_convert3);
2741           /* call 2D File Reader with file name (CYfabetaf_file) and
2742              conversion factors; function returns array of
2743              elevator deflections (deArray) and corresponding
2744              alpha (aArray) and delta CZ (CZArray) values and
2745              max number of terms in alpha arrays (nAlphaArray)
2746              and delfection array (nde) */
2747           uiuc_2DdataFileReader(CYfabetaf_file,
2748                                 datafile_xArray,
2749                                 datafile_yArray,
2750                                 datafile_zArray,
2751                                 datafile_nxArray,
2752                                 datafile_ny);
2753           d_2_to_3(datafile_xArray, CYfabetaf_aArray, CYfabetaf_index);
2754           d_1_to_2(datafile_yArray, CYfabetaf_betaArray, CYfabetaf_index);
2755           d_2_to_3(datafile_zArray, CYfabetaf_CYArray, CYfabetaf_index);
2756           i_1_to_2(datafile_nxArray, CYfabetaf_nAlphaArray, CYfabetaf_index);
2757           CYfabetaf_nbeta[CYfabetaf_index] = datafile_ny;
2758           if (CYfabetaf_first==true)
2759             {
2760               if (CYfabetaf_nice == 1)
2761                 {
2762                   CYfabetaf_na_nice = datafile_nxArray[1];
2763                   CYfabetaf_nb_nice = datafile_ny;
2764                   d_1_to_1(datafile_yArray, CYfabetaf_bArray_nice);
2765                   for (i=1; i<=CYfabetaf_na_nice; i++)
2766                     CYfabetaf_aArray_nice[i] = datafile_xArray[1][i];
2767                 }
2768               aeroSideforceParts -> storeCommands (*command_line);
2769               CYfabetaf_first=false;
2770             }
2771           break;
2772         }
2773       case CYfadaf_flag:
2774         {
2775           int CYfadaf_index, i;
2776           string CYfadaf_file;
2777           double flap_value;
2778           CYfadaf_file = aircraft_directory + linetoken3;
2779           token4 >> CYfadaf_index;
2780           if (CYfadaf_index < 0 || CYfadaf_index >= 30)
2781             uiuc_warnings_errors(1, *command_line);
2782           if (CYfadaf_index > CYfadaf_nf)
2783             CYfadaf_nf = CYfadaf_index;
2784           token5 >> flap_value;
2785           CYfadaf_fArray[CYfadaf_index] = flap_value;
2786           token6 >> token_value_convert1;
2787           token7 >> token_value_convert2;
2788           token8 >> token_value_convert3;
2789           token9 >> CYfadaf_nice;
2790           convert_z = uiuc_convert(token_value_convert1);
2791           convert_x = uiuc_convert(token_value_convert2);
2792           convert_y = uiuc_convert(token_value_convert3);
2793           /* call 2D File Reader with file name (CYfadaf_file) and
2794              conversion factors; function returns array of
2795              elevator deflections (deArray) and corresponding
2796              alpha (aArray) and delta CZ (CZArray) values and
2797              max number of terms in alpha arrays (nAlphaArray)
2798              and delfection array (nde) */
2799           uiuc_2DdataFileReader(CYfadaf_file,
2800                                 datafile_xArray,
2801                                 datafile_yArray,
2802                                 datafile_zArray,
2803                                 datafile_nxArray,
2804                                 datafile_ny);
2805           d_2_to_3(datafile_xArray, CYfadaf_aArray, CYfadaf_index);
2806           d_1_to_2(datafile_yArray, CYfadaf_daArray, CYfadaf_index);
2807           d_2_to_3(datafile_zArray, CYfadaf_CYArray, CYfadaf_index);
2808           i_1_to_2(datafile_nxArray, CYfadaf_nAlphaArray, CYfadaf_index);
2809           CYfadaf_nda[CYfadaf_index] = datafile_ny;
2810           if (CYfadaf_first==true)
2811             {
2812               if (CYfadaf_nice == 1)
2813                 {
2814                   CYfadaf_na_nice = datafile_nxArray[1];
2815                   CYfadaf_nda_nice = datafile_ny;
2816                   d_1_to_1(datafile_yArray, CYfadaf_daArray_nice);
2817                   for (i=1; i<=CYfadaf_na_nice; i++)
2818                     CYfadaf_aArray_nice[i] = datafile_xArray[1][i];
2819                 }
2820               aeroSideforceParts -> storeCommands (*command_line);
2821               CYfadaf_first=false;
2822             }
2823           break;
2824         }
2825       case CYfadrf_flag:
2826         {
2827           int CYfadrf_index, i;
2828           string CYfadrf_file;
2829           double flap_value;
2830           CYfadrf_file = aircraft_directory + linetoken3;
2831           token4 >> CYfadrf_index;
2832           if (CYfadrf_index < 0 || CYfadrf_index >= 30)
2833             uiuc_warnings_errors(1, *command_line);
2834           if (CYfadrf_index > CYfadrf_nf)
2835             CYfadrf_nf = CYfadrf_index;
2836           token5 >> flap_value;
2837           CYfadrf_fArray[CYfadrf_index] = flap_value;
2838           token6 >> token_value_convert1;
2839           token7 >> token_value_convert2;
2840           token8 >> token_value_convert3;
2841           token9 >> CYfadrf_nice;
2842           convert_z = uiuc_convert(token_value_convert1);
2843           convert_x = uiuc_convert(token_value_convert2);
2844           convert_y = uiuc_convert(token_value_convert3);
2845           /* call 2D File Reader with file name (CYfadrf_file) and
2846              conversion factors; function returns array of
2847              elevator deflections (deArray) and corresponding
2848              alpha (aArray) and delta CZ (CZArray) values and
2849              max number of terms in alpha arrays (nAlphaArray)
2850              and delfection array (nde) */
2851           uiuc_2DdataFileReader(CYfadrf_file,
2852                                 datafile_xArray,
2853                                 datafile_yArray,
2854                                 datafile_zArray,
2855                                 datafile_nxArray,
2856                                 datafile_ny);
2857           d_2_to_3(datafile_xArray, CYfadrf_aArray, CYfadrf_index);
2858           d_1_to_2(datafile_yArray, CYfadrf_drArray, CYfadrf_index);
2859           d_2_to_3(datafile_zArray, CYfadrf_CYArray, CYfadrf_index);
2860           i_1_to_2(datafile_nxArray, CYfadrf_nAlphaArray, CYfadrf_index);
2861           CYfadrf_ndr[CYfadrf_index] = datafile_ny;
2862           if (CYfadrf_first==true)
2863             {
2864               if (CYfadrf_nice == 1)
2865                 {
2866                   CYfadrf_na_nice = datafile_nxArray[1];
2867                   CYfadrf_ndr_nice = datafile_ny;
2868                   d_1_to_1(datafile_yArray, CYfadrf_drArray_nice);
2869                   for (i=1; i<=CYfadrf_na_nice; i++)
2870                     CYfadrf_aArray_nice[i] = datafile_xArray[1][i];
2871                 }
2872               aeroSideforceParts -> storeCommands (*command_line);
2873               CYfadrf_first=false;
2874             }
2875           break;
2876         }
2877       case CYfapf_flag:
2878         {
2879           int CYfapf_index, i;
2880           string CYfapf_file;
2881           double flap_value;
2882           CYfapf_file = aircraft_directory + linetoken3;
2883           token4 >> CYfapf_index;
2884           if (CYfapf_index < 0 || CYfapf_index >= 30)
2885             uiuc_warnings_errors(1, *command_line);
2886           if (CYfapf_index > CYfapf_nf)
2887             CYfapf_nf = CYfapf_index;
2888           token5 >> flap_value;
2889           CYfapf_fArray[CYfapf_index] = flap_value;
2890           token6 >> token_value_convert1;
2891           token7 >> token_value_convert2;
2892           token8 >> token_value_convert3;
2893           token9 >> CYfapf_nice;
2894           convert_z = uiuc_convert(token_value_convert1);
2895           convert_x = uiuc_convert(token_value_convert2);
2896           convert_y = uiuc_convert(token_value_convert3);
2897           /* call 2D File Reader with file name (CYfapf_file) and
2898              conversion factors; function returns array of
2899              elevator deflections (deArray) and corresponding
2900              alpha (aArray) and delta CZ (CZArray) values and
2901              max number of terms in alpha arrays (nAlphaArray)
2902              and delfection array (nde) */
2903           uiuc_2DdataFileReader(CYfapf_file,
2904                                 datafile_xArray,
2905                                 datafile_yArray,
2906                                 datafile_zArray,
2907                                 datafile_nxArray,
2908                                 datafile_ny);
2909           d_2_to_3(datafile_xArray, CYfapf_aArray, CYfapf_index);
2910           d_1_to_2(datafile_yArray, CYfapf_pArray, CYfapf_index);
2911           d_2_to_3(datafile_zArray, CYfapf_CYArray, CYfapf_index);
2912           i_1_to_2(datafile_nxArray, CYfapf_nAlphaArray, CYfapf_index);
2913           CYfapf_np[CYfapf_index] = datafile_ny;
2914           if (CYfapf_first==true)
2915             {
2916               if (CYfapf_nice == 1)
2917                 {
2918                   CYfapf_na_nice = datafile_nxArray[1];
2919                   CYfapf_np_nice = datafile_ny;
2920                   d_1_to_1(datafile_yArray, CYfapf_pArray_nice);
2921                   for (i=1; i<=CYfapf_na_nice; i++)
2922                     CYfapf_aArray_nice[i] = datafile_xArray[1][i];
2923                 }
2924               aeroSideforceParts -> storeCommands (*command_line);
2925               CYfapf_first=false;
2926             }
2927           break;
2928         }
2929       case CYfarf_flag:
2930         {
2931           int CYfarf_index, i;
2932           string CYfarf_file;
2933           double flap_value;
2934           CYfarf_file = aircraft_directory + linetoken3;
2935           token4 >> CYfarf_index;
2936           if (CYfarf_index < 0 || CYfarf_index >= 30)
2937             uiuc_warnings_errors(1, *command_line);
2938           if (CYfarf_index > CYfarf_nf)
2939             CYfarf_nf = CYfarf_index;
2940           token5 >> flap_value;
2941           CYfarf_fArray[CYfarf_index] = flap_value;
2942           token6 >> token_value_convert1;
2943           token7 >> token_value_convert2;
2944           token8 >> token_value_convert3;
2945           token9 >> CYfarf_nice;
2946           convert_z = uiuc_convert(token_value_convert1);
2947           convert_x = uiuc_convert(token_value_convert2);
2948           convert_y = uiuc_convert(token_value_convert3);
2949           /* call 2D File Reader with file name (CYfarf_file) and
2950              conversion factors; function returns array of
2951              elevator deflections (deArray) and corresponding
2952              alpha (aArray) and delta CZ (CZArray) values and
2953              max number of terms in alpha arrays (nAlphaArray)
2954              and delfection array (nde) */
2955           uiuc_2DdataFileReader(CYfarf_file,
2956                                 datafile_xArray,
2957                                 datafile_yArray,
2958                                 datafile_zArray,
2959                                 datafile_nxArray,
2960                                 datafile_ny);
2961           d_2_to_3(datafile_xArray, CYfarf_aArray, CYfarf_index);
2962           d_1_to_2(datafile_yArray, CYfarf_rArray, CYfarf_index);
2963           d_2_to_3(datafile_zArray, CYfarf_CYArray, CYfarf_index);
2964           i_1_to_2(datafile_nxArray, CYfarf_nAlphaArray, CYfarf_index);
2965           CYfarf_nr[CYfarf_index] = datafile_ny;
2966           if (CYfarf_first==true)
2967             {
2968               if (CYfarf_nice == 1)
2969                 {
2970                   CYfarf_na_nice = datafile_nxArray[1];
2971                   CYfarf_nr_nice = datafile_ny;
2972                   d_1_to_1(datafile_yArray, CYfarf_rArray_nice);
2973                   for (i=1; i<=CYfarf_na_nice; i++)
2974                     CYfarf_aArray_nice[i] = datafile_xArray[1][i];
2975                 }
2976               aeroSideforceParts -> storeCommands (*command_line);
2977               CYfarf_first=false;
2978             }
2979           break;
2980         }
2981       default:
2982         {
2983           if (dont_ignore)
2984             uiuc_warnings_errors(2, *command_line);
2985           break;
2986         }
2987       };
2988 }
2989
2990 void parse_Cl( const string& linetoken2, const string& linetoken3,
2991                const string& linetoken4, const string& linetoken5,
2992                const string& linetoken6, const string& linetoken7,
2993                const string& linetoken8, const string& linetoken9,
2994                const string& aircraft_directory,
2995                bool &Clfabetaf_first, bool &Clfadaf_first,
2996                bool &Clfadrf_first, bool &Clfapf_first,
2997                bool &Clfarf_first, LIST command_line ) {
2998     double token_value;
2999     int token_value_convert1, token_value_convert2, token_value_convert3;
3000     double datafile_xArray[100][100], datafile_yArray[100];
3001     double datafile_zArray[100][100];
3002     int datafile_nxArray[100], datafile_ny;
3003     istrstream token3(linetoken3.c_str());
3004     istrstream token4(linetoken4.c_str());
3005     istrstream token5(linetoken5.c_str());
3006     istrstream token6(linetoken6.c_str());
3007     istrstream token7(linetoken7.c_str());
3008     istrstream token8(linetoken8.c_str());
3009     istrstream token9(linetoken9.c_str());
3010
3011     switch(Cl_map[linetoken2])
3012       {
3013       case Clo_flag:
3014         {
3015           if (check_float(linetoken3))
3016             token3 >> token_value;
3017           else
3018             uiuc_warnings_errors(1, *command_line);
3019
3020           Clo = token_value;
3021           Clo_clean = Clo;
3022           aeroRollParts -> storeCommands (*command_line);
3023           break;
3024         }
3025       case Cl_beta_flag:
3026         {
3027           if (check_float(linetoken3))
3028             token3 >> token_value;
3029           else
3030             uiuc_warnings_errors(1, *command_line);
3031
3032           Cl_beta = token_value;
3033           Cl_beta_clean = Cl_beta;
3034           aeroRollParts -> storeCommands (*command_line);
3035           break;
3036         }
3037       case Cl_p_flag:
3038         {
3039           if (check_float(linetoken3))
3040             token3 >> token_value;
3041           else
3042             uiuc_warnings_errors(1, *command_line);
3043
3044           Cl_p = token_value;
3045           Cl_p_clean = Cl_p;
3046           aeroRollParts -> storeCommands (*command_line);
3047           break;
3048         }
3049       case Cl_r_flag:
3050         {
3051           if (check_float(linetoken3))
3052             token3 >> token_value;
3053           else
3054             uiuc_warnings_errors(1, *command_line);
3055
3056           Cl_r = token_value;
3057           Cl_r_clean = Cl_r;
3058           aeroRollParts -> storeCommands (*command_line);
3059           break;
3060         }
3061       case Cl_da_flag:
3062         {
3063           if (check_float(linetoken3))
3064             token3 >> token_value;
3065           else
3066             uiuc_warnings_errors(1, *command_line);
3067
3068           Cl_da = token_value;
3069           Cl_da_clean = Cl_da;
3070           aeroRollParts -> storeCommands (*command_line);
3071           break;
3072         }
3073       case Cl_dr_flag:
3074         {
3075           if (check_float(linetoken3))
3076             token3 >> token_value;
3077           else
3078             uiuc_warnings_errors(1, *command_line);
3079
3080           Cl_dr = token_value;
3081           Cl_dr_clean = Cl_dr;
3082           aeroRollParts -> storeCommands (*command_line);
3083           break;
3084         }
3085       case Cl_daa_flag:
3086         {
3087           if (check_float(linetoken3))
3088             token3 >> token_value;
3089           else
3090             uiuc_warnings_errors(1, *command_line);
3091
3092           Cl_daa = token_value;
3093           Cl_daa_clean = Cl_daa;
3094           aeroRollParts -> storeCommands (*command_line);
3095           break;
3096         }
3097       case Clfada_flag:
3098         {
3099           Clfada = aircraft_directory + linetoken3;
3100           token4 >> token_value_convert1;
3101           token5 >> token_value_convert2;
3102           token6 >> token_value_convert3;
3103           convert_z = uiuc_convert(token_value_convert1);
3104           convert_x = uiuc_convert(token_value_convert2);
3105           convert_y = uiuc_convert(token_value_convert3);
3106           /* call 2D File Reader with file name (Clfada) and
3107              conversion factors; function returns array of
3108              aileron deflections (daArray) and corresponding
3109              alpha (aArray) and delta Cl (ClArray) values and
3110              max number of terms in alpha arrays (nAlphaArray)
3111              and deflection array (nda) */
3112           uiuc_2DdataFileReader(Clfada,
3113                                 Clfada_aArray,
3114                                 Clfada_daArray,
3115                                 Clfada_ClArray,
3116                                 Clfada_nAlphaArray,
3117                                 Clfada_nda);
3118           aeroRollParts -> storeCommands (*command_line);
3119           break;
3120         }
3121       case Clfbetadr_flag:
3122         {
3123           Clfbetadr = aircraft_directory + linetoken3;
3124           token4 >> token_value_convert1;
3125           token5 >> token_value_convert2;
3126           token6 >> token_value_convert3;
3127           convert_z = uiuc_convert(token_value_convert1);
3128           convert_x = uiuc_convert(token_value_convert2);
3129           convert_y = uiuc_convert(token_value_convert3);
3130           /* call 2D File Reader with file name (Clfbetadr) and
3131              conversion factors; function returns array of
3132              rudder deflections (drArray) and corresponding
3133              beta (betaArray) and delta Cl (ClArray) values and
3134              max number of terms in beta arrays (nBetaArray)
3135              and deflection array (ndr) */
3136           uiuc_2DdataFileReader(Clfbetadr,
3137                                 Clfbetadr_betaArray,
3138                                 Clfbetadr_drArray,
3139                                 Clfbetadr_ClArray,
3140                                 Clfbetadr_nBetaArray,
3141                                 Clfbetadr_ndr);
3142           aeroRollParts -> storeCommands (*command_line);
3143           break;
3144         }
3145       case Clfabetaf_flag:
3146         {
3147           int Clfabetaf_index, i;
3148           string Clfabetaf_file;
3149           double flap_value;
3150           Clfabetaf_file = aircraft_directory + linetoken3;
3151           token4 >> Clfabetaf_index;
3152           if (Clfabetaf_index < 0 || Clfabetaf_index >= 100)
3153             uiuc_warnings_errors(1, *command_line);
3154           if (Clfabetaf_index > Clfabetaf_nf)
3155             Clfabetaf_nf = Clfabetaf_index;
3156           token5 >> flap_value;
3157           Clfabetaf_fArray[Clfabetaf_index] = flap_value;
3158           token6 >> token_value_convert1;
3159           token7 >> token_value_convert2;
3160           token8 >> token_value_convert3;
3161           token9 >> Clfabetaf_nice;
3162           convert_z = uiuc_convert(token_value_convert1);
3163           convert_x = uiuc_convert(token_value_convert2);
3164           convert_y = uiuc_convert(token_value_convert3);
3165           /* call 2D File Reader with file name (Clfabetaf_file) and
3166              conversion factors; function returns array of
3167              elevator deflections (deArray) and corresponding
3168              alpha (aArray) and delta CZ (CZArray) values and
3169              max number of terms in alpha arrays (nAlphaArray)
3170              and delfection array (nde) */
3171           uiuc_2DdataFileReader(Clfabetaf_file,
3172                                 datafile_xArray,
3173                                 datafile_yArray,
3174                                 datafile_zArray,
3175                                 datafile_nxArray,
3176                                 datafile_ny);
3177           d_2_to_3(datafile_xArray, Clfabetaf_aArray, Clfabetaf_index);
3178           d_1_to_2(datafile_yArray, Clfabetaf_betaArray, Clfabetaf_index);
3179           d_2_to_3(datafile_zArray, Clfabetaf_ClArray, Clfabetaf_index);
3180           i_1_to_2(datafile_nxArray, Clfabetaf_nAlphaArray, Clfabetaf_index);
3181           Clfabetaf_nbeta[Clfabetaf_index] = datafile_ny;
3182           if (Clfabetaf_first==true)
3183             {
3184               if (Clfabetaf_nice == 1)
3185                 {
3186                   Clfabetaf_na_nice = datafile_nxArray[1];
3187                   Clfabetaf_nb_nice = datafile_ny;
3188                   d_1_to_1(datafile_yArray, Clfabetaf_bArray_nice);
3189                   for (i=1; i<=Clfabetaf_na_nice; i++)
3190                     Clfabetaf_aArray_nice[i] = datafile_xArray[1][i];
3191                 }
3192               aeroRollParts -> storeCommands (*command_line);
3193               Clfabetaf_first=false;
3194             }
3195           break;
3196         }
3197       case Clfadaf_flag:
3198         {
3199           int Clfadaf_index, i;
3200           string Clfadaf_file;
3201           double flap_value;
3202           Clfadaf_file = aircraft_directory + linetoken3;
3203           token4 >> Clfadaf_index;
3204           if (Clfadaf_index < 0 || Clfadaf_index >= 100)
3205             uiuc_warnings_errors(1, *command_line);
3206           if (Clfadaf_index > Clfadaf_nf)
3207             Clfadaf_nf = Clfadaf_index;
3208           token5 >> flap_value;
3209           Clfadaf_fArray[Clfadaf_index] = flap_value;
3210           token6 >> token_value_convert1;
3211           token7 >> token_value_convert2;
3212           token8 >> token_value_convert3;
3213           token9 >> Clfadaf_nice;
3214           convert_z = uiuc_convert(token_value_convert1);
3215           convert_x = uiuc_convert(token_value_convert2);
3216           convert_y = uiuc_convert(token_value_convert3);
3217           /* call 2D File Reader with file name (Clfadaf_file) and
3218              conversion factors; function returns array of
3219              elevator deflections (deArray) and corresponding
3220              alpha (aArray) and delta CZ (CZArray) values and
3221              max number of terms in alpha arrays (nAlphaArray)
3222              and delfection array (nde) */
3223           uiuc_2DdataFileReader(Clfadaf_file,
3224                                 datafile_xArray,
3225                                 datafile_yArray,
3226                                 datafile_zArray,
3227                                 datafile_nxArray,
3228                                 datafile_ny);
3229           d_2_to_3(datafile_xArray, Clfadaf_aArray, Clfadaf_index);
3230           d_1_to_2(datafile_yArray, Clfadaf_daArray, Clfadaf_index);
3231           d_2_to_3(datafile_zArray, Clfadaf_ClArray, Clfadaf_index);
3232           i_1_to_2(datafile_nxArray, Clfadaf_nAlphaArray, Clfadaf_index);
3233           Clfadaf_nda[Clfadaf_index] = datafile_ny;
3234           if (Clfadaf_first==true)
3235             {
3236               if (Clfadaf_nice == 1)
3237                 {
3238                   Clfadaf_na_nice = datafile_nxArray[1];
3239                   Clfadaf_nda_nice = datafile_ny;
3240                   d_1_to_1(datafile_yArray, Clfadaf_daArray_nice);
3241                   for (i=1; i<=Clfadaf_na_nice; i++)
3242                     Clfadaf_aArray_nice[i] = datafile_xArray[1][i];
3243                 }
3244               aeroRollParts -> storeCommands (*command_line);
3245               Clfadaf_first=false;
3246             }
3247           break;
3248         }
3249       case Clfadrf_flag:
3250         {
3251           int Clfadrf_index, i;
3252           string Clfadrf_file;
3253           double flap_value;
3254           Clfadrf_file = aircraft_directory + linetoken3;
3255           token4 >> Clfadrf_index;
3256           if (Clfadrf_index < 0 || Clfadrf_index >= 100)
3257             uiuc_warnings_errors(1, *command_line);
3258           if (Clfadrf_index > Clfadrf_nf)
3259             Clfadrf_nf = Clfadrf_index;
3260           token5 >> flap_value;
3261           Clfadrf_fArray[Clfadrf_index] = flap_value;
3262           token6 >> token_value_convert1;
3263           token7 >> token_value_convert2;
3264           token8 >> token_value_convert3;
3265           token9 >> Clfadrf_nice;
3266           convert_z = uiuc_convert(token_value_convert1);
3267           convert_x = uiuc_convert(token_value_convert2);
3268           convert_y = uiuc_convert(token_value_convert3);
3269           /* call 2D File Reader with file name (Clfadrf_file) and
3270              conversion factors; function returns array of
3271              elevator deflections (deArray) and corresponding
3272              alpha (aArray) and delta CZ (CZArray) values and
3273              max number of terms in alpha arrays (nAlphaArray)
3274              and delfection array (nde) */
3275           uiuc_2DdataFileReader(Clfadrf_file,
3276                                 datafile_xArray,
3277                                 datafile_yArray,
3278                                 datafile_zArray,
3279                                 datafile_nxArray,
3280                                 datafile_ny);
3281           d_2_to_3(datafile_xArray, Clfadrf_aArray, Clfadrf_index);
3282           d_1_to_2(datafile_yArray, Clfadrf_drArray, Clfadrf_index);
3283           d_2_to_3(datafile_zArray, Clfadrf_ClArray, Clfadrf_index);
3284           i_1_to_2(datafile_nxArray, Clfadrf_nAlphaArray, Clfadrf_index);
3285           Clfadrf_ndr[Clfadrf_index] = datafile_ny;
3286           if (Clfadrf_first==true)
3287             {
3288               if (Clfadrf_nice == 1)
3289                 {
3290                   Clfadrf_na_nice = datafile_nxArray[1];
3291                   Clfadrf_ndr_nice = datafile_ny;
3292                   d_1_to_1(datafile_yArray, Clfadrf_drArray_nice);
3293                   for (i=1; i<=Clfadrf_na_nice; i++)
3294                     Clfadrf_aArray_nice[i] = datafile_xArray[1][i];
3295                 }
3296               aeroRollParts -> storeCommands (*command_line);
3297               Clfadrf_first=false;
3298             }
3299           break;
3300         }
3301       case Clfapf_flag:
3302         {
3303           int Clfapf_index, i;
3304           string Clfapf_file;
3305           double flap_value;
3306           Clfapf_file = aircraft_directory + linetoken3;
3307           token4 >> Clfapf_index;
3308           if (Clfapf_index < 0 || Clfapf_index >= 100)
3309             uiuc_warnings_errors(1, *command_line);
3310           if (Clfapf_index > Clfapf_nf)
3311             Clfapf_nf = Clfapf_index;
3312           token5 >> flap_value;
3313           Clfapf_fArray[Clfapf_index] = flap_value;
3314           token6 >> token_value_convert1;
3315           token7 >> token_value_convert2;
3316           token8 >> token_value_convert3;
3317           token9 >> Clfapf_nice;
3318           convert_z = uiuc_convert(token_value_convert1);
3319           convert_x = uiuc_convert(token_value_convert2);
3320           convert_y = uiuc_convert(token_value_convert3);
3321           /* call 2D File Reader with file name (Clfapf_file) and
3322              conversion factors; function returns array of
3323              elevator deflections (deArray) and corresponding
3324              alpha (aArray) and delta CZ (CZArray) values and
3325              max number of terms in alpha arrays (nAlphaArray)
3326              and delfection array (nde) */
3327           uiuc_2DdataFileReader(Clfapf_file,
3328                                 datafile_xArray,
3329                                 datafile_yArray,
3330                                 datafile_zArray,
3331                                 datafile_nxArray,
3332                                 datafile_ny);
3333           d_2_to_3(datafile_xArray, Clfapf_aArray, Clfapf_index);
3334           d_1_to_2(datafile_yArray, Clfapf_pArray, Clfapf_index);
3335           d_2_to_3(datafile_zArray, Clfapf_ClArray, Clfapf_index);
3336           i_1_to_2(datafile_nxArray, Clfapf_nAlphaArray, Clfapf_index);
3337           Clfapf_np[Clfapf_index] = datafile_ny;
3338           if (Clfapf_first==true)
3339             {
3340               if (Clfapf_nice == 1)
3341                 {
3342                   Clfapf_na_nice = datafile_nxArray[1];
3343                   Clfapf_np_nice = datafile_ny;
3344                   d_1_to_1(datafile_yArray, Clfapf_pArray_nice);
3345                   for (i=1; i<=Clfapf_na_nice; i++)
3346                     Clfapf_aArray_nice[i] = datafile_xArray[1][i];
3347                 }
3348               aeroRollParts -> storeCommands (*command_line);
3349               Clfapf_first=false;
3350             }
3351           break;
3352         }
3353       case Clfarf_flag:
3354         {
3355           int Clfarf_index, i;
3356           string Clfarf_file;
3357           double flap_value;
3358           Clfarf_file = aircraft_directory + linetoken3;
3359           token4 >> Clfarf_index;
3360           if (Clfarf_index < 0 || Clfarf_index >= 100)
3361             uiuc_warnings_errors(1, *command_line);
3362           if (Clfarf_index > Clfarf_nf)
3363             Clfarf_nf = Clfarf_index;
3364           token5 >> flap_value;
3365           Clfarf_fArray[Clfarf_index] = flap_value;
3366           token6 >> token_value_convert1;
3367           token7 >> token_value_convert2;
3368           token8 >> token_value_convert3;
3369           token9 >> Clfarf_nice;
3370           convert_z = uiuc_convert(token_value_convert1);
3371           convert_x = uiuc_convert(token_value_convert2);
3372           convert_y = uiuc_convert(token_value_convert3);
3373           /* call 2D File Reader with file name (Clfarf_file) and
3374              conversion factors; function returns array of
3375              elevator deflections (deArray) and corresponding
3376              alpha (aArray) and delta CZ (CZArray) values and
3377              max number of terms in alpha arrays (nAlphaArray)
3378              and delfection array (nde) */
3379           uiuc_2DdataFileReader(Clfarf_file,
3380                                 datafile_xArray,
3381                                 datafile_yArray,
3382                                 datafile_zArray,
3383                                 datafile_nxArray,
3384                                 datafile_ny);
3385           d_2_to_3(datafile_xArray, Clfarf_aArray, Clfarf_index);
3386           d_1_to_2(datafile_yArray, Clfarf_rArray, Clfarf_index);
3387           d_2_to_3(datafile_zArray, Clfarf_ClArray, Clfarf_index);
3388           i_1_to_2(datafile_nxArray, Clfarf_nAlphaArray, Clfarf_index);
3389           Clfarf_nr[Clfarf_index] = datafile_ny;
3390           if (Clfarf_first==true)
3391             {
3392               if (Clfarf_nice == 1)
3393                 {
3394                   Clfarf_na_nice = datafile_nxArray[1];
3395                   Clfarf_nr_nice = datafile_ny;
3396                   d_1_to_1(datafile_yArray, Clfarf_rArray_nice);
3397                   for (i=1; i<=Clfarf_na_nice; i++)
3398                     Clfarf_aArray_nice[i] = datafile_xArray[1][i];
3399                 }
3400               aeroRollParts -> storeCommands (*command_line);
3401               Clfarf_first=false;
3402             }
3403           break;
3404         }
3405       default:
3406         {
3407           if (dont_ignore)
3408             uiuc_warnings_errors(2, *command_line);
3409           break;
3410         }
3411       };
3412 }
3413
3414
3415 void parse_Cn( const string& linetoken2, const string& linetoken3,
3416                const string& linetoken4, const string& linetoken5,
3417                const string& linetoken6, const string& linetoken7,
3418                const string& linetoken8, const string& linetoken9,
3419                const string& aircraft_directory,
3420                bool &Cnfabetaf_first, bool &Cnfadaf_first,
3421                bool &Cnfadrf_first, bool &Cnfapf_first,
3422                bool &Cnfarf_first, LIST command_line ) {
3423     double token_value;
3424     int token_value_convert1, token_value_convert2, token_value_convert3;
3425     double datafile_xArray[100][100], datafile_yArray[100];
3426     double datafile_zArray[100][100];
3427     int datafile_nxArray[100], datafile_ny;
3428     istrstream token3(linetoken3.c_str());
3429     istrstream token4(linetoken4.c_str());
3430     istrstream token5(linetoken5.c_str());
3431     istrstream token6(linetoken6.c_str());
3432     istrstream token7(linetoken7.c_str());
3433     istrstream token8(linetoken8.c_str());
3434     istrstream token9(linetoken9.c_str());
3435
3436     switch(Cn_map[linetoken2])
3437       {
3438       case Cno_flag:
3439         {
3440           if (check_float(linetoken3))
3441             token3 >> token_value;
3442           else
3443             uiuc_warnings_errors(1, *command_line);
3444
3445           Cno = token_value;
3446           Cno_clean = Cno;
3447           aeroYawParts -> storeCommands (*command_line);
3448           break;
3449         }
3450       case Cn_beta_flag:
3451         {
3452           if (check_float(linetoken3))
3453             token3 >> token_value;
3454           else
3455             uiuc_warnings_errors(1, *command_line);
3456
3457           Cn_beta = token_value;
3458           Cn_beta_clean = Cn_beta;
3459           aeroYawParts -> storeCommands (*command_line);
3460           break;
3461         }
3462       case Cn_p_flag:
3463         {
3464           if (check_float(linetoken3))
3465             token3 >> token_value;
3466           else
3467             uiuc_warnings_errors(1, *command_line);
3468
3469           Cn_p = token_value;
3470           Cn_p_clean = Cn_p;
3471           aeroYawParts -> storeCommands (*command_line);
3472           break;
3473         }
3474       case Cn_r_flag:
3475         {
3476           if (check_float(linetoken3))
3477             token3 >> token_value;
3478           else
3479             uiuc_warnings_errors(1, *command_line);
3480
3481           Cn_r = token_value;
3482           Cn_r_clean = Cn_r;
3483           aeroYawParts -> storeCommands (*command_line);
3484           break;
3485         }
3486       case Cn_da_flag:
3487         {
3488           if (check_float(linetoken3))
3489             token3 >> token_value;
3490           else
3491             uiuc_warnings_errors(1, *command_line);
3492
3493           Cn_da = token_value;
3494           Cn_da_clean = Cn_da;
3495           aeroYawParts -> storeCommands (*command_line);
3496           break;
3497         }
3498       case Cn_dr_flag:
3499         {
3500           if (check_float(linetoken3))
3501             token3 >> token_value;
3502           else
3503             uiuc_warnings_errors(1, *command_line);
3504
3505           Cn_dr = token_value;
3506           Cn_dr_clean = Cn_dr;
3507           aeroYawParts -> storeCommands (*command_line);
3508           break;
3509         }
3510       case Cn_q_flag:
3511         {
3512           if (check_float(linetoken3))
3513             token3 >> token_value;
3514           else
3515             uiuc_warnings_errors(1, *command_line);
3516
3517           Cn_q = token_value;
3518           Cn_q_clean = Cn_q;
3519           aeroYawParts -> storeCommands (*command_line);
3520           break;
3521         }
3522       case Cn_b3_flag:
3523         {
3524           if (check_float(linetoken3))
3525             token3 >> token_value;
3526           else
3527             uiuc_warnings_errors(1, *command_line);
3528
3529           Cn_b3 = token_value;
3530           Cn_b3_clean = Cn_b3;
3531           aeroYawParts -> storeCommands (*command_line);
3532           break;
3533         }
3534       case Cnfada_flag:
3535         {
3536           Cnfada = aircraft_directory + linetoken3;
3537           token4 >> token_value_convert1;
3538           token5 >> token_value_convert2;
3539           token6 >> token_value_convert3;
3540           convert_z = uiuc_convert(token_value_convert1);
3541           convert_x = uiuc_convert(token_value_convert2);
3542           convert_y = uiuc_convert(token_value_convert3);
3543           /* call 2D File Reader with file name (Cnfada) and
3544              conversion factors; function returns array of
3545              aileron deflections (daArray) and corresponding
3546              alpha (aArray) and delta Cn (CnArray) values and
3547              max number of terms in alpha arrays (nAlphaArray)
3548              and deflection array (nda) */
3549           uiuc_2DdataFileReader(Cnfada,
3550                                 Cnfada_aArray,
3551                                 Cnfada_daArray,
3552                                 Cnfada_CnArray,
3553                                 Cnfada_nAlphaArray,
3554                                 Cnfada_nda);
3555           aeroYawParts -> storeCommands (*command_line);
3556           break;
3557         }
3558       case Cnfbetadr_flag:
3559         {
3560           Cnfbetadr = aircraft_directory + linetoken3;
3561           token4 >> token_value_convert1;
3562           token5 >> token_value_convert2;
3563           token6 >> token_value_convert3;
3564           convert_z = uiuc_convert(token_value_convert1);
3565           convert_x = uiuc_convert(token_value_convert2);
3566           convert_y = uiuc_convert(token_value_convert3);
3567           /* call 2D File Reader with file name (Cnfbetadr) and
3568              conversion factors; function returns array of
3569              rudder deflections (drArray) and corresponding
3570              beta (betaArray) and delta Cn (CnArray) values and
3571              max number of terms in beta arrays (nBetaArray)
3572              and deflection array (ndr) */
3573           uiuc_2DdataFileReader(Cnfbetadr,
3574                                 Cnfbetadr_betaArray,
3575                                 Cnfbetadr_drArray,
3576                                 Cnfbetadr_CnArray,
3577                                 Cnfbetadr_nBetaArray,
3578                                 Cnfbetadr_ndr);
3579           aeroYawParts -> storeCommands (*command_line);
3580           break;
3581         }
3582       case Cnfabetaf_flag:
3583         {
3584           int Cnfabetaf_index, i;
3585           string Cnfabetaf_file;
3586           double flap_value;
3587           Cnfabetaf_file = aircraft_directory + linetoken3;
3588           token4 >> Cnfabetaf_index;
3589           if (Cnfabetaf_index < 0 || Cnfabetaf_index >= 100)
3590             uiuc_warnings_errors(1, *command_line);
3591           if (Cnfabetaf_index > Cnfabetaf_nf)
3592             Cnfabetaf_nf = Cnfabetaf_index;
3593           token5 >> flap_value;
3594           Cnfabetaf_fArray[Cnfabetaf_index] = flap_value;
3595           token6 >> token_value_convert1;
3596           token7 >> token_value_convert2;
3597           token8 >> token_value_convert3;
3598           token9 >> Cnfabetaf_nice;
3599           convert_z = uiuc_convert(token_value_convert1);
3600           convert_x = uiuc_convert(token_value_convert2);
3601           convert_y = uiuc_convert(token_value_convert3);
3602           /* call 2D File Reader with file name (Cnfabetaf_file) and
3603              conversion factors; function returns array of
3604              elevator deflections (deArray) and corresponding
3605              alpha (aArray) and delta CZ (CZArray) values and
3606              max number of terms in alpha arrays (nAlphaArray)
3607              and delfection array (nde) */
3608           uiuc_2DdataFileReader(Cnfabetaf_file,
3609                                 datafile_xArray,
3610                                 datafile_yArray,
3611                                 datafile_zArray,
3612                                 datafile_nxArray,
3613                                 datafile_ny);
3614           d_2_to_3(datafile_xArray, Cnfabetaf_aArray, Cnfabetaf_index);
3615           d_1_to_2(datafile_yArray, Cnfabetaf_betaArray, Cnfabetaf_index);
3616           d_2_to_3(datafile_zArray, Cnfabetaf_CnArray, Cnfabetaf_index);
3617           i_1_to_2(datafile_nxArray, Cnfabetaf_nAlphaArray, Cnfabetaf_index);
3618           Cnfabetaf_nbeta[Cnfabetaf_index] = datafile_ny;
3619           if (Cnfabetaf_first==true)
3620             {
3621               if (Cnfabetaf_nice == 1)
3622                 {
3623                   Cnfabetaf_na_nice = datafile_nxArray[1];
3624                   Cnfabetaf_nb_nice = datafile_ny;
3625                   d_1_to_1(datafile_yArray, Cnfabetaf_bArray_nice);
3626                   for (i=1; i<=Cnfabetaf_na_nice; i++)
3627                     Cnfabetaf_aArray_nice[i] = datafile_xArray[1][i];
3628                 }
3629               aeroYawParts -> storeCommands (*command_line);
3630               Cnfabetaf_first=false;
3631             }
3632           break;
3633         }
3634       case Cnfadaf_flag:
3635         {
3636           int Cnfadaf_index, i;
3637           string Cnfadaf_file;
3638           double flap_value;
3639           Cnfadaf_file = aircraft_directory + linetoken3;
3640           token4 >> Cnfadaf_index;
3641           if (Cnfadaf_index < 0 || Cnfadaf_index >= 100)
3642             uiuc_warnings_errors(1, *command_line);
3643           if (Cnfadaf_index > Cnfadaf_nf)
3644             Cnfadaf_nf = Cnfadaf_index;
3645           token5 >> flap_value;
3646           Cnfadaf_fArray[Cnfadaf_index] = flap_value;
3647           token6 >> token_value_convert1;
3648           token7 >> token_value_convert2;
3649           token8 >> token_value_convert3;
3650           token9 >> Cnfadaf_nice;
3651           convert_z = uiuc_convert(token_value_convert1);
3652           convert_x = uiuc_convert(token_value_convert2);
3653           convert_y = uiuc_convert(token_value_convert3);
3654           /* call 2D File Reader with file name (Cnfadaf_file) and
3655              conversion factors; function returns array of
3656              elevator deflections (deArray) and corresponding
3657              alpha (aArray) and delta CZ (CZArray) values and
3658              max number of terms in alpha arrays (nAlphaArray)
3659              and delfection array (nde) */
3660           uiuc_2DdataFileReader(Cnfadaf_file,
3661                                 datafile_xArray,
3662                                 datafile_yArray,
3663                                 datafile_zArray,
3664                                 datafile_nxArray,
3665                                 datafile_ny);
3666           d_2_to_3(datafile_xArray, Cnfadaf_aArray, Cnfadaf_index);
3667           d_1_to_2(datafile_yArray, Cnfadaf_daArray, Cnfadaf_index);
3668           d_2_to_3(datafile_zArray, Cnfadaf_CnArray, Cnfadaf_index);
3669           i_1_to_2(datafile_nxArray, Cnfadaf_nAlphaArray, Cnfadaf_index);
3670           Cnfadaf_nda[Cnfadaf_index] = datafile_ny;
3671           if (Cnfadaf_first==true)
3672             {
3673               if (Cnfadaf_nice == 1)
3674                 {
3675                   Cnfadaf_na_nice = datafile_nxArray[1];
3676                   Cnfadaf_nda_nice = datafile_ny;
3677                   d_1_to_1(datafile_yArray, Cnfadaf_daArray_nice);
3678                   for (i=1; i<=Cnfadaf_na_nice; i++)
3679                     Cnfadaf_aArray_nice[i] = datafile_xArray[1][i];
3680                 }
3681               aeroYawParts -> storeCommands (*command_line);
3682               Cnfadaf_first=false;
3683             }
3684           break;
3685         }
3686       case Cnfadrf_flag:
3687         {
3688           int Cnfadrf_index, i;
3689           string Cnfadrf_file;
3690           double flap_value;
3691           Cnfadrf_file = aircraft_directory + linetoken3;
3692           token4 >> Cnfadrf_index;
3693           if (Cnfadrf_index < 0 || Cnfadrf_index >= 100)
3694             uiuc_warnings_errors(1, *command_line);
3695           if (Cnfadrf_index > Cnfadrf_nf)
3696             Cnfadrf_nf = Cnfadrf_index;
3697           token5 >> flap_value;
3698           Cnfadrf_fArray[Cnfadrf_index] = flap_value;
3699           token6 >> token_value_convert1;
3700           token7 >> token_value_convert2;
3701           token8 >> token_value_convert3;
3702           token9 >> Cnfadrf_nice;
3703           convert_z = uiuc_convert(token_value_convert1);
3704           convert_x = uiuc_convert(token_value_convert2);
3705           convert_y = uiuc_convert(token_value_convert3);
3706           /* call 2D File Reader with file name (Cnfadrf_file) and
3707              conversion factors; function returns array of
3708              elevator deflections (deArray) and corresponding
3709              alpha (aArray) and delta CZ (CZArray) values and
3710              max number of terms in alpha arrays (nAlphaArray)
3711              and delfection array (nde) */
3712           uiuc_2DdataFileReader(Cnfadrf_file,
3713                                 datafile_xArray,
3714                                 datafile_yArray,
3715                                 datafile_zArray,
3716                                 datafile_nxArray,
3717                                 datafile_ny);
3718           d_2_to_3(datafile_xArray, Cnfadrf_aArray, Cnfadrf_index);
3719           d_1_to_2(datafile_yArray, Cnfadrf_drArray, Cnfadrf_index);
3720           d_2_to_3(datafile_zArray, Cnfadrf_CnArray, Cnfadrf_index);
3721           i_1_to_2(datafile_nxArray, Cnfadrf_nAlphaArray, Cnfadrf_index);
3722           Cnfadrf_ndr[Cnfadrf_index] = datafile_ny;
3723           if (Cnfadrf_first==true)
3724             {
3725               if (Cnfadrf_nice == 1)
3726                 {
3727                   Cnfadrf_na_nice = datafile_nxArray[1];
3728                   Cnfadrf_ndr_nice = datafile_ny;
3729                   d_1_to_1(datafile_yArray, Cnfadrf_drArray_nice);
3730                   for (i=1; i<=Cnfadrf_na_nice; i++)
3731                     Cnfadrf_aArray_nice[i] = datafile_xArray[1][i];
3732                 }
3733               aeroYawParts -> storeCommands (*command_line);
3734               Cnfadrf_first=false;
3735             }
3736           break;
3737         }
3738       case Cnfapf_flag:
3739         {
3740           int Cnfapf_index, i;
3741           string Cnfapf_file;
3742           double flap_value;
3743           Cnfapf_file = aircraft_directory + linetoken3;
3744           token4 >> Cnfapf_index;
3745           if (Cnfapf_index < 0 || Cnfapf_index >= 100)
3746             uiuc_warnings_errors(1, *command_line);
3747           if (Cnfapf_index > Cnfapf_nf)
3748             Cnfapf_nf = Cnfapf_index;
3749           token5 >> flap_value;
3750           Cnfapf_fArray[Cnfapf_index] = flap_value;
3751           token6 >> token_value_convert1;
3752           token7 >> token_value_convert2;
3753           token8 >> token_value_convert3;
3754           token9 >> Cnfapf_nice;
3755           convert_z = uiuc_convert(token_value_convert1);
3756           convert_x = uiuc_convert(token_value_convert2);
3757           convert_y = uiuc_convert(token_value_convert3);
3758           /* call 2D File Reader with file name (Cnfapf_file) and
3759              conversion factors; function returns array of
3760              elevator deflections (deArray) and corresponding
3761              alpha (aArray) and delta CZ (CZArray) values and
3762              max number of terms in alpha arrays (nAlphaArray)
3763              and delfection array (nde) */
3764           uiuc_2DdataFileReader(Cnfapf_file,
3765                                 datafile_xArray,
3766                                 datafile_yArray,
3767                                 datafile_zArray,
3768                                 datafile_nxArray,
3769                                 datafile_ny);
3770           d_2_to_3(datafile_xArray, Cnfapf_aArray, Cnfapf_index);
3771           d_1_to_2(datafile_yArray, Cnfapf_pArray, Cnfapf_index);
3772           d_2_to_3(datafile_zArray, Cnfapf_CnArray, Cnfapf_index);
3773           i_1_to_2(datafile_nxArray, Cnfapf_nAlphaArray, Cnfapf_index);
3774           Cnfapf_np[Cnfapf_index] = datafile_ny;
3775           if (Cnfapf_first==true)
3776             {
3777               if (Cnfapf_nice == 1)
3778                 {
3779                   Cnfapf_na_nice = datafile_nxArray[1];
3780                   Cnfapf_np_nice = datafile_ny;
3781                   d_1_to_1(datafile_yArray, Cnfapf_pArray_nice);
3782                   for (i=1; i<=Cnfapf_na_nice; i++)
3783                     Cnfapf_aArray_nice[i] = datafile_xArray[1][i];
3784                 }
3785               aeroYawParts -> storeCommands (*command_line);
3786               Cnfapf_first=false;
3787             }
3788           break;
3789         }
3790       case Cnfarf_flag:
3791         {
3792           int Cnfarf_index, i;
3793           string Cnfarf_file;
3794           double flap_value;
3795           Cnfarf_file = aircraft_directory + linetoken3;
3796           token4 >> Cnfarf_index;
3797           if (Cnfarf_index < 0 || Cnfarf_index >= 100)
3798             uiuc_warnings_errors(1, *command_line);
3799           if (Cnfarf_index > Cnfarf_nf)
3800             Cnfarf_nf = Cnfarf_index;
3801           token5 >> flap_value;
3802           Cnfarf_fArray[Cnfarf_index] = flap_value;
3803           token6 >> token_value_convert1;
3804           token7 >> token_value_convert2;
3805           token8 >> token_value_convert3;
3806           token9 >> Cnfarf_nice;
3807           convert_z = uiuc_convert(token_value_convert1);
3808           convert_x = uiuc_convert(token_value_convert2);
3809           convert_y = uiuc_convert(token_value_convert3);
3810           /* call 2D File Reader with file name (Cnfarf_file) and
3811              conversion factors; function returns array of
3812              elevator deflections (deArray) and corresponding
3813              alpha (aArray) and delta CZ (CZArray) values and
3814              max number of terms in alpha arrays (nAlphaArray)
3815              and delfection array (nde) */
3816           uiuc_2DdataFileReader(Cnfarf_file,
3817                                 datafile_xArray,
3818                                 datafile_yArray,
3819                                 datafile_zArray,
3820                                 datafile_nxArray,
3821                                 datafile_ny);
3822           d_2_to_3(datafile_xArray, Cnfarf_aArray, Cnfarf_index);
3823           d_1_to_2(datafile_yArray, Cnfarf_rArray, Cnfarf_index);
3824           d_2_to_3(datafile_zArray, Cnfarf_CnArray, Cnfarf_index);
3825           i_1_to_2(datafile_nxArray, Cnfarf_nAlphaArray, Cnfarf_index);
3826           Cnfarf_nr[Cnfarf_index] = datafile_ny;
3827           if (Cnfarf_first==true)
3828             {
3829               if (Cnfarf_nice == 1)
3830                 {
3831                   Cnfarf_na_nice = datafile_nxArray[1];
3832                   Cnfarf_nr_nice = datafile_ny;
3833                   d_1_to_1(datafile_yArray, Cnfarf_rArray_nice);
3834                   for (i=1; i<=Cnfarf_na_nice; i++)
3835                     Cnfarf_aArray_nice[i] = datafile_xArray[1][i];
3836                 }
3837               aeroYawParts -> storeCommands (*command_line);
3838               Cnfarf_first=false;
3839             }
3840           break;
3841         }
3842       default:
3843         {
3844           if (dont_ignore)
3845             uiuc_warnings_errors(2, *command_line);
3846           break;
3847         }
3848       };
3849 }
3850
3851 void parse_gear( const string& linetoken2, const string& linetoken3,
3852                  const string& linetoken4, const int& index,
3853                  LIST command_line ) {
3854     double token_value;
3855     istrstream token3(linetoken3.c_str());
3856     istrstream token4(linetoken4.c_str());
3857
3858     switch(gear_map[linetoken2])
3859       {
3860       case Dx_gear_flag:
3861         {
3862           if (check_float(linetoken3))
3863             token4 >> token_value;
3864           else
3865             uiuc_warnings_errors(1, *command_line);
3866           D_gear_v[index][0] = token_value;
3867           gear_model[index] = true;
3868           break;
3869         }
3870       case Dy_gear_flag:
3871         {
3872           if (check_float(linetoken3))
3873             token4 >> token_value;
3874           else
3875             uiuc_warnings_errors(1, *command_line);
3876           D_gear_v[index][1] = token_value;
3877           gear_model[index] = true;
3878           break;
3879         }
3880       case Dz_gear_flag:
3881         {
3882           if (check_float(linetoken3))
3883             token4 >> token_value;
3884           else
3885             uiuc_warnings_errors(1, *command_line);
3886           D_gear_v[index][2] = token_value;
3887           gear_model[index] = true;
3888           break;
3889         }
3890       case cgear_flag:
3891         {
3892           if (check_float(linetoken3))
3893             token4 >> token_value;
3894           else
3895             uiuc_warnings_errors(1, *command_line);
3896           cgear[index] = token_value;
3897           gear_model[index] = true;
3898           break;
3899         }
3900       case kgear_flag:
3901         {
3902           if (check_float(linetoken3))
3903             token4 >> token_value;
3904           else
3905             uiuc_warnings_errors(1, *command_line);
3906           kgear[index] = token_value;
3907           gear_model[index] = true;
3908           break;
3909         }
3910       case muGear_flag:
3911         {
3912           if (check_float(linetoken3))
3913             token4 >> token_value;
3914           else
3915             uiuc_warnings_errors(1, *command_line);
3916           muGear[index] = token_value;
3917           gear_model[index] = true;
3918           break;
3919         }
3920       case strutLength_flag:
3921         {
3922           if (check_float(linetoken3))
3923             token4 >> token_value;
3924           else
3925             uiuc_warnings_errors(1, *command_line);
3926           strutLength[index] = token_value;
3927           gear_model[index] = true;
3928           break;
3929         }
3930       default:
3931         {
3932           if (dont_ignore)
3933             uiuc_warnings_errors(2, *command_line);
3934           break;
3935         }
3936       };
3937 }
3938
3939
3940 void parse_ice( const string& linetoken2, const string& linetoken3,
3941                 const string& linetoken4, LIST command_line ) {
3942     double token_value;
3943     istrstream token3(linetoken3.c_str());
3944     istrstream token4(linetoken4.c_str());
3945
3946     switch(ice_map[linetoken2])
3947       {
3948       case iceTime_flag:
3949         {
3950           if (check_float(linetoken3))
3951             token3 >> token_value;
3952
3953           else
3954             uiuc_warnings_errors(1, *command_line);
3955
3956           ice_model = true;
3957           iceTime = token_value;
3958           break;
3959         }
3960       case transientTime_flag:
3961         {
3962           if (check_float(linetoken3))
3963             token3 >> token_value;
3964           else
3965             uiuc_warnings_errors(1, *command_line);
3966
3967           transientTime = token_value;
3968           break;
3969         }
3970       case eta_ice_final_flag:
3971         {
3972           if (check_float(linetoken3))
3973             token3 >> token_value;
3974           else
3975             uiuc_warnings_errors(1, *command_line);
3976
3977           eta_ice_final = token_value;
3978           break;
3979         }
3980       case beta_probe_wing_flag:
3981         {
3982           if (check_float(linetoken3))
3983             token3 >> token_value;
3984           else
3985             uiuc_warnings_errors(1, *command_line);
3986
3987           beta_model = true;
3988           x_probe_wing = token_value;
3989           break;
3990         }
3991       case beta_probe_tail_flag:
3992         {
3993           if (check_float(linetoken3))
3994             token3 >> token_value;
3995           else
3996             uiuc_warnings_errors(1, *command_line);
3997
3998           beta_model = true;
3999           x_probe_tail = token_value;
4000           break;
4001         }
4002       case kCDo_flag:
4003         {
4004           if (check_float(linetoken3))
4005             token3 >> token_value;
4006           else
4007             uiuc_warnings_errors(1, *command_line);
4008
4009           kCDo = token_value;
4010           break;
4011         }
4012       case kCDK_flag:
4013         {
4014           if (check_float(linetoken3))
4015             token3 >> token_value;
4016           else
4017             uiuc_warnings_errors(1, *command_line);
4018
4019           kCDK = token_value;
4020           break;
4021         }
4022       case kCD_a_flag:
4023         {
4024           if (check_float(linetoken3))
4025             token3 >> token_value;
4026           else
4027             uiuc_warnings_errors(1, *command_line);
4028
4029           kCD_a = token_value;
4030           break;
4031         }
4032       case kCD_adot_flag:
4033         {
4034           if (check_float(linetoken3))
4035             token3 >> token_value;
4036           else
4037             uiuc_warnings_errors(1, *command_line);
4038
4039           kCD_adot = token_value;
4040           break;
4041         }
4042       case kCD_q_flag:
4043         {
4044           if (check_float(linetoken3))
4045             token3 >> token_value;
4046           else
4047             uiuc_warnings_errors(1, *command_line);
4048
4049           kCD_q = token_value;
4050           break;
4051         }
4052       case kCD_de_flag:
4053         {
4054           if (check_float(linetoken3))
4055             token3 >> token_value;
4056           else
4057             uiuc_warnings_errors(1, *command_line);
4058
4059           kCD_de = token_value;
4060           break;
4061         }
4062       case kCXo_flag:
4063         {
4064           if (check_float(linetoken3))
4065             token3 >> token_value;
4066           else
4067             uiuc_warnings_errors(1, *command_line);
4068
4069           kCXo = token_value;
4070           break;
4071         }
4072       case kCXK_flag:
4073         {
4074           if (check_float(linetoken3))
4075             token3 >> token_value;
4076           else
4077             uiuc_warnings_errors(1, *command_line);
4078
4079           kCXK = token_value;
4080           break;
4081         }
4082       case kCX_a_flag:
4083         {
4084           if (check_float(linetoken3))
4085             token3 >> token_value;
4086           else
4087             uiuc_warnings_errors(1, *command_line);
4088
4089           kCX_a = token_value;
4090           break;
4091         }
4092       case kCX_a2_flag:
4093         {
4094           if (check_float(linetoken3))
4095             token3 >> token_value;
4096           else
4097             uiuc_warnings_errors(1, *command_line);
4098
4099           kCX_a2 = token_value;
4100           break;
4101         }
4102       case kCX_a3_flag:
4103         {
4104           if (check_float(linetoken3))
4105             token3 >> token_value;
4106           else
4107             uiuc_warnings_errors(1, *command_line);
4108
4109           kCX_a3 = token_value;
4110           break;
4111         }
4112       case kCX_adot_flag:
4113         {
4114           if (check_float(linetoken3))
4115             token3 >> token_value;
4116           else
4117             uiuc_warnings_errors(1, *command_line);
4118
4119           kCX_adot = token_value;
4120           break;
4121         }
4122       case kCX_q_flag:
4123         {
4124           if (check_float(linetoken3))
4125             token3 >> token_value;
4126           else
4127             uiuc_warnings_errors(1, *command_line);
4128
4129           kCX_q = token_value;
4130           break;
4131         }
4132       case kCX_de_flag:
4133         {
4134           if (check_float(linetoken3))
4135             token3 >> token_value;
4136           else
4137             uiuc_warnings_errors(1, *command_line);
4138
4139           kCX_de = token_value;
4140           break;
4141         }
4142       case kCX_dr_flag:
4143         {
4144           if (check_float(linetoken3))
4145             token3 >> token_value;
4146           else
4147             uiuc_warnings_errors(1, *command_line);
4148
4149           kCX_dr = token_value;
4150           break;
4151         }
4152       case kCX_df_flag:
4153         {
4154           if (check_float(linetoken3))
4155             token3 >> token_value;
4156           else
4157             uiuc_warnings_errors(1, *command_line);
4158
4159           kCX_df = token_value;
4160           break;
4161         }
4162       case kCX_adf_flag:
4163         {
4164           if (check_float(linetoken3))
4165             token3 >> token_value;
4166           else
4167             uiuc_warnings_errors(1, *command_line);
4168
4169           kCX_adf = token_value;
4170           break;
4171         }
4172       case kCLo_flag:
4173         {
4174           if (check_float(linetoken3))
4175             token3 >> token_value;
4176           else
4177             uiuc_warnings_errors(1, *command_line);
4178
4179           kCLo = token_value;
4180           break;
4181         }
4182       case kCL_a_flag:
4183         {
4184           if (check_float(linetoken3))
4185             token3 >> token_value;
4186           else
4187             uiuc_warnings_errors(1, *command_line);
4188
4189           kCL_a = token_value;
4190           break;
4191         }
4192       case kCL_adot_flag:
4193         {
4194           if (check_float(linetoken3))
4195             token3 >> token_value;
4196           else
4197             uiuc_warnings_errors(1, *command_line);
4198
4199           kCL_adot = token_value;
4200           break;
4201         }
4202       case kCL_q_flag:
4203         {
4204           if (check_float(linetoken3))
4205             token3 >> token_value;
4206           else
4207             uiuc_warnings_errors(1, *command_line);
4208
4209           kCL_q = token_value;
4210           break;
4211         }
4212       case kCL_de_flag:
4213         {
4214           if (check_float(linetoken3))
4215             token3 >> token_value;
4216           else
4217             uiuc_warnings_errors(1, *command_line);
4218
4219           kCL_de = token_value;
4220           break;
4221         }
4222       case kCZo_flag:
4223         {
4224           if (check_float(linetoken3))
4225             token3 >> token_value;
4226           else
4227             uiuc_warnings_errors(1, *command_line);
4228
4229           kCZo = token_value;
4230           break;
4231         }
4232       case kCZ_a_flag:
4233         {
4234           if (check_float(linetoken3))
4235             token3 >> token_value;
4236           else
4237             uiuc_warnings_errors(1, *command_line);
4238
4239           kCZ_a = token_value;
4240           break;
4241         }
4242       case kCZ_a2_flag:
4243         {
4244           if (check_float(linetoken3))
4245             token3 >> token_value;
4246           else
4247             uiuc_warnings_errors(1, *command_line);
4248
4249           kCZ_a2 = token_value;
4250           break;
4251         }
4252       case kCZ_a3_flag:
4253         {
4254           if (check_float(linetoken3))
4255             token3 >> token_value;
4256           else
4257             uiuc_warnings_errors(1, *command_line);
4258
4259           kCZ_a3 = token_value;
4260           break;
4261         }
4262       case kCZ_adot_flag:
4263         {
4264           if (check_float(linetoken3))
4265             token3 >> token_value;
4266           else
4267             uiuc_warnings_errors(1, *command_line);
4268
4269           kCZ_adot = token_value;
4270           break;
4271         }
4272       case kCZ_q_flag:
4273         {
4274           if (check_float(linetoken3))
4275             token3 >> token_value;
4276           else
4277             uiuc_warnings_errors(1, *command_line);
4278
4279           kCZ_q = token_value;
4280           break;
4281         }
4282       case kCZ_de_flag:
4283         {
4284           if (check_float(linetoken3))
4285             token3 >> token_value;
4286           else
4287             uiuc_warnings_errors(1, *command_line);
4288
4289           kCZ_de = token_value;
4290           break;
4291         }
4292       case kCZ_deb2_flag:
4293         {
4294           if (check_float(linetoken3))
4295             token3 >> token_value;
4296           else
4297             uiuc_warnings_errors(1, *command_line);
4298
4299           kCZ_deb2 = token_value;
4300           break;
4301         }
4302       case kCZ_df_flag:
4303         {
4304           if (check_float(linetoken3))
4305             token3 >> token_value;
4306           else
4307             uiuc_warnings_errors(1, *command_line);
4308
4309           kCZ_df = token_value;
4310           break;
4311         }
4312       case kCZ_adf_flag:
4313         {
4314           if (check_float(linetoken3))
4315             token3 >> token_value;
4316           else
4317             uiuc_warnings_errors(1, *command_line);
4318
4319           kCZ_adf = token_value;
4320           break;
4321         }
4322       case kCmo_flag:
4323         {
4324           if (check_float(linetoken3))
4325             token3 >> token_value;
4326           else
4327             uiuc_warnings_errors(1, *command_line);
4328
4329           kCmo = token_value;
4330           break;
4331         }
4332       case kCm_a_flag:
4333         {
4334           if (check_float(linetoken3))
4335             token3 >> token_value;
4336           else
4337             uiuc_warnings_errors(1, *command_line);
4338
4339           kCm_a = token_value;
4340           break;
4341         }
4342       case kCm_a2_flag:
4343         {
4344           if (check_float(linetoken3))
4345             token3 >> token_value;
4346           else
4347             uiuc_warnings_errors(1, *command_line);
4348
4349           kCm_a2 = token_value;
4350           break;
4351         }
4352       case kCm_adot_flag:
4353         {
4354           if (check_float(linetoken3))
4355             token3 >> token_value;
4356           else
4357             uiuc_warnings_errors(1, *command_line);
4358
4359           kCm_adot = token_value;
4360           break;
4361         }
4362       case kCm_q_flag:
4363         {
4364           if (check_float(linetoken3))
4365             token3 >> token_value;
4366           else
4367             uiuc_warnings_errors(1, *command_line);
4368
4369           kCm_q = token_value;
4370           break;
4371         }
4372       case kCm_de_flag:
4373         {
4374           if (check_float(linetoken3))
4375             token3 >> token_value;
4376           else
4377             uiuc_warnings_errors(1, *command_line);
4378
4379           kCm_de = token_value;
4380           break;
4381         }
4382       case kCm_b2_flag:
4383         {
4384           if (check_float(linetoken3))
4385             token3 >> token_value;
4386           else
4387             uiuc_warnings_errors(1, *command_line);
4388
4389           kCm_b2 = token_value;
4390           break;
4391         }
4392       case kCm_r_flag:
4393         {
4394           if (check_float(linetoken3))
4395             token3 >> token_value;
4396           else
4397             uiuc_warnings_errors(1, *command_line);
4398
4399           kCm_r = token_value;
4400           break;
4401         }
4402       case kCm_df_flag:
4403         {
4404           if (check_float(linetoken3))
4405             token3 >> token_value;
4406           else
4407             uiuc_warnings_errors(1, *command_line);
4408
4409           kCm_df = token_value;
4410           break;
4411         }
4412       case kCYo_flag:
4413         {
4414           if (check_float(linetoken3))
4415             token3 >> token_value;
4416           else
4417             uiuc_warnings_errors(1, *command_line);
4418
4419           kCYo = token_value;
4420           break;
4421         }
4422       case kCY_beta_flag:
4423         {
4424           if (check_float(linetoken3))
4425             token3 >> token_value;
4426           else
4427             uiuc_warnings_errors(1, *command_line);
4428
4429           kCY_beta = token_value;
4430           break;
4431         }
4432       case kCY_p_flag:
4433         {
4434           if (check_float(linetoken3))
4435             token3 >> token_value;
4436           else
4437             uiuc_warnings_errors(1, *command_line);
4438
4439           kCY_p = token_value;
4440           break;
4441         }
4442       case kCY_r_flag:
4443         {
4444           if (check_float(linetoken3))
4445             token3 >> token_value;
4446           else
4447             uiuc_warnings_errors(1, *command_line);
4448
4449           kCY_r = token_value;
4450           break;
4451         }
4452       case kCY_da_flag:
4453         {
4454           if (check_float(linetoken3))
4455             token3 >> token_value;
4456           else
4457             uiuc_warnings_errors(1, *command_line);
4458
4459           kCY_da = token_value;
4460           break;
4461         }
4462       case kCY_dr_flag:
4463         {
4464           if (check_float(linetoken3))
4465             token3 >> token_value;
4466           else
4467             uiuc_warnings_errors(1, *command_line);
4468
4469           kCY_dr = token_value;
4470           break;
4471         }
4472       case kCY_dra_flag:
4473         {
4474           if (check_float(linetoken3))
4475             token3 >> token_value;
4476           else
4477             uiuc_warnings_errors(1, *command_line);
4478
4479           kCY_dra = token_value;
4480           break;
4481         }
4482       case kCY_bdot_flag:
4483         {
4484           if (check_float(linetoken3))
4485             token3 >> token_value;
4486           else
4487             uiuc_warnings_errors(1, *command_line);
4488
4489           kCY_bdot = token_value;
4490           break;
4491         }
4492       case kClo_flag:
4493         {
4494           if (check_float(linetoken3))
4495             token3 >> token_value;
4496           else
4497             uiuc_warnings_errors(1, *command_line);
4498
4499           kClo = token_value;
4500           break;
4501         }
4502       case kCl_beta_flag:
4503         {
4504           if (check_float(linetoken3))
4505             token3 >> token_value;
4506           else
4507             uiuc_warnings_errors(1, *command_line);
4508
4509           kCl_beta = token_value;
4510           break;
4511         }
4512       case kCl_p_flag:
4513         {
4514           if (check_float(linetoken3))
4515             token3 >> token_value;
4516           else
4517             uiuc_warnings_errors(1, *command_line);
4518
4519           kCl_p = token_value;
4520           break;
4521         }
4522       case kCl_r_flag:
4523         {
4524           if (check_float(linetoken3))
4525             token3 >> token_value;
4526           else
4527             uiuc_warnings_errors(1, *command_line);
4528
4529           kCl_r = token_value;
4530           break;
4531         }
4532       case kCl_da_flag:
4533         {
4534           if (check_float(linetoken3))
4535             token3 >> token_value;
4536           else
4537             uiuc_warnings_errors(1, *command_line);
4538
4539           kCl_da = token_value;
4540           break;
4541         }
4542       case kCl_dr_flag:
4543         {
4544           if (check_float(linetoken3))
4545             token3 >> token_value;
4546           else
4547             uiuc_warnings_errors(1, *command_line);
4548
4549           kCl_dr = token_value;
4550           break;
4551         }
4552       case kCl_daa_flag:
4553         {
4554           if (check_float(linetoken3))
4555             token3 >> token_value;
4556           else
4557             uiuc_warnings_errors(1, *command_line);
4558
4559           kCl_daa = token_value;
4560           break;
4561         }
4562       case kCno_flag:
4563         {
4564           if (check_float(linetoken3))
4565             token3 >> token_value;
4566           else
4567             uiuc_warnings_errors(1, *command_line);
4568
4569           kCno = token_value;
4570           break;
4571         }
4572       case kCn_beta_flag:
4573         {
4574           if (check_float(linetoken3))
4575             token3 >> token_value;
4576           else
4577             uiuc_warnings_errors(1, *command_line);
4578
4579           kCn_beta = token_value;
4580           break;
4581         }
4582       case kCn_p_flag:
4583         {
4584           if (check_float(linetoken3))
4585             token3 >> token_value;
4586           else
4587             uiuc_warnings_errors(1, *command_line);
4588
4589           kCn_p = token_value;
4590           break;
4591         }
4592       case kCn_r_flag:
4593         {
4594           if (check_float(linetoken3))
4595             token3 >> token_value;
4596           else
4597             uiuc_warnings_errors(1, *command_line);
4598
4599           kCn_r = token_value;
4600           break;
4601         }
4602       case kCn_da_flag:
4603         {
4604           if (check_float(linetoken3))
4605             token3 >> token_value;
4606           else
4607             uiuc_warnings_errors(1, *command_line);
4608
4609           kCn_da = token_value;
4610           break;
4611         }
4612       case kCn_dr_flag:
4613         {
4614           if (check_float(linetoken3))
4615             token3 >> token_value;
4616           else
4617             uiuc_warnings_errors(1, *command_line);
4618
4619           kCn_dr = token_value;
4620           break;
4621         }
4622       case kCn_q_flag:
4623         {
4624           if (check_float(linetoken3))
4625             token3 >> token_value;
4626           else
4627             uiuc_warnings_errors(1, *command_line);
4628
4629           kCn_q = token_value;
4630           break;
4631         }
4632       case kCn_b3_flag:
4633         {
4634           if (check_float(linetoken3))
4635             token3 >> token_value;
4636           else
4637             uiuc_warnings_errors(1, *command_line);
4638
4639           kCn_b3 = token_value;
4640           break;
4641         }
4642       case bootTime_flag:
4643         {
4644           int index;
4645           if (check_float(linetoken4))
4646             token4 >> token_value;
4647           else
4648             uiuc_warnings_errors(1, *command_line);
4649           token3 >> index;
4650           if (index < 0 || index >= 20)
4651             uiuc_warnings_errors(1, *command_line);
4652           bootTime[index] = token_value;
4653           bootTrue[index] = true;
4654           break;
4655         }
4656       default:
4657         {
4658           if (dont_ignore)
4659             uiuc_warnings_errors(2, *command_line);
4660           break;
4661         }
4662       };
4663 }
4664
4665
4666 void parse_fog( const string& linetoken2, const string& linetoken3,
4667                 const string& linetoken4, LIST command_line ) {
4668   double token_value;
4669   int token_value_convert1;
4670   istrstream token3(linetoken3.c_str());
4671   istrstream token4(linetoken4.c_str());
4672
4673     switch(fog_map[linetoken2])
4674       {
4675       case fog_segments_flag:
4676         {
4677           if (check_float(linetoken3))
4678             token3 >> token_value_convert1;
4679           else
4680             uiuc_warnings_errors(1, *command_line);
4681
4682           if (token_value_convert1 < 1 || token_value_convert1 > 100)
4683             uiuc_warnings_errors(1, *command_line);
4684
4685           fog_field = true;
4686           fog_point_index = 0;
4687           delete[] fog_time;
4688           delete[] fog_value;
4689           fog_segments = token_value_convert1;
4690           fog_time = new double[fog_segments+1];
4691           fog_time[0] = 0.0;
4692           fog_value = new int[fog_segments+1];
4693           fog_value[0] = 0;
4694
4695           break;
4696         }
4697       case fog_point_flag:
4698         {
4699           if (check_float(linetoken3))
4700             token3 >> token_value;
4701           else
4702             uiuc_warnings_errors(1, *command_line);
4703
4704           if (token_value < 0.1)
4705             uiuc_warnings_errors(1, *command_line);
4706
4707           if (check_float(linetoken4))
4708             token4 >> token_value_convert1;
4709           else
4710             uiuc_warnings_errors(1, *command_line);
4711
4712           if (token_value_convert1 < -1000 || token_value_convert1 > 1000)
4713             uiuc_warnings_errors(1, *command_line);
4714
4715           if (fog_point_index == fog_segments || fog_point_index == -1)
4716             uiuc_warnings_errors(1, *command_line);
4717
4718           fog_point_index++;
4719           fog_time[fog_point_index] = token_value;
4720           fog_value[fog_point_index] = token_value_convert1;
4721
4722           break;
4723         }
4724       default:
4725         {
4726           if (dont_ignore)
4727             uiuc_warnings_errors(2, *command_line);
4728           break;
4729         }
4730       };
4731 }
4732
4733
4734 void parse_record( const string& linetoken2, LIST command_line ) {
4735
4736   switch(record_map[linetoken2])
4737     {
4738       /************************* Time ************************/
4739     case Simtime_record:
4740       {
4741         recordParts -> storeCommands (*command_line);
4742         break;
4743       }
4744     case dt_record:
4745       {
4746         recordParts -> storeCommands (*command_line);
4747         break;
4748       }
4749
4750       /************************* Mass ************************/
4751     case Weight_record:
4752       {
4753         recordParts -> storeCommands (*command_line);
4754         break;
4755       }
4756     case Mass_record:
4757       {
4758         recordParts -> storeCommands (*command_line);
4759         break;
4760       }
4761     case I_xx_record:
4762       {
4763         recordParts -> storeCommands (*command_line);
4764         break;
4765       }
4766     case I_yy_record:
4767       {
4768         recordParts -> storeCommands (*command_line);
4769         break;
4770       }
4771     case I_zz_record:
4772       {
4773         recordParts -> storeCommands (*command_line);
4774         break;
4775       }
4776     case I_xz_record:
4777       {
4778         recordParts -> storeCommands (*command_line);
4779         break;
4780       }
4781
4782       /*********************** Geometry **********************/
4783     case Dx_pilot_record:
4784       {
4785         recordParts -> storeCommands (*command_line);
4786         break;
4787       }
4788     case Dy_pilot_record:
4789       {
4790         recordParts -> storeCommands (*command_line);
4791         break;
4792       }
4793     case Dz_pilot_record:
4794       {
4795         recordParts -> storeCommands (*command_line);
4796         break;
4797       }
4798     case Dx_cg_record:
4799       {
4800         recordParts -> storeCommands (*command_line);
4801         break;
4802       }
4803     case Dy_cg_record:
4804       {
4805         recordParts -> storeCommands (*command_line);
4806         break;
4807       }
4808     case Dz_cg_record:
4809       {
4810         recordParts -> storeCommands (*command_line);
4811         break;
4812       }
4813
4814       /********************** Positions **********************/
4815     case Lat_geocentric_record:
4816       {
4817         recordParts -> storeCommands (*command_line);
4818         break;
4819       }
4820     case Lon_geocentric_record:
4821       {
4822         recordParts -> storeCommands (*command_line);
4823         break;
4824       }
4825     case Radius_to_vehicle_record:
4826       {
4827         recordParts -> storeCommands (*command_line);
4828         break;
4829       }
4830     case Latitude_record:
4831       {
4832         recordParts -> storeCommands (*command_line);
4833         break;
4834       }
4835     case Longitude_record:
4836       {
4837         recordParts -> storeCommands (*command_line);
4838         break;
4839       }
4840     case Altitude_record:
4841       {
4842         recordParts -> storeCommands (*command_line);
4843         break;
4844       }
4845     case Phi_record:
4846       {
4847         recordParts -> storeCommands (*command_line);
4848         break;
4849       }
4850     case Theta_record:
4851       {
4852         recordParts -> storeCommands (*command_line);
4853         break;
4854       }
4855     case Psi_record:
4856       {
4857         recordParts -> storeCommands (*command_line);
4858         break;
4859       }
4860
4861       /******************** Accelerations ********************/
4862     case V_dot_north_record:
4863       {
4864         recordParts -> storeCommands (*command_line);
4865         break;
4866       }
4867     case V_dot_east_record:
4868       {
4869         recordParts -> storeCommands (*command_line);
4870         break;
4871       }
4872     case V_dot_down_record:
4873       {
4874         recordParts -> storeCommands (*command_line);
4875         break;
4876       }
4877     case U_dot_body_record:
4878       {
4879         recordParts -> storeCommands (*command_line);
4880         break;
4881       }
4882     case V_dot_body_record:
4883       {
4884         recordParts -> storeCommands (*command_line);
4885         break;
4886       }
4887     case W_dot_body_record:
4888       {
4889         recordParts -> storeCommands (*command_line);
4890         break;
4891       }
4892     case A_X_pilot_record:
4893       {
4894         recordParts -> storeCommands (*command_line);
4895         break;
4896       }
4897     case A_Y_pilot_record:
4898       {
4899         recordParts -> storeCommands (*command_line);
4900         break;
4901       }
4902     case A_Z_pilot_record:
4903       {
4904         recordParts -> storeCommands (*command_line);
4905         break;
4906       }
4907     case A_X_cg_record:
4908       {
4909         recordParts -> storeCommands (*command_line);
4910         break;
4911       }
4912     case A_Y_cg_record:
4913       {
4914         recordParts -> storeCommands (*command_line);
4915         break;
4916       }
4917     case A_Z_cg_record:
4918       {
4919         recordParts -> storeCommands (*command_line);
4920         break;
4921       }
4922     case N_X_pilot_record:
4923       {
4924         recordParts -> storeCommands (*command_line);
4925         break;
4926       }
4927     case N_Y_pilot_record:
4928       {
4929         recordParts -> storeCommands (*command_line);
4930         break;
4931       }
4932     case N_Z_pilot_record:
4933       {
4934         recordParts -> storeCommands (*command_line);
4935         break;
4936       }
4937     case N_X_cg_record:
4938       {
4939         recordParts -> storeCommands (*command_line);
4940         break;
4941       }
4942     case N_Y_cg_record:
4943       {
4944         recordParts -> storeCommands (*command_line);
4945         break;
4946       }
4947     case N_Z_cg_record:
4948       {
4949         recordParts -> storeCommands (*command_line);
4950         break;
4951       }
4952     case P_dot_body_record:
4953       {
4954         recordParts -> storeCommands (*command_line);
4955         break;
4956       }
4957     case Q_dot_body_record:
4958       {
4959         recordParts -> storeCommands (*command_line);
4960         break;
4961       }
4962     case R_dot_body_record:
4963       {
4964         recordParts -> storeCommands (*command_line);
4965         break;
4966       }
4967
4968       /********************** Velocities *********************/
4969     case V_north_record:
4970       {
4971         recordParts -> storeCommands (*command_line);
4972         break;
4973       }
4974     case V_east_record:
4975       {
4976         recordParts -> storeCommands (*command_line);
4977         break;
4978       }
4979     case V_down_record:
4980       {
4981         recordParts -> storeCommands (*command_line);
4982         break;
4983       }
4984     case V_north_rel_ground_record:
4985       {
4986         recordParts -> storeCommands (*command_line);
4987         break;
4988       }
4989     case V_east_rel_ground_record:
4990       {
4991         recordParts -> storeCommands (*command_line);
4992         break;
4993       }
4994     case V_down_rel_ground_record:
4995       {
4996         recordParts -> storeCommands (*command_line);
4997         break;
4998       }
4999     case V_north_airmass_record:
5000       {
5001         recordParts -> storeCommands (*command_line);
5002         break;
5003       }
5004     case V_east_airmass_record:
5005       {
5006         recordParts -> storeCommands (*command_line);
5007         break;
5008       }
5009     case V_down_airmass_record:
5010       {
5011         recordParts -> storeCommands (*command_line);
5012         break;
5013       }
5014     case V_north_rel_airmass_record:
5015       {
5016         recordParts -> storeCommands (*command_line);
5017         break;
5018       }
5019     case V_east_rel_airmass_record:
5020       {
5021         recordParts -> storeCommands (*command_line);
5022         break;
5023       }
5024     case V_down_rel_airmass_record:
5025       {
5026         recordParts -> storeCommands (*command_line);
5027         break;
5028       }
5029     case U_gust_record:
5030       {
5031         recordParts -> storeCommands (*command_line);
5032         break;
5033       }
5034     case V_gust_record:
5035       {
5036         recordParts -> storeCommands (*command_line);
5037         break;
5038       }
5039     case W_gust_record:
5040       {
5041         recordParts -> storeCommands (*command_line);
5042         break;
5043       }
5044     case U_body_record:
5045       {
5046         recordParts -> storeCommands (*command_line);
5047         break;
5048       }
5049     case V_body_record:
5050       {
5051         recordParts -> storeCommands (*command_line);
5052         break;
5053       }
5054     case W_body_record:
5055       {
5056         recordParts -> storeCommands (*command_line);
5057         break;
5058       }
5059     case V_rel_wind_record:
5060       {
5061         recordParts -> storeCommands (*command_line);
5062         break;
5063       }
5064     case V_true_kts_record:
5065       {
5066         recordParts -> storeCommands (*command_line);
5067         break;
5068       }
5069     case V_rel_ground_record:
5070       {
5071         recordParts -> storeCommands (*command_line);
5072         break;
5073       }
5074     case V_inertial_record:
5075       {
5076         recordParts -> storeCommands (*command_line);
5077         break;
5078       }
5079     case V_ground_speed_record:
5080       {
5081         recordParts -> storeCommands (*command_line);
5082         break;
5083       }
5084     case V_equiv_record:
5085       {
5086         recordParts -> storeCommands (*command_line);
5087         break;
5088       }
5089     case V_equiv_kts_record:
5090       {
5091         recordParts -> storeCommands (*command_line);
5092         break;
5093       }
5094     case V_calibrated_record:
5095       {
5096         recordParts -> storeCommands (*command_line);
5097         break;
5098       }
5099     case V_calibrated_kts_record:
5100       {
5101         recordParts -> storeCommands (*command_line);
5102         break;
5103       }
5104     case P_local_record:
5105       {
5106         recordParts -> storeCommands (*command_line);
5107         break;
5108       }
5109     case Q_local_record:
5110       {
5111         recordParts -> storeCommands (*command_line);
5112         break;
5113       }
5114     case R_local_record:
5115       {
5116         recordParts -> storeCommands (*command_line);
5117         break;
5118       }
5119     case P_body_record:
5120       {
5121         recordParts -> storeCommands (*command_line);
5122         break;
5123       }
5124     case Q_body_record:
5125       {
5126         recordParts -> storeCommands (*command_line);
5127         break;
5128       }
5129     case R_body_record:
5130       {
5131         recordParts -> storeCommands (*command_line);
5132         break;
5133       }
5134     case P_total_record:
5135       {
5136         recordParts -> storeCommands (*command_line);
5137         break;
5138       }
5139     case Q_total_record:
5140       {
5141         recordParts -> storeCommands (*command_line);
5142         break;
5143       }
5144     case R_total_record:
5145       {
5146         recordParts -> storeCommands (*command_line);
5147         break;
5148       }
5149     case Phi_dot_record:
5150       {
5151         recordParts -> storeCommands (*command_line);
5152         break;
5153       }
5154     case Theta_dot_record:
5155       {
5156         recordParts -> storeCommands (*command_line);
5157         break;
5158       }
5159     case Psi_dot_record:
5160       {
5161         recordParts -> storeCommands (*command_line);
5162         break;
5163       }
5164     case Latitude_dot_record:
5165       {
5166         recordParts -> storeCommands (*command_line);
5167         break;
5168       }
5169     case Longitude_dot_record:
5170       {
5171         recordParts -> storeCommands (*command_line);
5172         break;
5173       }
5174     case Radius_dot_record:
5175       {
5176         recordParts -> storeCommands (*command_line);
5177         break;
5178       }
5179
5180       /************************ Angles ***********************/
5181     case Alpha_record:
5182       {
5183         recordParts -> storeCommands (*command_line);
5184         break;
5185       }
5186     case Alpha_deg_record:
5187       {
5188         recordParts -> storeCommands (*command_line);
5189         break;
5190       }
5191     case Alpha_dot_record:
5192       {
5193         recordParts -> storeCommands (*command_line);
5194         break;
5195       }
5196     case Alpha_dot_deg_record:
5197       {
5198         recordParts -> storeCommands (*command_line);
5199         break;
5200       }
5201     case Beta_record:
5202       {
5203         recordParts -> storeCommands (*command_line);
5204         break;
5205       }
5206     case Beta_deg_record:
5207       {
5208         recordParts -> storeCommands (*command_line);
5209         break;
5210       }
5211     case Beta_dot_record:
5212       {
5213         recordParts -> storeCommands (*command_line);
5214         break;
5215       }
5216     case Beta_dot_deg_record:
5217       {
5218         recordParts -> storeCommands (*command_line);
5219         break;
5220       }
5221     case Gamma_vert_record:
5222       {
5223         recordParts -> storeCommands (*command_line);
5224         break;
5225       }
5226     case Gamma_vert_deg_record:
5227       {
5228         recordParts -> storeCommands (*command_line);
5229         break;
5230       }
5231     case Gamma_horiz_record:
5232       {
5233         recordParts -> storeCommands (*command_line);
5234         break;
5235       }
5236     case Gamma_horiz_deg_record:
5237       {
5238         recordParts -> storeCommands (*command_line);
5239         break;
5240       }
5241
5242       /**************** Atmospheric Properties ***************/
5243     case Density_record:
5244       {
5245         recordParts -> storeCommands (*command_line);
5246         break;
5247       }
5248     case V_sound_record:
5249       {
5250         recordParts -> storeCommands (*command_line);
5251         break;
5252       }
5253     case Mach_number_record:
5254       {
5255         recordParts -> storeCommands (*command_line);
5256         break;
5257       }
5258     case Static_pressure_record:
5259       {
5260         recordParts -> storeCommands (*command_line);
5261         break;
5262       }
5263     case Total_pressure_record:
5264       {
5265         recordParts -> storeCommands (*command_line);
5266         break;
5267       }
5268     case Impact_pressure_record:
5269       {
5270         recordParts -> storeCommands (*command_line);
5271         break;
5272       }
5273     case Dynamic_pressure_record:
5274       {
5275         recordParts -> storeCommands (*command_line);
5276         break;
5277       }
5278     case Static_temperature_record:
5279       {
5280         recordParts -> storeCommands (*command_line);
5281         break;
5282       }
5283     case Total_temperature_record:
5284       {
5285         recordParts -> storeCommands (*command_line);
5286         break;
5287       }
5288
5289       /******************** Earth Properties *****************/
5290     case Gravity_record:
5291       {
5292         recordParts -> storeCommands (*command_line);
5293         break;
5294       }
5295     case Sea_level_radius_record:
5296       {
5297         recordParts -> storeCommands (*command_line);
5298         break;
5299       }
5300     case Earth_position_angle_record:
5301       {
5302         recordParts -> storeCommands (*command_line);
5303         break;
5304       }
5305     case Runway_altitude_record:
5306       {
5307         recordParts -> storeCommands (*command_line);
5308         break;
5309       }
5310     case Runway_latitude_record:
5311       {
5312         recordParts -> storeCommands (*command_line);
5313         break;
5314       }
5315     case Runway_longitude_record:
5316       {
5317         recordParts -> storeCommands (*command_line);
5318         break;
5319       }
5320     case Runway_heading_record:
5321       {
5322         recordParts -> storeCommands (*command_line);
5323         break;
5324       }
5325     case Radius_to_rwy_record:
5326       {
5327         recordParts -> storeCommands (*command_line);
5328         break;
5329       }
5330     case D_pilot_north_of_rwy_record:
5331       {
5332         recordParts -> storeCommands (*command_line);
5333         break;
5334       }
5335     case D_pilot_east_of_rwy_record:
5336       {
5337         recordParts -> storeCommands (*command_line);
5338         break;
5339       }
5340     case D_pilot_above_rwy_record:
5341                 {
5342                   recordParts -> storeCommands (*command_line);
5343                   break;
5344                 }
5345     case X_pilot_rwy_record:
5346       {
5347         recordParts -> storeCommands (*command_line);
5348         break;
5349       }
5350     case Y_pilot_rwy_record:
5351       {
5352         recordParts -> storeCommands (*command_line);
5353         break;
5354       }
5355     case H_pilot_rwy_record:
5356       {
5357         recordParts -> storeCommands (*command_line);
5358         break;
5359       }
5360     case D_cg_north_of_rwy_record:
5361       {
5362         recordParts -> storeCommands (*command_line);
5363         break;
5364       }
5365     case D_cg_east_of_rwy_record:
5366       {
5367         recordParts -> storeCommands (*command_line);
5368         break;
5369       }
5370     case D_cg_above_rwy_record:
5371       {
5372         recordParts -> storeCommands (*command_line);
5373         break;
5374       }
5375     case X_cg_rwy_record:
5376       {
5377         recordParts -> storeCommands (*command_line);
5378         break;
5379       }
5380     case Y_cg_rwy_record:
5381       {
5382         recordParts -> storeCommands (*command_line);
5383         break;
5384       }
5385     case H_cg_rwy_record:
5386       {
5387         recordParts -> storeCommands (*command_line);
5388         break;
5389       }
5390
5391       /********************* Engine Inputs *******************/
5392     case Throttle_pct_record:
5393       {
5394         recordParts -> storeCommands (*command_line);
5395         break;
5396       }
5397     case Throttle_3_record:
5398       {
5399         recordParts -> storeCommands (*command_line);
5400         break;
5401       }
5402
5403       /******************** Control Inputs *******************/
5404     case Long_control_record:
5405       {
5406         recordParts -> storeCommands (*command_line);
5407         break;
5408       }
5409     case Long_trim_record:
5410       {
5411         recordParts -> storeCommands (*command_line);
5412         break;
5413       }
5414     case Long_trim_deg_record:
5415       {
5416         recordParts -> storeCommands (*command_line);
5417         break;
5418       }
5419     case elevator_record:
5420       {
5421         recordParts -> storeCommands (*command_line);
5422         break;
5423       }
5424     case elevator_deg_record:
5425       {
5426         recordParts -> storeCommands (*command_line);
5427         break;
5428       }
5429     case Lat_control_record:
5430       {
5431         recordParts -> storeCommands (*command_line);
5432         break;
5433       }
5434     case aileron_record:
5435       {
5436         recordParts -> storeCommands (*command_line);
5437         break;
5438       }
5439     case aileron_deg_record:
5440       {
5441         recordParts -> storeCommands (*command_line);
5442         break;
5443       }
5444     case Rudder_pedal_record:
5445       {
5446         recordParts -> storeCommands (*command_line);
5447         break;
5448       }
5449     case rudder_record:
5450       {
5451         recordParts -> storeCommands (*command_line);
5452         break;
5453       }
5454     case rudder_deg_record:
5455       {
5456         recordParts -> storeCommands (*command_line);
5457         break;
5458       }
5459     case Flap_handle_record:
5460       {
5461         recordParts -> storeCommands (*command_line);
5462         break;
5463       }
5464     case flap_record:
5465       {
5466         recordParts -> storeCommands (*command_line);
5467         break;
5468       }
5469     case flap_deg_record:
5470       {
5471         recordParts -> storeCommands (*command_line);
5472         break;
5473       }
5474     case flap_goal_record:
5475       {
5476         recordParts -> storeCommands (*command_line);
5477         break;
5478       }
5479     case flap_pos_record:
5480       {
5481         recordParts -> storeCommands (*command_line);
5482         break;
5483       }
5484
5485       /****************** Aero Coefficients ******************/
5486     case CD_record:
5487       {
5488         recordParts -> storeCommands (*command_line);
5489         break;
5490       }
5491     case CDfaI_record:
5492       {
5493         recordParts -> storeCommands (*command_line);
5494         break;
5495       }
5496     case CDfadeI_record:
5497       {
5498         recordParts -> storeCommands (*command_line);
5499         break;
5500       }
5501     case CDfdfI_record:
5502       {
5503         recordParts -> storeCommands (*command_line);
5504         break;
5505       }
5506     case CDfadfI_record:
5507       {
5508         recordParts -> storeCommands (*command_line);
5509         break;
5510       }
5511     case CX_record:
5512       {
5513         recordParts -> storeCommands (*command_line);
5514         break;
5515       }
5516     case CXfabetafI_record:
5517       {
5518         recordParts -> storeCommands (*command_line);
5519         break;
5520       }
5521     case CXfadefI_record:
5522       {
5523         recordParts -> storeCommands (*command_line);
5524         break;
5525       }
5526     case CXfaqfI_record:
5527       {
5528         recordParts -> storeCommands (*command_line);
5529         break;
5530       }
5531     case CDo_save_record:
5532       {
5533         recordParts -> storeCommands (*command_line);
5534         break;
5535       }
5536     case CDK_save_record:
5537       {
5538         recordParts -> storeCommands (*command_line);
5539         break;
5540       }
5541     case CD_a_save_record:
5542       {
5543         recordParts -> storeCommands (*command_line);
5544         break;
5545       }
5546     case CD_adot_save_record:
5547       {
5548         recordParts -> storeCommands (*command_line);
5549         break;
5550       }
5551     case CD_q_save_record:
5552       {
5553         recordParts -> storeCommands (*command_line);
5554         break;
5555       }
5556     case CD_ih_save_record:
5557       {
5558         recordParts -> storeCommands (*command_line);
5559         break;
5560       }
5561     case CD_de_save_record:
5562       {
5563         recordParts -> storeCommands (*command_line);
5564         break;
5565       }
5566     case CXo_save_record:
5567       {
5568         recordParts -> storeCommands (*command_line);
5569         break;
5570       }
5571     case CXK_save_record:
5572       {
5573         recordParts -> storeCommands (*command_line);
5574         break;
5575       }
5576     case CX_a_save_record:
5577       {
5578         recordParts -> storeCommands (*command_line);
5579         break;
5580       }
5581     case CX_a2_save_record:
5582       {
5583         recordParts -> storeCommands (*command_line);
5584         break;
5585       }
5586     case CX_a3_save_record:
5587       {
5588         recordParts -> storeCommands (*command_line);
5589         break;
5590       }
5591     case CX_adot_save_record:
5592       {
5593         recordParts -> storeCommands (*command_line);
5594         break;
5595       }
5596     case CX_q_save_record:
5597       {
5598         recordParts -> storeCommands (*command_line);
5599         break;
5600       }
5601     case CX_de_save_record:
5602       {
5603         recordParts -> storeCommands (*command_line);
5604         break;
5605       }
5606     case CX_dr_save_record:
5607       {
5608         recordParts -> storeCommands (*command_line);
5609         break;
5610       }
5611     case CX_df_save_record:
5612       {
5613         recordParts -> storeCommands (*command_line);
5614         break;
5615       }
5616     case CX_adf_save_record:
5617       {
5618         recordParts -> storeCommands (*command_line);
5619         break;
5620       }
5621     case CL_record:
5622       {
5623         recordParts -> storeCommands (*command_line);
5624         break;
5625       }
5626     case CLfaI_record:
5627       {
5628         recordParts -> storeCommands (*command_line);
5629         break;
5630       }
5631     case CLfadeI_record:
5632       {
5633         recordParts -> storeCommands (*command_line);
5634         break;
5635       }
5636     case CLfdfI_record:
5637       {
5638         recordParts -> storeCommands (*command_line);
5639         break;
5640       }
5641     case CLfadfI_record:
5642       {
5643         recordParts -> storeCommands (*command_line);
5644         break;
5645       }
5646     case CZ_record:
5647       {
5648         recordParts -> storeCommands (*command_line);
5649         break;
5650       }
5651     case CZfaI_record:
5652       {
5653         recordParts -> storeCommands (*command_line);
5654         break;
5655       }
5656     case CZfabetafI_record:
5657       {
5658         recordParts -> storeCommands (*command_line);
5659         break;
5660       }
5661     case CZfadefI_record:
5662       {
5663         recordParts -> storeCommands (*command_line);
5664         break;
5665       }
5666     case CZfaqfI_record:
5667       {
5668         recordParts -> storeCommands (*command_line);
5669         break;
5670       }
5671     case CLo_save_record:
5672       {
5673         recordParts -> storeCommands (*command_line);
5674         break;
5675       }
5676     case CL_a_save_record:
5677       {
5678         recordParts -> storeCommands (*command_line);
5679         break;
5680       }
5681     case CL_adot_save_record:
5682       {
5683         recordParts -> storeCommands (*command_line);
5684         break;
5685       }
5686     case CL_q_save_record:
5687       {
5688         recordParts -> storeCommands (*command_line);
5689         break;
5690       }
5691     case CL_ih_save_record:
5692       {
5693         recordParts -> storeCommands (*command_line);
5694         break;
5695       }
5696     case CL_de_save_record:
5697       {
5698         recordParts -> storeCommands (*command_line);
5699         break;
5700       }
5701     case CZo_save_record:
5702       {
5703         recordParts -> storeCommands (*command_line);
5704         break;
5705       }
5706     case CZ_a_save_record:
5707       {
5708         recordParts -> storeCommands (*command_line);
5709         break;
5710       }
5711     case CZ_a2_save_record:
5712       {
5713         recordParts -> storeCommands (*command_line);
5714         break;
5715       }
5716     case CZ_a3_save_record:
5717       {
5718         recordParts -> storeCommands (*command_line);
5719         break;
5720       }
5721     case CZ_adot_save_record:
5722       {
5723         recordParts -> storeCommands (*command_line);
5724         break;
5725       }
5726     case CZ_q_save_record:
5727       {
5728         recordParts -> storeCommands (*command_line);
5729         break;
5730       }
5731     case CZ_de_save_record:
5732       {
5733         recordParts -> storeCommands (*command_line);
5734         break;
5735       }
5736     case CZ_deb2_save_record:
5737       {
5738         recordParts -> storeCommands (*command_line);
5739         break;
5740       }
5741     case CZ_df_save_record:
5742       {
5743         recordParts -> storeCommands (*command_line);
5744         break;
5745       }
5746     case CZ_adf_save_record:
5747       {
5748         recordParts -> storeCommands (*command_line);
5749         break;
5750       }
5751     case Cm_record:
5752       {
5753         recordParts -> storeCommands (*command_line);
5754         break;
5755       }
5756     case CmfaI_record:
5757       {
5758         recordParts -> storeCommands (*command_line);
5759         break;
5760       }
5761     case CmfadeI_record:
5762       {
5763         recordParts -> storeCommands (*command_line);
5764         break;
5765       }
5766     case CmfdfI_record:
5767       {
5768         recordParts -> storeCommands (*command_line);
5769         break;
5770       }
5771     case CmfadfI_record:
5772       {
5773         recordParts -> storeCommands (*command_line);
5774         break;
5775       }
5776     case CmfabetafI_record:
5777       {
5778         recordParts -> storeCommands (*command_line);
5779         break;
5780       }
5781     case CmfadefI_record:
5782       {
5783         recordParts -> storeCommands (*command_line);
5784         break;
5785       }
5786     case CmfaqfI_record:
5787       {
5788         recordParts -> storeCommands (*command_line);
5789         break;
5790       }
5791     case Cmo_save_record:
5792       {
5793         recordParts -> storeCommands (*command_line);
5794         break;
5795       }
5796     case Cm_a_save_record:
5797       {
5798         recordParts -> storeCommands (*command_line);
5799         break;
5800       }
5801     case Cm_a2_save_record:
5802       {
5803         recordParts -> storeCommands (*command_line);
5804         break;
5805       }
5806     case Cm_adot_save_record:
5807       {
5808         recordParts -> storeCommands (*command_line);
5809         break;
5810       }
5811     case Cm_q_save_record:
5812       {
5813         recordParts -> storeCommands (*command_line);
5814         break;
5815       }
5816     case Cm_ih_save_record:
5817       {
5818         recordParts -> storeCommands (*command_line);
5819         break;
5820       }
5821     case Cm_de_save_record:
5822       {
5823         recordParts -> storeCommands (*command_line);
5824         break;
5825       }
5826     case Cm_b2_save_record:
5827       {
5828         recordParts -> storeCommands (*command_line);
5829         break;
5830       }
5831     case Cm_r_save_record:
5832       {
5833         recordParts -> storeCommands (*command_line);
5834         break;
5835       }
5836     case Cm_df_save_record:
5837       {
5838         recordParts -> storeCommands (*command_line);
5839         break;
5840       }
5841     case CY_record:
5842       {
5843         recordParts -> storeCommands (*command_line);
5844         break;
5845       }
5846     case CYfadaI_record:
5847       {
5848         recordParts -> storeCommands (*command_line);
5849         break;
5850       }
5851     case CYfbetadrI_record:
5852       {
5853         recordParts -> storeCommands (*command_line);
5854         break;
5855       }
5856     case CYfabetafI_record:
5857       {
5858         recordParts -> storeCommands (*command_line);
5859         break;
5860       }
5861     case CYfadafI_record:
5862       {
5863         recordParts -> storeCommands (*command_line);
5864         break;
5865       }
5866     case CYfadrfI_record:
5867       {
5868         recordParts -> storeCommands (*command_line);
5869         break;
5870       }
5871     case CYfapfI_record:
5872       {
5873         recordParts -> storeCommands (*command_line);
5874         break;
5875       }
5876     case CYfarfI_record:
5877       {
5878         recordParts -> storeCommands (*command_line);
5879         break;
5880       }
5881     case CYo_save_record:
5882       {
5883         recordParts -> storeCommands (*command_line);
5884         break;
5885       }
5886     case CY_beta_save_record:
5887       {
5888         recordParts -> storeCommands (*command_line);
5889         break;
5890       }
5891     case CY_p_save_record:
5892       {
5893         recordParts -> storeCommands (*command_line);
5894         break;
5895       }
5896     case CY_r_save_record:
5897       {
5898         recordParts -> storeCommands (*command_line);
5899         break;
5900       }
5901     case CY_da_save_record:
5902       {
5903         recordParts -> storeCommands (*command_line);
5904         break;
5905       }
5906     case CY_dr_save_record:
5907       {
5908         recordParts -> storeCommands (*command_line);
5909         break;
5910       }
5911     case CY_dra_save_record:
5912       {
5913         recordParts -> storeCommands (*command_line);
5914         break;
5915       }
5916     case CY_bdot_save_record:
5917       {
5918         recordParts -> storeCommands (*command_line);
5919         break;
5920       }
5921     case Cl_record:
5922       {
5923         recordParts -> storeCommands (*command_line);
5924         break;
5925       }
5926     case ClfadaI_record:
5927       {
5928         recordParts -> storeCommands (*command_line);
5929         break;
5930       }
5931     case ClfbetadrI_record:
5932       {
5933         recordParts -> storeCommands (*command_line);
5934         break;
5935       }
5936     case ClfabetafI_record:
5937       {
5938         recordParts -> storeCommands (*command_line);
5939         break;
5940       }
5941     case ClfadafI_record:
5942       {
5943         recordParts -> storeCommands (*command_line);
5944         break;
5945       }
5946     case ClfadrfI_record:
5947       {
5948         recordParts -> storeCommands (*command_line);
5949         break;
5950       }
5951     case ClfapfI_record:
5952       {
5953         recordParts -> storeCommands (*command_line);
5954         break;
5955       }
5956     case ClfarfI_record:
5957       {
5958         recordParts -> storeCommands (*command_line);
5959         break;
5960       }
5961     case Clo_save_record:
5962       {
5963         recordParts -> storeCommands (*command_line);
5964         break;
5965       }
5966     case Cl_beta_save_record:
5967       {
5968         recordParts -> storeCommands (*command_line);
5969         break;
5970       }
5971     case Cl_p_save_record:
5972       {
5973         recordParts -> storeCommands (*command_line);
5974         break;
5975       }
5976     case Cl_r_save_record:
5977       {
5978         recordParts -> storeCommands (*command_line);
5979         break;
5980       }
5981     case Cl_da_save_record:
5982       {
5983         recordParts -> storeCommands (*command_line);
5984         break;
5985       }
5986     case Cl_dr_save_record:
5987       {
5988         recordParts -> storeCommands (*command_line);
5989         break;
5990       }
5991     case Cl_daa_save_record:
5992       {
5993         recordParts -> storeCommands (*command_line);
5994         break;
5995       }
5996     case Cn_record:
5997       {
5998         recordParts -> storeCommands (*command_line);
5999         break;
6000       }
6001     case CnfadaI_record:
6002       {
6003         recordParts -> storeCommands (*command_line);
6004         break;
6005       }
6006     case CnfbetadrI_record:
6007       {
6008         recordParts -> storeCommands (*command_line);
6009         break;
6010       }
6011     case CnfabetafI_record:
6012       {
6013         recordParts -> storeCommands (*command_line);
6014         break;
6015       }
6016     case CnfadafI_record:
6017       {
6018         recordParts -> storeCommands (*command_line);
6019         break;
6020       }
6021     case CnfadrfI_record:
6022       {
6023         recordParts -> storeCommands (*command_line);
6024         break;
6025       }
6026     case CnfapfI_record:
6027       {
6028         recordParts -> storeCommands (*command_line);
6029         break;
6030       }
6031     case CnfarfI_record:
6032       {
6033         recordParts -> storeCommands (*command_line);
6034         break;
6035       }
6036     case Cno_save_record:
6037       {
6038         recordParts -> storeCommands (*command_line);
6039         break;
6040       }
6041     case Cn_beta_save_record:
6042       {
6043         recordParts -> storeCommands (*command_line);
6044         break;
6045       }
6046     case Cn_p_save_record:
6047       {
6048         recordParts -> storeCommands (*command_line);
6049         break;
6050       }
6051     case Cn_r_save_record:
6052       {
6053         recordParts -> storeCommands (*command_line);
6054         break;
6055       }
6056     case Cn_da_save_record:
6057       {
6058         recordParts -> storeCommands (*command_line);
6059         break;
6060       }
6061     case Cn_dr_save_record:
6062       {
6063         recordParts -> storeCommands (*command_line);
6064         break;
6065       }
6066     case Cn_q_save_record:
6067       {
6068         recordParts -> storeCommands (*command_line);
6069         break;
6070       }
6071     case Cn_b3_save_record:
6072       {
6073         recordParts -> storeCommands (*command_line);
6074         break;
6075       }
6076
6077       /******************** Ice Detection ********************/
6078     case CL_clean_record:
6079       {
6080         recordParts -> storeCommands (*command_line);
6081         break;
6082       }
6083     case CL_iced_record:
6084       {
6085         recordParts -> storeCommands (*command_line);
6086         break;
6087       }
6088     case CD_clean_record:
6089       {
6090         recordParts -> storeCommands (*command_line);
6091         break;
6092       }
6093     case CD_iced_record:
6094       {
6095         recordParts -> storeCommands (*command_line);
6096         break;
6097       }
6098     case Cm_clean_record:
6099       {
6100         recordParts -> storeCommands (*command_line);
6101         break;
6102       }
6103     case Cm_iced_record:
6104       {
6105         recordParts -> storeCommands (*command_line);
6106         break;
6107       }
6108     case Ch_clean_record:
6109       {
6110         recordParts -> storeCommands (*command_line);
6111         break;
6112       }
6113     case Ch_iced_record:
6114       {
6115         recordParts -> storeCommands (*command_line);
6116         break;
6117       }
6118     case Cl_clean_record:
6119       {
6120         recordParts -> storeCommands (*command_line);
6121         break;
6122       }
6123     case Cl_iced_record:
6124       {
6125         recordParts -> storeCommands (*command_line);
6126         break;
6127       }
6128     case CLclean_wing_record:
6129       {
6130         recordParts -> storeCommands (*command_line);
6131         break;
6132       }
6133     case CLiced_wing_record:
6134       {
6135         recordParts -> storeCommands (*command_line);
6136         break;
6137       }
6138     case CLclean_tail_record:
6139       {
6140         recordParts -> storeCommands (*command_line);
6141         break;
6142       }
6143     case CLiced_tail_record:
6144       {
6145         recordParts -> storeCommands (*command_line);
6146         break;
6147       }
6148     case Lift_clean_wing_record:
6149       {
6150         recordParts -> storeCommands (*command_line);
6151         break;
6152       }
6153     case Lift_iced_wing_record:
6154       {
6155         recordParts -> storeCommands (*command_line);
6156         break;
6157       }
6158     case Lift_clean_tail_record:
6159       {
6160         recordParts -> storeCommands (*command_line);
6161         break;
6162       }
6163     case Lift_iced_tail_record:
6164       {
6165         recordParts -> storeCommands (*command_line);
6166         break;
6167       }
6168     case Gamma_clean_wing_record:
6169       {
6170         recordParts -> storeCommands (*command_line);
6171         break;
6172       }
6173     case Gamma_iced_wing_record:
6174       {
6175         recordParts -> storeCommands (*command_line);
6176         break;
6177       }
6178     case Gamma_clean_tail_record:
6179       {
6180         recordParts -> storeCommands (*command_line);
6181         break;
6182       }
6183     case Gamma_iced_tail_record:
6184       {
6185         recordParts -> storeCommands (*command_line);
6186         break;
6187       }
6188     case w_clean_wing_record:
6189       {
6190         recordParts -> storeCommands (*command_line);
6191         break;
6192       }
6193     case w_iced_wing_record:
6194       {
6195         recordParts -> storeCommands (*command_line);
6196         break;
6197       }
6198     case w_clean_tail_record:
6199       {
6200         recordParts -> storeCommands (*command_line);
6201         break;
6202       }
6203     case w_iced_tail_record:
6204       {
6205         recordParts -> storeCommands (*command_line);
6206         break;
6207       }
6208     case V_total_clean_wing_record:
6209       {
6210         recordParts -> storeCommands (*command_line);
6211         break;
6212       }
6213     case V_total_iced_wing_record:
6214       {
6215         recordParts -> storeCommands (*command_line);
6216         break;
6217       }
6218     case V_total_clean_tail_record:
6219       {
6220         recordParts -> storeCommands (*command_line);
6221         break;
6222       }
6223     case V_total_iced_tail_record:
6224       {
6225         recordParts -> storeCommands (*command_line);
6226         break;
6227       }
6228     case beta_flow_clean_wing_record:
6229       {
6230         recordParts -> storeCommands (*command_line);
6231         break;
6232       }
6233     case beta_flow_clean_wing_deg_record:
6234       {
6235         recordParts -> storeCommands (*command_line);
6236         break;
6237       }
6238     case beta_flow_iced_wing_record:
6239       {
6240         recordParts -> storeCommands (*command_line);
6241         break;
6242       }
6243     case beta_flow_iced_wing_deg_record:
6244       {
6245         recordParts -> storeCommands (*command_line);
6246         break;
6247       }
6248     case beta_flow_clean_tail_record:
6249       {
6250         recordParts -> storeCommands (*command_line);
6251         break;
6252       }
6253     case beta_flow_clean_tail_deg_record:
6254       {
6255         recordParts -> storeCommands (*command_line);
6256         break;
6257       }
6258     case beta_flow_iced_tail_record:
6259       {
6260         recordParts -> storeCommands (*command_line);
6261         break;
6262       }
6263     case beta_flow_iced_tail_deg_record:
6264       {
6265         recordParts -> storeCommands (*command_line);
6266         break;
6267       }
6268     case Dbeta_flow_wing_record:
6269       {
6270         recordParts -> storeCommands (*command_line);
6271         break;
6272       }
6273     case Dbeta_flow_wing_deg_record:
6274       {
6275         recordParts -> storeCommands (*command_line);
6276         break;
6277       }
6278     case Dbeta_flow_tail_record:
6279       {
6280         recordParts -> storeCommands (*command_line);
6281         break;
6282       }
6283     case Dbeta_flow_tail_deg_record:
6284       {
6285         recordParts -> storeCommands (*command_line);
6286         break;
6287       }
6288     case pct_beta_flow_wing_record:
6289       {
6290         recordParts -> storeCommands (*command_line);
6291         break;
6292       }
6293     case pct_beta_flow_tail_record:
6294       {
6295         recordParts -> storeCommands (*command_line);
6296         break;
6297       }
6298     case eta_ice_record:
6299       {
6300         recordParts -> storeCommands (*command_line);
6301         break;
6302       }
6303
6304       /************************ Forces ***********************/
6305     case F_X_wind_record:
6306       {
6307         recordParts -> storeCommands (*command_line);
6308         break;
6309       }
6310     case F_Y_wind_record:
6311       {
6312         recordParts -> storeCommands (*command_line);
6313         break;
6314       }
6315     case F_Z_wind_record:
6316       {
6317         recordParts -> storeCommands (*command_line);
6318         break;
6319       }
6320     case F_X_aero_record:
6321       {
6322         recordParts -> storeCommands (*command_line);
6323         break;
6324       }
6325     case F_Y_aero_record:
6326       {
6327         recordParts -> storeCommands (*command_line);
6328         break;
6329       }
6330     case F_Z_aero_record:
6331       {
6332         recordParts -> storeCommands (*command_line);
6333         break;
6334       }
6335     case F_X_engine_record:
6336       {
6337         recordParts -> storeCommands (*command_line);
6338         break;
6339       }
6340     case F_Y_engine_record:
6341       {
6342         recordParts -> storeCommands (*command_line);
6343         break;
6344       }
6345     case F_Z_engine_record:
6346       {
6347         recordParts -> storeCommands (*command_line);
6348         break;
6349       }
6350     case F_X_gear_record:
6351       {
6352         recordParts -> storeCommands (*command_line);
6353         break;
6354       }
6355     case F_Y_gear_record:
6356       {
6357         recordParts -> storeCommands (*command_line);
6358         break;
6359       }
6360     case F_Z_gear_record:
6361       {
6362         recordParts -> storeCommands (*command_line);
6363         break;
6364       }
6365     case F_X_record:
6366       {
6367         recordParts -> storeCommands (*command_line);
6368         break;
6369       }
6370     case F_Y_record:
6371       {
6372         recordParts -> storeCommands (*command_line);
6373         break;
6374       }
6375     case F_Z_record:
6376       {
6377         recordParts -> storeCommands (*command_line);
6378         break;
6379       }
6380     case F_north_record:
6381       {
6382         recordParts -> storeCommands (*command_line);
6383         break;
6384       }
6385     case F_east_record:
6386       {
6387         recordParts -> storeCommands (*command_line);
6388         break;
6389       }
6390     case F_down_record:
6391       {
6392         recordParts -> storeCommands (*command_line);
6393         break;
6394       }
6395
6396       /*********************** Moments ***********************/
6397     case M_l_aero_record:
6398       {
6399         recordParts -> storeCommands (*command_line);
6400         break;
6401       }
6402     case M_m_aero_record:
6403       {
6404         recordParts -> storeCommands (*command_line);
6405         break;
6406       }
6407     case M_n_aero_record:
6408       {
6409         recordParts -> storeCommands (*command_line);
6410         break;
6411       }
6412     case M_l_engine_record:
6413       {
6414         recordParts -> storeCommands (*command_line);
6415         break;
6416       }
6417     case M_m_engine_record:
6418       {
6419         recordParts -> storeCommands (*command_line);
6420         break;
6421       }
6422     case M_n_engine_record:
6423       {
6424         recordParts -> storeCommands (*command_line);
6425         break;
6426       }
6427     case M_l_gear_record:
6428       {
6429         recordParts -> storeCommands (*command_line);
6430         break;
6431       }
6432     case M_m_gear_record:
6433       {
6434         recordParts -> storeCommands (*command_line);
6435         break;
6436       }
6437     case M_n_gear_record:
6438       {
6439         recordParts -> storeCommands (*command_line);
6440         break;
6441       }
6442     case M_l_rp_record:
6443       {
6444         recordParts -> storeCommands (*command_line);
6445         break;
6446       }
6447     case M_m_rp_record:
6448       {
6449         recordParts -> storeCommands (*command_line);
6450         break;
6451       }
6452     case M_n_rp_record:
6453       {
6454         recordParts -> storeCommands (*command_line);
6455         break;
6456       }
6457       /****************** Flapper Data ***********************/
6458       /*    case flapper_freq_record:
6459       {
6460         recordParts -> storeCommands (*command_line);
6461         break;
6462       }
6463     case flapper_phi_record:
6464       {
6465         recordParts -> storeCommands (*command_line);
6466         break;
6467       }
6468     case flapper_phi_deg_record:
6469       {
6470         recordParts -> storeCommands (*command_line);
6471         break;
6472       }
6473     case flapper_Lift_record:
6474       {
6475         recordParts -> storeCommands (*command_line);
6476         break;
6477       }
6478     case flapper_Thrust_record:
6479       {
6480         recordParts -> storeCommands (*command_line);
6481         break;
6482       }
6483     case flapper_Inertia_record:
6484       {
6485         recordParts -> storeCommands (*command_line);
6486         break;
6487       }
6488     case flapper_Moment_record:
6489       {
6490         recordParts -> storeCommands (*command_line);
6491         break;
6492         }*/
6493     default:
6494       {
6495         if (dont_ignore)
6496           uiuc_warnings_errors(2, *command_line);
6497         break;
6498       }
6499     };
6500 }
6501
6502
6503 void parse_misc( const string& linetoken2, const string& linetoken3,
6504                  const string& aircraft_directory, LIST command_line ) {
6505   double token_value;
6506   istrstream token3(linetoken3.c_str());
6507
6508   switch(misc_map[linetoken2])
6509     {
6510     case simpleHingeMomentCoef_flag:
6511       {
6512         if (check_float(linetoken3))
6513           token3 >> token_value;
6514         else
6515           uiuc_warnings_errors(1, *command_line);
6516
6517         simpleHingeMomentCoef = token_value;
6518         break;
6519       }
6520     case dfTimefdf_flag:
6521       {
6522         dfTimefdf = linetoken3;
6523         /* call 1D File Reader with file name (dfTimefdf);
6524            function returns array of dfs (dfArray) and
6525            corresponding time values (TimeArray) and max
6526            number of terms in arrays (ndf) */
6527         uiuc_1DdataFileReader(dfTimefdf,
6528                               dfTimefdf_dfArray,
6529                               dfTimefdf_TimeArray,
6530                               dfTimefdf_ndf);
6531         break;
6532       }
6533       /*    case flapper_flag:
6534       {
6535         string flap_file;
6536
6537         flap_file = aircraft_directory + "flap.dat";
6538         flapper_model = true;
6539         flapper_data = new FlapData(flap_file.c_str());
6540         break;
6541       }
6542     case flapper_phi_init_flag:
6543       {
6544         if (check_float(linetoken3))
6545           token3 >> token_value;
6546         else
6547           uiuc_warnings_errors(1, *command_line);
6548
6549         flapper_phi_init = token_value*DEG_TO_RAD;
6550         break;
6551         }*/
6552     default:
6553       {
6554         if (dont_ignore)
6555           uiuc_warnings_errors(2, *command_line);
6556         break;
6557       }
6558     };
6559 }
6560
6561
6562 void uiuc_menu( string aircraft_name )
6563 {
6564   string aircraft_directory;
6565   stack command_list;
6566   double token_value;
6567   int token_value_recordRate;
6568   int token_value_convert1, token_value_convert2, token_value_convert3;
6569
6570   string linetoken1;
6571   string linetoken2;
6572   string linetoken3;
6573   string linetoken4;
6574   string linetoken5;
6575   string linetoken6;
6576   string linetoken7;
6577   string linetoken8;
6578   string linetoken9;
6579
6580   double datafile_xArray[100][100], datafile_yArray[100];
6581   double datafile_zArray[100][100];
6582   int datafile_nxArray[100], datafile_ny;
6583
6584   bool CXfabetaf_first = true;
6585   bool CXfadef_first = true;
6586   bool CXfaqf_first = true;
6587   bool CZfabetaf_first = true;
6588   bool CZfadef_first = true;
6589   bool CZfaqf_first = true;
6590   bool Cmfabetaf_first = true;
6591   bool Cmfadef_first = true;
6592   bool Cmfaqf_first = true;
6593   bool CYfabetaf_first = true;
6594   bool CYfadaf_first = true;
6595   bool CYfadrf_first = true;
6596   bool CYfapf_first = true;
6597   bool CYfarf_first = true;
6598   bool Clfabetaf_first = true;
6599   bool Clfadaf_first = true;
6600   bool Clfadrf_first = true;
6601   bool Clfapf_first = true;
6602   bool Clfarf_first = true;
6603   bool Cnfabetaf_first = true;
6604   bool Cnfadaf_first = true;
6605   bool Cnfadrf_first = true;
6606   bool Cnfapf_first = true;
6607   bool Cnfarf_first = true;
6608
6609   /* the following default setting should eventually be moved to a default or uiuc_init routine */
6610
6611   recordRate = 1;       /* record every time step, default */
6612   recordStartTime = 0;  /* record from beginning of simulation */
6613
6614 /* set speed at which dynamic pressure terms will be accounted for,
6615    since if velocity is too small, coefficients will go to infinity */
6616   dyn_on_speed      = 33;    /* 20 kts, default */
6617   dyn_on_speed_zero = 0.5 * dyn_on_speed;    /* only used of use_dyn_on_speed_curve1 is used */
6618   bootindex = 0;  // the index for the bootTime
6619
6620   dont_ignore = true;
6621
6622   /* Read the file and get the list of commands */
6623   airplane = new ParseFile(aircraft_name); /* struct that includes all lines of the input file */
6624   command_list = airplane -> getCommands();
6625   /* structs to include all parts included in the input file for specific keyword groups */
6626   initParts          = new ParseFile();
6627   geometryParts      = new ParseFile();
6628   massParts          = new ParseFile();
6629   engineParts        = new ParseFile();
6630   aeroDragParts      = new ParseFile();
6631   aeroLiftParts      = new ParseFile();
6632   aeroPitchParts     = new ParseFile();
6633   aeroSideforceParts = new ParseFile();
6634   aeroRollParts      = new ParseFile();
6635   aeroYawParts       = new ParseFile();
6636   gearParts          = new ParseFile();
6637   recordParts        = new ParseFile();
6638
6639   if (command_list.begin() == command_list.end())
6640   {
6641     cerr << "UIUC ERROR: File " << aircraft_name <<" does not exist" << endl;
6642     exit(-1);
6643   }
6644
6645   //construct aircraft-directory
6646   aircraft_directory = aircraft_name;
6647   int index_aircraft_dat = aircraft_directory.find("aircraft.dat");
6648   aircraft_directory.erase(index_aircraft_dat,12);
6649
6650   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
6651     {
6652       cout << *command_line << endl;
6653
6654       linetoken1 = airplane -> getToken (*command_line, 1);
6655       linetoken2 = airplane -> getToken (*command_line, 2);
6656       linetoken3 = airplane -> getToken (*command_line, 3);
6657       linetoken4 = airplane -> getToken (*command_line, 4);
6658       linetoken5 = airplane -> getToken (*command_line, 5);
6659       linetoken6 = airplane -> getToken (*command_line, 6);
6660       linetoken7 = airplane -> getToken (*command_line, 7);
6661       linetoken8 = airplane -> getToken (*command_line, 8);
6662       linetoken9 = airplane -> getToken (*command_line, 9);
6663
6664       istrstream token3(linetoken3.c_str());
6665       istrstream token4(linetoken4.c_str());
6666       istrstream token5(linetoken5.c_str());
6667       istrstream token6(linetoken6.c_str());
6668       istrstream token7(linetoken7.c_str());
6669       istrstream token8(linetoken8.c_str());
6670       istrstream token9(linetoken9.c_str());
6671
6672       switch (Keyword_map[linetoken1])
6673         {
6674         case init_flag:
6675           {
6676             parse_init( linetoken2, linetoken3, command_line );
6677             break;
6678           } // end init map
6679
6680
6681         case geometry_flag:
6682           {
6683             parse_geometry( linetoken2, linetoken3, command_line );
6684             break;
6685           } // end geometry map
6686
6687
6688         case controlSurface_flag:
6689           {
6690             parse_controlSurface( linetoken2, linetoken3, linetoken4,
6691                                   linetoken5, linetoken6, aircraft_directory,
6692                                   command_line );
6693             break;
6694           } // end controlSurface map
6695
6696
6697         case mass_flag:
6698           {
6699             parse_mass( linetoken2, linetoken3, command_line );
6700             break;
6701           } // end mass map
6702
6703
6704         case engine_flag:
6705           {
6706             parse_engine( linetoken2, linetoken3, linetoken4,
6707                           linetoken5, linetoken6, aircraft_directory,
6708                           command_line );
6709             break;
6710           } // end engine map
6711
6712
6713         case CD_flag:
6714           {
6715             parse_CD( linetoken2, linetoken3, linetoken4,
6716                       linetoken5, linetoken6, linetoken7,
6717                       linetoken8, linetoken9, aircraft_directory,
6718                       CXfabetaf_first, CXfadef_first,
6719                       CXfaqf_first, command_line );
6720             break;
6721           } // end CD map
6722
6723
6724         case CL_flag:
6725           {
6726             parse_CL( linetoken2, linetoken3, linetoken4,
6727                       linetoken5, linetoken6, linetoken7,
6728                       linetoken8, linetoken9, aircraft_directory,
6729                       CZfabetaf_first, CZfadef_first,
6730                       CZfaqf_first, command_line );
6731             break;
6732           } // end CL map
6733
6734
6735         case Cm_flag:
6736           {
6737             parse_Cm( linetoken2, linetoken3, linetoken4,
6738                       linetoken5, linetoken6, linetoken7,
6739                       linetoken8, linetoken9, aircraft_directory,
6740                       Cmfabetaf_first, Cmfadef_first,
6741                       Cmfaqf_first, command_line );
6742             break;
6743           } // end Cm map
6744
6745
6746         case CY_flag:
6747           {
6748             parse_CY( linetoken2, linetoken3, linetoken4,
6749                       linetoken5, linetoken6, linetoken7,
6750                       linetoken8, linetoken9, aircraft_directory,
6751                       CYfabetaf_first, CYfadaf_first,
6752                       CYfadrf_first, CYfapf_first, CYfarf_first,
6753                       command_line );
6754             break;
6755           } // end CY map
6756
6757
6758         case Cl_flag:
6759           {
6760             parse_Cl( linetoken2, linetoken3, linetoken4,
6761                       linetoken5, linetoken6, linetoken7,
6762                       linetoken8, linetoken9, aircraft_directory,
6763                       Clfabetaf_first, Clfadaf_first,
6764                       Clfadrf_first, Clfapf_first, Clfarf_first,
6765                       command_line );
6766             break;
6767           } // end Cl map
6768
6769
6770         case Cn_flag:
6771           {
6772             parse_Cn( linetoken2, linetoken3, linetoken4,
6773                       linetoken5, linetoken6, linetoken7,
6774                       linetoken8, linetoken9, aircraft_directory,
6775                       Cnfabetaf_first, Cnfadaf_first,
6776                       Cnfadrf_first, Cnfapf_first, Cnfarf_first,
6777                       command_line );
6778             break;
6779           } // end Cn map
6780
6781
6782         case gear_flag:
6783           {
6784             int index;
6785             token3 >> index;
6786             if (index < 0 || index >= 16)
6787               uiuc_warnings_errors(1, *command_line);
6788             parse_gear( linetoken2, linetoken3, linetoken4,
6789                         index, command_line );
6790             break;
6791           } // end gear map
6792
6793
6794         case ice_flag:
6795           {
6796             parse_ice( linetoken2, linetoken3, linetoken4,
6797                        command_line );
6798             break;
6799           } // end ice map
6800
6801
6802         case fog_flag:
6803           {
6804             parse_fog( linetoken2, linetoken3, linetoken4,
6805                        command_line );
6806             break;
6807           } // end fog map
6808
6809
6810         case record_flag:
6811           {
6812             static int fout_flag=0;
6813             if (fout_flag==0)
6814             {
6815               fout_flag=-1;
6816               fout.open("uiuc_record.dat");
6817             }
6818             parse_record( linetoken2, command_line );
6819             break;
6820           } // end record map
6821
6822
6823         case misc_flag:
6824           {
6825             parse_misc( linetoken2, linetoken3, aircraft_directory,
6826                         command_line );
6827             break;
6828           } // end misc map
6829
6830
6831         default:
6832           {
6833             if (linetoken1=="*")
6834                 return;
6835             if (dont_ignore)
6836               uiuc_warnings_errors(2, *command_line);
6837             break;
6838           }
6839         };
6840     } // end keyword map
6841
6842   delete airplane;
6843 }
6844
6845 // end menu.cpp