/* VMS archive wrapper.
   Copyright (C) 2011-2020 Free Software Foundation, Inc.
   Contributed by AdaCore.

This file is part of GCC.

GCC 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, or (at your option)
any later version.

GCC 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 GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */

#include <errno.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "libiberty.h"

#define FATAL_EXIT_CODE (44 | 0x10000000)

/* Librarian arguments.  */
static int lib_arg_max = 0;
static const char **lib_args;
static int lib_arg_index = -1;

/* Set for r/c/x/v command.  */
static int replace_mode = 0;
static int create_mode = 0;
static int extract_mode = 0;
static int verbose_mode = 0;

static char modecmd[32];
static char libname[256];

#define TEMP_FILE "arXXXXXX"
#define TEMP_FILE_LEN (sizeof(TEMP_FILE) - 1)
#define SUFFIX ".com"
#define SUFFIX_LEN (sizeof(SUFFIX) - 1)

static char *to_host_file_spec (char *filespec);
static int is_regular_file (char *name);

#ifdef VMS
static char new_host_filespec [255];
static char filename_buff [256];

static int
translate_unix (char *name, int type)
{
  strcpy (filename_buff, name);
  return 0;
}
#endif

static char *
to_host_file_spec (char *filespec)
{
#ifdef VMS
  if (strchr (filespec, ']') || strchr (filespec, ':'))
    return filespec;
  else
    {
      strcpy (filename_buff, filespec);
      decc$to_vms (filespec, translate_unix, 1, 1);
      strcpy (new_host_filespec, filename_buff);
      return new_host_filespec;
    }
#else
  return filespec;
#endif
}

/* Check to see if the file named in NAME is a regular file, i.e. not a
   directory.  */

static int
is_regular_file (char *name)
{
  int ret;
  struct stat statbuf;

  ret = stat (name, &statbuf);
  return !ret && S_ISREG (statbuf.st_mode);
}

/* Add the argument contained in STR to the list of arguments to pass to the
   archiver.  */

static void
addarg (const char *str)
{
  if (++lib_arg_index >= lib_arg_max)
    {
      lib_arg_max += 1000;
      lib_args = XRESIZEVEC (const char *, lib_args, lib_arg_max);
    }

  lib_args[lib_arg_index] = str;
}

static void
usage (void)
{
  printf ("usage: ar -r [-cv] archive file...\n");
  printf ("       ar -c [-rv] archive file...\n");
  printf ("       ar -x [-v] archive [module...]\n");
}

int
main (int argc, char *argv[])
{
  int i, nexti, iarg;
  FILE *comfile;
  int comfd;
  int outlen, maxoutlen = 4000;
  char temp_filename[] = TEMP_FILE SUFFIX;
  char command[256];
  int status;

  if (argc < 2)
    {
      fprintf (stderr, "ar: no command or archive\n");
      exit (FATAL_EXIT_CODE);
    }

  if (argv[1][0] != '-')
    {
      int arglen = strlen (argv[1]);

      /* Compatibility mode.  */
      for (i = 0; i < arglen; i++)
	{
	  if (argv[1][i] == 'r')
	    {
	      replace_mode = 1;
	    }
	  else if (argv[1][i] == 'c')
	    {
	      create_mode = 1;
	    }
	  else if (argv[1][i] == 'x')
	    {
	      extract_mode = 1;
	    }
	  else if (argv[1][i] == 'v')
	    {
	      verbose_mode = 1;
	    }
          else
            {
              fprintf (stderr, "ar: unknown command '%c'\n", argv[1][i]);
              exit (FATAL_EXIT_CODE);
            }
	}
      nexti = 2;
    }
  else
    {
      /* Option mode.  */
      nexti = 1;
      for (i = 1; i < argc; i++)
	{
	  if (argv[i][0] != '-')
	    {
	      nexti = i;
	      break;
	    }
	  else if (strcmp (argv[i], "-r") == 0)
	    {
	      replace_mode = 1;
	    }
	  else if (strcmp (argv[i], "-c") == 0)
	    {
	      create_mode = 1;
	    }
	  else if (strcmp (argv[i], "-x") == 0)
	    {
	      extract_mode = 1;
	    }
	  else if (strcmp (argv[i], "-v") == 0)
	    {
	      verbose_mode = 1;
	    }
	  else if (strcmp (argv[i], "--help") == 0)
	    {
              usage ();
              exit (EXIT_SUCCESS);
	    }
          else
            {
              fprintf (stderr, "ar: unknown option %s\n", argv[i]);
              exit (FATAL_EXIT_CODE);
            }
	}
    }

  if (extract_mode)
    {
      do
        {
          char *lname = argv[nexti];
          int lnamelen;

          /* Next argument is the archive name.  */
          if (is_regular_file (lname))
            {
              addarg (xstrdup (to_host_file_spec (lname)));
              break;
            }

          /* If not found, try with .olb instead of .a.  */
          lnamelen = strlen (lname);

	  if (lnamelen > 2
              && strcmp (&lname [lnamelen - 2], ".a") == 0)
	    {
	      char *nlibname;

	      nlibname = (char *)alloca (lnamelen + 3);
	      strcpy (nlibname, lname);
	      strcpy (&nlibname [lnamelen - 2], ".olb");
	      if (is_regular_file (nlibname))
                {
                  addarg (xstrdup (to_host_file_spec (nlibname)));
                  break;
                }
            }

          fprintf (stderr, "ar: file '%s' doesn't exist\n", lname);
          exit (FATAL_EXIT_CODE);
	} while (0);
    }
  else
    strcpy (libname, to_host_file_spec (argv[nexti]));

  nexti++;

  /* Build command mode.  */
  if (replace_mode)
    {
      strcat (modecmd, "/replace");

      if (!is_regular_file (libname) || !replace_mode)
        {
          /* Really create if the archive doesn't exist.  */
          strcat (modecmd, "/create");
        }
    }
  else if (extract_mode)
    {
      if (nexti == argc)
        {
          /* Extract all.  */
          strcat (modecmd, "/extract=(*");
        }
      else
        strcat (modecmd, "/extract=(");
    }

  /* Add files.  */
  for (i = nexti; i < argc; i++)
    {
      if (extract_mode)
        {
          /* Convert to module name (remove extension) and quote it.  */
          char *module = argv[i];
          int module_len = strlen (module);
          char *newarg = (char *)xmalloc (module_len + 3);
          int l;

          newarg[0] = '"';
          memcpy (newarg + 1, module, module_len);

          l = 1 + module_len;
          if (module_len > 4
              && strcmp (&module[module_len - 4], ".obj") == 0)
            l -= 4;

          newarg[l] = '"';
          newarg[l + 1] = 0;

          addarg (newarg);
        }
      else
        {
          /* Add the filename.  */
          addarg (xstrdup (to_host_file_spec (argv[i])));
        }
    }

  if (extract_mode)
    addarg (")");

  /* Create the command file name.  */
  strcpy (temp_filename, TEMP_FILE SUFFIX);
  comfd = mkstemps (temp_filename, SUFFIX_LEN);
  comfile = fdopen (comfd, "w");

  /* Write the command file.
     We need to split to command into severals ones if it is too long.  */
  outlen = 0;
  for (iarg = 0; iarg <= lib_arg_index; iarg++)
    {
      if (outlen == 0)
        {
          fprintf (comfile, "$ library %s %s -\n", modecmd, libname);
          if (create_mode && iarg == 0)
            strcpy (modecmd, "/replace");
        }

      fprintf (comfile, "%s", lib_args [iarg]);
      outlen += strlen (lib_args [iarg]) + 2;

      if (outlen > maxoutlen || iarg == lib_arg_index)
        {
          /* Will write a new command.  */
          fprintf (comfile, "\n");
          outlen = 0;
        }
      else
        {
          /* Continuation line.  */
          fprintf (comfile, ",-\n");
        }
    }

  fclose (comfile);

  sprintf (command, "@%s", temp_filename);

  status = system (command);

  remove (temp_filename);

  exit (status);
}