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
  45 ----------------------------------------------------------------------
  46
  47  AUTHOR(S):    Bipin Sehgal       <bsehgal@uiuc.edu>
  48                Jeff Scott         <jscott@mail.com>
  49                Michael Selig      <m-selig@uiuc.edu>
  50
  51 ----------------------------------------------------------------------
  52
  53  VARIABLES:
  54
  55 ----------------------------------------------------------------------
  56
  57  INPUTS:       n/a
  58
  59 ----------------------------------------------------------------------
  60
  61  OUTPUTS:      n/a
  62
  63 ----------------------------------------------------------------------
  64
  65  CALLED BY:    uiuc_wrapper.cpp
  66
  67 ----------------------------------------------------------------------
  68
  69  CALLS TO:     aircraft.dat
  70                tabulated data files (if needed)
  71
  72 ----------------------------------------------------------------------
  73
  74  COPYRIGHT:    (C) 2000 by Michael Selig
  75
  76  This program is free software; you can redistribute it and/or
  77  modify it under the terms of the GNU General Public License
  78  as published by the Free Software Foundation.
  79
  80  This program is distributed in the hope that it will be useful,
  81  but WITHOUT ANY WARRANTY; without even the implied warranty of
  82  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  83  GNU General Public License for more details.
  84
  85  You should have received a copy of the GNU General Public License
  86  along with this program; if not, write to the Free Software
  87  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  88  USA or view http://www.gnu.org/copyleft/gpl.html.
  89
  90 **********************************************************************/
  91
  92 #include <simgear/compiler.h>
  93
  94 #if defined( __MWERKS__ )
  95 // -dw- optimizer chokes (big-time) trying to optimize humongous
  96 // loop/switch statements
  97 #pragma optimization_level 0
  98 #endif
  99
 100 #include <stdlib.h>
 101 #include <iostream>
 102
 103 #include "uiuc_menu.h"
 104
 105 FG_USING_STD(cerr);
 106 FG_USING_STD(cout);
 107 FG_USING_STD(endl);
 108
 109 #ifndef _MSC_VER
 110 FG_USING_STD(exit);
 111 #endif
 112
 113 bool check_float(string  &token)
 114 {
 115   float value;
 116   istrstream stream(token.c_str());
 117   return (stream >> value);
 118 }
 119
 120
 121 void uiuc_menu( string aircraft_name )
 122 {
 123   stack command_list;
 124   double token_value;
 125   int token_value_recordRate;
 126   int token_value_convert1, token_value_convert2, token_value_convert3;
 127
 128   string linetoken1;
 129   string linetoken2;
 130   string linetoken3;
 131   string linetoken4;
 132   string linetoken5;
 133   string linetoken6;
 134
 135
 136   /* the following default setting should eventually be moved to a default or uiuc_init routine */
 137
 138   recordRate = 1;       /* record every time step, default */
 139   recordStartTime = 0;  /* record from beginning of simulation */
 140
 141 /* set speed at which dynamic pressure terms will be accounted for,
 142    since if velocity is too small, coefficients will go to infinity */
 143   dyn_on_speed = 33;    /* 20 kts, default */
 144
 145
 146
 147   /* Read the file and get the list of commands */
 148   airplane = new ParseFile(aircraft_name); /* struct that includes all lines of the input file */
 149   command_list = airplane -> getCommands();
 150   /* structs to include all parts included in the input file for specific keyword groups */
 151   initParts          = new ParseFile();
 152   geometryParts      = new ParseFile();
 153   massParts          = new ParseFile();
 154   engineParts        = new ParseFile();
 155   aeroDragParts      = new ParseFile();
 156   aeroLiftParts      = new ParseFile();
 157   aeroPitchParts     = new ParseFile();
 158   aeroSideforceParts = new ParseFile();
 159   aeroRollParts      = new ParseFile();
 160   aeroYawParts       = new ParseFile();
 161   gearParts          = new ParseFile();
 162   recordParts        = new ParseFile();
 163
 164   if (command_list.begin() == command_list.end())
 165   {
 166     cerr << "UIUC ERROR: File " << aircraft_name <<" does not exist" << endl;
 167     exit(-1);
 168   }
 169
 170   for (LIST command_line = command_list.begin(); command_line!=command_list.end(); ++command_line)
 171     {
 172       cout << *command_line << endl;
 173
 174       linetoken1 = airplane -> getToken (*command_line, 1);
 175       linetoken2 = airplane -> getToken (*command_line, 2);
 176       linetoken3 = airplane -> getToken (*command_line, 3);
 177       linetoken4 = airplane -> getToken (*command_line, 4);
 178       linetoken5 = airplane -> getToken (*command_line, 5);
 179       linetoken6 = airplane -> getToken (*command_line, 6);
 180
 181       istrstream token3(linetoken3.c_str());
 182       istrstream token4(linetoken4.c_str());
 183       istrstream token5(linetoken5.c_str());
 184       istrstream token6(linetoken6.c_str());
 185
 186       switch (Keyword_map[linetoken1])
 187         {
 188         case init_flag:
 189           {
 190             switch(init_map[linetoken2])
 191               {
 192               case Dx_pilot_flag:
 193                 {
 194                   if (check_float(linetoken3))
 195                     token3 >> token_value;
 196                   else
 197                     uiuc_warnings_errors(1, *command_line);
 198
 199                   Dx_pilot = token_value;
 200                   initParts -> storeCommands (*command_line);
 201                   break;
 202                 }
 203               case Dy_pilot_flag:
 204                 {
 205                   if (check_float(linetoken3))
 206                     token3 >> token_value;
 207                   else
 208                     uiuc_warnings_errors(1, *command_line);
 209
 210                   Dy_pilot = token_value;
 211                   initParts -> storeCommands (*command_line);
 212                   break;
 213                 }
 214               case Dz_pilot_flag:
 215                 {
 216                   if (check_float(linetoken3))
 217                     token3 >> token_value;
 218                   else
 219                     uiuc_warnings_errors(1, *command_line);
 220
 221                   Dz_pilot = token_value;
 222                   initParts -> storeCommands (*command_line);
 223                   break;
 224                 }
 225               case Dx_cg_flag:
 226                 {
 227                   if (check_float(linetoken3))
 228                     token3 >> token_value;
 229                   else
 230                     uiuc_warnings_errors(1, *command_line);
 231
 232                   Dx_cg = token_value;
 233                   initParts -> storeCommands (*command_line);
 234                   break;
 235                 }
 236               case Dy_cg_flag:
 237                 {
 238                   if (check_float(linetoken3))
 239                     token3 >> token_value;
 240                   else
 241                     uiuc_warnings_errors(1, *command_line);
 242
 243                   Dy_cg = token_value;
 244                   initParts -> storeCommands (*command_line);
 245                   break;
 246                 }
 247               case Dz_cg_flag:
 248                 {
 249                   if (check_float(linetoken3))
 250                     token3 >> token_value;
 251                   else
 252                     uiuc_warnings_errors(1, *command_line);
 253
 254                   Dz_cg = token_value;
 255                   initParts -> storeCommands (*command_line);
 256                   break;
 257                 }
 258               case Altitude_flag:
 259                 {
 260                   if (check_float(linetoken3))
 261                     token3 >> token_value;
 262                   else
 263                     uiuc_warnings_errors(1, *command_line);
 264
 265                   Altitude = token_value;
 266                   initParts -> storeCommands (*command_line);
 267                   break;
 268                 }
 269               case V_north_flag:
 270                 {
 271                   if (check_float(linetoken3))
 272                     token3 >> token_value;
 273                   else
 274                     uiuc_warnings_errors(1, *command_line);
 275
 276                   V_north = token_value;
 277                   initParts -> storeCommands (*command_line);
 278                   break;
 279                 }
 280               case V_east_flag:
 281                 {
 282                   initParts -> storeCommands (*command_line);
 283                   if (check_float(linetoken3))
 284                     token3 >> token_value;
 285                   else
 286                     uiuc_warnings_errors(1, *command_line);
 287
 288                   V_east = token_value;
 289                   break;
 290                 }
 291               case V_down_flag:
 292                 {
 293                   if (check_float(linetoken3))
 294                     token3 >> token_value;
 295                   else
 296                     uiuc_warnings_errors(1, *command_line);
 297
 298                   V_down = token_value;
 299                   initParts -> storeCommands (*command_line);
 300                   break;
 301                 }
 302               case P_body_flag:
 303                 {
 304                   if (check_float(linetoken3))
 305                     token3 >> token_value;
 306                   else
 307                     uiuc_warnings_errors(1, *command_line);
 308
 309                   P_body = token_value;
 310                   initParts -> storeCommands (*command_line);
 311                   break;
 312                 }
 313               case Q_body_flag:
 314                 {
 315                   if (check_float(linetoken3))
 316                     token3 >> token_value;
 317                   else
 318                     uiuc_warnings_errors(1, *command_line);
 319
 320                   Q_body = token_value;
 321                   initParts -> storeCommands (*command_line);
 322                   break;
 323                 }
 324               case R_body_flag:
 325                 {
 326                   if (check_float(linetoken3))
 327                     token3 >> token_value;
 328                   else
 329                     uiuc_warnings_errors(1, *command_line);
 330
 331                   R_body = token_value;
 332                   initParts -> storeCommands (*command_line);
 333                   break;
 334                 }
 335               case Phi_flag:
 336                 {
 337                   if (check_float(linetoken3))
 338                     token3 >> token_value;
 339                   else
 340                     uiuc_warnings_errors(1, *command_line);
 341
 342                   Phi = token_value;
 343                   initParts -> storeCommands (*command_line);
 344                   break;
 345                 }
 346               case Theta_flag:
 347                 {
 348                   if (check_float(linetoken3))
 349                     token3 >> token_value;
 350                   else
 351                     uiuc_warnings_errors(1, *command_line);
 352
 353                   Theta = token_value;
 354                   initParts -> storeCommands (*command_line);
 355                   break;
 356                 }
 357               case Psi_flag:
 358                 {
 359                   if (check_float(linetoken3))
 360                     token3 >> token_value;
 361                   else
 362                     uiuc_warnings_errors(1, *command_line);
 363
 364                   Psi = token_value;
 365                   initParts -> storeCommands (*command_line);
 366                   break;
 367                 }
 368               case Long_trim_flag:
 369                 {
 370                   if (check_float(linetoken3))
 371                     token3 >> token_value;
 372                   else
 373                     uiuc_warnings_errors(1, *command_line);
 374
 375                   Long_trim = token_value;
 376                   initParts -> storeCommands (*command_line);
 377                   break;
 378                 }
 379               case recordRate_flag:
 380                 {
 381                   //can't use check_float since variable is integer
 382                   token3 >> token_value_recordRate;
 383                   recordRate = 120 / token_value_recordRate;
 384                   break;
 385                 }
 386               case recordStartTime_flag:
 387                 {
 388                   if (check_float(linetoken3))
 389                     token3 >> token_value;
 390                   else
 391                     uiuc_warnings_errors(1, *command_line);
 392
 393                   recordStartTime = token_value;
 394                   break;
 395                 }
 396               case nondim_rate_V_rel_wind_flag:
 397                 {
 398                   nondim_rate_V_rel_wind = true;
 399                   break;
 400                 }
 401               case dyn_on_speed_flag:
 402                 {
 403                   if (check_float(linetoken3))
 404                     token3 >> token_value;
 405                   else
 406                     uiuc_warnings_errors(1, *command_line);
 407
 408                   dyn_on_speed = token_value;
 409                   break;
 410                 }
 411               default:
 412                 {
 413                   uiuc_warnings_errors(2, *command_line);
 414                   break;
 415                 }
 416               };
 417             break;
 418           } // end init map
 419
 420
 421         case geometry_flag:
 422           {
 423             switch(geometry_map[linetoken2])
 424               {
 425               case bw_flag:
 426                 {
 427                   if (check_float(linetoken3))
 428                     token3 >> token_value;
 429                   else
 430                     uiuc_warnings_errors(1, *command_line);
 431
 432                   bw = token_value;
 433                   geometryParts -> storeCommands (*command_line);
 434                   break;
 435                 }
 436               case cbar_flag:
 437                 {
 438                   if (check_float(linetoken3))
 439                     token3 >> token_value;
 440                   else
 441                     uiuc_warnings_errors(1, *command_line);
 442
 443                   cbar = token_value;
 444                   geometryParts -> storeCommands (*command_line);
 445                   break;
 446                 }
 447               case Sw_flag:
 448                 {
 449                   if (check_float(linetoken3))
 450                     token3 >> token_value;
 451                   else
 452                     uiuc_warnings_errors(1, *command_line);
 453
 454                   Sw = token_value;
 455                   geometryParts -> storeCommands (*command_line);
 456                   break;
 457                 }
 458               case ih_flag:
 459                 {
 460                   if (check_float(linetoken3))
 461                     token3 >> token_value;
 462                   else
 463                     uiuc_warnings_errors(1, *command_line);
 464
 465                   ih = token_value;
 466                   geometryParts -> storeCommands (*command_line);
 467                   break;
 468                 }
 469               case bh_flag:
 470                 {
 471                   if (check_float(linetoken3))
 472                     token3 >> token_value;
 473                   else
 474                     uiuc_warnings_errors(1, *command_line);
 475
 476                   bh = token_value;
 477                   geometryParts -> storeCommands (*command_line);
 478                   break;
 479                 }
 480               case ch_flag:
 481                 {
 482                   if (check_float(linetoken3))
 483                     token3 >> token_value;
 484                   else
 485                     uiuc_warnings_errors(1, *command_line);
 486
 487                   ch = token_value;
 488                   geometryParts -> storeCommands (*command_line);
 489                   break;
 490                 }
 491               case Sh_flag:
 492                 {
 493                   if (check_float(linetoken3))
 494                     token3 >> token_value;
 495                   else
 496                     uiuc_warnings_errors(1, *command_line);
 497
 498                   Sh = token_value;
 499                   geometryParts -> storeCommands (*command_line);
 500                   break;
 501                 }
 502               default:
 503                 {
 504                   uiuc_warnings_errors(2, *command_line);
 505                   break;
 506                 }
 507               };
 508             break;
 509           } // end geometry map
 510
 511
 512         case controlSurface_flag:
 513           {
 514             switch(controlSurface_map[linetoken2])
 515               {
 516               case de_flag:
 517                 {
 518                   if (check_float(linetoken3))
 519                     token3 >> token_value;
 520                   else
 521                     uiuc_warnings_errors(1, *command_line);
 522
 523                   demax = token_value;
 524
 525                   if (check_float(linetoken4))
 526                     token4 >> token_value;
 527                   else
 528                     uiuc_warnings_errors(1, *command_line);
 529
 530                   demin = token_value;
 531                   break;
 532                 }
 533               case da_flag:
 534                 {
 535                   if (check_float(linetoken3))
 536                     token3 >> token_value;
 537                   else
 538                     uiuc_warnings_errors(1, *command_line);
 539
 540                   damax = token_value;
 541
 542                   if (check_float(linetoken4))
 543                     token4 >> token_value;
 544                   else
 545                     uiuc_warnings_errors(1, *command_line);
 546
 547                   damin = token_value;
 548                   break;
 549                 }
 550               case dr_flag:
 551                 {
 552                   if (check_float(linetoken3))
 553                     token3 >> token_value;
 554                   else
 555                     uiuc_warnings_errors(1, *command_line);
 556
 557                   drmax = token_value;
 558
 559                   if (check_float(linetoken4))
 560                     token4 >> token_value;
 561                   else
 562                     uiuc_warnings_errors(1, *command_line);
 563
 564                   drmin = token_value;
 565                   break;
 566                 }
 567               case set_Long_trim_flag:
 568                 {
 569                   if (check_float(linetoken3))
 570                     token3 >> token_value;
 571                   else
 572                     uiuc_warnings_errors(1, *command_line);
 573
 574                   set_Long_trim = true;
 575                   elevator_tab = token_value;
 576                   break;
 577                 }
 578               case set_Long_trim_deg_flag:
 579                 {
 580                   if (check_float(linetoken3))
 581                     token3 >> token_value;
 582                   else
 583                     uiuc_warnings_errors(1, *command_line);
 584
 585                   set_Long_trim = true;
 586                   elevator_tab = token_value * DEG_TO_RAD;
 587                   break;
 588                 }
 589               case zero_Long_trim_flag:
 590                 {
 591                   zero_Long_trim = true;
 592                   break;
 593                 }
 594               case elevator_step_flag:
 595                 {
 596                   // set step input flag
 597                   elevator_step = true;
 598
 599                   // read in step angle in degrees and convert
 600                   if (check_float(linetoken3))
 601                     token3 >> token_value;
 602                   else
 603                     uiuc_warnings_errors(1, *command_line);
 604
 605                   elevator_step_angle = token_value * DEG_TO_RAD;
 606
 607                   // read in step start time
 608                   if (check_float(linetoken4))
 609                     token4 >> token_value;
 610                   else
 611                     uiuc_warnings_errors(1, *command_line);
 612
 613                   elevator_step_startTime = token_value;
 614                   break;
 615                 }
 616               case elevator_singlet_flag:
 617                 {
 618                   // set singlet input flag
 619                   elevator_singlet = true;
 620
 621                   // read in singlet angle in degrees and convert
 622                   if (check_float(linetoken3))
 623                     token3 >> token_value;
 624                   else
 625                     uiuc_warnings_errors(1, *command_line);
 626
 627                   elevator_singlet_angle = token_value * DEG_TO_RAD;
 628
 629                   // read in singlet start time
 630                   if (check_float(linetoken4))
 631                     token4 >> token_value;
 632                   else
 633                     uiuc_warnings_errors(1, *command_line);
 634
 635                   elevator_singlet_startTime = token_value;
 636
 637                   // read in singlet duration
 638                   if (check_float(linetoken5))
 639                     token5 >> token_value;
 640                   else
 641                     uiuc_warnings_errors(1, *command_line);
 642
 643                   elevator_singlet_duration = token_value;
 644                   break;
 645                 }
 646               case elevator_doublet_flag:
 647                 {
 648                   // set doublet input flag
 649                   elevator_doublet = true;
 650
 651                   // read in doublet angle in degrees and convert
 652                   if (check_float(linetoken3))
 653                     token3 >> token_value;
 654                   else
 655                     uiuc_warnings_errors(1, *command_line);
 656
 657                   elevator_doublet_angle = token_value * DEG_TO_RAD;
 658
 659                   // read in doublet start time
 660                   if (check_float(linetoken4))
 661                     token4 >> token_value;
 662                   else
 663                     uiuc_warnings_errors(1, *command_line);
 664
 665                   elevator_doublet_startTime = token_value;
 666
 667                   // read in doublet duration
 668                   if (check_float(linetoken5))
 669                     token5 >> token_value;
 670                   else
 671                     uiuc_warnings_errors(1, *command_line);
 672
 673                   elevator_doublet_duration = token_value;
 674                   break;
 675                 }
 676               case elevator_input_flag:
 677                 {
 678                   elevator_input = true;
 679                   elevator_input_file = linetoken3;
 680                   token4 >> token_value_convert1;
 681                   token5 >> token_value_convert2;
 682                   convert_y = uiuc_convert(token_value_convert1);
 683                   convert_x = uiuc_convert(token_value_convert2);
 684                   uiuc_1DdataFileReader(elevator_input_file,
 685                                         elevator_input_timeArray,
 686                                         elevator_input_deArray,
 687                                         elevator_input_ntime);
 688                   token6 >> token_value;
 689                   elevator_input_startTime = token_value;
 690                   break;
 691                 }
 692               default:
 693                 {
 694                   uiuc_warnings_errors(2, *command_line);
 695                   break;
 696                 }
 697               };
 698             break;
 699           } // end controlSurface map
 700
 701
 702         case mass_flag:
 703           {
 704             switch(mass_map[linetoken2])
 705               {
 706               case Weight_flag:
 707                 {
 708                   if (check_float(linetoken3))
 709                     token3 >> token_value;
 710                   else
 711                     uiuc_warnings_errors(1, *command_line);
 712
 713                   Weight = token_value;
 714                   Mass = Weight * INVG;
 715                   massParts -> storeCommands (*command_line);
 716                   break;
 717                 }
 718               case Mass_flag:
 719                 {
 720                   if (check_float(linetoken3))
 721                     token3 >> token_value;
 722                   else
 723                     uiuc_warnings_errors(1, *command_line);
 724
 725                   Mass = token_value;
 726                   massParts -> storeCommands (*command_line);
 727                   break;
 728                 }
 729               case I_xx_flag:
 730                 {
 731                   if (check_float(linetoken3))
 732                     token3 >> token_value;
 733                   else
 734                     uiuc_warnings_errors(1, *command_line);
 735
 736                   I_xx = token_value;
 737                   massParts -> storeCommands (*command_line);
 738                   break;
 739                 }
 740               case I_yy_flag:
 741                 {
 742                   if (check_float(linetoken3))
 743                     token3 >> token_value;
 744                   else
 745                     uiuc_warnings_errors(1, *command_line);
 746
 747                   I_yy = token_value;
 748                   massParts -> storeCommands (*command_line);
 749                   break;
 750                 }
 751               case I_zz_flag:
 752                 {
 753                   if (check_float(linetoken3))
 754                     token3 >> token_value;
 755                   else
 756                     uiuc_warnings_errors(1, *command_line);
 757
 758                   I_zz = token_value;
 759                   massParts -> storeCommands (*command_line);
 760                   break;
 761                 }
 762               case I_xz_flag:
 763                 {
 764                   if (check_float(linetoken3))
 765                     token3 >> token_value;
 766                   else
 767                     uiuc_warnings_errors(1, *command_line);
 768
 769                   I_xz = token_value;
 770                   massParts -> storeCommands (*command_line);
 771                   break;
 772                 }
 773               default:
 774                 {
 775                   uiuc_warnings_errors(2, *command_line);
 776                   break;
 777                 }
 778               };
 779             break;
 780           } // end mass map
 781
 782
 783         case engine_flag:
 784           {
 785             switch(engine_map[linetoken2])
 786               {
 787               case simpleSingle_flag:
 788                 {
 789                   if (check_float(linetoken3))
 790                     token3 >> token_value;
 791                   else
 792                     uiuc_warnings_errors(1, *command_line);
 793
 794                   simpleSingleMaxThrust = token_value;
 795                   engineParts -> storeCommands (*command_line);
 796                   break;
 797                 }
 798               case c172_flag:
 799                 {
 800                   engineParts -> storeCommands (*command_line);
 801                   break;
 802                 }
 803               case cherokee_flag:
 804                 {
 805                   engineParts -> storeCommands (*command_line);
 806                   break;
 807                 }
 808               default:
 809                 {
 810                   uiuc_warnings_errors(2, *command_line);
 811                   break;
 812                 }
 813               };
 814             break;
 815           } // end engine map
 816
 817
 818         case CD_flag:
 819           {
 820             switch(CD_map[linetoken2])
 821               {
 822               case CDo_flag:
 823                 {
 824                   if (check_float(linetoken3))
 825                     token3 >> token_value;
 826                   else
 827                     uiuc_warnings_errors(1, *command_line);
 828
 829                   CDo = token_value;
 830                   CDo_clean = CDo;
 831                   aeroDragParts -> storeCommands (*command_line);
 832                   break;
 833                 }
 834               case CDK_flag:
 835                 {
 836                   if (check_float(linetoken3))
 837                     token3 >> token_value;
 838                   else
 839                     uiuc_warnings_errors(1, *command_line);
 840
 841                   CDK = token_value;
 842                   CDK_clean = CDK;
 843                   aeroDragParts -> storeCommands (*command_line);
 844                   break;
 845                 }
 846               case CD_a_flag:
 847                 {
 848                   if (check_float(linetoken3))
 849                     token3 >> token_value;
 850                   else
 851                     uiuc_warnings_errors(1, *command_line);
 852
 853                   CD_a = token_value;
 854                   CD_a_clean = CD_a;
 855                   aeroDragParts -> storeCommands (*command_line);
 856                   break;
 857                 }
 858               case CD_adot_flag:
 859                 {
 860                   if (check_float(linetoken3))
 861                     token3 >> token_value;
 862                   else
 863                     uiuc_warnings_errors(1, *command_line);
 864
 865                   CD_adot = token_value;
 866                   CD_adot_clean = CD_adot;
 867                   aeroDragParts -> storeCommands (*command_line);
 868                   break;
 869                 }
 870               case CD_q_flag:
 871                 {
 872                   if (check_float(linetoken3))
 873                     token3 >> token_value;
 874                   else
 875                     uiuc_warnings_errors(1, *command_line);
 876
 877                   CD_q = token_value;
 878                   CD_q_clean = CD_q;
 879                   aeroDragParts -> storeCommands (*command_line);
 880                   break;
 881                 }
 882               case CD_ih_flag:
 883                 {
 884                   if (check_float(linetoken3))
 885                     token3 >> token_value;
 886                   else
 887                     uiuc_warnings_errors(1, *command_line);
 888
 889                   CD_ih = token_value;
 890                   aeroDragParts -> storeCommands (*command_line);
 891                   break;
 892                 }
 893               case CD_de_flag:
 894                 {
 895                   if (check_float(linetoken3))
 896                     token3 >> token_value;
 897                   else
 898                     uiuc_warnings_errors(1, *command_line);
 899
 900                   CD_de = token_value;
 901                   CD_de_clean = CD_de;
 902                   aeroDragParts -> storeCommands (*command_line);
 903                   break;
 904                 }
 905               case CDfa_flag:
 906                 {
 907                   CDfa = linetoken3;
 908                   token4 >> token_value_convert1;
 909                   token5 >> token_value_convert2;
 910                   convert_y = uiuc_convert(token_value_convert1);
 911                   convert_x = uiuc_convert(token_value_convert2);
 912                   /* call 1D File Reader with file name (CDfa) and conversion
 913                      factors; function returns array of alphas (aArray) and
 914                      corresponding CD values (CDArray) and max number of
 915                      terms in arrays (nAlpha) */
 916                   uiuc_1DdataFileReader(CDfa,
 917                                         CDfa_aArray,
 918                                         CDfa_CDArray,
 919                                         CDfa_nAlpha);
 920                   aeroDragParts -> storeCommands (*command_line);
 921                   break;
 922                 }
 923               case CDfCL_flag:
 924                 {
 925                   CDfCL = linetoken3;
 926                   token4 >> token_value_convert1;
 927                   token5 >> token_value_convert2;
 928                   convert_y = uiuc_convert(token_value_convert1);
 929                   convert_x = uiuc_convert(token_value_convert2);
 930                   /* call 1D File Reader with file name (CDfCL) and conversion
 931                      factors; function returns array of CLs (CLArray) and
 932                      corresponding CD values (CDArray) and max number of
 933                      terms in arrays (nCL) */
 934                   uiuc_1DdataFileReader(CDfCL,
 935                                         CDfCL_CLArray,
 936                                         CDfCL_CDArray,
 937                                         CDfCL_nCL);
 938                   aeroDragParts -> storeCommands (*command_line);
 939                   break;
 940                 }
 941               case CDfade_flag:
 942                 {
 943                   CDfade = linetoken3;
 944                   token4 >> token_value_convert1;
 945                   token5 >> token_value_convert2;
 946                   token6 >> token_value_convert3;
 947                   convert_z = uiuc_convert(token_value_convert1);
 948                   convert_x = uiuc_convert(token_value_convert2);
 949                   convert_y = uiuc_convert(token_value_convert3);
 950                   /* call 2D File Reader with file name (CDfade) and
 951                      conversion factors; function returns array of
 952                      elevator deflections (deArray) and corresponding
 953                      alpha (aArray) and delta CD (CDArray) values and
 954                      max number of terms in alpha arrays (nAlphaArray)
 955                      and deflection array (nde) */
 956                   uiuc_2DdataFileReader(CDfade,
 957                                         CDfade_aArray,
 958                                         CDfade_deArray,
 959                                         CDfade_CDArray,
 960                                         CDfade_nAlphaArray,
 961                                         CDfade_nde);
 962                   aeroDragParts -> storeCommands (*command_line);
 963                   break;
 964                 }
 965               case CDfdf_flag:
 966                 {
 967                   CDfdf = linetoken3;
 968                   token4 >> token_value_convert1;
 969                   token5 >> token_value_convert2;
 970                   convert_y = uiuc_convert(token_value_convert1);
 971                   convert_x = uiuc_convert(token_value_convert2);
 972                   /* call 1D File Reader with file name (CDfdf) and conversion
 973                      factors; function returns array of dfs (dfArray) and
 974                      corresponding CD values (CDArray) and max number of
 975                      terms in arrays (ndf) */
 976                   uiuc_1DdataFileReader(CDfdf,
 977                                         CDfdf_dfArray,
 978                                         CDfdf_CDArray,
 979                                         CDfdf_ndf);
 980                   aeroDragParts -> storeCommands (*command_line);
 981                   break;
 982                 }
 983               case CDfadf_flag:
 984                 {
 985                   CDfadf = linetoken3;
 986                   token4 >> token_value_convert1;
 987                   token5 >> token_value_convert2;
 988                   token6 >> token_value_convert3;
 989                   convert_z = uiuc_convert(token_value_convert1);
 990                   convert_x = uiuc_convert(token_value_convert2);
 991                   convert_y = uiuc_convert(token_value_convert3);
 992                   /* call 2D File Reader with file name (CDfadf) and
 993                      conversion factors; function returns array of
 994                      flap deflections (dfArray) and corresponding
 995                      alpha (aArray) and delta CD (CDArray) values and
 996                      max number of terms in alpha arrays (nAlphaArray)
 997                      and deflection array (ndf) */
 998                   uiuc_2DdataFileReader(CDfadf,
 999                                         CDfadf_aArray,
1000                                         CDfadf_dfArray,
1001                                         CDfadf_CDArray,
1002                                         CDfadf_nAlphaArray,
1003                                         CDfadf_ndf);
1004                   aeroDragParts -> storeCommands (*command_line);
1005                   break;
1006                 }
1007               case CXo_flag:
1008                 {
1009                   if (check_float(linetoken3))
1010                     token3 >> token_value;
1011                   else
1012                     uiuc_warnings_errors(1, *command_line);
1013
1014                   CXo = token_value;
1015                   CXo_clean = CXo;
1016                   aeroDragParts -> storeCommands (*command_line);
1017                   break;
1018                 }
1019               case CXK_flag:
1020                 {
1021                   if (check_float(linetoken3))
1022                     token3 >> token_value;
1023                   else
1024                     uiuc_warnings_errors(1, *command_line);
1025
1026                   CXK = token_value;
1027                   CXK_clean = CXK;
1028                   aeroDragParts -> storeCommands (*command_line);
1029                   break;
1030                 }
1031               case CX_a_flag:
1032                 {
1033                   if (check_float(linetoken3))
1034                     token3 >> token_value;
1035                   else
1036                     uiuc_warnings_errors(1, *command_line);
1037
1038                   CX_a = token_value;
1039                   CX_a_clean = CX_a;
1040                   aeroDragParts -> storeCommands (*command_line);
1041                   break;
1042                 }
1043               case CX_a2_flag:
1044                 {
1045                   if (check_float(linetoken3))
1046                     token3 >> token_value;
1047                   else
1048                     uiuc_warnings_errors(1, *command_line);
1049
1050                   CX_a2 = token_value;
1051                   CX_a2_clean = CX_a2;
1052                   aeroDragParts -> storeCommands (*command_line);
1053                   break;
1054                 }
1055               case CX_a3_flag:
1056                 {
1057                   if (check_float(linetoken3))
1058                     token3 >> token_value;
1059                   else
1060                     uiuc_warnings_errors(1, *command_line);
1061
1062                   CX_a3 = token_value;
1063                   CX_a3_clean = CX_a3;
1064                   aeroDragParts -> storeCommands (*command_line);
1065                   break;
1066                 }
1067               case CX_adot_flag:
1068                 {
1069                   if (check_float(linetoken3))
1070                     token3 >> token_value;
1071                   else
1072                     uiuc_warnings_errors(1, *command_line);
1073
1074                   CX_adot = token_value;
1075                   CX_adot_clean = CX_adot;
1076                   aeroDragParts -> storeCommands (*command_line);
1077                   break;
1078                 }
1079               case CX_q_flag:
1080                 {
1081                   if (check_float(linetoken3))
1082                     token3 >> token_value;
1083                   else
1084                     uiuc_warnings_errors(1, *command_line);
1085
1086                   CX_q = token_value;
1087                   CX_q_clean = CX_q;
1088                   aeroDragParts -> storeCommands (*command_line);
1089                   break;
1090                 }
1091               case CX_de_flag:
1092                 {
1093                   if (check_float(linetoken3))
1094                     token3 >> token_value;
1095                   else
1096                     uiuc_warnings_errors(1, *command_line);
1097
1098                   CX_de = token_value;
1099                   CX_de_clean = CX_de;
1100                   aeroDragParts -> storeCommands (*command_line);
1101                   break;
1102                 }
1103               case CX_dr_flag:
1104                 {
1105                   if (check_float(linetoken3))
1106                     token3 >> token_value;
1107                   else
1108                     uiuc_warnings_errors(1, *command_line);
1109
1110                   CX_dr = token_value;
1111                   CX_dr_clean = CX_dr;
1112                   aeroDragParts -> storeCommands (*command_line);
1113                   break;
1114                 }
1115               case CX_df_flag:
1116                 {
1117                   if (check_float(linetoken3))
1118                     token3 >> token_value;
1119                   else
1120                     uiuc_warnings_errors(1, *command_line);
1121
1122                   CX_df = token_value;
1123                   CX_df_clean = CX_df;
1124                   aeroDragParts -> storeCommands (*command_line);
1125                   break;
1126                 }
1127               case CX_adf_flag:
1128                 {
1129                   if (check_float(linetoken3))
1130                     token3 >> token_value;
1131                   else
1132                     uiuc_warnings_errors(1, *command_line);
1133
1134                   CX_adf = token_value;
1135                   CX_adf_clean = CX_adf;
1136                   aeroDragParts -> storeCommands (*command_line);
1137                   break;
1138                 }
1139               default:
1140                 {
1141                   uiuc_warnings_errors(2, *command_line);
1142                   break;
1143                 }
1144               };
1145             break;
1146           } // end CD map
1147
1148
1149         case CL_flag:
1150           {
1151             switch(CL_map[linetoken2])
1152               {
1153               case CLo_flag:
1154                 {
1155                   if (check_float(linetoken3))
1156                     token3 >> token_value;
1157                   else
1158                     uiuc_warnings_errors(1, *command_line);
1159
1160                   CLo = token_value;
1161                   CLo_clean = CLo;
1162                   aeroLiftParts -> storeCommands (*command_line);
1163                   break;
1164                 }
1165               case CL_a_flag:
1166                 {
1167                   if (check_float(linetoken3))
1168                     token3 >> token_value;
1169                   else
1170                     uiuc_warnings_errors(1, *command_line);
1171
1172                   CL_a = token_value;
1173                   CL_a_clean = CL_a;
1174                   aeroLiftParts -> storeCommands (*command_line);
1175                   break;
1176                 }
1177               case CL_adot_flag:
1178                 {
1179                   if (check_float(linetoken3))
1180                     token3 >> token_value;
1181                   else
1182                     uiuc_warnings_errors(1, *command_line);
1183
1184                   CL_adot = token_value;
1185                   CL_adot_clean = CL_adot;
1186                   aeroLiftParts -> storeCommands (*command_line);
1187                   break;
1188                 }
1189               case CL_q_flag:
1190                 {
1191                   if (check_float(linetoken3))
1192                     token3 >> token_value;
1193                   else
1194                     uiuc_warnings_errors(1, *command_line);
1195
1196                   CL_q = token_value;
1197                   CL_q_clean = CL_q;
1198                   aeroLiftParts -> storeCommands (*command_line);
1199                   break;
1200                 }
1201               case CL_ih_flag:
1202                 {
1203                   if (check_float(linetoken3))
1204                     token3 >> token_value;
1205                   else
1206                     uiuc_warnings_errors(1, *command_line);
1207
1208                   CL_ih = token_value;
1209                   aeroLiftParts -> storeCommands (*command_line);
1210                   break;
1211                 }
1212               case CL_de_flag:
1213                 {
1214                   if (check_float(linetoken3))
1215                     token3 >> token_value;
1216                   else
1217                     uiuc_warnings_errors(1, *command_line);
1218
1219                   CL_de = token_value;
1220                   CL_de_clean = CL_de;
1221                   aeroLiftParts -> storeCommands (*command_line);
1222                   break;
1223                 }
1224               case CLfa_flag:
1225                 {
1226                   CLfa = linetoken3;
1227                   token4 >> token_value_convert1;
1228                   token5 >> token_value_convert2;
1229                   convert_y = uiuc_convert(token_value_convert1);
1230                   convert_x = uiuc_convert(token_value_convert2);
1231                   /* call 1D File Reader with file name (CLfa) and conversion
1232                      factors; function returns array of alphas (aArray) and
1233                      corresponding CL values (CLArray) and max number of
1234                      terms in arrays (nAlpha) */
1235                   uiuc_1DdataFileReader(CLfa,
1236                                         CLfa_aArray,
1237                                         CLfa_CLArray,
1238                                         CLfa_nAlpha);
1239                   aeroLiftParts -> storeCommands (*command_line);
1240                   break;
1241                 }
1242               case CLfade_flag:
1243                 {
1244                   CLfade = linetoken3;
1245                   token4 >> token_value_convert1;
1246                   token5 >> token_value_convert2;
1247                   token6 >> token_value_convert3;
1248                   convert_z = uiuc_convert(token_value_convert1);
1249                   convert_x = uiuc_convert(token_value_convert2);
1250                   convert_y = uiuc_convert(token_value_convert3);
1251                   /* call 2D File Reader with file name (CLfade) and
1252                      conversion factors; function returns array of
1253                      elevator deflections (deArray) and corresponding
1254                      alpha (aArray) and delta CL (CLArray) values and
1255                      max number of terms in alpha arrays (nAlphaArray)
1256                      and deflection array (nde) */
1257                   uiuc_2DdataFileReader(CLfade,
1258                                         CLfade_aArray,
1259                                         CLfade_deArray,
1260                                         CLfade_CLArray,
1261                                         CLfade_nAlphaArray,
1262                                         CLfade_nde);
1263                   aeroLiftParts -> storeCommands (*command_line);
1264                   break;
1265                 }
1266               case CLfdf_flag:
1267                 {
1268                   CLfdf = linetoken3;
1269                   token4 >> token_value_convert1;
1270                   token5 >> token_value_convert2;
1271                   convert_y = uiuc_convert(token_value_convert1);
1272                   convert_x = uiuc_convert(token_value_convert2);
1273                   /* call 1D File Reader with file name (CLfdf) and conversion
1274                      factors; function returns array of dfs (dfArray) and
1275                      corresponding CL values (CLArray) and max number of
1276                      terms in arrays (ndf) */
1277                   uiuc_1DdataFileReader(CLfdf,
1278                                         CLfdf_dfArray,
1279                                         CLfdf_CLArray,
1280                                         CLfdf_ndf);
1281                   aeroLiftParts -> storeCommands (*command_line);
1282
1283                   // additional variables to streamline flap routine in aerodeflections
1284                   ndf = CLfdf_ndf;
1285                   int temp_counter = 1;
1286                   while (temp_counter <= ndf)
1287                     {
1288                       dfArray[temp_counter] = CLfdf_dfArray[temp_counter];
1289                       TimeArray[temp_counter] = dfTimefdf_TimeArray[temp_counter];
1290                       temp_counter++;
1291                     }
1292                   break;
1293                 }
1294               case CLfadf_flag:
1295                 {
1296                   CLfadf = linetoken3;
1297                   token4 >> token_value_convert1;
1298                   token5 >> token_value_convert2;
1299                   token6 >> token_value_convert3;
1300                   convert_z = uiuc_convert(token_value_convert1);
1301                   convert_x = uiuc_convert(token_value_convert2);
1302                   convert_y = uiuc_convert(token_value_convert3);
1303                   /* call 2D File Reader with file name (CLfadf) and
1304                      conversion factors; function returns array of
1305                      flap deflections (dfArray) and corresponding
1306                      alpha (aArray) and delta CL (CLArray) values and
1307                      max number of terms in alpha arrays (nAlphaArray)
1308                      and deflection array (ndf) */
1309                   uiuc_2DdataFileReader(CLfadf,
1310                                         CLfadf_aArray,
1311                                         CLfadf_dfArray,
1312                                         CLfadf_CLArray,
1313                                         CLfadf_nAlphaArray,
1314                                         CLfadf_ndf);
1315                   aeroLiftParts -> storeCommands (*command_line);
1316                   break;
1317                 }
1318               case CZo_flag:
1319                 {
1320                   if (check_float(linetoken3))
1321                     token3 >> token_value;
1322                   else
1323                     uiuc_warnings_errors(1, *command_line);
1324
1325                   CZo = token_value;
1326                   CZo_clean = CZo;
1327                   aeroLiftParts -> storeCommands (*command_line);
1328                   break;
1329                 }
1330               case CZ_a_flag:
1331                 {
1332                   if (check_float(linetoken3))
1333                     token3 >> token_value;
1334                   else
1335                     uiuc_warnings_errors(1, *command_line);
1336
1337                   CZ_a = token_value;
1338                   CZ_a_clean = CZ_a;
1339                   aeroLiftParts -> storeCommands (*command_line);
1340                   break;
1341                 }
1342               case CZ_a2_flag:
1343                 {
1344                   if (check_float(linetoken3))
1345                     token3 >> token_value;
1346                   else
1347                     uiuc_warnings_errors(1, *command_line);
1348
1349                   CZ_a2 = token_value;
1350                   CZ_a2_clean = CZ_a2;
1351                   aeroLiftParts -> storeCommands (*command_line);
1352                   break;
1353                 }
1354               case CZ_a3_flag:
1355                 {
1356                   if (check_float(linetoken3))
1357                     token3 >> token_value;
1358                   else
1359                     uiuc_warnings_errors(1, *command_line);
1360
1361                   CZ_a3 = token_value;
1362                   CZ_a3_clean = CZ_a3;
1363                   aeroLiftParts -> storeCommands (*command_line);
1364                   break;
1365                 }
1366               case CZ_adot_flag:
1367                 {
1368                   if (check_float(linetoken3))
1369                     token3 >> token_value;
1370                   else
1371                     uiuc_warnings_errors(1, *command_line);
1372
1373                   CZ_adot = token_value;
1374                   CZ_adot_clean = CZ_adot;
1375                   aeroLiftParts -> storeCommands (*command_line);
1376                   break;
1377                 }
1378               case CZ_q_flag:
1379                 {
1380                   if (check_float(linetoken3))
1381                     token3 >> token_value;
1382                   else
1383                     uiuc_warnings_errors(1, *command_line);
1384
1385                   CZ_q = token_value;
1386                   CZ_q_clean = CZ_q;
1387                   aeroLiftParts -> storeCommands (*command_line);
1388                   break;
1389                 }
1390               case CZ_de_flag:
1391                 {
1392                   if (check_float(linetoken3))
1393                     token3 >> token_value;
1394                   else
1395                     uiuc_warnings_errors(1, *command_line);
1396
1397                   CZ_de = token_value;
1398                   CZ_de_clean = CZ_de;
1399                   aeroLiftParts -> storeCommands (*command_line);
1400                   break;
1401                 }
1402               case CZ_deb2_flag:
1403                 {
1404                   if (check_float(linetoken3))
1405                     token3 >> token_value;
1406                   else
1407                     uiuc_warnings_errors(1, *command_line);
1408
1409                   CZ_deb2 = token_value;
1410                   CZ_deb2_clean = CZ_deb2;
1411                   aeroLiftParts -> storeCommands (*command_line);
1412                   break;
1413                 }
1414               case CZ_df_flag:
1415                 {
1416                   if (check_float(linetoken3))
1417                     token3 >> token_value;
1418                   else
1419                     uiuc_warnings_errors(1, *command_line);
1420
1421                   CZ_df = token_value;
1422                   CZ_df_clean = CZ_df;
1423                   aeroLiftParts -> storeCommands (*command_line);
1424                   break;
1425                 }
1426               case CZ_adf_flag:
1427                 {
1428                   if (check_float(linetoken3))
1429                     token3 >> token_value;
1430                   else
1431                     uiuc_warnings_errors(1, *command_line);
1432
1433                   CZ_adf = token_value;
1434                   CZ_adf_clean = CZ_adf;
1435                   aeroLiftParts -> storeCommands (*command_line);
1436                   break;
1437                 }
1438               default:
1439                 {
1440                   uiuc_warnings_errors(2, *command_line);
1441                   break;
1442                 }
1443               };
1444             break;
1445           } // end CL map
1446
1447
1448         case Cm_flag:
1449           {
1450             switch(Cm_map[linetoken2])
1451               {
1452               case Cmo_flag:
1453                 {
1454                   if (check_float(linetoken3))
1455                     token3 >> token_value;
1456                   else
1457                     uiuc_warnings_errors(1, *command_line);
1458
1459                   Cmo = token_value;
1460                   Cmo_clean = Cmo;
1461                   aeroPitchParts -> storeCommands (*command_line);
1462                   break;
1463                 }
1464               case Cm_a_flag:
1465                 {
1466                   if (check_float(linetoken3))
1467                     token3 >> token_value;
1468                   else
1469                     uiuc_warnings_errors(1, *command_line);
1470
1471                   Cm_a = token_value;
1472                   Cm_a_clean = Cm_a;
1473                   aeroPitchParts -> storeCommands (*command_line);
1474                   break;
1475                 }
1476               case Cm_a2_flag:
1477                 {
1478                   if (check_float(linetoken3))
1479                     token3 >> token_value;
1480                   else
1481                     uiuc_warnings_errors(1, *command_line);
1482
1483                   Cm_a2 = token_value;
1484                   Cm_a2_clean = Cm_a2;
1485                   aeroPitchParts -> storeCommands (*command_line);
1486                   break;
1487                 }
1488               case Cm_adot_flag:
1489                 {
1490                   if (check_float(linetoken3))
1491                     token3 >> token_value;
1492                   else
1493                     uiuc_warnings_errors(1, *command_line);
1494
1495                   Cm_adot = token_value;
1496                   Cm_adot_clean = Cm_adot;
1497                   aeroPitchParts -> storeCommands (*command_line);
1498                   break;
1499                 }
1500               case Cm_q_flag:
1501                 {
1502                   if (check_float(linetoken3))
1503                     token3 >> token_value;
1504                   else
1505                     uiuc_warnings_errors(1, *command_line);
1506
1507                   Cm_q = token_value;
1508                   Cm_q_clean = Cm_q;
1509                   aeroPitchParts -> storeCommands (*command_line);
1510                   break;
1511                 }
1512               case Cm_ih_flag:
1513                 {
1514                   if (check_float(linetoken3))
1515                     token3 >> token_value;
1516                   else
1517                     uiuc_warnings_errors(1, *command_line);
1518
1519                   Cm_ih = token_value;
1520                   aeroPitchParts -> storeCommands (*command_line);
1521                   break;
1522                 }
1523               case Cm_de_flag:
1524                 {
1525                   if (check_float(linetoken3))
1526                     token3 >> token_value;
1527                   else
1528                     uiuc_warnings_errors(1, *command_line);
1529
1530                   Cm_de = token_value;
1531                   Cm_de_clean = Cm_de;
1532                   aeroPitchParts -> storeCommands (*command_line);
1533                   break;
1534                 }
1535               case Cm_b2_flag:
1536                 {
1537                   if (check_float(linetoken3))
1538                     token3 >> token_value;
1539                   else
1540                     uiuc_warnings_errors(1, *command_line);
1541
1542                   Cm_b2 = token_value;
1543                   Cm_b2_clean = Cm_b2;
1544                   aeroPitchParts -> storeCommands (*command_line);
1545                   break;
1546                 }
1547               case Cm_r_flag:
1548                 {
1549                   if (check_float(linetoken3))
1550                     token3 >> token_value;
1551                   else
1552                     uiuc_warnings_errors(1, *command_line);
1553
1554                   Cm_r = token_value;
1555                   Cm_r_clean = Cm_r;
1556                   aeroPitchParts -> storeCommands (*command_line);
1557                   break;
1558                 }
1559               case Cm_df_flag:
1560                 {
1561                   if (check_float(linetoken3))
1562                     token3 >> token_value;
1563                   else
1564                     uiuc_warnings_errors(1, *command_line);
1565
1566                   Cm_df = token_value;
1567                   Cm_df_clean = Cm_df;
1568                   aeroPitchParts -> storeCommands (*command_line);
1569                   break;
1570                 }
1571               case Cmfa_flag:
1572                 {
1573                   Cmfa = linetoken3;
1574                   token4 >> token_value_convert1;
1575                   token5 >> token_value_convert2;
1576                   convert_y = uiuc_convert(token_value_convert1);
1577                   convert_x = uiuc_convert(token_value_convert2);
1578                   /* call 1D File Reader with file name (Cmfa) and conversion
1579                      factors; function returns array of alphas (aArray) and
1580                      corresponding Cm values (CmArray) and max number of
1581                      terms in arrays (nAlpha) */
1582                   uiuc_1DdataFileReader(Cmfa,
1583                                         Cmfa_aArray,
1584                                         Cmfa_CmArray,
1585                                         Cmfa_nAlpha);
1586                   aeroPitchParts -> storeCommands (*command_line);
1587                   break;
1588                 }
1589               case Cmfade_flag:
1590                 {
1591                   Cmfade = linetoken3;
1592                   token4 >> token_value_convert1;
1593                   token5 >> token_value_convert2;
1594                   token6 >> token_value_convert3;
1595                   convert_z = uiuc_convert(token_value_convert1);
1596                   convert_x = uiuc_convert(token_value_convert2);
1597                   convert_y = uiuc_convert(token_value_convert3);
1598                   /* call 2D File Reader with file name (Cmfade) and
1599                      conversion factors; function returns array of
1600                      elevator deflections (deArray) and corresponding
1601                      alpha (aArray) and delta Cm (CmArray) values and
1602                      max number of terms in alpha arrays (nAlphaArray)
1603                      and deflection array (nde) */
1604                   uiuc_2DdataFileReader(Cmfade,
1605                                         Cmfade_aArray,
1606                                         Cmfade_deArray,
1607                                         Cmfade_CmArray,
1608                                         Cmfade_nAlphaArray,
1609                                         Cmfade_nde);
1610                   aeroPitchParts -> storeCommands (*command_line);
1611                   break;
1612                 }
1613               case Cmfdf_flag:
1614                 {
1615                   Cmfdf = linetoken3;
1616                   token4 >> token_value_convert1;
1617                   token5 >> token_value_convert2;
1618                   convert_y = uiuc_convert(token_value_convert1);
1619                   convert_x = uiuc_convert(token_value_convert2);
1620                   /* call 1D File Reader with file name (Cmfdf) and conversion
1621                      factors; function returns array of dfs (dfArray) and
1622                      corresponding Cm values (CmArray) and max number of
1623                      terms in arrays (ndf) */
1624                   uiuc_1DdataFileReader(Cmfdf,
1625                                         Cmfdf_dfArray,
1626                                         Cmfdf_CmArray,
1627                                         Cmfdf_ndf);
1628                   aeroPitchParts -> storeCommands (*command_line);
1629                   break;
1630                 }
1631               case Cmfadf_flag:
1632                 {
1633                   Cmfadf = linetoken3;
1634                   token4 >> token_value_convert1;
1635                   token5 >> token_value_convert2;
1636                   token6 >> token_value_convert3;
1637                   convert_z = uiuc_convert(token_value_convert1);
1638                   convert_x = uiuc_convert(token_value_convert2);
1639                   convert_y = uiuc_convert(token_value_convert3);
1640                   /* call 2D File Reader with file name (Cmfadf) and
1641                      conversion factors; function returns array of
1642                      flap deflections (dfArray) and corresponding
1643                      alpha (aArray) and delta Cm (CmArray) values and
1644                      max number of terms in alpha arrays (nAlphaArray)
1645                      and deflection array (ndf) */
1646                   uiuc_2DdataFileReader(Cmfadf,
1647                                         Cmfadf_aArray,
1648                                         Cmfadf_dfArray,
1649                                         Cmfadf_CmArray,
1650                                         Cmfadf_nAlphaArray,
1651                                         Cmfadf_ndf);
1652                   aeroPitchParts -> storeCommands (*command_line);
1653                   break;
1654                 }
1655               default:
1656                 {
1657                   uiuc_warnings_errors(2, *command_line);
1658                   break;
1659                 }
1660               };
1661             break;
1662           } // end Cm map
1663
1664
1665         case CY_flag:
1666           {
1667             switch(CY_map[linetoken2])
1668               {
1669               case CYo_flag:
1670                 {
1671                   if (check_float(linetoken3))
1672                     token3 >> token_value;
1673                   else
1674                     uiuc_warnings_errors(1, *command_line);
1675
1676                   CYo = token_value;
1677                   CYo_clean = CYo;
1678                   aeroSideforceParts -> storeCommands (*command_line);
1679                   break;
1680                 }
1681               case CY_beta_flag:
1682                 {
1683                   if (check_float(linetoken3))
1684                     token3 >> token_value;
1685                   else
1686                     uiuc_warnings_errors(1, *command_line);
1687
1688                   CY_beta = token_value;
1689                   CY_beta_clean = CY_beta;
1690                   aeroSideforceParts -> storeCommands (*command_line);
1691                   break;
1692                 }
1693               case CY_p_flag:
1694                 {
1695                   if (check_float(linetoken3))
1696                     token3 >> token_value;
1697                   else
1698                     uiuc_warnings_errors(1, *command_line);
1699
1700                   CY_p = token_value;
1701                   CY_p_clean = CY_p;
1702                   aeroSideforceParts -> storeCommands (*command_line);
1703                   break;
1704                 }
1705               case CY_r_flag:
1706                 {
1707                   if (check_float(linetoken3))
1708                     token3 >> token_value;
1709                   else
1710                     uiuc_warnings_errors(1, *command_line);
1711
1712                   CY_r = token_value;
1713                   CY_r_clean = CY_r;
1714                   aeroSideforceParts -> storeCommands (*command_line);
1715                   break;
1716                 }
1717               case CY_da_flag:
1718                 {
1719                   if (check_float(linetoken3))
1720                     token3 >> token_value;
1721                   else
1722                     uiuc_warnings_errors(1, *command_line);
1723
1724                   CY_da = token_value;
1725                   CY_da_clean = CY_da;
1726                   aeroSideforceParts -> storeCommands (*command_line);
1727                   break;
1728                 }
1729               case CY_dr_flag:
1730                 {
1731                   if (check_float(linetoken3))
1732                     token3 >> token_value;
1733                   else
1734                     uiuc_warnings_errors(2, *command_line);
1735
1736                   CY_dr = token_value;
1737                   CY_dr_clean = CY_dr;
1738                   aeroSideforceParts -> storeCommands (*command_line);
1739                   break;
1740                 }
1741               case CY_dra_flag:
1742                 {
1743                   if (check_float(linetoken3))
1744                     token3 >> token_value;
1745                   else
1746                     uiuc_warnings_errors(2, *command_line);
1747
1748                   CY_dra = token_value;
1749                   CY_dra_clean = CY_dra;
1750                   aeroSideforceParts -> storeCommands (*command_line);
1751                   break;
1752                 }
1753               case CY_bdot_flag:
1754                 {
1755                   if (check_float(linetoken3))
1756                     token3 >> token_value;
1757                   else
1758                     uiuc_warnings_errors(2, *command_line);
1759
1760                   CY_bdot = token_value;
1761                   CY_bdot_clean = CY_bdot;
1762                   aeroSideforceParts -> storeCommands (*command_line);
1763                   break;
1764                 }
1765               case CYfada_flag:
1766                 {
1767                   CYfada = linetoken3;
1768                   token4 >> token_value_convert1;
1769                   token5 >> token_value_convert2;
1770                   token6 >> token_value_convert3;
1771                   convert_z = uiuc_convert(token_value_convert1);
1772                   convert_x = uiuc_convert(token_value_convert2);
1773                   convert_y = uiuc_convert(token_value_convert3);
1774                   /* call 2D File Reader with file name (CYfada) and
1775                      conversion factors; function returns array of
1776                      aileron deflections (daArray) and corresponding
1777                      alpha (aArray) and delta CY (CYArray) values and
1778                      max number of terms in alpha arrays (nAlphaArray)
1779                      and deflection array (nda) */
1780                   uiuc_2DdataFileReader(CYfada,
1781                                         CYfada_aArray,
1782                                         CYfada_daArray,
1783                                         CYfada_CYArray,
1784                                         CYfada_nAlphaArray,
1785                                         CYfada_nda);
1786                   aeroSideforceParts -> storeCommands (*command_line);
1787                   break;
1788                 }
1789               case CYfbetadr_flag:
1790                 {
1791                   CYfbetadr = linetoken3;
1792                   token4 >> token_value_convert1;
1793                   token5 >> token_value_convert2;
1794                   token6 >> token_value_convert3;
1795                   convert_z = uiuc_convert(token_value_convert1);
1796                   convert_x = uiuc_convert(token_value_convert2);
1797                   convert_y = uiuc_convert(token_value_convert3);
1798                   /* call 2D File Reader with file name (CYfbetadr) and
1799                      conversion factors; function returns array of
1800                      rudder deflections (drArray) and corresponding
1801                      beta (betaArray) and delta CY (CYArray) values and
1802                      max number of terms in beta arrays (nBetaArray)
1803                      and deflection array (ndr) */
1804                   uiuc_2DdataFileReader(CYfbetadr,
1805                                         CYfbetadr_betaArray,
1806                                         CYfbetadr_drArray,
1807                                         CYfbetadr_CYArray,
1808                                         CYfbetadr_nBetaArray,
1809                                         CYfbetadr_ndr);
1810                   aeroSideforceParts -> storeCommands (*command_line);
1811                   break;
1812                 }
1813               default:
1814                 {
1815                   uiuc_warnings_errors(2, *command_line);
1816                   break;
1817                 }
1818               };
1819             break;
1820           } // end CY map
1821
1822
1823         case Cl_flag:
1824           {
1825             switch(Cl_map[linetoken2])
1826               {
1827               case Clo_flag:
1828                 {
1829                   if (check_float(linetoken3))
1830                     token3 >> token_value;
1831                   else
1832                     uiuc_warnings_errors(1, *command_line);
1833
1834                   Clo = token_value;
1835                   Clo_clean = Clo;
1836                   aeroRollParts -> storeCommands (*command_line);
1837                   break;
1838                 }
1839               case Cl_beta_flag:
1840                 {
1841                   if (check_float(linetoken3))
1842                     token3 >> token_value;
1843                   else
1844                     uiuc_warnings_errors(1, *command_line);
1845
1846                   Cl_beta = token_value;
1847                   Cl_beta_clean = Cl_beta;
1848                   aeroRollParts -> storeCommands (*command_line);
1849                   break;
1850                 }
1851               case Cl_p_flag:
1852                 {
1853                   if (check_float(linetoken3))
1854                     token3 >> token_value;
1855                   else
1856                     uiuc_warnings_errors(1, *command_line);
1857
1858                   Cl_p = token_value;
1859                   Cl_p_clean = Cl_p;
1860                   aeroRollParts -> storeCommands (*command_line);
1861                   break;
1862                 }
1863               case Cl_r_flag:
1864                 {
1865                   if (check_float(linetoken3))
1866                     token3 >> token_value;
1867                   else
1868                     uiuc_warnings_errors(1, *command_line);
1869
1870                   Cl_r = token_value;
1871                   Cl_r_clean = Cl_r;
1872                   aeroRollParts -> storeCommands (*command_line);
1873                   break;
1874                 }
1875               case Cl_da_flag:
1876                 {
1877                   if (check_float(linetoken3))
1878                     token3 >> token_value;
1879                   else
1880                     uiuc_warnings_errors(1, *command_line);
1881
1882                   Cl_da = token_value;
1883                   Cl_da_clean = Cl_da;
1884                   aeroRollParts -> storeCommands (*command_line);
1885                   break;
1886                 }
1887               case Cl_dr_flag:
1888                 {
1889                   if (check_float(linetoken3))
1890                     token3 >> token_value;
1891                   else
1892                     uiuc_warnings_errors(1, *command_line);
1893
1894                   Cl_dr = token_value;
1895                   Cl_dr_clean = Cl_dr;
1896                   aeroRollParts -> storeCommands (*command_line);
1897                   break;
1898                 }
1899               case Cl_daa_flag:
1900                 {
1901                   if (check_float(linetoken3))
1902                     token3 >> token_value;
1903                   else
1904                     uiuc_warnings_errors(1, *command_line);
1905
1906                   Cl_daa = token_value;
1907                   Cl_daa_clean = Cl_daa;
1908                   aeroRollParts -> storeCommands (*command_line);
1909                   break;
1910                 }
1911               case Clfada_flag:
1912                 {
1913                   Clfada = linetoken3;
1914                   token4 >> token_value_convert1;
1915                   token5 >> token_value_convert2;
1916                   token6 >> token_value_convert3;
1917                   convert_z = uiuc_convert(token_value_convert1);
1918                   convert_x = uiuc_convert(token_value_convert2);
1919                   convert_y = uiuc_convert(token_value_convert3);
1920                   /* call 2D File Reader with file name (Clfada) and
1921                      conversion factors; function returns array of
1922                      aileron deflections (daArray) and corresponding
1923                      alpha (aArray) and delta Cl (ClArray) values and
1924                      max number of terms in alpha arrays (nAlphaArray)
1925                      and deflection array (nda) */
1926                   uiuc_2DdataFileReader(Clfada,
1927                                         Clfada_aArray,
1928                                         Clfada_daArray,
1929                                         Clfada_ClArray,
1930                                         Clfada_nAlphaArray,
1931                                         Clfada_nda);
1932                   aeroRollParts -> storeCommands (*command_line);
1933                   break;
1934                 }
1935               case Clfbetadr_flag:
1936                 {
1937                   Clfbetadr = linetoken3;
1938                   token4 >> token_value_convert1;
1939                   token5 >> token_value_convert2;
1940                   token6 >> token_value_convert3;
1941                   convert_z = uiuc_convert(token_value_convert1);
1942                   convert_x = uiuc_convert(token_value_convert2);
1943                   convert_y = uiuc_convert(token_value_convert3);
1944                   /* call 2D File Reader with file name (Clfbetadr) and
1945                      conversion factors; function returns array of
1946                      rudder deflections (drArray) and corresponding
1947                      beta (betaArray) and delta Cl (ClArray) values and
1948                      max number of terms in beta arrays (nBetaArray)
1949                      and deflection array (ndr) */
1950                   uiuc_2DdataFileReader(Clfbetadr,
1951                                         Clfbetadr_betaArray,
1952                                         Clfbetadr_drArray,
1953                                         Clfbetadr_ClArray,
1954                                         Clfbetadr_nBetaArray,
1955                                         Clfbetadr_ndr);
1956                   aeroRollParts -> storeCommands (*command_line);
1957                   break;
1958                 }
1959               default:
1960                 {
1961                   uiuc_warnings_errors(2, *command_line);
1962           break;
1963                 }
1964               };
1965             break;
1966           } // end Cl map
1967
1968
1969         case Cn_flag:
1970           {
1971             switch(Cn_map[linetoken2])
1972               {
1973               case Cno_flag:
1974                 {
1975                   if (check_float(linetoken3))
1976                     token3 >> token_value;
1977                   else
1978                     uiuc_warnings_errors(1, *command_line);
1979
1980                   Cno = token_value;
1981                   Cno_clean = Cno;
1982                   aeroYawParts -> storeCommands (*command_line);
1983                   break;
1984                 }
1985               case Cn_beta_flag:
1986                 {
1987                   if (check_float(linetoken3))
1988                     token3 >> token_value;
1989                   else
1990                     uiuc_warnings_errors(1, *command_line);
1991
1992                   Cn_beta = token_value;
1993                   Cn_beta_clean = Cn_beta;
1994                   aeroYawParts -> storeCommands (*command_line);
1995                   break;
1996                 }
1997               case Cn_p_flag:
1998                 {
1999                   if (check_float(linetoken3))
2000                     token3 >> token_value;
2001                   else
2002                     uiuc_warnings_errors(1, *command_line);
2003
2004                   Cn_p = token_value;
2005                   Cn_p_clean = Cn_p;
2006                   aeroYawParts -> storeCommands (*command_line);
2007                   break;
2008                 }
2009               case Cn_r_flag:
2010                 {
2011                   if (check_float(linetoken3))
2012                     token3 >> token_value;
2013                   else
2014                     uiuc_warnings_errors(1, *command_line);
2015
2016                   Cn_r = token_value;
2017                   Cn_r_clean = Cn_r;
2018                   aeroYawParts -> storeCommands (*command_line);
2019                   break;
2020                 }
2021               case Cn_da_flag:
2022                 {
2023                   if (check_float(linetoken3))
2024                     token3 >> token_value;
2025                   else
2026                     uiuc_warnings_errors(1, *command_line);
2027
2028                   Cn_da = token_value;
2029                   Cn_da_clean = Cn_da;
2030                   aeroYawParts -> storeCommands (*command_line);
2031                   break;
2032                 }
2033               case Cn_dr_flag:
2034                 {
2035                   if (check_float(linetoken3))
2036                     token3 >> token_value;
2037                   else
2038                     uiuc_warnings_errors(1, *command_line);
2039
2040                   Cn_dr = token_value;
2041                   Cn_dr_clean = Cn_dr;
2042                   aeroYawParts -> storeCommands (*command_line);
2043                   break;
2044                 }
2045               case Cn_q_flag:
2046                 {
2047                   if (check_float(linetoken3))
2048                     token3 >> token_value;
2049                   else
2050                     uiuc_warnings_errors(1, *command_line);
2051
2052                   Cn_q = token_value;
2053                   Cn_q_clean = Cn_q;
2054                   aeroYawParts -> storeCommands (*command_line);
2055                   break;
2056                 }
2057               case Cn_b3_flag:
2058                 {
2059                   if (check_float(linetoken3))
2060                     token3 >> token_value;
2061                   else
2062                     uiuc_warnings_errors(1, *command_line);
2063
2064                   Cn_b3 = token_value;
2065                   Cn_b3_clean = Cn_b3;
2066                   aeroYawParts -> storeCommands (*command_line);
2067                   break;
2068                 }
2069               case Cnfada_flag:
2070                 {
2071                   Cnfada = linetoken3;
2072                   token4 >> token_value_convert1;
2073                   token5 >> token_value_convert2;
2074                   token6 >> token_value_convert3;
2075                   convert_z = uiuc_convert(token_value_convert1);
2076                   convert_x = uiuc_convert(token_value_convert2);
2077                   convert_y = uiuc_convert(token_value_convert3);
2078                   /* call 2D File Reader with file name (Cnfada) and
2079                      conversion factors; function returns array of
2080                      aileron deflections (daArray) and corresponding
2081                      alpha (aArray) and delta Cn (CnArray) values and
2082                      max number of terms in alpha arrays (nAlphaArray)
2083                      and deflection array (nda) */
2084                   uiuc_2DdataFileReader(Cnfada,
2085                                         Cnfada_aArray,
2086                                         Cnfada_daArray,
2087                                         Cnfada_CnArray,
2088                                         Cnfada_nAlphaArray,
2089                                         Cnfada_nda);
2090                   aeroYawParts -> storeCommands (*command_line);
2091                   break;
2092                 }
2093               case Cnfbetadr_flag:
2094                 {
2095                   Cnfbetadr = linetoken3;
2096                   token4 >> token_value_convert1;
2097                   token5 >> token_value_convert2;
2098                   token6 >> token_value_convert3;
2099                   convert_z = uiuc_convert(token_value_convert1);
2100                   convert_x = uiuc_convert(token_value_convert2);
2101                   convert_y = uiuc_convert(token_value_convert3);
2102                   /* call 2D File Reader with file name (Cnfbetadr) and
2103                      conversion factors; function returns array of
2104                      rudder deflections (drArray) and corresponding
2105                      beta (betaArray) and delta Cn (CnArray) values and
2106                      max number of terms in beta arrays (nBetaArray)
2107                      and deflection array (ndr) */
2108                   uiuc_2DdataFileReader(Cnfbetadr,
2109                                         Cnfbetadr_betaArray,
2110                                         Cnfbetadr_drArray,
2111                                         Cnfbetadr_CnArray,
2112                                         Cnfbetadr_nBetaArray,
2113                                         Cnfbetadr_ndr);
2114                   aeroYawParts -> storeCommands (*command_line);
2115                   break;
2116                 }
2117               default:
2118                 {
2119                   uiuc_warnings_errors(2, *command_line);
2120                   break;
2121                 }
2122               };
2123             break;
2124           } // end Cn map
2125
2126
2127      /*
2128
2129         case gear_flag:
2130           {
2131             switch(gear_map[linetoken2])
2132               {
2133               case kgear:
2134                 {
2135                   // none yet
2136                   break;
2137                 }
2138               default:
2139                 {
2140                   uiuc_warnings_errors(2, *command_line);
2141           break;
2142                 }
2143               };
2144           } // end gear map
2145
2146 */
2147
2148
2149         case ice_flag:
2150           {
2151             switch(ice_map[linetoken2])
2152               {
2153               case iceTime_flag:
2154                 {
2155                   if (check_float(linetoken3))
2156                     token3 >> token_value;
2157
2158                   else
2159                     uiuc_warnings_errors(1, *command_line);
2160
2161                   ice_model = true;
2162                   iceTime = token_value;
2163                   break;
2164                 }
2165               case transientTime_flag:
2166                 {
2167                   if (check_float(linetoken3))
2168                     token3 >> token_value;
2169                   else
2170                     uiuc_warnings_errors(1, *command_line);
2171
2172                   transientTime = token_value;
2173                   break;
2174                 }
2175               case eta_ice_final_flag:
2176                 {
2177                   if (check_float(linetoken3))
2178                     token3 >> token_value;
2179                   else
2180                     uiuc_warnings_errors(1, *command_line);
2181
2182                   eta_ice_final = token_value;
2183                   break;
2184                 }
2185               case beta_probe_wing_flag:
2186                 {
2187                   if (check_float(linetoken3))
2188                     token3 >> token_value;
2189                   else
2190                     uiuc_warnings_errors(1, *command_line);
2191
2192                   beta_model = true;
2193                   x_probe_wing = token_value;
2194                   break;
2195                 }
2196               case beta_probe_tail_flag:
2197                 {
2198                   if (check_float(linetoken3))
2199                     token3 >> token_value;
2200                   else
2201                     uiuc_warnings_errors(1, *command_line);
2202
2203                   beta_model = true;
2204                   x_probe_tail = token_value;
2205                   break;
2206                 }
2207               case kCDo_flag:
2208                 {
2209                   if (check_float(linetoken3))
2210                     token3 >> token_value;
2211                   else
2212                     uiuc_warnings_errors(1, *command_line);
2213
2214                   kCDo = token_value;
2215                   break;
2216                 }
2217               case kCDK_flag:
2218                 {
2219                   if (check_float(linetoken3))
2220                     token3 >> token_value;
2221                   else
2222                     uiuc_warnings_errors(1, *command_line);
2223
2224                   kCDK = token_value;
2225                   break;
2226                 }
2227               case kCD_a_flag:
2228                 {
2229                   if (check_float(linetoken3))
2230                     token3 >> token_value;
2231                   else
2232                     uiuc_warnings_errors(1, *command_line);
2233
2234                   kCD_a = token_value;
2235                   break;
2236                 }
2237               case kCD_adot_flag:
2238                 {
2239                   if (check_float(linetoken3))
2240                     token3 >> token_value;
2241                   else
2242                     uiuc_warnings_errors(1, *command_line);
2243
2244                   kCD_adot = token_value;
2245                   break;
2246                 }
2247               case kCD_q_flag:
2248                 {
2249                   if (check_float(linetoken3))
2250                     token3 >> token_value;
2251                   else
2252                     uiuc_warnings_errors(1, *command_line);
2253
2254                   kCD_q = token_value;
2255                   break;
2256                 }
2257               case kCD_de_flag:
2258                 {
2259                   if (check_float(linetoken3))
2260                     token3 >> token_value;
2261                   else
2262                     uiuc_warnings_errors(1, *command_line);
2263
2264                   kCD_de = token_value;
2265                   break;
2266                 }
2267               case kCXo_flag:
2268                 {
2269                   if (check_float(linetoken3))
2270                     token3 >> token_value;
2271                   else
2272                     uiuc_warnings_errors(1, *command_line);
2273
2274                   kCXo = token_value;
2275                   break;
2276                 }
2277               case kCXK_flag:
2278                 {
2279                   if (check_float(linetoken3))
2280                     token3 >> token_value;
2281                   else
2282                     uiuc_warnings_errors(1, *command_line);
2283
2284                   kCXK = token_value;
2285                   break;
2286                 }
2287               case kCX_a_flag:
2288                 {
2289                   if (check_float(linetoken3))
2290                     token3 >> token_value;
2291                   else
2292                     uiuc_warnings_errors(1, *command_line);
2293
2294                   kCX_a = token_value;
2295                   break;
2296                 }
2297               case kCX_a2_flag:
2298                 {
2299                   if (check_float(linetoken3))
2300                     token3 >> token_value;
2301                   else
2302                     uiuc_warnings_errors(1, *command_line);
2303
2304                   kCX_a2 = token_value;
2305                   break;
2306                 }
2307               case kCX_a3_flag:
2308                 {
2309                   if (check_float(linetoken3))
2310                     token3 >> token_value;
2311                   else
2312                     uiuc_warnings_errors(1, *command_line);
2313
2314                   kCX_a3 = token_value;
2315                   break;
2316                 }
2317               case kCX_adot_flag:
2318                 {
2319                   if (check_float(linetoken3))
2320                     token3 >> token_value;
2321                   else
2322                     uiuc_warnings_errors(1, *command_line);
2323
2324                   kCX_adot = token_value;
2325                   break;
2326                 }
2327               case kCX_q_flag:
2328                 {
2329                   if (check_float(linetoken3))
2330                     token3 >> token_value;
2331                   else
2332                     uiuc_warnings_errors(1, *command_line);
2333
2334                   kCX_q = token_value;
2335                   break;
2336                 }
2337               case kCX_de_flag:
2338                 {
2339                   if (check_float(linetoken3))
2340                     token3 >> token_value;
2341                   else
2342                     uiuc_warnings_errors(1, *command_line);
2343
2344                   kCX_de = token_value;
2345                   break;
2346                 }
2347               case kCX_dr_flag:
2348                 {
2349                   if (check_float(linetoken3))
2350                     token3 >> token_value;
2351                   else
2352                     uiuc_warnings_errors(1, *command_line);
2353
2354                   kCX_dr = token_value;
2355                   break;
2356                 }
2357               case kCX_df_flag:
2358                 {
2359                   if (check_float(linetoken3))
2360                     token3 >> token_value;
2361                   else
2362                     uiuc_warnings_errors(1, *command_line);
2363
2364                   kCX_df = token_value;
2365                   break;
2366                 }
2367               case kCX_adf_flag:
2368                 {
2369                   if (check_float(linetoken3))
2370                     token3 >> token_value;
2371                   else
2372                     uiuc_warnings_errors(1, *command_line);
2373
2374                   kCX_adf = token_value;
2375                   break;
2376                 }
2377               case kCLo_flag:
2378                 {
2379                   if (check_float(linetoken3))
2380                     token3 >> token_value;
2381                   else
2382                     uiuc_warnings_errors(1, *command_line);
2383
2384                   kCLo = token_value;
2385                   break;
2386                 }
2387               case kCL_a_flag:
2388                 {
2389                   if (check_float(linetoken3))
2390                     token3 >> token_value;
2391                   else
2392                     uiuc_warnings_errors(1, *command_line);
2393
2394                   kCL_a = token_value;
2395                   break;
2396                 }
2397               case kCL_adot_flag:
2398                 {
2399                   if (check_float(linetoken3))
2400                     token3 >> token_value;
2401                   else
2402                     uiuc_warnings_errors(1, *command_line);
2403
2404                   kCL_adot = token_value;
2405                   break;
2406                 }
2407               case kCL_q_flag:
2408                 {
2409                   if (check_float(linetoken3))
2410                     token3 >> token_value;
2411                   else
2412                     uiuc_warnings_errors(1, *command_line);
2413
2414                   kCL_q = token_value;
2415                   break;
2416                 }
2417               case kCL_de_flag:
2418                 {
2419                   if (check_float(linetoken3))
2420                     token3 >> token_value;
2421                   else
2422                     uiuc_warnings_errors(1, *command_line);
2423
2424                   kCL_de = token_value;
2425                   break;
2426                 }
2427               case kCZo_flag:
2428                 {
2429                   if (check_float(linetoken3))
2430                     token3 >> token_value;
2431                   else
2432                     uiuc_warnings_errors(1, *command_line);
2433
2434                   kCZo = token_value;
2435                   break;
2436                 }
2437               case kCZ_a_flag:
2438                 {
2439                   if (check_float(linetoken3))
2440                     token3 >> token_value;
2441                   else
2442                     uiuc_warnings_errors(1, *command_line);
2443
2444                   kCZ_a = token_value;
2445                   break;
2446                 }
2447               case kCZ_a2_flag:
2448                 {
2449                   if (check_float(linetoken3))
2450                     token3 >> token_value;
2451                   else
2452                     uiuc_warnings_errors(1, *command_line);
2453
2454                   kCZ_a2 = token_value;
2455                   break;
2456                 }
2457               case kCZ_a3_flag:
2458                 {
2459                   if (check_float(linetoken3))
2460                     token3 >> token_value;
2461                   else
2462                     uiuc_warnings_errors(1, *command_line);
2463
2464                   kCZ_a3 = token_value;
2465                   break;
2466                 }
2467               case kCZ_adot_flag:
2468                 {
2469                   if (check_float(linetoken3))
2470                     token3 >> token_value;
2471                   else
2472                     uiuc_warnings_errors(1, *command_line);
2473
2474                   kCZ_adot = token_value;
2475                   break;
2476                 }
2477               case kCZ_q_flag:
2478                 {
2479                   if (check_float(linetoken3))
2480                     token3 >> token_value;
2481                   else
2482                     uiuc_warnings_errors(1, *command_line);
2483
2484                   kCZ_q = token_value;
2485                   break;
2486                 }
2487               case kCZ_de_flag:
2488                 {
2489                   if (check_float(linetoken3))
2490                     token3 >> token_value;
2491                   else
2492                     uiuc_warnings_errors(1, *command_line);
2493
2494                   kCZ_de = token_value;
2495                   break;
2496                 }
2497               case kCZ_deb2_flag:
2498                 {
2499                   if (check_float(linetoken3))
2500                     token3 >> token_value;
2501                   else
2502                     uiuc_warnings_errors(1, *command_line);
2503
2504                   kCZ_deb2 = token_value;
2505                   break;
2506                 }
2507               case kCZ_df_flag:
2508                 {
2509                   if (check_float(linetoken3))
2510                     token3 >> token_value;
2511                   else
2512                     uiuc_warnings_errors(1, *command_line);
2513
2514                   kCZ_df = token_value;
2515                   break;
2516                 }
2517               case kCZ_adf_flag:
2518                 {
2519                   if (check_float(linetoken3))
2520                     token3 >> token_value;
2521                   else
2522                     uiuc_warnings_errors(1, *command_line);
2523
2524                   kCZ_adf = token_value;
2525                   break;
2526                 }
2527               case kCmo_flag:
2528                 {
2529                   if (check_float(linetoken3))
2530                     token3 >> token_value;
2531                   else
2532                     uiuc_warnings_errors(1, *command_line);
2533
2534                   kCmo = token_value;
2535                   break;
2536                 }
2537               case kCm_a_flag:
2538                 {
2539                   if (check_float(linetoken3))
2540                     token3 >> token_value;
2541                   else
2542                     uiuc_warnings_errors(1, *command_line);
2543
2544                   kCm_a = token_value;
2545                   break;
2546                 }
2547               case kCm_a2_flag:
2548                 {
2549                   if (check_float(linetoken3))
2550                     token3 >> token_value;
2551                   else
2552                     uiuc_warnings_errors(1, *command_line);
2553
2554                   kCm_a2 = token_value;
2555                   break;
2556                 }
2557               case kCm_adot_flag:
2558                 {
2559                   if (check_float(linetoken3))
2560                     token3 >> token_value;
2561                   else
2562                     uiuc_warnings_errors(1, *command_line);
2563
2564                   kCm_adot = token_value;
2565                   break;
2566                 }
2567               case kCm_q_flag:
2568                 {
2569                   if (check_float(linetoken3))
2570                     token3 >> token_value;
2571                   else
2572                     uiuc_warnings_errors(1, *command_line);
2573
2574                   kCm_q = token_value;
2575                   break;
2576                 }
2577               case kCm_de_flag:
2578                 {
2579                   if (check_float(linetoken3))
2580                     token3 >> token_value;
2581                   else
2582                     uiuc_warnings_errors(1, *command_line);
2583
2584                   kCm_de = token_value;
2585                   break;
2586                 }
2587               case kCm_b2_flag:
2588                 {
2589                   if (check_float(linetoken3))
2590                     token3 >> token_value;
2591                   else
2592                     uiuc_warnings_errors(1, *command_line);
2593
2594                   kCm_b2 = token_value;
2595                   break;
2596                 }
2597               case kCm_r_flag:
2598                 {
2599                   if (check_float(linetoken3))
2600                     token3 >> token_value;
2601                   else
2602                     uiuc_warnings_errors(1, *command_line);
2603
2604                   kCm_r = token_value;
2605                   break;
2606                 }
2607               case kCm_df_flag:
2608                 {
2609                   if (check_float(linetoken3))
2610                     token3 >> token_value;
2611                   else
2612                     uiuc_warnings_errors(1, *command_line);
2613
2614                   kCm_df = token_value;
2615                   break;
2616                 }
2617               case kCYo_flag:
2618                 {
2619                   if (check_float(linetoken3))
2620                     token3 >> token_value;
2621                   else
2622                     uiuc_warnings_errors(1, *command_line);
2623
2624                   kCYo = token_value;
2625                   break;
2626                 }
2627               case kCY_beta_flag:
2628                 {
2629                   if (check_float(linetoken3))
2630                     token3 >> token_value;
2631                   else
2632                     uiuc_warnings_errors(1, *command_line);
2633
2634                   kCY_beta = token_value;
2635                   break;
2636                 }
2637               case kCY_p_flag:
2638                 {
2639                   if (check_float(linetoken3))
2640                     token3 >> token_value;
2641                   else
2642                     uiuc_warnings_errors(1, *command_line);
2643
2644                   kCY_p = token_value;
2645                   break;
2646                 }
2647               case kCY_r_flag:
2648                 {
2649                   if (check_float(linetoken3))
2650                     token3 >> token_value;
2651                   else
2652                     uiuc_warnings_errors(1, *command_line);
2653
2654                   kCY_r = token_value;
2655                   break;
2656                 }
2657               case kCY_da_flag:
2658                 {
2659                   if (check_float(linetoken3))
2660                     token3 >> token_value;
2661                   else
2662                     uiuc_warnings_errors(1, *command_line);
2663
2664                   kCY_da = token_value;
2665                   break;
2666                 }
2667               case kCY_dr_flag:
2668                 {
2669                   if (check_float(linetoken3))
2670                     token3 >> token_value;
2671                   else
2672                     uiuc_warnings_errors(1, *command_line);
2673
2674                   kCY_dr = token_value;
2675                   break;
2676                 }
2677               case kCY_dra_flag:
2678                 {
2679                   if (check_float(linetoken3))
2680                     token3 >> token_value;
2681                   else
2682                     uiuc_warnings_errors(1, *command_line);
2683
2684                   kCY_dra = token_value;
2685                   break;
2686                 }
2687               case kCY_bdot_flag:
2688                 {
2689                   if (check_float(linetoken3))
2690                     token3 >> token_value;
2691                   else
2692                     uiuc_warnings_errors(1, *command_line);
2693
2694                   kCY_bdot = token_value;
2695                   break;
2696                 }
2697               case kClo_flag:
2698                 {
2699                   if (check_float(linetoken3))
2700                     token3 >> token_value;
2701                   else
2702                     uiuc_warnings_errors(1, *command_line);
2703
2704                   kClo = token_value;
2705                   break;
2706                 }
2707               case kCl_beta_flag:
2708                 {
2709                   if (check_float(linetoken3))
2710                     token3 >> token_value;
2711                   else
2712                     uiuc_warnings_errors(1, *command_line);
2713
2714                   kCl_beta = token_value;
2715                   break;
2716                 }
2717               case kCl_p_flag:
2718                 {
2719                   if (check_float(linetoken3))
2720                     token3 >> token_value;
2721                   else
2722                     uiuc_warnings_errors(1, *command_line);
2723
2724                   kCl_p = token_value;
2725                   break;
2726                 }
2727               case kCl_r_flag:
2728                 {
2729                   if (check_float(linetoken3))
2730                     token3 >> token_value;
2731                   else
2732                     uiuc_warnings_errors(1, *command_line);
2733
2734                   kCl_r = token_value;
2735                   break;
2736                 }
2737               case kCl_da_flag:
2738                 {
2739                   if (check_float(linetoken3))
2740                     token3 >> token_value;
2741                   else
2742                     uiuc_warnings_errors(1, *command_line);
2743
2744                   kCl_da = token_value;
2745                   break;
2746                 }
2747               case kCl_dr_flag:
2748                 {
2749                   if (check_float(linetoken3))
2750                     token3 >> token_value;
2751                   else
2752                     uiuc_warnings_errors(1, *command_line);
2753
2754                   kCl_dr = token_value;
2755                   break;
2756                 }
2757               case kCl_daa_flag:
2758                 {
2759                   if (check_float(linetoken3))
2760                     token3 >> token_value;
2761                   else
2762                     uiuc_warnings_errors(1, *command_line);
2763
2764                   kCl_daa = token_value;
2765                   break;
2766                 }
2767               case kCno_flag:
2768                 {
2769                   if (check_float(linetoken3))
2770                     token3 >> token_value;
2771                   else
2772                     uiuc_warnings_errors(1, *command_line);
2773
2774                   kCno = token_value;
2775                   break;
2776                 }
2777               case kCn_beta_flag:
2778                 {
2779                   if (check_float(linetoken3))
2780                     token3 >> token_value;
2781                   else
2782                     uiuc_warnings_errors(1, *command_line);
2783
2784                   kCn_beta = token_value;
2785                   break;
2786                 }
2787               case kCn_p_flag:
2788                 {
2789                   if (check_float(linetoken3))
2790                     token3 >> token_value;
2791                   else
2792                     uiuc_warnings_errors(1, *command_line);
2793
2794                   kCn_p = token_value;
2795                   break;
2796                 }
2797               case kCn_r_flag:
2798                 {
2799                   if (check_float(linetoken3))
2800                     token3 >> token_value;
2801                   else
2802                     uiuc_warnings_errors(1, *command_line);
2803
2804                   kCn_r = token_value;
2805                   break;
2806                 }
2807               case kCn_da_flag:
2808                 {
2809                   if (check_float(linetoken3))
2810                     token3 >> token_value;
2811                   else
2812                     uiuc_warnings_errors(1, *command_line);
2813
2814                   kCn_da = token_value;
2815                   break;
2816                 }
2817               case kCn_dr_flag:
2818                 {
2819                   if (check_float(linetoken3))
2820                     token3 >> token_value;
2821                   else
2822                     uiuc_warnings_errors(1, *command_line);
2823
2824                   kCn_dr = token_value;
2825                   break;
2826                 }
2827               case kCn_q_flag:
2828                 {
2829                   if (check_float(linetoken3))
2830                     token3 >> token_value;
2831                   else
2832                     uiuc_warnings_errors(1, *command_line);
2833
2834                   kCn_q = token_value;
2835                   break;
2836                 }
2837               case kCn_b3_flag:
2838                 {
2839                   if (check_float(linetoken3))
2840                     token3 >> token_value;
2841                   else
2842                     uiuc_warnings_errors(1, *command_line);
2843
2844                   kCn_b3 = token_value;
2845                   break;
2846                 }
2847               default:
2848                 {
2849                   uiuc_warnings_errors(2, *command_line);
2850                   break;
2851                 }
2852               };
2853             break;
2854           } // end ice map
2855
2856
2857         case record_flag:
2858           {
2859             static int fout_flag=0;
2860             if (fout_flag==0)
2861             {
2862               fout_flag=-1;
2863               fout.open("uiuc_record.dat");
2864             }
2865             switch(record_map[linetoken2])
2866               {
2867                 /************************* Time ************************/
2868               case Simtime_record:
2869                 {
2870                   recordParts -> storeCommands (*command_line);
2871                   break;
2872                 }
2873               case dt_record:
2874                 {
2875                   recordParts -> storeCommands (*command_line);
2876                   break;
2877                 }
2878
2879                 /************************* Mass ************************/
2880               case Weight_record:
2881                 {
2882                   recordParts -> storeCommands (*command_line);
2883                   break;
2884                 }
2885               case Mass_record:
2886                 {
2887                   recordParts -> storeCommands (*command_line);
2888                   break;
2889                 }
2890               case I_xx_record:
2891                 {
2892                   recordParts -> storeCommands (*command_line);
2893                   break;
2894                 }
2895               case I_yy_record:
2896                 {
2897                   recordParts -> storeCommands (*command_line);
2898                   break;
2899                 }
2900               case I_zz_record:
2901                 {
2902                   recordParts -> storeCommands (*command_line);
2903                   break;
2904                 }
2905               case I_xz_record:
2906                 {
2907                   recordParts -> storeCommands (*command_line);
2908                   break;
2909                 }
2910
2911                 /*********************** Geometry **********************/
2912               case Dx_pilot_record:
2913                 {
2914                   recordParts -> storeCommands (*command_line);
2915                   break;
2916                 }
2917               case Dy_pilot_record:
2918                 {
2919                   recordParts -> storeCommands (*command_line);
2920                   break;
2921                 }
2922               case Dz_pilot_record:
2923                 {
2924                   recordParts -> storeCommands (*command_line);
2925                   break;
2926                 }
2927               case Dx_cg_record:
2928                 {
2929                   recordParts -> storeCommands (*command_line);
2930                   break;
2931                 }
2932               case Dy_cg_record:
2933                 {
2934                   recordParts -> storeCommands (*command_line);
2935                   break;
2936                 }
2937               case Dz_cg_record:
2938                 {
2939                   recordParts -> storeCommands (*command_line);
2940                   break;
2941                 }
2942
2943                 /********************** Positions **********************/
2944               case Lat_geocentric_record:
2945                 {
2946                   recordParts -> storeCommands (*command_line);
2947                   break;
2948                 }
2949               case Lon_geocentric_record:
2950                 {
2951                   recordParts -> storeCommands (*command_line);
2952                   break;
2953                 }
2954               case Radius_to_vehicle_record:
2955                 {
2956                   recordParts -> storeCommands (*command_line);
2957                   break;
2958                 }
2959               case Latitude_record:
2960                 {
2961                   recordParts -> storeCommands (*command_line);
2962                   break;
2963                 }
2964               case Longitude_record:
2965                 {
2966                   recordParts -> storeCommands (*command_line);
2967                   break;
2968                 }
2969               case Altitude_record:
2970                 {
2971                   recordParts -> storeCommands (*command_line);
2972                   break;
2973                 }
2974               case Phi_record:
2975                 {
2976                   recordParts -> storeCommands (*command_line);
2977                   break;
2978                 }
2979               case Theta_record:
2980                 {
2981                   recordParts -> storeCommands (*command_line);
2982                   break;
2983                 }
2984               case Psi_record:
2985                 {
2986                   recordParts -> storeCommands (*command_line);
2987                   break;
2988                 }
2989
2990                 /******************** Accelerations ********************/
2991               case V_dot_north_record:
2992                 {
2993                   recordParts -> storeCommands (*command_line);
2994                   break;
2995                 }
2996               case V_dot_east_record:
2997                 {
2998                   recordParts -> storeCommands (*command_line);
2999                   break;
3000                 }
3001               case V_dot_down_record:
3002                 {
3003                   recordParts -> storeCommands (*command_line);
3004                   break;
3005                 }
3006               case U_dot_body_record:
3007                 {
3008                   recordParts -> storeCommands (*command_line);
3009                   break;
3010                 }
3011               case V_dot_body_record:
3012                 {
3013                   recordParts -> storeCommands (*command_line);
3014                   break;
3015                 }
3016               case W_dot_body_record:
3017                 {
3018                   recordParts -> storeCommands (*command_line);
3019                   break;
3020                 }
3021               case A_X_pilot_record:
3022                 {
3023                   recordParts -> storeCommands (*command_line);
3024                   break;
3025                 }
3026               case A_Y_pilot_record:
3027                 {
3028                   recordParts -> storeCommands (*command_line);
3029                   break;
3030                 }
3031               case A_Z_pilot_record:
3032                 {
3033                   recordParts -> storeCommands (*command_line);
3034                   break;
3035                 }
3036               case A_X_cg_record:
3037                 {
3038                   recordParts -> storeCommands (*command_line);
3039                   break;
3040                 }
3041               case A_Y_cg_record:
3042                 {
3043                   recordParts -> storeCommands (*command_line);
3044                   break;
3045                 }
3046               case A_Z_cg_record:
3047                 {
3048                   recordParts -> storeCommands (*command_line);
3049                   break;
3050                 }
3051               case N_X_pilot_record:
3052                 {
3053                   recordParts -> storeCommands (*command_line);
3054                   break;
3055                 }
3056               case N_Y_pilot_record:
3057                 {
3058                   recordParts -> storeCommands (*command_line);
3059                   break;
3060                 }
3061               case N_Z_pilot_record:
3062                 {
3063                   recordParts -> storeCommands (*command_line);
3064                   break;
3065                 }
3066               case N_X_cg_record:
3067                 {
3068                   recordParts -> storeCommands (*command_line);
3069                   break;
3070                 }
3071               case N_Y_cg_record:
3072                 {
3073                   recordParts -> storeCommands (*command_line);
3074                   break;
3075                 }
3076               case N_Z_cg_record:
3077                 {
3078                   recordParts -> storeCommands (*command_line);
3079                   break;
3080                 }
3081               case P_dot_body_record:
3082                 {
3083                   recordParts -> storeCommands (*command_line);
3084                   break;
3085                 }
3086               case Q_dot_body_record:
3087                 {
3088                   recordParts -> storeCommands (*command_line);
3089                   break;
3090                 }
3091               case R_dot_body_record:
3092                 {
3093                   recordParts -> storeCommands (*command_line);
3094                   break;
3095                 }
3096
3097                 /********************** Velocities *********************/
3098               case V_north_record:
3099                 {
3100                   recordParts -> storeCommands (*command_line);
3101                   break;
3102                 }
3103               case V_east_record:
3104                 {
3105                   recordParts -> storeCommands (*command_line);
3106                   break;
3107                 }
3108               case V_down_record:
3109                 {
3110                   recordParts -> storeCommands (*command_line);
3111                   break;
3112                 }
3113               case V_north_rel_ground_record:
3114                 {
3115                   recordParts -> storeCommands (*command_line);
3116                   break;
3117                 }
3118               case V_east_rel_ground_record:
3119                 {
3120                   recordParts -> storeCommands (*command_line);
3121                   break;
3122                 }
3123               case V_down_rel_ground_record:
3124                 {
3125                   recordParts -> storeCommands (*command_line);
3126                   break;
3127                 }
3128               case V_north_airmass_record:
3129                 {
3130                   recordParts -> storeCommands (*command_line);
3131                   break;
3132                 }
3133               case V_east_airmass_record:
3134                 {
3135                   recordParts -> storeCommands (*command_line);
3136                   break;
3137                 }
3138               case V_down_airmass_record:
3139                 {
3140                   recordParts -> storeCommands (*command_line);
3141                   break;
3142                 }
3143               case V_north_rel_airmass_record:
3144                 {
3145                   recordParts -> storeCommands (*command_line);
3146                   break;
3147                 }
3148               case V_east_rel_airmass_record:
3149                 {
3150                   recordParts -> storeCommands (*command_line);
3151                   break;
3152                 }
3153               case V_down_rel_airmass_record:
3154                 {
3155                   recordParts -> storeCommands (*command_line);
3156                   break;
3157                 }
3158               case U_gust_record:
3159                 {
3160                   recordParts -> storeCommands (*command_line);
3161                   break;
3162                 }
3163               case V_gust_record:
3164                 {
3165                   recordParts -> storeCommands (*command_line);
3166                   break;
3167                 }
3168               case W_gust_record:
3169                 {
3170                   recordParts -> storeCommands (*command_line);
3171                   break;
3172                 }
3173               case U_body_record:
3174                 {
3175                   recordParts -> storeCommands (*command_line);
3176                   break;
3177                 }
3178               case V_body_record:
3179                 {
3180                   recordParts -> storeCommands (*command_line);
3181                   break;
3182                 }
3183               case W_body_record:
3184                 {
3185                   recordParts -> storeCommands (*command_line);
3186                   break;
3187                 }
3188               case V_rel_wind_record:
3189                 {
3190                   recordParts -> storeCommands (*command_line);
3191                   break;
3192                 }
3193               case V_true_kts_record:
3194                 {
3195                   recordParts -> storeCommands (*command_line);
3196                   break;
3197                 }
3198               case V_rel_ground_record:
3199                 {
3200                   recordParts -> storeCommands (*command_line);
3201                   break;
3202                 }
3203               case V_inertial_record:
3204                 {
3205                   recordParts -> storeCommands (*command_line);
3206                   break;
3207                 }
3208               case V_ground_speed_record:
3209                 {
3210                   recordParts -> storeCommands (*command_line);
3211                   break;
3212                 }
3213               case V_equiv_record:
3214                 {
3215                   recordParts -> storeCommands (*command_line);
3216                   break;
3217                 }
3218               case V_equiv_kts_record:
3219                 {
3220                   recordParts -> storeCommands (*command_line);
3221                   break;
3222                 }
3223               case V_calibrated_record:
3224                 {
3225                   recordParts -> storeCommands (*command_line);
3226                   break;
3227                 }
3228               case V_calibrated_kts_record:
3229                 {
3230                   recordParts -> storeCommands (*command_line);
3231                   break;
3232                 }
3233               case P_local_record:
3234                 {
3235                   recordParts -> storeCommands (*command_line);
3236                   break;
3237                 }
3238               case Q_local_record:
3239                 {
3240                   recordParts -> storeCommands (*command_line);
3241                   break;
3242                 }
3243               case R_local_record:
3244                 {
3245                   recordParts -> storeCommands (*command_line);
3246                   break;
3247                 }
3248               case P_body_record:
3249                 {
3250                   recordParts -> storeCommands (*command_line);
3251                   break;
3252                 }
3253               case Q_body_record:
3254                 {
3255                   recordParts -> storeCommands (*command_line);
3256                   break;
3257                 }
3258               case R_body_record:
3259                 {
3260                   recordParts -> storeCommands (*command_line);
3261                   break;
3262                 }
3263               case P_total_record:
3264                 {
3265                   recordParts -> storeCommands (*command_line);
3266                   break;
3267                 }
3268               case Q_total_record:
3269                 {
3270                   recordParts -> storeCommands (*command_line);
3271                   break;
3272                 }
3273               case R_total_record:
3274                 {
3275                   recordParts -> storeCommands (*command_line);
3276                   break;
3277                 }
3278               case Phi_dot_record:
3279                 {
3280                   recordParts -> storeCommands (*command_line);
3281                   break;
3282                 }
3283               case Theta_dot_record:
3284                 {
3285                   recordParts -> storeCommands (*command_line);
3286                   break;
3287                 }
3288               case Psi_dot_record:
3289                 {
3290                   recordParts -> storeCommands (*command_line);
3291                   break;
3292                 }
3293               case Latitude_dot_record:
3294                 {
3295                   recordParts -> storeCommands (*command_line);
3296                   break;
3297                 }
3298               case Longitude_dot_record:
3299                 {
3300                   recordParts -> storeCommands (*command_line);
3301                   break;
3302                 }
3303               case Radius_dot_record:
3304                 {
3305                   recordParts -> storeCommands (*command_line);
3306                   break;
3307                 }
3308
3309                 /************************ Angles ***********************/
3310               case Alpha_record:
3311                 {
3312                   recordParts -> storeCommands (*command_line);
3313                   break;
3314                 }
3315               case Alpha_deg_record:
3316                 {
3317                   recordParts -> storeCommands (*command_line);
3318                   break;
3319                 }
3320               case Alpha_dot_record:
3321                 {
3322                   recordParts -> storeCommands (*command_line);
3323                   break;
3324                 }
3325               case Alpha_dot_deg_record:
3326                 {
3327                   recordParts -> storeCommands (*command_line);
3328                   break;
3329                 }
3330               case Beta_record:
3331                 {
3332                   recordParts -> storeCommands (*command_line);
3333                   break;
3334                 }
3335               case Beta_deg_record:
3336                 {
3337                   recordParts -> storeCommands (*command_line);
3338                   break;
3339                 }
3340               case Beta_dot_record:
3341                 {
3342                   recordParts -> storeCommands (*command_line);
3343                   break;
3344                 }
3345               case Beta_dot_deg_record:
3346                 {
3347                   recordParts -> storeCommands (*command_line);
3348                   break;
3349                 }
3350               case Gamma_vert_record:
3351                 {
3352                   recordParts -> storeCommands (*command_line);
3353                   break;
3354                 }
3355               case Gamma_vert_deg_record:
3356                 {
3357                   recordParts -> storeCommands (*command_line);
3358                   break;
3359                 }
3360               case Gamma_horiz_record:
3361                 {
3362                   recordParts -> storeCommands (*command_line);
3363                   break;
3364                 }
3365               case Gamma_horiz_deg_record:
3366                 {
3367                   recordParts -> storeCommands (*command_line);
3368                   break;
3369                 }
3370
3371                 /**************** Atmospheric Properties ***************/
3372               case Density_record:
3373                 {
3374                   recordParts -> storeCommands (*command_line);
3375                   break;
3376                 }
3377               case V_sound_record:
3378                 {
3379                   recordParts -> storeCommands (*command_line);
3380                   break;
3381                 }
3382               case Mach_number_record:
3383                 {
3384                   recordParts -> storeCommands (*command_line);
3385                   break;
3386                 }
3387               case Static_pressure_record:
3388                 {
3389                   recordParts -> storeCommands (*command_line);
3390                   break;
3391                 }
3392               case Total_pressure_record:
3393                 {
3394                   recordParts -> storeCommands (*command_line);
3395                   break;
3396                 }
3397               case Impact_pressure_record:
3398                 {
3399                   recordParts -> storeCommands (*command_line);
3400                   break;
3401                 }
3402               case Dynamic_pressure_record:
3403                 {
3404                   recordParts -> storeCommands (*command_line);
3405                   break;
3406                 }
3407               case Static_temperature_record:
3408                 {
3409                   recordParts -> storeCommands (*command_line);
3410                   break;
3411                 }
3412               case Total_temperature_record:
3413                 {
3414                   recordParts -> storeCommands (*command_line);
3415                   break;
3416                 }
3417
3418                 /******************** Earth Properties *****************/
3419               case Gravity_record:
3420                 {
3421                   recordParts -> storeCommands (*command_line);
3422                   break;
3423                 }
3424               case Sea_level_radius_record:
3425                 {
3426                   recordParts -> storeCommands (*command_line);
3427                   break;
3428                 }
3429               case Earth_position_angle_record:
3430                 {
3431                   recordParts -> storeCommands (*command_line);
3432                   break;
3433                 }
3434               case Runway_altitude_record:
3435                 {
3436                   recordParts -> storeCommands (*command_line);
3437                   break;
3438                 }
3439               case Runway_latitude_record:
3440                 {
3441                   recordParts -> storeCommands (*command_line);
3442                   break;
3443                 }
3444               case Runway_longitude_record:
3445                 {
3446                   recordParts -> storeCommands (*command_line);
3447                   break;
3448                 }
3449               case Runway_heading_record:
3450                 {
3451                   recordParts -> storeCommands (*command_line);
3452                   break;
3453                 }
3454               case Radius_to_rwy_record:
3455                 {
3456                   recordParts -> storeCommands (*command_line);
3457                   break;
3458                 }
3459               case D_pilot_north_of_rwy_record:
3460                 {
3461                   recordParts -> storeCommands (*command_line);
3462                   break;
3463                 }
3464               case D_pilot_east_of_rwy_record:
3465                 {
3466                   recordParts -> storeCommands (*command_line);
3467                   break;
3468                 }
3469               case D_pilot_above_rwy_record:
3470                 {
3471                   recordParts -> storeCommands (*command_line);
3472                   break;
3473                 }
3474               case X_pilot_rwy_record:
3475                 {
3476                   recordParts -> storeCommands (*command_line);
3477                   break;
3478                 }
3479               case Y_pilot_rwy_record:
3480                 {
3481                   recordParts -> storeCommands (*command_line);
3482                   break;
3483                 }
3484               case H_pilot_rwy_record:
3485                 {
3486                   recordParts -> storeCommands (*command_line);
3487                   break;
3488                 }
3489               case D_cg_north_of_rwy_record:
3490                 {
3491                   recordParts -> storeCommands (*command_line);
3492                   break;
3493                 }
3494               case D_cg_east_of_rwy_record:
3495                 {
3496                   recordParts -> storeCommands (*command_line);
3497                   break;
3498                 }
3499               case D_cg_above_rwy_record:
3500                 {
3501                   recordParts -> storeCommands (*command_line);
3502                   break;
3503                 }
3504               case X_cg_rwy_record:
3505                 {
3506                   recordParts -> storeCommands (*command_line);
3507                   break;
3508                 }
3509               case Y_cg_rwy_record:
3510                 {
3511                   recordParts -> storeCommands (*command_line);
3512                   break;
3513                 }
3514               case H_cg_rwy_record:
3515                 {
3516                   recordParts -> storeCommands (*command_line);
3517                   break;
3518                 }
3519
3520                 /********************* Engine Inputs *******************/
3521               case Throttle_pct_record:
3522                 {
3523                   recordParts -> storeCommands (*command_line);
3524                   break;
3525                 }
3526               case Throttle_3_record:
3527                 {
3528                   recordParts -> storeCommands (*command_line);
3529                   break;
3530                 }
3531
3532                 /******************** Control Inputs *******************/
3533               case Long_control_record:
3534                 {
3535                   recordParts -> storeCommands (*command_line);
3536                   break;
3537                 }
3538               case Long_trim_record:
3539                 {
3540                   recordParts -> storeCommands (*command_line);
3541                   break;
3542                 }
3543               case Long_trim_deg_record:
3544                 {
3545                   recordParts -> storeCommands (*command_line);
3546                   break;
3547                 }
3548               case elevator_record:
3549                 {
3550                   recordParts -> storeCommands (*command_line);
3551                   break;
3552                 }
3553               case elevator_deg_record:
3554                 {
3555                   recordParts -> storeCommands (*command_line);
3556                   break;
3557                 }
3558               case Lat_control_record:
3559                 {
3560                   recordParts -> storeCommands (*command_line);
3561                   break;
3562                 }
3563               case aileron_record:
3564                 {
3565                   recordParts -> storeCommands (*command_line);
3566                   break;
3567                 }
3568               case aileron_deg_record:
3569                 {
3570                   recordParts -> storeCommands (*command_line);
3571                   break;
3572                 }
3573               case Rudder_pedal_record:
3574                 {
3575                   recordParts -> storeCommands (*command_line);
3576                   break;
3577                 }
3578               case rudder_record:
3579                 {
3580                   recordParts -> storeCommands (*command_line);
3581                   break;
3582                 }
3583               case rudder_deg_record:
3584                 {
3585                   recordParts -> storeCommands (*command_line);
3586                   break;
3587                 }
3588               case Flap_handle_record:
3589                 {
3590                   recordParts -> storeCommands (*command_line);
3591                   break;
3592                 }
3593               case flap_record:
3594                 {
3595                   recordParts -> storeCommands (*command_line);
3596                   break;
3597                 }
3598               case flap_deg_record:
3599                 {
3600                   recordParts -> storeCommands (*command_line);
3601                   break;
3602                 }
3603
3604                 /****************** Aero Coefficients ******************/
3605               case CD_record:
3606                 {
3607                   recordParts -> storeCommands (*command_line);
3608                   break;
3609                 }
3610               case CDfaI_record:
3611                 {
3612                   recordParts -> storeCommands (*command_line);
3613                   break;
3614                 }
3615               case CDfadeI_record:
3616                 {
3617                   recordParts -> storeCommands (*command_line);
3618                   break;
3619                 }
3620               case CDfdfI_record:
3621                 {
3622                   recordParts -> storeCommands (*command_line);
3623                   break;
3624                 }
3625               case CDfadfI_record:
3626                 {
3627                   recordParts -> storeCommands (*command_line);
3628                   break;
3629                 }
3630               case CX_record:
3631                 {
3632                   recordParts -> storeCommands (*command_line);
3633                   break;
3634                 }
3635               case CL_record:
3636                 {
3637                   recordParts -> storeCommands (*command_line);
3638                   break;
3639                 }
3640               case CLfaI_record:
3641                 {
3642                   recordParts -> storeCommands (*command_line);
3643                   break;
3644                 }
3645               case CLfadeI_record:
3646                 {
3647                   recordParts -> storeCommands (*command_line);
3648                   break;
3649                 }
3650               case CLfdfI_record:
3651                 {
3652                   recordParts -> storeCommands (*command_line);
3653                   break;
3654                 }
3655               case CLfadfI_record:
3656                 {
3657                   recordParts -> storeCommands (*command_line);
3658                   break;
3659                 }
3660               case CZ_record:
3661                 {
3662                   recordParts -> storeCommands (*command_line);
3663                   break;
3664                 }
3665               case Cm_record:
3666                 {
3667                   recordParts -> storeCommands (*command_line);
3668                   break;
3669                 }
3670               case CmfaI_record:
3671                 {
3672                   recordParts -> storeCommands (*command_line);
3673                   break;
3674                 }
3675               case CmfadeI_record:
3676                 {
3677                   recordParts -> storeCommands (*command_line);
3678                   break;
3679                 }
3680               case CmfdfI_record:
3681                 {
3682                   recordParts -> storeCommands (*command_line);
3683                   break;
3684                 }
3685               case CmfadfI_record:
3686                 {
3687                   recordParts -> storeCommands (*command_line);
3688                   break;
3689                 }
3690               case CY_record:
3691                 {
3692                   recordParts -> storeCommands (*command_line);
3693                   break;
3694                 }
3695               case CYfadaI_record:
3696                 {
3697                   recordParts -> storeCommands (*command_line);
3698                   break;
3699                 }
3700               case CYfbetadrI_record:
3701                 {
3702                   recordParts -> storeCommands (*command_line);
3703                   break;
3704                 }
3705               case Cl_record:
3706                 {
3707                   recordParts -> storeCommands (*command_line);
3708                   break;
3709                 }
3710               case ClfadaI_record:
3711                 {
3712                   recordParts -> storeCommands (*command_line);
3713                   break;
3714                 }
3715               case ClfbetadrI_record:
3716                 {
3717                   recordParts -> storeCommands (*command_line);
3718                   break;
3719                 }
3720               case Cn_record:
3721                 {
3722                   recordParts -> storeCommands (*command_line);
3723                   break;
3724                 }
3725               case CnfadaI_record:
3726                 {
3727                   recordParts -> storeCommands (*command_line);
3728                   break;
3729                 }
3730               case CnfbetadrI_record:
3731                 {
3732                   recordParts -> storeCommands (*command_line);
3733                   break;
3734                 }
3735
3736                 /******************** Ice Detection ********************/
3737               case CLclean_wing_record:
3738                 {
3739                   recordParts -> storeCommands (*command_line);
3740                   break;
3741                 }
3742               case CLiced_wing_record:
3743                 {
3744                   recordParts -> storeCommands (*command_line);
3745                   break;
3746                 }
3747               case CLclean_tail_record:
3748                 {
3749                   recordParts -> storeCommands (*command_line);
3750                   break;
3751                 }
3752               case CLiced_tail_record:
3753                 {
3754                   recordParts -> storeCommands (*command_line);
3755                   break;
3756                 }
3757               case Lift_clean_wing_record:
3758                 {
3759                   recordParts -> storeCommands (*command_line);
3760                   break;
3761                 }
3762               case Lift_iced_wing_record:
3763                 {
3764                   recordParts -> storeCommands (*command_line);
3765                   break;
3766                 }
3767               case Lift_clean_tail_record:
3768                 {
3769                   recordParts -> storeCommands (*command_line);
3770                   break;
3771                 }
3772               case Lift_iced_tail_record:
3773                 {
3774                   recordParts -> storeCommands (*command_line);
3775                   break;
3776                 }
3777               case Gamma_clean_wing_record:
3778                 {
3779                   recordParts -> storeCommands (*command_line);
3780                   break;
3781                 }
3782               case Gamma_iced_wing_record:
3783                 {
3784                   recordParts -> storeCommands (*command_line);
3785                   break;
3786                 }
3787               case Gamma_clean_tail_record:
3788                 {
3789                   recordParts -> storeCommands (*command_line);
3790                   break;
3791                 }
3792               case Gamma_iced_tail_record:
3793                 {
3794                   recordParts -> storeCommands (*command_line);
3795                   break;
3796                 }
3797               case w_clean_wing_record:
3798                 {
3799                   recordParts -> storeCommands (*command_line);
3800                   break;
3801                 }
3802               case w_iced_wing_record:
3803                 {
3804                   recordParts -> storeCommands (*command_line);
3805                   break;
3806                 }
3807               case w_clean_tail_record:
3808                 {
3809                   recordParts -> storeCommands (*command_line);
3810                   break;
3811                 }
3812               case w_iced_tail_record:
3813                 {
3814                   recordParts -> storeCommands (*command_line);
3815                   break;
3816                 }
3817               case V_total_clean_wing_record:
3818                 {
3819                   recordParts -> storeCommands (*command_line);
3820                   break;
3821                 }
3822               case V_total_iced_wing_record:
3823                 {
3824                   recordParts -> storeCommands (*command_line);
3825                   break;
3826                 }
3827               case V_total_clean_tail_record:
3828                 {
3829                   recordParts -> storeCommands (*command_line);
3830                   break;
3831                 }
3832               case V_total_iced_tail_record:
3833                 {
3834                   recordParts -> storeCommands (*command_line);
3835                   break;
3836                 }
3837               case beta_flow_clean_wing_record:
3838                 {
3839                   recordParts -> storeCommands (*command_line);
3840                   break;
3841                 }
3842               case beta_flow_clean_wing_deg_record:
3843                 {
3844                   recordParts -> storeCommands (*command_line);
3845                   break;
3846                 }
3847               case beta_flow_iced_wing_record:
3848                 {
3849                   recordParts -> storeCommands (*command_line);
3850                   break;
3851                 }
3852               case beta_flow_iced_wing_deg_record:
3853                 {
3854                   recordParts -> storeCommands (*command_line);
3855                   break;
3856                 }
3857               case beta_flow_clean_tail_record:
3858                 {
3859                   recordParts -> storeCommands (*command_line);
3860                   break;
3861                 }
3862               case beta_flow_clean_tail_deg_record:
3863                 {
3864                   recordParts -> storeCommands (*command_line);
3865                   break;
3866                 }
3867               case beta_flow_iced_tail_record:
3868                 {
3869                   recordParts -> storeCommands (*command_line);
3870                   break;
3871                 }
3872               case beta_flow_iced_tail_deg_record:
3873                 {
3874                   recordParts -> storeCommands (*command_line);
3875                   break;
3876                 }
3877               case Dbeta_flow_wing_record:
3878                 {
3879                   recordParts -> storeCommands (*command_line);
3880                   break;
3881                 }
3882               case Dbeta_flow_wing_deg_record:
3883                 {
3884                   recordParts -> storeCommands (*command_line);
3885                   break;
3886                 }
3887               case Dbeta_flow_tail_record:
3888                 {
3889                   recordParts -> storeCommands (*command_line);
3890                   break;
3891                 }
3892               case Dbeta_flow_tail_deg_record:
3893                 {
3894                   recordParts -> storeCommands (*command_line);
3895                   break;
3896                 }
3897               case pct_beta_flow_wing_record:
3898                 {
3899                   recordParts -> storeCommands (*command_line);
3900                   break;
3901                 }
3902               case pct_beta_flow_tail_record:
3903                 {
3904                   recordParts -> storeCommands (*command_line);
3905                   break;
3906                 }
3907
3908                 /************************ Forces ***********************/
3909               case F_X_wind_record:
3910                 {
3911                   recordParts -> storeCommands (*command_line);
3912                   break;
3913                 }
3914               case F_Y_wind_record:
3915                 {
3916                   recordParts -> storeCommands (*command_line);
3917                   break;
3918                 }
3919               case F_Z_wind_record:
3920                 {
3921                   recordParts -> storeCommands (*command_line);
3922                   break;
3923                 }
3924               case F_X_aero_record:
3925                 {
3926                   recordParts -> storeCommands (*command_line);
3927                   break;
3928                 }
3929               case F_Y_aero_record:
3930                 {
3931                   recordParts -> storeCommands (*command_line);
3932                   break;
3933                 }
3934               case F_Z_aero_record:
3935                 {
3936                   recordParts -> storeCommands (*command_line);
3937                   break;
3938                 }
3939               case F_X_engine_record:
3940                 {
3941                   recordParts -> storeCommands (*command_line);
3942                   break;
3943                 }
3944               case F_Y_engine_record:
3945                 {
3946                   recordParts -> storeCommands (*command_line);
3947                   break;
3948                 }
3949               case F_Z_engine_record:
3950                 {
3951                   recordParts -> storeCommands (*command_line);
3952                   break;
3953                 }
3954               case F_X_gear_record:
3955                 {
3956                   recordParts -> storeCommands (*command_line);
3957                   break;
3958                 }
3959               case F_Y_gear_record:
3960                 {
3961                   recordParts -> storeCommands (*command_line);
3962                   break;
3963                 }
3964               case F_Z_gear_record:
3965                 {
3966                   recordParts -> storeCommands (*command_line);
3967                   break;
3968                 }
3969               case F_X_record:
3970                 {
3971                   recordParts -> storeCommands (*command_line);
3972                   break;
3973                 }
3974               case F_Y_record:
3975                 {
3976                   recordParts -> storeCommands (*command_line);
3977                   break;
3978                 }
3979               case F_Z_record:
3980                 {
3981                   recordParts -> storeCommands (*command_line);
3982                   break;
3983                 }
3984               case F_north_record:
3985                 {
3986                   recordParts -> storeCommands (*command_line);
3987                   break;
3988                 }
3989               case F_east_record:
3990                 {
3991                   recordParts -> storeCommands (*command_line);
3992                   break;
3993                 }
3994               case F_down_record:
3995                 {
3996                   recordParts -> storeCommands (*command_line);
3997                   break;
3998                 }
3999
4000                 /*********************** Moments ***********************/
4001               case M_l_aero_record:
4002                 {
4003                   recordParts -> storeCommands (*command_line);
4004                   break;
4005                 }
4006               case M_m_aero_record:
4007                 {
4008                   recordParts -> storeCommands (*command_line);
4009                   break;
4010                 }
4011               case M_n_aero_record:
4012                 {
4013                   recordParts -> storeCommands (*command_line);
4014                   break;
4015                 }
4016               case M_l_engine_record:
4017                 {
4018                   recordParts -> storeCommands (*command_line);
4019                   break;
4020                 }
4021               case M_m_engine_record:
4022                 {
4023                   recordParts -> storeCommands (*command_line);
4024                   break;
4025                 }
4026               case M_n_engine_record:
4027                 {
4028                   recordParts -> storeCommands (*command_line);
4029                   break;
4030                 }
4031               case M_l_gear_record:
4032                 {
4033                   recordParts -> storeCommands (*command_line);
4034                   break;
4035                 }
4036               case M_m_gear_record:
4037                 {
4038                   recordParts -> storeCommands (*command_line);
4039                   break;
4040                 }
4041               case M_n_gear_record:
4042                 {
4043                   recordParts -> storeCommands (*command_line);
4044                   break;
4045                 }
4046               case M_l_rp_record:
4047                 {
4048                   recordParts -> storeCommands (*command_line);
4049                   break;
4050                 }
4051               case M_m_rp_record:
4052                 {
4053                   recordParts -> storeCommands (*command_line);
4054                   break;
4055                 }
4056               case M_n_rp_record:
4057                 {
4058                   recordParts -> storeCommands (*command_line);
4059                   break;
4060                 }
4061               default:
4062                 {
4063                   uiuc_warnings_errors(2, *command_line);
4064                   break;
4065                 }
4066               };
4067             break;
4068           } // end record map
4069
4070
4071         case misc_flag:
4072           {
4073             switch(misc_map[linetoken2])
4074               {
4075               case simpleHingeMomentCoef_flag:
4076                 {
4077                   if (check_float(linetoken3))
4078                     token3 >> token_value;
4079                   else
4080                     uiuc_warnings_errors(1, *command_line);
4081
4082                   simpleHingeMomentCoef = token_value;
4083                   break;
4084                 }
4085               case dfTimefdf_flag:
4086                 {
4087                   dfTimefdf = linetoken3;
4088                   /* call 1D File Reader with file name (dfTimefdf);
4089                      function returns array of dfs (dfArray) and
4090                      corresponding time values (TimeArray) and max
4091                      number of terms in arrays (ndf) */
4092                   uiuc_1DdataFileReader(dfTimefdf,
4093                                         dfTimefdf_dfArray,
4094                                         dfTimefdf_TimeArray,
4095                                         dfTimefdf_ndf);
4096                   break;
4097                 }
4098               default:
4099                 {
4100                   uiuc_warnings_errors(2, *command_line);
4101                   break;
4102                 }
4103               };
4104             break;
4105           } // end misc map
4106
4107
4108         default:
4109           {
4110             if (linetoken1=="*")
4111                 return;
4112             uiuc_warnings_errors(2, *command_line);
4113             break;
4114           }
4115         };
4116     } // end keyword map
4117
4118   delete airplane;
4119 }
4120
4121 // end menu.cpp