/////////////////////////////////////////////////////////////// 
//  cmdline.cpp - extract arguments and commands from the    //
//  ver 1.0       executive module's command line            //
//                                                           //
//  Language:     Visual C++, ver 6.0                        //
//  Platform:     Micron Dual Pentium Pro 200, Win NT 4.0    //
//  Application:  CSE784 Project #1, Fall 1999               //
//  Author:       Jim Fawcett, CST 2-187, Syracuse Univ.     //
//                (315) 443-3948, fawcett@ecs.syr.edu        //
///////////////////////////////////////////////////////////////

#pragma warning(disable : 4786)
#include <iostream>
#include <set>
#include "cmdline.h"

using namespace std;

//----< remove extension from a file name >--------------------

std::string commandLine::name(string name) {

  int pos = name.find(".");
  if(pos == name.size())
    return name;
  name.resize(pos);
  return name;
}

//----< set usage message >------------------------------------

void commandLine::usage(const string &msg) { usageMsg = msg; }

//----< extract usage message >--------------------------------

string commandLine::usage() { return usageMsg; }

//----< is the current arg name that of a new module? >--------

bool commandLine::isNewModule() {

  if(next == orderedArgs.begin())
    return true;
  if(next == orderedArgs.end())
    return true;
  vector<string>::iterator it = next;
  --it;
  if(name(*it) != name(*next))
    return true;
  return false;  
}

//

//----< make C string lower case >-----------------------------

string commandLine::makeLower(const char *s) {

  string temp;
  int len = strlen(s);
  int i;
  for(i=0; i<len; i++)
    temp += tolower(s[i]);
  return temp;
}

//----< make C++ string lower case >-----------------------------

string commandLine::makeLower(const string &s) {

  string temp;
  int len = s.size();
  int i;
  for(i=0; i<len; i++)
    temp += tolower(s[i]);
  return temp;
}

//

//----< constructor builds collections of cmds and args >------
//
//  arg collection is order into modules and orphan files
//
commandLine::commandLine(int argc, char *argv[]) {

  set<string> args, bachelors;
  int i;
  for(i=1; i<argc; i++) {
    if(argv[i][0] == '-' || argv[i][0] == '/')
      cmds.insert(&argv[i][1]);
//    else if(!isalpha(argv[i][0])) {
//      cout << "\n  --- invalid argument: \"" << argv[i] << "\" ---\n";
//      continue;
//    }
    else
      args.insert(makeLower(argv[i]));
  }
  set<string> pairs, singles;
  bool isPair;
  set<string>::iterator it,nextItem,last;
  for(it=args.begin(); it!=args.end(); it++) {
    nextItem = it; ++nextItem;
    isPair = false;
    if(nextItem != args.end()) {
      if(name(*it) == name(*nextItem))
        isPair = true;
    }
    if(!isPair && pairs.size() > 0) {
      last = --(pairs.end());
      if(name(*it) == name(*last))
        isPair = true;
    }
    if(isPair)
      pairs.insert(*it);
    else
      singles.insert(*it);
  }
  for(it=pairs.begin(); it!=pairs.end(); it++)
    orderedArgs.push_back(*it);
  for(it=singles.begin(); it!=singles.end(); it++)
    orderedArgs.push_back(*it);

  next = orderedArgs.begin();
}

//----< is this string a command collected from cmdline? >-----

bool commandLine::isCommand(const string &s) const {

  set<string>::const_iterator it = cmds.find(s);
  if(it == cmds.end())
    return false;
  return true;
}

//

//----< extract the next command line argument >---------------

string commandLine::nextArg() {

  vector<string>::iterator it = next++;
  if(it == orderedArgs.end()) {
    --next;
    return "";
  }
  return (*it);
}

//----< get ready to extract cmdline args again >--------------

void commandLine::resetArgs() { next = orderedArgs.begin(); }


//----< test stub >--------------------------------------------

#ifdef TEST_CMDLINE

#include <iostream>

void main(int argc, char *argv[]) {

  cout << "\n  testing cmdline module "
       << "\n ========================\n";

  cout << "\n  command line arguments are:"
       << "\n ----------------------------";

  int i;
  for(i=1; i<argc; i++) {
    if(odd(i))
      cout << "\n  ";
    cout << argv[i] << " ";
  }
  cout << "\n";

  commandLine cl(argc,argv);

  cout << "\n  display usage message:"
       << "\n -----------------------";

  cl.usage(
    "\n  this is a usage message displayed when command line"
    "\n  arguments aren't as needed by the program\n"
  );

  cout << cl.usage();

//

  cout << "\n  ordered command line arguments are:"
       << "\n ------------------------------------";

  string arg;
  for(i=0; i<cl.size(); i++) {
    if(even(i))
      cout << "\n  ";
    cout << cl.nextArg() << " ";
  }
  cout << '\n';

  cout << "\n  testing command extraction:"
       << "\n ----------------------------";

  if(cl.isCommand("s"))
    cout << "\n  \"s\" is a command";
  else
    cout << "\n  \"s\" is not a command";

  if(cl.isCommand("test"))
    cout << "\n  \"test\" is a command";
  else
    cout << "\n  \"test\" is not a command";

  cout << "\n\n";
}

#endif