/*
 * Amanda, The Advanced Maryland Automatic Network Disk Archiver
 * Copyright (c) 1991-1998, 2000 University of Maryland at College Park
 * Copyright (c) 2007-2012 Zmanda, Inc.  All Rights Reserved.
 * Copyright (c) 2013-2016 Carbonite, Inc.  All Rights Reserved.
 * All Rights Reserved.
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of U.M. not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  U.M. makes no representations about the
 * suitability of this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 *
 * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Authors: the Amanda Development Team.  Its members are listed in a
 * file named AUTHORS, in the root directory of this distribution.
 */
/*
 * $Id$
 *
 * parser for amrecover interactive language
 */
%{
#include "amanda.h"
#include "amrecover.h"

#define DATE_ALLOC_SIZE sizeof("YYYY-MM-DD-HH-MM-SS")   /* includes null */

void		yyerror(char *s);
extern int	yylex(void);
extern char *	yytext;
%}

/* DECLARATIONS */
%union {
	int	intval;
	double	floatval;
	char *	strval;
	int	subtok;
}

	/* literal keyword tokens */

%token LISTHOST LISTDISK LISTPROPERTY
%token SETHOST SETDISK SETDATE SETTAPE SETMODE SETDEVICE SETPROPERTY
%token CD CDX QUIT DHIST LS ADD ADDX EXTRACT DASH_H
%token LIST DELETE DELETEX PWD CLEAR HELP LCD LPWD MODE SMB TAR
%token APPEND PRIORITY SETTRANSLATE STORAGE
%token NL

        /* typed tokens */

%token <strval> STRING


/* GRAMMAR */
%%

ucommand:
	set_command
  |     setdate_command
  |     display_command
  |     quit_command
  |     add_command
  |     addx_command
  |     delete_command
  |     deletex_command
  |     local_command
  |	help_command
  |     extract_command
  |     invalid_command
  ;

set_command:
	LISTHOST NL { list_host(); }
  |	LISTHOST invalid_string { yyerror("Invalid argument"); }
  |	LISTDISK STRING NL { list_disk($2); amfree($2); }
  |	LISTDISK NL { list_disk(NULL); }
  |	LISTDISK STRING invalid_string { yyerror("Invalid argument"); amfree($2); }
  |	LISTPROPERTY NL { list_property(); }
  |	LISTPROPERTY invalid_string { yyerror("Invalid argument"); }
  |	SETTRANSLATE NL { set_translate(NULL); }
  |	SETTRANSLATE STRING invalid_string NL { yyerror("Invalid argument"); }
  |	SETTRANSLATE STRING NL { set_translate($2); amfree($2); }
  |	SETHOST STRING NL { set_host($2); amfree($2); }
  |	SETHOST STRING invalid_string { yyerror("Invalid argument"); amfree($2); }
  |	SETHOST NL { yyerror("Argument required"); }
  |	SETDISK STRING STRING NL { set_disk($2, $3); amfree($2); amfree($3); }
  |	SETDISK STRING NL { set_disk($2, NULL); amfree($2); }
  |	SETDISK STRING STRING invalid_string { yyerror("Invalid argument"); amfree($2); amfree($3); }
  |	SETDISK { yyerror("Argument required"); }
  |	SETTAPE STRING NL { set_tape($2); amfree($2); }
  |	SETTAPE NL { set_tape("default"); }
  |	SETTAPE STRING invalid_string { yyerror("Invalid argument"); amfree($2); }
  |	SETDEVICE STRING NL { set_device(NULL, $2); amfree($2); }
  |	SETDEVICE DASH_H STRING STRING NL { set_device($3, $4); amfree($3); amfree($4);  }
  |	SETDEVICE NL { set_device(NULL, NULL); }
  |	SETDEVICE STRING invalid_string { yyerror("Invalid argument"); amfree($2); }
  |	SETDEVICE DASH_H STRING NL { yyerror("Invalid argument"); amfree($3); }
  |	SETDEVICE DASH_H STRING STRING invalid_string { yyerror("Invalid argument"); amfree($3); amfree($4); }
  |	SETPROPERTY STRING property_value { set_property_name($2, 0); amfree($2); }
  |	SETPROPERTY APPEND STRING property_value { set_property_name($3, 1); amfree($3); }
  |	SETPROPERTY PRIORITY STRING property_value { set_property_name($3, 0); amfree($3); }
  |	SETPROPERTY APPEND PRIORITY STRING property_value { set_property_name($4, 1); amfree($4); }
  |	SETPROPERTY NL { yyerror("Invalid argument"); }
  |	SETPROPERTY APPEND NL { yyerror("Invalid argument"); }
  |	SETPROPERTY PRIORITY NL { yyerror("Invalid argument"); }
  |	SETPROPERTY APPEND PRIORITY NL { yyerror("Invalid argument"); }
  |	CD STRING NL { cd_glob($2, 1); amfree($2); }
  |	CD STRING invalid_string { yyerror("Invalid argument"); }
  |	CD NL { yyerror("Argument required"); }
  |     CDX STRING NL { cd_regex($2, 1); amfree($2); }
  |	CDX STRING invalid_string { yyerror("Invalid argument"); amfree($2); }
  |	CDX NL { yyerror("Argument required"); }
  |	SETMODE SMB NL { set_mode(SAMBA_SMBCLIENT); }
  |	SETMODE TAR NL { set_mode(SAMBA_TAR); }
  |	SETMODE SMB invalid_string { yyerror("Invalid argument"); }
  |	SETMODE TAR invalid_string { yyerror("Invalid argument"); }
  |	SETMODE invalid_string { yyerror("Invalid argument"); }
  |	SETMODE NL { yyerror("Argument required"); }
  |	STORAGE storage_value { set_storage(); }
  ;

setdate_command:
	SETDATE STRING NL {
			time_t now;
			struct tm *t;
			int y=2000, m=0, d=1, h=0, mi=0, s=0;
			char *mydate = $2;

			now = time((time_t *)NULL);
			t = localtime(&now);
			if (t) {
			    y = 1900+t->tm_year;
			    m = t->tm_mon+1;
			    d = t->tm_mday;
			}
			if (sscanf(mydate, "---%d", &d) == 1 ||
			    sscanf(mydate, "--%d-%d", &m, &d) == 2 ||
			    sscanf(mydate, "%d-%d-%d-%d-%d-%d", &y, &m, &d, &h, &mi, &s) >= 3) {
			    if (y < 70) {
				y += 2000;
			    } else if (y < 100) {
				y += 1900;
			    }
			    if(y < 1000 || y > 9999) {
				printf("invalid year");
			    } else if(m < 1 || m > 12) {
				printf("invalid month");
			    } else if(d < 1 || d > 31) {
				printf("invalid day");
			    } else if(h < 0 || h > 24) {
				printf("invalid hour");
			    } else if(mi < 0 || mi > 59) {
				printf("invalid minute");
			    } else if(s < 0 || s > 59) {
				printf("invalid second");
			    } else {
				char result[DATE_ALLOC_SIZE];
				if (h == 0 && mi == 0 && s == 0)
				    g_snprintf(result, DATE_ALLOC_SIZE, "%04d-%02d-%02d", y, m, d);
				else
				    g_snprintf(result, DATE_ALLOC_SIZE, "%04d-%02d-%02d-%02d-%02d-%02d", y, m, d, h, mi, s);
				set_date(result);
			    }
			} else {
			    printf("Invalid date: %s\n", mydate);
			}
		     }
  |	SETDATE NL { yyerror("Argument required"); }
  |	SETDATE STRING invalid_string { yyerror("Invalid argument"); }
  ;

display_command:
	DHIST NL { list_disk_history(); }
  |	DHIST invalid_string { yyerror("Invalid argument"); }
  |	LS NL { list_directory(); }
  |	LS invalid_string { yyerror("Invalid argument"); }
  |	LIST STRING NL { display_extract_list($2); amfree($2); }
  |	LIST NL { display_extract_list(NULL); }
  |	LIST STRING invalid_string { yyerror("Invalid argument"); }
  |	PWD NL { show_directory(); }
  |	PWD invalid_string { yyerror("Invalid argument"); }
  |	CLEAR NL { clear_extract_list(); }
  |	CLEAR invalid_string { yyerror("Invalid argument"); }
  |	MODE NL { show_mode (); }
  |	MODE invalid_string { yyerror("Invalid argument"); }
  ;

quit_command:
	QUIT NL { quit(); }
  |	QUIT invalid_string { yyerror("Invalid argument"); }
  ;

add_command:
	ADD add_path NL
  ;

add_path:
	add_path STRING { add_glob($2); amfree($2); }
  |	STRING { add_glob($1); amfree($1); }
  ;

addx_command:
	ADDX addx_path NL
  ;

addx_path:
	addx_path STRING { add_regex($2); amfree($2); }
  |	STRING { add_regex($1); amfree($1); }
  ;

delete_command:
	DELETE delete_path NL
  ;

delete_path:
	delete_path STRING { delete_glob($2); amfree($2); }
  |	STRING { delete_glob($1); amfree($1); }
  ;

deletex_command:
	DELETEX deletex_path NL
  ;

deletex_path:
	deletex_path STRING { delete_regex($2); amfree($2); }
  |	STRING { delete_regex($1); amfree($1); }
  ;

local_command:
	LPWD NL { char * buf= g_get_current_dir(); puts(buf); free(buf); }
  |	LPWD invalid_string { yyerror("Invalid argument"); }
  |	LCD STRING NL {
		local_cd($2);
		amfree($2);
	}
  |	LCD STRING invalid_string { yyerror("Invalid argument"); }
  |	LCD NL { yyerror("Argument required"); }
  ;

help_command:
	HELP NL { help_list(); }
  |	HELP invalid_string { yyerror("Invalid argument"); }
  ;

extract_command:
	EXTRACT NL { extract_files(); }
  |	EXTRACT invalid_string { yyerror("Invalid argument"); }
  ;

invalid_command:
        STRING bogus_string {
	    char * errstr = g_strjoin(NULL, "Invalid command: ", $1, NULL);
	    yyerror(errstr);
	    amfree(errstr);
	    YYERROR;
	} /* Quiets compiler warnings about unused label */
  ;

property_value:
	STRING property_value { add_property_value($1); amfree( $1); }
  |     NL { ; }
  ;

storage_value:
	STRING storage_value { add_storage_value($1); amfree( $1); }
  |     NL { ; }
  ;

invalid_string:
	STRING bogus_string { amfree($1); }
  ;

bogus_string:
        STRING bogus_string { amfree($1); }
  |	NL { ; }

/* ADDITIONAL C CODE */
%%

void
yyerror(
    char *	s)
{
	g_printf("%s\n", s);
}
