← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gettext/utopic

« back to all changes in this revision

Viewing changes to gettext-tools/gnulib-lib/javacomp.c

  • Committer: Colin Watson
  • Date: 2010-08-01 21:36:08 UTC
  • mfrom: (2.1.10 sid)
  • Revision ID: cjwatson@canonical.com-20100801213608-yy7vkm8lpatep3ci
merge from Debian 0.18.1.1-1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gettext-tools/gnulib-lib/javacomp.c
1
1
/* Compile a Java program.
2
 
   Copyright (C) 2001-2003, 2006-2007 Free Software Foundation, Inc.
 
2
   Copyright (C) 2001-2003, 2006-2010 Free Software Foundation, Inc.
3
3
   Written by Bruno Haible <haible@clisp.cons.org>, 2001.
4
4
 
5
5
   This program is free software: you can redistribute it and/or modify
41
41
#include "safe-read.h"
42
42
#include "xalloc.h"
43
43
#include "xmalloca.h"
44
 
#include "filename.h"
 
44
#include "concat-filename.h"
45
45
#include "fwriteerror.h"
46
46
#include "clean-temp.h"
47
47
#include "error.h"
81
81
 
82
82
   We try the Java compilers in the following order:
83
83
     1. getenv ("JAVAC"), because the user must be able to override our
84
 
        preferences,
 
84
        preferences,
85
85
     2. "gcj -C", because it is a completely free compiler,
86
86
     3. "javac", because it is a standard compiler,
87
87
     4. "jikes", comes last because it has some deviating interpretation
88
 
        of the Java Language Specification and because it requires a
89
 
        CLASSPATH environment variable.
 
88
        of the Java Language Specification and because it requires a
 
89
        CLASSPATH environment variable.
90
90
 
91
91
   We unset the JAVA_HOME environment variable, because a wrong setting of
92
92
   this variable can confuse the JDK's javac.
104
104
      /* Determine the version from the found JVM.  */
105
105
      java_version_cache = javaexec_version ();
106
106
      if (java_version_cache == NULL
107
 
          || !(java_version_cache[0] == '1' && java_version_cache[1] == '.'
108
 
               && (java_version_cache[2] >= '1' && java_version_cache[2] <= '6')
109
 
               && java_version_cache[3] == '\0'))
110
 
        java_version_cache = "1.1";
 
107
          || !(java_version_cache[0] == '1' && java_version_cache[1] == '.'
 
108
               && (java_version_cache[2] >= '1' && java_version_cache[2] <= '6')
 
109
               && java_version_cache[3] == '\0'))
 
110
        java_version_cache = "1.1";
111
111
    }
112
112
  return java_version_cache;
113
113
}
199
199
   Return a failure indicator (true upon error).  */
200
200
static bool
201
201
compile_using_envjavac (const char *javac,
202
 
                        const char * const *java_sources,
203
 
                        unsigned int java_sources_count,
204
 
                        const char *directory,
205
 
                        bool optimize, bool debug,
206
 
                        bool verbose, bool null_stderr)
 
202
                        const char * const *java_sources,
 
203
                        unsigned int java_sources_count,
 
204
                        const char *directory,
 
205
                        bool optimize, bool debug,
 
206
                        bool verbose, bool null_stderr)
207
207
{
208
208
  /* Because $JAVAC may consist of a command and options, we use the
209
209
     shell.  Because $JAVAC has been set by the user, we leave all
268
268
  argv[2] = command;
269
269
  argv[3] = NULL;
270
270
  exitstatus = execute (javac, "/bin/sh", argv, false, false, false,
271
 
                        null_stderr, true, true);
 
271
                        null_stderr, true, true, NULL);
272
272
  err = (exitstatus != 0);
273
273
 
274
274
  freea (command);
280
280
   Return a failure indicator (true upon error).  */
281
281
static bool
282
282
compile_using_gcj (const char * const *java_sources,
283
 
                   unsigned int java_sources_count,
284
 
                   bool no_assert_option,
285
 
                   bool fsource_option, const char *source_version,
286
 
                   bool ftarget_option, const char *target_version,
287
 
                   const char *directory,
288
 
                   bool optimize, bool debug,
289
 
                   bool verbose, bool null_stderr)
 
283
                   unsigned int java_sources_count,
 
284
                   bool no_assert_option,
 
285
                   bool fsource_option, const char *source_version,
 
286
                   bool ftarget_option, const char *target_version,
 
287
                   const char *directory,
 
288
                   bool optimize, bool debug,
 
289
                   bool verbose, bool null_stderr)
290
290
{
291
291
  bool err;
292
292
  unsigned int argc;
350
350
    }
351
351
 
352
352
  exitstatus = execute ("gcj", "gcj", argv, false, false, false, null_stderr,
353
 
                        true, true);
 
353
                        true, true, NULL);
354
354
  err = (exitstatus != 0);
355
355
 
356
356
  if (ftarget_arg != NULL)
366
366
   Return a failure indicator (true upon error).  */
367
367
static bool
368
368
compile_using_javac (const char * const *java_sources,
369
 
                     unsigned int java_sources_count,
370
 
                     bool source_option, const char *source_version,
371
 
                     bool target_option, const char *target_version,
372
 
                     const char *directory,
373
 
                     bool optimize, bool debug,
374
 
                     bool verbose, bool null_stderr)
 
369
                     unsigned int java_sources_count,
 
370
                     bool source_option, const char *source_version,
 
371
                     bool target_option, const char *target_version,
 
372
                     const char *directory,
 
373
                     bool optimize, bool debug,
 
374
                     bool verbose, bool null_stderr)
375
375
{
376
376
  bool err;
377
377
  unsigned int argc;
421
421
    }
422
422
 
423
423
  exitstatus = execute ("javac", "javac", argv, false, false, false,
424
 
                        null_stderr, true, true);
 
424
                        null_stderr, true, true, NULL);
425
425
  err = (exitstatus != 0);
426
426
 
427
427
  freea (argv);
433
433
   Return a failure indicator (true upon error).  */
434
434
static bool
435
435
compile_using_jikes (const char * const *java_sources,
436
 
                     unsigned int java_sources_count,
437
 
                     const char *directory,
438
 
                     bool optimize, bool debug,
439
 
                     bool verbose, bool null_stderr)
 
436
                     unsigned int java_sources_count,
 
437
                     const char *directory,
 
438
                     bool optimize, bool debug,
 
439
                     bool verbose, bool null_stderr)
440
440
{
441
441
  bool err;
442
442
  unsigned int argc;
476
476
    }
477
477
 
478
478
  exitstatus = execute ("jikes", "jikes", argv, false, false, false,
479
 
                        null_stderr, true, true);
 
479
                        null_stderr, true, true, NULL);
480
480
  err = (exitstatus != 0);
481
481
 
482
482
  freea (argv);
492
492
   Return a failure indicator (true upon error).  */
493
493
static bool
494
494
write_temp_file (struct temp_dir *tmpdir, const char *file_name,
495
 
                 const char *contents)
 
495
                 const char *contents)
496
496
{
497
497
  FILE *fp;
498
498
 
526
526
    {
527
527
      /* Read its first 8 bytes.  */
528
528
      if (safe_read (fd, header, 8) == 8)
529
 
        {
530
 
          /* Verify the class file signature.  */
531
 
          if (header[0] == 0xCA && header[1] == 0xFE
532
 
              && header[2] == 0xBA && header[3] == 0xBE)
533
 
            return header[7];
534
 
        }
 
529
        {
 
530
          /* Verify the class file signature.  */
 
531
          if (header[0] == 0xCA && header[1] == 0xFE
 
532
              && header[2] == 0xBA && header[3] == 0xBE)
 
533
            return header[7];
 
534
        }
535
535
      close (fd);
536
536
    }
537
537
 
549
549
  if (!envjavac_tested)
550
550
    {
551
551
      /* Test whether $JAVAC is gcj:
552
 
         "$JAVAC --version 2>/dev/null | sed -e 1q | grep gcj > /dev/null"  */
 
552
         "$JAVAC --version 2>/dev/null | sed -e 1q | grep gcj > /dev/null"  */
553
553
      unsigned int command_length;
554
554
      char *command;
555
555
      char *argv[4];
567
567
      command = (char *) xmalloca (command_length);
568
568
      p = command;
569
569
      /* Don't shell_quote $JAVAC, because it may consist of a command
570
 
         and options.  */
 
570
         and options.  */
571
571
      memcpy (p, javac, strlen (javac));
572
572
      p += strlen (javac);
573
573
      memcpy (p, " --version", 1 + 9 + 1);
574
574
      p += 1 + 9 + 1;
575
575
      /* Ensure command_length was correctly calculated.  */
576
576
      if (p - command > command_length)
577
 
        abort ();
 
577
        abort ();
578
578
 
579
579
      /* Call $JAVAC --version 2>/dev/null.  */
580
580
      argv[0] = "/bin/sh";
582
582
      argv[2] = command;
583
583
      argv[3] = NULL;
584
584
      child = create_pipe_in (javac, "/bin/sh", argv, DEV_NULL, true, true,
585
 
                              false, fd);
 
585
                              false, fd);
586
586
      if (child == -1)
587
 
        goto failed;
 
587
        goto failed;
588
588
 
589
589
      /* Retrieve its result.  */
590
590
      fp = fdopen (fd[0], "r");
591
591
      if (fp == NULL)
592
 
        goto failed;
 
592
        goto failed;
593
593
 
594
594
      line = NULL; linesize = 0;
595
595
      linelen = getline (&line, &linesize, fp);
596
596
      if (linelen == (size_t)(-1))
597
 
        {
598
 
          fclose (fp);
599
 
          goto failed;
600
 
        }
 
597
        {
 
598
          fclose (fp);
 
599
          goto failed;
 
600
        }
601
601
      /* It is safe to call c_strstr() instead of strstr() here; see the
602
 
         comments in c-strstr.h.  */
 
602
         comments in c-strstr.h.  */
603
603
      envjavac_gcj = (c_strstr (line, "gcj") != NULL);
604
604
 
605
605
      fclose (fp);
606
606
 
607
607
      /* Remove zombie process from process list, and retrieve exit status.  */
608
 
      exitstatus = wait_subprocess (child, javac, true, true, true, false);
 
608
      exitstatus =
 
609
        wait_subprocess (child, javac, true, true, true, false, NULL);
609
610
      if (exitstatus != 0)
610
 
        envjavac_gcj = false;
 
611
        envjavac_gcj = false;
611
612
 
612
613
     failed:
613
614
      freea (command);
629
630
  if (!envjavac_tested)
630
631
    {
631
632
      /* Test whether $JAVAC is gcj:
632
 
         "$JAVAC --version 2>/dev/null | sed -e 's,^[^0-9]*,,' -e 1q \
633
 
          | sed -e '/^4\.[012]/d' | grep '^[4-9]' >/dev/null"  */
 
633
         "$JAVAC --version 2>/dev/null | sed -e 's,^[^0-9]*,,' -e 1q \
 
634
          | sed -e '/^4\.[012]/d' | grep '^[4-9]' >/dev/null"  */
634
635
      unsigned int command_length;
635
636
      char *command;
636
637
      char *argv[4];
648
649
      command = (char *) xmalloca (command_length);
649
650
      p = command;
650
651
      /* Don't shell_quote $JAVAC, because it may consist of a command
651
 
         and options.  */
 
652
         and options.  */
652
653
      memcpy (p, javac, strlen (javac));
653
654
      p += strlen (javac);
654
655
      memcpy (p, " --version", 1 + 9 + 1);
655
656
      p += 1 + 9 + 1;
656
657
      /* Ensure command_length was correctly calculated.  */
657
658
      if (p - command > command_length)
658
 
        abort ();
 
659
        abort ();
659
660
 
660
661
      /* Call $JAVAC --version 2>/dev/null.  */
661
662
      argv[0] = "/bin/sh";
663
664
      argv[2] = command;
664
665
      argv[3] = NULL;
665
666
      child = create_pipe_in (javac, "/bin/sh", argv, DEV_NULL, true, true,
666
 
                              false, fd);
 
667
                              false, fd);
667
668
      if (child == -1)
668
 
        goto failed;
 
669
        goto failed;
669
670
 
670
671
      /* Retrieve its result.  */
671
672
      fp = fdopen (fd[0], "r");
672
673
      if (fp == NULL)
673
 
        goto failed;
 
674
        goto failed;
674
675
 
675
676
      line = NULL; linesize = 0;
676
677
      linelen = getline (&line, &linesize, fp);
677
678
      if (linelen == (size_t)(-1))
678
 
        {
679
 
          fclose (fp);
680
 
          goto failed;
681
 
        }
 
679
        {
 
680
          fclose (fp);
 
681
          goto failed;
 
682
        }
682
683
      p = line;
683
684
      while (*p != '\0' && !(*p >= '0' && *p <= '9'))
684
 
        p++;
 
685
        p++;
685
686
      envjavac_gcj43 =
686
687
        !(*p == '4' && p[1] == '.' && p[2] >= '0' && p[2] <= '2')
687
 
        && (*p >= '4' && *p <= '9');
 
688
        && (*p >= '4' && *p <= '9');
688
689
 
689
690
      fclose (fp);
690
691
 
691
692
      /* Remove zombie process from process list, and retrieve exit status.  */
692
 
      exitstatus = wait_subprocess (child, javac, true, true, true, false);
 
693
      exitstatus =
 
694
        wait_subprocess (child, javac, true, true, true, false, NULL);
693
695
      if (exitstatus != 0)
694
 
        envjavac_gcj43 = false;
 
696
        envjavac_gcj43 = false;
695
697
 
696
698
     failed:
697
699
      freea (command);
707
709
   Return a failure indicator (true upon error).  */
708
710
static bool
709
711
is_envjavac_gcj43_usable (const char *javac,
710
 
                          const char *source_version,
711
 
                          const char *target_version,
712
 
                          bool *usablep,
713
 
                          bool *fsource_option_p, bool *ftarget_option_p)
 
712
                          const char *source_version,
 
713
                          const char *target_version,
 
714
                          bool *usablep,
 
715
                          bool *fsource_option_p, bool *ftarget_option_p)
714
716
{
715
717
  /* The cache depends on the source_version and target_version.  */
716
718
  struct result_t
724
726
  struct result_t *resultp;
725
727
 
726
728
  resultp = &result_cache[source_version_index (source_version)]
727
 
                         [target_version_index (target_version)];
 
729
                         [target_version_index (target_version)];
728
730
  if (!resultp->tested)
729
731
    {
730
732
      /* Try $JAVAC.  */
736
738
 
737
739
      tmpdir = create_temp_dir ("java", NULL, false);
738
740
      if (tmpdir == NULL)
739
 
        return true;
 
741
        return true;
740
742
 
741
743
      conftest_file_name =
742
 
        concatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
 
744
        xconcatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
743
745
      if (write_temp_file (tmpdir, conftest_file_name,
744
 
                           get_goodcode_snippet (source_version)))
745
 
        {
746
 
          free (conftest_file_name);
747
 
          cleanup_temp_dir (tmpdir);
748
 
          return true;
749
 
        }
 
746
                           get_goodcode_snippet (source_version)))
 
747
        {
 
748
          free (conftest_file_name);
 
749
          cleanup_temp_dir (tmpdir);
 
750
          return true;
 
751
        }
750
752
 
751
753
      compiled_file_name =
752
 
        concatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
 
754
        xconcatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
753
755
      register_temp_file (tmpdir, compiled_file_name);
754
756
 
755
757
      java_sources[0] = conftest_file_name;
756
758
      if (!compile_using_envjavac (javac,
757
 
                                   java_sources, 1, tmpdir->dir_name,
758
 
                                   false, false, false, true)
759
 
          && stat (compiled_file_name, &statbuf) >= 0
760
 
          && get_classfile_version (compiled_file_name)
761
 
             <= corresponding_classfile_version (target_version))
762
 
        {
763
 
          /* $JAVAC compiled conftest.java successfully.  */
764
 
          /* Try adding -fsource option if it is useful.  */
765
 
          char *javac_source =
766
 
            xasprintf ("%s -fsource=%s", javac, source_version);
767
 
 
768
 
          unlink (compiled_file_name);
769
 
 
770
 
          java_sources[0] = conftest_file_name;
771
 
          if (!compile_using_envjavac (javac_source,
772
 
                                       java_sources, 1, tmpdir->dir_name,
773
 
                                       false, false, false, true)
774
 
              && stat (compiled_file_name, &statbuf) >= 0
775
 
              && get_classfile_version (compiled_file_name)
776
 
                 <= corresponding_classfile_version (target_version))
777
 
            {
778
 
              const char *failcode = get_failcode_snippet (source_version);
779
 
 
780
 
              if (failcode != NULL)
781
 
                {
782
 
                  free (compiled_file_name);
783
 
                  free (conftest_file_name);
784
 
 
785
 
                  conftest_file_name =
786
 
                    concatenated_filename (tmpdir->dir_name,
787
 
                                           "conftestfail.java",
788
 
                                           NULL);
789
 
                  if (write_temp_file (tmpdir, conftest_file_name, failcode))
790
 
                    {
791
 
                      free (conftest_file_name);
792
 
                      free (javac_source);
793
 
                      cleanup_temp_dir (tmpdir);
794
 
                      return true;
795
 
                    }
796
 
 
797
 
                  compiled_file_name =
798
 
                    concatenated_filename (tmpdir->dir_name,
799
 
                                           "conftestfail.class",
800
 
                                           NULL);
801
 
                  register_temp_file (tmpdir, compiled_file_name);
802
 
 
803
 
                  java_sources[0] = conftest_file_name;
804
 
                  if (!compile_using_envjavac (javac,
805
 
                                               java_sources, 1,
806
 
                                               tmpdir->dir_name,
807
 
                                               false, false, false, true)
808
 
                      && stat (compiled_file_name, &statbuf) >= 0)
809
 
                    {
810
 
                      unlink (compiled_file_name);
811
 
 
812
 
                      java_sources[0] = conftest_file_name;
813
 
                      if (compile_using_envjavac (javac_source,
814
 
                                                  java_sources, 1,
815
 
                                                  tmpdir->dir_name,
816
 
                                                  false, false, false, true))
817
 
                        /* $JAVAC compiled conftestfail.java successfully, and
818
 
                           "$JAVAC -fsource=$source_version" rejects it.  So
819
 
                           the -fsource option is useful.  */
820
 
                        resultp->fsource_option = true;
821
 
                    }
822
 
                }
823
 
            }
824
 
 
825
 
          free (javac_source);
826
 
 
827
 
          resultp->usable = true;
828
 
        }
 
759
                                   java_sources, 1, tmpdir->dir_name,
 
760
                                   false, false, false, true)
 
761
          && stat (compiled_file_name, &statbuf) >= 0
 
762
          && get_classfile_version (compiled_file_name)
 
763
             <= corresponding_classfile_version (target_version))
 
764
        {
 
765
          /* $JAVAC compiled conftest.java successfully.  */
 
766
          /* Try adding -fsource option if it is useful.  */
 
767
          char *javac_source =
 
768
            xasprintf ("%s -fsource=%s", javac, source_version);
 
769
 
 
770
          unlink (compiled_file_name);
 
771
 
 
772
          java_sources[0] = conftest_file_name;
 
773
          if (!compile_using_envjavac (javac_source,
 
774
                                       java_sources, 1, tmpdir->dir_name,
 
775
                                       false, false, false, true)
 
776
              && stat (compiled_file_name, &statbuf) >= 0
 
777
              && get_classfile_version (compiled_file_name)
 
778
                 <= corresponding_classfile_version (target_version))
 
779
            {
 
780
              const char *failcode = get_failcode_snippet (source_version);
 
781
 
 
782
              if (failcode != NULL)
 
783
                {
 
784
                  free (compiled_file_name);
 
785
                  free (conftest_file_name);
 
786
 
 
787
                  conftest_file_name =
 
788
                    xconcatenated_filename (tmpdir->dir_name,
 
789
                                            "conftestfail.java",
 
790
                                            NULL);
 
791
                  if (write_temp_file (tmpdir, conftest_file_name, failcode))
 
792
                    {
 
793
                      free (conftest_file_name);
 
794
                      free (javac_source);
 
795
                      cleanup_temp_dir (tmpdir);
 
796
                      return true;
 
797
                    }
 
798
 
 
799
                  compiled_file_name =
 
800
                    xconcatenated_filename (tmpdir->dir_name,
 
801
                                            "conftestfail.class",
 
802
                                            NULL);
 
803
                  register_temp_file (tmpdir, compiled_file_name);
 
804
 
 
805
                  java_sources[0] = conftest_file_name;
 
806
                  if (!compile_using_envjavac (javac,
 
807
                                               java_sources, 1,
 
808
                                               tmpdir->dir_name,
 
809
                                               false, false, false, true)
 
810
                      && stat (compiled_file_name, &statbuf) >= 0)
 
811
                    {
 
812
                      unlink (compiled_file_name);
 
813
 
 
814
                      java_sources[0] = conftest_file_name;
 
815
                      if (compile_using_envjavac (javac_source,
 
816
                                                  java_sources, 1,
 
817
                                                  tmpdir->dir_name,
 
818
                                                  false, false, false, true))
 
819
                        /* $JAVAC compiled conftestfail.java successfully, and
 
820
                           "$JAVAC -fsource=$source_version" rejects it.  So
 
821
                           the -fsource option is useful.  */
 
822
                        resultp->fsource_option = true;
 
823
                    }
 
824
                }
 
825
            }
 
826
 
 
827
          free (javac_source);
 
828
 
 
829
          resultp->usable = true;
 
830
        }
829
831
      else
830
 
        {
831
 
          /* Try with -fsource and -ftarget options.  */
832
 
          char *javac_target =
833
 
            xasprintf ("%s -fsource=%s -ftarget=%s",
834
 
                       javac, source_version, target_version);
835
 
 
836
 
          unlink (compiled_file_name);
837
 
 
838
 
          java_sources[0] = conftest_file_name;
839
 
          if (!compile_using_envjavac (javac_target,
840
 
                                       java_sources, 1, tmpdir->dir_name,
841
 
                                       false, false, false, true)
842
 
              && stat (compiled_file_name, &statbuf) >= 0
843
 
              && get_classfile_version (compiled_file_name)
844
 
                 <= corresponding_classfile_version (target_version))
845
 
            {
846
 
              /* "$JAVAC -fsource $source_version -ftarget $target_version"
847
 
                 compiled conftest.java successfully.  */
848
 
              resultp->fsource_option = true;
849
 
              resultp->ftarget_option = true;
850
 
              resultp->usable = true;
851
 
            }
852
 
 
853
 
          free (javac_target);
854
 
        }
 
832
        {
 
833
          /* Try with -fsource and -ftarget options.  */
 
834
          char *javac_target =
 
835
            xasprintf ("%s -fsource=%s -ftarget=%s",
 
836
                       javac, source_version, target_version);
 
837
 
 
838
          unlink (compiled_file_name);
 
839
 
 
840
          java_sources[0] = conftest_file_name;
 
841
          if (!compile_using_envjavac (javac_target,
 
842
                                       java_sources, 1, tmpdir->dir_name,
 
843
                                       false, false, false, true)
 
844
              && stat (compiled_file_name, &statbuf) >= 0
 
845
              && get_classfile_version (compiled_file_name)
 
846
                 <= corresponding_classfile_version (target_version))
 
847
            {
 
848
              /* "$JAVAC -fsource $source_version -ftarget $target_version"
 
849
                 compiled conftest.java successfully.  */
 
850
              resultp->fsource_option = true;
 
851
              resultp->ftarget_option = true;
 
852
              resultp->usable = true;
 
853
            }
 
854
 
 
855
          free (javac_target);
 
856
        }
855
857
 
856
858
      free (compiled_file_name);
857
859
      free (conftest_file_name);
885
887
 
886
888
      tmpdir = create_temp_dir ("java", NULL, false);
887
889
      if (tmpdir == NULL)
888
 
        return true;
 
890
        return true;
889
891
 
890
892
      conftest_file_name =
891
 
        concatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
 
893
        xconcatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
892
894
      if (write_temp_file (tmpdir, conftest_file_name,
893
 
                           get_goodcode_snippet ("1.4")))
894
 
        {
895
 
          free (conftest_file_name);
896
 
          cleanup_temp_dir (tmpdir);
897
 
          return true;
898
 
        }
 
895
                           get_goodcode_snippet ("1.4")))
 
896
        {
 
897
          free (conftest_file_name);
 
898
          cleanup_temp_dir (tmpdir);
 
899
          return true;
 
900
        }
899
901
 
900
902
      compiled_file_name =
901
 
        concatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
 
903
        xconcatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
902
904
      register_temp_file (tmpdir, compiled_file_name);
903
905
 
904
906
      java_sources[0] = conftest_file_name;
905
907
      if (!compile_using_envjavac (javac, java_sources, 1, tmpdir->dir_name,
906
 
                                   false, false, false, true)
907
 
          && stat (compiled_file_name, &statbuf) >= 0)
908
 
        /* Compilation succeeded.  */
909
 
        envjavac_usable = true;
 
908
                                   false, false, false, true)
 
909
          && stat (compiled_file_name, &statbuf) >= 0)
 
910
        /* Compilation succeeded.  */
 
911
        envjavac_usable = true;
910
912
 
911
913
      free (compiled_file_name);
912
914
      free (conftest_file_name);
925
927
   Return a failure indicator (true upon error).  */
926
928
static bool
927
929
is_envjavac_oldgcj_14_13_usable (const char *javac,
928
 
                                 bool *usablep, bool *need_no_assert_option_p)
 
930
                                 bool *usablep, bool *need_no_assert_option_p)
929
931
{
930
932
  static bool envjavac_tested;
931
933
  static bool envjavac_usable;
934
936
  if (!envjavac_tested)
935
937
    {
936
938
      /* Try $JAVAC and "$JAVAC -fno-assert".  But add -fno-assert only if
937
 
         it makes a difference.  (It could already be part of $JAVAC.)  */
 
939
         it makes a difference.  (It could already be part of $JAVAC.)  */
938
940
      struct temp_dir *tmpdir;
939
941
      char *conftest_file_name;
940
942
      char *compiled_file_name;
946
948
 
947
949
      tmpdir = create_temp_dir ("java", NULL, false);
948
950
      if (tmpdir == NULL)
949
 
        return true;
 
951
        return true;
950
952
 
951
953
      conftest_file_name =
952
 
        concatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
 
954
        xconcatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
953
955
      if (write_temp_file (tmpdir, conftest_file_name,
954
 
                           get_goodcode_snippet ("1.3")))
955
 
        {
956
 
          free (conftest_file_name);
957
 
          cleanup_temp_dir (tmpdir);
958
 
          return true;
959
 
        }
 
956
                           get_goodcode_snippet ("1.3")))
 
957
        {
 
958
          free (conftest_file_name);
 
959
          cleanup_temp_dir (tmpdir);
 
960
          return true;
 
961
        }
960
962
 
961
963
      compiled_file_name =
962
 
        concatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
 
964
        xconcatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
963
965
      register_temp_file (tmpdir, compiled_file_name);
964
966
 
965
967
      java_sources[0] = conftest_file_name;
966
968
      if (!compile_using_envjavac (javac,
967
 
                                   java_sources, 1, tmpdir->dir_name,
968
 
                                   false, false, false, true)
969
 
          && stat (compiled_file_name, &statbuf) >= 0)
970
 
        /* Compilation succeeded.  */
971
 
        javac_works = true;
 
969
                                   java_sources, 1, tmpdir->dir_name,
 
970
                                   false, false, false, true)
 
971
          && stat (compiled_file_name, &statbuf) >= 0)
 
972
        /* Compilation succeeded.  */
 
973
        javac_works = true;
972
974
      else
973
 
        javac_works = false;
 
975
        javac_works = false;
974
976
 
975
977
      unlink (compiled_file_name);
976
978
 
978
980
 
979
981
      java_sources[0] = conftest_file_name;
980
982
      if (!compile_using_envjavac (javac_noassert,
981
 
                                   java_sources, 1, tmpdir->dir_name,
982
 
                                   false, false, false, true)
983
 
          && stat (compiled_file_name, &statbuf) >= 0)
984
 
        /* Compilation succeeded.  */
985
 
        javac_noassert_works = true;
 
983
                                   java_sources, 1, tmpdir->dir_name,
 
984
                                   false, false, false, true)
 
985
          && stat (compiled_file_name, &statbuf) >= 0)
 
986
        /* Compilation succeeded.  */
 
987
        javac_noassert_works = true;
986
988
      else
987
 
        javac_noassert_works = false;
 
989
        javac_noassert_works = false;
988
990
 
989
991
      free (compiled_file_name);
990
992
      free (conftest_file_name);
991
993
 
992
994
      if (javac_works && javac_noassert_works)
993
 
        {
994
 
          conftest_file_name =
995
 
            concatenated_filename (tmpdir->dir_name, "conftestfail.java",
996
 
                                   NULL);
997
 
          if (write_temp_file (tmpdir, conftest_file_name,
998
 
                               get_failcode_snippet ("1.3")))
999
 
            {
1000
 
              free (conftest_file_name);
1001
 
              free (javac_noassert);
1002
 
              cleanup_temp_dir (tmpdir);
1003
 
              return true;
1004
 
            }
1005
 
 
1006
 
          compiled_file_name =
1007
 
            concatenated_filename (tmpdir->dir_name, "conftestfail.class",
1008
 
                                   NULL);
1009
 
          register_temp_file (tmpdir, compiled_file_name);
1010
 
 
1011
 
          java_sources[0] = conftest_file_name;
1012
 
          if (!compile_using_envjavac (javac,
1013
 
                                       java_sources, 1, tmpdir->dir_name,
1014
 
                                       false, false, false, true)
1015
 
              && stat (compiled_file_name, &statbuf) >= 0)
1016
 
            {
1017
 
              /* Compilation succeeded.  */
1018
 
              unlink (compiled_file_name);
1019
 
 
1020
 
              java_sources[0] = conftest_file_name;
1021
 
              if (!(!compile_using_envjavac (javac_noassert,
1022
 
                                             java_sources, 1, tmpdir->dir_name,
1023
 
                                             false, false, false, true)
1024
 
                    && stat (compiled_file_name, &statbuf) >= 0))
1025
 
                /* Compilation failed.  */
1026
 
                /* "$JAVAC -fno-assert" works better than $JAVAC.  */
1027
 
                javac_works = true;
1028
 
            }
1029
 
 
1030
 
          free (compiled_file_name);
1031
 
          free (conftest_file_name);
1032
 
        }
 
995
        {
 
996
          conftest_file_name =
 
997
            xconcatenated_filename (tmpdir->dir_name, "conftestfail.java",
 
998
                                    NULL);
 
999
          if (write_temp_file (tmpdir, conftest_file_name,
 
1000
                               get_failcode_snippet ("1.3")))
 
1001
            {
 
1002
              free (conftest_file_name);
 
1003
              free (javac_noassert);
 
1004
              cleanup_temp_dir (tmpdir);
 
1005
              return true;
 
1006
            }
 
1007
 
 
1008
          compiled_file_name =
 
1009
            xconcatenated_filename (tmpdir->dir_name, "conftestfail.class",
 
1010
                                    NULL);
 
1011
          register_temp_file (tmpdir, compiled_file_name);
 
1012
 
 
1013
          java_sources[0] = conftest_file_name;
 
1014
          if (!compile_using_envjavac (javac,
 
1015
                                       java_sources, 1, tmpdir->dir_name,
 
1016
                                       false, false, false, true)
 
1017
              && stat (compiled_file_name, &statbuf) >= 0)
 
1018
            {
 
1019
              /* Compilation succeeded.  */
 
1020
              unlink (compiled_file_name);
 
1021
 
 
1022
              java_sources[0] = conftest_file_name;
 
1023
              if (!(!compile_using_envjavac (javac_noassert,
 
1024
                                             java_sources, 1, tmpdir->dir_name,
 
1025
                                             false, false, false, true)
 
1026
                    && stat (compiled_file_name, &statbuf) >= 0))
 
1027
                /* Compilation failed.  */
 
1028
                /* "$JAVAC -fno-assert" works better than $JAVAC.  */
 
1029
                javac_works = true;
 
1030
            }
 
1031
 
 
1032
          free (compiled_file_name);
 
1033
          free (conftest_file_name);
 
1034
        }
1033
1035
 
1034
1036
      cleanup_temp_dir (tmpdir);
1035
1037
 
1036
1038
      if (javac_works)
1037
 
        {
1038
 
          envjavac_usable = true;
1039
 
          envjavac_need_no_assert_option = false;
1040
 
        }
 
1039
        {
 
1040
          envjavac_usable = true;
 
1041
          envjavac_need_no_assert_option = false;
 
1042
        }
1041
1043
      else if (javac_noassert_works)
1042
 
        {
1043
 
          envjavac_usable = true;
1044
 
          envjavac_need_no_assert_option = true;
1045
 
        }
 
1044
        {
 
1045
          envjavac_usable = true;
 
1046
          envjavac_need_no_assert_option = true;
 
1047
        }
1046
1048
 
1047
1049
      envjavac_tested = true;
1048
1050
    }
1057
1059
   Return a failure indicator (true upon error).  */
1058
1060
static bool
1059
1061
is_envjavac_nongcj_usable (const char *javac,
1060
 
                           const char *source_version,
1061
 
                           const char *target_version,
1062
 
                           bool *usablep,
1063
 
                           bool *source_option_p, bool *target_option_p)
 
1062
                           const char *source_version,
 
1063
                           const char *target_version,
 
1064
                           bool *usablep,
 
1065
                           bool *source_option_p, bool *target_option_p)
1064
1066
{
1065
1067
  /* The cache depends on the source_version and target_version.  */
1066
1068
  struct result_t
1074
1076
  struct result_t *resultp;
1075
1077
 
1076
1078
  resultp = &result_cache[source_version_index (source_version)]
1077
 
                         [target_version_index (target_version)];
 
1079
                         [target_version_index (target_version)];
1078
1080
  if (!resultp->tested)
1079
1081
    {
1080
1082
      /* Try $JAVAC.  */
1086
1088
 
1087
1089
      tmpdir = create_temp_dir ("java", NULL, false);
1088
1090
      if (tmpdir == NULL)
1089
 
        return true;
 
1091
        return true;
1090
1092
 
1091
1093
      conftest_file_name =
1092
 
        concatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
 
1094
        xconcatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
1093
1095
      if (write_temp_file (tmpdir, conftest_file_name,
1094
 
                           get_goodcode_snippet (source_version)))
1095
 
        {
1096
 
          free (conftest_file_name);
1097
 
          cleanup_temp_dir (tmpdir);
1098
 
          return true;
1099
 
        }
 
1096
                           get_goodcode_snippet (source_version)))
 
1097
        {
 
1098
          free (conftest_file_name);
 
1099
          cleanup_temp_dir (tmpdir);
 
1100
          return true;
 
1101
        }
1100
1102
 
1101
1103
      compiled_file_name =
1102
 
        concatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
 
1104
        xconcatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
1103
1105
      register_temp_file (tmpdir, compiled_file_name);
1104
1106
 
1105
1107
      java_sources[0] = conftest_file_name;
1106
1108
      if (!compile_using_envjavac (javac,
1107
 
                                   java_sources, 1, tmpdir->dir_name,
1108
 
                                   false, false, false, true)
1109
 
          && stat (compiled_file_name, &statbuf) >= 0
1110
 
          && get_classfile_version (compiled_file_name)
1111
 
             <= corresponding_classfile_version (target_version))
1112
 
        {
1113
 
          /* $JAVAC compiled conftest.java successfully.  */
1114
 
          /* Try adding -source option if it is useful.  */
1115
 
          char *javac_source =
1116
 
            xasprintf ("%s -source %s", javac, source_version);
1117
 
 
1118
 
          unlink (compiled_file_name);
1119
 
 
1120
 
          java_sources[0] = conftest_file_name;
1121
 
          if (!compile_using_envjavac (javac_source,
1122
 
                                       java_sources, 1, tmpdir->dir_name,
1123
 
                                       false, false, false, true)
1124
 
              && stat (compiled_file_name, &statbuf) >= 0
1125
 
              && get_classfile_version (compiled_file_name)
1126
 
                 <= corresponding_classfile_version (target_version))
1127
 
            {
1128
 
              const char *failcode = get_failcode_snippet (source_version);
1129
 
 
1130
 
              if (failcode != NULL)
1131
 
                {
1132
 
                  free (compiled_file_name);
1133
 
                  free (conftest_file_name);
1134
 
 
1135
 
                  conftest_file_name =
1136
 
                    concatenated_filename (tmpdir->dir_name,
1137
 
                                           "conftestfail.java",
1138
 
                                           NULL);
1139
 
                  if (write_temp_file (tmpdir, conftest_file_name, failcode))
1140
 
                    {
1141
 
                      free (conftest_file_name);
1142
 
                      free (javac_source);
1143
 
                      cleanup_temp_dir (tmpdir);
1144
 
                      return true;
1145
 
                    }
1146
 
 
1147
 
                  compiled_file_name =
1148
 
                    concatenated_filename (tmpdir->dir_name,
1149
 
                                           "conftestfail.class",
1150
 
                                           NULL);
1151
 
                  register_temp_file (tmpdir, compiled_file_name);
1152
 
 
1153
 
                  java_sources[0] = conftest_file_name;
1154
 
                  if (!compile_using_envjavac (javac,
1155
 
                                               java_sources, 1,
1156
 
                                               tmpdir->dir_name,
1157
 
                                               false, false, false, true)
1158
 
                      && stat (compiled_file_name, &statbuf) >= 0)
1159
 
                    {
1160
 
                      unlink (compiled_file_name);
1161
 
 
1162
 
                      java_sources[0] = conftest_file_name;
1163
 
                      if (compile_using_envjavac (javac_source,
1164
 
                                                  java_sources, 1,
1165
 
                                                  tmpdir->dir_name,
1166
 
                                                  false, false, false, true))
1167
 
                        /* $JAVAC compiled conftestfail.java successfully, and
1168
 
                           "$JAVAC -source $source_version" rejects it.  So the
1169
 
                           -source option is useful.  */
1170
 
                        resultp->source_option = true;
1171
 
                    }
1172
 
                }
1173
 
            }
1174
 
 
1175
 
          free (javac_source);
1176
 
 
1177
 
          resultp->usable = true;
1178
 
        }
 
1109
                                   java_sources, 1, tmpdir->dir_name,
 
1110
                                   false, false, false, true)
 
1111
          && stat (compiled_file_name, &statbuf) >= 0
 
1112
          && get_classfile_version (compiled_file_name)
 
1113
             <= corresponding_classfile_version (target_version))
 
1114
        {
 
1115
          /* $JAVAC compiled conftest.java successfully.  */
 
1116
          /* Try adding -source option if it is useful.  */
 
1117
          char *javac_source =
 
1118
            xasprintf ("%s -source %s", javac, source_version);
 
1119
 
 
1120
          unlink (compiled_file_name);
 
1121
 
 
1122
          java_sources[0] = conftest_file_name;
 
1123
          if (!compile_using_envjavac (javac_source,
 
1124
                                       java_sources, 1, tmpdir->dir_name,
 
1125
                                       false, false, false, true)
 
1126
              && stat (compiled_file_name, &statbuf) >= 0
 
1127
              && get_classfile_version (compiled_file_name)
 
1128
                 <= corresponding_classfile_version (target_version))
 
1129
            {
 
1130
              const char *failcode = get_failcode_snippet (source_version);
 
1131
 
 
1132
              if (failcode != NULL)
 
1133
                {
 
1134
                  free (compiled_file_name);
 
1135
                  free (conftest_file_name);
 
1136
 
 
1137
                  conftest_file_name =
 
1138
                    xconcatenated_filename (tmpdir->dir_name,
 
1139
                                            "conftestfail.java",
 
1140
                                            NULL);
 
1141
                  if (write_temp_file (tmpdir, conftest_file_name, failcode))
 
1142
                    {
 
1143
                      free (conftest_file_name);
 
1144
                      free (javac_source);
 
1145
                      cleanup_temp_dir (tmpdir);
 
1146
                      return true;
 
1147
                    }
 
1148
 
 
1149
                  compiled_file_name =
 
1150
                    xconcatenated_filename (tmpdir->dir_name,
 
1151
                                            "conftestfail.class",
 
1152
                                            NULL);
 
1153
                  register_temp_file (tmpdir, compiled_file_name);
 
1154
 
 
1155
                  java_sources[0] = conftest_file_name;
 
1156
                  if (!compile_using_envjavac (javac,
 
1157
                                               java_sources, 1,
 
1158
                                               tmpdir->dir_name,
 
1159
                                               false, false, false, true)
 
1160
                      && stat (compiled_file_name, &statbuf) >= 0)
 
1161
                    {
 
1162
                      unlink (compiled_file_name);
 
1163
 
 
1164
                      java_sources[0] = conftest_file_name;
 
1165
                      if (compile_using_envjavac (javac_source,
 
1166
                                                  java_sources, 1,
 
1167
                                                  tmpdir->dir_name,
 
1168
                                                  false, false, false, true))
 
1169
                        /* $JAVAC compiled conftestfail.java successfully, and
 
1170
                           "$JAVAC -source $source_version" rejects it.  So the
 
1171
                           -source option is useful.  */
 
1172
                        resultp->source_option = true;
 
1173
                    }
 
1174
                }
 
1175
            }
 
1176
 
 
1177
          free (javac_source);
 
1178
 
 
1179
          resultp->usable = true;
 
1180
        }
1179
1181
      else
1180
 
        {
1181
 
          /* Try with -target option alone. (Sun javac 1.3.1 has the -target
1182
 
             option but no -source option.)  */
1183
 
          char *javac_target =
1184
 
            xasprintf ("%s -target %s", javac, target_version);
1185
 
 
1186
 
          unlink (compiled_file_name);
1187
 
 
1188
 
          java_sources[0] = conftest_file_name;
1189
 
          if (!compile_using_envjavac (javac_target,
1190
 
                                       java_sources, 1, tmpdir->dir_name,
1191
 
                                       false, false, false, true)
1192
 
              && stat (compiled_file_name, &statbuf) >= 0
1193
 
              && get_classfile_version (compiled_file_name)
1194
 
                 <= corresponding_classfile_version (target_version))
1195
 
            {
1196
 
              /* "$JAVAC -target $target_version" compiled conftest.java
1197
 
                 successfully.  */
1198
 
              /* Try adding -source option if it is useful.  */
1199
 
              char *javac_target_source =
1200
 
                xasprintf ("%s -source %s", javac_target, source_version);
1201
 
 
1202
 
              unlink (compiled_file_name);
1203
 
 
1204
 
              java_sources[0] = conftest_file_name;
1205
 
              if (!compile_using_envjavac (javac_target_source,
1206
 
                                           java_sources, 1, tmpdir->dir_name,
1207
 
                                           false, false, false, true)
1208
 
                  && stat (compiled_file_name, &statbuf) >= 0
1209
 
                  && get_classfile_version (compiled_file_name)
1210
 
                     <= corresponding_classfile_version (target_version))
1211
 
                {
1212
 
                  const char *failcode = get_failcode_snippet (source_version);
1213
 
 
1214
 
                  if (failcode != NULL)
1215
 
                    {
1216
 
                      free (compiled_file_name);
1217
 
                      free (conftest_file_name);
1218
 
 
1219
 
                      conftest_file_name =
1220
 
                        concatenated_filename (tmpdir->dir_name,
1221
 
                                               "conftestfail.java",
1222
 
                                               NULL);
1223
 
                      if (write_temp_file (tmpdir, conftest_file_name,
1224
 
                                           failcode))
1225
 
                        {
1226
 
                          free (conftest_file_name);
1227
 
                          free (javac_target_source);
1228
 
                          free (javac_target);
1229
 
                          cleanup_temp_dir (tmpdir);
1230
 
                          return true;
1231
 
                        }
1232
 
 
1233
 
                      compiled_file_name =
1234
 
                        concatenated_filename (tmpdir->dir_name,
1235
 
                                               "conftestfail.class",
1236
 
                                               NULL);
1237
 
                      register_temp_file (tmpdir, compiled_file_name);
1238
 
 
1239
 
                      java_sources[0] = conftest_file_name;
1240
 
                      if (!compile_using_envjavac (javac_target,
1241
 
                                                   java_sources, 1,
1242
 
                                                   tmpdir->dir_name,
1243
 
                                                   false, false, false, true)
1244
 
                          && stat (compiled_file_name, &statbuf) >= 0)
1245
 
                        {
1246
 
                          unlink (compiled_file_name);
1247
 
 
1248
 
                          java_sources[0] = conftest_file_name;
1249
 
                          if (compile_using_envjavac (javac_target_source,
1250
 
                                                      java_sources, 1,
1251
 
                                                      tmpdir->dir_name,
1252
 
                                                      false, false, false,
1253
 
                                                      true))
1254
 
                            /* "$JAVAC -target $target_version" compiled
1255
 
                               conftestfail.java successfully, and
1256
 
                               "$JAVAC -target $target_version -source $source_version"
1257
 
                               rejects it.  So the -source option is useful.  */
1258
 
                            resultp->source_option = true;
1259
 
                        }
1260
 
                    }
1261
 
                }
1262
 
 
1263
 
              free (javac_target_source);
1264
 
 
1265
 
              resultp->target_option = true;
1266
 
              resultp->usable = true;
1267
 
            }
1268
 
          else
1269
 
            {
1270
 
              /* Maybe this -target option requires a -source option? Try with
1271
 
                 -target and -source options. (Supported by Sun javac 1.4 and
1272
 
                 higher.)  */
1273
 
              char *javac_target_source =
1274
 
                xasprintf ("%s -source %s", javac_target, source_version);
1275
 
 
1276
 
              unlink (compiled_file_name);
1277
 
 
1278
 
              java_sources[0] = conftest_file_name;
1279
 
              if (!compile_using_envjavac (javac_target_source,
1280
 
                                           java_sources, 1, tmpdir->dir_name,
1281
 
                                           false, false, false, true)
1282
 
                  && stat (compiled_file_name, &statbuf) >= 0
1283
 
                  && get_classfile_version (compiled_file_name)
1284
 
                     <= corresponding_classfile_version (target_version))
1285
 
                {
1286
 
                  /* "$JAVAC -target $target_version -source $source_version"
1287
 
                     compiled conftest.java successfully.  */
1288
 
                  resultp->source_option = true;
1289
 
                  resultp->target_option = true;
1290
 
                  resultp->usable = true;
1291
 
                }
1292
 
 
1293
 
              free (javac_target_source);
1294
 
            }
1295
 
 
1296
 
          free (javac_target);
1297
 
        }
 
1182
        {
 
1183
          /* Try with -target option alone. (Sun javac 1.3.1 has the -target
 
1184
             option but no -source option.)  */
 
1185
          char *javac_target =
 
1186
            xasprintf ("%s -target %s", javac, target_version);
 
1187
 
 
1188
          unlink (compiled_file_name);
 
1189
 
 
1190
          java_sources[0] = conftest_file_name;
 
1191
          if (!compile_using_envjavac (javac_target,
 
1192
                                       java_sources, 1, tmpdir->dir_name,
 
1193
                                       false, false, false, true)
 
1194
              && stat (compiled_file_name, &statbuf) >= 0
 
1195
              && get_classfile_version (compiled_file_name)
 
1196
                 <= corresponding_classfile_version (target_version))
 
1197
            {
 
1198
              /* "$JAVAC -target $target_version" compiled conftest.java
 
1199
                 successfully.  */
 
1200
              /* Try adding -source option if it is useful.  */
 
1201
              char *javac_target_source =
 
1202
                xasprintf ("%s -source %s", javac_target, source_version);
 
1203
 
 
1204
              unlink (compiled_file_name);
 
1205
 
 
1206
              java_sources[0] = conftest_file_name;
 
1207
              if (!compile_using_envjavac (javac_target_source,
 
1208
                                           java_sources, 1, tmpdir->dir_name,
 
1209
                                           false, false, false, true)
 
1210
                  && stat (compiled_file_name, &statbuf) >= 0
 
1211
                  && get_classfile_version (compiled_file_name)
 
1212
                     <= corresponding_classfile_version (target_version))
 
1213
                {
 
1214
                  const char *failcode = get_failcode_snippet (source_version);
 
1215
 
 
1216
                  if (failcode != NULL)
 
1217
                    {
 
1218
                      free (compiled_file_name);
 
1219
                      free (conftest_file_name);
 
1220
 
 
1221
                      conftest_file_name =
 
1222
                        xconcatenated_filename (tmpdir->dir_name,
 
1223
                                                "conftestfail.java",
 
1224
                                                NULL);
 
1225
                      if (write_temp_file (tmpdir, conftest_file_name,
 
1226
                                           failcode))
 
1227
                        {
 
1228
                          free (conftest_file_name);
 
1229
                          free (javac_target_source);
 
1230
                          free (javac_target);
 
1231
                          cleanup_temp_dir (tmpdir);
 
1232
                          return true;
 
1233
                        }
 
1234
 
 
1235
                      compiled_file_name =
 
1236
                        xconcatenated_filename (tmpdir->dir_name,
 
1237
                                                "conftestfail.class",
 
1238
                                                NULL);
 
1239
                      register_temp_file (tmpdir, compiled_file_name);
 
1240
 
 
1241
                      java_sources[0] = conftest_file_name;
 
1242
                      if (!compile_using_envjavac (javac_target,
 
1243
                                                   java_sources, 1,
 
1244
                                                   tmpdir->dir_name,
 
1245
                                                   false, false, false, true)
 
1246
                          && stat (compiled_file_name, &statbuf) >= 0)
 
1247
                        {
 
1248
                          unlink (compiled_file_name);
 
1249
 
 
1250
                          java_sources[0] = conftest_file_name;
 
1251
                          if (compile_using_envjavac (javac_target_source,
 
1252
                                                      java_sources, 1,
 
1253
                                                      tmpdir->dir_name,
 
1254
                                                      false, false, false,
 
1255
                                                      true))
 
1256
                            /* "$JAVAC -target $target_version" compiled
 
1257
                               conftestfail.java successfully, and
 
1258
                               "$JAVAC -target $target_version -source $source_version"
 
1259
                               rejects it.  So the -source option is useful.  */
 
1260
                            resultp->source_option = true;
 
1261
                        }
 
1262
                    }
 
1263
                }
 
1264
 
 
1265
              free (javac_target_source);
 
1266
 
 
1267
              resultp->target_option = true;
 
1268
              resultp->usable = true;
 
1269
            }
 
1270
          else
 
1271
            {
 
1272
              /* Maybe this -target option requires a -source option? Try with
 
1273
                 -target and -source options. (Supported by Sun javac 1.4 and
 
1274
                 higher.)  */
 
1275
              char *javac_target_source =
 
1276
                xasprintf ("%s -source %s", javac_target, source_version);
 
1277
 
 
1278
              unlink (compiled_file_name);
 
1279
 
 
1280
              java_sources[0] = conftest_file_name;
 
1281
              if (!compile_using_envjavac (javac_target_source,
 
1282
                                           java_sources, 1, tmpdir->dir_name,
 
1283
                                           false, false, false, true)
 
1284
                  && stat (compiled_file_name, &statbuf) >= 0
 
1285
                  && get_classfile_version (compiled_file_name)
 
1286
                     <= corresponding_classfile_version (target_version))
 
1287
                {
 
1288
                  /* "$JAVAC -target $target_version -source $source_version"
 
1289
                     compiled conftest.java successfully.  */
 
1290
                  resultp->source_option = true;
 
1291
                  resultp->target_option = true;
 
1292
                  resultp->usable = true;
 
1293
                }
 
1294
 
 
1295
              free (javac_target_source);
 
1296
            }
 
1297
 
 
1298
          free (javac_target);
 
1299
        }
1298
1300
 
1299
1301
      free (compiled_file_name);
1300
1302
      free (conftest_file_name);
1317
1319
  if (!gcj_tested)
1318
1320
    {
1319
1321
      /* Test for presence of gcj:
1320
 
         "gcj --version 2> /dev/null | \
1321
 
          sed -e 's,^[^0-9]*,,' -e 1q | \
1322
 
          sed -e '/^3\.[01]/d' | grep '^[3-9]' > /dev/null"  */
 
1322
         "gcj --version 2> /dev/null | \
 
1323
          sed -e 's,^[^0-9]*,,' -e 1q | \
 
1324
          sed -e '/^3\.[01]/d' | grep '^[3-9]' > /dev/null"  */
1323
1325
      char *argv[3];
1324
1326
      pid_t child;
1325
1327
      int fd[1];
1329
1331
      argv[1] = "--version";
1330
1332
      argv[2] = NULL;
1331
1333
      child = create_pipe_in ("gcj", "gcj", argv, DEV_NULL, true, true,
1332
 
                              false, fd);
 
1334
                              false, fd);
1333
1335
      gcj_present = false;
1334
1336
      if (child != -1)
1335
 
        {
1336
 
          /* Read the subprocess output, drop all lines except the first,
1337
 
             drop all characters before the first digit, and test whether
1338
 
             the remaining string starts with a digit >= 3, but not with
1339
 
             "3.0" or "3.1".  */
1340
 
          char c[3];
1341
 
          size_t count = 0;
1342
 
 
1343
 
          while (safe_read (fd[0], &c[count], 1) > 0)
1344
 
            {
1345
 
              if (c[count] == '\n')
1346
 
                break;
1347
 
              if (count == 0)
1348
 
                {
1349
 
                  if (!(c[0] >= '0' && c[0] <= '9'))
1350
 
                    continue;
1351
 
                  gcj_present = (c[0] >= '3');
1352
 
                }
1353
 
              count++;
1354
 
              if (count == 3)
1355
 
                {
1356
 
                  if (c[0] == '3' && c[1] == '.'
1357
 
                      && (c[2] == '0' || c[2] == '1'))
1358
 
                    gcj_present = false;
1359
 
                  break;
1360
 
                }
1361
 
            }
1362
 
          while (safe_read (fd[0], &c[0], 1) > 0)
1363
 
            ;
1364
 
 
1365
 
          close (fd[0]);
1366
 
 
1367
 
          /* Remove zombie process from process list, and retrieve exit
1368
 
             status.  */
1369
 
          exitstatus =
1370
 
            wait_subprocess (child, "gcj", false, true, true, false);
1371
 
          if (exitstatus != 0)
1372
 
            gcj_present = false;
1373
 
        }
 
1337
        {
 
1338
          /* Read the subprocess output, drop all lines except the first,
 
1339
             drop all characters before the first digit, and test whether
 
1340
             the remaining string starts with a digit >= 3, but not with
 
1341
             "3.0" or "3.1".  */
 
1342
          char c[3];
 
1343
          size_t count = 0;
 
1344
 
 
1345
          while (safe_read (fd[0], &c[count], 1) > 0)
 
1346
            {
 
1347
              if (c[count] == '\n')
 
1348
                break;
 
1349
              if (count == 0)
 
1350
                {
 
1351
                  if (!(c[0] >= '0' && c[0] <= '9'))
 
1352
                    continue;
 
1353
                  gcj_present = (c[0] >= '3');
 
1354
                }
 
1355
              count++;
 
1356
              if (count == 3)
 
1357
                {
 
1358
                  if (c[0] == '3' && c[1] == '.'
 
1359
                      && (c[2] == '0' || c[2] == '1'))
 
1360
                    gcj_present = false;
 
1361
                  break;
 
1362
                }
 
1363
            }
 
1364
          while (safe_read (fd[0], &c[0], 1) > 0)
 
1365
            ;
 
1366
 
 
1367
          close (fd[0]);
 
1368
 
 
1369
          /* Remove zombie process from process list, and retrieve exit
 
1370
             status.  */
 
1371
          exitstatus =
 
1372
            wait_subprocess (child, "gcj", false, true, true, false, NULL);
 
1373
          if (exitstatus != 0)
 
1374
            gcj_present = false;
 
1375
        }
1374
1376
 
1375
1377
      if (gcj_present)
1376
 
        {
1377
 
          /* See if libgcj.jar is well installed.  */
1378
 
          struct temp_dir *tmpdir;
1379
 
 
1380
 
          tmpdir = create_temp_dir ("java", NULL, false);
1381
 
          if (tmpdir == NULL)
1382
 
            gcj_present = false;
1383
 
          else
1384
 
            {
1385
 
              char *conftest_file_name;
1386
 
 
1387
 
              conftest_file_name =
1388
 
                concatenated_filename (tmpdir->dir_name, "conftestlib.java",
1389
 
                                       NULL);
1390
 
              if (write_temp_file (tmpdir, conftest_file_name,
 
1378
        {
 
1379
          /* See if libgcj.jar is well installed.  */
 
1380
          struct temp_dir *tmpdir;
 
1381
 
 
1382
          tmpdir = create_temp_dir ("java", NULL, false);
 
1383
          if (tmpdir == NULL)
 
1384
            gcj_present = false;
 
1385
          else
 
1386
            {
 
1387
              char *conftest_file_name;
 
1388
 
 
1389
              conftest_file_name =
 
1390
                xconcatenated_filename (tmpdir->dir_name, "conftestlib.java",
 
1391
                                        NULL);
 
1392
              if (write_temp_file (tmpdir, conftest_file_name,
1391
1393
"public class conftestlib {\n"
1392
1394
"  public static void main (String[] args) {\n"
1393
1395
"  }\n"
1394
1396
"}\n"))
1395
 
                gcj_present = false;
1396
 
              else
1397
 
                {
1398
 
                  char *compiled_file_name;
1399
 
                  const char *java_sources[1];
1400
 
 
1401
 
                  compiled_file_name =
1402
 
                    concatenated_filename (tmpdir->dir_name,
1403
 
                                           "conftestlib.class",
1404
 
                                           NULL);
1405
 
                  register_temp_file (tmpdir, compiled_file_name);
1406
 
 
1407
 
                  java_sources[0] = conftest_file_name;
1408
 
                  if (compile_using_gcj (java_sources, 1, false,
1409
 
                                         false, NULL, false, NULL,
1410
 
                                         tmpdir->dir_name,
1411
 
                                         false, false, false, true))
1412
 
                    gcj_present = false;
1413
 
 
1414
 
                  free (compiled_file_name);
1415
 
                }
1416
 
              free (conftest_file_name);
1417
 
            }
1418
 
          cleanup_temp_dir (tmpdir);
1419
 
        }
 
1397
                gcj_present = false;
 
1398
              else
 
1399
                {
 
1400
                  char *compiled_file_name;
 
1401
                  const char *java_sources[1];
 
1402
 
 
1403
                  compiled_file_name =
 
1404
                    xconcatenated_filename (tmpdir->dir_name,
 
1405
                                            "conftestlib.class",
 
1406
                                            NULL);
 
1407
                  register_temp_file (tmpdir, compiled_file_name);
 
1408
 
 
1409
                  java_sources[0] = conftest_file_name;
 
1410
                  if (compile_using_gcj (java_sources, 1, false,
 
1411
                                         false, NULL, false, NULL,
 
1412
                                         tmpdir->dir_name,
 
1413
                                         false, false, false, true))
 
1414
                    gcj_present = false;
 
1415
 
 
1416
                  free (compiled_file_name);
 
1417
                }
 
1418
              free (conftest_file_name);
 
1419
            }
 
1420
          cleanup_temp_dir (tmpdir);
 
1421
        }
1420
1422
 
1421
1423
      gcj_tested = true;
1422
1424
    }
1433
1435
  if (!gcj_tested)
1434
1436
    {
1435
1437
      /* Test for presence of gcj:
1436
 
         "gcj --version 2> /dev/null | \
1437
 
          sed -e 's,^[^0-9]*,,' -e 1q | \
1438
 
          sed -e '/^4\.[012]/d' | grep '^[4-9]'"  */
 
1438
         "gcj --version 2> /dev/null | \
 
1439
          sed -e 's,^[^0-9]*,,' -e 1q | \
 
1440
          sed -e '/^4\.[012]/d' | grep '^[4-9]'"  */
1439
1441
      char *argv[3];
1440
1442
      pid_t child;
1441
1443
      int fd[1];
1445
1447
      argv[1] = "--version";
1446
1448
      argv[2] = NULL;
1447
1449
      child = create_pipe_in ("gcj", "gcj", argv, DEV_NULL, true, true,
1448
 
                              false, fd);
 
1450
                              false, fd);
1449
1451
      gcj_43 = false;
1450
1452
      if (child != -1)
1451
 
        {
1452
 
          /* Read the subprocess output, drop all lines except the first,
1453
 
             drop all characters before the first digit, and test whether
1454
 
             the remaining string starts with a digit >= 4, but not with
1455
 
             "4.0" or "4.1" or "4.2".  */
1456
 
          char c[3];
1457
 
          size_t count = 0;
1458
 
 
1459
 
          while (safe_read (fd[0], &c[count], 1) > 0)
1460
 
            {
1461
 
              if (c[count] == '\n')
1462
 
                break;
1463
 
              if (count == 0)
1464
 
                {
1465
 
                  if (!(c[0] >= '0' && c[0] <= '9'))
1466
 
                    continue;
1467
 
                  gcj_43 = (c[0] >= '4');
1468
 
                }
1469
 
              count++;
1470
 
              if (count == 3)
1471
 
                {
1472
 
                  if (c[0] == '4' && c[1] == '.' && c[2] >= '0' && c[2] <= '2')
1473
 
                    gcj_43 = false;
1474
 
                  break;
1475
 
                }
1476
 
            }
1477
 
          while (safe_read (fd[0], &c[0], 1) > 0)
1478
 
            ;
1479
 
 
1480
 
          close (fd[0]);
1481
 
 
1482
 
          /* Remove zombie process from process list, and retrieve exit
1483
 
             status.  */
1484
 
          exitstatus =
1485
 
            wait_subprocess (child, "gcj", false, true, true, false);
1486
 
          if (exitstatus != 0)
1487
 
            gcj_43 = false;
1488
 
        }
 
1453
        {
 
1454
          /* Read the subprocess output, drop all lines except the first,
 
1455
             drop all characters before the first digit, and test whether
 
1456
             the remaining string starts with a digit >= 4, but not with
 
1457
             "4.0" or "4.1" or "4.2".  */
 
1458
          char c[3];
 
1459
          size_t count = 0;
 
1460
 
 
1461
          while (safe_read (fd[0], &c[count], 1) > 0)
 
1462
            {
 
1463
              if (c[count] == '\n')
 
1464
                break;
 
1465
              if (count == 0)
 
1466
                {
 
1467
                  if (!(c[0] >= '0' && c[0] <= '9'))
 
1468
                    continue;
 
1469
                  gcj_43 = (c[0] >= '4');
 
1470
                }
 
1471
              count++;
 
1472
              if (count == 3)
 
1473
                {
 
1474
                  if (c[0] == '4' && c[1] == '.' && c[2] >= '0' && c[2] <= '2')
 
1475
                    gcj_43 = false;
 
1476
                  break;
 
1477
                }
 
1478
            }
 
1479
          while (safe_read (fd[0], &c[0], 1) > 0)
 
1480
            ;
 
1481
 
 
1482
          close (fd[0]);
 
1483
 
 
1484
          /* Remove zombie process from process list, and retrieve exit
 
1485
             status.  */
 
1486
          exitstatus =
 
1487
            wait_subprocess (child, "gcj", false, true, true, false, NULL);
 
1488
          if (exitstatus != 0)
 
1489
            gcj_43 = false;
 
1490
        }
1489
1491
 
1490
1492
      gcj_tested = true;
1491
1493
    }
1498
1500
   Return a failure indicator (true upon error).  */
1499
1501
static bool
1500
1502
is_gcj43_usable (const char *source_version,
1501
 
                 const char *target_version,
1502
 
                 bool *usablep,
1503
 
                 bool *fsource_option_p, bool *ftarget_option_p)
 
1503
                 const char *target_version,
 
1504
                 bool *usablep,
 
1505
                 bool *fsource_option_p, bool *ftarget_option_p)
1504
1506
{
1505
1507
  /* The cache depends on the source_version and target_version.  */
1506
1508
  struct result_t
1514
1516
  struct result_t *resultp;
1515
1517
 
1516
1518
  resultp = &result_cache[source_version_index (source_version)]
1517
 
                         [target_version_index (target_version)];
 
1519
                         [target_version_index (target_version)];
1518
1520
  if (!resultp->tested)
1519
1521
    {
1520
1522
      /* Try gcj.  */
1526
1528
 
1527
1529
      tmpdir = create_temp_dir ("java", NULL, false);
1528
1530
      if (tmpdir == NULL)
1529
 
        return true;
 
1531
        return true;
1530
1532
 
1531
1533
      conftest_file_name =
1532
 
        concatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
 
1534
        xconcatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
1533
1535
      if (write_temp_file (tmpdir, conftest_file_name,
1534
 
                           get_goodcode_snippet (source_version)))
1535
 
        {
1536
 
          free (conftest_file_name);
1537
 
          cleanup_temp_dir (tmpdir);
1538
 
          return true;
1539
 
        }
 
1536
                           get_goodcode_snippet (source_version)))
 
1537
        {
 
1538
          free (conftest_file_name);
 
1539
          cleanup_temp_dir (tmpdir);
 
1540
          return true;
 
1541
        }
1540
1542
 
1541
1543
      compiled_file_name =
1542
 
        concatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
 
1544
        xconcatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
1543
1545
      register_temp_file (tmpdir, compiled_file_name);
1544
1546
 
1545
1547
      java_sources[0] = conftest_file_name;
1546
1548
      if (!compile_using_gcj (java_sources, 1, false, false, NULL, false, NULL,
1547
 
                              tmpdir->dir_name, false, false, false, true)
1548
 
          && stat (compiled_file_name, &statbuf) >= 0
1549
 
          && get_classfile_version (compiled_file_name)
1550
 
             <= corresponding_classfile_version (target_version))
1551
 
        {
1552
 
          /* gcj compiled conftest.java successfully.  */
1553
 
          /* Try adding -fsource option if it is useful.  */
1554
 
          unlink (compiled_file_name);
1555
 
 
1556
 
          java_sources[0] = conftest_file_name;
1557
 
          if (!compile_using_gcj (java_sources, 1,
1558
 
                                  false, true, source_version, false, NULL,
1559
 
                                  tmpdir->dir_name, false, false, false, true)
1560
 
              && stat (compiled_file_name, &statbuf) >= 0
1561
 
              && get_classfile_version (compiled_file_name)
1562
 
                 <= corresponding_classfile_version (target_version))
1563
 
            {
1564
 
              const char *failcode = get_failcode_snippet (source_version);
1565
 
 
1566
 
              if (failcode != NULL)
1567
 
                {
1568
 
                  free (compiled_file_name);
1569
 
                  free (conftest_file_name);
1570
 
 
1571
 
                  conftest_file_name =
1572
 
                    concatenated_filename (tmpdir->dir_name,
1573
 
                                           "conftestfail.java",
1574
 
                                           NULL);
1575
 
                  if (write_temp_file (tmpdir, conftest_file_name, failcode))
1576
 
                    {
1577
 
                      free (conftest_file_name);
1578
 
                      cleanup_temp_dir (tmpdir);
1579
 
                      return true;
1580
 
                    }
1581
 
 
1582
 
                  compiled_file_name =
1583
 
                    concatenated_filename (tmpdir->dir_name,
1584
 
                                           "conftestfail.class",
1585
 
                                           NULL);
1586
 
                  register_temp_file (tmpdir, compiled_file_name);
1587
 
 
1588
 
                  java_sources[0] = conftest_file_name;
1589
 
                  if (!compile_using_gcj (java_sources, 1,
1590
 
                                          false, false, NULL, false, NULL,
1591
 
                                          tmpdir->dir_name,
1592
 
                                          false, false, false, true)
1593
 
                      && stat (compiled_file_name, &statbuf) >= 0)
1594
 
                    {
1595
 
                      unlink (compiled_file_name);
1596
 
 
1597
 
                      java_sources[0] = conftest_file_name;
1598
 
                      if (compile_using_gcj (java_sources, 1,
1599
 
                                             false, true, source_version,
1600
 
                                             false, NULL,
1601
 
                                             tmpdir->dir_name,
1602
 
                                             false, false, false, true))
1603
 
                        /* gcj compiled conftestfail.java successfully, and
1604
 
                           "gcj -fsource=$source_version" rejects it.  So
1605
 
                           the -fsource option is useful.  */
1606
 
                        resultp->fsource_option = true;
1607
 
                    }
1608
 
                }
1609
 
            }
1610
 
 
1611
 
          resultp->usable = true;
1612
 
        }
 
1549
                              tmpdir->dir_name, false, false, false, true)
 
1550
          && stat (compiled_file_name, &statbuf) >= 0
 
1551
          && get_classfile_version (compiled_file_name)
 
1552
             <= corresponding_classfile_version (target_version))
 
1553
        {
 
1554
          /* gcj compiled conftest.java successfully.  */
 
1555
          /* Try adding -fsource option if it is useful.  */
 
1556
          unlink (compiled_file_name);
 
1557
 
 
1558
          java_sources[0] = conftest_file_name;
 
1559
          if (!compile_using_gcj (java_sources, 1,
 
1560
                                  false, true, source_version, false, NULL,
 
1561
                                  tmpdir->dir_name, false, false, false, true)
 
1562
              && stat (compiled_file_name, &statbuf) >= 0
 
1563
              && get_classfile_version (compiled_file_name)
 
1564
                 <= corresponding_classfile_version (target_version))
 
1565
            {
 
1566
              const char *failcode = get_failcode_snippet (source_version);
 
1567
 
 
1568
              if (failcode != NULL)
 
1569
                {
 
1570
                  free (compiled_file_name);
 
1571
                  free (conftest_file_name);
 
1572
 
 
1573
                  conftest_file_name =
 
1574
                    xconcatenated_filename (tmpdir->dir_name,
 
1575
                                            "conftestfail.java",
 
1576
                                            NULL);
 
1577
                  if (write_temp_file (tmpdir, conftest_file_name, failcode))
 
1578
                    {
 
1579
                      free (conftest_file_name);
 
1580
                      cleanup_temp_dir (tmpdir);
 
1581
                      return true;
 
1582
                    }
 
1583
 
 
1584
                  compiled_file_name =
 
1585
                    xconcatenated_filename (tmpdir->dir_name,
 
1586
                                            "conftestfail.class",
 
1587
                                            NULL);
 
1588
                  register_temp_file (tmpdir, compiled_file_name);
 
1589
 
 
1590
                  java_sources[0] = conftest_file_name;
 
1591
                  if (!compile_using_gcj (java_sources, 1,
 
1592
                                          false, false, NULL, false, NULL,
 
1593
                                          tmpdir->dir_name,
 
1594
                                          false, false, false, true)
 
1595
                      && stat (compiled_file_name, &statbuf) >= 0)
 
1596
                    {
 
1597
                      unlink (compiled_file_name);
 
1598
 
 
1599
                      java_sources[0] = conftest_file_name;
 
1600
                      if (compile_using_gcj (java_sources, 1,
 
1601
                                             false, true, source_version,
 
1602
                                             false, NULL,
 
1603
                                             tmpdir->dir_name,
 
1604
                                             false, false, false, true))
 
1605
                        /* gcj compiled conftestfail.java successfully, and
 
1606
                           "gcj -fsource=$source_version" rejects it.  So
 
1607
                           the -fsource option is useful.  */
 
1608
                        resultp->fsource_option = true;
 
1609
                    }
 
1610
                }
 
1611
            }
 
1612
 
 
1613
          resultp->usable = true;
 
1614
        }
1613
1615
      else
1614
 
        {
1615
 
          /* Try with -fsource and -ftarget options.  */
1616
 
          unlink (compiled_file_name);
 
1616
        {
 
1617
          /* Try with -fsource and -ftarget options.  */
 
1618
          unlink (compiled_file_name);
1617
1619
 
1618
 
          java_sources[0] = conftest_file_name;
1619
 
          if (!compile_using_gcj (java_sources, 1,
1620
 
                                  false, true, source_version,
1621
 
                                  true, target_version,
1622
 
                                  tmpdir->dir_name,
1623
 
                                  false, false, false, true)
1624
 
              && stat (compiled_file_name, &statbuf) >= 0
1625
 
              && get_classfile_version (compiled_file_name)
1626
 
                 <= corresponding_classfile_version (target_version))
1627
 
            {
1628
 
              /* "gcj -fsource $source_version -ftarget $target_version"
1629
 
                 compiled conftest.java successfully.  */
1630
 
              resultp->fsource_option = true;
1631
 
              resultp->ftarget_option = true;
1632
 
              resultp->usable = true;
1633
 
            }
1634
 
        }
 
1620
          java_sources[0] = conftest_file_name;
 
1621
          if (!compile_using_gcj (java_sources, 1,
 
1622
                                  false, true, source_version,
 
1623
                                  true, target_version,
 
1624
                                  tmpdir->dir_name,
 
1625
                                  false, false, false, true)
 
1626
              && stat (compiled_file_name, &statbuf) >= 0
 
1627
              && get_classfile_version (compiled_file_name)
 
1628
                 <= corresponding_classfile_version (target_version))
 
1629
            {
 
1630
              /* "gcj -fsource $source_version -ftarget $target_version"
 
1631
                 compiled conftest.java successfully.  */
 
1632
              resultp->fsource_option = true;
 
1633
              resultp->ftarget_option = true;
 
1634
              resultp->usable = true;
 
1635
            }
 
1636
        }
1635
1637
 
1636
1638
      free (compiled_file_name);
1637
1639
      free (conftest_file_name);
1665
1667
 
1666
1668
      tmpdir = create_temp_dir ("java", NULL, false);
1667
1669
      if (tmpdir == NULL)
1668
 
        return true;
 
1670
        return true;
1669
1671
 
1670
1672
      conftest_file_name =
1671
 
        concatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
 
1673
        xconcatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
1672
1674
      if (write_temp_file (tmpdir, conftest_file_name,
1673
 
                           get_goodcode_snippet ("1.4")))
1674
 
        {
1675
 
          free (conftest_file_name);
1676
 
          cleanup_temp_dir (tmpdir);
1677
 
          return true;
1678
 
        }
 
1675
                           get_goodcode_snippet ("1.4")))
 
1676
        {
 
1677
          free (conftest_file_name);
 
1678
          cleanup_temp_dir (tmpdir);
 
1679
          return true;
 
1680
        }
1679
1681
 
1680
1682
      compiled_file_name =
1681
 
        concatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
 
1683
        xconcatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
1682
1684
      register_temp_file (tmpdir, compiled_file_name);
1683
1685
 
1684
1686
      java_sources[0] = conftest_file_name;
1685
1687
      if (!compile_using_gcj (java_sources, 1, false, false, NULL, false, NULL,
1686
 
                              tmpdir->dir_name, false, false, false, true)
1687
 
          && stat (compiled_file_name, &statbuf) >= 0)
1688
 
        /* Compilation succeeded.  */
1689
 
        gcj_usable = true;
 
1688
                              tmpdir->dir_name, false, false, false, true)
 
1689
          && stat (compiled_file_name, &statbuf) >= 0)
 
1690
        /* Compilation succeeded.  */
 
1691
        gcj_usable = true;
1690
1692
 
1691
1693
      free (compiled_file_name);
1692
1694
      free (conftest_file_name);
1713
1715
  if (!gcj_tested)
1714
1716
    {
1715
1717
      /* Try gcj and "gcj -fno-assert".  But add -fno-assert only if
1716
 
         it works (not gcj < 3.3).  */
 
1718
         it works (not gcj < 3.3).  */
1717
1719
      struct temp_dir *tmpdir;
1718
1720
      char *conftest_file_name;
1719
1721
      char *compiled_file_name;
1722
1724
 
1723
1725
      tmpdir = create_temp_dir ("java", NULL, false);
1724
1726
      if (tmpdir == NULL)
1725
 
        return true;
 
1727
        return true;
1726
1728
 
1727
1729
      conftest_file_name =
1728
 
        concatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
 
1730
        xconcatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
1729
1731
      if (write_temp_file (tmpdir, conftest_file_name,
1730
 
                           get_goodcode_snippet ("1.3")))
1731
 
        {
1732
 
          free (conftest_file_name);
1733
 
          cleanup_temp_dir (tmpdir);
1734
 
          return true;
1735
 
        }
 
1732
                           get_goodcode_snippet ("1.3")))
 
1733
        {
 
1734
          free (conftest_file_name);
 
1735
          cleanup_temp_dir (tmpdir);
 
1736
          return true;
 
1737
        }
1736
1738
 
1737
1739
      compiled_file_name =
1738
 
        concatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
 
1740
        xconcatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
1739
1741
      register_temp_file (tmpdir, compiled_file_name);
1740
1742
 
1741
1743
      java_sources[0] = conftest_file_name;
1742
1744
      if (!compile_using_gcj (java_sources, 1, true, false, NULL, false, NULL,
1743
 
                              tmpdir->dir_name, false, false, false, true)
1744
 
          && stat (compiled_file_name, &statbuf) >= 0)
1745
 
        /* Compilation succeeded.  */
1746
 
        {
1747
 
          gcj_usable = true;
1748
 
          gcj_need_no_assert_option = true;
1749
 
        }
 
1745
                              tmpdir->dir_name, false, false, false, true)
 
1746
          && stat (compiled_file_name, &statbuf) >= 0)
 
1747
        /* Compilation succeeded.  */
 
1748
        {
 
1749
          gcj_usable = true;
 
1750
          gcj_need_no_assert_option = true;
 
1751
        }
1750
1752
      else
1751
 
        {
1752
 
          unlink (compiled_file_name);
 
1753
        {
 
1754
          unlink (compiled_file_name);
1753
1755
 
1754
 
          java_sources[0] = conftest_file_name;
1755
 
          if (!compile_using_gcj (java_sources, 1, false,
1756
 
                                  false, NULL, false, NULL,
1757
 
                                  tmpdir->dir_name, false, false, false, true)
1758
 
              && stat (compiled_file_name, &statbuf) >= 0)
1759
 
            /* Compilation succeeded.  */
1760
 
            {
1761
 
              gcj_usable = true;
1762
 
              gcj_need_no_assert_option = false;
1763
 
            }
1764
 
        }
 
1756
          java_sources[0] = conftest_file_name;
 
1757
          if (!compile_using_gcj (java_sources, 1, false,
 
1758
                                  false, NULL, false, NULL,
 
1759
                                  tmpdir->dir_name, false, false, false, true)
 
1760
              && stat (compiled_file_name, &statbuf) >= 0)
 
1761
            /* Compilation succeeded.  */
 
1762
            {
 
1763
              gcj_usable = true;
 
1764
              gcj_need_no_assert_option = false;
 
1765
            }
 
1766
        }
1765
1767
 
1766
1768
      free (compiled_file_name);
1767
1769
      free (conftest_file_name);
1791
1793
      argv[0] = "javac";
1792
1794
      argv[1] = NULL;
1793
1795
      exitstatus = execute ("javac", "javac", argv, false, false, true, true,
1794
 
                            true, false);
 
1796
                            true, false, NULL);
1795
1797
      javac_present = (exitstatus == 0 || exitstatus == 1 || exitstatus == 2);
1796
1798
      javac_tested = true;
1797
1799
    }
1804
1806
   Return a failure indicator (true upon error).  */
1805
1807
static bool
1806
1808
is_javac_usable (const char *source_version, const char *target_version,
1807
 
                 bool *usablep, bool *source_option_p, bool *target_option_p)
 
1809
                 bool *usablep, bool *source_option_p, bool *target_option_p)
1808
1810
{
1809
1811
  /* The cache depends on the source_version and target_version.  */
1810
1812
  struct result_t
1818
1820
  struct result_t *resultp;
1819
1821
 
1820
1822
  resultp = &result_cache[source_version_index (source_version)]
1821
 
                         [target_version_index (target_version)];
 
1823
                         [target_version_index (target_version)];
1822
1824
  if (!resultp->tested)
1823
1825
    {
1824
1826
      /* Try javac.  */
1830
1832
 
1831
1833
      tmpdir = create_temp_dir ("java", NULL, false);
1832
1834
      if (tmpdir == NULL)
1833
 
        return true;
 
1835
        return true;
1834
1836
 
1835
1837
      conftest_file_name =
1836
 
        concatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
 
1838
        xconcatenated_filename (tmpdir->dir_name, "conftest.java", NULL);
1837
1839
      if (write_temp_file (tmpdir, conftest_file_name,
1838
 
                           get_goodcode_snippet (source_version)))
1839
 
        {
1840
 
          free (conftest_file_name);
1841
 
          cleanup_temp_dir (tmpdir);
1842
 
          return true;
1843
 
        }
 
1840
                           get_goodcode_snippet (source_version)))
 
1841
        {
 
1842
          free (conftest_file_name);
 
1843
          cleanup_temp_dir (tmpdir);
 
1844
          return true;
 
1845
        }
1844
1846
 
1845
1847
      compiled_file_name =
1846
 
        concatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
 
1848
        xconcatenated_filename (tmpdir->dir_name, "conftest.class", NULL);
1847
1849
      register_temp_file (tmpdir, compiled_file_name);
1848
1850
 
1849
1851
      java_sources[0] = conftest_file_name;
1850
1852
      if (!compile_using_javac (java_sources, 1,
1851
 
                                false, source_version,
1852
 
                                false, target_version,
1853
 
                                tmpdir->dir_name, false, false, false, true)
1854
 
          && stat (compiled_file_name, &statbuf) >= 0
1855
 
          && get_classfile_version (compiled_file_name)
1856
 
             <= corresponding_classfile_version (target_version))
1857
 
        {
1858
 
          /* javac compiled conftest.java successfully.  */
1859
 
          /* Try adding -source option if it is useful.  */
1860
 
          unlink (compiled_file_name);
1861
 
 
1862
 
          java_sources[0] = conftest_file_name;
1863
 
          if (!compile_using_javac (java_sources, 1,
1864
 
                                    true, source_version,
1865
 
                                    false, target_version,
1866
 
                                    tmpdir->dir_name, false, false, false, true)
1867
 
              && stat (compiled_file_name, &statbuf) >= 0
1868
 
              && get_classfile_version (compiled_file_name)
1869
 
                 <= corresponding_classfile_version (target_version))
1870
 
            {
1871
 
              const char *failcode = get_failcode_snippet (source_version);
1872
 
 
1873
 
              if (failcode != NULL)
1874
 
                {
1875
 
                  free (compiled_file_name);
1876
 
                  free (conftest_file_name);
1877
 
 
1878
 
                  conftest_file_name =
1879
 
                    concatenated_filename (tmpdir->dir_name,
1880
 
                                           "conftestfail.java",
1881
 
                                           NULL);
1882
 
                  if (write_temp_file (tmpdir, conftest_file_name, failcode))
1883
 
                    {
1884
 
                      free (conftest_file_name);
1885
 
                      cleanup_temp_dir (tmpdir);
1886
 
                      return true;
1887
 
                    }
1888
 
 
1889
 
                  compiled_file_name =
1890
 
                    concatenated_filename (tmpdir->dir_name,
1891
 
                                           "conftestfail.class",
1892
 
                                           NULL);
1893
 
                  register_temp_file (tmpdir, compiled_file_name);
1894
 
 
1895
 
                  java_sources[0] = conftest_file_name;
1896
 
                  if (!compile_using_javac (java_sources, 1,
1897
 
                                            false, source_version,
1898
 
                                            false, target_version,
1899
 
                                            tmpdir->dir_name,
1900
 
                                            false, false, false, true)
1901
 
                      && stat (compiled_file_name, &statbuf) >= 0)
1902
 
                    {
1903
 
                      unlink (compiled_file_name);
1904
 
 
1905
 
                      java_sources[0] = conftest_file_name;
1906
 
                      if (compile_using_javac (java_sources, 1,
1907
 
                                               true, source_version,
1908
 
                                               false, target_version,
1909
 
                                               tmpdir->dir_name,
1910
 
                                               false, false, false, true))
1911
 
                        /* javac compiled conftestfail.java successfully, and
1912
 
                           "javac -source $source_version" rejects it.  So the
1913
 
                           -source option is useful.  */
1914
 
                        resultp->source_option = true;
1915
 
                    }
1916
 
                }
1917
 
            }
1918
 
 
1919
 
          resultp->usable = true;
1920
 
        }
 
1853
                                false, source_version,
 
1854
                                false, target_version,
 
1855
                                tmpdir->dir_name, false, false, false, true)
 
1856
          && stat (compiled_file_name, &statbuf) >= 0
 
1857
          && get_classfile_version (compiled_file_name)
 
1858
             <= corresponding_classfile_version (target_version))
 
1859
        {
 
1860
          /* javac compiled conftest.java successfully.  */
 
1861
          /* Try adding -source option if it is useful.  */
 
1862
          unlink (compiled_file_name);
 
1863
 
 
1864
          java_sources[0] = conftest_file_name;
 
1865
          if (!compile_using_javac (java_sources, 1,
 
1866
                                    true, source_version,
 
1867
                                    false, target_version,
 
1868
                                    tmpdir->dir_name, false, false, false, true)
 
1869
              && stat (compiled_file_name, &statbuf) >= 0
 
1870
              && get_classfile_version (compiled_file_name)
 
1871
                 <= corresponding_classfile_version (target_version))
 
1872
            {
 
1873
              const char *failcode = get_failcode_snippet (source_version);
 
1874
 
 
1875
              if (failcode != NULL)
 
1876
                {
 
1877
                  free (compiled_file_name);
 
1878
                  free (conftest_file_name);
 
1879
 
 
1880
                  conftest_file_name =
 
1881
                    xconcatenated_filename (tmpdir->dir_name,
 
1882
                                            "conftestfail.java",
 
1883
                                            NULL);
 
1884
                  if (write_temp_file (tmpdir, conftest_file_name, failcode))
 
1885
                    {
 
1886
                      free (conftest_file_name);
 
1887
                      cleanup_temp_dir (tmpdir);
 
1888
                      return true;
 
1889
                    }
 
1890
 
 
1891
                  compiled_file_name =
 
1892
                    xconcatenated_filename (tmpdir->dir_name,
 
1893
                                            "conftestfail.class",
 
1894
                                            NULL);
 
1895
                  register_temp_file (tmpdir, compiled_file_name);
 
1896
 
 
1897
                  java_sources[0] = conftest_file_name;
 
1898
                  if (!compile_using_javac (java_sources, 1,
 
1899
                                            false, source_version,
 
1900
                                            false, target_version,
 
1901
                                            tmpdir->dir_name,
 
1902
                                            false, false, false, true)
 
1903
                      && stat (compiled_file_name, &statbuf) >= 0)
 
1904
                    {
 
1905
                      unlink (compiled_file_name);
 
1906
 
 
1907
                      java_sources[0] = conftest_file_name;
 
1908
                      if (compile_using_javac (java_sources, 1,
 
1909
                                               true, source_version,
 
1910
                                               false, target_version,
 
1911
                                               tmpdir->dir_name,
 
1912
                                               false, false, false, true))
 
1913
                        /* javac compiled conftestfail.java successfully, and
 
1914
                           "javac -source $source_version" rejects it.  So the
 
1915
                           -source option is useful.  */
 
1916
                        resultp->source_option = true;
 
1917
                    }
 
1918
                }
 
1919
            }
 
1920
 
 
1921
          resultp->usable = true;
 
1922
        }
1921
1923
      else
1922
 
        {
1923
 
          /* Try with -target option alone. (Sun javac 1.3.1 has the -target
1924
 
             option but no -source option.)  */
1925
 
          unlink (compiled_file_name);
1926
 
 
1927
 
          java_sources[0] = conftest_file_name;
1928
 
          if (!compile_using_javac (java_sources, 1,
1929
 
                                    false, source_version,
1930
 
                                    true, target_version,
1931
 
                                    tmpdir->dir_name,
1932
 
                                    false, false, false, true)
1933
 
              && stat (compiled_file_name, &statbuf) >= 0
1934
 
              && get_classfile_version (compiled_file_name)
1935
 
                 <= corresponding_classfile_version (target_version))
1936
 
            {
1937
 
              /* "javac -target $target_version" compiled conftest.java
1938
 
                 successfully.  */
1939
 
              /* Try adding -source option if it is useful.  */
1940
 
              unlink (compiled_file_name);
1941
 
 
1942
 
              java_sources[0] = conftest_file_name;
1943
 
              if (!compile_using_javac (java_sources, 1,
1944
 
                                        true, source_version,
1945
 
                                        true, target_version,
1946
 
                                        tmpdir->dir_name,
1947
 
                                        false, false, false, true)
1948
 
                  && stat (compiled_file_name, &statbuf) >= 0
1949
 
                  && get_classfile_version (compiled_file_name)
1950
 
                     <= corresponding_classfile_version (target_version))
1951
 
                {
1952
 
                  const char *failcode = get_failcode_snippet (source_version);
1953
 
 
1954
 
                  if (failcode != NULL)
1955
 
                    {
1956
 
                      free (compiled_file_name);
1957
 
                      free (conftest_file_name);
1958
 
 
1959
 
                      conftest_file_name =
1960
 
                        concatenated_filename (tmpdir->dir_name,
1961
 
                                               "conftestfail.java",
1962
 
                                               NULL);
1963
 
                      if (write_temp_file (tmpdir, conftest_file_name,
1964
 
                                           failcode))
1965
 
                        {
1966
 
                          free (conftest_file_name);
1967
 
                          cleanup_temp_dir (tmpdir);
1968
 
                          return true;
1969
 
                        }
1970
 
 
1971
 
                      compiled_file_name =
1972
 
                        concatenated_filename (tmpdir->dir_name,
1973
 
                                               "conftestfail.class",
1974
 
                                               NULL);
1975
 
                      register_temp_file (tmpdir, compiled_file_name);
1976
 
 
1977
 
                      java_sources[0] = conftest_file_name;
1978
 
                      if (!compile_using_javac (java_sources, 1,
1979
 
                                                false, source_version,
1980
 
                                                true, target_version,
1981
 
                                                tmpdir->dir_name,
1982
 
                                                false, false, false, true)
1983
 
                          && stat (compiled_file_name, &statbuf) >= 0)
1984
 
                        {
1985
 
                          unlink (compiled_file_name);
1986
 
 
1987
 
                          java_sources[0] = conftest_file_name;
1988
 
                          if (compile_using_javac (java_sources, 1,
1989
 
                                                   true, source_version,
1990
 
                                                   true, target_version,
1991
 
                                                   tmpdir->dir_name,
1992
 
                                                   false, false, false, true))
1993
 
                            /* "javac -target $target_version" compiled
1994
 
                               conftestfail.java successfully, and
1995
 
                               "javac -target $target_version -source $source_version"
1996
 
                               rejects it.  So the -source option is useful.  */
1997
 
                            resultp->source_option = true;
1998
 
                        }
1999
 
                    }
2000
 
                }
2001
 
 
2002
 
              resultp->target_option = true;
2003
 
              resultp->usable = true;
2004
 
            }
2005
 
          else
2006
 
            {
2007
 
              /* Maybe this -target option requires a -source option? Try with
2008
 
                 -target and -source options. (Supported by Sun javac 1.4 and
2009
 
                 higher.)  */
2010
 
              unlink (compiled_file_name);
2011
 
 
2012
 
              java_sources[0] = conftest_file_name;
2013
 
              if (!compile_using_javac (java_sources, 1,
2014
 
                                        true, source_version,
2015
 
                                        true, target_version,
2016
 
                                        tmpdir->dir_name,
2017
 
                                        false, false, false, true)
2018
 
                  && stat (compiled_file_name, &statbuf) >= 0
2019
 
                  && get_classfile_version (compiled_file_name)
2020
 
                     <= corresponding_classfile_version (target_version))
2021
 
                {
2022
 
                  /* "javac -target $target_version -source $source_version"
2023
 
                     compiled conftest.java successfully.  */
2024
 
                  resultp->source_option = true;
2025
 
                  resultp->target_option = true;
2026
 
                  resultp->usable = true;
2027
 
                }
2028
 
            }
2029
 
        }
 
1924
        {
 
1925
          /* Try with -target option alone. (Sun javac 1.3.1 has the -target
 
1926
             option but no -source option.)  */
 
1927
          unlink (compiled_file_name);
 
1928
 
 
1929
          java_sources[0] = conftest_file_name;
 
1930
          if (!compile_using_javac (java_sources, 1,
 
1931
                                    false, source_version,
 
1932
                                    true, target_version,
 
1933
                                    tmpdir->dir_name,
 
1934
                                    false, false, false, true)
 
1935
              && stat (compiled_file_name, &statbuf) >= 0
 
1936
              && get_classfile_version (compiled_file_name)
 
1937
                 <= corresponding_classfile_version (target_version))
 
1938
            {
 
1939
              /* "javac -target $target_version" compiled conftest.java
 
1940
                 successfully.  */
 
1941
              /* Try adding -source option if it is useful.  */
 
1942
              unlink (compiled_file_name);
 
1943
 
 
1944
              java_sources[0] = conftest_file_name;
 
1945
              if (!compile_using_javac (java_sources, 1,
 
1946
                                        true, source_version,
 
1947
                                        true, target_version,
 
1948
                                        tmpdir->dir_name,
 
1949
                                        false, false, false, true)
 
1950
                  && stat (compiled_file_name, &statbuf) >= 0
 
1951
                  && get_classfile_version (compiled_file_name)
 
1952
                     <= corresponding_classfile_version (target_version))
 
1953
                {
 
1954
                  const char *failcode = get_failcode_snippet (source_version);
 
1955
 
 
1956
                  if (failcode != NULL)
 
1957
                    {
 
1958
                      free (compiled_file_name);
 
1959
                      free (conftest_file_name);
 
1960
 
 
1961
                      conftest_file_name =
 
1962
                        xconcatenated_filename (tmpdir->dir_name,
 
1963
                                                "conftestfail.java",
 
1964
                                                NULL);
 
1965
                      if (write_temp_file (tmpdir, conftest_file_name,
 
1966
                                           failcode))
 
1967
                        {
 
1968
                          free (conftest_file_name);
 
1969
                          cleanup_temp_dir (tmpdir);
 
1970
                          return true;
 
1971
                        }
 
1972
 
 
1973
                      compiled_file_name =
 
1974
                        xconcatenated_filename (tmpdir->dir_name,
 
1975
                                                "conftestfail.class",
 
1976
                                                NULL);
 
1977
                      register_temp_file (tmpdir, compiled_file_name);
 
1978
 
 
1979
                      java_sources[0] = conftest_file_name;
 
1980
                      if (!compile_using_javac (java_sources, 1,
 
1981
                                                false, source_version,
 
1982
                                                true, target_version,
 
1983
                                                tmpdir->dir_name,
 
1984
                                                false, false, false, true)
 
1985
                          && stat (compiled_file_name, &statbuf) >= 0)
 
1986
                        {
 
1987
                          unlink (compiled_file_name);
 
1988
 
 
1989
                          java_sources[0] = conftest_file_name;
 
1990
                          if (compile_using_javac (java_sources, 1,
 
1991
                                                   true, source_version,
 
1992
                                                   true, target_version,
 
1993
                                                   tmpdir->dir_name,
 
1994
                                                   false, false, false, true))
 
1995
                            /* "javac -target $target_version" compiled
 
1996
                               conftestfail.java successfully, and
 
1997
                               "javac -target $target_version -source $source_version"
 
1998
                               rejects it.  So the -source option is useful.  */
 
1999
                            resultp->source_option = true;
 
2000
                        }
 
2001
                    }
 
2002
                }
 
2003
 
 
2004
              resultp->target_option = true;
 
2005
              resultp->usable = true;
 
2006
            }
 
2007
          else
 
2008
            {
 
2009
              /* Maybe this -target option requires a -source option? Try with
 
2010
                 -target and -source options. (Supported by Sun javac 1.4 and
 
2011
                 higher.)  */
 
2012
              unlink (compiled_file_name);
 
2013
 
 
2014
              java_sources[0] = conftest_file_name;
 
2015
              if (!compile_using_javac (java_sources, 1,
 
2016
                                        true, source_version,
 
2017
                                        true, target_version,
 
2018
                                        tmpdir->dir_name,
 
2019
                                        false, false, false, true)
 
2020
                  && stat (compiled_file_name, &statbuf) >= 0
 
2021
                  && get_classfile_version (compiled_file_name)
 
2022
                     <= corresponding_classfile_version (target_version))
 
2023
                {
 
2024
                  /* "javac -target $target_version -source $source_version"
 
2025
                     compiled conftest.java successfully.  */
 
2026
                  resultp->source_option = true;
 
2027
                  resultp->target_option = true;
 
2028
                  resultp->usable = true;
 
2029
                }
 
2030
            }
 
2031
        }
2030
2032
 
2031
2033
      free (compiled_file_name);
2032
2034
      free (conftest_file_name);
2055
2057
      argv[0] = "jikes";
2056
2058
      argv[1] = NULL;
2057
2059
      exitstatus = execute ("jikes", "jikes", argv, false, false, true, true,
2058
 
                            true, false);
 
2060
                            true, false, NULL);
2059
2061
      jikes_present = (exitstatus == 0 || exitstatus == 1);
2060
2062
      jikes_tested = true;
2061
2063
    }
2067
2069
 
2068
2070
bool
2069
2071
compile_java_class (const char * const *java_sources,
2070
 
                    unsigned int java_sources_count,
2071
 
                    const char * const *classpaths,
2072
 
                    unsigned int classpaths_count,
2073
 
                    const char *source_version,
2074
 
                    const char *target_version,
2075
 
                    const char *directory,
2076
 
                    bool optimize, bool debug,
2077
 
                    bool use_minimal_classpath,
2078
 
                    bool verbose)
 
2072
                    unsigned int java_sources_count,
 
2073
                    const char * const *classpaths,
 
2074
                    unsigned int classpaths_count,
 
2075
                    const char *source_version,
 
2076
                    const char *target_version,
 
2077
                    const char *directory,
 
2078
                    bool optimize, bool debug,
 
2079
                    bool use_minimal_classpath,
 
2080
                    bool verbose)
2079
2081
{
2080
2082
  bool err = false;
2081
2083
  char *old_JAVA_HOME;
2084
2086
    const char *javac = getenv ("JAVAC");
2085
2087
    if (javac != NULL && javac[0] != '\0')
2086
2088
      {
2087
 
        bool usable = false;
2088
 
        bool no_assert_option = false;
2089
 
        bool source_option = false;
2090
 
        bool target_option = false;
2091
 
        bool fsource_option = false;
2092
 
        bool ftarget_option = false;
2093
 
 
2094
 
        if (target_version == NULL)
2095
 
          target_version = default_target_version ();
2096
 
 
2097
 
        if (is_envjavac_gcj (javac))
2098
 
          {
2099
 
            /* It's a version of gcj.  */
2100
 
            if (is_envjavac_gcj43 (javac))
2101
 
              {
2102
 
                /* It's a version of gcj >= 4.3.  Assume the classfile versions
2103
 
                   are correct.  */
2104
 
                if (is_envjavac_gcj43_usable (javac,
2105
 
                                              source_version, target_version,
2106
 
                                              &usable,
2107
 
                                              &fsource_option, &ftarget_option))
2108
 
                  {
2109
 
                    err = true;
2110
 
                    goto done1;
2111
 
                  }
2112
 
              }
2113
 
            else
2114
 
              {
2115
 
                /* It's a version of gcj < 4.3.  Ignore the version of the
2116
 
                   class files that it creates.  */
2117
 
                if (strcmp (target_version, "1.4") == 0
2118
 
                    && strcmp (source_version, "1.4") == 0)
2119
 
                  {
2120
 
                    if (is_envjavac_oldgcj_14_14_usable (javac, &usable))
2121
 
                      {
2122
 
                        err = true;
2123
 
                        goto done1;
2124
 
                      }
2125
 
                  }
2126
 
                else if (strcmp (target_version, "1.4") == 0
2127
 
                         && strcmp (source_version, "1.3") == 0)
2128
 
                  {
2129
 
                    if (is_envjavac_oldgcj_14_13_usable (javac,
2130
 
                                                         &usable,
2131
 
                                                         &no_assert_option))
2132
 
                      {
2133
 
                        err = true;
2134
 
                        goto done1;
2135
 
                      }
2136
 
                  }
2137
 
              }
2138
 
          }
2139
 
        else
2140
 
          {
2141
 
            /* It's not gcj.  Assume the classfile versions are correct.  */
2142
 
            if (is_envjavac_nongcj_usable (javac,
2143
 
                                           source_version, target_version,
2144
 
                                           &usable,
2145
 
                                           &source_option, &target_option))
2146
 
              {
2147
 
                err = true;
2148
 
                goto done1;
2149
 
              }
2150
 
          }
2151
 
 
2152
 
        if (usable)
2153
 
          {
2154
 
            char *old_classpath;
2155
 
            char *javac_with_options;
2156
 
 
2157
 
            /* Set CLASSPATH.  */
2158
 
            old_classpath =
2159
 
              set_classpath (classpaths, classpaths_count, false, verbose);
2160
 
 
2161
 
            javac_with_options =
2162
 
              (no_assert_option
2163
 
               ? xasprintf ("%s -fno-assert", javac)
2164
 
               : xasprintf ("%s%s%s%s%s%s%s%s%s",
2165
 
                            javac,
2166
 
                            source_option ? " -source " : "",
2167
 
                            source_option ? source_version : "",
2168
 
                            target_option ? " -target " : "",
2169
 
                            target_option ? target_version : "",
2170
 
                            fsource_option ? " -fsource=" : "",
2171
 
                            fsource_option ? source_version : "",
2172
 
                            ftarget_option ? " -ftarget=" : "",
2173
 
                            ftarget_option ? target_version : ""));
2174
 
 
2175
 
            err = compile_using_envjavac (javac_with_options,
2176
 
                                          java_sources, java_sources_count,
2177
 
                                          directory, optimize, debug, verbose,
2178
 
                                          false);
2179
 
 
2180
 
            free (javac_with_options);
2181
 
 
2182
 
            /* Reset CLASSPATH.  */
2183
 
            reset_classpath (old_classpath);
2184
 
 
2185
 
            goto done1;
2186
 
          }
 
2089
        bool usable = false;
 
2090
        bool no_assert_option = false;
 
2091
        bool source_option = false;
 
2092
        bool target_option = false;
 
2093
        bool fsource_option = false;
 
2094
        bool ftarget_option = false;
 
2095
 
 
2096
        if (target_version == NULL)
 
2097
          target_version = default_target_version ();
 
2098
 
 
2099
        if (is_envjavac_gcj (javac))
 
2100
          {
 
2101
            /* It's a version of gcj.  */
 
2102
            if (is_envjavac_gcj43 (javac))
 
2103
              {
 
2104
                /* It's a version of gcj >= 4.3.  Assume the classfile versions
 
2105
                   are correct.  */
 
2106
                if (is_envjavac_gcj43_usable (javac,
 
2107
                                              source_version, target_version,
 
2108
                                              &usable,
 
2109
                                              &fsource_option, &ftarget_option))
 
2110
                  {
 
2111
                    err = true;
 
2112
                    goto done1;
 
2113
                  }
 
2114
              }
 
2115
            else
 
2116
              {
 
2117
                /* It's a version of gcj < 4.3.  Ignore the version of the
 
2118
                   class files that it creates.  */
 
2119
                if (strcmp (target_version, "1.4") == 0
 
2120
                    && strcmp (source_version, "1.4") == 0)
 
2121
                  {
 
2122
                    if (is_envjavac_oldgcj_14_14_usable (javac, &usable))
 
2123
                      {
 
2124
                        err = true;
 
2125
                        goto done1;
 
2126
                      }
 
2127
                  }
 
2128
                else if (strcmp (target_version, "1.4") == 0
 
2129
                         && strcmp (source_version, "1.3") == 0)
 
2130
                  {
 
2131
                    if (is_envjavac_oldgcj_14_13_usable (javac,
 
2132
                                                         &usable,
 
2133
                                                         &no_assert_option))
 
2134
                      {
 
2135
                        err = true;
 
2136
                        goto done1;
 
2137
                      }
 
2138
                  }
 
2139
              }
 
2140
          }
 
2141
        else
 
2142
          {
 
2143
            /* It's not gcj.  Assume the classfile versions are correct.  */
 
2144
            if (is_envjavac_nongcj_usable (javac,
 
2145
                                           source_version, target_version,
 
2146
                                           &usable,
 
2147
                                           &source_option, &target_option))
 
2148
              {
 
2149
                err = true;
 
2150
                goto done1;
 
2151
              }
 
2152
          }
 
2153
 
 
2154
        if (usable)
 
2155
          {
 
2156
            char *old_classpath;
 
2157
            char *javac_with_options;
 
2158
 
 
2159
            /* Set CLASSPATH.  */
 
2160
            old_classpath =
 
2161
              set_classpath (classpaths, classpaths_count, false, verbose);
 
2162
 
 
2163
            javac_with_options =
 
2164
              (no_assert_option
 
2165
               ? xasprintf ("%s -fno-assert", javac)
 
2166
               : xasprintf ("%s%s%s%s%s%s%s%s%s",
 
2167
                            javac,
 
2168
                            source_option ? " -source " : "",
 
2169
                            source_option ? source_version : "",
 
2170
                            target_option ? " -target " : "",
 
2171
                            target_option ? target_version : "",
 
2172
                            fsource_option ? " -fsource=" : "",
 
2173
                            fsource_option ? source_version : "",
 
2174
                            ftarget_option ? " -ftarget=" : "",
 
2175
                            ftarget_option ? target_version : ""));
 
2176
 
 
2177
            err = compile_using_envjavac (javac_with_options,
 
2178
                                          java_sources, java_sources_count,
 
2179
                                          directory, optimize, debug, verbose,
 
2180
                                          false);
 
2181
 
 
2182
            free (javac_with_options);
 
2183
 
 
2184
            /* Reset CLASSPATH.  */
 
2185
            reset_classpath (old_classpath);
 
2186
 
 
2187
            goto done1;
 
2188
          }
2187
2189
      }
2188
2190
  }
2189
2191
 
2204
2206
      bool ftarget_option = false;
2205
2207
 
2206
2208
      if (target_version == NULL)
2207
 
        target_version = default_target_version ();
 
2209
        target_version = default_target_version ();
2208
2210
 
2209
2211
      if (is_gcj_43 ())
2210
 
        {
2211
 
          /* It's a version of gcj >= 4.3.  Assume the classfile versions
2212
 
             are correct.  */
2213
 
          if (is_gcj43_usable (source_version, target_version,
2214
 
                               &usable, &fsource_option, &ftarget_option))
2215
 
            {
2216
 
              err = true;
2217
 
              goto done1;
2218
 
            }
2219
 
        }
 
2212
        {
 
2213
          /* It's a version of gcj >= 4.3.  Assume the classfile versions
 
2214
             are correct.  */
 
2215
          if (is_gcj43_usable (source_version, target_version,
 
2216
                               &usable, &fsource_option, &ftarget_option))
 
2217
            {
 
2218
              err = true;
 
2219
              goto done1;
 
2220
            }
 
2221
        }
2220
2222
      else
2221
 
        {
2222
 
          /* It's a version of gcj < 4.3.  Ignore the version of the class
2223
 
             files that it creates.
2224
 
             Test whether it supports the desired target-version and
2225
 
             source-version.  */
2226
 
          if (strcmp (target_version, "1.4") == 0
2227
 
              && strcmp (source_version, "1.4") == 0)
2228
 
            {
2229
 
              if (is_oldgcj_14_14_usable (&usable))
2230
 
                {
2231
 
                  err = true;
2232
 
                  goto done1;
2233
 
                }
2234
 
            }
2235
 
          else if (strcmp (target_version, "1.4") == 0
2236
 
                   && strcmp (source_version, "1.3") == 0)
2237
 
            {
2238
 
              if (is_oldgcj_14_13_usable (&usable, &no_assert_option))
2239
 
                {
2240
 
                  err = true;
2241
 
                  goto done1;
2242
 
                }
2243
 
            }
2244
 
        }
 
2223
        {
 
2224
          /* It's a version of gcj < 4.3.  Ignore the version of the class
 
2225
             files that it creates.
 
2226
             Test whether it supports the desired target-version and
 
2227
             source-version.  */
 
2228
          if (strcmp (target_version, "1.4") == 0
 
2229
              && strcmp (source_version, "1.4") == 0)
 
2230
            {
 
2231
              if (is_oldgcj_14_14_usable (&usable))
 
2232
                {
 
2233
                  err = true;
 
2234
                  goto done1;
 
2235
                }
 
2236
            }
 
2237
          else if (strcmp (target_version, "1.4") == 0
 
2238
                   && strcmp (source_version, "1.3") == 0)
 
2239
            {
 
2240
              if (is_oldgcj_14_13_usable (&usable, &no_assert_option))
 
2241
                {
 
2242
                  err = true;
 
2243
                  goto done1;
 
2244
                }
 
2245
            }
 
2246
        }
2245
2247
 
2246
2248
      if (usable)
2247
 
        {
2248
 
          char *old_classpath;
2249
 
 
2250
 
          /* Set CLASSPATH.  We could also use the --CLASSPATH=... option
2251
 
             of gcj.  Note that --classpath=... option is different: its
2252
 
             argument should also contain gcj's libgcj.jar, but we don't
2253
 
             know its location.  */
2254
 
          old_classpath =
2255
 
            set_classpath (classpaths, classpaths_count, use_minimal_classpath,
2256
 
                           verbose);
2257
 
 
2258
 
          err = compile_using_gcj (java_sources, java_sources_count,
2259
 
                                   no_assert_option,
2260
 
                                   fsource_option, source_version,
2261
 
                                   ftarget_option, target_version,
2262
 
                                   directory, optimize, debug, verbose, false);
2263
 
 
2264
 
          /* Reset CLASSPATH.  */
2265
 
          reset_classpath (old_classpath);
2266
 
 
2267
 
          goto done2;
2268
 
        }
 
2249
        {
 
2250
          char *old_classpath;
 
2251
 
 
2252
          /* Set CLASSPATH.  We could also use the --CLASSPATH=... option
 
2253
             of gcj.  Note that --classpath=... option is different: its
 
2254
             argument should also contain gcj's libgcj.jar, but we don't
 
2255
             know its location.  */
 
2256
          old_classpath =
 
2257
            set_classpath (classpaths, classpaths_count, use_minimal_classpath,
 
2258
                           verbose);
 
2259
 
 
2260
          err = compile_using_gcj (java_sources, java_sources_count,
 
2261
                                   no_assert_option,
 
2262
                                   fsource_option, source_version,
 
2263
                                   ftarget_option, target_version,
 
2264
                                   directory, optimize, debug, verbose, false);
 
2265
 
 
2266
          /* Reset CLASSPATH.  */
 
2267
          reset_classpath (old_classpath);
 
2268
 
 
2269
          goto done2;
 
2270
        }
2269
2271
    }
2270
2272
 
2271
2273
  if (is_javac_present ())
2275
2277
      bool target_option = false;
2276
2278
 
2277
2279
      if (target_version == NULL)
2278
 
        target_version = default_target_version ();
 
2280
        target_version = default_target_version ();
2279
2281
 
2280
2282
      if (is_javac_usable (source_version, target_version,
2281
 
                           &usable, &source_option, &target_option))
2282
 
        {
2283
 
          err = true;
2284
 
          goto done1;
2285
 
        }
 
2283
                           &usable, &source_option, &target_option))
 
2284
        {
 
2285
          err = true;
 
2286
          goto done1;
 
2287
        }
2286
2288
 
2287
2289
      if (usable)
2288
 
        {
2289
 
          char *old_classpath;
2290
 
 
2291
 
          /* Set CLASSPATH.  We don't use the "-classpath ..." option because
2292
 
             in JDK 1.1.x its argument should also contain the JDK's
2293
 
             classes.zip, but we don't know its location.  (In JDK 1.3.0 it
2294
 
             would work.)  */
2295
 
          old_classpath =
2296
 
            set_classpath (classpaths, classpaths_count, use_minimal_classpath,
2297
 
                           verbose);
2298
 
 
2299
 
          err = compile_using_javac (java_sources, java_sources_count,
2300
 
                                     source_option, source_version,
2301
 
                                     target_option, target_version,
2302
 
                                     directory, optimize, debug, verbose,
2303
 
                                     false);
2304
 
 
2305
 
          /* Reset CLASSPATH.  */
2306
 
          reset_classpath (old_classpath);
2307
 
 
2308
 
          goto done2;
2309
 
        }
 
2290
        {
 
2291
          char *old_classpath;
 
2292
 
 
2293
          /* Set CLASSPATH.  We don't use the "-classpath ..." option because
 
2294
             in JDK 1.1.x its argument should also contain the JDK's
 
2295
             classes.zip, but we don't know its location.  (In JDK 1.3.0 it
 
2296
             would work.)  */
 
2297
          old_classpath =
 
2298
            set_classpath (classpaths, classpaths_count, use_minimal_classpath,
 
2299
                           verbose);
 
2300
 
 
2301
          err = compile_using_javac (java_sources, java_sources_count,
 
2302
                                     source_option, source_version,
 
2303
                                     target_option, target_version,
 
2304
                                     directory, optimize, debug, verbose,
 
2305
                                     false);
 
2306
 
 
2307
          /* Reset CLASSPATH.  */
 
2308
          reset_classpath (old_classpath);
 
2309
 
 
2310
          goto done2;
 
2311
        }
2310
2312
    }
2311
2313
 
2312
2314
  if (is_jikes_present ())
2313
2315
    {
2314
2316
      /* Test whether it supports the desired target-version and
2315
 
         source-version.  */
 
2317
         source-version.  */
2316
2318
      bool usable = (strcmp (source_version, "1.3") == 0);
2317
2319
 
2318
2320
      if (usable)
2319
 
        {
2320
 
          char *old_classpath;
2321
 
 
2322
 
          /* Set CLASSPATH.  We could also use the "-classpath ..." option.
2323
 
             Since jikes doesn't come with its own standard library, it
2324
 
             needs a classes.zip or rt.jar or libgcj.jar in the CLASSPATH.
2325
 
             To increase the chance of success, we reuse the current CLASSPATH
2326
 
             if the user has set it.  */
2327
 
          old_classpath =
2328
 
            set_classpath (classpaths, classpaths_count, false, verbose);
2329
 
 
2330
 
          err = compile_using_jikes (java_sources, java_sources_count,
2331
 
                                     directory, optimize, debug, verbose,
2332
 
                                     false);
2333
 
 
2334
 
          /* Reset CLASSPATH.  */
2335
 
          reset_classpath (old_classpath);
2336
 
 
2337
 
          goto done2;
2338
 
        }
 
2321
        {
 
2322
          char *old_classpath;
 
2323
 
 
2324
          /* Set CLASSPATH.  We could also use the "-classpath ..." option.
 
2325
             Since jikes doesn't come with its own standard library, it
 
2326
             needs a classes.zip or rt.jar or libgcj.jar in the CLASSPATH.
 
2327
             To increase the chance of success, we reuse the current CLASSPATH
 
2328
             if the user has set it.  */
 
2329
          old_classpath =
 
2330
            set_classpath (classpaths, classpaths_count, false, verbose);
 
2331
 
 
2332
          err = compile_using_jikes (java_sources, java_sources_count,
 
2333
                                     directory, optimize, debug, verbose,
 
2334
                                     false);
 
2335
 
 
2336
          /* Reset CLASSPATH.  */
 
2337
          reset_classpath (old_classpath);
 
2338
 
 
2339
          goto done2;
 
2340
        }
2339
2341
    }
2340
2342
 
2341
2343
  error (0, 0, _("Java compiler not found, try installing gcj or set $JAVAC"));