/* script.c -- Functions to create an in memory description of the script. */
/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2005,2006,2007,2009,2010  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  VAS_EBOOT is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/misc.h>
#include <VasEBoot/script_sh.h>
#include <VasEBoot/parser.h>
#include <VasEBoot/mm.h>

/* It is not possible to deallocate the memory when a syntax error was
   found.  Because of that it is required to keep track of all memory
   allocations.  The memory is freed in case of an error, or assigned
   to the parsed script when parsing was successful.

   In case of the normal malloc, some additional bytes are allocated
   for this datastructure.  All reserved memory is stored in a linked
   list so it can be easily freed.  The original memory can be found
   from &mem.  */
struct VasEBoot_script_mem
{
  struct VasEBoot_script_mem *next;
  char mem;
};

/* Return malloc'ed memory and keep track of the allocation.  */
void *
VasEBoot_script_malloc (struct VasEBoot_parser_param *state, VasEBoot_size_t size)
{
  struct VasEBoot_script_mem *mem;
  mem = (struct VasEBoot_script_mem *) VasEBoot_malloc (size + sizeof (*mem)
						- sizeof (char));
  if (!mem)
    return 0;

  VasEBoot_dprintf ("scripting", "malloc %p\n", mem);
  mem->next = state->memused;
  state->memused = mem;
  return (void *) &mem->mem;
}

/* Free all memory described by MEM.  */
void
VasEBoot_script_mem_free (struct VasEBoot_script_mem *mem)
{
  struct VasEBoot_script_mem *memfree;

  while (mem)
    {
      memfree = mem->next;
      VasEBoot_dprintf ("scripting", "free %p\n", mem);
      VasEBoot_free (mem);
      mem = memfree;
    }
}

/* Start recording memory usage.  Returns the memory that should be
   restored when calling stop.  */
struct VasEBoot_script_mem *
VasEBoot_script_mem_record (struct VasEBoot_parser_param *state)
{
  struct VasEBoot_script_mem *mem = state->memused;
  state->memused = 0;

  return mem;
}

/* Stop recording memory usage.  Restore previous recordings using
   RESTORE.  Return the recorded memory.  */
struct VasEBoot_script_mem *
VasEBoot_script_mem_record_stop (struct VasEBoot_parser_param *state,
			     struct VasEBoot_script_mem *restore)
{
  struct VasEBoot_script_mem *mem = state->memused;
  state->memused = restore;
  return mem;
}

/* Free the memory reserved for CMD and all of it's children.  */
void
VasEBoot_script_free (struct VasEBoot_script *script)
{
  struct VasEBoot_script *s;
  struct VasEBoot_script *t;

  if (! script)
    return;

  if (script->mem)
    VasEBoot_script_mem_free (script->mem);

  s = script->children;
  while (s) {
    t = s->next_siblings;
    VasEBoot_script_unref (s);
    s = t;
  }
  VasEBoot_free (script);
}



/* Extend the argument arg with a variable or string of text.  If ARG
   is zero a new list is created.  */
struct VasEBoot_script_arg *
VasEBoot_script_arg_add (struct VasEBoot_parser_param *state,
		     struct VasEBoot_script_arg *arg, VasEBoot_script_arg_type_t type,
		     char *str)
{
  struct VasEBoot_script_arg *argpart;
  struct VasEBoot_script_arg *ll;
  int len;

  argpart =
    (struct VasEBoot_script_arg *) VasEBoot_script_malloc (state, sizeof (*arg));
  if (!argpart)
    return arg;

  argpart->type = type;
  argpart->script = 0;

  len = VasEBoot_strlen (str) + 1;
  argpart->str = VasEBoot_script_malloc (state, len);
  if (!argpart->str)
    return arg; /* argpart is freed later, during VasEBoot_script_free.  */

  VasEBoot_memcpy (argpart->str, str, len);
  argpart->next = 0;

  if (!arg)
    return argpart;

  for (ll = arg; ll->next; ll = ll->next);
  ll->next = argpart;

  return arg;
}

/* Add the argument ARG to the end of the argument list LIST.  If LIST
   is zero, a new list will be created.  */
struct VasEBoot_script_arglist *
VasEBoot_script_add_arglist (struct VasEBoot_parser_param *state,
			 struct VasEBoot_script_arglist *list,
			 struct VasEBoot_script_arg *arg)
{
  struct VasEBoot_script_arglist *link;
  struct VasEBoot_script_arglist *ll;

  VasEBoot_dprintf ("scripting", "arglist\n");

  link =
    (struct VasEBoot_script_arglist *) VasEBoot_script_malloc (state, sizeof (*link));
  if (!link)
    return list;

  link->next = 0;
  link->arg = arg;
  link->argcount = 0;

  if (!list)
    {
      link->argcount++;
      return link;
    }

  list->argcount++;

  /* Look up the last link in the chain.  */
  for (ll = list; ll->next; ll = ll->next);
  ll->next = link;

  return list;
}

/* Create a command that describes a single command line.  CMDLINE
   contains the name of the command that should be executed.  ARGLIST
   holds all arguments for this command.  */
struct VasEBoot_script_cmd *
VasEBoot_script_create_cmdline (struct VasEBoot_parser_param *state,
			    struct VasEBoot_script_arglist *arglist)
{
  struct VasEBoot_script_cmdline *cmd;

  VasEBoot_dprintf ("scripting", "cmdline\n");

  cmd = VasEBoot_script_malloc (state, sizeof (*cmd));
  if (!cmd)
    return 0;

  cmd->cmd.exec = VasEBoot_script_execute_cmdline;
  cmd->cmd.next = 0;
  cmd->arglist = arglist;

  return (struct VasEBoot_script_cmd *) cmd;
}

/* Create a command that functions as an if statement.  If BOOL is
   evaluated to true (the value is returned in envvar '?'), the
   interpreter will run the command TRUE, otherwise the interpreter
   runs the command FALSE.  */
struct VasEBoot_script_cmd *
VasEBoot_script_create_cmdif (struct VasEBoot_parser_param *state,
			  struct VasEBoot_script_cmd *exec_to_evaluate,
			  struct VasEBoot_script_cmd *exec_on_true,
			  struct VasEBoot_script_cmd *exec_on_false)
{
  struct VasEBoot_script_cmdif *cmd;

  VasEBoot_dprintf ("scripting", "cmdif\n");

  cmd = VasEBoot_script_malloc (state, sizeof (*cmd));
  if (!cmd)
    return 0;

  cmd->cmd.exec = VasEBoot_script_execute_cmdif;
  cmd->cmd.next = 0;
  cmd->exec_to_evaluate = exec_to_evaluate;
  cmd->exec_on_true = exec_on_true;
  cmd->exec_on_false = exec_on_false;

  return (struct VasEBoot_script_cmd *) cmd;
}

/* Create a command that functions as a for statement.  */
struct VasEBoot_script_cmd *
VasEBoot_script_create_cmdfor (struct VasEBoot_parser_param *state,
			   struct VasEBoot_script_arg *name,
			   struct VasEBoot_script_arglist *words,
			   struct VasEBoot_script_cmd *list)
{
  struct VasEBoot_script_cmdfor *cmd;

  VasEBoot_dprintf ("scripting", "cmdfor\n");

  cmd = VasEBoot_script_malloc (state, sizeof (*cmd));
  if (! cmd)
    return 0;

  cmd->cmd.exec = VasEBoot_script_execute_cmdfor;
  cmd->cmd.next = 0;
  cmd->name = name;
  cmd->words = words;
  cmd->list = list;

  return (struct VasEBoot_script_cmd *) cmd;
}

/* Create a "while" or "until" command.  */
struct VasEBoot_script_cmd *
VasEBoot_script_create_cmdwhile (struct VasEBoot_parser_param *state,
			     struct VasEBoot_script_cmd *cond,
			     struct VasEBoot_script_cmd *list,
			     int is_an_until_loop)
{
  struct VasEBoot_script_cmdwhile *cmd;

  cmd = VasEBoot_script_malloc (state, sizeof (*cmd));
  if (! cmd)
    return 0;

  cmd->cmd.exec = VasEBoot_script_execute_cmdwhile;
  cmd->cmd.next = 0;
  cmd->cond = cond;
  cmd->list = list;
  cmd->until = is_an_until_loop;

  return (struct VasEBoot_script_cmd *) cmd;
}

/* Create a chain of commands.  LAST contains the command that should
   be added at the end of LIST's list.  If LIST is zero, a new list
   will be created.  */
struct VasEBoot_script_cmd *
VasEBoot_script_append_cmd (struct VasEBoot_parser_param *state,
			struct VasEBoot_script_cmd *list,
			struct VasEBoot_script_cmd *last)
{
  struct VasEBoot_script_cmd *ptr;

  VasEBoot_dprintf ("scripting", "append command\n");

  if (! last)
    return list;

  if (! list)
    {
      list = VasEBoot_script_malloc (state, sizeof (*list));
      if (! list)
	return 0;

      list->exec = VasEBoot_script_execute_cmdlist;
      list->next = last;
    }
  else
    {
      ptr = list;
      while (ptr->next)
	ptr = ptr->next;

      ptr->next = last;
    }

  return list;
}



struct VasEBoot_script *
VasEBoot_script_create (struct VasEBoot_script_cmd *cmd, struct VasEBoot_script_mem *mem)
{
  struct VasEBoot_script *parsed;

  parsed = VasEBoot_malloc (sizeof (*parsed));
  if (! parsed)
    return 0;

  parsed->mem = mem;
  parsed->cmd = cmd;
  parsed->refcnt = 0;
  parsed->children = 0;
  parsed->next_siblings = 0;

  return parsed;
}

/* Parse the script passed in SCRIPT and return the parsed
   datastructure that is ready to be interpreted.  */
struct VasEBoot_script *
VasEBoot_script_parse (char *script,
		   VasEBoot_reader_getline_t getline, void *getline_data)
{
  struct VasEBoot_script *parsed;
  struct VasEBoot_script_mem *membackup;
  struct VasEBoot_lexer_param *lexstate;
  struct VasEBoot_parser_param *parsestate;

  parsed = VasEBoot_script_create (0, 0);
  if (!parsed)
    return 0;

  parsestate = VasEBoot_zalloc (sizeof (*parsestate));
  if (!parsestate)
    {
      VasEBoot_free (parsed);
      return 0;
    }

  /* Initialize the lexer.  */
  lexstate = VasEBoot_script_lexer_init (parsestate, script,
				     getline, getline_data);
  if (!lexstate)
    {
      VasEBoot_free (parsed);
      VasEBoot_free (parsestate);
      return 0;
    }

  parsestate->lexerstate = lexstate;

  membackup = VasEBoot_script_mem_record (parsestate);

  /* Parse the script.  */
  if (VasEBoot_script_yyparse (parsestate) || parsestate->err)
    {
      struct VasEBoot_script_mem *memfree;
      memfree = VasEBoot_script_mem_record_stop (parsestate, membackup);
      VasEBoot_script_mem_free (memfree);
      VasEBoot_script_lexer_fini (lexstate);
      VasEBoot_free (parsestate);
      VasEBoot_free (parsed);
      return 0;
    }

  parsed->mem = VasEBoot_script_mem_record_stop (parsestate, membackup);
  parsed->cmd = parsestate->parsed;
  parsed->children = parsestate->scripts;

  VasEBoot_script_lexer_fini (lexstate);
  VasEBoot_free (parsestate);

  return parsed;
}