%{
/****************************************************************************
 * BiffSocko
 * answerparser.lex
 *
 * parses answer.xml files located in Murex.  I go under assumption that the
 * file modification date is the finish time of the process.  I basically stat 
 * the file and use the variable modtime to get the last modification of the file.
 * Based on that I derive the start_time as well.
 *
 * OUTPUT:
 * =======
 * the output is CSV Formatted.  The Header is created in a shell script
 * that calls this process.  The header appears like this:
 *
 * Hostname,Process,Status,ElpsedTime,CPU_Time,IO_Time,Start_Time,Finish_Time,CPU_Percent,Rdbcom1,Rdbcom2
 * 
 * COMPILE:
 * =======
 * flex answerparser.lex
 * fcc lex.yy.c
 *
 ****************************************************************************/
#include<stdio.h>
#include<strings.h>
#include<time.h>
#include<stdlib.h>
#include<sys/stat.h>

#define MAX 512

/************************************************************ 
 * when DEBUG is uncommented, you get some extra output that 
 * can be helpful in troubleshooting
 *************************************************************/
/* #define DEBUG */

char* get_time_date(time_t);

/*********************************
 * Some Global Variables (yuck)
 ********************************/
char status[MAX];		/* output status of murex app */
char name[MAX];			/* name of murex app */
char host[MAX];			/* host the murex app ran on */
char elapsed_time[MAX];		/* how long the murex app ran */
char cpu_time[MAX];		/* how much cpu time the murex app used */
char io_time[MAX];		/* how much io time the murex app used */

%}
%option stack
%START parseScript
%START parseStatus
%START parseName
%START parseHost
%START parseElapsedTime
%START parseCPUTime
%START parseIOTime
%START parseTimeing
%%

"<Script>"		{yy_push_state(parseScript);}
"<Status>" 		{yy_push_state(parseStatus);}
<parseStatus>[^<]*	{
				strcpy(status, yytext);
				yy_pop_state();
			}

"Status><Name>"		{yy_push_state(parseName);}
<parseName>[^<]*        {
                                strcpy(name, yytext);
                                yy_pop_state();
                        }
"<Hostname>"            {yy_push_state(parseHost);}
<parseHost>[^<]*        {
                                strcpy(host, yytext);
                                yy_pop_state();
                        }
"<Timing>"		{yy_push_state(parseTimeing);}
"<ElapsedTime>"		{yy_push_state(parseElapsedTime);}
<parseElapsedTime>[^<]* {
                                strcpy(elapsed_time, yytext);
                                yy_pop_state();
                        }
"<CPUTime>"		{yy_push_state(parseCPUTime);}
<parseCPUTime>[^<]*     {
				strcpy(cpu_time, yytext);
                                yy_pop_state();
                        }
"<IOTime>"		{yy_push_state(parseIOTime);}
<parseIOTime>[^<]*     	{
                                strcpy(io_time, yytext);
                                yy_pop_state();
			}
"</Timing>"		{ 
				yy_pop_state();
				yy_pop_state();
				YY_BREAK;
			}
. 			|
\n			{/* */}
%%
/************************************************************
 * START MAIN() 
 ***********************************************************/
int main(int argc, char *argv[]){
	FILE *Fp=NULL;			/* input file */
	struct stat sbuf;     		/* struct with file attriibutes */
	int stat_ret;         		/* return value for stat() */
	time_t modtime;	      		/* struct for file modification time */
	char *seperator = ":";  	/* pointer to character seperator for strtok() */
	char *tok=NULL;			/* temp pointer for strtok() */
	char tmp[MAX];			/* temp string for the tokenizer */
	int hour; 			/* hour */
	int minute; 			/* minute */
	int seconds;			/* seconds */
	time_t start_time;     	     	/* time the murex process started (modtime - elapsed_time) */
	char *tmp_time ='\0';		/* place holder for time */
	char start_time_str[MAX];   	/* start time date string */ 
	char finish_time_str[MAX];  	/* finish time date string */

	/*****************************
	 * check command line input
	 ****************************/
	if(argc != 2){
		printf("usage: %s [file]\n", argv[0]);
		exit(1);
	}

	/*****************************
	 * get file modification time
	 ****************************/
	stat_ret = stat(argv[1], &sbuf);
	if (stat_ret == -1) {
		printf("error getting modification time\n");
		exit(1);
	}else{
		modtime = (time_t * ) (sbuf.st_mtime);
	}

	/*****************************
	 * open file for lex analysis
	 ****************************/
	 if(!(Fp = fopen(argv[1], "r"))){
                fprintf(stderr, "error opening %s\n", argv[1]);
                exit(2);
        }


	/********************************
	 * start lex analysis 
	 * parse input file with rules
	 * listed above
	 ********************************/
	yyin=Fp;
	yylex();
	fclose(Fp);

	/********************************
	 * convert ElapsedTime to something
	 * I can use as a start time
	 ********************************/
	strcpy(tmp, elapsed_time);
	tok = strtok(tmp, seperator);
	hour = atoi(tok);
	tok = strtok(NULL, seperator);
	minute =  atoi(tok);
	tok = strtok(NULL, seperator);
	seconds =  atoi(tok);

	/********************************
	 * get length of processing time
	 * minus the finish time to get us
	 * the starting time of the process.
	 *
	 * this assumes modification time 
	 * is the time that the process
	 * finished
	 ********************************/
	start_time = hour*60*60+minute*60+seconds; 
	start_time = modtime - start_time;
	tmp_time = get_time_date(start_time); 
	strcpy(start_time_str,tmp_time); 
	tmp_time = get_time_date(modtime); 
	strcpy(finish_time_str,tmp_time); 

	#ifdef DEBUG	
		printf("=======================================================\n");
		printf("hostname = %s\nProcessName = %s\nStatus = %s\nElapsedTime = %s\n",host,name,status,elapsed_time);
		printf("CPU Time = %s\nIO Time = %s\nfinish_time = %s\nstart_time = %s\n",cpu_time,io_time,finish_time_str,start_time_str);
		printf("finish time seconds = %ld\nstart time seconds = %ld\n",modtime, start_time);
		printf("=======================================================\n");
		printf("host,name,status,elapsed_time,cpu_time,io_time,start_time,finish_time\n");
		printf("%s,%s,%s,%s%s,%s,%s,%s,,,,,,\n",host,name,status,elapsed_time,cpu_time,io_time,start_time_str,finish_time_str);
	#endif
printf("%s,%s,,,%s,%s,%s,%s,%s,%ld,%s,%ld,,,,\n",host,name,status,elapsed_time,cpu_time,io_time,start_time_str,start_time,finish_time_str,modtime);


	exit(0);
}


/*********************************
 * this function is required for
 * portability
 *********************************/
int yywrap(){
	return -1;
}

/*********************************
 * get_time_date()
 * changes seconds since EPOCH to 
 * a date string
 *********************************/
char* get_time_date(time_t time){
	char *str=NULL;
        /*********************************************************
         * convert using atoi the character str containing seconds
         *********************************************************/
        str = ctime(&time);

	str[strlen(str)-1] = '\0';
	return str; 

}