*** empty log message ***

[h316.git] / pc-tools / ldc2 / src / config.cpp

/*
 * Program configuration management
 */

#include <vector>
#include <string>

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "configuration_manager.hh"
#include "tool.hh"

/* Global configuration data */
string cfg_infile;
string cfg_outfile;
int cfg_infile_set=0;
int cfg_outfile_set=0; 
int cfg_config_file_set=0;

int cfg_do_help=0;
int cfg_output_info=0;
int cfg_output_called=0;
int cfg_output_exported=0;
int cfg_output_unsatisfied=0;
int cfg_splitobjects=0;
int cfg_splitobjects_numbered=0;
int cfg_ignore_block_errors=0;
int cfg_ignore_checksum_errors=0;
int cfg_pause_on_checksum_error=0;
int cfg_ignore_unknown_block_errors=0;
int cfg_ignore_object_integrity_errors=0;
int cfg_list_contents=1;
int cfg_verbose=0;
int cfg_version=0;

int in_fd=0;  //! File descriptor for data input 
int out_fd=1; //! File descriptor for text output


void do_config(int argc, char ** args){

  string cfg_config_file;
  configuration_manager ar("ldc2");
  
  /* Here come the configuration switches */
  ar.add_option_switch("h","help",
		       "Output this help text and exit.",
		       &cfg_do_help,false,true);

  ar.add_option_switch("a","output_info",
		       "Print tape data information",
		       &cfg_output_info,true,true);

  ar.add_option_switch("c","output_called",
		       "Print all called symbols from the object(s).",
		       &cfg_output_called,true,true);

  ar.add_option_switch("e","output_exported",
		       "Print all exported symbols from the object(s).",
		       &cfg_output_exported,true,true);

  ar.add_option_switch("u","output_unsatisfied",
		       "List all unsatisfied symbols.",
		       &cfg_output_unsatisfied,true,true);

  ar.add_option_switch("S","split_objects_numbered",
		       "Split input data into distinct numbered files",
		       &cfg_splitobjects_numbered,true,true);

  ar.add_option_switch("s","split_objects",
		       "Split input data into distinct object files.",
		       &cfg_splitobjects,true,true);
  
  ar.add_option_switch("b","ignore_block_errors",
		       "Ignore block integrity errors. This will output broken blocks,too",
		       &cfg_ignore_block_errors,true,true);

  ar.add_option_switch("k","ignore_checksum_errors",
		       "Ignore block checksum errors. Errors will be converted to warnings.",
		       &cfg_ignore_checksum_errors,true,true);

  ar.add_option_switch("p","pause_on_checksum_error",
		       "Wait for user input on checksum error.",
		       &cfg_pause_on_checksum_error,true,true);
  
  ar.add_option_switch("n","ignore_unknown_block_errors",
		       "Ignore errors caused by unknown block types. Errors will be converted to warnings.",
		       &cfg_ignore_unknown_block_errors,true,true);

  ar.add_option_switch("g","ignore_object_integrity_errors",
		       "Ignore errors caused by objects without proper end block. \
Errors will be converted to warnings.",
		       &cfg_ignore_object_integrity_errors,true,true);

  ar.add_option_switch("v","verbose",
		       "Be a bit more verbose.",
		       &cfg_verbose,true,true);

  ar.add_option_switch("V","version",
		       "Output version information and exit.",
		       &cfg_version,false,true);
  
  ar.add_option_value("i","in_file",
		      "specify input file",
		  &cfg_infile_set,&cfg_infile,
		      "<input-file>",true,false);
		      
  ar.add_option_value("o","out_file",
		      "Specify output file.",
		      &cfg_outfile_set,&cfg_outfile,
		      "<output_file>",true,true);
  
  ar.add_argument("File from where data is read",
		  &cfg_infile_set,&cfg_infile,
		  "<input-file>");
  
  ar.add_argument("File to where output is redirected",
		  &cfg_outfile_set,&cfg_outfile,
		  "<output-file>");

  ar.add_option_value("F","cfg_config_file",
		      "Use the specified configuration file.", 
		      &cfg_config_file_set,&cfg_config_file,
		      "<file-name>",false,true);

  
  // If there's a config file mentioned in the environment, take it!
  char * env_ldc_config=getenv("LDC_CONFIG");
  if(env_ldc_config){
    fprintf(stderr,"Using config file: \"%s\"\n",env_ldc_config);
    if(dump_vector_err(ar.read_file(env_ldc_config))){
      dump_vector_err(ar.get_help());
      exit(1);
    }
  }

  // Process command line first time
  if(dump_vector_err(ar.read_args(argc,args))){
    dump_vector_err(ar.get_help());
    exit(7);
  }
  
  if (cfg_do_help) {
    dump_vector_err(ar.get_help());
    exit(0);
  }

  // If user has a config file, use it.
  if (cfg_config_file_set){
    if (cfg_verbose) 
      fprintf(stderr,"Using config file: \"%s\"\n",cfg_config_file.c_str());
    if(dump_vector_err(ar.read_file(cfg_config_file))){
      dump_vector_err(ar.get_help());
      exit(7);
    }

    // Process command line a second time to override values from config file.
    if(dump_vector_err(ar.read_args(argc,args))||cfg_do_help){
      dump_vector_err(ar.get_help());
      exit(7);
    }
  }

  if (cfg_infile_set==1){
    if (cfg_verbose) 
      fprintf(stderr,"Opening file for input: \"%s\"\n",cfg_infile.c_str());
    in_fd=open(cfg_infile.c_str(),O_RDONLY);
    if (in_fd<0){
      fprintf(stderr,"Error: could not open file \"%s\" for reading!\n",
	      cfg_infile.c_str());
      exit (1);
    }
  }
  
  if (cfg_outfile_set==1){
    if (cfg_verbose) 
      fprintf(stderr,"Opening file for output: \"%s\"\n",cfg_outfile.c_str());
    out_fd=open(cfg_outfile.c_str(),O_CREAT|O_WRONLY|O_TRUNC,0666);
    if (out_fd<0){
      fprintf(stderr,"Error: could not open file \"%s\" for writing!\n",
	      cfg_outfile.c_str());
      exit (1);
    }
  }
  
  // The configuration implications according to /cfg007/
  if (in_fd==0) cfg_pause_on_checksum_error=0;
  if (cfg_pause_on_checksum_error==1) cfg_ignore_checksum_errors=1;

  if (cfg_output_info||cfg_output_called||cfg_output_exported||cfg_output_unsatisfied)
    cfg_list_contents=0;
}