// parse.cc

#include "parse.h"


char *mystrdup(char *todup)
{
  if(todup == NULL)
    return NULL;
  char *p = new char[strlen(todup)+1];
  strcpy(p, todup);
  return p;
}

Parse::Parse(char *filename)
{
  // init
  FileName = mystrdup(filename);
  StartPos = 0;
  EndPos   = 0;
  FD       = NULL;
  CL       = NULL;
  Valid    = 0;
  NumOfLines = 0;
  NumOfVar = 0;

  Line = new char[2048];

  VarArg = NULL;
  VarNam = NULL; 
  VarType = NULL;
  Default = NULL;
  Description = NULL;

  Author = NULL;
  Usage = NULL; 
  Version = NULL;


  FD = fopen(FileName, "rb");
  if(FD == NULL) {
    perror(FileName);
    Valid = -1;
    return;
  }

  // finde Stelle an der command line beginnt und endet.
  Valid = FindBeginEnd();
  if(Valid != 0)
    return;
  fprintf(stderr, "Number of lines to parse: %d\n", NumOfLines);

  VarArg = new char* [NumOfLines];
  VarNam = new char* [NumOfLines];
  VarType = new char* [NumOfLines];
  Default = new char* [NumOfLines];
  Description = new char* [NumOfLines];
  int i;
  for(i = 0; i < NumOfLines; i++) {
    VarArg[i] = NULL;
    VarNam[i] = NULL;
    VarType[i] = NULL;
    Default[i] = NULL;
    Description[i] = NULL;
  }    

  Valid = ScanArguments();
  if(Valid == -1) {
    fprintf(stderr, "Error in line: %s\n", Line);
    return;
  }
  fprintf(stderr, "Building include file ");
  Valid = BuiltInclude();
  if(Valid == 0)
    fprintf(stderr, "- ok.\n");
  else
    fprintf(stderr, "- there was an error!\n");
}

Parse::~Parse(void)
{
  if(FD != NULL)
    fclose(FD);

  delete [] Line;

  if(VarArg!=NULL) {
    int i;
    for(i = 0; i < NumOfLines; i++) {
      delete [] VarArg[i];
      delete [] VarNam[i];
      delete [] VarType[i];
      delete [] Default[i];
      delete [] Description[i];
    }    
    delete [] VarArg;
    delete [] VarNam;
    delete [] VarType;
    delete [] Default;
    delete [] Description;
  }
}

char Parse::GetC(void)
{
  char c = getc(FD);
  if(c == '\r') {  // CR & LF will be only LF
    c = getc(FD);
    if(c == '\n')
      return c;
    else {
      ungetc(c, FD);
      return '\r';
    }
  }
  else
    return c;
}

int Parse::ReadWhiteSpace(void)
{
  while(Line[PosInLine] == ' ')
    PosInLine++;
  return 0;
}

int Parse::ReadToEndOfLine(void)
{
  char c;

  c = GetC();
  while((c != EOF) && (c != '\n')) {
    c = GetC();
  }
  if(c == EOF)
    return -1;
  else return 0;
}  

int Parse::FindBeginEnd(void)
{
  char c;
  unsigned long pos;
  int out;

  fseek(FD, 0, SEEK_SET);
  out = 0;
  pos = ftell(FD);
  c = GetC();
  while((c != EOF) && (!out)) {
    if(c == '#') {
      out = Compare("if 0");
      if(out) {
	ReadToEndOfLine();
	out = Compare("$command line$");
	if(out) {
	  ReadToEndOfLine();
	  StartPos = ftell(FD);
	}
      }
    }
    pos = ftell(FD);
    c = GetC();
  }
  if(out == 0)
    return -1;  // the begining was not found
  out = 0;
  NumOfLines = 0;
  while((c != EOF) && (!out)) {
    if(c == '#') {
      out = Compare("endif");
      if(out)
	EndPos = pos;
    }
    else if(c == '\n')
      NumOfLines++;
    pos = ftell(FD);
    c = GetC();
  }
  if(out == 0)
    return -1;
  return 0;
}


int Parse::Compare(char *str)
{
  // the position in the file is after the comparison:
  // 1. if the following characters are equal at the end of the
  //    part to compare.
  // 2. otherwise the same position where the comparison starts.
  
  int i;
  char *cstr, c;
  unsigned long pos;

  pos = ftell(FD);
  c = GetC();
  cstr = new char[strlen(str)+1];
  i = 0;
  
  cstr[i] = c;
  i++;
  while((i < strlen(str)) && c != EOF) {
    cstr[i] = GetC();
    i++;
  }

  if(c == EOF) {
    delete [] cstr;
    fseek(FD, pos, SEEK_SET);
    return 0;
  }
  cstr[i] = '\0';
  if(strcmp(str, cstr) == 0) {
    delete [] cstr;
    return 1;
  }
  else {
    delete [] cstr;
    fseek(FD, pos, SEEK_SET);
    return 0;
  }
}

int Parse::Status(void)
{
  return Valid;
}
  
int Parse::ScanArguments(void)
{
  fprintf(stderr, "Parsing the lines");
  fseek(FD, StartPos, SEEK_SET);
  
  int mes, i;
  
  for(i = 0; i < NumOfLines; i++) {
    fprintf(stderr, ".");
    if(ReadLine() == -1) {
      fprintf(stderr, "\n");
      return -1;
    }
    PosInLine = 0;
    if(Line[PosInLine] != '#') { // could be a commentar line
      mes = ReadText();
      if(mes == -1) {
	fprintf(stderr, "\nError in ReadText().\n");
	return -1;
      }
    }
    else {
      PosInLine++;
      ReadWhiteSpace();
      mes = ReadVarArg(i);
      if(mes == -1) {
	fprintf(stderr, "\nError in ReadVarArg().\n");
	return -1;
      }
      mes = ReadVarNam(i);
      if(mes == -1) {
	fprintf(stderr, "\nError in ReadVarNam().\n");
	return -1;
      }
      mes = ReadVarType(i);
      if(mes == -1) {
	fprintf(stderr, "\nError in ReadVarType().\n");
	return -1;
      }
      else if(strcmp("string", VarType[i]) == 0) {
	mes = ReadDefDesString(i);
	if(mes == -1) {
	  fprintf(stderr, "\nError while reading default and description\n"
		  "for a string variable.\n");
	  return -1;
	}
      }
      else {
	// try what is next default or description
	// description beginns with a " and ends with a "
	if(Line[PosInLine] == '\"') {// there is no default for this variable
	  mes = ReadDescription(i);
	  if(mes == -1) {
	    fprintf(stderr, "\nError in ReadDescription().\n");
	    return -1;
	  }
	}
	else {         // there will be a default value
	  mes = ReadDefault(i);
	  if(mes == -1) {
	    fprintf(stderr, "\nError in ReadDefault().\n");
	    return -1;
	  }
	  else {
	    mes = ReadDescription(i);
	    if(mes == -1) {
	      fprintf(stderr, "\nError in ReadDescription().\n");
	      return -1;
	    }
	  }
	}
      }
    }
  } // for i    
  fprintf(stderr, "\n");
  return 0;
}  
  
int Parse::ReadDefDesString(int x)
{
  if(Line[PosInLine] == '\0')
    return -1;

  char def[1024];
  char des[1024];
  int i = 0;

  if(Line[PosInLine] != '\"')
    return -1;

  def[i] = Line[PosInLine];
  PosInLine++;
  i++;
  while(Line[PosInLine]!='\0') {
    def[i] = Line[PosInLine];
    i++;
    if(Line[PosInLine] == '\"')
      break;
    PosInLine++;
  }
  def[i] = '\0';
  if(Line[PosInLine] != '\"')
    return -1;
  else
    PosInLine++;
  ReadWhiteSpace();

  if(Line[PosInLine] == '\0') {
    def[strlen(def)-1] = '\0';  // remove " at the end
    Description[x] = mystrdup(def+1);  // it's allright: def
    return 0;
  }

  i = 0;
  if(Line[PosInLine] != '\"')
    return -1;

  des[i] = Line[PosInLine];
  PosInLine++;
  while(Line[PosInLine]!='\0') {
    des[i] = Line[PosInLine];
    i++;
    if(Line[PosInLine] == '\"')
      break;
    PosInLine++;
  }
  i--;
  des[i] = '\0';
  if(Line[PosInLine] != '\"')
    return -1;

  Default[x] = mystrdup(def);
  Description[x] = mystrdup(des);
  return 0;
}

int Parse::Info(void)
{
  int i;
  for(i = 0; i < NumOfLines; i++) {
    fprintf(stderr, "ActVar: %s  ActNam: %s  ActType %s\n", VarArg[i], VarNam[i], VarType[i]);
    fprintf(stderr, "  Default: %s  Description: %s\n", Default[i], Description[i]);
  }

  fprintf(stderr, "Author %s  Version %s\n", Author, Version);
  fprintf(stderr, "Usage %s\n", Usage);

}


int Parse::ReadVarArg(int x)
{
  if(Line[PosInLine] == '\0')
    return -1;

  unsigned long len, i;
  len = strlen(Line);
  i = 0;
  char arg[1024];

  while((PosInLine<len)&&(Line[PosInLine]!=' ')&&(Line[PosInLine]!='\0')) {
    arg[i] = Line[PosInLine];
    PosInLine++;
    i++;
  }
  arg[i] = '\0';
  if(PosInLine == len)
    return -1;
  else {
    if(strcmp("-c", arg)==0 || strcmp("-h", arg)==0) {
      fprintf(stderr, "Error: conflict in name space. -c and -h are\n");
      fprintf(stderr, "       reserved keywords.\n");
      return -1;
    }
    ReadWhiteSpace();
    VarArg[x] = mystrdup(arg);
    return 0;
  }
}

int Parse::ReadVarNam(int x)
{
  if(Line[PosInLine] == '\0')
    return -1;

  unsigned long len, i;
  len = strlen(Line);
  i = 0;
  char arg[1024];

  while((PosInLine<len)&&(Line[PosInLine]!=' ')&&(Line[PosInLine]!='\0')) {
    arg[i] = Line[PosInLine];
    PosInLine++;
    i++;
  }
  arg[i] = '\0';
  if(PosInLine == len)
    return -1;
  else {
    ReadWhiteSpace();
    VarNam[x] = mystrdup(arg);
    return 0;
  }
}

int Parse::ReadVarType(int x)
{
  if(Line[PosInLine] == '\0')
    return -1;

  unsigned long len, i;
  len = strlen(Line);
  i = 0;
  char arg[1024];

  while((PosInLine<len)&&(Line[PosInLine]!=' ')&&(Line[PosInLine]!='\0')) {
    arg[i] = Line[PosInLine];
    PosInLine++;
    i++;
  }
  arg[i] = '\0';
  VarType[x] = mystrdup(arg);
  if(DetNumOfArg(x) == -1) {
    fprintf(stderr, "Error: variable of unknown type.\n");
    return -1;
  }
  if(PosInLine == len)
    return -1;
  else {
    ReadWhiteSpace();
    return 0;
  }
}

int Parse::ReadDefault(int x)
{
  // wieviele Argumente hat hat diese Variable?
  // lese bis Description bzw. Zeilenende
  if(Line[PosInLine] == '\0')
    return -1;

  unsigned long len;
  int num, i, p;
  char arg[1024];

  len = strlen(Line);
  num = DetNumOfArg(x);

  i = 0;
  p = 0;
  while((p < num)&&(PosInLine<=len)) {
    arg[i] = Line[PosInLine];
    if(Line[PosInLine]==' ' || Line[PosInLine]=='\0') {
      ReadWhiteSpace();
      p++;
      if(p == num)
	break;
    }
    else
      PosInLine++;
    i++;
  }
  ReadWhiteSpace();

  arg[i] = '\0';

  if(p == num) {
    Default[x] = mystrdup(arg);
    ReadWhiteSpace();
    if(Line[PosInLine] == '\0')
      return -1;
    else
      return 0;
  }
  else
    return -1;
}

int Parse::DetNumOfArg(int x)
{
  if(strcmp("int", VarType[x]) == 0)
    return 1;
  else if(strcmp("float", VarType[x]) == 0)
    return 1;
  else if(strcmp("string", VarType[x]) == 0)
    return 1;
  else if(strcmp("intervallint", VarType[x]) == 0)
    return 2;
  else if(strcmp("intervallfloat", VarType[x]) == 0)
    return 2;
  else if(strcmp("eventlist", VarType[x]) == 0)
    return 1;
  else if(strcmp("bool", VarType[x]) == 0)
    return 0;
  else
    return -1;
}

int Parse::ReadDescription(int x)
{
  if(Line[PosInLine] == '\0')
    return -1;

  unsigned long len = strlen(Line);
  int i = 0;
  char arg[1024];

  if(Line[PosInLine] != '\"')
    return -1;
  PosInLine++;
  while((PosInLine < len)&&(Line[PosInLine]!='\0')) {
    arg[i] = Line[PosInLine];
    i++;
    if(Line[PosInLine] == '\"')
      break;
    PosInLine++;
  }
  i--;
  arg[i] = '\0';
  if(Line[PosInLine] != '\"')
    return -1;
  else {
    Description[x] = mystrdup(arg);
    return 0;
  }
}

int Parse::ReadLine()
{
  int i = 0;
  char c = GetC();

  while((c!='\n') && (c!=EOF)) {
    Line[i] = c;
    c = GetC();
    i++;
  }
  Line[i] = '\0';
  if(c == EOF)
    return -1;
  else 
    return 0;
}

int Parse::ReadText(void)
{
  // author, usage, version or //
  int mes;
  ReadWhiteSpace();
  char *author  = "author";
  char *usage   = "usage";
  char *version = "version";
  char *comm    = "//";
  if(strncmp(Line, author, strlen(author)) == 0) {
    PosInLine += strlen(author);
    ReadWhiteSpace();
    if(Line[PosInLine] == '=') {
      PosInLine++;
      ReadWhiteSpace();
      mes = ReadString(Author);
      return mes;
    }
    else
      return -1;
  }
  else if(strncmp(Line, usage, strlen(usage)) == 0) {
    PosInLine += strlen(usage);
    ReadWhiteSpace();
    if(Line[PosInLine] == '=') {
      PosInLine++;
      ReadWhiteSpace();
      mes = ReadString(Usage);
      return mes;
    }
    else
      return -1;
  }
  else if(strncmp(Line, version, strlen(version)) == 0) {
    PosInLine += strlen(version);
    ReadWhiteSpace();
    if(Line[PosInLine] == '=') {
      PosInLine++;
      ReadWhiteSpace();
      mes = ReadString(Version);
      return mes;
    }
    else
      return -1;
  }
  else if(strncmp(Line, comm, strlen(comm)) == 0) {
    return 0;
  }
  else {
    return -1;
  }
}

int Parse::ReadString(char *&string)
{
  unsigned long len = strlen(Line);
  int i = 0;
  char arg[1024];

  if(Line[PosInLine] != '\"')
    return -1;
  PosInLine++;
  while((PosInLine < len)&&(Line[PosInLine]!='\0')) {
    arg[i] = Line[PosInLine];
    i++;
    if(Line[PosInLine] == '\"')
      break;
    PosInLine++;
  }
  i--;
  arg[i] = '\0';
  if(Line[PosInLine] != '\"')
    return -1;
  else {
    string = mystrdup(arg);
    return 0;
  }
}

int Parse::BuiltInclude(char *name)
{
  char *nameh = new char[strlen(name)+3];
  char *namecc = new char[strlen(name)+4];
  strcpy(nameh, name);
  strcpy(namecc, name);
  strcat(nameh, ".h");
  strcat(namecc, ".cc");

  int err = 0;
  err += BuiltH(nameh, name);
  err += BuiltCC(namecc, nameh);
  if(err != 0)
    return -1;
  else
    return 0;
}

int Parse::BuiltH(char *nameh, char *name)
{
  CL = fopen(nameh, "wb");
  if(CL == NULL)
    return -1;
  char *code;
  code = "// include file for parsing the command line and usage message.\n"
    "// %s\n\n"
    "#ifndef __%s_h\n"
    "#define __%s_h\n"
    "\n"
    "extern \"C\" {\n"
    "#include <stdio.h>\n"
    "#include <stdlib.h>\n"
    "#include <string.h>\n"
    "}\n\n";
  fprintf(CL, code, nameh, name, name);

  code = "struct InterVallInt {\n"
    "  int From;\n"
    "  int To;\n"
    "};\n\n"
    "struct InterVallFloat {\n"
    "  float From;\n"
    "  float To;\n"
    "};\n\n"
    "struct EventMod {\n"
    "  char *FileName;\n"
    "  unsigned long Offset, Length;\n"
    "  int ListNr, Begin, End;\n"
    "  EventMod *Next;\n"
    "};\n\n"
    "// typedef int bool;\n"
    "typedef char* string;\n"
    "typedef InterVallInt intervallint;\n"
    "typedef InterVallFloat intervallfloat;\n"
    "typedef EventMod eventlist;\n\n";
  fprintf(CL, code);
  
  int i;
  for(i = 0; i < NumOfLines; i++) {
    if(VarArg[i] == NULL)
      continue;
    else {
      fprintf(CL, "extern %s \t%s;\n", VarType[i], VarNam[i]);
    }
  }
  fprintf(CL, "extern char \t*Copyright;\n");

  code = "\n\n// writes the usage message to stderr\n"
    "void Usage(char*);\n\n"
    "// parses the command line\n"
    "int ParseCommandLine(int, char**);\n\n"
    "#endif\n\n";
  fprintf(CL, code);
  fclose(CL);
  return 0;
}

int Parse::BuiltCC(char *namecc, char *nameh)
{
  CL = fopen(namecc, "wb");
  if(CL == NULL)
    return -1;

  char *code;
  code = "// file for parsing the command line and usage message.\n"
    "// %s\n\n"
    "#include \"%s\"\n\n";
  fprintf(CL, code, namecc, nameh);

  int i;
  for(i = 0; i < NumOfLines; i++) {
    if(VarArg[i] == NULL)
      continue;
    else {
      fprintf(CL, "%s \t%s;\n", VarType[i], VarNam[i]);
    }
  }
  fprintf(CL, "char \t*Copyright;\n");
  fprintf(CL, "\n");

  code = "char *mystrdup(char *todup)\n"
    "{\n"
    "  if(todup == NULL)\n"
    "    return NULL;\n"
    "  char *p = new char[strlen(todup)+1];\n"
    "  strcpy(p, todup);\n"
    "  return p;\n"
    "}\n";
  fprintf(CL, code);
  
  code = "char copyrightinternal[]=\n"
    "\"This is the internal copyright message and could be substitute.\\n\"\n"
    "\"by our own one. This copyright message is only for the\\n\"\n"
    "\"command line parser and not for the whole program.\\n\"\n"
    "\"Copyright (C) for the command line parser:\\n\"\n"
    "\"       1994 R. Schamburger, Institut fuer Physiologie und\\n\"\n"
    "\"       Biokybernetik (IPB), Universitaet Erlangen, Deutschland\\n\"\n"
    "\"  Permission to use, copy, modify, distribute, and sell this\\n\"\n"
    "\"  software and its documentation for any purpose is hereby\\n\"\n"
    "\"  granted without fee, provided that the above copyright notice\\n\"\n"
    "\"  appear in all copies and related publications and that both\\n\"\n"
    "\"  that copyright notice and this permission notice appear in\\n\"\n"
    "\"  supporting documentation. The authors make no representations\\n\"\n"
    "\"  about the suitability of this software for any purpose. It is\\n\"\n"
    "\"  provided \\\"as is\\\" without express or implied warranty.\\n\\n\"\n"
    "\"  Send your comments, suggestions or bug reports to\\n\"\n"
    "\"          ftpebs@uni-erlangen.de\\n\\n\";\n";
  fprintf(CL, code);

  delete [] nameh;
  delete [] namecc; 

  int err = 0;
  err += BuiltUsageCode();
  err += BuiltParserCode();
  fclose(CL);
  if(err != 0)
    return -1;
  else
    return 0;
}

int Parse::BuiltUsageCode(void)
{
  if(CL == NULL)
    return -1;
  fprintf(CL,"\n");
  fprintf(CL, "void Usage(char *pname)\n");
  fprintf(CL, "{\n");
  if(Usage != NULL)
    fprintf(CL, "  fprintf(stderr, \"Usage  : %s\\n\");\n", Usage);
  if(Author != NULL)
    fprintf(CL, "  fprintf(stderr, \"Author : %s\\n\");\n", Author);
  if(Version != NULL)
    fprintf(CL, "  fprintf(stderr, \"Version: %s\\n\");\n", Version);
  fprintf(CL, "  fprintf(stderr, \" %%s {arguments}\\n\", pname);\n");
  fprintf(CL, "  fprintf(stderr, \"\\targuments:\\n\");\n");
  fprintf(CL, "  fprintf(stderr, \"     *\\t-c \\tcopyright message\\n\");\n");
  fprintf(CL, "  fprintf(stderr, \"     *\\t-h \\thelp or usage"
	  " message\\n\");\n");
  int i;
  char *des;
  for(i = 0; i < NumOfLines; i++) {
    if(VarArg[i] == NULL)
      continue;
    else {
      if(Description[i] == NULL)
	des = "";
      else 
	des = Description[i];
      if((Default[i] != NULL) || (strcmp(VarType[i], "bool")==0))
	fprintf(CL, "  fprintf(stderr, \"     *\\t%s \\t%s\\n\");\n",
		VarArg[i], des);
      else
	fprintf(CL, "  fprintf(stderr, \"\\t%s \\t%s\\n\");\n",
		VarArg[i], des);
    }
  }
  fprintf(CL, "fprintf(stderr, \"\\n     * means that this argument"
	  " is optional.\\n\");\n");
  fprintf(CL, "  fprintf(stderr, \"\\n\");\n");
  fprintf(CL, "}\n");
  fprintf(CL, "\n");
  return 0;
}

int Parse::BuiltEventParser(void)
{
  int y;
  int found = 0;

  for(y=0; y<NumOfLines; y++) {
    if(VarType[y] == NULL)
      continue;
    if(strcmp("eventlist", VarType[y])==0) {
      found = 1;
      break;
    }
  }
  if(!found)
    return 0;

  char *code;

  code = "void ClearEvents(EventMod *pars_event)\n"
    "{\n"
    "  if(pars_event == NULL)\n"
    "    return;\n"
    "  else {\n"
    "    ClearEvents(pars_event->Next);\n"
    "    delete pars_event;\n"
    "  }\n"
    "}\n\n";
  fprintf(CL, code);

  code = "int ParseEventWord(EventMod *pars_event, char *pars_text0)\n"
    "{\n"
    "  char *pars_text = mystrdup(pars_text0);\n"
    "  int pars_textlen = strlen(pars_text);\n"
    "  int pars_out = 0;\n"
    "  int pars_pos1 = 0;\n"
    "  int pars_pos2 = 0;\n"
    "  char pars_c;\n"
    "  char pars_helpbuf[1024];\n"
    "  for(;;) {\n"
    "    pars_event->FileName = NULL;\n"
    "    pars_event->Offset = 0;\n"
    "    pars_event->Length = 0;\n"
    "    pars_event->ListNr = -1;\n"
    "    pars_event->Begin  = 0;\n"
    "    pars_event->End    = 0;\n"
    "    pars_event->Next   = NULL;\n"
    "    // read the filename\n"
    "    while(pars_text[pars_pos2]!='#'&&pars_text[pars_pos2]!='+'&&\n"
    "          pars_text[pars_pos2]!=','&&pars_text[pars_pos2]!=':'&&\n"
    "          pars_text[pars_pos2]!='@'&&pars_textlen>=pars_pos2)\n"
    "      pars_pos2++;\n"
    "    pars_c = pars_text[pars_pos2];\n"
    "    pars_text[pars_pos2] = '\\0';\n"
    "    pars_event->FileName = mystrdup(pars_text+pars_pos1);\n"
    "    pars_text[pars_pos2] = pars_c;\n"
    "    pars_pos1=pars_pos2+1;\n"
    "\n"
    "    while((!pars_out) && (pars_textlen>=pars_pos2)) {\n"
    "      if(pars_text[pars_pos2] == '#') { // read listnr\n"
    "        pars_pos2++;\n"
    "        while(pars_text[pars_pos2]!='+'&&\n"
    "              pars_text[pars_pos2]!=','&&pars_text[pars_pos2]!=':'&&\n"
    "              pars_text[pars_pos2]!='@'&&pars_textlen>=pars_pos2)\n"
    "          pars_pos2++;\n"
    "        pars_c = pars_text[pars_pos2];\n"
    "        pars_text[pars_pos2] = '\\0';\n"
    "        strcpy(pars_helpbuf, pars_text+pars_pos1);\n"
    "        pars_text[pars_pos2] = pars_c;\n"
    "        pars_pos1=pars_pos2+1;\n"
    "        pars_event->ListNr = atoi(pars_helpbuf);\n"
    "      } else if(pars_text[pars_pos2] == '+') { // read offset\n"
    "        pars_pos2++;\n"
    "        while(pars_text[pars_pos2]!=','&&pars_text[pars_pos2]!=':'&&\n"
    "              pars_text[pars_pos2]!='@'&&pars_textlen>=pars_pos2)\n"
    "          pars_pos2++;\n"
    "        pars_c = pars_text[pars_pos2];\n"
    "        pars_text[pars_pos2] = '\\0';\n"
    "        strcpy(pars_helpbuf, pars_text+pars_pos1);\n"
    "        pars_text[pars_pos2] = pars_c;\n"
    "        pars_pos1=pars_pos2+1;\n"
    "        pars_event->Offset = atoi(pars_helpbuf);\n"
    "      } else if(pars_text[pars_pos2] == ',') { // read length\n"
    "        pars_pos2++;\n"
    "        while(pars_text[pars_pos2]!=':'&&\n"
    "              pars_text[pars_pos2]!='@'&&pars_textlen>=pars_pos2)\n"
    "          pars_pos2++;\n"
    "        pars_c = pars_text[pars_pos2];\n"
    "        pars_text[pars_pos2] = '\\0';\n"
    "        strcpy(pars_helpbuf, pars_text+pars_pos1);\n"
    "        pars_text[pars_pos2] = pars_c;\n"
    "        pars_pos1=pars_pos2+1;\n"
    "        pars_event->Length = atoi(pars_helpbuf);\n"
    "      } else if(pars_text[pars_pos2] == ':') { // read intervall\n"
    "        pars_pos2++;\n"
    "        while(pars_text[pars_pos2]!='-'&&pars_textlen>=pars_pos2)\n"
    "          pars_pos2++;\n"
    "        pars_c = pars_text[pars_pos2];\n"
    "        pars_text[pars_pos2] = '\\0';\n"
    "        strcpy(pars_helpbuf, pars_text+pars_pos1);\n"
    "        pars_text[pars_pos2] = pars_c;\n"
    "        pars_pos1=pars_pos2+1;\n"
    "        pars_event->Begin = atoi(pars_helpbuf);\n"
    "        while(pars_text[pars_pos2]!='@'&&pars_textlen>=pars_pos2)\n"
    "          pars_pos2++;\n"
    "        pars_c = pars_text[pars_pos2];\n"
    "        pars_text[pars_pos2] = '\\0';\n"
    "        strcpy(pars_helpbuf, pars_text+pars_pos1);\n"
    "        pars_text[pars_pos2] = pars_c;\n"
    "        pars_pos1=pars_pos2+1;\n"
    "        pars_event->End = atoi(pars_helpbuf);\n"
    "        pars_pos1 = pars_pos2+1;\n"
    "      } else if(pars_text[pars_pos2]=='@' && "
                    "pars_text[pars_pos2+1]!='\\0') {\n"
    "        pars_event->Next = new EventMod;\n"
    "        pars_event = pars_event->Next;\n"
    "        pars_pos2++;\n"
    "        pars_pos1=pars_pos2;\n"
    "        break;\n"
    "      }\n"
    "      else {\n"
    "        fprintf(stderr, \"Error: something is wrong with: %%s\\n\", "
                             "pars_text);\n"
    "        fprintf(stderr, \" look at position: %%d\\n\", pars_pos2+1);\n"
    "        delete [] pars_text;\n"
    "        return -1;\n"
    "      }\n"
    "      if(pars_pos2>=pars_textlen)\n"
    "        pars_out = 1;\n"
    "    } //while\n" // while
    "    if(pars_pos2>=pars_textlen) {\n"
    "      break;\n"
    "    }\n"
    "  } //for\n" //for      
    "  delete [] pars_text;\n"
    "  return 0;\n"
    "}\n\n";
  fprintf(CL, code, VarNam[y]);
  return 0;
}


int Parse::BuiltParserCode(void)
{
  if(CL == NULL)
    return -1;
  char *code;
  int y, mes, k;

  BuiltEventParser();

  code = "int ParseCommandLine(int pars_num, char **pars_vec)\n"
    "{\n"
    "  // set defaults\n";
  fprintf(CL, code);
  int numofstrings = 0;
  for(y=0; y<NumOfLines; y++) {
    if(VarType[y] == NULL)
      continue;
    if(strcmp("string", VarType[y]) == 0)
      numofstrings++;
    fprintf(CL, "  int %s_def\t= 0;\n", VarNam[y]);
  }
  fprintf(CL, "\n");
  for(y=0; y<NumOfLines; y++) {
    if(VarType[y] == NULL)
      continue;
    if(strcmp("bool", VarType[y])==0) {
      fprintf(CL, "  %s\t= 0;\n", VarNam[y]);
      fprintf(CL, "  %s_def\t= 1;\n", VarNam[y]);
    }
    if(Default[y] == NULL)
      continue;
    else {
      fprintf(CL, "  %s_def\t= 1;\n", VarNam[y]);
      if((strcmp("bool", VarType[y])==0) ||
	 (strcmp("int", VarType[y])==0)  ||
	 (strcmp("float", VarType[y])==0) ||
	 (strcmp("string", VarType[y])==0)) {
	fprintf(CL, "  %s\t= %s;\n", VarNam[y], Default[y]);
      }
      else if(strcmp("intervallint", VarType[y])==0) {
	char **end = &Default[y];
	fprintf(CL, "  %s.From\t= %d;\n", 
		VarNam[y], strtol(Default[y], end, 0));
	fprintf(CL, "  %s.To\t= %d;\n", 
		VarNam[y], strtol(*end, end, 0));
      } else if(strcmp("intervallfloat", VarType[y])==0) {
	char **end = &Default[y];
	fprintf(CL, "  %s.From\t= %f;\n", 
		VarNam[y], strtod(Default[y], end));
	fprintf(CL, "  %s.To\t= %f;\n", 
		VarNam[y], strtod(*end, end));
      } else if(strcmp("eventlist", VarType[y])==0) {
	fprintf(CL, "  if(ParseEventWord(&%s, \"%s\")==-1) {\n",
		VarNam[y], Default[y]);
	fprintf(CL, "    return -1;\n");
	fprintf(CL, "  }\n");
      }
    }
  }

  code = "\n  int pars_numofstrings = %d;\n"
    "  int pars_atstring = 0;\n"
    "  char **pars_strings = new char* [pars_numofstrings];\n"
    "  int pars_i = 1;\n"
    "  while(pars_i < pars_num) {\n"
    "    if(strcmp(\"-h\", pars_vec[pars_i])==0) {\n"
    "      Usage(pars_vec[0]);\n"
    "      return -1;\n"
    "    }\n"
    "    else if(strcmp(\"-c\", pars_vec[pars_i])==0) {\n"
    "      if(Copyright == NULL)\n"
    "        fprintf(stderr, \"%%s\\n\", copyrightinternal);\n"
    "      else\n"
    "        fprintf(stderr, \"%%s\\n\", Copyright);\n"
    "    }\n";
  fprintf(CL, code, numofstrings);

  for(y = 0; y<NumOfLines; y++) {
    if(VarArg[y] == NULL)
      continue;
    else {
      fprintf(CL, "    else if(strcmp(\"%s\", pars_vec[pars_i])==0) {\n",
	      VarArg[y]);
      mes = WriteCodeArg(y);
      if(mes == -1)
	return -1;
      fprintf(CL, "    }\n");
    }
  }
  code = "    else {\n"
    "      if(pars_vec[pars_i][0]=='-'||pars_atstring==pars_numofstrings) {\n"
    "        fprintf(stderr, \"Error: unknown argument: %%s\\n\", pars_vec[pars_i]);\n"
    "        Usage(pars_vec[0]);\n"
    "        return -1;\n"
    "      }\n"
    "      pars_strings[pars_atstring] = pars_vec[pars_i];\n"
    "      pars_atstring++;\n"
    "    }\n"
    "    pars_i++;\n"
    "  }\n\n"; // while
  fprintf(CL, code);

  int dum = 0;
  fprintf(CL, "  int pars_atstring2 = 0;\n");
  fprintf(CL, "  while(pars_atstring2 < pars_atstring) {\n");
  for(y=0; y<NumOfLines; y++) {
    if(VarType[y] == NULL)
      continue;
    if(strcmp("string", VarType[y]) == 0) {
      if(dum == 0) {
	fprintf(CL, "    if(%s_def == 0) {\n",
		VarNam[y],VarNam[y]);
	dum = 1;
      }
      else {
	fprintf(CL, " else if(%s_def == 0) {\n",
		VarNam[y], VarNam[y]);
      }
      fprintf(CL, "      %s_def = 1;\n", VarNam[y]);
      fprintf(CL, "      %s = pars_strings[pars_atstring2];\n", VarNam[y]);
      fprintf(CL, "      pars_atstring2++;\n");
      fprintf(CL, "    }");
    }
  }
  code = " else {\n"
    "      fprintf(stderr, \"Error: to many string variables!\\n\");\n"
    "      Usage(pars_vec[0]);\n"
    "      return -1;\n"
    "    }\n"
    "  }\n\n";
  fprintf(CL, code);

  dum = 0;
  for(y = 0; y<NumOfLines; y++) {
    if(VarType[y] == NULL)
      continue;
    else {
      if(dum == 0) {
	fprintf(CL, "  if(%s_def == 0", VarNam[y]);
	dum = 1;
      }
      else {
	fprintf(CL, " ||\n     %s_def == 0", VarNam[y]);
      }
    }
  }
  if(dum == 1) {
    fprintf(CL, ") {\n");
    fprintf(CL, "    fprintf(stderr, \"Error: missing some arguments!\\n\");\n");
    fprintf(CL, "    Usage(pars_vec[0]);\n");
    fprintf(CL, "    return -1;\n");
    fprintf(CL, "  }\n");
  }
  fprintf(CL, "  return 0;\n");
  fprintf(CL, "}\n"); // void

  return 0;
}

int Parse::WriteCodeArg(int y)
{
  fprintf(CL, "      //Code for Argument %d\n", y);
  char *code;
  
  fprintf(CL, "      %s_def = 1;\n", VarNam[y]);
  if(strcmp("bool", VarType[y])==0) {
    fprintf(CL, "      %s = 1;\n", VarNam[y]);
  }
  else if(strcmp("int", VarType[y])==0) {
    code = "      pars_i++;\n"
      "      if(pars_i >= pars_num) {\n"
      "        fprintf(stderr, \"Error: missing some values!\\n\");\n"
      "        Usage(pars_vec[0]);\n"
      "        return -1;\n"
      "      }\n"
      "      %s = atoi(pars_vec[pars_i]);\n";
    fprintf(CL, code, VarNam[y]);
  }
  else if(strcmp("float", VarType[y])==0) {
    code = "      pars_i++;\n"
      "      if(pars_i >= pars_num) {\n"
      "        fprintf(stderr, \"Error: missing some values!\\n\");\n"
      "        Usage(pars_vec[0]);\n"
      "        return -1;\n"
      "      }\n"
      "      %s = atof(pars_vec[pars_i]);\n";
    fprintf(CL, code, VarNam[y]);
  }
  else if(strcmp("intervallint", VarType[y])==0) {
    code = "      pars_i++;\n"
      "      pars_i++;\n"
      "      if(pars_i >= pars_num) {\n"
      "        fprintf(stderr, \"Error: missing some values!\\n\");\n"
      "        Usage(pars_vec[0]);\n"
      "        return -1;\n"
      "      }\n"
      "      %s.From = atoi(pars_vec[pars_i-1]);\n"
      "      %s.To   = atoi(pars_vec[pars_i]);\n";
    fprintf(CL, code, VarNam[y], VarNam[y]);
  }
  else if(strcmp("intervallfloat", VarType[y])==0) {
    code = "      pars_i++;\n"
      "      pars_i++;\n"
      "      if(pars_i >= pars_num) {\n"
      "        fprintf(stderr, \"Error: issing some values!\\n\");\n"
      "        Usage(pars_vec[0]);\n"
      "        return -1;\n"
      "      }\n"
      "      %s.From = atof(pars_vec[pars_i-1]);\n"
      "      %s.To   = atof(pars_vec[pars_i]);\n";
    fprintf(CL, code, VarNam[y], VarNam[y]);
  }
  else if(strcmp("string", VarType[y])==0) {
    code = "      pars_i++;\n"
      "      if(pars_i >= pars_num) {\n"
      "        fprintf(stderr, \"Error: missing some values!\\n\");\n"
      "        Usage(pars_vec[0]);\n"
      "        return -1;\n"
      "      }\n"
      "      %s = pars_vec[pars_i];\n";
    fprintf(CL, code, VarNam[y]);
  }
  else if(strcmp("eventlist", VarType[y])==0) {
    code = "      pars_i++;\n"
      "      if(pars_i >= pars_num) {\n"
      "        fprintf(stderr, \"Error: missing some values!\\n\");\n"
      "        Usage(pars_vec[0]);\n"
      "        return -1;\n"
      "      }\n"
      "      if(%s.Next != NULL) {\n"
      "        ClearEvents(%s.Next);\n"
      "        %s.Next = NULL;\n"
      "      }\n"
      "      if(ParseEventWord(&%s, pars_vec[pars_i])!=0)\n"
      "        return -1;\n";

    fprintf(CL, code, VarNam[y], VarNam[y], VarNam[y], VarNam[y]);
  }
  return 0;
}